Qt - remove all widgets from layout?

Question

This doesn't seem easy. Basically, I add QPushButtons through a function to a layout, and when the function executes, I want to clear the layout first (removing all QPushButtons and whatever else is in there), because more buttons just get appended to the scrollview.

header

QVBoxLayout* _layout;

cpp

void MainWindow::removeButtonsThenAddMore(const QString &item) {

//remove buttons/widgets

QVBoxLayout* _layout = new QVBoxLayout(this);

QPushButton button = new QPushButton(item);
_layout->addWidget(button);

QPushButton button = new QPushButton("button");
_layout->addWidget(button);

QWidget* widget = new QWidget();
widget->setLayout(_layout);

QScrollArea* scroll = new QScrollArea();
scroll->setWidget(widget);
scroll->show();

}

Solution 1

I had the same problem: I have a game app whose main window class inherits QMainWindow. Its constructor looks partly like this:

m_scene = new QGraphicsScene;
m_scene->setBackgroundBrush( Qt::black );
...
m_view = new QGraphicsView( m_scene );
...
setCentralWidget( m_view );

When I want to display a level of the game, I instantiate a QGridLayout, into which I add QLabels, and then set their pixmaps to certain pictures (pixmaps with transparent parts). The first level displays fine, but when switching to the second level, the pixmaps from the first level could still be seen behind the new ones (where the pixmap was transparent).

I tried several things to delete the old widgets. (a) I tried deleting the QGridLayout and instantiating a new one, but then learned that deleting a layout does not delete the widgets added to it. (b) I tried calling QLabel::clear() on the new pixmaps, but that of course had only an effect on the new ones, not the zombie ones. (c) I even tried deleting my m_view and m_scene, and reconstructing them every time I displayed a new level, but still no luck.

Then (d) I tried one of the solutions given above, namely

QLayoutItem *wItem;
while (wItem = widget->layout()->takeAt(0) != 0)
    delete wItem;

but that didn't work, either.

However, googling further, I found an answer that worked. What was missing from (d) was a call to delete item->widget(). The following now works for me:

// THIS IS THE SOLUTION!
// Delete all existing widgets, if any.
if ( m_view->layout() != NULL )
{
    QLayoutItem* item;
    while ( ( item = m_view->layout()->takeAt( 0 ) ) != NULL )
    {
        delete item->widget();
        delete item;
    }
    delete m_view->layout();
}

and then I instantiate a new QGridLayout as with the first level, add the new level's widgets to it, etc.

Qt is great in many ways, but I do think this problems shows that things could be a bit easier here.

Solution 2

Layout management page in Qt's help states:

The layout will automatically reparent the widgets (using QWidget::setParent()) so that they are children of the widget on which the layout is installed.

My conclusion: Widgets need to be destroyed manually or by destroying the parent WIDGET, not layout

Widgets in a layout are children of the widget on which the layout is installed, not of the layout itself. Widgets can only have other widgets as parent, not layouts.

My conclusion: Same as above

To @Muelner for "contradiction" "The ownership of item is transferred to the layout, and it's the layout's responsibility to delete it." - this doesn't mean WIDGET, but ITEM that is reparented to the layout and will be deleted later by the layout. Widgets are still children of the widget the layout is installed on, and they need to be removed either manually or by deleting the whole parent widget.

If one really needs to remove all widgets and items from a layout, leaving it completely empty, he needs to make a recursive function like this:

// shallowly tested, seems to work, but apply the logic

void clearLayout(QLayout* layout, bool deleteWidgets = true)
{
    while (QLayoutItem* item = layout->takeAt(0))
    {
        if (deleteWidgets)
        {
            if (QWidget* widget = item->widget())
                widget->deleteLater();
        }
        if (QLayout* childLayout = item->layout())
            clearLayout(childLayout, deleteWidgets);
        delete item;
    }
}

Solution 3

This code deletes all its children. So everything inside the layout 'disappears'.

qDeleteAll(yourWidget->findChildren<QWidget *>(QString(), Qt::FindDirectChildrenOnly));

This deletes all direct widgets of the widget yourWidget. Using Qt::FindDirectChildrenOnly is essential as it prevents the deletion of widgets that are children of widgets that are also in the list and probably already deleted by the loop inside qDeleteAll.

Here is the description of qDeleteAll:

void qDeleteAll(ForwardIterator begin, ForwardIterator end)

Deletes all the items in the range [begin, end] using the C++ delete > operator. The item type must be a pointer type (for example, QWidget *).

Note that qDeleteAll needs to be called with a container from that widget (not the layout). And note that qDeleteAll does NOT delete yourWidget - just its children.

Solution 4

Untried: Why not create a new layout, swap it with the old layout and delete the old layout? This should delete all items that were owned by the layout and leave the others.

Edit: After studying the comments to my answer, the documentation and the Qt sources I found a better solution:

If you still have Qt3 support enabled, you can use QLayout::deleteAllItems() which is basically the same as hint in the documentation for QLayout::takeAt:

The following code fragment shows a safe way to remove all items from a layout:

QLayoutItem *child;
while ((child = layout->takeAt(0)) != 0) {
  ...
  delete child;
}

