Merge branch 'blender2.7'
[blender.git] / intern / ghost / intern / GHOST_Window.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file \ingroup GHOST
21  * Declaration of GHOST_Window class.
22  */
23
24 #ifndef __GHOST_WINDOW_H__
25 #define __GHOST_WINDOW_H__
26
27 #include "GHOST_IWindow.h"
28
29 class STR_String;
30 class GHOST_Context;
31
32 /**
33  * Platform independent implementation of GHOST_IWindow.
34  * Dimensions are given in screen coordinates that are relative to the
35  * upper-left corner of the screen.
36  * Implements part of the GHOST_IWindow interface and adds some methods to
37  * be implemented by childs of this class.
38  */
39 class GHOST_Window : public GHOST_IWindow
40 {
41 public:
42
43         /**
44          * Constructor.
45          * Creates a new window and opens it.
46          * To check if the window was created properly, use the getValid() method.
47          * \param width             The width the window.
48          * \param heigh             The height the window.
49          * \param state             The state the window is initially opened with.
50          * \param type              The type of drawing context installed in this window.
51          * \param stereoVisual      Stereo visual for quad buffered stereo.
52          * \param exclusive         Use to show the window ontop and ignore others
53          *                          (used fullscreen).
54          * \param numOfAASamples    Number of samples used for AA (zero if no AA)
55          */
56         GHOST_Window(
57             GHOST_TUns32 width,
58             GHOST_TUns32 height,
59             GHOST_TWindowState state,
60             const bool wantStereoVisual = false,
61             const bool exclusive = false,
62             const GHOST_TUns16 wantNumOfAASamples = 0);
63
64         /**
65          * \section Interface inherited from GHOST_IWindow left for derived class
66          * implementation.
67          * virtual      bool getValid() const = 0;
68          * virtual void setTitle(const STR_String& title) = 0;
69          * virtual void getTitle(STR_String& title) const = 0;
70          * virtual      void getWindowBounds(GHOST_Rect& bounds) const = 0;
71          * virtual      void getClientBounds(GHOST_Rect& bounds) const = 0;
72          * virtual      GHOST_TSuccess setClientWidth(GHOST_TUns32 width) = 0;
73          * virtual      GHOST_TSuccess setClientHeight(GHOST_TUns32 height) = 0;
74          * virtual      GHOST_TSuccess setClientSize(GHOST_TUns32 width, GHOST_TUns32 height) = 0;
75          * virtual      void screenToClient(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
76          * virtual      void clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
77          * virtual GHOST_TWindowState getState() const = 0;
78          * virtual GHOST_TSuccess setState(GHOST_TWindowState state) = 0;
79          * virtual GHOST_TSuccess setOrder(GHOST_TWindowOrder order) = 0;
80          * virtual GHOST_TSuccess swapBuffers() = 0;
81          * virtual GHOST_TSuccess setSwapInterval() = 0;
82          * virtual GHOST_TSuccess getSwapInterval(int& intervalOut) = 0;
83          * virtual GHOST_TSuccess activateDrawingContext() = 0;
84          * virtual GHOST_TSuccess invalidate() = 0;
85          */
86
87         /**
88          * Destructor.
89          * Closes the window and disposes resources allocated.
90          */
91         virtual ~GHOST_Window();
92
93         /**
94          * Returns indication as to whether the window is valid.
95          * \return The validity of the window.
96          */
97         virtual bool getValid() const {
98                 return m_context != NULL;
99         }
100
101         /**
102          * Returns the associated OS object/handle
103          * \return The associated OS object/handle
104          */
105         virtual void *getOSWindow() const;
106
107         /**
108          * Returns the current cursor shape.
109          * \return      The current cursor shape.
110          */
111         inline GHOST_TStandardCursor getCursorShape() const;
112
113         /**
114          * Set the shape of the cursor.
115          * \param       cursorShape: The new cursor shape type id.
116          * \return      Indication of success.
117          */
118         GHOST_TSuccess setCursorShape(GHOST_TStandardCursor cursorShape);
119
120         /**
121          * Set the shape of the cursor to a custom cursor.
122          * \param       bitmap  The bitmap data for the cursor.
123          * \param       mask    The mask data for the cursor.
124          * \param       hotX    The X coordinate of the cursor hotspot.
125          * \param       hotY    The Y coordinate of the cursor hotspot.
126          * \return      Indication of success.
127          */
128         GHOST_TSuccess setCustomCursorShape(GHOST_TUns8 bitmap[16][2],
129                                             GHOST_TUns8 mask[16][2],
130                                             int hotX,
131                                             int hotY);
132
133         GHOST_TSuccess setCustomCursorShape(GHOST_TUns8 *bitmap,
134                                             GHOST_TUns8 *mask,
135                                             int sizex, int sizey,
136                                             int hotX,  int hotY,
137                                             int fg_color, int bg_color);
138
139         /**
140          * Returns the visibility state of the cursor.
141          * \return      The visibility state of the cursor.
142          */
143         inline bool getCursorVisibility() const;
144         inline GHOST_TGrabCursorMode getCursorGrabMode() const;
145         inline bool getCursorGrabModeIsWarp() const;
146         inline void getCursorGrabInitPos(GHOST_TInt32 &x, GHOST_TInt32 &y) const;
147         inline void getCursorGrabAccum(GHOST_TInt32 &x, GHOST_TInt32 &y) const;
148         inline void setCursorGrabAccum(GHOST_TInt32 x, GHOST_TInt32 y);
149
150         /**
151          * Shows or hides the cursor.
152          * \param       visible The new visibility state of the cursor.
153          * \return      Indication of success.
154          */
155         GHOST_TSuccess setCursorVisibility(bool visible);
156
157         /**
158          * Sets the cursor grab.
159          * \param       mode The new grab state of the cursor.
160          * \return      Indication of success.
161          */
162         GHOST_TSuccess setCursorGrab(GHOST_TGrabCursorMode mode, GHOST_Rect *bounds, GHOST_TInt32 mouse_ungrab_xy[2]);
163
164         /**
165          * Gets the cursor grab region, if unset the window is used.
166          * reset when grab is disabled.
167          */
168         GHOST_TSuccess getCursorGrabBounds(GHOST_Rect& bounds);
169
170         /**
171          * Sets the progress bar value displayed in the window/application icon
172          * \param progress The progress % (0.0 to 1.0)
173          */
174         virtual GHOST_TSuccess setProgressBar(float /*progress*/) {
175                 return GHOST_kFailure;
176         }
177
178         /**
179          * Hides the progress bar in the icon
180          */
181         virtual GHOST_TSuccess endProgressBar() {
182                 return GHOST_kFailure;
183         }
184
185         /**
186          * Sets the swap interval for swapBuffers.
187          * \param interval The swap interval to use.
188          * \return A boolean success indicator.
189          */
190         GHOST_TSuccess setSwapInterval(int interval);
191
192         /**
193          * Gets the current swap interval for swapBuffers.
194          * \return An integer.
195          */
196         GHOST_TSuccess getSwapInterval(int& intervalOut);
197
198         /**
199          * Gets the current swap interval for swapBuffers.
200          * \return Number of AA Samples (0 if there is no multisample buffer)
201          */
202         GHOST_TUns16 getNumOfAASamples();
203
204         /**
205          * Tells if the ongoing drag'n'drop object can be accepted upon mouse drop
206          */
207         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         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 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 newDrawingContext instead.
238          * \param type  The type of rendering context installed.
239          * \return Indication as to whether installation has succeeded.
240          */
241         GHOST_TSuccess setDrawingContextType(GHOST_TDrawingContextType type);
242
243         /**
244          * Swaps front and back buffers of a window.
245          * \return  A boolean success indicator.
246          */
247         virtual GHOST_TSuccess swapBuffers();
248
249         /**
250          * Activates the drawing context of this window.
251          * \return  A boolean success indicator.
252          */
253         virtual GHOST_TSuccess activateDrawingContext();
254
255         /**
256          * Updates the drawing context of this window. Needed
257          * whenever the window is changed.
258          * \return Indication of success.
259          */
260         GHOST_TSuccess updateDrawingContext();
261
262         /**
263          * Returns the window user data.
264          * \return The window user data.
265          */
266         inline GHOST_TUserDataPtr getUserData() const
267         {
268                 return m_userData;
269         }
270
271         /**
272          * Changes the window user data.
273          * \param userData: The window user data.
274          */
275         void setUserData(const GHOST_TUserDataPtr userData)
276         {
277                 m_userData = userData;
278         }
279
280         float getNativePixelSize(void)
281         {
282                 if (m_nativePixelSize > 0.0f)
283                         return m_nativePixelSize;
284                 return 1.0f;
285         }
286
287         /**
288          * Returns the recommended DPI for this window.
289          * \return The recommended DPI for this window.
290          */
291         virtual inline GHOST_TUns16 getDPIHint()
292         {
293                 return 96;
294         }
295
296 #ifdef WITH_INPUT_IME
297         virtual void beginIME(GHOST_TInt32 x,
298                               GHOST_TInt32 y,
299                               GHOST_TInt32 w,
300                               GHOST_TInt32 h,
301                               int completed)
302         {
303                 /* do nothing temporarily if not in windows */
304         }
305
306         virtual void endIME()
307         {
308                 /* do nothing temporarily if not in windows */
309         }
310 #endif /* WITH_INPUT_IME */
311
312 protected:
313         /**
314          * Tries to install a rendering context in this window.
315          * \param type  The type of rendering context installed.
316          * \return Indication as to whether installation has succeeded.
317          */
318         virtual GHOST_Context *newDrawingContext(GHOST_TDrawingContextType type) = 0;
319
320         /**
321          * Sets the cursor visibility on the window using
322          * native window system calls.
323          */
324         virtual GHOST_TSuccess setWindowCursorVisibility(bool visible) = 0;
325
326         /**
327          * Sets the cursor grab on the window using
328          * native window system calls.
329          */
330         virtual GHOST_TSuccess setWindowCursorGrab(GHOST_TGrabCursorMode /*mode*/) {
331                 return GHOST_kSuccess;
332         }
333
334         /**
335          * Sets the cursor shape on the window using
336          * native window system calls.
337          */
338         virtual GHOST_TSuccess setWindowCursorShape(GHOST_TStandardCursor shape) = 0;
339
340         /**
341          * Sets the cursor shape on the window using
342          * native window system calls.
343          */
344         virtual GHOST_TSuccess setWindowCustomCursorShape(GHOST_TUns8 bitmap[16][2],
345                                                           GHOST_TUns8 mask[16][2],
346                                                           int hotX, int hotY) = 0;
347
348         virtual GHOST_TSuccess setWindowCustomCursorShape(GHOST_TUns8 *bitmap, GHOST_TUns8 *mask,
349                                                           int szx, int szy, int hotX, int hotY, int fg, int bg) = 0;
350
351         GHOST_TSuccess releaseNativeHandles();
352
353         /** The drawing context installed in this window. */
354         GHOST_TDrawingContextType m_drawingContextType;
355
356         /** The window user data */
357         GHOST_TUserDataPtr m_userData;
358
359         /** The current visibility of the cursor */
360         bool m_cursorVisible;
361
362         /** The current grabbed state of the cursor */
363         GHOST_TGrabCursorMode m_cursorGrab;
364
365         /** Initial grab location. */
366         GHOST_TInt32 m_cursorGrabInitPos[2];
367
368         /** Accumulated offset from m_cursorGrabInitPos. */
369         GHOST_TInt32 m_cursorGrabAccumPos[2];
370
371         /** Wrap the cursor within this region. */
372         GHOST_Rect m_cursorGrabBounds;
373
374         /** The current shape of the cursor */
375         GHOST_TStandardCursor m_cursorShape;
376
377         /** The presence of progress indicator with the application icon */
378         bool m_progressBarVisible;
379
380         /** The acceptance of the "drop candidate" of the current drag'n'drop operation */
381         bool m_canAcceptDragOperation;
382
383         /** Modified state : are there unsaved changes */
384         bool m_isUnsavedChanges;
385
386         /** Stores whether this is a full screen window. */
387         bool m_fullScreen;
388
389         /** Whether to attempt to initialize a context with a stereo framebuffer. */
390         bool m_wantStereoVisual;
391
392         /** Attempt to initialize a context with this many samples. */
393         GHOST_TUns16 m_wantNumOfAASamples;
394
395         /** Full-screen width */
396         GHOST_TUns32 m_fullScreenWidth;
397         /** Full-screen height */
398         GHOST_TUns32 m_fullScreenHeight;
399
400         /* OSX only, retina screens */
401         float m_nativePixelSize;
402
403 private:
404         GHOST_Context *m_context;
405 };
406
407
408 inline GHOST_TDrawingContextType GHOST_Window::getDrawingContextType()
409 {
410         return m_drawingContextType;
411 }
412
413 inline bool GHOST_Window::getCursorVisibility() const
414 {
415         return m_cursorVisible;
416 }
417
418 inline GHOST_TGrabCursorMode GHOST_Window::getCursorGrabMode() const
419 {
420         return m_cursorGrab;
421 }
422
423 inline bool GHOST_Window::getCursorGrabModeIsWarp() const
424 {
425         return (m_cursorGrab == GHOST_kGrabWrap) ||
426                (m_cursorGrab == GHOST_kGrabHide);
427 }
428
429 inline void GHOST_Window::getCursorGrabInitPos(GHOST_TInt32 &x, GHOST_TInt32 &y) const
430 {
431         x = m_cursorGrabInitPos[0];
432         y = m_cursorGrabInitPos[1];
433 }
434
435 inline void GHOST_Window::getCursorGrabAccum(GHOST_TInt32 &x, GHOST_TInt32 &y) const
436 {
437         x = m_cursorGrabAccumPos[0];
438         y = m_cursorGrabAccumPos[1];
439 }
440
441 inline void GHOST_Window::setCursorGrabAccum(GHOST_TInt32 x, GHOST_TInt32 y)
442 {
443         m_cursorGrabAccumPos[0] = x;
444         m_cursorGrabAccumPos[1] = y;
445 }
446
447 inline GHOST_TStandardCursor GHOST_Window::getCursorShape() const
448 {
449         return m_cursorShape;
450 }
451
452 #endif // _GHOST_WINDOW_H