Blokkal

an Extendable KDE Blogging Client

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

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

categoryview.cpp

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

#include "../blokkalaccount.h"
#include "../blokkalblog.h"
#include "../blokkalentry.h"
#include "../blokkalio/categorymanager.h"

#include "blogdelegate.h"

#include <kdebug.h>

#include <QSortFilterProxyModel>

class Blokkal::Ui::CategoryModel::Private {
public:
        Private( const Blog * blog ):
        blog( blog ) {}
        const Blog * const blog;
};

Blokkal::Ui::CategoryModel::CategoryModel( Blokkal::Blog * blog, QObject * parent ):
TreeModel( new TreeModel::TreeItemNode( 0, blog ), parent ),
d( new Private( blog ) )
{
        Blokkal::Account * account = d->blog->account();
        Blokkal::Io::CategoryManager * manager = account->categoryManager();
        Blokkal::Io::CategoryList categories = manager->categories( blog->id() );
        for( Blokkal::Io::CategoryList::ConstIterator it = categories.begin();
             it != categories.end();
             ++it )
        {
                addCategory( d->blog->id(), *it );
        }

        connect( manager,
                 SIGNAL( categoryAdded( const QString &, Blokkal::Io::Category *  ) ),
                 SLOT( addCategory( const QString &, Blokkal::Io::Category * ) ) );
        connect( manager,
                 SIGNAL( categoryRemoved( const QString &, Blokkal::Io::Category *  ) ),
                 SLOT( removeCategory( const QString &, Blokkal::Io::Category * ) ) );
}

Blokkal::Ui::CategoryModel::~CategoryModel( void )
{
}


void Blokkal::Ui::CategoryModel::addCategory( const QString & blogId, Blokkal::Io::Category * category )
{
        if( blogId != d->blog->id() ) {
                return;
        }

        beginInsertRows( QModelIndex(),
                         root()->children.size(),
                         root()->children.size() );
        new TreeItemNode( root(), category );
        endInsertRows();

        connect( category,
                 SIGNAL( updated( Blokkal::Io::Category* ) ),
                 SLOT( emitDataChanged( Blokkal::Io::Category* ) ) );
}

void Blokkal::Ui::CategoryModel::removeCategory( const QString & blogId, Blokkal::Io::Category * category )
{
        if( blogId != d->blog->id() ) {
                return;
        }

        TreeItemNode * categoryNode;
        for( int i = 0; i != root()->children.size(); ++i ) {
                categoryNode = root()->children.at(i);
                if( ((Blokkal::Io::Category*)categoryNode->data.toULongLong() ) == category ) {
                        break;
                }
                categoryNode = 0;
        }

        if( !categoryNode ) {
                return;
        }

        int index = root()->children.indexOf( categoryNode );
        beginRemoveRows( QModelIndex(),
                         index,
                         index );
        delete root()->children.takeAt( index );
        endRemoveRows();        
}


void Blokkal::Ui::CategoryModel::emitDataChanged( Blokkal::Io::Category * category )
{
        TreeItemNode * node;
        for( int i = 0; i != root()->children.size(); ++i ) {
                node = root()->children.at(i);
                if( ((Blokkal::Io::Category*)node->data.toULongLong() ) == category ) {
                        QModelIndex index = createIndex( node->parent->children.indexOf( node ),
                                                         0,
                                                         node );
                        emit dataChanged( index, index );
                        return;
                }
        }
}

QVariant Blokkal::Ui::CategoryModel::data( const QModelIndex & index, int role ) const
{
        if( role != SortRole ) {
                return TreeModel::data( index, role );
        }

        if( !index.isValid() ) {
                return QVariant();
        }

        Io::Category * const category = dynamic_cast<Io::Category*>( (QObject*) index.data().toULongLong() );
        if( !category ) {
                kError() << "invalid data type encountered" << endl;
                return QVariant();
        }

        return category->name();
}

//------------
//CategoryView
//------------
class Blokkal::Ui::CategoryView::Private {
public:
        Private( Blokkal::Entry * entry, bool exclusive ) :
        entry( entry ),
        exclusive( exclusive ){}
        
        Blokkal::Entry * entry;
        bool exclusive;
};

Blokkal::Ui::CategoryView::CategoryView( Blokkal::Entry * entry, bool exclusive, QWidget * parent ) :
BlogView( parent, BlogDelegate::DisplayCheckBoxes ),
d( new Private( entry, exclusive ) )
{
        setSelectionMode( NoSelection );
        QSortFilterProxyModel * sortModel = new QSortFilterProxyModel( this );
        sortModel->setSourceModel( new CategoryModel( entry->blog() ) );
        sortModel->setSortRole( CategoryModel::SortRole );
        setModel( sortModel );
        
        model()->sort( 0 );
        setRootIsDecorated( FALSE );
}

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

void Blokkal::Ui::CategoryView::selectCategories( const QStringList & ids )
{
        for( int i = 0; i < model()->rowCount(); ++i ) {
                QModelIndex index = model()->index( i, 0 );
                Blokkal::Io::Category * category = dynamic_cast<Blokkal::Io::Category*>( (QObject*) index.data().toULongLong() );
                if( !category ) {
                        kDebug() << "model contains data types other than categories" << endl;
                        continue;
                }

                setChecked( index, ids.contains( category->id() ) );
                
                if( d->exclusive && isChecked( index ) ) {
                        return;
                }
        }
}

QStringList Blokkal::Ui::CategoryView::selectedCategories( void ) const
{
        QStringList ids;

        for( int i = 0; i < model()->rowCount(); ++i ) {
                QModelIndex index = model()->index( i, 0 );
                Blokkal::Io::Category * category = dynamic_cast<Blokkal::Io::Category*>( (QObject*) index.data().toULongLong() );
                if( !category ) {
                        kDebug() << "model contains data types other than categories" << endl;
                        continue;
                }

                if( isChecked( index ) ) {
                        ids.append( category->id() );
                }
        }
        
        return ids;
}