Edit: After further research it looks like both version above are equivalent: only sublayouts and widget without parents are deleted. Widgets with parent are treated in a special way. It looks like TeL's solution should work, you only should be careful not to delete any top-level widgets. Another way would be to use the widget hierarchy to delete widgets: Create a special widget without parent and create all your removeable widgets as child of this special widget. After cleaning the layout delete this special widget.

Solution 5

You also want to make sure that you remove spacers and things that are not QWidgets. If you are sure that the only things in your layout are QWidgets, the previous answer is fine. Otherwise you should do this:

QLayoutItem *wItem;
while (wItem = widget->layout()->takeAt(0) != 0)
      delete wItem;

It is important to know how to do this because if the layout you want to clear is part of a bigger layout, you don't want to destroy the layout. You want to ensure that your layout maintains it's place and relation to the rest of your window.

You should also be careful, you're are creating a load of objects each time you call this method, and they are not being cleaned up. Firstly, you probably should create the QWidget and QScrollArea somewhere else, and keep a member variable pointing to them for reference. Then your code could look something like this:

QLayout *_layout = WidgetMemberVariable->layout();

// If it is the first time and the layout has not been created
if (_layout == 0)
{
  _layout = new QVBoxLayout(this);
  WidgetMemberVariable->setLayout(_layout);
}

// Delete all the existing buttons in the layout
QLayoutItem *wItem;
while (wItem = widget->layout()->takeAt(0) != 0)
    delete wItem;

//  Add your new buttons here.
QPushButton button = new QPushButton(item);
_layout->addWidget(button);

QPushButton button = new QPushButton("button");
_layout->addWidget(button);

View more solutions

Comments

[Admin]

Hmmm...this force closes the application, even if I wait for the layout to populate once. I must be doing something wrong.

[BastiBen]

Don't copy-paste the code. Look up what I used above in the Qt documentation and make it fit your needs. Use gdb or Qt Creator to find where it crashed by running it in debug mode.

[Zelid]

This will not delete widgets that already exist in layout, as widgets belong to a parent widget, not the layout.

[hmuelner]

If you downvote someone, you should at least read the correspondig documentation of QLayout::addItem, which contains the note: he ownership of item is transferred to the layout, and it's the layout's responsibility to delete it.

[Teemu Leisti]

Actually, hold on, I might have spoken too soon. I saw the second game level displayed correctly, but there's still something funny going on. I'll get back to this once I've figured it out.

[Christopher Bruns]

@hmuelner OK, let's read the documentation. First, the "addItem" method you cite is not used in the example, and is "not recommended for use in applications". Second, the documentation for "~QVBoxLayout()" clearly states that "The layout's widgets aren't destroyed.". It would seem that user118657's criticism is correct.

[hmuelner]

The documentation is contradictory: QLayout::addWidget contains: This function uses addItem(). So I went to the ultimate documentation - the source code. It looks like both of us are right: If you add a wdiget without a parent (like in the example of the OP) the layout takes ownership and the widget are destroyed, otherwise the widgets will be destroyed when their parents are destroyed.

[hmuelner]

I just had a look at QLayout::deleteAllItems() (Qt3 support) and at the documentation for QLayout::takeAt. This gives another answer.

[Christopher Bruns]

Nice update. Your answer now has strengths from answers by Liz and TeL. I also am curious about TeL's point about adding "delete child->widget()". Is that important here?

[emkey08]

This solution doesn't consider nested layouts correctly. See Darko Maksimovic's answer for the correct solution.

[Miguel]

Are you sure deleteLater() deletes after the queue is idle? (and how would idle be defined? idle wrt. to the object? unlikely...) The docs state: "The object will be deleted when control returns to the event loop." I've had a few problems with events sent to deleteLater()'d objects, though it might have been due to many things...

[odinthenerd]

I changed my wording to something less ambiguous. deleteLater() is implemented like other signal/slot arriving from other threads which are queued in order of occurrence. Therefore if other signals (events) are queued at the time deleteLater() is called they will be handled before it is deleted, this is by design.

[odinthenerd]

this is dangerous if the widgets have signals connected to them because there may be pending events at the time clearLayout(...) is called.

[earthdan]

A QLayout cannot be a parent of a QWidget. So qLayout->childern() return 0 items.

[Jean-Michaël Celerier]

In order to prevent this problem with pending events, widget->deleteLater() should maybe be called instead of just delete ??

[Marco Sulla]

I have a grid layout for a group box, and calling qDeleteAll for the group box crashes the program. I tried also calling it with the layout object, but it does nothing. I'm using QT 5.8 for a desktop app.

[C--]

This is rather convenient.

[m.w.]

@MarcoSulla Adding a widget to a layout does not parent the widget to the layout but to the layout's parent (a widget). So calling children() on a layout correctly returns an empty list.

[Oshada]

this works well, but I had to add parentheses to following statement while ((wItem = ui->verticalLayoutForScenarios->takeAt(0)) != 0)

[Nulik]

he said "remove", not delete (destroy the objects) . To remove a widget from a layout you don't need to destroy the object.