CustomEditor Example

#include <QtGui>
#include <QMessageBox>
#include <DevMachines/QtitanBase>

#include "window.h"

/* Window */
Window::Window()
: DemoMainWindow(QStringLiteral("QtitanDataGrid"), QStringLiteral(QTN_VERSION_DATAGRID_STR), tr("Custom Cell Editor"))
{
    Grid::loadTranslation();

    m_grid = new Qtitan::Grid();
    QStandardItemModel* model = new QStandardItemModel(100, 4, m_grid);
    model->setHeaderData(0, Qt::Horizontal, QStringLiteral("Custom Value"));
    model->setHeaderData(1, Qt::Horizontal, QStringLiteral("Integer Value"));
    model->setHeaderData(2, Qt::Horizontal, QStringLiteral("String Value"));
    model->setHeaderData(3, Qt::Horizontal, QStringLiteral("Color Value"));

    for (int row = 0; row < model->rowCount(); ++row)
    {
        model->setData(model->index(row, 0), row);
        model->setData(model->index(row, 1), row);
        model->setData(model->index(row, 2), tr("Value: %1").arg(row));
        QColor color(qtn_rand(0, 255), qtn_rand(0, 255), qtn_rand(0, 255));
        model->setData(model->index(row, 3), color);
    }

    // Configure grid view
    m_grid->setViewType(Qtitan::Grid::TableView);
    Qtitan::GridTableView* view = m_grid->view<Qtitan::GridTableView>();
    view->beginUpdate();

    view->options().setGridLineWidth(1);

    //Connect Grid's context menu handler.
    connect(view, SIGNAL(contextMenu(ContextMenuEventArgs*)), this, SLOT(contextMenu(ContextMenuEventArgs* )));
    connect(view, SIGNAL(editorModifying(GridEditor *)), this, SLOT(editorModifying(GridEditor *)));
    connect(view, SIGNAL(editorValidating(EditorValidationEventArgs*)), this, SLOT(editorValidating(EditorValidationEventArgs*)));

    view->setModel(model);

    //Configure the grid columns.
    Qtitan::GridTableColumn* column = (Qtitan::GridTableColumn*)view->getColumn(0);
    column->setEditorRepository(new CustomEditorRepository());
    column->editorRepository()->setEditorActivationPolicy(GridEditor::ActivationPolicy(GridEditor::ActivateByDblClick));

    column = (Qtitan::GridTableColumn*)view->getColumn(1);
    column->setEditorType(GridEditor::Numeric);
    column = (Qtitan::GridTableColumn*)view->getColumn(2);
    column->setEditorType(GridEditor::String);

    view->endUpdate();
    setDemoWidget(m_grid, createSettingsWidget());
}

