COLLADA: merge from trunk -r 24390:24522.
[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 class GHOST_NDOFManager;
52
53 /**
54  * Implementation of platform independent functionality of the GHOST_ISystem
55  * interface.
56  * GHOST_System is an abstract class because not all methods of GHOST_ISystem
57  * are implemented.
58  * @see GHOST_ISystem.
59  * @author      Maarten Gribnau
60  * @date        May 7, 2001
61  */
62 class GHOST_System : public GHOST_ISystem
63 {
64 protected:
65         /**
66          * Constructor.
67          * Protected default constructor to force use of static createSystem member.
68          */
69         GHOST_System();
70
71         /**
72          * Destructor.
73          * Protected default constructor to force use of static dispose member.
74          */
75         virtual ~GHOST_System();
76
77 public:
78         /***************************************************************************************
79          ** Time(r) functionality
80          ***************************************************************************************/
81
82         /**
83          * Returns the system time.
84          * Returns the number of milliseconds since the start of the system process.
85          * Based on ANSI clock() routine.
86          * @return The number of milliseconds.
87          */
88         virtual GHOST_TUns64 getMilliSeconds() const;
89
90         /**
91          * Installs a timer.
92          * Note that, on most operating systems, messages need to be processed in order 
93          * for the timer callbacks to be invoked.
94          * @param delay         The time to wait for the first call to the timerProc (in milliseconds)
95          * @param interval      The interval between calls to the timerProc
96          * @param timerProc     The callback invoked when the interval expires,
97          * @param userData      Placeholder for user data.
98          * @return A timer task (0 if timer task installation failed).
99          */
100         virtual GHOST_ITimerTask* installTimer(GHOST_TUns64 delay, GHOST_TUns64 interval, GHOST_TimerProcPtr timerProc, GHOST_TUserDataPtr userData = 0);
101
102         /**
103          * Removes a timer.
104          * @param timerTask Timer task to be removed.
105          * @return Indication of success.
106          */
107         virtual GHOST_TSuccess removeTimer(GHOST_ITimerTask* timerTask);
108
109         /***************************************************************************************
110          ** Display/window management functionality
111          ***************************************************************************************/
112         
113         /**
114          * Inherited from GHOST_ISystem but left pure virtual
115          *
116          * virtual      GHOST_TUns8 getNumDisplays() const = 0;
117          * virtual void getMainDisplayDimensions(...) const = 0;
118          * virtual GHOST_IWindow* createWindow(..)
119          */
120
121         /**
122          * Dispose a window.
123          * @param       window Pointer to the window to be disposed.
124          * @return      Indication of success.
125          */
126         virtual GHOST_TSuccess disposeWindow(GHOST_IWindow* window);
127
128         /**
129          * Returns whether a window is valid.
130          * @param       window Pointer to the window to be checked.
131          * @return      Indication of validity.
132          */
133         virtual bool validWindow(GHOST_IWindow* window);
134
135         /**
136          * Begins full screen mode.
137          * @param setting       The new setting of the display.
138          * @param window        Window displayed in full screen.
139          * @param stereoVisual  Stereo visual for quad buffered stereo.
140          * This window is invalid after full screen has been ended.
141          * @return      Indication of success.
142          */
143         virtual GHOST_TSuccess beginFullScreen(const GHOST_DisplaySetting& setting, GHOST_IWindow** window,
144                 const bool stereoVisual);
145
146         /**
147          * Ends full screen mode.
148          * @return      Indication of success.
149          */
150         virtual GHOST_TSuccess endFullScreen(void);
151
152         /**
153          * Returns current full screen mode status.
154          * @return The current status.
155          */
156         virtual bool getFullScreen(void);
157
158
159         /***************************************************************************************
160          ** Event management functionality
161          ***************************************************************************************/
162
163         /**
164          * Inherited from GHOST_ISystem but left pure virtual
165          *
166          *      virtual bool processEvents(bool waitForEvent) = 0;
167          */
168
169
170
171         /**
172          * Dispatches all the events on the stack.
173          * The event stack will be empty afterwards.
174          * @return Indication as to whether any of the consumers handled the events.
175          */
176         virtual bool dispatchEvents();
177
178         /**
179          * Adds the given event consumer to our list.
180          * @param consumer The event consumer to add.
181          * @return Indication of success.
182          */
183         virtual GHOST_TSuccess addEventConsumer(GHOST_IEventConsumer* consumer);
184
185
186
187         /***************************************************************************************
188          ** N-degree of freedom devcice management functionality
189          ***************************************************************************************/
190
191         /** Inherited from GHOST_ISystem
192      *  Opens the N-degree of freedom device manager
193          * return 0 if device found, 1 otherwise
194      */
195     virtual int openNDOF(GHOST_IWindow* w,        
196         GHOST_NDOFLibraryInit_fp setNdofLibraryInit, 
197         GHOST_NDOFLibraryShutdown_fp setNdofLibraryShutdown,
198         GHOST_NDOFDeviceOpen_fp setNdofDeviceOpen);
199         
200 // original patch only        
201 //        GHOST_NDOFEventHandler_fp setNdofEventHandler);
202
203
204
205
206         /***************************************************************************************
207          ** Cursor management functionality
208          ***************************************************************************************/
209
210         /** Inherited from GHOST_ISystem but left pure virtual
211          *      GHOST_TSuccess getCursorPosition(GHOST_TInt32& x, GHOST_TInt32& y) const = 0;   
212          *  GHOST_TSuccess setCursorPosition(GHOST_TInt32 x, GHOST_TInt32 y)
213          */
214
215         /***************************************************************************************
216          ** Access to mouse button and keyboard states.
217          ***************************************************************************************/
218
219         /**
220          * Returns the state of a modifier key (ouside the message queue).
221          * @param mask          The modifier key state to retrieve.
222          * @param isDown        The state of a modifier key (true == pressed).
223          * @return                      Indication of success.
224          */
225         virtual GHOST_TSuccess getModifierKeyState(GHOST_TModifierKeyMask mask, bool& isDown) const;
226
227         /**
228          * Returns the state of a mouse button (ouside the message queue).
229          * @param mask          The button state to retrieve.
230          * @param isDown        Button state.
231          * @return                      Indication of success.
232          */
233         virtual GHOST_TSuccess getButtonState(GHOST_TButtonMask mask, bool& isDown) const;
234         
235         /***************************************************************************************
236          ** Drag'n'drop operations
237          ***************************************************************************************/
238         
239         /**
240          * Tells if the ongoing drag'n'drop object can be accepted upon mouse drop
241          */
242         virtual void setAcceptDragOperation(bool canAccept);
243         
244         /**
245          * Returns acceptance of the dropped object
246          * Usually called by the "object dropped" event handling function
247          */
248         virtual bool canAcceptDragOperation() const;
249
250         /***************************************************************************************
251          ** Other (internal) functionality.
252          ***************************************************************************************/
253
254         /**
255          * Pushes an event on the stack.
256          * To dispatch it, call dispatchEvent() or dispatchEvents().
257          * Do not delete the event!
258          * @param event The event to push on the stack.
259          */
260         virtual GHOST_TSuccess pushEvent(GHOST_IEvent* event);
261
262         /**
263          * Returns the timer manager.
264          * @return The timer manager.
265          */
266         inline virtual GHOST_TimerManager* getTimerManager() const;
267
268         /**
269          * Returns a pointer to our event manager.
270          * @return A pointer to our event manager.
271          */
272         virtual inline GHOST_EventManager* getEventManager() const;
273
274         /**
275          * Returns a pointer to our window manager.
276          * @return A pointer to our window manager.
277          */
278         virtual inline GHOST_WindowManager* getWindowManager() const;
279
280         /**
281          * Returns a pointer to our n-degree of freedeom manager.
282          * @return A pointer to our n-degree of freedeom manager.
283          */
284         virtual inline GHOST_NDOFManager* getNDOFManager() const;
285
286         /**
287          * Returns the state of all modifier keys.
288          * @param keys  The state of all modifier keys (true == pressed).
289          * @return              Indication of success.
290          */
291         virtual GHOST_TSuccess getModifierKeys(GHOST_ModifierKeys& keys) const = 0;
292
293         /**
294          * Returns the state of the mouse buttons (ouside the message queue).
295          * @param buttons       The state of the buttons.
296          * @return                      Indication of success.
297          */
298         virtual GHOST_TSuccess getButtons(GHOST_Buttons& buttons) const = 0;
299
300         /**
301          * Returns the selection buffer
302          * @param selection             Only used on X11
303          * @return                              Returns the clipboard data
304          *
305          */
306          virtual GHOST_TUns8* getClipboard(bool selection) const = 0;
307           
308           /**
309            * Put data to the Clipboard
310            * @param buffer              The buffer to copy to the clipboard
311            * @param selection   The clipboard to copy too only used on X11
312            */
313           virtual void putClipboard(GHOST_TInt8 *buffer, bool selection) const = 0;
314
315 protected:
316         /**
317          * Initialize the system.
318          * @return Indication of success.
319          */
320         virtual GHOST_TSuccess init();
321
322         /**
323          * Shut the system down.
324          * @return Indication of success.
325          */
326         virtual GHOST_TSuccess exit();
327
328         /**
329          * Creates a fullscreen window.
330          * @param window The window created.
331          * @return Indication of success.
332          */
333         virtual GHOST_TSuccess createFullScreenWindow(GHOST_Window** window,
334                 const bool stereoVisual);
335
336         /** The display manager (platform dependant). */
337         GHOST_DisplayManager* m_displayManager;
338
339         /** The timer manager. */
340         GHOST_TimerManager* m_timerManager;
341
342         /** The window manager. */
343         GHOST_WindowManager* m_windowManager;
344
345         /** The event manager. */
346         GHOST_EventManager* m_eventManager;
347
348     /** The N-degree of freedom device manager */
349     GHOST_NDOFManager* m_ndofManager;
350         
351         /** The acceptance of the "drop candidate" of the current drag'n'drop operation */
352         bool m_canAcceptDragOperation;
353
354         /** Prints all the events. */
355 #ifdef GHOST_DEBUG
356         GHOST_EventPrinter* m_eventPrinter;
357 #endif // GHOST_DEBUG
358
359         /** Settings of the display before the display went fullscreen. */
360         GHOST_DisplaySetting m_preFullScreenSetting;
361 };
362
363 inline GHOST_TimerManager* GHOST_System::getTimerManager() const
364 {
365         return m_timerManager;
366 }
367
368 inline GHOST_EventManager* GHOST_System::getEventManager() const
369 {
370         return m_eventManager;
371 }
372
373 inline GHOST_WindowManager* GHOST_System::getWindowManager() const
374 {
375         return m_windowManager;
376 }
377
378 inline GHOST_NDOFManager* GHOST_System::getNDOFManager() const
379 {
380         return m_ndofManager;
381 }
382
383 #endif // _GHOST_SYSTEM_H_
384