36e4bac6dae1b54f0bcd9ed321ede74b84a83d8e
[blender-staging.git] / intern / ghost / intern / GHOST_Window.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_Window.h
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 title         The text shown in the title bar of the window.
79          * @param left          The coordinate of the left edge of the window.
80          * @param top           The coordinate of the top edge of the window.
81          * @param width         The width the window.
82          * @param heigh         The height the window.
83          * @param state         The state the window is initially opened with.
84          * @param type          The type of drawing context installed in this window.
85          * @param stereoVisual  Stereo visual for quad buffered stereo.
86          */
87         GHOST_Window(
88                 const STR_String& title, 
89                 GHOST_TInt32 left,
90                 GHOST_TInt32 top,
91                 GHOST_TUns32 width,
92                 GHOST_TUns32 height,
93                 GHOST_TWindowState state,
94                 GHOST_TDrawingContextType type = GHOST_kDrawingContextTypeNone,
95                 const bool stereoVisual = false);
96
97         /**
98          * @section Interface inherited from GHOST_IWindow left for derived class
99          * implementation.
100          * virtual      bool getValid() const = 0;
101          * virtual void setTitle(const STR_String& title) = 0;
102          * virtual void getTitle(STR_String& title) const = 0;
103          * virtual      void getWindowBounds(GHOST_Rect& bounds) const = 0;
104          * virtual      void getClientBounds(GHOST_Rect& bounds) const = 0;
105          * virtual      GHOST_TSuccess setClientWidth(GHOST_TUns32 width) = 0;
106          * virtual      GHOST_TSuccess setClientHeight(GHOST_TUns32 height) = 0;
107          * virtual      GHOST_TSuccess setClientSize(GHOST_TUns32 width, GHOST_TUns32 height) = 0;
108          * virtual      void screenToClient(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
109          * virtual      void clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
110          * virtual GHOST_TWindowState getState() const = 0;
111          * virtual GHOST_TSuccess setState(GHOST_TWindowState state) = 0;
112          * virtual GHOST_TSuccess setOrder(GHOST_TWindowOrder order) = 0;
113          * virtual GHOST_TSuccess swapBuffers() = 0;
114          * virtual GHOST_TSuccess activateDrawingContext() = 0;
115          * virtual GHOST_TSuccess invalidate() = 0;
116          */
117          
118         /**
119          * Destructor.
120          * Closes the window and disposes resources allocated.
121          */
122         virtual ~GHOST_Window();
123
124         /**
125          * Returns the current cursor shape.
126          * @return      The current cursor shape.
127          */
128         inline virtual GHOST_TStandardCursor getCursorShape() const;
129
130         /**
131          * Set the shape of the cursor.
132          * @param       cursor  The new cursor shape type id.
133          * @return      Indication of success.
134          */
135         virtual GHOST_TSuccess setCursorShape(GHOST_TStandardCursor cursorShape);
136
137         /**
138          * Set the shape of the cursor to a custom cursor.
139          * @param       bitmap  The bitmap data for the cursor.
140          * @param       mask    The mask data for the cursor.
141          * @param       hotX    The X coordinate of the cursor hotspot.
142          * @param       hotY    The Y coordinate of the cursor hotspot.
143          * @return      Indication of success.
144          */
145         virtual GHOST_TSuccess setCustomCursorShape(GHOST_TUns8 bitmap[16][2], 
146                                                                                                 GHOST_TUns8 mask[16][2], 
147                                                                                                 int hotX, 
148                                                                                                 int hotY);
149                                                                                                 
150         virtual GHOST_TSuccess setCustomCursorShape(GHOST_TUns8 *bitmap, 
151                                                                                                 GHOST_TUns8 *mask, 
152                                                                                                 int sizex, int sizey,
153                                                                                                 int hotX,  int hotY,
154                                                                                                 int fg_color, int bg_color);
155         
156         /**
157          * Returns the visibility state of the cursor.
158          * @return      The visibility state of the cursor.
159          */
160         inline virtual bool getCursorVisibility() const;
161         inline virtual bool getCursorWarp() const;
162         inline virtual bool getCursorWarpPos(GHOST_TInt32 &x, GHOST_TInt32 &y) const;
163         inline virtual bool getCursorWarpAccum(GHOST_TInt32 &x, GHOST_TInt32 &y) const;
164         inline virtual bool setCursorWarpAccum(GHOST_TInt32 x, GHOST_TInt32 y);
165
166         /**
167          * Shows or hides the cursor.
168          * @param       visible The new visibility state of the cursor.
169          * @return      Indication of success.
170          */
171         virtual GHOST_TSuccess setCursorVisibility(bool visible);
172
173         /**
174          * Sets the cursor grab.
175          * @param       grab The new grab state of the cursor.
176          * @return      Indication of success.
177          */
178         virtual GHOST_TSuccess setCursorGrab(bool grab, bool warp);
179
180         /**
181          * Sets the window "modified" status, indicating unsaved changes
182          * @param isUnsavedChanges Unsaved changes or not
183          * @return Indication of success.
184          */
185         virtual GHOST_TSuccess setModifiedState(bool isUnsavedChanges);
186         
187         /**
188          * Gets the window "modified" status, indicating unsaved changes
189          * @return True if there are unsaved changes
190          */
191         virtual bool getModifiedState();
192         
193         /**
194          * Returns the type of drawing context used in this window.
195          * @return The current type of drawing context.
196          */
197         inline virtual GHOST_TDrawingContextType getDrawingContextType();
198
199         /**
200          * Tries to install a rendering context in this window.
201          * Child classes do not need to overload this method.
202          * They should overload the installDrawingContext and removeDrawingContext instead.
203          * @param type  The type of rendering context installed.
204          * @return Indication as to whether installation has succeeded.
205          */
206         virtual GHOST_TSuccess setDrawingContextType(GHOST_TDrawingContextType type);
207
208         /**
209          * Returns the window user data.
210          * @return The window user data.
211          */
212         inline virtual GHOST_TUserDataPtr getUserData() const
213         {
214                 return m_userData;
215         }
216         
217         /**
218          * Changes the window user data.
219          * @param data The window user data.
220          */
221         virtual void setUserData(const GHOST_TUserDataPtr userData)
222         {
223                 m_userData = userData;
224         }
225
226 protected:
227         /**
228          * Tries to install a rendering context in this window.
229          * @param type  The type of rendering context installed.
230          * @return Indication as to whether installation has succeeded.
231          */
232         virtual GHOST_TSuccess installDrawingContext(GHOST_TDrawingContextType type) = 0;
233
234         /**
235          * Removes the current drawing context.
236          * @return Indication as to whether removal has succeeded.
237          */
238         virtual GHOST_TSuccess removeDrawingContext() = 0;
239
240         /**
241          * Sets the cursor visibility on the window using
242          * native window system calls.
243          */
244         virtual GHOST_TSuccess setWindowCursorVisibility(bool visible) = 0;
245
246         /**
247          * Sets the cursor grab on the window using
248          * native window system calls.
249          */
250         virtual GHOST_TSuccess setWindowCursorGrab(bool grab, bool warp) { return GHOST_kSuccess; };
251         
252         /**
253          * Sets the cursor shape on the window using
254          * native window system calls.
255          */
256         virtual GHOST_TSuccess setWindowCursorShape(GHOST_TStandardCursor shape) = 0;
257
258         /**
259          * Sets the cursor shape on the window using
260          * native window system calls.
261          */
262         virtual GHOST_TSuccess setWindowCustomCursorShape(GHOST_TUns8 bitmap[16][2], GHOST_TUns8 mask[16][2],
263                                                          int hotX, int hotY) = 0;
264         
265         virtual GHOST_TSuccess setWindowCustomCursorShape(GHOST_TUns8 *bitmap, GHOST_TUns8 *mask, 
266                                                 int szx, int szy, int hotX, int hotY, int fg, int bg) = 0;
267         /** The the of drawing context installed in this window. */
268         GHOST_TDrawingContextType m_drawingContextType;
269         
270         /** The window user data */
271         GHOST_TUserDataPtr m_userData;
272
273         /** The current visibility of the cursor */
274         bool m_cursorVisible;
275
276         /** The current grabbed state of the cursor */
277         bool m_cursorGrabbed;
278         
279         /** The current warped state of the cursor */
280         bool m_cursorWarp;
281
282         /** Initial grab location. */
283         GHOST_TInt32 m_cursorWarpInitPos[2];
284
285         /** Accumulated offset from m_cursorWarpInitPos. */
286         GHOST_TInt32 m_cursorWarpAccumPos[2];
287
288         /** The current shape of the cursor */
289         GHOST_TStandardCursor m_cursorShape;
290     
291         /** Modified state : are there unsaved changes */
292         bool m_isUnsavedChanges;
293         
294         /** Stores wether this is a full screen window. */
295         bool m_fullScreen;
296
297         /** Stereo visual created. Only necessary for 'real' stereo support,
298          *  ie quad buffered stereo. This is not always possible, depends on
299          *  the graphics h/w
300          */
301         bool m_stereoVisual;
302     
303     /** Full-screen width */
304     GHOST_TUns32 m_fullScreenWidth;
305     /** Full-screen height */
306     GHOST_TUns32 m_fullScreenHeight;
307 };
308
309
310 inline GHOST_TDrawingContextType GHOST_Window::getDrawingContextType()
311 {
312         return m_drawingContextType;
313 }
314
315 inline bool GHOST_Window::getCursorVisibility() const
316 {
317         return m_cursorVisible;
318 }
319
320 inline bool GHOST_Window::getCursorWarp() const
321 {
322         return m_cursorWarp;
323 }
324
325 inline bool GHOST_Window::getCursorWarpPos(GHOST_TInt32 &x, GHOST_TInt32 &y) const
326 {
327         if(m_cursorWarp==false)
328                 return GHOST_kFailure;
329
330         x= m_cursorWarpInitPos[0];
331         y= m_cursorWarpInitPos[1];
332         return GHOST_kSuccess;
333 }
334
335 inline bool GHOST_Window::getCursorWarpAccum(GHOST_TInt32 &x, GHOST_TInt32 &y) const
336 {
337         if(m_cursorWarp==false)
338                 return GHOST_kFailure;
339
340         x= m_cursorWarpAccumPos[0];
341         y= m_cursorWarpAccumPos[1];
342         return GHOST_kSuccess;
343 }
344
345 inline bool GHOST_Window::setCursorWarpAccum(GHOST_TInt32 x, GHOST_TInt32 y)
346 {
347         if(m_cursorWarp==false)
348                 return GHOST_kFailure;
349
350         m_cursorWarpAccumPos[0]= x;
351         m_cursorWarpAccumPos[1]= y;
352
353         return GHOST_kSuccess;
354 }
355
356 inline GHOST_TStandardCursor GHOST_Window::getCursorShape() const
357 {
358         return m_cursorShape;
359 }
360
361 #endif // _GHOST_WINDOW_H
362