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