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