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