style cleanup: ghost headers
[blender.git] / intern / ghost / intern / GHOST_Window.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file ghost/intern/GHOST_Window.h
29  *  \ingroup GHOST
30  * Declaration of GHOST_Window class.
31  */
32
33 #ifndef __GHOST_WINDOW_H__
34 #define __GHOST_WINDOW_H__
35
36 #include "GHOST_IWindow.h"
37
38 class STR_String;
39
40 /**
41  * Platform independent implementation of GHOST_IWindow.
42  * Dimensions are given in screen coordinates that are relative to the 
43  * upper-left corner of the screen.
44  * Implements part of the GHOST_IWindow interface and adds some methods to
45  * be implemented by childs of this class.
46  * @author      Maarten Gribnau
47  * @date        May 7, 2001
48  */
49 class GHOST_Window : public GHOST_IWindow
50 {
51 public:
52         /**
53          * @section Interface inherited from GHOST_IWindow left for derived class
54          * implementation.
55          * virtual      bool getValid() const = 0;
56          * virtual void setTitle(const STR_String& title) = 0;
57          * virtual void getTitle(STR_String& title) const = 0;
58          * virtual      void getWindowBounds(GHOST_Rect& bounds) const = 0;
59          * virtual      void getClientBounds(GHOST_Rect& bounds) const = 0;
60          * virtual      GHOST_TSuccess setClientWidth(GHOST_TUns32 width) = 0;
61          * virtual      GHOST_TSuccess setClientHeight(GHOST_TUns32 height) = 0;
62          * virtual      GHOST_TSuccess setClientSize(GHOST_TUns32 width, GHOST_TUns32 height) = 0;
63          * virtual      void screenToClient(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
64          * virtual      void clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
65          * virtual GHOST_TWindowState getState() const = 0;
66          * virtual GHOST_TSuccess setState(GHOST_TWindowState state) = 0;
67          * virtual GHOST_TWindowOrder getOrder(void) = 0;
68          * virtual GHOST_TSuccess setOrder(GHOST_TWindowOrder order) = 0;
69          * virtual GHOST_TSuccess swapBuffers() = 0;
70          * virtual GHOST_TSuccess activateDrawingContext() = 0;
71          * virtual GHOST_TSuccess invalidate() = 0;
72          */
73
74         /**
75          * Constructor.
76          * Creates a new window and opens it.
77          * To check if the window was created properly, use the getValid() method.
78          * @param width                         The width the window.
79          * @param heigh                         The height the window.
80          * @param state                         The state the window is initially opened with.
81          * @param type                          The type of drawing context installed in this window.
82          * @param stereoVisual          Stereo visual for quad buffered stereo.
83          * @param numOfAASamples        Number of samples used for AA (zero if no AA)
84          */
85         GHOST_Window(
86             GHOST_TUns32 width,
87             GHOST_TUns32 height,
88             GHOST_TWindowState state,
89             GHOST_TDrawingContextType type = GHOST_kDrawingContextTypeNone,
90             const bool stereoVisual = false,
91             const GHOST_TUns16 numOfAASamples = 0);
92
93         /**
94          * @section Interface inherited from GHOST_IWindow left for derived class
95          * implementation.
96          * virtual      bool getValid() const = 0;
97          * virtual void setTitle(const STR_String& title) = 0;
98          * virtual void getTitle(STR_String& title) const = 0;
99          * virtual      void getWindowBounds(GHOST_Rect& bounds) const = 0;
100          * virtual      void getClientBounds(GHOST_Rect& bounds) const = 0;
101          * virtual      GHOST_TSuccess setClientWidth(GHOST_TUns32 width) = 0;
102          * virtual      GHOST_TSuccess setClientHeight(GHOST_TUns32 height) = 0;
103          * virtual      GHOST_TSuccess setClientSize(GHOST_TUns32 width, GHOST_TUns32 height) = 0;
104          * virtual      void screenToClient(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
105          * virtual      void clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
106          * virtual GHOST_TWindowState getState() const = 0;
107          * virtual GHOST_TSuccess setState(GHOST_TWindowState state) = 0;
108          * virtual GHOST_TSuccess setOrder(GHOST_TWindowOrder order) = 0;
109          * virtual GHOST_TSuccess swapBuffers() = 0;
110          * virtual GHOST_TSuccess activateDrawingContext() = 0;
111          * virtual GHOST_TSuccess invalidate() = 0;
112          */
113          
114         /**
115          * Destructor.
116          * Closes the window and disposes resources allocated.
117          */
118         virtual ~GHOST_Window();
119
120         /**
121          * Returns the associated OS object/handle
122          * @return The associated OS object/handle
123          */
124         virtual void *getOSWindow() const;
125         
126         /**
127          * Returns the current cursor shape.
128          * @return      The current cursor shape.
129          */
130         inline virtual GHOST_TStandardCursor getCursorShape() const;
131
132         /**
133          * Set the shape of the cursor.
134          * @param       cursor  The new cursor shape type id.
135          * @return      Indication of success.
136          */
137         virtual GHOST_TSuccess setCursorShape(GHOST_TStandardCursor cursorShape);
138
139         /**
140          * Set the shape of the cursor to a custom cursor.
141          * @param       bitmap  The bitmap data for the cursor.
142          * @param       mask    The mask data for the cursor.
143          * @param       hotX    The X coordinate of the cursor hotspot.
144          * @param       hotY    The Y coordinate of the cursor hotspot.
145          * @return      Indication of success.
146          */
147         virtual GHOST_TSuccess setCustomCursorShape(GHOST_TUns8 bitmap[16][2], 
148                                                     GHOST_TUns8 mask[16][2],
149                                                     int hotX,
150                                                     int hotY);
151                                                                                                 
152         virtual GHOST_TSuccess setCustomCursorShape(GHOST_TUns8 *bitmap, 
153                                                     GHOST_TUns8 *mask,
154                                                     int sizex, int sizey,
155                                                     int hotX,  int hotY,
156                                                     int fg_color, int bg_color);
157         
158         /**
159          * Returns the visibility state of the cursor.
160          * @return      The visibility state of the cursor.
161          */
162         inline virtual bool getCursorVisibility() const;
163         inline virtual GHOST_TGrabCursorMode getCursorGrabMode() const;
164         inline virtual bool getCursorGrabModeIsWarp() const;
165         inline virtual void getCursorGrabInitPos(GHOST_TInt32 &x, GHOST_TInt32 &y) const;
166         inline virtual void getCursorGrabAccum(GHOST_TInt32 &x, GHOST_TInt32 &y) const;
167         inline virtual void setCursorGrabAccum(GHOST_TInt32 x, GHOST_TInt32 y);
168
169         /**
170          * Shows or hides the cursor.
171          * @param       visible The new visibility state of the cursor.
172          * @return      Indication of success.
173          */
174         virtual GHOST_TSuccess setCursorVisibility(bool visible);
175
176         /**
177          * Sets the cursor grab.
178          * @param       mode The new grab state of the cursor.
179          * @return      Indication of success.
180          */
181         virtual GHOST_TSuccess setCursorGrab(GHOST_TGrabCursorMode mode, GHOST_Rect *bounds);
182
183         /**
184          * Gets the cursor grab region, if unset the window is used.
185          * reset when grab is disabled.
186          */
187         virtual GHOST_TSuccess getCursorGrabBounds(GHOST_Rect& bounds);
188
189         /**
190          * Sets the progress bar value displayed in the window/application icon
191          * @param progress The progress % (0.0 to 1.0)
192          */
193         virtual GHOST_TSuccess setProgressBar(float progress) {
194                 return GHOST_kFailure;
195         };
196         
197         /**
198          * Hides the progress bar in the icon
199          */
200         virtual GHOST_TSuccess endProgressBar() {
201                 return GHOST_kFailure;
202         };
203         
204         /**
205          * Tells if the ongoing drag'n'drop object can be accepted upon mouse drop
206          */
207         virtual void setAcceptDragOperation(bool canAccept);
208         
209         /**
210          * Returns acceptance of the dropped object
211          * Usually called by the "object dropped" event handling function
212          */
213         virtual bool canAcceptDragOperation() const;
214         
215         /**
216          * Sets the window "modified" status, indicating unsaved changes
217          * @param isUnsavedChanges Unsaved changes or not
218          * @return Indication of success.
219          */
220         virtual GHOST_TSuccess setModifiedState(bool isUnsavedChanges);
221         
222         /**
223          * Gets the window "modified" status, indicating unsaved changes
224          * @return True if there are unsaved changes
225          */
226         virtual bool getModifiedState();
227         
228         /**
229          * Returns the type of drawing context used in this window.
230          * @return The current type of drawing context.
231          */
232         inline virtual GHOST_TDrawingContextType getDrawingContextType();
233
234         /**
235          * Tries to install a rendering context in this window.
236          * Child classes do not need to overload this method.
237          * They should overload the installDrawingContext and removeDrawingContext instead.
238          * @param type  The type of rendering context installed.
239          * @return Indication as to whether installation has succeeded.
240          */
241         virtual GHOST_TSuccess setDrawingContextType(GHOST_TDrawingContextType type);
242
243         /**
244          * Returns the window user data.
245          * @return The window user data.
246          */
247         inline virtual GHOST_TUserDataPtr getUserData() const
248         {
249                 return m_userData;
250         }
251         
252         /**
253          * Changes the window user data.
254          * @param data The window user data.
255          */
256         virtual void setUserData(const GHOST_TUserDataPtr userData)
257         {
258                 m_userData = userData;
259         }
260
261 protected:
262         /**
263          * Tries to install a rendering context in this window.
264          * @param type  The type of rendering context installed.
265          * @return Indication as to whether installation has succeeded.
266          */
267         virtual GHOST_TSuccess installDrawingContext(GHOST_TDrawingContextType type) = 0;
268
269         /**
270          * Removes the current drawing context.
271          * @return Indication as to whether removal has succeeded.
272          */
273         virtual GHOST_TSuccess removeDrawingContext() = 0;
274
275         /**
276          * Sets the cursor visibility on the window using
277          * native window system calls.
278          */
279         virtual GHOST_TSuccess setWindowCursorVisibility(bool visible) = 0;
280
281         /**
282          * Sets the cursor grab on the window using
283          * native window system calls.
284          */
285         virtual GHOST_TSuccess setWindowCursorGrab(GHOST_TGrabCursorMode mode) {
286                 return GHOST_kSuccess;
287         };
288         
289         /**
290          * Sets the cursor shape on the window using
291          * native window system calls.
292          */
293         virtual GHOST_TSuccess setWindowCursorShape(GHOST_TStandardCursor shape) = 0;
294
295         /**
296          * Sets the cursor shape on the window using
297          * native window system calls.
298          */
299         virtual GHOST_TSuccess setWindowCustomCursorShape(GHOST_TUns8 bitmap[16][2],
300                                                           GHOST_TUns8 mask[16][2],
301                                                           int hotX, int hotY) = 0;
302         
303         virtual GHOST_TSuccess setWindowCustomCursorShape(GHOST_TUns8 *bitmap, GHOST_TUns8 *mask, 
304                                                           int szx, int szy, int hotX, int hotY, int fg, int bg) = 0;
305         /** The the of drawing context installed in this window. */
306         GHOST_TDrawingContextType m_drawingContextType;
307         
308         /** The window user data */
309         GHOST_TUserDataPtr m_userData;
310
311         /** The current visibility of the cursor */
312         bool m_cursorVisible;
313
314         /** The current grabbed state of the cursor */
315         GHOST_TGrabCursorMode m_cursorGrab;
316
317         /** Initial grab location. */
318         GHOST_TInt32 m_cursorGrabInitPos[2];
319
320         /** Accumulated offset from m_cursorGrabInitPos. */
321         GHOST_TInt32 m_cursorGrabAccumPos[2];
322
323         /** Wrap the cursor within this region. */
324         GHOST_Rect m_cursorGrabBounds;
325
326         /** The current shape of the cursor */
327         GHOST_TStandardCursor m_cursorShape;
328     
329         /** The presence of progress indicator with the application icon */
330         bool m_progressBarVisible;
331         
332         /** The acceptance of the "drop candidate" of the current drag'n'drop operation */
333         bool m_canAcceptDragOperation;
334         
335         /** Modified state : are there unsaved changes */
336         bool m_isUnsavedChanges;
337         
338         /** Stores wether this is a full screen window. */
339         bool m_fullScreen;
340
341         /** Stereo visual created. Only necessary for 'real' stereo support,
342          *  ie quad buffered stereo. This is not always possible, depends on
343          *  the graphics h/w
344          */
345         bool m_stereoVisual;
346         
347         /** Number of samples used in anti-aliasing, set to 0 if no AA **/
348         GHOST_TUns16 m_numOfAASamples;
349
350         /** Full-screen width */
351         GHOST_TUns32 m_fullScreenWidth;
352         /** Full-screen height */
353         GHOST_TUns32 m_fullScreenHeight;
354 };
355
356
357 inline GHOST_TDrawingContextType GHOST_Window::getDrawingContextType()
358 {
359         return m_drawingContextType;
360 }
361
362 inline bool GHOST_Window::getCursorVisibility() const
363 {
364         return m_cursorVisible;
365 }
366
367 inline GHOST_TGrabCursorMode GHOST_Window::getCursorGrabMode() const
368 {
369         return m_cursorGrab;
370 }
371
372 inline bool GHOST_Window::getCursorGrabModeIsWarp() const
373 {
374         return (m_cursorGrab == GHOST_kGrabWrap) ||
375                (m_cursorGrab == GHOST_kGrabHide);
376 }
377
378 inline void GHOST_Window::getCursorGrabInitPos(GHOST_TInt32 &x, GHOST_TInt32 &y) const
379 {
380         x = m_cursorGrabInitPos[0];
381         y = m_cursorGrabInitPos[1];
382 }
383
384 inline void GHOST_Window::getCursorGrabAccum(GHOST_TInt32 &x, GHOST_TInt32 &y) const
385 {
386         x = m_cursorGrabAccumPos[0];
387         y = m_cursorGrabAccumPos[1];
388 }
389
390 inline void GHOST_Window::setCursorGrabAccum(GHOST_TInt32 x, GHOST_TInt32 y)
391 {
392         m_cursorGrabAccumPos[0] = x;
393         m_cursorGrabAccumPos[1] = y;
394 }
395
396 inline GHOST_TStandardCursor GHOST_Window::getCursorShape() const
397 {
398         return m_cursorShape;
399 }
400
401 #endif // _GHOST_WINDOW_H
402