Home/ Questions/Q 122169
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-11T04:05:10+00:00

I have a program that (amongst other things) has a command line interface that

  • 0

I have a program that (amongst other things) has a command line interface that lets the user enter strings, which will then be sent over the network. The problem is that I’m not sure how to connect the events, which are generated deep inside the GUI, to the network interface. Suppose for instance that my GUI class hierarchy looks like this:

GUI -> MainWindow -> CommandLineInterface -> EntryField

Each GUI object holds some other GUI objects and everything is private. Now the entryField object generates an event/signal that a message has been entered. At the moment I’m passing the signal up the class hierarchy so the CLI class would look something like this:

public:     sig::csignal<void, string> msgEntered;

And in the c’tor:

entryField.msgEntered.connect(sigc::mem_fun(this, &CLI::passUp));

The passUp function just emits the signal again for the owning class (MainWindow) to connect to until I can finally do this in the main loop:

gui.msgEntered.connect(sigc::mem_fun(networkInterface, &NetworkInterface::sendMSG));

Now this seems like a real bad solution. Every time I add something to the GUI I have to wire it up all through the class hierarchy. I do see several ways around this. I could make all objects public, which would allow me to just do this in the main loop:

gui.mainWindow.cli.entryField.msgEntered.connect(sigc::mem_fun(networkInterface, &NetworkInterface::sendMSG));

But that would go against the idea of encapsulation. I could also pass a reference to the network interface all over the GUI, but I would like to keep the GUI code as seperate as possible.

It feels like I’m missing something essential here. Is there a clean way to do this?

Note: I’m using GTK+/gtkmm/LibSigC++, but I’m not tagging it as such because I’ve had pretty much the same problem with Qt. It’s really a general question.

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Short of having some global pub/sub hub, you aren’t going to get away from passing something up or down the hierarchy. Even if you abstract the listener to a generic interface or a controller, you still have to attach the controller to the UI event somehow.

    With a pub/sub hub you add another layer of indirection, but there’s still a duplication – the entryField still says ‘publish message ready event’ and the listener/controller/network interface says ‘listen for message ready event’, so there’s a common event ID that both sides need to know about, and if you’re not going to hard-code that in two places then it needs to be passed into both files (though as global it’s not passed as an argument; which in itself isn’t any great advantage).

    I’ve used all four approaches – direct coupling, controller, listener and pub-sub – and in each successor you loosen the coupling a bit, but you don’t ever get away from having some duplication, even if it’s only the id of the published event.

    It really comes down to variance. If you find you need to switch to a different implementation of the interface, then abstracting the concrete interface as a controller is worthwhile. If you find you need to have other logic observing the state, change it to an observer. If you need to decouple it between processes, or want to plug into a more general architecture, pub/sub can work, but it introduces a form of global state, and isn’t as amenable to compile-time checking.

    But if you don’t need to vary the parts of the system independently it’s probably not worth worrying about.

    • 0