Blokkal

an Extendable KDE Blogging Client

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

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

checkboxview.cpp

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

#include "blogdelegate.h"

#include <kdebug.h>

#include <QHeaderView>
#include <QContextMenuEvent>
#include <QSignalMapper>
#include <QTimer>
#include <QMap>


class Blokkal::Ui::CheckBoxView::Private {
public:
        Private( CheckBoxDelegate * delegate ):
        delegate( delegate ),
        mapper( new QSignalMapper( delegate ) ),
        id( 0 ) {}

        CheckBoxDelegate * const delegate;
        QSignalMapper * const mapper;
        int id;
        QMap<int, QTimer *> idTimerMap;
        QMap<int, QPersistentModelIndex> idIndexMap;
        QMap<QPersistentModelIndex, int> indexIdMap;
        QList<QPersistentModelIndex> blinkingIndexes;
};

Blokkal::Ui::CheckBoxView::CheckBoxView( CheckBoxDelegate * delegate, QWidget * parent ):
QTreeView( parent ),
d( new Private( delegate ) )
{
        d->delegate->setView( this );
        d->delegate->setParent( this );
        setItemDelegate( d->delegate );
        header()->hide();

        connect( d->mapper, SIGNAL( mapped( int ) ), SLOT( updateIndexId( int ) ) );    
}

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


bool Blokkal::Ui::CheckBoxView::isChecked( const QModelIndex & index ) const
{
        if( !index.isValid() ) {
                return FALSE;
        }

        QVariant checkData = index.data( Qt::CheckStateRole );
        if( !checkData.isValid() ) {
                return FALSE;
        }
        return static_cast<Qt::CheckState>(checkData.toInt()) == Qt::Checked;
}

void Blokkal::Ui::CheckBoxView::setChecked( const QModelIndex & index, bool check )
{
        if( !index.isValid() ) {
                return;
        }
        model()->setData( index, check ? Qt::Checked : Qt::Unchecked, Qt::CheckStateRole);
}

void Blokkal::Ui::CheckBoxView::rowsAboutToBeRemoved( const QModelIndex & parent, int start, int end )
{
        for( int i = start; i <= end; ++i ) {
                QModelIndex index = model()->index( i, 0, parent );
                if( index.isValid() ) {
                        if( d->blinkingIndexes.contains( index ) ) {
                                d->blinkingIndexes.removeAll( index );
                        }
                }
        }


        QAbstractItemView::rowsAboutToBeRemoved( parent, start, end );
}

bool Blokkal::Ui::CheckBoxView::toogleBlinkState( const QModelIndex & index )
{
        if( d->blinkingIndexes.contains( index ) ) {
                d->blinkingIndexes.removeAll( index );
                return FALSE;
        }
        else {
                d->blinkingIndexes.append( index );
                return TRUE;
        }
}

void Blokkal::Ui::CheckBoxView::connectIndex( const QModelIndex & index, int msecs )
{
        if( !index.isValid() ) {
                return;
        }

        if( d->indexIdMap.contains( index ) ) {
                return;
        }

        QTimer * timer = new QTimer( this );
        d->id++;
        d->idTimerMap.insert( d->id, timer );
        d->idIndexMap.insert( d->id, index );
        d->indexIdMap.insert( index, d->id );
        d->mapper->setMapping( timer, d->id );
        connect( timer, SIGNAL( timeout( void ) ),
                 d->mapper, SLOT( map( void ) ) );
        timer->start( msecs );
}

void Blokkal::Ui::CheckBoxView::disconnectIndex( const QModelIndex & index )
{
        if( !d->indexIdMap.contains( index ) ) {
                return;
        }

        int id = d->indexIdMap[index];
        d->indexIdMap.remove( index );
        d->idIndexMap.remove( id );
        d->idTimerMap[id]->deleteLater();
        d->idTimerMap.remove( id );
}

void Blokkal::Ui::CheckBoxView::updateIndexId( int id )
{
        QPersistentModelIndex index = d->idIndexMap[id];
        if( !index.isValid() ) {
                disconnectIndex( index );
                return;
        }
        
        update( index );
        d->idTimerMap[id]->start();
}

Blokkal::Ui::BlogView::BlogView( QWidget * parent, unsigned int displayOptions ):
CheckBoxView( new BlogDelegate( displayOptions ), parent )
{
}

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