Blokkal

an Extendable KDE Blogging Client

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

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

blokkaltreemodel.cpp

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

#include <kdebug.h>

Blokkal::TreeModel::TreeItemNode::TreeItemNode( TreeItemNode * parent, void * data ):
parent( parent ),
data( QVariant::fromValue( (qulonglong) data ) ),
checked( Qt::Unchecked ){
        if( parent ) {
                parent->children.append( this );
        }
}

Blokkal::TreeModel::TreeItemNode::~TreeItemNode( void )
{
        qDeleteAll( children );
}

class Blokkal::TreeModel::Private {
public:
        Private( TreeItemNode * root ) :
        root( root ){}

        ~Private( void ) {
                delete root;
        }

        TreeItemNode * const root;
};

Blokkal::TreeModel::TreeModel( Blokkal::TreeModel::TreeItemNode * root, QObject * parent ):
QAbstractItemModel( parent ),
d(new Private( root ? root : new TreeItemNode( 0, 0 ) ) )
{
}

Blokkal::TreeModel::~TreeModel( void )
{
        delete d;
}

QModelIndex Blokkal::TreeModel::index( int row, int column, const QModelIndex & parent ) const
{
        if ( !hasIndex( row, column, parent ) ) {
                return QModelIndex();
        }

        TreeItemNode * parentNode;

        if ( !parent.isValid() ) {
                parentNode = d->root;
        }
        else {
                parentNode = static_cast<TreeItemNode*>( parent.internalPointer() );
        }


        TreeItemNode * childNode = parentNode->children.at( row );
        if( childNode ) {
                return createIndex( row, column, childNode );
        }
        
        return QModelIndex();   
}

QModelIndex Blokkal::TreeModel::parent( const QModelIndex & index ) const
{
        if ( !index.isValid() ) {
                 return QModelIndex();
        }

        TreeItemNode * childNode = static_cast<TreeItemNode*>( index.internalPointer() );
        TreeItemNode * parentNode = childNode->parent;

        if( parentNode == d->root ) {
                return QModelIndex();
        }

        if( childNode == d->root ) {
                kError() << "parent of root requested" << endl;
                return QModelIndex();
        }

        return createIndex( parentNode->parent->children.indexOf(parentNode), 0, parentNode );
}

int Blokkal::TreeModel::rowCount( const QModelIndex & parent ) const
{
        TreeItemNode * parentNode;
        if( parent.column() > 0 ) {
                return 0;
        }
 
        if ( !parent.isValid() ) {
                parentNode = d->root;
        }
        else {
                parentNode = static_cast<TreeItemNode*>( parent.internalPointer() );
        }

        return parentNode->children.size();     
}

int Blokkal::TreeModel::columnCount( const QModelIndex & parent ) const
{
        Q_UNUSED( parent );
        return 1;
}

QVariant Blokkal::TreeModel::data( const QModelIndex & index, int role ) const
{
        if( !index.isValid() ) {
                return QVariant();
        }

        if( role == Qt::DisplayRole ) {
                return static_cast<TreeItemNode*>(index.internalPointer())->data;
        }
        if( role == Qt::CheckStateRole ) {
                return static_cast<TreeItemNode*>(index.internalPointer())->checked;
        }

        return QVariant();
}

Blokkal::TreeModel::TreeItemNode * Blokkal::TreeModel::root( void ) const
{
        return d->root;
}

Qt::ItemFlags Blokkal::TreeModel::flags( const QModelIndex & index ) const
{
        if (!index.isValid()) {
                return Qt::ItemIsEnabled;
        }
        
        return QAbstractItemModel::flags(index) | Qt::ItemIsUserCheckable;
}

bool Blokkal::TreeModel::setData( const QModelIndex & index, const QVariant & value, int role )
{
        if( role != Qt::CheckStateRole ) {
                return FALSE;
        }

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

        if( !value.isValid() ) {
                return FALSE;
        }

        static_cast<TreeItemNode*>(index.internalPointer())->checked = static_cast<Qt::CheckState>( value.toInt() );
        emit dataChanged( index, index );
        return TRUE;
}