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