Blokkal

an Extendable KDE Blogging Client

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

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

blogbrowsingdriver.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 "blogbrowsingdriver.h"
#include "blogbrowsingdriver.moc"

#include "../blokkalblog.h"
#include "../blokkalaccount.h"
#include "../blokkalpluginmanager.h"

#include "../blokkalui/browseentryviewfactory.h"

class Blokkal::Io::BlogBrowsingDriver::Private {
public:
        Private( Blokkal::Blog * blog ):
        blog( blog ) {}

        Blokkal::Blog * const blog;
        QList<Ui::BrowseEntryDialog*> dialogList;
};

Blokkal::Io::BlogBrowsingDriver::BlogBrowsingDriver( Blokkal::Blog * parent ):
QObject( parent ),
d( new Private( parent ) )
{
        connect( blog()->account(),
                 SIGNAL( connectionStatusChanged( Blokkal::Account* ) ),
                 SLOT( slotAccountStatusChanged( Blokkal::Account* ) ) );
}

Blokkal::Io::BlogBrowsingDriver::~BlogBrowsingDriver( void )
{
        for( int i = 0; i < d->dialogList.size(); ++i ) {
                d->dialogList[i]->close();
                delete d->dialogList.takeAt(i);
        }       
        delete d;
}

unsigned int Blokkal::Io::BlogBrowsingDriver::recentLimit( void ) const
{
        return 0;
}

unsigned int Blokkal::Io::BlogBrowsingDriver::supportedOperations( void ) const
{
        return 0;
}

Blokkal::Io::LoadEntryJob * Blokkal::Io::BlogBrowsingDriver::createLoadEntryJob( const QStringList & idList )
{
        Q_UNUSED( idList );
        return 0;
}

Blokkal::Io::LoadEntryJob * Blokkal::Io::BlogBrowsingDriver::createLoadEntryJob( const QDate & date )
{
        Q_UNUSED( date );
        return 0;
}

Blokkal::Io::LoadEntryJob * Blokkal::Io::BlogBrowsingDriver::createLoadEntryJob( unsigned int n )
{
        Q_UNUSED( n );
        return 0;
}

Blokkal::Io::LoadIndexJob * Blokkal::Io::BlogBrowsingDriver::createLoadIndexJob( const QDate & from, const QDate & to )
{
        Q_UNUSED( from );
        Q_UNUSED( to );
        return 0;
}

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

unsigned int Blokkal::Io::BlogBrowsingDriver::supportedBrowseModes( void ) const
{
        return BrowseEdit|BrowseLink;
}

Blokkal::Ui::BrowseEntryDialog * Blokkal::Io::BlogBrowsingDriver::browseBlogDialog( BrowseMode mode )
{
        if(  mode == BrowseEdit ) {
                for( int i = 0; i < d->dialogList.size(); ++i ) {
                        if( d->dialogList[i]->mode() == mode ) {
                                return d->dialogList[i];
                        }
                }
        }
        
        for( int i = 0; i < d->dialogList.size(); ++i ) {
                if( !d->dialogList[i]->isVisible() ) {
                        d->dialogList[i]->setMode( mode );
                        return d->dialogList[i];
                }
        }
        
        Ui::BrowseEntryDialog * const browseView = Blokkal::PluginManager::self()->browseEntryViewFactory()->createView( blog() );
        browseView->setMode( mode );
        d->dialogList.append( browseView );
        connect( browseView,
                 SIGNAL( destroyed( QObject * ) ),
                 SLOT( slotBrowseViewDestroyed( QObject * ) ) );
        connect( browseView,
                 SIGNAL( finished( void ) ),
                 SLOT( slotBrowseViewFinished( void ) ) );
        return browseView;
}

void Blokkal::Io::BlogBrowsingDriver::slotBrowseViewDestroyed( QObject * object )
{
        for( int i = 0; i < d->dialogList.size(); ++i ) {
                if( d->dialogList[i] == object ) {
                        d->dialogList.takeAt( i );
                        i--;
                }
        }
}

void Blokkal::Io::BlogBrowsingDriver::slotAccountStatusChanged( Blokkal::Account * account )
{
        if( account->isConnected() ) {
                return;
        }
        
        for( int i = 0; i < d->dialogList.size(); ++i ) {
                d->dialogList[i]->close();
        }
}

void Blokkal::Io::BlogBrowsingDriver::slotBrowseViewFinished( void )
{
        for( int i = 0; i < d->dialogList.size() && d->dialogList.size() > 1; ++i ) {
                if( !d->dialogList[i]->isVisible() ) {
                        d->dialogList.takeAt( i )->deleteLater();
                        i--;
                }
        }
}

QList< Blokkal::Ui::BrowseOptionWidget * > Blokkal::Io::BlogBrowsingDriver::customBrowseOptionWidgets( QWidget * parent )
{
        Q_UNUSED( parent );
        return QList< Blokkal::Ui::BrowseOptionWidget * >();
}