kwebsnap.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by Bojan D.                                        *
 *   bojan_d@users.sourceforge.net                                         *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include <kaboutapplication.h>
#include <kstartupinfo.h>
#include <kmessagebox.h>
#include <kfiledialog.h>
#include <kimagefilepreview.h>
#include <kapplication.h>
#include <krun.h>

#include <kdebug.h>

#include <qfile.h>
#include <qtimer.h>
#include <qpushbutton.h>
#include <qlabel.h>
#include <qpixmap.h>

#include "configuration.h"
#include "configdialog.h"
#include "wsystray.h"
#include "kwebsnap.h"
#include "kwebsnapwidget.h"
#include "wshttpserver.h"

KWebSnap::KWebSnap(QWidget* parent, const char* name)
        : KMainWindow(parent, name),
        m_quit( FALSE ),
        m_secondsLeft(Config().Capture.CaptureDelay / 1000),
        m_scount(0),
        m_logger(this, "logger"),
        m_grabber(this, "grabber"),
        m_ftp(this, "ftp")
{
        KStartupInfo::appStarted();
        
        applyPreferences();     
        
        m_confDialog = 0;
        m_server = 0;
        
        // create the central widget
        m_mainWidget = new KWebSnapWidget( this, "mainWidget" );
        setCentralWidget(m_mainWidget);
        
        // connect the main widget signals so we handle them here
        connect( m_mainWidget, SIGNAL( snapClicked() ), SLOT( slotSnapshot() ) );
    connect( m_mainWidget, SIGNAL( helpClicked() ), SLOT( slotHelp() ) );
    connect( m_mainWidget, SIGNAL( configClicked() ), SLOT( slotConfig() ) );
        connect( m_mainWidget, SIGNAL( aboutClicked() ), SLOT( slotAbout() ) );
        connect( m_mainWidget, SIGNAL( quitClicked() ), SLOT( slotQuit() ) );
        connect( m_mainWidget, SIGNAL( stopClicked() ), SLOT( slotStop() ) );
        connect( m_mainWidget, SIGNAL( startClicked() ), SLOT( slotStart() ) );
        
        // create the system tray
        m_systray = new WSysTray( this, "System Tray" );
        
        // connect the grabber's signals to system tray
        connect( &m_grabber, SIGNAL( startCapture() ), m_systray, SLOT( drawFlash() ) );
        connect( &m_grabber, SIGNAL( finishCapture() ), m_systray, SLOT( resetIcon() ) );
        connect( &m_grabber, SIGNAL( startSave() ), m_systray, SLOT( drawSave() ) );
        connect( &m_grabber, SIGNAL( finishSave() ), m_systray, SLOT( resetIcon() ) );
        
        // connect our signals to system tray
        connect( this, SIGNAL( timeLeft(int) ), m_systray, SLOT( setNumber(int) ) );
        connect( this, SIGNAL( start() ), m_systray, SLOT( disableMenues() ) );
        connect( this, SIGNAL( stop() ), m_systray, SLOT( enableMenues() ) );
        connect( this, SIGNAL( stop() ), m_systray, SLOT( resetIcon() ) );
        
        // connect ftp signals
        connect( &m_ftp, SIGNAL( startTransfer() ), m_systray, SLOT( drawSend() ) );
        connect( &m_ftp, SIGNAL( finishTransfer() ), m_systray, SLOT( resetIcon() ) );
        connect( &m_ftp, SIGNAL( message(const QString&)), m_mainWidget, SLOT(setLabel(const QString&)));
        
        // connect the message signals
        connect( this, SIGNAL(message(const QString&, int)), m_mainWidget, SLOT(setLabel(const QString&)));
        connect( this, SIGNAL(message(const QString&, int)), &m_logger, SLOT(print(const QString&, int)));
        
        // connect grabber's messages
        connect( &m_grabber, SIGNAL(message(const QString&, int)), m_mainWidget, SLOT(setLabel(const QString&)));
        connect( &m_grabber, SIGNAL(message(const QString&, int)), &m_logger, SLOT(print(const QString&, int)));
        
        // connect ftp's messages
        connect( &m_ftp, SIGNAL( message(const QString&, int)), &m_logger, SLOT(print(const QString&, int)));
        connect( &m_ftp, SIGNAL( error(const QString&)), &m_logger, SLOT(printDebug(const QString&)));
                
        // create what we need
        m_timer = new QTimer(this);
        
        // set the stop button to disabled
        m_mainWidget->setStop(false);

        QPixmap snapshot = m_grabber.capture(); 
        updatePreview(snapshot);
                
        // emit the message
        emit message(i18n("Welcome to WebSnap."));
}

KWebSnap::~KWebSnap()
{
        delete m_timer;
        m_timer = 0;
        
        delete m_systray;
        m_systray = 0;
        
        delete m_confDialog;
        m_confDialog = 0;
        
        delete m_server;
        m_confDialog = 0;
}

void KWebSnap::startTimer()
{
        m_timer->start(1000, FALSE);
}


void KWebSnap::slotSnapshot()
{
        QPixmap snapshot = m_grabber.capture(); 
        updatePreview(snapshot);
        m_grabber.saveFiles();
}

void KWebSnap::updatePreview(const QPixmap& pixmap)
{
        /*QImage img = m_snapshot.convertToImage();
    double r1 = ((double) m_snapshot.height() ) / m_snapshot.width();
    if ( r1 * m_mainWidget->previewWidth()  < m_mainWidget->previewHeight() )
                img = img.smoothScale(  m_mainWidget->previewWidth(), 
                                                                int(m_mainWidget->previewWidth() * r1 ));
    else
                img = img.smoothScale(  (int) (((double)m_mainWidget->previewHeight()) / r1),
                                                        (m_mainWidget->previewHeight()) );

    QPixmap pm;
    pm.convertFromImage( img );
    m_mainWidget->setPreview(pm);   */
        m_mainWidget->setPreview(pixmap);   
}

