Blokkal

an Extendable KDE Blogging Client

• Download
• Screenshots
• LiveJournal Community
• API Documentation
• Contact

• Class Hierarchy
• Class List
• File List
• Class Members

jobs.cpp

/***************************************************************************
 *   Copyright (C) 2008 by Martin Mueller                                  *
 *   orvio@orvio.de                                                        *
 *                                                                         *
 *   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 "jobs.h"
#include "jobs.moc"

#include "../blokkalentry.h"
#include "../blokkalblog.h"

//---
//Job
//---
Blokkal::Io::Job::Job( QObject * parent ):
KCompositeJob( parent )
{
}

Blokkal::Io::Job::~Job( void )
{
}

void Blokkal::Io::Job::start( void )
{
        const QList<KJob *> jobList = subjobs();

        if( jobList.isEmpty() ) {
                emitResult();
                return;
        }
        
        for( QList<KJob *>::ConstIterator it = jobList.begin();
             it !=jobList.end();
             ++it )
        {
                (*it)->start();
        }
}

void Blokkal::Io::Job::slotResult( KJob * job )
{
        KCompositeJob::slotResult( job );

        subjobFinished( job );
        
        if( !error() && subjobs().isEmpty() ) {
                jobFinished();
                emitResult();
        }
        else if( error() ) { //an error may be set in subjbFinished()
                emitResult();
        }
}

void Blokkal::Io::Job::jobFinished( void )
{}

void Blokkal::Io::Job::subjobFinished( KJob * job )
{
        Q_UNUSED( job );
}

bool Blokkal::Io::Job::doKill( void )
{
        bool allKilled = TRUE;
        const QList<KJob *> jobList = subjobs();
        for( QList<KJob *>::ConstIterator it = jobList.begin();
             it !=jobList.end();
             ++it )
        {
                allKilled &= (*it)->kill();
        }

        return allKilled;
}

void Blokkal::Io::Job::slotEmitPercent( void )
{
        unsigned long percent = 0;
        const QList<KJob *> jobList = subjobs();
        for( QList<KJob *>::ConstIterator it = jobList.begin();
             it !=jobList.end();
             ++it )
        {
                percent += (*it)->percent() / jobList.size();
        }
        
        setPercent( percent );
}

bool Blokkal::Io::Job::addSubjob( KJob * job )
{
        bool added = KCompositeJob::addSubjob( job );
        if( added ) {
                connect( job,
                         SIGNAL( percent( KJob*, unsigned long ) ),
                         SLOT( slotEmitPercent( void ) ) );
        }
        return added;
}

//--------
//EntryJob
//--------
class Blokkal::Io::EntryJob::Private {
public:
        Private( Blokkal::Entry * entry ):
        entry( entry ) {}

        Blokkal::Entry * const entry;
};

Blokkal::Io::EntryJob::EntryJob( Blokkal::Entry * entry ):
Job( entry ),
d( new Private( entry  ) )
{
}

Blokkal::Io::EntryJob::~EntryJob( void )
{
        delete d;
}

Blokkal::Entry * Blokkal::Io::EntryJob::entry( void ) const
{
        return d->entry;
}

//--------
//BlogJob
//--------
class Blokkal::Io::BlogJob::Private {
public:
        Private( Blokkal::Blog * blog ):
        blog( blog ) {}

        Blokkal::Blog * const blog;
};

Blokkal::Io::BlogJob::BlogJob( Blokkal::Blog * blog ):
Job( blog ),
d( new Private( blog  ) )
{
}

Blokkal::Io::BlogJob::~BlogJob( void )
{
        delete d;
}

Blokkal::Blog * Blokkal::Io::BlogJob::blog( void ) const
{
        return d->blog;
}

//------------
//LoadEntryJob
//------------

Blokkal::Io::LoadEntryJob::LoadEntryJob( Blokkal::Blog * blog ):
BlogJob( blog )
{
}

Blokkal::Io::LoadEntryJob::~LoadEntryJob( void )
{
}

//------------
//LoadIndexJob
//------------
Blokkal::Io::LoadIndexJob::LoadIndexJob( Blokkal::Blog * blog ):
BlogJob( blog )
{
}

Blokkal::Io::LoadIndexJob::~LoadIndexJob( void )
{
}