Since Agui favors Listeners over bubbling messages, the way I did it might not be exactly what you need (since I think you mentioned integrating your messages?)
But here is basically how I did it.
I have a base class Image, Font, Font Loader, Image Loader, Graphics Context...
I expect the back-end to implement all of these.
The loaders are pretty straight forward:
class AGUI_BACKEND_DECLSPEC Allegro5FontLoader :
public FontLoader
{
public:
Allegro5FontLoader(void) {}
~Allegro5FontLoader(void) {}
virtual Font* loadFont(const std::string &fileName, int height);
};
They implement the base class's load method and return an abstract Font, Image, etc.
The way Input works is as follows.
I have a base input class that allows you to queue up Mouse and Keyboard events.
The Input Handler base looks like:
#SelectExpand
1namespace agui
2{
3
4 /**
5 * Abstract class for Input.
6 *
7 * Should implement:
8 *
9 * A method to receive a back end specific event and convert it
10 * to MouseInput or KeyboardInput.
11 *
12 * getTime (default uses std::clock)
13 *
14 * Should respect:
15 *
16 * isMouseEnabled
17 *
18 * isKeyboardEnabled
19 * @author Joshua Larouche
20 * @since 0.1.0
21 */
22
23 class AGUI_CORE_DECLSPEC Input
24 {
25 double startTime;
26 std::queue<MouseInput> mouseEvents;
27 std::queue<KeyboardInput> keyboardEvents;
28 bool mouseEnabled;
29 bool keyboardEnabled;
30 protected:
31 /**
32 * Default constructor.
33 */
34 Input(void);
35 public:
36 /**
37 * Called by the Gui in its logic loop. Used for non event driven back ends.
38 */
39 virtual void pollInput();
40 /**
41 * Pushes a mouse event which will be dequeued and processed in the next logic loop.
42 */
43 void pushMouseEvent(const MouseInput &input);
44 /**
45 * Pushes a keyboard event which will be dequeued and processed in the next logic loop.
46 */
47 void pushKeyboardEvent(const KeyboardInput &input);
48 /**
49 * @return True if no mouse events are queued.
50 */
51 bool isMouseQueueEmpty() const;
52 /**
53 * @return True if no keyboard events are queued.
54 */
55 bool isKeyboardQueueEmpty() const;
56 /**
57 * Called by the Gui to process the event.
58 * @return The keyboard event information and removes it from the queue.
59 */
60 const KeyboardInput dequeueKeyboardInput();
61 /**
62 * Called by the Gui to process the event.
63 * @return The mouse event information and removes it from the queue.
64 */
65 const MouseInput dequeueMouseInput();
66 /**
67 * @return The amount of time the application has been running in seconds.
68 */
69 virtual double getTime() const;
70 /**
71 * Set whether or not keyboard input is enabled for the Gui.
72 */
73 void setKeyboardEnabled(bool enabled);
74 /**
75 * Set whether or not mouse input is enabled for the Gui.
76 */
77 void setMouseEnabled(bool enabled);
78 /**
79 * @return True if mouse input is enabled for the Gui.
80 */
81 bool isMouseEnabled() const;
82 /**
83 * @return True if keyboard input is enabled for the Gui.
84 */
85 bool isKeyboardEnabled() const;
86 /**
87 * Default destructor.
88 */
89 virtual ~Input(void);
90 };
91}
The way this works is, there is a Gui object that handles just about everything event related. It takes in an Input and GraphicsContext.
Example:
#SelectExpand
1class Scene : public agui::ActionListener, public agui::WidgetListener,
2 public SceneEventProvider
3 {
4 Timer* m_gameTimer;
5 DeviceManager* m_settings;
6 DynamicUIManager* m_dynamicUI;
7 SceneManagerMessage* m_sceneMessenger;
8
9 agui::Gui m_gui;
10 agui::Allegro5Input m_a5GuiInput;
11 agui::Allegro5Graphics m_a5GuiGraphics;
12 agui::Allegro5CursorProvider m_a5GuiCursor;
13.....
14
15 Scene::Scene(void)
16 : m_gameTimer(NULL),
17 m_sceneMessenger(NULL),
18 m_settings(NULL),
19 m_frame(NULL)
20 {
21 m_gui.setInput(&m_a5GuiInput);
22 m_gui.setGraphics(&m_a5GuiGraphics);
23 m_gui.setCursorProvider(&m_a5GuiCursor);
24 m_gui.setToolTipShowLength(10.0);
25 m_gui.setHoverInterval(0.75);
26 m_gui.setMaxToolTipWidth(400);
27
28 }
What the Gui does with this Input is:
In each logic() update it:
-calls input->poll()
-dequeues and dispatches queued, abstracted input.
It is the backend implementation's responsibility to convert whatever input it receives into agui::MouseInput and agui::KeyboardInput.
Now, in a case of A4 or SDL 1.2, the Input::poll() method would be implemented.
In an event driven style such as A5, I created a processInput(ALLEGRO_EVENT& evt).
That is called like this:
#SelectExpand
1 void Scene::processGuiInputEvent
( ALLEGRO_EVENT* evt
)
2 {
3 m_a5GuiInput.processEvent
(*evt
);
4 }
5
6...
7In Scene Manager...
8//main loop
9 while(m_gameIsRunning
)
10 {
11
12 handled
= false;
13 al_wait_for_event(queue,
&evt
);
14
15 bool hasNext
= al_peek_next_event(queue,
&next
);
16 if(hasNext
&& next.type
== ALLEGRO_EVENT_TIMER
)
17 {
18 al_drop_next_event(queue
);
19 }
20 //render the scene
21 if(m_needsRedraw
&& al_is_event_queue_empty(queue
))
22 {
23 m_currentScene->render
();
24 m_needsRedraw
= false;
25 }
26
27 defaultBeginEventHandler
(&evt
);
28 m_currentScene->processEvent
(&evt,handled
);
29
30...
31 void SceneManager::defaultBeginEventHandler
( ALLEGRO_EVENT*evt
)
32 {
33
34 m_currentScene->processGuiInputEvent
(evt
);
35
36 if(evt->type
== ALLEGRO_EVENT_TIMER
&& evt->timer.source
== m_gameTimer
)
37 {
38 m_needsRedraw
= true;
39 m_currentScene->processGuiLogic
();
40 m_devices->getNetClient
()->tick
();
41 }
42 else if(evt->type
== ALLEGRO_EVENT_DISPLAY_RESIZE
)
43 {
44 sendResizeMessage
(evt->display.width,evt->display.height
);
45 }
46 }
That is the basic idea... create an abstract set of functionality that any backend should be able to support, then implement it as a subclass and use polymorphism (and casting) to do the backend specific action.
As for Layouts, I probably should have made every Widget own a layout, but instead I made it so that a Layout has complete control over the Widgets it is laying out.
I prefer the idea of every Widget having a layout, and preferably a NULL layout can be supported.
As to what you should work on with it... I guess games or level editors...
I like your GUI, I think it looks quite nice. The default skin doesn't matter anyways :p
Take Agui for example, it looks much nicer in action!
{"name":"607025","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/c\/5\/c5f02ac525f2c373d6fa7ae914a70bf9.png","w":476,"h":281,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/c\/5\/c5f02ac525f2c373d6fa7ae914a70bf9"}
]]>
