Blokkal

an Extendable KDE Blogging Client

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

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

blogchooser.cpp

/***************************************************************************
 *   Copyright (C) 2006 - 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 "blogchooser.h"
#include "blogchooser.moc"

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

#include <kdebug.h>
#include <k3listbox.h>
#include <klocale.h>

#include <QLayout>
#include <QLabel>
#include <QPushButton>
#include <QList>

class Blokkal::Ui::BlogChooser::Private
{
public:
        Private( void ) :
        accountListBox( 0 ),
        blogListBox( 0 ),
        account( 0 ),
        blog( 0 ) {}

        K3ListBox * accountListBox;
        K3ListBox * blogListBox;

        Account * account;
        Blog * blog;

        QMap< Account*, Q3ListBoxItem *> accountItemMap;
        QMap< Blog*, Q3ListBoxItem *> blogItemMap;
};

Blokkal::Ui::BlogChooser::BlogChooser( QWidget * parent ) :
QWidget( parent ),
d( new Private() )
{
        QHBoxLayout * layout = new QHBoxLayout( this );
        layout->setSpacing( KDialog::spacingHint() );
        d->accountListBox = new K3ListBox( this );
        layout->addWidget( d->accountListBox );
        d->blogListBox = new K3ListBox( this );
        layout->addWidget( d->blogListBox );
        d->blogListBox->setEnabled( FALSE );
        
        AccountList accounts = AccountManager::self()->accounts();
        for( AccountList::ConstIterator it = accounts.begin();
             it != accounts.end();
             ++it )
        {
                d->accountListBox->insertItem( (*it)->icon().pixmap(16,16), (*it)->id(), 0 );
                d->accountItemMap.insert( *it, d->accountListBox->firstItem() );
        }

        d->accountListBox->sort();

        connect( d->accountListBox, SIGNAL( selectionChanged( void ) ),
                 this, SLOT( slotAccountSelectionChanged( void ) ) );
        connect( d->blogListBox, SIGNAL( selectionChanged( void ) ),
                 this, SLOT( slotBlogSelectionChanged( void ) ) );
}

Blokkal::Ui::BlogChooser::~BlogChooser( void )
{
        delete d;
}

Blokkal::Account * Blokkal::Ui::BlogChooser::account( void ) const
{
        return d->account;
}

void Blokkal::Ui::BlogChooser::setAccount( Blokkal::Account * account )
{
        if( d->account == account ) {
                return;
        }

        d->account = account;

        setBlog( 0 );
        d->blogItemMap.clear();
        d->blogListBox->clear();
        
        if( d->accountItemMap.contains( account ) ) {
                QList<Blokkal::Blog * > blogs = account->blogs();
                for( QList< Blokkal::Blog * >::ConstIterator it = blogs.begin();
                     it != blogs.end();
                     ++it )
                {
                        d->blogListBox->insertItem( (*it)->icon().pixmap(16,16), (*it)->id(), 0 );
                        d->blogItemMap.insert( *it, d->blogListBox->firstItem() );
                }

                d->blogListBox->sort();

                d->accountListBox->setSelected( d->accountItemMap[account], TRUE );
                d->blogListBox->setEnabled( TRUE );
        }
        else {
                d->accountListBox->clearSelection();
                d->blogListBox->setEnabled( FALSE );
        }
}

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

void Blokkal::Ui::BlogChooser::setBlog( Blokkal::Blog * blog )
{
        if( d->blog == blog ) {
                return;
        }

        d->blog = blog;
        
        if( d->blogItemMap.contains( blog ) ) {
                d->blogListBox->setSelected( d->blogItemMap[blog], TRUE );
                emit blogSelected( blog );
        }
        else {
                d->blogListBox->clearSelection();
                emit blogSelected( 0 );
        }
}

void Blokkal::Ui::BlogChooser::slotAccountSelectionChanged( void )
{
        //kdDebug() << k_funcinfo << endl;
        Q3ListBoxItem * item = d->accountListBox->selectedItem();
        if( !item ) {
                setAccount( 0 );
                return;
        }
        
        QList<Account*> accounts = d->accountItemMap.keys();
        for( QList<Account*>::ConstIterator it = accounts.begin();
             it != accounts.end();
             ++it )
        {
                if( d->accountItemMap[*it] == item ) {
                        setAccount( *it );
                        return;
                }
        }

        setAccount( 0 );
}

void Blokkal::Ui::BlogChooser::slotBlogSelectionChanged( void )
{
        //kdDebug() << k_funcinfo << endl;
        Q3ListBoxItem * item = d->blogListBox->selectedItem();
        if( !item ) {
                setBlog( 0 );
                return;
        }
        
        QList<Blog*> blogs = d->blogItemMap.keys();
        for( QList<Blog*>::ConstIterator it = blogs.begin();
             it != blogs.end();
             ++it )
        {
                if( d->blogItemMap[*it] == item ) {
                        setBlog( *it );
                        return;
                }
        }

        setBlog( 0 );
}

class Blokkal::Ui::BlogChooserDialog::Private
{
public:
        Private( void ) {}

        BlogChooser * blogChooser;
};

Blokkal::Ui::BlogChooserDialog::BlogChooserDialog( const QString & message, QWidget * parent ):
KDialog( parent ),
d( new Private() )
{
        setModal( TRUE );
        setButtons( Ok|Cancel );
        setDefaultButton( Ok );
        setCaption( i18n( "Select a Blog" ) );
        QWidget * mainWidget = new QWidget( this );
        QVBoxLayout * layout = new QVBoxLayout( mainWidget );
        layout->setSpacing( KDialog::spacingHint() );
        QLabel * messageLabel = new QLabel( message, mainWidget );
        messageLabel->setWordWrap( TRUE );
        layout->addWidget( messageLabel );
        d->blogChooser = new BlogChooser( mainWidget );
        layout->addWidget( d->blogChooser );

        setMainWidget( mainWidget );
        enableButton( Ok, FALSE );

        connect( d->blogChooser, SIGNAL( blogSelected( Blokkal::Blog * ) ),
                 this, SLOT( slotBlogSelected( Blokkal::Blog * ) ) );
}

Blokkal::Ui::BlogChooserDialog::~BlogChooserDialog( void )
{
        delete d;
}

Blokkal::Ui::BlogChooser * Blokkal::Ui::BlogChooserDialog::blogChooser( void ) const
{
        return d->blogChooser;
}

void Blokkal::Ui::BlogChooserDialog::slotBlogSelected( Blokkal::Blog * blog )
{
        enableButton( Ok, blog );
}