Question

I have the following problem with QT model/view framework. I want to render a widget inside a table view item.

First my thought was to use

void QAbstractItemView::setIndexWidget( const QModelIndex & index, QWidget * widget )

But the documentation for this function explicitly states:

This function should only be used to
display static content within the
visible area corresponding to an item
of data. If you want to display custom
dynamic content or implement a custom
editor widget, subclass QItemDelegate
instead.

So they propose to use delegates here. Well, so far so good. I know that the delegates may be used to create an editor, which may be basically any QT widget. But here is the problem – I don’t want this widget to be an editor – I want to render the item with this widget always. And not just “render”, I need it to have the exact behavior of the widget.

Now the widget I want to use is a custom widget, which is a container of some other widgets (few check-boxes, few buttons with some layout).

The solution I consider is like this:

1. Grab the look of my custom widget to a pixmap.
2. Let the delegate paint itself using this pixmap.
3. When the mouse is over an item cause the view to automatically start editing (I don’t
   know how to do it yet, but I suppose it’s possible)
4. Let the delegate create my widget as the editor for an item.

This solution seems to work, but it smells bad for me. Can anyone thing about more elegant solution for this problem?

Thanks.

Answer 1

Delegates are in charge of creating editors as well as doing all necessary display. They may use styles to do much of the painting, like drawing a progress bar, or paint manually.

A delegate, however, is not a widget. Unless an editor has been invoked, it doesn’t have access to most things a widget would. The two are very different, have different purposes, and accomplish different things.

One of the most troublesome aspect of delegates is that they are static. Unless something in the model triggers an update (or the widget is configured to watch hover events), the delegate won’t be used to redraw whatever data is present — the buffered representation will be drawn to the screen.

You have some control over when an editor is invoked with edit triggers, although you can definitely handle it with some custom code, such as through mouse tracking.