void KWebSnap::slotHelp()
{
        KRun* help = new KRun("http://websnap.sourceforge.net");
        //      nothing more to do
        //      it autoruns, and subsequently deletes itself when done.
}

void KWebSnap::slotConfig()
{
        // create dialog on demand
    if (m_confDialog==0)
        {
        m_confDialog=new ConfigDialog(this);    // create dialog on demand
                // connect to the "settingsChanged" signal
        connect(m_confDialog, SIGNAL(settingsChanged()), this, SLOT(applyPreferences()));
        }
        
        m_confDialog->updateDialog();                           // update the dialog widgets
        
    if (m_confDialog->exec()==QDialog::Accepted)// execute the dialog
        {
                m_confDialog->updateConfiguration();    // store settings in config object
        applyPreferences();
        }
        
        delete m_confDialog;
        m_confDialog = 0;
}

void KWebSnap::slotQuit()
{
        m_quit = true;
        
        if(Config().Ftp.UseFtp && Config().Ftp.UseOffline)
                connect( &m_ftp, SIGNAL(finishTransfer()), this, SLOT(close()));
        else
                connect( this, SIGNAL(stop()), this, SLOT(close()));
        
        slotStop();
}

void KWebSnap::slotAbout()
{
        KAboutApplication* kabout = new KAboutApplication(this);
        kabout->show();
}

void KWebSnap::slotStop()
{
        if(m_timer->isActive())
        {
                m_timer->stop();
        }
        
        if(Config().Ftp.UseFtp)
        {
                m_ftp.stop();
        
                if(Config().Ftp.UseOffline)
                        m_ftp.sendOffline();
        }
        
        if(Config().WWW.UseWWW) 
        {
                if(m_server) disconnect( m_server, SIGNAL( message(const QString&, int)), &m_logger, SLOT(print(const QString&, int))); 
                delete m_server;
                m_server = 0;
        }
        
        // disconnect signals
        disconnect( m_timer, SIGNAL(timeout()), this, SLOT(slotOnTimer()) );
        
        if(Config().Ftp.UseFtp) disconnect( &m_ftp, SIGNAL(finishTransfer()), this, SLOT(startTimer()));
        else disconnect( this, SIGNAL(timeout()), this, SLOT(startTimer()));
        
        // set the stop button disnabled
        m_mainWidget->setStop(false);

        // and start and config buttons to enabled
        m_mainWidget->setStart(true);
        m_mainWidget->setConfig(true);
        
        emit stop();
}

void KWebSnap::slotStart()
{
        QString s;
    if(!Config().validate(s))
    {
        KMessageBox::information( this, s, i18n("Error") );
                return;
        }
        
        connect( m_timer, SIGNAL(timeout()), this, SLOT(slotOnTimer()) );
        
        // setup timer control
        if(Config().Ftp.UseFtp)
        {
                // connect the timer signal, so that we restart the countdown when the thumbnail image was transfered.
                // this means we have to transfer thumbnail image last
                connect( &m_ftp, SIGNAL(finishTransfer()), this, SLOT(startTimer()));
        }
        else
        {
                connect( this, SIGNAL(timeout()), this, SLOT(startTimer()));
        }
        
        if(Config().WWW.UseWWW) 
        {
                m_server = new WSHttpServer(this);
                if(m_server->ok())
                {
                        connect( m_server, SIGNAL( message(const QString&, int)), &m_logger, SLOT(print(const QString&, int)));
                }
                else
                {
                        QString msg = i18n("Could not bind to port %1.").arg(Config().WWW.Port); 
                        KMessageBox::sorry(this, msg, i18n("WWW Server Error"));
                        emit message( msg );
                        Config().WWW.UseWWW = false;
                        delete m_server;
                        m_server = 0;
                }
        }
        
        // set the stop button enabled
        m_mainWidget->setStop(true);

        // and start and config buttons to disabled
        m_mainWidget->setStart(false);
        m_mainWidget->setConfig(false);

        // timer
        m_secondsLeft = Config().Capture.CaptureDelay / 1000;

        // session counter
        m_scount = 0;
        
        emit start();
        
        startTimer();
}

void KWebSnap::slotOnTimer()
{
        m_secondsLeft--;

        if(m_secondsLeft == 0)
        {
                m_timer->stop();
                slotSnapSend();
                m_secondsLeft = Config().Capture.CaptureDelay / 1000;
                emit timeout();
        }
        else if(m_secondsLeft < 16)
        {
                emit timeLeft(m_secondsLeft);
        }
}

void KWebSnap::slotSnapSend()
{
        m_scount++;
        
        slotSnapshot();
        
        if(Config().Ftp.UseFtp)
        {
                QString errorString;
                if(Config().validate(errorString))
                {
                        m_ftp.sendFiles();
                }
                else
                        emit error(errorString);
        }
}
                

bool KWebSnap::queryClose()
{
        if (!m_quit)
    {
                KMessageBox::information( this, i18n("KWebSnap will still stay in the system tray.\nPress quit to exit."), i18n("Minimize KWebSnap"), "dont_show_again");
                hide();
                return FALSE;
        }
        else
        {
                return TRUE;
        }
}

bool KWebSnap::close()
{
    m_quit = TRUE;
    return KMainWindow::close();
}

void KWebSnap::applyPreferences() 
{
        Config().write();
        emit message(i18n("wrote settings."), Configuration::Debug);
}

---