GUI application and singleton/dependency injection

Question

Hello,

I am working on an application with a GUI using wxWidgets. I got an object used as a "model": its data has to be used to draw the ui and the ui should modify it. Let's call this class Model.

The structure of the applications looks like this:

A wxApp-derived object, that possesses:

• a wxFrame-derived object, that possesses a wxGLCanvas-derived object.
• another wxFrame-derived object.

For the Model class,

1. I could use a singleton that would make things very simple: I could just use model.getThatData() or model.setThatData() anywhere.

   However, I can't disagree when people say that it's a global variable with a fancy dress.

2. I could also use dependency injection (or is it something else): I instanciate Model in the wxApp object, and then I pass a reference to the instance model in the constructors of both wxFrame-derived classes, same thing with wxGLCanvas constructor, and I store the reference as an attribute of the needed classes.

   However, this doesn't seem either a very good solution. Suppose the first wxFrame object doesn't need to use model. We will nontheless have to pass a reference to model in its constructor to be able to pass it to the wxGLCanvas-derived object. So that design could lead to many (?) unnecessary passings.

3. ?

What do you think ? I have been asking myself this question for a long time...

Answer 1

However, this doesn't seem either a very good solution. Suppose the first wxFrame object doesn't need to use model. We will nontheless have to pass a reference to model in its constructor to be able to pass it to the wxGLCanvas-derived object. So that design could lead to many (?) unnecessary passings.

Passing pointers around is peanuts compared to the nightmares of untangling the dependencies between classes/objects, hidden in the implementation (== singletons).

The #2 is the way I do it. The goal is to be able just by looking at the class declaration to have an idea about the class prerequisites. Ideally, if in the context I have everything what c'tor/init method needs, I should be able to instantiate and use the object. That way the life-cycle also becomes clear: the prerequisites may not be released until the object is released.

Answer 2

Does the frame dependent on a specific canvas class? Or the canvas object interchangeable?

If the latter is the case, then the constructor for the frame should be parameterized by a reference to a canvas object. This way, the application will take care of instantiating the model, creating the canvas using said model, and passing the canvas to the frame. The frame will no more be dependent on the model directly.

If the frame is dependent on a specific canvas class (that is, the frame instantiates its own canvas, and knows what type of canvas it wants). Then if the canvas' constructor is dependent on the Model object, by proxy your frame is also dependent on the model. So #2 is correct.

Answer 3

Put it into a simple MVC model. (Recall that C interacts with M and V, and M and V do not interact with each other.)

Your model is (obviously) the "M" in MVC. Your widgets are the "V" in MVC.

See the problem here? You're trying to give the "M" to the "V"; you're missing the "C" to delegate everything. Your "C" may be your wxApp (it depends on how you want to design things).

In other words, the controller should give the data the view needs from the model to the view; the view shouldn't grab its own data directly from the model.

(Therefore, both of your proposals are, in my opinion, poor options in an MVC application.)