QWidget* Window::createSettingsWidget()
{
    //Create settings widget
    QWidget* settings = new QWidget(this);
    QVBoxLayout* l = new QVBoxLayout(settings);

    l->addLayout(createStyleSetting());

   QCheckBox* autoWidthCheck = new QCheckBox(settings);
    autoWidthCheck->setText(tr("Column auto width"));
    connect(autoWidthCheck, SIGNAL(stateChanged(int)), this, SLOT(autoWidthStateChanged(int)));
    autoWidthCheck->setChecked(true);
    l->addWidget(autoWidthCheck);

    QCheckBox* fastScrollCheck = new QCheckBox(settings);
    fastScrollCheck->setText(tr("Fast scroll effect"));
    connect(fastScrollCheck, SIGNAL(stateChanged(int)), this, SLOT(fastScrollChanged(int)));
    l->addWidget(fastScrollCheck);
    fastScrollCheck->setChecked(true);

    QCheckBox* dottedLineCheck = new QCheckBox(settings);
    dottedLineCheck->setText(tr("Dotted grid line"));
    connect(dottedLineCheck, SIGNAL(stateChanged(int)), this, SLOT(dottedLineChanged(int)));
    l->addWidget(dottedLineCheck);
    dottedLineCheck->setChecked(true);

    QLabel* label = new QLabel(this);
    QHBoxLayout* hl = new QHBoxLayout(0);
    label->setText(tr("Grid line style:"));
    QComboBox* lineStylesSelect = new QComboBox(settings);

    lineStylesSelect->addItem(tr("None"));
    lineStylesSelect->addItem(tr("Both"));
    lineStylesSelect->addItem(tr("Both2D"));
    lineStylesSelect->addItem(tr("Horizontal"));
    lineStylesSelect->addItem(tr("Horizontal2D"));
    lineStylesSelect->addItem(tr("Vertical"));
    lineStylesSelect->addItem(tr("Vertical2D"));
    connect(lineStylesSelect, SIGNAL(currentIndexChanged(int)), this, SLOT(selectGridLineStyles(int)));
    hl->addWidget(label);
    hl->addWidget(lineStylesSelect);
    l->addLayout(hl);
    lineStylesSelect->setCurrentIndex(2);

    QCheckBox* zoomEnable = new QCheckBox(settings);
    zoomEnable->setText(tr("Zoom enabled"));
    zoomEnable->setChecked(true);
    connect(zoomEnable, SIGNAL(stateChanged(int)), this, SLOT(zoomEnabledChanged(int)));
    l->addWidget(zoomEnable);

    QCheckBox* zoomIndicator = new QCheckBox(settings);
    zoomIndicator->setText(tr("Show zoom indicator"));
    zoomIndicator->setChecked(true);
    connect(zoomIndicator, SIGNAL(stateChanged(int)), this, SLOT(zoomIndicatorChanged(int)));
    l->addWidget(zoomIndicator);

    QSlider* zoomSlider = new QSlider(settings);
    zoomSlider->setOrientation(Qt::Horizontal);
    zoomSlider->setTickPosition(QSlider::TicksBothSides);
    zoomSlider->setMinimum(25);
    zoomSlider->setMaximum(300);
    zoomSlider->setTickInterval(25);
    zoomSlider->setSingleStep(25);
    zoomSlider->setValue(100);
    connect(zoomSlider, SIGNAL(sliderMoved(int)), this, SLOT(zoomValueChanged(int)));
    connect(m_grid->view<Qtitan::GridTableView>(), SIGNAL(zoomChanged(int)), zoomSlider, SLOT(setValue(int)));
    l->addWidget(zoomSlider);

    QCheckBox* cellAutoRaise = new QCheckBox(settings);
    cellAutoRaise->setText(tr("Auto raise cell button"));
    connect(cellAutoRaise, SIGNAL(stateChanged(int)), this, SLOT(cellButtonAutoRaiseEnabled(int)));
    cellAutoRaise->setChecked(true);
    l->addWidget(cellAutoRaise);

    QCheckBox* frozenRowsBox = new QCheckBox(settings);
    frozenRowsBox->setText(tr("Frozen Rows"));
    connect(frozenRowsBox, SIGNAL(stateChanged(int)), this, SLOT(frozenRowsEnabled(int)));
    frozenRowsBox->setChecked(true);
    l->addWidget(frozenRowsBox);

    QCheckBox* transparentBox = new QCheckBox(settings);
    transparentBox->setText(tr("Transparent Background"));
    connect(transparentBox, SIGNAL(stateChanged(int)), this, SLOT(transparentBackgroundEnabled(int)));
    transparentBox->setChecked(false);
    l->addWidget(transparentBox);

    QCheckBox* rowSizingBox = new QCheckBox(settings);
    rowSizingBox->setText(tr("Resizing row (new)"));
    connect(rowSizingBox, SIGNAL(stateChanged(int)), this, SLOT(rowSizingEnabled(int)));
    rowSizingBox->setChecked(true);
    l->addWidget(rowSizingBox);

    QPushButton* printButton = new QPushButton(settings);
    printButton->setText(tr("Print Preview"));
    connect(printButton, SIGNAL(clicked()), this, SLOT(printPreview()));
    l->addWidget(printButton);

    return settings;
}

