src/job_editor_widget/jobpropertydelegate.cpp

Go to the documentation of this file.

#include "jobpropertydelegate.h"
#include "jobpropertyitem.h"


#include <QKeyEvent>
#include <QApplication>
#include <QPen>
#include <QPainter>
#include <QFont>
#include <QLineEdit>
#include <QAbstractItemView>

JobPropertyDelegate::JobPropertyDelegate(QObject *parent)
    : QItemDelegate(parent),
      m_syncing(false),
      m_lastEdited(0)
{
}

JobPropertyDelegate::~JobPropertyDelegate()
{
}

bool JobPropertyDelegate::eventFilter(QObject *object, QEvent *event)
{
    QWidget *editor = qobject_cast<QWidget*>(object);
    if (editor && qobject_cast<QLineEdit*>(editor->parent()))
        editor = editor->parentWidget();

    switch (event->type()) {
        case QEvent::KeyPress:
        case QEvent::KeyRelease:
        {
            QKeyEvent *ke = static_cast<QKeyEvent*>(event);
            if (!(ke->modifiers() & Qt::ControlModifier)
                && (ke->key() == Qt::Key_Up || ke->key() == Qt::Key_Down)) {
                event->ignore();
                return true;
            }
            if (object->metaObject()->className() == QLatin1String("QtKeySequenceEdit"))
            {
                event->ignore();
                return false;
            }
        } break;

        case QEvent::FocusOut:
            if (!editor->isActiveWindow() || (QApplication::focusWidget() != editor))
            {
                emit commitData(editor);
                emit closeEditor(editor);
            }
            return false;

        default:
            break;
    }

    return QItemDelegate::eventFilter(editor ? editor : object, event);
}

void JobPropertyDelegate::paint(QPainter *painter, const QStyleOptionViewItem &opt, const QModelIndex &index) const
{
    QStyleOptionViewItem option = opt;

    if (index.column() == 1)
    {
        option.state &= ~QStyle::State_Selected;
    }

    option.state &= ~QStyle::State_HasFocus;

    const QPen savedPen = painter->pen();

    QItemDelegate::paint(painter, option, index);

    const QColor color = static_cast<QRgb>(QApplication::style()->styleHint(QStyle::SH_Table_GridLineColor, &option));
    painter->setPen(QPen(color));
    if (index.column() == 1 )
    {
        const int right = (option.direction == Qt::LeftToRight) ? option.rect.right() : option.rect.left();
        painter->drawLine(right, option.rect.y(), right, option.rect.bottom());
    }
    painter->drawLine(option.rect.x(), option.rect.bottom(),
            option.rect.right(), option.rect.bottom());
    painter->setPen(savedPen);
}

QSize JobPropertyDelegate::sizeHint(const QStyleOptionViewItem &opt, const QModelIndex &index) const
{
    return QItemDelegate::sizeHint(opt, index) + QSize(4, 4);
}


void JobPropertyDelegate::slotDestroyed(QObject *object)
{
    if (m_lastEdited == object)
    {
        m_lastEdited = 0;
        emit editorClosed();
    }
}

QWidget *JobPropertyDelegate::createEditor(QWidget *parent,
                                const QStyleOptionViewItem &option,
                                const QModelIndex &index) const
{
    Q_UNUSED(option);

    JobPropertyModel *model = const_cast<JobPropertyModel *>(static_cast<const JobPropertyModel *>(index.model()));
    const JobPropertyItem *property = model->getItem(index);
    if (property == 0)
        return 0;

    QWidget *editor = 0;

    if (!property->isReadOnly() && index.column() != 0)
    {
        editor = property->createEditor(parent, this, SLOT(sync()));
        editor->installEventFilter(const_cast<JobPropertyDelegate *>(this));

        connect(editor, SIGNAL(destroyed(QObject *)), this, SLOT(slotDestroyed(QObject *)));

        JobPropertyDelegate *that = const_cast<JobPropertyDelegate *>(this);
        if (!m_lastEdited)
            emit that->editorOpened();
        m_lastEdited = editor;
    }
    return editor;
}

void JobPropertyDelegate::setEditorData(QWidget *editor,
                             const QModelIndex &index) const
{
    const QAbstractItemModel *model = index.model();
    JobPropertyItem *property = static_cast<const JobPropertyModel*>(model)->getItem(index);
    if (property)
    {
        property->updateEditorContents(editor);
    }
}

void JobPropertyDelegate::setModelData(QWidget *editor,
                            QAbstractItemModel *model,
                            const QModelIndex &index) const
{
    if (JobPropertyItem *property = static_cast<const JobPropertyModel*>(model)->getItem(index))
    {
        property->updateValue(editor);
        model->setData(index, property->data());
    }
}


void JobPropertyDelegate::sync()
{
    m_syncing = true;
    QWidget *w = qobject_cast<QWidget*>(sender());
    if (w == 0)
        return;
    emit commitData(w);
    m_syncing = false;
}

void JobPropertyDelegate::updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
    QItemDelegate::updateEditorGeometry(editor, option, index);
    editor->setGeometry(editor->geometry().adjusted(0, 0, -1, -1));
}

void JobPropertyDelegate::onCustomContextMenuRequested(const QPoint & pos)
{
    QModelIndex idx = dynamic_cast<QAbstractItemView *>(parent())->indexAt(pos);
    JobPropertyModel *model = const_cast<JobPropertyModel *>(static_cast<const JobPropertyModel *>(idx.model()));
    if (model)
    {
        JobPropertyItem *jpi = model->getItem(idx);

        if (jpi && jpi->hasContextMenu())
            jpi->createCustomContextMenu(dynamic_cast<QWidget *>(parent()), pos);
    }
}

---