merge with/from trunk at r35190
[blender.git] / intern / ghost / intern / GHOST_EventManager.h
1 /*
2  * $Id$
3  * ***** BEGIN GPL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software Foundation,
17  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  *
19  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
20  * All rights reserved.
21  *
22  * The Original Code is: all of this file.
23  *
24  * Contributor(s): none yet.
25  *
26  * ***** END GPL LICENSE BLOCK *****
27  */
28
29 /** \file ghost/intern/GHOST_EventManager.h
30  *  \ingroup GHOST
31  * Declaration of GHOST_EventManager class.
32  */
33
34 #ifndef _GHOST_EVENT_MANAGER_H_
35 #define _GHOST_EVENT_MANAGER_H_
36
37 #include <deque>
38 #include <vector>
39 #include <cstdio>
40
41 #include "GHOST_IEventConsumer.h"
42 #include "GHOST_ModifierKeys.h"
43
44 /**
45  * Manages an event stack and a list of event consumers.
46  * The stack works on a FIFO (First In First Out) basis.
47  * Events are pushed on the front of the stack and retrieved from the back.
48  * Ownership of the event is transferred to the event manager as soon as an event is pushed.
49  * Ownership of the event is transferred from the event manager as soon as an event is popped.
50  * Events can be dispatched to the event consumers.
51  */
52 class GHOST_EventManager
53 {
54 public:
55         /**
56          * Constructor.
57          */
58         GHOST_EventManager();
59
60         /**
61          * Destructor.
62          */
63         virtual ~GHOST_EventManager();
64
65         /**
66          * Returns the number of events currently on the stack.
67          * @return The number of events on the stack.
68          */
69         virtual GHOST_TUns32    getNumEvents();
70
71         /**
72          * Returns the number of events of a certain type currently on the stack.
73          * @param type The type of events to be counted.
74          * @return The number of events on the stack of this type.
75          */
76         virtual GHOST_TUns32    getNumEvents(GHOST_TEventType type);
77
78         /**
79          * Return the event at the top of the stack without removal.
80          * Do not delete the event!
81          * @return The event at the top of the stack.
82          */
83         virtual GHOST_IEvent* peekEvent();
84
85         /**
86          * Pushes an event on the stack.
87          * To dispatch it, call dispatchEvent() or dispatchEvents().
88          * Do not delete the event!
89          * @param event The event to push on the stack.
90          */
91         virtual GHOST_TSuccess pushEvent(GHOST_IEvent* event);
92         
93         virtual GHOST_TSuccess beginRecord(FILE *file);
94         virtual GHOST_TSuccess endRecord();
95         virtual GHOST_TSuccess playbackEvents(FILE *file);
96         
97         virtual bool playingEvents(bool *hasevent);
98         
99         virtual bool recordingEvents() {
100                 return m_recfile != NULL;
101         }
102         
103         /** only used during playback **/
104         virtual GHOST_TSuccess getModifierKeys(GHOST_ModifierKeys &keys) const
105         {
106                 keys = m_playmods;
107                 return GHOST_kSuccess;
108         }
109         
110         /** only used during playback **/
111         virtual GHOST_TSuccess getCursorPosition(GHOST_TInt32 &x, GHOST_TInt32 &y) const
112         {
113                 x = m_x;
114                 y = m_y;
115                 
116                 return GHOST_kSuccess;
117         }
118         
119         /**
120          * Dispatches the given event directly, bypassing the event stack.
121          * @return Indication as to whether any of the consumers handled the event.
122          */
123         virtual bool dispatchEvent(GHOST_IEvent* event);
124
125         /**
126          * Dispatches the event at the back of the stack.
127          * The event will be removed from the stack.
128          * @return Indication as to whether any of the consumers handled the event.
129          */
130         virtual bool dispatchEvent();
131
132         /**
133          * Dispatches all the events on the stack.
134          * The event stack will be empty afterwards.
135          * @return Indication as to whether any of the consumers handled the events.
136          */
137         virtual bool dispatchEvents();
138
139         /**
140          * Adds a consumer to the list of event consumers.
141          * @param consumer The consumer added to the list.
142          * @return Indication as to whether addition has succeeded.
143          */
144         virtual GHOST_TSuccess addConsumer(GHOST_IEventConsumer* consumer);
145
146         /**
147          * Removes a consumer from the list of event consumers.
148          * @param consumer The consumer removed from the list.
149          * @return Indication as to whether removal has succeeded.
150          */
151         virtual GHOST_TSuccess removeConsumer(GHOST_IEventConsumer* consumer);
152
153         /**
154          * Removes all events for a window from the stack.
155          * @param       window  The window to remove events for.
156          */
157                 virtual void
158          removeWindowEvents(
159                 GHOST_IWindow* window
160          );
161
162         /**
163          * Removes all events of a certain type from the stack.
164          * The window parameter is optional. If non-null, the routine will remove
165          * events only associated with that window.
166          * @param       type    The type of events to be removed.
167          * @param       window  The window to remove the events for.
168          */
169                 virtual void
170         removeTypeEvents(
171                 GHOST_TEventType type,
172                 GHOST_IWindow* window = 0
173         );
174
175 protected:
176         /**
177          * Returns the event at the top of the stack and removes it.
178          * Delete the event after use!
179          * @return The event at the top of the stack.
180          */
181         virtual GHOST_IEvent* popEvent();
182
183         /**
184          * Removes all events from the stack.
185          */
186         virtual void disposeEvents();
187
188         /** A stack with events. */
189         typedef std::deque<GHOST_IEvent*> TEventStack;
190         
191         /** The event stack. */
192         std::deque<GHOST_IEvent*> m_events;
193
194         /** A vector with event consumers. */
195         typedef std::vector<GHOST_IEventConsumer*> TConsumerVector;
196
197         /** The list with event consumers. */
198         TConsumerVector m_consumers;
199 private:
200         /** used for playback functionality**/
201         FILE *m_recfile;
202         FILE *m_playfile;
203         GHOST_ModifierKeys m_playmods;  
204         GHOST_TUns64 m_lasttime;
205         GHOST_TInt32 m_x, m_y;
206 };
207
208 #endif // _GHOST_EVENT_MANAGER_H_
209