void Window::autoWidthStateChanged(int state)
{
    Qtitan::GridTableView* view = m_grid->view<Qtitan::GridTableView>();
    view->tableOptions().setColumnAutoWidth(state == Qt::Checked);
}

void Window::fastScrollChanged(int state)
{
    Qtitan::GridTableView* view = m_grid->view<Qtitan::GridTableView>();
    view->options().setFastScrollEffect(state == Qt::Checked);
}

void Window::dottedLineChanged(int state)
{
    Qtitan::GridTableView* view = m_grid->view<Qtitan::GridTableView>();
    QPen pen = view->options().gridLinePen();
    pen.setStyle(state == Qt::Checked ? Qt::DotLine : Qt::SolidLine);
    view->options().setGridLinePen(pen);
}

void Window::selectGridLineStyles(int index)
{
    Qtitan::GridTableView* view = m_grid->view<Qtitan::GridTableView>();
    switch (index)
    {
    case 0:
        view->options().setGridLines(Qtitan::LinesNone);
        break;
    case 1:
        view->options().setGridLines(Qtitan::LinesBoth);
        break;
    case 2:
        view->options().setGridLines(Qtitan::LinesBoth2D);
        break;
    case 3:
        view->options().setGridLines(Qtitan::LinesHorizontal);
        break;
    case 4:
        view->options().setGridLines(Qtitan::LinesHorizontal2D);
        break;
    case 5:
        view->options().setGridLines(Qtitan::LinesVertical);
        break;
    case 6:
        view->options().setGridLines(Qtitan::LinesVertical2D);
        break;
    default:
        view->options().setGridLines(Qtitan::LinesBoth);
    }
 }

void Window::zoomEnabledChanged(int state)
{
    Qtitan::GridTableView* view = m_grid->view<Qtitan::GridTableView>();
    view->options().setZoomEnabled(state == Qt::Checked);
}

void Window::zoomIndicatorChanged(int state)
{
    Qtitan::GridTableView* view = m_grid->view<Qtitan::GridTableView>();
    view->options().setZoomIndicatorActive(state == Qt::Checked);
}

void Window::zoomValueChanged(int value)
{
    double factor = qCeil((double)value / 25) * 25;
    Qtitan::GridTableView* view = m_grid->view<Qtitan::GridTableView>();
    view->options().setZoomFactor(factor / 100);
}

void Window::cellButtonAutoRaiseEnabled(int state)
{
    Qtitan::GridTableView* view = m_grid->view<Qtitan::GridTableView>();
    view->options().setCellButtonAutoRaise(state == Qt::Checked);
}

void Window::frozenRowsEnabled(int state)
{
    Qtitan::GridTableView* view = m_grid->view<Qtitan::GridTableView>();
    view->tableOptions().setRowFrozenButtonVisible(state == Qt::Checked);
    view->tableOptions().setFrozenPlaceQuickSelection(state == Qt::Checked);
}

void Window::transparentBackgroundEnabled(int state)
{
    Qtitan::GridTableView* view = m_grid->view<Qtitan::GridTableView>();
    view->options().setTransparentBackground(state == Qt::Checked);
    view->options().setAlternatingRowColors(!view->options().alternatingRowColors());
}

void Window::rowSizingEnabled(int state)
{
    Qtitan::GridTableView* view = m_grid->view<Qtitan::GridTableView>();
    view->tableOptions().setRowSizingEnabled(state == Qt::Checked);
}

void Window::editorModifying(GridEditor* editor)
{
    Q_UNUSED(editor);
}

void Window::editorValidating(EditorValidationEventArgs* args)
{
    args->setValueValid(true);
    //args->setEditingValue(args->editValue());
    args->setHandled(true);
}

void Window::contextMenu(ContextMenuEventArgs* args)
{
    args->contextMenu()->addAction(tr("Print Preview"), this, SLOT(printPreview()));
    args->contextMenu()->addSeparator();
    args->contextMenu()->addAction(tr("Developer Machines on the Web"), this, SLOT(showCompanyWebSite()));
}

