e0c676f53a579cbb0742f05cc7bd0a178b7a2187
[blender.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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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/intern/GHOST_Window.h
30  *  \ingroup GHOST
31  * Declaration of GHOST_Window class.
32  */
33
34 #ifndef _GHOST_WINDOW_H_
35 #define _GHOST_WINDOW_H_
36
37 #include "GHOST_IWindow.h"
38
39 class STR_String;
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          * @section Interface inherited from GHOST_IWindow left for derived class
55          * implementation.
56          * virtual      bool getValid() const = 0;
57          * virtual void setTitle(const STR_String& title) = 0;
58          * virtual void getTitle(STR_String& title) const = 0;
59          * virtual      void getWindowBounds(GHOST_Rect& bounds) const = 0;
60          * virtual      void getClientBounds(GHOST_Rect& bounds) const = 0;
61          * virtual      GHOST_TSuccess setClientWidth(GHOST_TUns32 width) = 0;
62          * virtual      GHOST_TSuccess setClientHeight(GHOST_TUns32 height) = 0;
63          * virtual      GHOST_TSuccess setClientSize(GHOST_TUns32 width, GHOST_TUns32 height) = 0;
64          * virtual      void screenToClient(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
65          * virtual      void clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
66          * virtual GHOST_TWindowState getState() const = 0;
67          * virtual GHOST_TSuccess setState(GHOST_TWindowState state) = 0;
68          * virtual GHOST_TWindowOrder getOrder(void) = 0;
69          * virtual GHOST_TSuccess setOrder(GHOST_TWindowOrder order) = 0;
70          * virtual GHOST_TSuccess swapBuffers() = 0;
71          * virtual GHOST_TSuccess activateDrawingContext() = 0;
72          * virtual GHOST_TSuccess invalidate() = 0;
73          */
74
75         /**
76          * Constructor.
77          * Creates a new window and opens it.
78          * To check if the window was created properly, use the getValid() method.
79          * @param title                         The text shown in the title bar of the window.
80          * @param left                          The coordinate of the left edge of the window.
81          * @param top                           The coordinate of the top edge of the window.
82          * @param width                         The width the window.
83          * @param heigh                         The height the window.
84          * @param state                         The state the window is initially opened with.
85          * @param type                          The type of drawing context installed in this window.
86          * @param stereoVisual          Stereo visual for quad buffered stereo.
87          * @param numOfAASamples        Number of samples used for AA (zero if no AA)
88          */
89         GHOST_Window(
90                 const STR_String& title, 
91                 GHOST_TInt32 left,
92                 GHOST_TInt32 top,
93                 GHOST_TUns32 width,
94                 GHOST_TUns32 height,
95                 GHOST_TWindowState state,
96                 GHOST_TDrawingContextType type = GHOST_kDrawingContextTypeNone,
97                 const bool stereoVisual = false,
98                 const GHOST_TUns16 numOfAASamples = 0);
99
100         /**
101          * @section Interface inherited from GHOST_IWindow left for derived class
102          * implementation.
103          * virtual      bool getValid() const = 0;
104          * virtual void setTitle(const STR_String& title) = 0;
105          * virtual void getTitle(STR_String& title) const = 0;
106          * virtual      void getWindowBounds(GHOST_Rect& bounds) const = 0;
107          * virtual      void getClientBounds(GHOST_Rect& bounds) const = 0;
108          * virtual      GHOST_TSuccess setClientWidth(GHOST_TUns32 width) = 0;
109          * virtual      GHOST_TSuccess setClientHeight(GHOST_TUns32 height) = 0;
110          * virtual      GHOST_TSuccess setClientSize(GHOST_TUns32 width, GHOST_TUns32 height) = 0;
111          * virtual      void screenToClient(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
112          * virtual      void clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
113          * virtual GHOST_TWindowState getState() const = 0;
114          * virtual GHOST_TSuccess setState(GHOST_TWindowState state) = 0;
115          * virtual GHOST_TSuccess setOrder(GHOST_TWindowOrder order) = 0;
116          * virtual GHOST_TSuccess swapBuffers() = 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 void getCursorGrabInitPos(GHOST_TInt32 &x, GHOST_TInt32 &y) const;
172         inline virtual void getCursorGrabAccum(GHOST_TInt32 &x, GHOST_TInt32 &y) const;
173         inline virtual void setCursorGrabAccum(GHOST_TInt32 x, GHOST_TInt32 y);
174
175         /**
176          * Shows or hides the cursor.
177          * @param       visible The new visibility state of the cursor.
178          * @return      Indication of success.
179          */
180         virtual GHOST_TSuccess setCursorVisibility(bool visible);
181
182         /**
183          * Sets the cursor grab.
184          * @param       mode The new grab state of the cursor.
185          * @return      Indication of success.
186          */
187         virtual GHOST_TSuccess setCursorGrab(GHOST_TGrabCursorMode mode, GHOST_Rect *bounds);
188
189         /**
190          * Gets the cursor grab region, if unset the window is used.
191          * reset when grab is disabled.
192          */
193         virtual GHOST_TSuccess getCursorGrabBounds(GHOST_Rect& bounds);
194
195         /**
196      * Sets the progress bar value displayed in the window/application icon
197          * @param progress The progress % (0.0 to 1.0)
198          */
199         virtual GHOST_TSuccess setProgressBar(float progress) {return GHOST_kFailure;};
200         
201         /**
202          * Hides the progress bar in the icon
203          */
204         virtual GHOST_TSuccess endProgressBar() {return GHOST_kFailure;};
205         
206         /**
207          * Tells if the ongoing drag'n'drop object can be accepted upon mouse drop
208          */
209         virtual void setAcceptDragOperation(bool canAccept);
210         
211         /**
212          * Returns acceptance of the dropped object
213          * Usually called by the "object dropped" event handling function
214          */
215         virtual bool canAcceptDragOperation() const;
216         
217         /**
218          * Sets the window "modified" status, indicating unsaved changes
219          * @param isUnsavedChanges Unsaved changes or not
220          * @return Indication of success.
221          */
222         virtual GHOST_TSuccess setModifiedState(bool isUnsavedChanges);
223         
224         /**
225          * Gets the window "modified" status, indicating unsaved changes
226          * @return True if there are unsaved changes
227          */
228         virtual bool getModifiedState();
229         
230         /**
231          * Returns the type of drawing context used in this window.
232          * @return The current type of drawing context.
233          */
234         inline virtual GHOST_TDrawingContextType getDrawingContextType();
235
236         /**
237          * Tries to install a rendering context in this window.
238          * Child classes do not need to overload this method.
239          * They should overload the installDrawingContext and removeDrawingContext instead.
240          * @param type  The type of rendering context installed.
241          * @return Indication as to whether installation has succeeded.
242          */
243         virtual GHOST_TSuccess setDrawingContextType(GHOST_TDrawingContextType type);
244
245         /**
246          * Returns the window user data.
247          * @return The window user data.
248          */
249         inline virtual GHOST_TUserDataPtr getUserData() const
250         {
251                 return m_userData;
252         }
253         
254         /**
255          * Changes the window user data.
256          * @param data The window user data.
257          */
258         virtual void setUserData(const GHOST_TUserDataPtr userData)
259         {
260                 m_userData = userData;
261         }
262
263 protected:
264         /**
265          * Tries to install a rendering context in this window.
266          * @param type  The type of rendering context installed.
267          * @return Indication as to whether installation has succeeded.
268          */
269         virtual GHOST_TSuccess installDrawingContext(GHOST_TDrawingContextType type) = 0;
270
271         /**
272          * Removes the current drawing context.
273          * @return Indication as to whether removal has succeeded.
274          */
275         virtual GHOST_TSuccess removeDrawingContext() = 0;
276
277         /**
278          * Sets the cursor visibility on the window using
279          * native window system calls.
280          */
281         virtual GHOST_TSuccess setWindowCursorVisibility(bool visible) = 0;
282
283         /**
284          * Sets the cursor grab on the window using
285          * native window system calls.
286          */
287         virtual GHOST_TSuccess setWindowCursorGrab(GHOST_TGrabCursorMode mode) { return GHOST_kSuccess; };
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], GHOST_TUns8 mask[16][2],
300                                                          int hotX, int hotY) = 0;
301         
302         virtual GHOST_TSuccess setWindowCustomCursorShape(GHOST_TUns8 *bitmap, GHOST_TUns8 *mask, 
303                                                 int szx, int szy, int hotX, int hotY, int fg, int bg) = 0;
304         /** The the of drawing context installed in this window. */
305         GHOST_TDrawingContextType m_drawingContextType;
306         
307         /** The window user data */
308         GHOST_TUserDataPtr m_userData;
309
310         /** The current visibility of the cursor */
311         bool m_cursorVisible;
312
313         /** The current grabbed state of the cursor */
314         GHOST_TGrabCursorMode m_cursorGrab;
315
316         /** Initial grab location. */
317         GHOST_TInt32 m_cursorGrabInitPos[2];
318
319         /** Accumulated offset from m_cursorGrabInitPos. */
320         GHOST_TInt32 m_cursorGrabAccumPos[2];
321
322         /** Wrap the cursor within this region. */
323         GHOST_Rect m_cursorGrabBounds;
324
325         /** The current shape of the cursor */
326         GHOST_TStandardCursor m_cursorShape;
327     
328         /** The presence of progress indicator with the application icon */
329         bool m_progressBarVisible;
330         
331         /** The acceptance of the "drop candidate" of the current drag'n'drop operation */
332         bool m_canAcceptDragOperation;
333         
334         /** Modified state : are there unsaved changes */
335         bool m_isUnsavedChanges;
336         
337         /** Stores wether this is a full screen window. */
338         bool m_fullScreen;
339
340         /** Stereo visual created. Only necessary for 'real' stereo support,
341          *  ie quad buffered stereo. This is not always possible, depends on
342          *  the graphics h/w
343          */
344         bool m_stereoVisual;
345         
346         /** Number of samples used in anti-aliasing, set to 0 if no AA **/
347         GHOST_TUns16 m_numOfAASamples;
348     
349     /** Full-screen width */
350     GHOST_TUns32 m_fullScreenWidth;
351     /** Full-screen height */
352     GHOST_TUns32 m_fullScreenHeight;
353 };
354
355
356 inline GHOST_TDrawingContextType GHOST_Window::getDrawingContextType()
357 {
358         return m_drawingContextType;
359 }
360
361 inline bool GHOST_Window::getCursorVisibility() const
362 {
363         return m_cursorVisible;
364 }
365
366 inline GHOST_TGrabCursorMode GHOST_Window::getCursorGrabMode() const
367 {
368         return m_cursorGrab;
369 }
370
371 inline void GHOST_Window::getCursorGrabInitPos(GHOST_TInt32 &x, GHOST_TInt32 &y) const
372 {
373         x = m_cursorGrabInitPos[0];
374         y = m_cursorGrabInitPos[1];
375 }
376
377 inline void GHOST_Window::getCursorGrabAccum(GHOST_TInt32 &x, GHOST_TInt32 &y) const
378 {
379         x= m_cursorGrabAccumPos[0];
380         y= m_cursorGrabAccumPos[1];
381 }
382
383 inline void GHOST_Window::setCursorGrabAccum(GHOST_TInt32 x, GHOST_TInt32 y)
384 {
385         m_cursorGrabAccumPos[0]= x;
386         m_cursorGrabAccumPos[1]= y;
387 }
388
389 inline GHOST_TStandardCursor GHOST_Window::getCursorShape() const
390 {
391         return m_cursorShape;
392 }
393
394 #endif // _GHOST_WINDOW_H
395