Pixelator Example

PixelDelegate Class Implementation

The PixelDelegate constructor is used to set up a default value for the size of each "pixel" that it renders. The base class constructor is also called to ensure that the delegate is set up with a parent object, if one is supplied:

    PixelDelegate::PixelDelegate(QObject *parent)
        : QAbstractItemDelegate(parent)
    {
        pixelSize = 12;
    }

Each item is rendered by the delegate's paint() function. The view calls this function with a ready-to-use QPainter object, style information that the delegate should use to correctly draw the item, and an index to the item in the model:

    void PixelDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option,
                              const QModelIndex &index) const
    {
        painter->setRenderHint(QPainter::Antialiasing);
        painter->setPen(Qt::NoPen);

For this delegate, we do not need to use a pen, but we would like the output to be antialiased.

The first task the delegate has to perform is to draw the item's background correctly. Usually, selected items appear differently to non-selected items, so we begin by testing the state passed in the style option and setting the painter's brush accordingly:

        if (option.state & QStyle::State_Selected)
            painter->setBrush(option.palette.highlight());
        else
            painter->setBrush(QBrush(Qt::white));

This ensures that the background of each item in the view has the correct style for both selected and unselected items. Ideally, we would also test for other states and draw each item in the appropriate style, too.

The foreground of the item (the circle representing a pixel) must also be rendered using an appropriate brush. For unselected items, we will use a solid black brush; selected items are drawn using a predefined brush from the style option's palette:

        if (option.state & QStyle::State_Selected)
            painter->setBrush(option.palette.highlightedText());
        else
            painter->setBrush(QBrush(Qt::black));

The radius of each circle is calculated in the following three lines of code:

        int size = qMin(option.rect.width(), option.rect.height());
        int brightness = index.model()->data(index, Qt::DisplayRole).toInt();
        double radius = (size/2.0) - (brightness/255.0 * size/2.0);

First, the largest possible radius of the circle is determined by taking the smallest dimension of the style option's rect attribute. Using the model index supplied, we obtain a value for the brightness of the relevant pixel in the image. The radius of the circle is calculated by scaling the brightness to fit within the item and subtracting it from the largest possible radius.

Finally, we paint the circle within the rectangle specified by the style option:

        painter->drawEllipse(QRectF(option.rect.x() + option.rect.width()/2 - radius,
                                    option.rect.y() + option.rect.height()/2 - radius,
                                    2*radius, 2*radius));
    }

The paint() function does not have to be particularly complicated; it is only necessary to ensure that the state of the painter when the function returns is the same as it was when it was called. This usually means that any transformations applied to the painter must be preceded by a call to QPainter::save() and followed by a call to QPainter::restore().

The delegate's sizeHint() function returns a size for the item based on the predefined pixel size, initially set up in the constructor:

    QSize PixelDelegate::sizeHint(const QStyleOptionViewItem & /* option */,
                                  const QModelIndex & /* index */) const
    {
        return QSize(pixelSize, pixelSize);
    }

The delegate's size is updated whenever the pixel size is changed. We provide a custom slot to do this:

    void PixelDelegate::setPixelSize(int size)
    {
        pixelSize = size;
    }

    MainWindow::MainWindow() : QMainWindow()
    {
        ...
        view = new QTableView;
        view->setShowGrid(false);
        view->horizontalHeader()->hide();
        view->verticalHeader()->hide();

        PixelDelegate *delegate = new PixelDelegate(this);
        view->setItemDelegate(delegate);

        QLabel *pixelSizeLabel = new QLabel(tr("Pixel size:"));
        QSpinBox *pixelSizeSpinBox = new QSpinBox;
        pixelSizeSpinBox->setMinimum(1);
        pixelSizeSpinBox->setMaximum(32);
        pixelSizeSpinBox->setValue(12);

        connect(pixelSizeSpinBox, SIGNAL(valueChanged(int)),
                delegate, SLOT(setPixelSize(int)));
        connect(pixelSizeSpinBox, SIGNAL(valueChanged(int)),
                this, SLOT(updateView()));
        ...
    }

    void MainWindow::updateView()
    {
        for (int row = 0; row < model->rowCount(QModelIndex()); ++row)
            view->resizeRowToContents(row);
        for (int column = 0; column < model->columnCount(QModelIndex()); ++column)
            view->resizeColumnToContents(column);
    }