Comments
[blender.git] / intern / ghost / GHOST_IWindow.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/GHOST_IWindow.h
29  *  \ingroup GHOST
30  * Declaration of GHOST_IWindow interface class.
31  */
32
33 #ifndef __GHOST_IWINDOW_H__
34 #define __GHOST_IWINDOW_H__
35
36 #include "STR_String.h"
37 #include "GHOST_Rect.h"
38 #include "GHOST_Types.h"
39
40
41 /**
42  * Interface for GHOST windows.
43  *
44  * You can create a window with the system's GHOST_ISystem::createWindow
45  * method.
46  * \see GHOST_ISystem#createWindow
47  *
48  * There are two coordinate systems:
49  *
50  * - The screen coordinate system. The origin of the screen is located in the
51  *   upper left corner of the screen.</li>
52  * - The client rectangle coordinate system. The client rectangle of a window
53  *   is the area that is drawable by the application (excluding title bars etc.).
54  *
55  * \author  Maarten Gribnau
56  * \date    May 31, 2001
57  */
58 class GHOST_IWindow
59 {
60 public:
61         /**
62          * Destructor.
63          */
64         virtual ~GHOST_IWindow()
65         {
66         }
67
68         /**
69          * Returns indication as to whether the window is valid.
70          * \return The validity of the window.
71          */
72         virtual bool getValid() const = 0;
73
74         /**
75          * Returns the associated OS object/handle
76          * \return The associated OS object/handle
77          */
78         virtual void *getOSWindow() const = 0;
79
80         /**
81          * Returns the type of drawing context used in this window.
82          * \return The current type of drawing context.
83          */
84         virtual GHOST_TDrawingContextType getDrawingContextType() = 0;
85
86         /**
87          * Tries to install a rendering context in this window.
88          * \param type  The type of rendering context installed.
89          * \return Indication as to whether installation has succeeded.
90          */
91         virtual GHOST_TSuccess setDrawingContextType(GHOST_TDrawingContextType type) = 0;
92
93         /**
94          * Sets the title displayed in the title bar.
95          * \param title The title to display in the title bar.
96          */
97         virtual void setTitle(const STR_String& title) = 0;
98
99         /**
100          * Returns the title displayed in the title bar.
101          * \param title The title displayed in the title bar.
102          */
103         virtual void getTitle(STR_String& title) const = 0;
104
105         /**
106          * Returns the window rectangle dimensions.
107          * These are screen coordinates.
108          * \param bounds The bounding rectangle of the window.
109          */
110         virtual void getWindowBounds(GHOST_Rect& bounds) const = 0;
111
112         /**
113          * Returns the client rectangle dimensions.
114          * The left and top members of the rectangle are always zero.
115          * \param bounds The bounding rectangle of the client area of the window.
116          */
117         virtual void getClientBounds(GHOST_Rect& bounds) const = 0;
118
119         /**
120          * Resizes client rectangle width.
121          * \param width The new width of the client area of the window.
122          */
123         virtual GHOST_TSuccess setClientWidth(GHOST_TUns32 width) = 0;
124
125         /**
126          * Resizes client rectangle height.
127          * \param height The new height of the client area of the window.
128          */
129         virtual GHOST_TSuccess setClientHeight(GHOST_TUns32 height) = 0;
130
131         /**
132          * Resizes client rectangle.
133          * \param width     The new width of the client area of the window.
134          * \param height    The new height of the client area of the window.
135          */
136         virtual GHOST_TSuccess setClientSize(GHOST_TUns32 width, GHOST_TUns32 height) = 0;
137
138         /**
139          * Converts a point in screen coordinates to client rectangle coordinates
140          * \param inX   The x-coordinate on the screen.
141          * \param inY   The y-coordinate on the screen.
142          * \param outX  The x-coordinate in the client rectangle.
143          * \param outY  The y-coordinate in the client rectangle.
144          */
145         virtual void screenToClient(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
146
147         /**
148          * Converts a point in screen coordinates to client rectangle coordinates
149          * \param inX   The x-coordinate in the client rectangle.
150          * \param inY   The y-coordinate in the client rectangle.
151          * \param outX  The x-coordinate on the screen.
152          * \param outY  The y-coordinate on the screen.
153          */
154         virtual void clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const = 0;
155
156         /**
157          * Tells if the ongoing drag'n'drop object can be accepted upon mouse drop
158          */
159         virtual void setAcceptDragOperation(bool canAccept) = 0;
160
161         /**
162          * Returns acceptance of the dropped object
163          * Usually called by the "object dropped" event handling function
164          */
165         virtual bool canAcceptDragOperation() const = 0;
166
167         /**
168          * Returns the state of the window (normal, minimized, maximized).
169          * \return The state of the window.
170          */
171         virtual GHOST_TWindowState getState() const = 0;
172
173         /**
174          * Sets the state of the window (normal, minimized, maximized).
175          * \param state The state of the window.
176          * \return Indication of success.
177          */
178         virtual GHOST_TSuccess setState(GHOST_TWindowState state) = 0;
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) = 0;
186
187         /**
188          * Gets the window "modified" status, indicating unsaved changes
189          * \return True if there are unsaved changes
190          */
191         virtual bool getModifiedState() = 0;
192
193         /**
194          * Sets the order of the window (bottom, top).
195          * \param order The order of the window.
196          * \return Indication of success.
197          */
198         virtual GHOST_TSuccess setOrder(GHOST_TWindowOrder order) = 0;
199
200         /**
201          * Swaps front and back buffers of a window.
202          * \return  A boolean success indicator.
203          */
204         virtual GHOST_TSuccess swapBuffers() = 0;
205
206         /**
207          * Sets the swap interval for swapBuffers.
208          * \param interval The swap interval to use.
209          * \return A boolean success indicator.
210          */
211         virtual GHOST_TSuccess setSwapInterval(int interval) = 0;
212
213         /**
214          * Gets the current swap interval for swapBuffers.
215          * \return An integer.
216          */
217         virtual int getSwapInterval() = 0;
218
219         /**
220          * Activates the drawing context of this window.
221          * \return  A boolean success indicator.
222          */
223         virtual GHOST_TSuccess activateDrawingContext() = 0;
224
225         /**
226          * Invalidates the contents of this window.
227          * \return Indication of success.
228          */
229         virtual GHOST_TSuccess invalidate() = 0;
230
231         /**
232          * Returns the window user data.
233          * \return The window user data.
234          */
235         virtual GHOST_TUserDataPtr getUserData() const = 0;
236
237         /**
238          * Changes the window user data.
239          * \param data The window user data.
240          */
241         virtual void setUserData(const GHOST_TUserDataPtr userData) = 0;
242
243         /**
244          * Returns the tablet data (pressure etc).
245          * \return The tablet data (pressure etc).
246          */
247         virtual const GHOST_TabletData *GetTabletData() = 0;
248
249         /***************************************************************************************
250          * Progress bar functionality
251          ***************************************************************************************/
252
253         /**
254          * Sets the progress bar value displayed in the window/application icon
255          * \param progress The progress %
256          */
257         virtual GHOST_TSuccess setProgressBar(float progress) = 0;
258
259         /**
260          * Hides the progress bar in the icon
261          */
262         virtual GHOST_TSuccess endProgressBar() = 0;
263
264         /***************************************************************************************
265          * Cursor management functionality
266          ***************************************************************************************/
267
268         /**
269          * Returns the current cursor shape.
270          * \return  The current cursor shape.
271          */
272         virtual GHOST_TStandardCursor getCursorShape() const = 0;
273
274         /**
275          * Set the shape of the cursor.
276          * \param   cursor  The new cursor shape type id.
277          * \return  Indication of success.
278          */
279         virtual GHOST_TSuccess setCursorShape(GHOST_TStandardCursor cursorShape) = 0;
280
281         /**
282          * Set the shape of the cursor to a custom cursor.
283          * \param   bitmap  The bitmap data for the cursor.
284          * \param   mask    The mask data for the cursor.
285          * \param   hotX    The X coordinate of the cursor hotspot.
286          * \param   hotY    The Y coordinate of the cursor hotspot.
287          * \return  Indication of success.
288          */
289         virtual GHOST_TSuccess setCustomCursorShape(GHOST_TUns8 bitmap[16][2],
290                                                     GHOST_TUns8 mask[16][2],
291                                                     int hotX,
292                                                     int hotY) = 0;
293
294         virtual GHOST_TSuccess setCustomCursorShape(GHOST_TUns8 *bitmap,
295                                                     GHOST_TUns8 *mask,
296                                                     int sizex, int sizey,
297                                                     int hotX, int hotY,
298                                                     int fg_color, int bg_color) = 0;
299
300         /**
301          * Returns the visibility state of the cursor.
302          * \return  The visibility state of the cursor.
303          */
304         virtual bool getCursorVisibility() const = 0;
305
306         /**
307          * Shows or hides the cursor.
308          * \param   visible The new visibility state of the cursor.
309          * \return  Indication of success.
310          */
311         virtual GHOST_TSuccess setCursorVisibility(bool visible) = 0;
312
313         /**
314          * Grabs the cursor for a modal operation.
315          * \param   grab The new grab state of the cursor.
316          * \return  Indication of success.
317          */
318         virtual GHOST_TSuccess setCursorGrab(GHOST_TGrabCursorMode mode, GHOST_Rect *bounds, GHOST_TInt32 mouse_ungrab_xy[2]) { return GHOST_kSuccess; }
319
320         /** */
321         virtual GHOST_TSuccess beginFullScreen() const = 0;
322         virtual GHOST_TSuccess endFullScreen() const = 0;
323
324         virtual float getNativePixelSize(void) = 0;
325
326         
327 #ifdef WITH_CXX_GUARDEDALLOC
328         MEM_CXX_CLASS_ALLOC_FUNCS("GHOST:GHOST_IWindow")
329 #endif
330 };
331
332 #endif // __GHOST_IWINDOW_H__
333