Blokkal

an Extendable KDE Blogging Client

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

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

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

#include "checkboxview.h"

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

#include <QPainter>
#include <QModelIndex>
#include <QMouseEvent>

class Blokkal::Ui::CheckBoxDelegate::Private {
public:
        Private( void ):
        view( 0 ) {}

        CheckBoxView * view;
};

Blokkal::Ui::CheckBoxDelegate::CheckBoxDelegate( QObject * parent ):
QItemDelegate( parent ),
d( new Private( ) )
{}

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

void Blokkal::Ui::CheckBoxDelegate::setView( CheckBoxView * view )
{
        d->view = view;
}

Blokkal::Ui::CheckBoxView * Blokkal::Ui::CheckBoxDelegate::view( void ) const
{
        return d->view;
}

int Blokkal::Ui::CheckBoxDelegate::checkBoxSize( const QFontMetrics & metrics ) const
{
        return metrics.height()-1;
}

QRect Blokkal::Ui::CheckBoxDelegate::checkBoxRect( const QStyleOptionViewItem & option, const QModelIndex & index ) const
{
        if( !index.isValid() ) {
                return QRect();
        }

        if( !index.data( Qt::CheckStateRole ).isValid() ) {
                return QRect();
        }
        
        const int size = checkBoxSize( option.fontMetrics );

        QRect boxRect;
        if( option.direction == Qt::LeftToRight ) {
                QPoint offset = option.rect.topLeft();
                boxRect = QRect( offset.x(),
                                 offset.y() + ( ( option.fontMetrics.height() - size ) / 2 ),
                                 size,
                                 size );
        }
        else {
                QPoint offset = option.rect.topRight();
                boxRect = QRect( offset.x() - size,
                                 offset.y() + ( ( option.fontMetrics.height() - size ) / 2 ),
                                 size,
                                 size );
        }

        return boxRect;
}

void Blokkal::Ui::CheckBoxDelegate::paint( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) const
{
        painter->save();
        drawBackground( painter, option, index );

        QRect boxRect = checkBoxRect( option, index );
        if( boxRect.isValid() ) {
                drawCheck( painter,
                           option,
                           boxRect,
                           static_cast<Qt::CheckState>( index.data( Qt::CheckStateRole ).toInt() ) );
        }
        
        painter->restore();     
}

QSize Blokkal::Ui::CheckBoxDelegate::sizeHint( const QStyleOptionViewItem & option, const QModelIndex & index ) const
{
        QRect boxRect = checkBoxRect( option, index );
        if( !boxRect.isValid() ) {
                return QSize(0,0);
        }

        return boxRect.size();
}

bool Blokkal::Ui::CheckBoxDelegate::editorEvent( QEvent * event,
                                                 QAbstractItemModel * model,
                                                 const QStyleOptionViewItem & option,
                                                 const QModelIndex & index)
{
        //Code borrowed from Qt to make this method use the virtual
        //checkBoxRect method
        Q_ASSERT(event);
        Q_ASSERT(model);

   // make sure that the item is checkable
        Qt::ItemFlags flags = model->flags( index );
        if ( !(flags & Qt::ItemIsUserCheckable)
             || !(option.state & QStyle::State_Enabled)
             || !(flags & Qt::ItemIsEnabled) )
        {
                return FALSE;
        }
        
        // make sure that we have a check state
        QVariant value = index.data(Qt::CheckStateRole);
        if( !value.isValid() )
        {
                return FALSE;
        }

        // make sure that we have the right event type
        if ((event->type() == QEvent::MouseButtonRelease)
            || (event->type() == QEvent::MouseButtonDblClick))
        {
                QRect checkRect = checkBoxRect( option, index );

                if (!checkRect.contains( static_cast<QMouseEvent*>(event)->pos()) ) {
                        return FALSE;
                }

                // eat the double click events inside the check rect
                if (event->type() == QEvent::MouseButtonDblClick) {
                        return TRUE;
                }
        }
        else {
                return FALSE;
        }

        const Qt::CheckState oldState = static_cast<Qt::CheckState>(value.toInt());
        Qt::CheckState state = oldState == Qt::Checked ? Qt::Unchecked : Qt::Checked;
        bool changed = model->setData( index, state, Qt::CheckStateRole );
        if( changed ) {
                stateChanged( model, index, state );
        }
        return changed;
}

void Blokkal::Ui::CheckBoxDelegate::layoutPlainItem( const QStyleOptionViewItem & option,
        const QModelIndex & index,
        QRect & textRect ) const
{
        const int height = option.fontMetrics.height();
        const int width = option.rect.width();
        const int x = option.rect.x();
        const int y = option.rect.y();

        const QRect checkBoxRect = this->checkBoxRect( option, index );
        textRect.setRect( x, y, width, height );
        if( option.direction == Qt::LeftToRight ) {
                if( checkBoxRect.isValid() ) {
                        textRect.setLeft( checkBoxRect.right() );
                }
        }
        else {
                if( checkBoxRect.isValid() ) {
                        textRect.setRight( checkBoxRect.left() );
                }
        }
}

void Blokkal::Ui::CheckBoxDelegate::stateChanged( QAbstractItemModel * model,
                                                  const QModelIndex & index,
                                                  Qt::CheckState newState )
{
        Q_UNUSED( model );
        Q_UNUSED( index );
        Q_UNUSED( newState );
}