Automate window programming through a base class - c++

Question

I have programmed several windows for an application that all inherit Gtkmm::Window. At this point, I would like to automate the process. Right now, the following structure stands out:
class MyWindow : public Gtk::Window
{
public:
MyWindow();
virtual ~MyWindow();
//...
private:
void registerLayouts(); // Adds layouts to the window.
void registerWidgets(); // Adds widgets to the layouts.
//...
};
And the constructor:
MyWindow::MyWindow()
{
registerLayouts(); // Cannot be virtual: in constructor.
registerWidgets(); // Cannot be virtual: in constructor.
//...
}
So the problem is that all of this has to be done manually (i.e. copy/pasted) every time a new window has to be programmed because registerLayouts() and registerWidgets() are called at construction and hence cannot be virtual.
Ideally, I would have a base class that I could inherit from which would give me the option of overriding the two methods and would take care of the rest: it would call the two methods at an appropriate location.
The thing is, I have not found where this appropriate location could be. I have look at different signal handlers, but there seem to be none for this.
Do you have an idea of how I could do this?
MFC has the CDialog::OnInitDialog() that performs something similar to what I need.

Answer 1

You could delegate the work to a separate class:
class MyWindow : public Gtk::Window
{
//public: *** EDIT ***
protected:
template <typename LayoutManager>
MyWindow(LayoutManager const& lm)
{
lm.registerLayouts(this);
lm.registerWidgets(this);
}
};
class SubWindow : public MyWindow
{
class LM { /* ... */ };
public:
SubWindow() : MyWindow(LM()) { }
};
(Edited: The improved pattern hides away from public the layout managers of sub classes...)
Alternatively, the whole class as template (possibly superior to above):
template <typename LayoutManager>
class MyWindow : public Gtk::Window
{
public:
MyWindow()
{
LayoutManager lm(*this);
lm.registerLayouts();
lm.registerWidgets();
}
};
class SpecificLayoutManager { /* ... */ };
using SpecificWindow = MyWindow<SpecificLayoutManager>;
If you need the layout manager for cleaning up as well (not familiar with GTK myself...):
template <typename LayoutManager>
class MyWindow : public Gtk::Window
{
LayoutManager lm;
public:
MyWindow() : lm(*this)
{
lm.registerLayouts();
lm.registerWidgets();
}
virtual ~MyWindow()
{
// still access to lm...
}
};
Important side note: In all variants we do not yet have a fully constructed derived class – casting to the latter within the layout managers thus is not legal (experimented with curiously recurring template pattern, but dropped the idea for exactly the same reason: needed to cast to derived in constructor of base as well).
Edit in response to comments: A sample on how you could manage additional members of a subclass (using third variant above, the template class one with the layout manager member; lm member now needs to be protected):
class SubWindowLayoutManager
{
template <typename>
friend class MyWindow;
friend class SubWindow;
int someMember;
void registerLayouts() { }
void registerWidgets() { }
};
class SubWindow : public MyWindow<SubWindowLayoutManager>
{
void doSomething()
{
lm.someMember = 77;
}
};
Additionally a new variant entirely without templates:
class MyWindow : public Gtk::Window
{
protected:
class LayoutManager
{
public:
virtual void registerLayouts(MyWindow* parent) = 0;
virtual void registerWidgets(MyWindow* parent) = 0;
};
std::unique_ptr<LayoutManager> lm;
MyWindow(std::unique_ptr<LayoutManager> lm)
: lm(std::move(lm))
{
this->lm->registerLayouts(this);
this->lm->registerWidgets(this);
}
};
class SubWindow : public MyWindow
{
class LM : public LayoutManager
{
public:
void registerLayouts(MyWindow* parent) override { }
void registerWidgets(MyWindow* parent) override { }
int someMember;
};
// convenience access function:
inline LM& lm()
{
return *static_cast<LM*>(MyWindow::lm.get());
}
public:
SubWindow() : MyWindow(std::make_unique<LM>()) { }
void doSomething()
{
//static_cast<LM*>(lm.get())->someMember = 77;
lm().someMember = 77;
}
};