Merged revision(s) 58682-58770 from trunk/blender into soc-2013-dingto.
[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 setSwapInterval() = 0;
71          * virtual int getSwapInterval() = 0;
72          * virtual GHOST_TSuccess activateDrawingContext() = 0;
73          * virtual GHOST_TSuccess invalidate() = 0;
74          */
75
76         /**
77          * Constructor.
78          * Creates a new window and opens it.
79          * To check if the window was created properly, use the getValid() method.
80          * \param width                         The width the window.
81          * \param heigh                         The height the window.
82          * \param state                         The state the window is initially opened with.
83          * \param type                          The type of drawing context installed in this window.
84          * \param stereoVisual          Stereo visual for quad buffered stereo.
85          * \param exclusive                     Use to show the window ontop and ignore others
86          *                                                      (used fullscreen).
87          * \param numOfAASamples        Number of samples used for AA (zero if no AA)
88          */
89         GHOST_Window(
90             GHOST_TUns32 width,
91             GHOST_TUns32 height,
92             GHOST_TWindowState state,
93             GHOST_TDrawingContextType type = GHOST_kDrawingContextTypeNone,
94             const bool stereoVisual = false,
95             const bool exclusive = false,
96             const GHOST_TUns16 numOfAASamples = 0);
97
98         /**
99          * \section Interface inherited from GHOST_IWindow left for derived class
100          * implementation.
101          * virtual      bool getValid() const = 0;
102          * virtual void setTitle(const STR_String& title) = 0;
103          * virtual void getTitle(STR_String& title) const = 0;
104          * virtual      void getWindowBounds(GHOST_Rect& bounds) const = 0;
105          * virtual      void getClientBounds(GHOST_Rect& bounds) const = 0;
106          * virtual      GHOST_TSuccess setClientWidth(GHOST_TUns32 width) = 0;
107          * virtual      GHOST_TSuccess setClientHeight(GHOST_TUns32 height) = 0;
108          * virtual      GHOST_TSuccess setClientSize(GHOST_TUns32 width, GHOST_TUns32 height) = 0;
109          * virtual      void screenToClient(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
110          * virtual      void clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
111          * virtual GHOST_TWindowState getState() const = 0;
112          * virtual GHOST_TSuccess setState(GHOST_TWindowState state) = 0;
113          * virtual GHOST_TSuccess setOrder(GHOST_TWindowOrder order) = 0;
114          * virtual GHOST_TSuccess swapBuffers() = 0;
115          * virtual GHOST_TSuccess setSwapInterval() = 0;
116          * virtual int getSwapInterval() = 0;
117          * virtual GHOST_TSuccess activateDrawingContext() = 0;
118          * virtual GHOST_TSuccess invalidate() = 0;
119          */
120          
121         /**
122          * Destructor.
123          * Closes the window and disposes resources allocated.
124          */
125         virtual ~GHOST_Window();
126
127         /**
128          * Returns the associated OS object/handle
129          * \return The associated OS object/handle
130          */
131         virtual void *getOSWindow() const;
132         
133         /**
134          * Returns the current cursor shape.
135          * \return      The current cursor shape.
136          */
137         inline virtual GHOST_TStandardCursor getCursorShape() const;
138
139         /**
140          * Set the shape of the cursor.
141          * \param       cursor  The new cursor shape type id.
142          * \return      Indication of success.
143          */
144         virtual GHOST_TSuccess setCursorShape(GHOST_TStandardCursor cursorShape);
145
146         /**
147          * Set the shape of the cursor to a custom cursor.
148          * \param       bitmap  The bitmap data for the cursor.
149          * \param       mask    The mask data for the cursor.
150          * \param       hotX    The X coordinate of the cursor hotspot.
151          * \param       hotY    The Y coordinate of the cursor hotspot.
152          * \return      Indication of success.
153          */
154         virtual GHOST_TSuccess setCustomCursorShape(GHOST_TUns8 bitmap[16][2], 
155                                                     GHOST_TUns8 mask[16][2],
156                                                     int hotX,
157                                                     int hotY);
158                                                                                                 
159         virtual GHOST_TSuccess setCustomCursorShape(GHOST_TUns8 *bitmap, 
160                                                     GHOST_TUns8 *mask,
161                                                     int sizex, int sizey,
162                                                     int hotX,  int hotY,
163                                                     int fg_color, int bg_color);
164         
165         /**
166          * Returns the visibility state of the cursor.
167          * \return      The visibility state of the cursor.
168          */
169         inline virtual bool getCursorVisibility() const;
170         inline virtual GHOST_TGrabCursorMode getCursorGrabMode() const;
171         inline virtual bool getCursorGrabModeIsWarp() const;
172         inline virtual void getCursorGrabInitPos(GHOST_TInt32 &x, GHOST_TInt32 &y) const;
173         inline virtual void getCursorGrabAccum(GHOST_TInt32 &x, GHOST_TInt32 &y) const;
174         inline virtual void setCursorGrabAccum(GHOST_TInt32 x, GHOST_TInt32 y);
175
176         /**
177          * Shows or hides the cursor.
178          * \param       visible The new visibility state of the cursor.
179          * \return      Indication of success.
180          */
181         virtual GHOST_TSuccess setCursorVisibility(bool visible);
182
183         /**
184          * Sets the cursor grab.
185          * \param       mode The new grab state of the cursor.
186          * \return      Indication of success.
187          */
188         virtual GHOST_TSuccess setCursorGrab(GHOST_TGrabCursorMode mode, GHOST_Rect *bounds, GHOST_TInt32 mouse_ungrab_xy[2]);
189
190         /**
191          * Gets the cursor grab region, if unset the window is used.
192          * reset when grab is disabled.
193          */
194         virtual GHOST_TSuccess getCursorGrabBounds(GHOST_Rect& bounds);
195
196         /**
197          * Sets the progress bar value displayed in the window/application icon
198          * \param progress The progress % (0.0 to 1.0)
199          */
200         virtual GHOST_TSuccess setProgressBar(float progress) {
201                 return GHOST_kFailure;
202         }
203         
204         /**
205          * Hides the progress bar in the icon
206          */
207         virtual GHOST_TSuccess endProgressBar() {
208                 return GHOST_kFailure;
209         }
210         
211         /**
212          * Sets the swap interval for swapBuffers.
213          * \param interval The swap interval to use.
214          * \return A boolean success indicator.
215          */
216         virtual GHOST_TSuccess setSwapInterval(int interval) {
217                 return GHOST_kFailure;
218         }
219         
220         /**
221          * Gets the current swap interval for swapBuffers.
222          * \return An integer.
223          */
224         virtual int getSwapInterval() {
225                 return 0;
226         }
227         
228         /**
229          * Tells if the ongoing drag'n'drop object can be accepted upon mouse drop
230          */
231         virtual void setAcceptDragOperation(bool canAccept);
232         
233         /**
234          * Returns acceptance of the dropped object
235          * Usually called by the "object dropped" event handling function
236          */
237         virtual bool canAcceptDragOperation() const;
238         
239         /**
240          * Sets the window "modified" status, indicating unsaved changes
241          * \param isUnsavedChanges Unsaved changes or not
242          * \return Indication of success.
243          */
244         virtual GHOST_TSuccess setModifiedState(bool isUnsavedChanges);
245         
246         /**
247          * Gets the window "modified" status, indicating unsaved changes
248          * \return True if there are unsaved changes
249          */
250         virtual bool getModifiedState();
251         
252         /**
253          * Returns the type of drawing context used in this window.
254          * \return The current type of drawing context.
255          */
256         inline virtual GHOST_TDrawingContextType getDrawingContextType();
257
258         /**
259          * Tries to install a rendering context in this window.
260          * Child classes do not need to overload this method.
261          * They should overload the installDrawingContext and removeDrawingContext instead.
262          * \param type  The type of rendering context installed.
263          * \return Indication as to whether installation has succeeded.
264          */
265         virtual GHOST_TSuccess setDrawingContextType(GHOST_TDrawingContextType type);
266
267         /**
268          * Returns the window user data.
269          * \return The window user data.
270          */
271         inline virtual GHOST_TUserDataPtr getUserData() const
272         {
273                 return m_userData;
274         }
275         
276         /**
277          * Changes the window user data.
278          * \param data The window user data.
279          */
280         virtual void setUserData(const GHOST_TUserDataPtr userData)
281         {
282                 m_userData = userData;
283         }
284         
285         virtual float getNativePixelSize(void)
286         {
287                 if (m_nativePixelSize > 0.0f)
288                         return m_nativePixelSize;
289                 return 1.0f;
290         }
291
292 protected:
293         /**
294          * Tries to install a rendering context in this window.
295          * \param type  The type of rendering context installed.
296          * \return Indication as to whether installation has succeeded.
297          */
298         virtual GHOST_TSuccess installDrawingContext(GHOST_TDrawingContextType type) = 0;
299
300         /**
301          * Removes the current drawing context.
302          * \return Indication as to whether removal has succeeded.
303          */
304         virtual GHOST_TSuccess removeDrawingContext() = 0;
305
306         /**
307          * Sets the cursor visibility on the window using
308          * native window system calls.
309          */
310         virtual GHOST_TSuccess setWindowCursorVisibility(bool visible) = 0;
311
312         /**
313          * Sets the cursor grab on the window using
314          * native window system calls.
315          */
316         virtual GHOST_TSuccess setWindowCursorGrab(GHOST_TGrabCursorMode mode) {
317                 return GHOST_kSuccess;
318         }
319         
320         /**
321          * Sets the cursor shape on the window using
322          * native window system calls.
323          */
324         virtual GHOST_TSuccess setWindowCursorShape(GHOST_TStandardCursor shape) = 0;
325
326         /**
327          * Sets the cursor shape on the window using
328          * native window system calls.
329          */
330         virtual GHOST_TSuccess setWindowCustomCursorShape(GHOST_TUns8 bitmap[16][2],
331                                                           GHOST_TUns8 mask[16][2],
332                                                           int hotX, int hotY) = 0;
333         
334         virtual GHOST_TSuccess setWindowCustomCursorShape(GHOST_TUns8 *bitmap, GHOST_TUns8 *mask, 
335                                                           int szx, int szy, int hotX, int hotY, int fg, int bg) = 0;
336         /** The the of drawing context installed in this window. */
337         GHOST_TDrawingContextType m_drawingContextType;
338         
339         /** The window user data */
340         GHOST_TUserDataPtr m_userData;
341
342         /** The current visibility of the cursor */
343         bool m_cursorVisible;
344
345         /** The current grabbed state of the cursor */
346         GHOST_TGrabCursorMode m_cursorGrab;
347
348         /** Initial grab location. */
349         GHOST_TInt32 m_cursorGrabInitPos[2];
350
351         /** Accumulated offset from m_cursorGrabInitPos. */
352         GHOST_TInt32 m_cursorGrabAccumPos[2];
353
354         /** Wrap the cursor within this region. */
355         GHOST_Rect m_cursorGrabBounds;
356
357         /** The current shape of the cursor */
358         GHOST_TStandardCursor m_cursorShape;
359     
360         /** The presence of progress indicator with the application icon */
361         bool m_progressBarVisible;
362         
363         /** The acceptance of the "drop candidate" of the current drag'n'drop operation */
364         bool m_canAcceptDragOperation;
365         
366         /** Modified state : are there unsaved changes */
367         bool m_isUnsavedChanges;
368         
369         /** Stores whether this is a full screen window. */
370         bool m_fullScreen;
371
372         /** Stereo visual created. Only necessary for 'real' stereo support,
373          *  ie quad buffered stereo. This is not always possible, depends on
374          *  the graphics h/w
375          */
376         bool m_stereoVisual;
377         
378         /** Number of samples used in anti-aliasing, set to 0 if no AA **/
379         GHOST_TUns16 m_numOfAASamples;
380
381         /** Full-screen width */
382         GHOST_TUns32 m_fullScreenWidth;
383         /** Full-screen height */
384         GHOST_TUns32 m_fullScreenHeight;
385         
386         /* OSX only, retina screens */
387         float m_nativePixelSize;
388 };
389
390
391 inline GHOST_TDrawingContextType GHOST_Window::getDrawingContextType()
392 {
393         return m_drawingContextType;
394 }
395
396 inline bool GHOST_Window::getCursorVisibility() const
397 {
398         return m_cursorVisible;
399 }
400
401 inline GHOST_TGrabCursorMode GHOST_Window::getCursorGrabMode() const
402 {
403         return m_cursorGrab;
404 }
405
406 inline bool GHOST_Window::getCursorGrabModeIsWarp() const
407 {
408         return (m_cursorGrab == GHOST_kGrabWrap) ||
409                (m_cursorGrab == GHOST_kGrabHide);
410 }
411
412 inline void GHOST_Window::getCursorGrabInitPos(GHOST_TInt32 &x, GHOST_TInt32 &y) const
413 {
414         x = m_cursorGrabInitPos[0];
415         y = m_cursorGrabInitPos[1];
416 }
417
418 inline void GHOST_Window::getCursorGrabAccum(GHOST_TInt32 &x, GHOST_TInt32 &y) const
419 {
420         x = m_cursorGrabAccumPos[0];
421         y = m_cursorGrabAccumPos[1];
422 }
423
424 inline void GHOST_Window::setCursorGrabAccum(GHOST_TInt32 x, GHOST_TInt32 y)
425 {
426         m_cursorGrabAccumPos[0] = x;
427         m_cursorGrabAccumPos[1] = y;
428 }
429
430 inline GHOST_TStandardCursor GHOST_Window::getCursorShape() const
431 {
432         return m_cursorShape;
433 }
434
435 #endif // _GHOST_WINDOW_H
436