9bb2be7679f21ff8f996896408f22a7aa2cdf3bf
[blender.git] / intern / ghost / intern / GHOST_Window.h
1 /**
2  * $Id$
3  * ***** BEGIN GPL/BL DUAL 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. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30  */
31
32 /**
33
34  * $Id$
35  * Copyright (C) 2001 NaN Technologies B.V.
36  * @author      Maarten Gribnau
37  * @date        May 7, 2001
38  */
39
40 #ifndef _GHOST_WINDOW_H_
41 #define _GHOST_WINDOW_H_
42
43
44 #include "GHOST_IWindow.h"
45
46 class STR_String;
47
48 /**
49  * Platform independent implementation of GHOST_IWindow.
50  * Dimensions are given in screen coordinates that are relative to the upper-left corner of the screen. 
51  * @author      Maarten Gribnau
52  * @date        May 7, 2001
53  */
54
55 class GHOST_Window : public GHOST_IWindow
56 {
57 public:
58         /**
59          * Constructor.
60          * Creates a new window and opens it.
61          * To check if the window was created properly, use the getValid() method.
62          * @param title         The text shown in the title bar of the window.
63          * @param left          The coordinate of the left edge of the window.
64          * @param top           The coordinate of the top edge of the window.
65          * @param width         The width the window.
66          * @param heigh         The height the window.
67          * @param state         The state the window is initially opened with.
68          * @param type          The type of drawing context installed in this window.
69          * @param stereoVisual  Stereo visual for quad buffered stereo.
70          */
71         GHOST_Window(
72                 const STR_String& title, 
73                 GHOST_TInt32 left,
74                 GHOST_TInt32 top,
75                 GHOST_TUns32 width,
76                 GHOST_TUns32 height,
77                 GHOST_TWindowState state,
78                 GHOST_TDrawingContextType type = GHOST_kDrawingContextTypeNone,
79                 const bool stereoVisual = false);
80
81         /**
82          * @section Interface inherited from GHOST_IWindow left for derived class
83          * implementation.
84          * virtual      bool getValid() const = 0;
85          * virtual void setTitle(const STR_String& title) = 0;
86          * virtual void getTitle(STR_String& title) const = 0;
87          * virtual      void getWindowBounds(GHOST_Rect& bounds) const = 0;
88          * virtual      void getClientBounds(GHOST_Rect& bounds) const = 0;
89          * virtual      GHOST_TSuccess setClientWidth(GHOST_TUns32 width) = 0;
90          * virtual      GHOST_TSuccess setClientHeight(GHOST_TUns32 height) = 0;
91          * virtual      GHOST_TSuccess setClientSize(GHOST_TUns32 width, GHOST_TUns32 height) = 0;
92          * virtual      void screenToClient(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
93          * virtual      void clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
94          * virtual GHOST_TWindowState getState() const = 0;
95          * virtual GHOST_TSuccess setState(GHOST_TWindowState state) = 0;
96          * virtual GHOST_TSuccess setOrder(GHOST_TWindowOrder order) = 0;
97          * virtual GHOST_TSuccess swapBuffers() = 0;
98          * virtual GHOST_TSuccess activateDrawingContext() = 0;
99          * virtual GHOST_TSuccess invalidate() = 0;
100          */
101          
102         /**
103          * Destructor.
104          * Closes the window and disposes resources allocated.
105          */
106         virtual ~GHOST_Window();
107
108         /**
109          * Returns the current cursor shape.
110          * @return      The current cursor shape.
111          */
112         inline virtual GHOST_TStandardCursor getCursorShape() const;
113
114         /**
115          * Set the shape of the cursor.
116          * @param       cursor  The new cursor shape type id.
117          * @return      Indication of success.
118          */
119         virtual GHOST_TSuccess setCursorShape(GHOST_TStandardCursor cursorShape);
120
121         /**
122          * Set the shape of the cursor to a custom cursor.
123          * @param       bitmap  The bitmap data for the cursor.
124          * @param       mask    The mask data for the cursor.
125          * @param       hotX    The X coordinate of the cursor hotspot.
126          * @param       hotY    The Y coordinate of the cursor hotspot.
127          * @return      Indication of success.
128          */
129         virtual GHOST_TSuccess setCustomCursorShape(GHOST_TUns8 bitmap[16][2], 
130                                                                                                 GHOST_TUns8 mask[16][2], 
131                                                                                                 int hotX, 
132                                                                                                 int hotY);
133         
134         /**
135          * Returns the visibility state of the cursor.
136          * @return      The visibility state of the cursor.
137          */
138         inline virtual bool getCursorVisibility() const;
139
140         /**
141          * Shows or hides the cursor.
142          * @param       visible The new visibility state of the cursor.
143          * @return      Indication of success.
144          */
145         virtual GHOST_TSuccess setCursorVisibility(bool visible);
146
147         /**
148          * Returns the type of drawing context used in this window.
149          * @return The current type of drawing context.
150          */
151         inline virtual GHOST_TDrawingContextType getDrawingContextType();
152
153         /**
154          * Tries to install a rendering context in this window.
155          * Child classes do not need to overload this method.
156          * They should overload the installDrawingContext and removeDrawingContext instead.
157          * @param type  The type of rendering context installed.
158          * @return Indication as to whether installation has succeeded.
159          */
160         virtual GHOST_TSuccess setDrawingContextType(GHOST_TDrawingContextType type);
161
162         /**
163          * Returns the window user data.
164          * @return The window user data.
165          */
166         inline virtual GHOST_TUserDataPtr getUserData() const
167         {
168                 return m_userData;
169         }
170         
171         /**
172          * Changes the window user data.
173          * @param data The window user data.
174          */
175         virtual void setUserData(const GHOST_TUserDataPtr userData)
176         {
177                 m_userData = userData;
178         }
179
180 protected:
181         /**
182          * Tries to install a rendering context in this window.
183          * @param type  The type of rendering context installed.
184          * @return Indication as to whether installation has succeeded.
185          */
186         virtual GHOST_TSuccess installDrawingContext(GHOST_TDrawingContextType type) = 0;
187
188         /**
189          * Removes the current drawing context.
190          * @return Indication as to whether removal has succeeded.
191          */
192         virtual GHOST_TSuccess removeDrawingContext() = 0;
193
194         /**
195          * Sets the cursor visibility on the window using
196          * native window system calls.
197          */
198         virtual GHOST_TSuccess setWindowCursorVisibility(bool visible) = 0;
199         
200         /**
201          * Sets the cursor shape on the window using
202          * native window system calls.
203          */
204         virtual GHOST_TSuccess setWindowCursorShape(GHOST_TStandardCursor shape) = 0;
205
206         /**
207          * Sets the cursor shape on the window using
208          * native window system calls.
209          */
210         virtual GHOST_TSuccess setWindowCustomCursorShape(GHOST_TUns8 bitmap[16][2], GHOST_TUns8 mask[16][2], int hotX, int hotY) = 0;
211
212         /** The the of drawing context installed in this window. */
213         GHOST_TDrawingContextType m_drawingContextType;
214         
215         /** The window user data */
216         GHOST_TUserDataPtr m_userData;
217
218         /** The current visibility of the cursor */
219         bool m_cursorVisible;
220         
221         /** The current shape of the cursor */
222         GHOST_TStandardCursor m_cursorShape;
223     
224         /** Stores wether this is a full screen window. */
225         bool m_fullScreen;
226
227         /** Stereo visual created. Only necessary for 'real' stereo support,
228          *  ie quad buffered stereo. This is not always possible, depends on
229          *  the graphics h/w
230          */
231         bool m_stereoVisual;
232     
233     /** Full-screen width */
234     GHOST_TUns32 m_fullScreenWidth;
235     /** Full-screen height */
236     GHOST_TUns32 m_fullScreenHeight;
237 };
238
239
240 inline GHOST_TDrawingContextType GHOST_Window::getDrawingContextType()
241 {
242         return m_drawingContextType;
243 }
244
245 inline bool GHOST_Window::getCursorVisibility() const
246 {
247         return m_cursorVisible;
248 }
249
250 inline GHOST_TStandardCursor GHOST_Window::getCursorShape() const
251 {
252         return m_cursorShape;
253 }
254
255 #endif // _GHOST_WINDOW_H