Best way to access (grand grand) parent element in gui

Question

I'm creating a multi window gui program, in c++ with Qt Widgets. I do have many custom gui elements, which usually are c++ classes inherited from QWidget or other Qt elements. When foo is the main window, it often looks like this:

Foo = new Foo();
Bar1 *widget1(foo);
Bar2 *widget2(widget1);
Bar3 *widget3(widget2);
Bar4 *widget4(widget3);

foo->addWidget(widget1);
widget1->addWidget(widget2);
widget2->addWidget(widget3);
widget3->addWidget(widget4);

Actually I use std::shared_ptr everywhere but I'm omitting that here for the sake of readability. Also this is simplified, the order is not always like this and there may be other Qt elements in between.

The argument in the constructors is the "parent" Window. Qt handles the deletion of all my Widgets using the parent structures.

My problem is, that sometimes, I need to access elements of my main window foo from some Bar widget down the road. E.g.: "If this is clicked, add another tab to the QTabwidget in foo. I do not always know, how many layers there are between foo and widgetX.

What's the best way to have a reference to foo in the lowest layer?

1. The easiest way would be to make foo a singleton since I only ever have one foo window and once it get's closed, my program terminates anyway. But making the whole class static comes with it's own drawbacks.
2. Add a reference to foo to all my constructors and pass it through them. I'd have a reference to foo in many places where I do not need one.
3. I can access the parent reference that got passed through the constructors, but it's a pointer to QWidget. I'd have to cast it, check whether it's actually Foo and not Bar2, and then continue until I have found Foo.
4. Set foo as a parent for everything, even if it is not really the parent (e.g. in a new Window). This would keep all my elements in memory until foo is destroyed.
5. Use signals and slots. This sometimes works, but if I'm already 3 layers below foo when creating widget4, I can't connect them without foo.

Currently I have a mixed mess where I sometimes pass a reference to foo, have some static elements in foo and at some point cast the parent widget to foo.

What would be a good approach here?

Answer 1

Assuming you have your own widget class that wraps the Qt widget or descends from it, you can add a GetGodfather() method who's implementation looks somewhat like this:

if (this.parent == NULL)
{
    return this;
}
else
{
    return this.parent.GetGodfather();
}

Or, if you want to be smart about it:

return (this.Parent == NULL) ? this : this.parent.GetGodfather();

Answer 2

I encountered this same problem and solved it via a static member function of Foo that traverses parents of a child widget until one of type Foo is found:

class Foo : public QWidget {

public:
    // static member function to find Foo parent
    static Foo* findFrom(QWidget* widget) {
        while (widget) {
            Foo* foo = qobject_cast<Foo*>(widget);
            if (foo) {
                return foo; // found a Foo parent
            }
            widget = widget->parentWidget();
        }
        return nullptr; // no Foo parent found
    }
};

In some child widget's member method, you can then call Foo* parentFoo = Foo::findFrom(this) to get the Foo-pointer.