void Window::cellButtonClicked(CellButtonClickEventArgs* args)
{
    QMessageBox::information(this, tr("Cell button clicked"),
        tr("Clicked: Button - %1, Column Title - %2, RowIndex - %3").arg(args->buttonIndex()).arg(args->column()->caption()).arg(args->row().rowIndex()));
}

void Window::printPreview()
{
    m_grid->view<Qtitan::GridTableView>()->printPreview();
}

void Window::setShadeColor(const QColor& color)
{
    m_grid->themeManager()->setShadeColor(color);
}

/* CustomEditWidget */
CustomEditWidget::CustomEditWidget(QWidget* parent)
    : QLineEdit(parent)
{
}

void CustomEditWidget::mouseDoubleClickEvent(QMouseEvent* e)
{
    QLineEdit::mouseDoubleClickEvent(e);
    qWarning() << QLatin1String("mouseDoubleClickEvent");
}

/* CustomEditorRepository */
CustomEditorRepository::CustomEditorRepository()
    : GridEditorRepository()
{
    m_defValueDisplay = QString();
    m_defValueEdit = QString();
}

GridEditor* CustomEditorRepository::createEditor()
{
    return new CustomEditor();
}

/* CustomEditor */
CustomEditor::CustomEditor()
    :GridEditorBase(), m_customWidget(Q_NULL)
{
}

CustomEditor::~CustomEditor()
{
    Q_ASSERT(!isEditMode());
    destroyEditModeContext();
}

QWidget* CustomEditor::getCellWidget()
{
    return m_customWidget;
}

void CustomEditor::repositoryUpdated()
{
    if (m_customWidget == Q_NULL)
        return;
    GridEditorStyleOption option;
    site()->initOption(&option);
    m_customWidget->setAttribute(Qt::WA_NoSystemBackground, m_editorRepository->transparentBackground());
    if (m_customWidget->alignment() != option.decorationAlignment)
        m_customWidget->setAlignment(option.decorationAlignment);
}

void CustomEditor::paintEvent(QPainter& painter, const GridEditorStyleOption& option)
{
    GridEditorBase::paintEvent(painter, option);
}

void CustomEditor::mouseOverEvent(QEnterEvent* e)
{
    GridEditorBase::mouseOverEvent(e);
}

void CustomEditor::mouseOutEvent()
{
    GridEditorBase::mouseOutEvent();
}

void CustomEditor::focusInEvent(QFocusEvent* e)
{
    GridEditorBase::focusInEvent(e);
    if (e->reason() == Qt::ActiveWindowFocusReason)
        return;
    if (m_customWidget != Q_NULL && m_editorRepository->autoSelect())
        m_customWidget->selectAll();
}

void CustomEditor::updateContext(const QVariant& value)
{
    EditorAutoUpdater autoupdater(this);
    if (isEditMode())
        setValueToWidget(value);
    GridEditorBase::updateContext(value);
}

void CustomEditor::createEditModeContext()
{
    Q_ASSERT(isEditMode());
    m_customWidget = new CustomEditWidget(site()->parent());
    connect(m_customWidget, SIGNAL(textEdited(const QString&)), this, SLOT(textEdited(const QString&)));
    repositoryUpdated();
}

void CustomEditor::destroyEditModeContext()
{
    Q_DELETE_AND_NULL(m_customWidget);
}

void CustomEditor::setValueToWidget(const QVariant& value)
{
    if (m_customWidget == Q_NULL)
        return;

    EditorAutoUpdater autoupdater(this);

    QString text = m_editorRepository->valueToText(value);
    if (text != m_customWidget->text())
    {
        m_customWidget->setAttribute(Qt::WA_UpdatesDisabled, true);
        m_customWidget->setText(text);
        m_customWidget->setAttribute(Qt::WA_UpdatesDisabled, false);
    }
}

void CustomEditor::textEdited(const QString& text)
{
    editingValueUpdated(text);
}