Yes I did it again ;)
[blender.git] / intern / ghost / intern / GHOST_System.h
1 /**
2  * $Id$
3  * ***** BEGIN GPL/BL DUAL 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. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30  */
31
32 /**
33
34  * $Id$
35  * Copyright (C) 2001 NaN Technologies B.V.
36  * @author      Maarten Gribnau
37  * @date        May 7, 2001
38  */
39
40 #ifndef _GHOST_SYSTEM_H_
41 #define _GHOST_SYSTEM_H_
42
43 #ifdef HAVE_CONFIG_H
44 #include <config.h>
45 #endif
46
47 #include "GHOST_ISystem.h"
48
49 #include "GHOST_Debug.h"
50 #include "GHOST_Buttons.h"
51 #include "GHOST_ModifierKeys.h"
52 #include "GHOST_EventManager.h"
53 #ifdef GHOST_DEBUG
54 #include "GHOST_EventPrinter.h"
55 #endif // GHOST_DEBUG
56
57 class GHOST_DisplayManager;
58 class GHOST_Event;
59 class GHOST_TimerManager;
60 class GHOST_Window;
61 class GHOST_WindowManager;
62
63 /**
64  * Implementation of platform independent functionality of the GHOST_ISystem interface.
65  * GHOST_System is an abstract base class because not all methods of GHOST_ISystem are implemented.
66  * There should be only one system class in an application.
67  * Therefore, the routines to create and dispose the system are static.
68  * Provides:
69  * 1. Time(r) management.
70  * 2. Display/window management (windows are only created on the main display for now).
71  * 3. Event management.
72  * 4. Cursor shape management (no custom cursors for now).
73  * 5. Access to the state of the mouse buttons and the keyboard.
74  * @see GHOST_ISystem.
75  * @author      Maarten Gribnau
76  * @date        May 7, 2001
77  */
78
79 class GHOST_System : public GHOST_ISystem
80 {
81 protected:
82         /**
83          * Constructor.
84          * Protected default constructor to force use of static createSystem member.
85          */
86         GHOST_System();
87
88         /**
89          * Destructor.
90          * Protected default constructor to force use of static dispose member.
91          */
92         virtual ~GHOST_System();
93
94 public:
95         /***************************************************************************************
96          ** Time(r) functionality
97          ***************************************************************************************/
98
99         /**
100          * Returns the system time.
101          * Returns the number of milliseconds since the start of the system process.
102          * Based on ANSI clock() routine.
103          * @return The number of milliseconds.
104          */
105         virtual GHOST_TUns64 getMilliSeconds() const;
106
107         /**
108          * Installs a timer.
109          * Note that, on most operating systems, messages need to be processed in order 
110          * for the timer callbacks to be invoked.
111          * @param delay         The time to wait for the first call to the timerProc (in milliseconds)
112          * @param interval      The interval between calls to the timerProc
113          * @param timerProc     The callback invoked when the interval expires,
114          * @param userData      Placeholder for user data.
115          * @return A timer task (0 if timer task installation failed).
116          */
117         virtual GHOST_ITimerTask* installTimer(GHOST_TUns64 delay, GHOST_TUns64 interval, GHOST_TimerProcPtr timerProc, GHOST_TUserDataPtr userData = 0);
118
119         /**
120          * Removes a timer.
121          * @param timerTask Timer task to be removed.
122          * @return Indication of success.
123          */
124         virtual GHOST_TSuccess removeTimer(GHOST_ITimerTask* timerTask);
125
126         /***************************************************************************************
127          ** Display/window management functionality
128          ***************************************************************************************/
129         
130         /**
131          * Inherited from GHOST_ISystem but left pure virtual
132          *
133          * virtual      GHOST_TUns8 getNumDisplays() const = 0;
134          * virtual void getMainDisplayDimensions(...) const = 0;
135          * virtual GHOST_IWindow* createWindow(..)
136          */
137
138         /**
139          * Dispose a window.
140          * @param       window Pointer to the window to be disposed.
141          * @return      Indication of success.
142          */
143         virtual GHOST_TSuccess disposeWindow(GHOST_IWindow* window);
144
145         /**
146          * Returns whether a window is valid.
147          * @param       window Pointer to the window to be checked.
148          * @return      Indication of validity.
149          */
150         virtual bool validWindow(GHOST_IWindow* window);
151
152         /**
153          * Begins full screen mode.
154          * @param setting       The new setting of the display.
155          * @param window        Window displayed in full screen.
156          * @param stereoVisual  Stereo visual for quad buffered stereo.
157          * This window is invalid after full screen has been ended.
158          * @return      Indication of success.
159          */
160         virtual GHOST_TSuccess beginFullScreen(const GHOST_DisplaySetting& setting, GHOST_IWindow** window,
161                 const bool stereoVisual);
162
163         /**
164          * Ends full screen mode.
165          * @return      Indication of success.
166          */
167         virtual GHOST_TSuccess endFullScreen(void);
168
169         /**
170          * Returns current full screen mode status.
171          * @return The current status.
172          */
173         virtual bool getFullScreen(void);
174
175
176         /***************************************************************************************
177          ** Event management functionality
178          ***************************************************************************************/
179
180         /**
181          * Inherited from GHOST_ISystem but left pure virtual
182          *
183          *      virtual bool processEvents(bool waitForEvent) = 0;
184          */
185
186
187
188         /**
189          * Dispatches all the events on the stack.
190          * The event stack will be empty afterwards.
191          * @return Indication as to whether any of the consumers handled the events.
192          */
193         virtual bool dispatchEvents();
194
195         /**
196          * Adds the given event consumer to our list.
197          * @param consumer The event consumer to add.
198          * @return Indication of success.
199          */
200         virtual GHOST_TSuccess addEventConsumer(GHOST_IEventConsumer* consumer);
201
202         /***************************************************************************************
203          ** Cursor management functionality
204          ***************************************************************************************/
205
206         /** Inherited from GHOST_ISystem but left pure virtual
207          *      GHOST_TSuccess getCursorPosition(GHOST_TInt32& x, GHOST_TInt32& y) const = 0;   
208          *  GHOST_TSuccess setCursorPosition(GHOST_TInt32 x, GHOST_TInt32 y)
209          */
210
211         /***************************************************************************************
212          ** Access to mouse button and keyboard states.
213          ***************************************************************************************/
214
215         /**
216          * Returns the state of a modifier key (ouside the message queue).
217          * @param mask          The modifier key state to retrieve.
218          * @param isDown        The state of a modifier key (true == pressed).
219          * @return                      Indication of success.
220          */
221         virtual GHOST_TSuccess getModifierKeyState(GHOST_TModifierKeyMask mask, bool& isDown) const;
222
223         /**
224          * Returns the state of a mouse button (ouside the message queue).
225          * @param mask          The button state to retrieve.
226          * @param isDown        Button state.
227          * @return                      Indication of success.
228          */
229         virtual GHOST_TSuccess getButtonState(GHOST_TButtonMask mask, bool& isDown) const;
230
231         /***************************************************************************************
232          ** Other (internal) functionality.
233          ***************************************************************************************/
234
235         /**
236          * Pushes an event on the stack.
237          * To dispatch it, call dispatchEvent() or dispatchEvents().
238          * Do not delete the event!
239          * @param event The event to push on the stack.
240          */
241         virtual GHOST_TSuccess pushEvent(GHOST_IEvent* event);
242
243         /**
244          * Returns the timer manager.
245          * @return The timer manager.
246          */
247         inline virtual GHOST_TimerManager* getTimerManager() const;
248
249         /**
250          * Returns a pointer to our event manager.
251          * @return A pointer to our event manager.
252          */
253         virtual inline GHOST_EventManager* getEventManager() const;
254
255         /**
256          * Returns a pointer to our window manager.
257          * @return A pointer to our window manager.
258          */
259         virtual inline GHOST_WindowManager* getWindowManager() const;
260
261         /**
262          * Returns the state of all modifier keys.
263          * @param keys  The state of all modifier keys (true == pressed).
264          * @return              Indication of success.
265          */
266         virtual GHOST_TSuccess getModifierKeys(GHOST_ModifierKeys& keys) const = 0;
267
268         /**
269          * Returns the state of the mouse buttons (ouside the message queue).
270          * @param buttons       The state of the buttons.
271          * @return                      Indication of success.
272          */
273         virtual GHOST_TSuccess getButtons(GHOST_Buttons& buttons) const = 0;
274
275 protected:
276         /**
277          * Initialize the system.
278          * @return Indication of success.
279          */
280         virtual GHOST_TSuccess init();
281
282         /**
283          * Shut the system down.
284          * @return Indication of success.
285          */
286         virtual GHOST_TSuccess exit();
287
288         /**
289          * Creates a fullscreen window.
290          * @param window The window created.
291          * @return Indication of success.
292          */
293         virtual GHOST_TSuccess createFullScreenWindow(GHOST_Window** window,
294                 const bool stereoVisual);
295
296         /** The display manager (platform dependant). */
297         GHOST_DisplayManager* m_displayManager;
298
299         /** The timer manager. */
300         GHOST_TimerManager* m_timerManager;
301
302         /** The window manager. */
303         GHOST_WindowManager* m_windowManager;
304
305         /** The event manager. */
306         GHOST_EventManager* m_eventManager;
307
308         /** Prints all the events. */
309 #ifdef GHOST_DEBUG
310         GHOST_EventPrinter m_eventPrinter;
311 #endif // GHOST_DEBUG
312
313         /** Settings of the display before the display went fullscreen. */
314         GHOST_DisplaySetting m_preFullScreenSetting;
315 };
316
317 inline GHOST_TimerManager* GHOST_System::getTimerManager() const
318 {
319         return m_timerManager;
320 }
321
322 inline GHOST_EventManager* GHOST_System::getEventManager() const
323 {
324         return m_eventManager;
325 }
326
327 inline GHOST_WindowManager* GHOST_System::getWindowManager() const
328 {
329         return m_windowManager;
330 }
331
332 #endif // _GHOST_SYSTEM_H_
333