synched with trunk at revision 36569
[blender.git] / intern / ghost / GHOST_C-api.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 /** \ingroup GHOST
29  *
30  * \file        GHOST_C-api.h
31  * \brief GHOST C-API function and type declarations.
32  */
33
34 #ifndef GHOST_C_API_H
35 #define GHOST_C_API_H
36
37 #include "GHOST_Types.h"
38
39 #ifdef __cplusplus
40 extern "C" { 
41 #endif
42
43 /**
44  * Creates a "handle" for a C++ GHOST object.
45  * A handle is just an opaque pointer to an empty struct.
46  * In the API the pointer is casted to the actual C++ class.
47  * \param       name    Name of the handle to create.
48  */
49
50 GHOST_DECLARE_HANDLE(GHOST_SystemHandle);
51 GHOST_DECLARE_HANDLE(GHOST_TimerTaskHandle);
52 GHOST_DECLARE_HANDLE(GHOST_WindowHandle);
53 GHOST_DECLARE_HANDLE(GHOST_EventHandle);
54 GHOST_DECLARE_HANDLE(GHOST_RectangleHandle);
55 GHOST_DECLARE_HANDLE(GHOST_EventConsumerHandle);
56
57
58 /**
59  * Definition of a callback routine that receives events.
60  * @param event The event received.
61  * @param userdata The callback's user data, supplied to GHOST_CreateSystem.
62  */
63 typedef int (*GHOST_EventCallbackProcPtr)(GHOST_EventHandle event, GHOST_TUserDataPtr userdata);
64
65
66 /**
67  * Creates the one and only system.
68  * @return a handle to the system.
69  */
70 extern GHOST_SystemHandle GHOST_CreateSystem(void);
71
72 /**
73  * Disposes the one and only system.
74  * @param systemhandle The handle to the system
75  * @return An indication of success.
76  */
77 extern GHOST_TSuccess GHOST_DisposeSystem(GHOST_SystemHandle systemhandle);
78
79
80 /**
81  * Creates an event consumer object
82  * @param eventCallback The event callback routine.
83  * @param userdata              Pointer to user data returned to the callback routine.
84  */
85 extern GHOST_EventConsumerHandle GHOST_CreateEventConsumer(GHOST_EventCallbackProcPtr eventCallback, GHOST_TUserDataPtr userdata);
86
87 /**
88  * Disposes an event consumer object
89  * @param consumerhandle        Handle to the event consumer.
90  * @return An indication of success.
91  */
92 extern GHOST_TSuccess GHOST_DisposeEventConsumer(GHOST_EventConsumerHandle consumerhandle);
93
94
95 /**
96  * Returns the system time.
97  * Returns the number of milliseconds since the start of the system process.
98  * Based on ANSI clock() routine.
99  * @param systemhandle The handle to the system
100  * @return The number of milliseconds.
101  */
102 extern GHOST_TUns64 GHOST_GetMilliSeconds(GHOST_SystemHandle systemhandle);
103
104 /**
105  * Installs a timer.
106  * Note that, on most operating systems, messages need to be processed in order 
107  * for the timer callbacks to be invoked.
108  * @param systemhandle The handle to the system
109  * @param delay         The time to wait for the first call to the timerProc (in milliseconds)
110  * @param interval      The interval between calls to the timerProc (in milliseconds)
111  * @param timerProc     The callback invoked when the interval expires,
112  * @param userData      Placeholder for user data.
113  * @return A timer task (0 if timer task installation failed).
114  */
115 extern GHOST_TimerTaskHandle GHOST_InstallTimer(GHOST_SystemHandle systemhandle,
116                                                                                                 GHOST_TUns64 delay,
117                                                                                                 GHOST_TUns64 interval,
118                                                                                                 GHOST_TimerProcPtr timerProc,
119                                                                                                 GHOST_TUserDataPtr userData);
120
121 /**
122  * Removes a timer.
123  * @param systemhandle The handle to the system
124  * @param timerTask Timer task to be removed.
125  * @return Indication of success.
126  */
127 extern GHOST_TSuccess GHOST_RemoveTimer(GHOST_SystemHandle systemhandle,
128                                                                                 GHOST_TimerTaskHandle timertaskhandle);
129
130 /***************************************************************************************
131  ** Display/window management functionality
132  ***************************************************************************************/
133
134 /**
135  * Returns the number of displays on this system.
136  * @param systemhandle The handle to the system
137  * @return The number of displays.
138  */
139 extern GHOST_TUns8 GHOST_GetNumDisplays(GHOST_SystemHandle systemhandle);
140
141 /**
142  * Returns the dimensions of the main display on this system.
143  * @param systemhandle The handle to the system
144  * @param width         A pointer the width gets put in
145  * @param height        A pointer the height gets put in
146  * @return void.
147  */
148 extern void GHOST_GetMainDisplayDimensions(GHOST_SystemHandle systemhandle,
149                                                                                    GHOST_TUns32* width,
150                                                                                    GHOST_TUns32* height);
151
152 /**
153  * Create a new window.
154  * The new window is added to the list of windows managed. 
155  * Never explicitly delete the window, use disposeWindow() instead.
156  * @param systemhandle The handle to the system
157  * @param       title   The name of the window (displayed in the title bar of the window if the OS supports it).
158  * @param       left    The coordinate of the left edge of the window.
159  * @param       top             The coordinate of the top edge of the window.
160  * @param       width   The width the window.
161  * @param       height  The height the window.
162  * @param       state   The state of the window when opened.
163  * @param       type    The type of drawing context installed in this window.
164  * @param stereoVisual          Stereo visual for quad buffered stereo.
165  * @param numOfAASamples        Number of samples used for AA (zero if no AA)
166  * @return      A handle to the new window ( == NULL if creation failed).
167  */
168 extern GHOST_WindowHandle GHOST_CreateWindow(GHOST_SystemHandle systemhandle,
169         const char* title,
170         GHOST_TInt32 left,
171         GHOST_TInt32 top,
172         GHOST_TUns32 width,
173         GHOST_TUns32 height,
174         GHOST_TWindowState state,
175         GHOST_TDrawingContextType type,
176         const int stereoVisual,
177         const GHOST_TUns16 numOfAASamples);
178
179 /**
180  * Returns the window user data.
181  * @param windowhandle  The handle to the window
182  * @return The window user data.
183  */
184 extern GHOST_TUserDataPtr GHOST_GetWindowUserData(GHOST_WindowHandle windowhandle);
185         
186 /**
187  * Changes the window user data.
188  * @param windowhandle  The handle to the window
189  * @param data The window user data.
190  */
191 extern void GHOST_SetWindowUserData(GHOST_WindowHandle windowhandle, 
192         GHOST_TUserDataPtr userdata);
193
194 /**
195  * Dispose a window.
196  * @param systemhandle The handle to the system
197  * @param       window Handle to the window to be disposed.
198  * @return      Indication of success.
199  */
200 extern GHOST_TSuccess GHOST_DisposeWindow(GHOST_SystemHandle systemhandle,
201                                                                                   GHOST_WindowHandle windowhandle);
202
203 /**
204  * Returns whether a window is valid.
205  * @param systemhandle The handle to the system
206  * @param       window Handle to the window to be checked.
207  * @return      Indication of validity.
208  */
209 extern int GHOST_ValidWindow(GHOST_SystemHandle systemhandle,
210                                                                                 GHOST_WindowHandle windowhandle);
211
212 /**
213  * Begins full screen mode.
214  * @param systemhandle The handle to the system
215  * @param setting       The new setting of the display.
216  * @return                      A handle to the window displayed in full screen.
217  *                                      This window is invalid after full screen has been ended.
218  */
219 extern GHOST_WindowHandle GHOST_BeginFullScreen(GHOST_SystemHandle systemhandle,
220         GHOST_DisplaySetting* setting,
221         const int stereoVisual);
222
223 /**
224  * Ends full screen mode.
225  * @param systemhandle The handle to the system
226  * @return      Indication of success.
227  */
228 extern GHOST_TSuccess GHOST_EndFullScreen(GHOST_SystemHandle systemhandle);
229
230 /**
231  * Returns current full screen mode status.
232  * @param systemhandle The handle to the system
233  * @return The current status.
234  */
235 extern int GHOST_GetFullScreen(GHOST_SystemHandle systemhandle);
236
237 /***************************************************************************************
238  ** Event management functionality
239  ***************************************************************************************/
240
241 /**
242  * Retrieves events from the system and stores them in the queue.
243  * @param systemhandle The handle to the system
244  * @param waitForEvent Boolean to indicate that ProcessEvents should
245  * wait (block) until the next event before returning.
246  * @return Indication of the presence of events.
247  */
248 extern int GHOST_ProcessEvents(GHOST_SystemHandle systemhandle, int waitForEvent);
249
250 /**
251  * Retrieves events from the queue and send them to the event consumers.
252  * @param systemhandle The handle to the system
253  * @return Indication of the presence of events.
254  */
255 extern int GHOST_DispatchEvents(GHOST_SystemHandle systemhandle);
256
257 /**
258  * Adds the given event consumer to our list.
259  * @param systemhandle The handle to the system
260  * @param consumerhandle The event consumer to add.
261  * @return Indication of success.
262  */
263 extern GHOST_TSuccess GHOST_AddEventConsumer(GHOST_SystemHandle systemhandle,
264                                                                                           GHOST_EventConsumerHandle consumerhandle);
265
266 /**
267  * Remove the given event consumer to our list.
268  * @param systemhandle The handle to the system
269  * @param consumerhandle The event consumer to remove.
270  * @return Indication of success.
271  */
272 extern GHOST_TSuccess GHOST_RemoveEventConsumer(GHOST_SystemHandle systemhandle,
273                                                                                           GHOST_EventConsumerHandle consumerhandle);
274
275 /***************************************************************************************
276  ** Progress bar functionality
277  ***************************************************************************************/
278
279 /**
280  * Sets the progress bar value displayed in the window/application icon
281  * @param windowhandle The handle to the window
282  * @param progress The progress % (0.0 to 1.0)
283  */
284 extern GHOST_TSuccess GHOST_SetProgressBar(GHOST_WindowHandle windowhandle, float progress);
285
286 /**
287  * Hides the progress bar in the icon
288  * @param windowhandle The handle to the window
289  */
290 extern GHOST_TSuccess GHOST_EndProgressBar(GHOST_WindowHandle windowhandle);
291         
292         
293 /***************************************************************************************
294  ** N-degree of freedom device management functionality
295  ***************************************************************************************/
296  
297 /**
298 * Open N-degree of freedom devices
299  */
300 extern int GHOST_OpenNDOF(GHOST_SystemHandle systemhandle, 
301                            GHOST_WindowHandle windowhandle,
302                           GHOST_NDOFLibraryInit_fp setNdofLibraryInit, 
303                           GHOST_NDOFLibraryShutdown_fp setNdofLibraryShutdown,
304                           GHOST_NDOFDeviceOpen_fp setNdofDeviceOpen
305                           );
306
307 /***************************************************************************************
308  ** Cursor management functionality
309  ***************************************************************************************/
310
311 /**
312  * Returns the current cursor shape.
313  * @param windowhandle The handle to the window
314  * @return      The current cursor shape.
315  */
316 extern GHOST_TStandardCursor GHOST_GetCursorShape(GHOST_WindowHandle windowhandle);
317
318 /**
319  * Set the shape of the cursor.
320  * @param windowhandle The handle to the window
321  * @param       cursor  The new cursor shape type id.
322  * @return      Indication of success.
323  */
324 extern GHOST_TSuccess GHOST_SetCursorShape(GHOST_WindowHandle windowhandle,
325                                                                                    GHOST_TStandardCursor cursorshape);
326
327 /**
328  * Set the shape of the cursor to a custom cursor.
329  * @param windowhandle The handle to the window
330  * @param       bitmap  The bitmap data for the cursor.
331  * @param       mask    The mask data for the cursor.
332  * @param       hotX    The X coordinate of the cursor hotspot.
333  * @param       hotY    The Y coordinate of the cursor hotspot.
334  * @return      Indication of success.
335  */
336 extern GHOST_TSuccess GHOST_SetCustomCursorShape(GHOST_WindowHandle windowhandle,
337                                                                                                  GHOST_TUns8 bitmap[16][2], 
338                                                                                                  GHOST_TUns8 mask[16][2], 
339                                                                                                  int hotX, 
340                                                                                                  int hotY);
341 /**
342  * Set the shape of the cursor to a custom cursor of specified size.
343  * @param windowhandle The handle to the window
344  * @param       bitmap  The bitmap data for the cursor.
345  * @param       mask    The mask data for the cursor.
346  * @parm    sizex, sizey  The size of the cursor
347  * @param       hotX    The X coordinate of the cursor hotspot.
348  * @param       hotY    The Y coordinate of the cursor hotspot.
349  * @param   fg_color, bg_color  Colors of the cursor
350  * @return      Indication of success.
351   */
352 extern GHOST_TSuccess GHOST_SetCustomCursorShapeEx(GHOST_WindowHandle windowhandle,
353                                                                                                  GHOST_TUns8 *bitmap, 
354                                                                                                  GHOST_TUns8 *mask, 
355                                                                                                  int sizex, int sizey, 
356                                                                                                  int hotX,  int hotY,
357                                                                                                  int fg_color, int bg_color );
358
359 /**
360  * Returns the visibility state of the cursor.
361  * @param windowhandle The handle to the window
362  * @return      The visibility state of the cursor.
363  */
364 extern int GHOST_GetCursorVisibility(GHOST_WindowHandle windowhandle);
365
366 /**
367  * Shows or hides the cursor.
368  * @param windowhandle The handle to the window
369  * @param       visible The new visibility state of the cursor.
370  * @return      Indication of success.
371  */
372 extern GHOST_TSuccess GHOST_SetCursorVisibility(GHOST_WindowHandle windowhandle,
373                                                                                                 int visible);
374
375 /**
376  * Returns the current location of the cursor (location in screen coordinates)
377  * @param systemhandle The handle to the system
378  * @param x                     The x-coordinate of the cursor.
379  * @param y                     The y-coordinate of the cursor.
380  * @return                      Indication of success.
381  */
382 extern GHOST_TSuccess GHOST_GetCursorPosition(GHOST_SystemHandle systemhandle,
383                                                                                           GHOST_TInt32* x,
384                                                                                           GHOST_TInt32* y);
385
386 /**
387  * Updates the location of the cursor (location in screen coordinates).
388  * Not all operating systems allow the cursor to be moved (without the input device being moved).
389  * @param systemhandle The handle to the system
390  * @param x                     The x-coordinate of the cursor.
391  * @param y                     The y-coordinate of the cursor.
392  * @return                      Indication of success.
393  */
394 extern GHOST_TSuccess GHOST_SetCursorPosition(GHOST_SystemHandle systemhandle,
395                                                                                           GHOST_TInt32 x,
396                                                                                           GHOST_TInt32 y);
397
398 /**
399  * Grabs the cursor for a modal operation, to keep receiving
400  * events when the mouse is outside the window. X11 only, others
401  * do this automatically.
402  * @param windowhandle The handle to the window
403  * @param       mode The new grab state of the cursor.
404  * @param       bounds The grab ragion (optional) - left,top,right,bottom
405  * @return      Indication of success.
406  */
407 extern GHOST_TSuccess GHOST_SetCursorGrab(GHOST_WindowHandle windowhandle,
408                                                                                                 GHOST_TGrabCursorMode mode,
409                                                                                                 int* bounds);
410
411 /***************************************************************************************
412  ** Access to mouse button and keyboard states.
413  ***************************************************************************************/
414
415 /**
416  * Returns the state of a modifier key (ouside the message queue).
417  * @param systemhandle The handle to the system
418  * @param mask          The modifier key state to retrieve.
419  * @param isDown        Pointer to return modifier state in.
420  * @return                      Indication of success.
421  */
422 extern GHOST_TSuccess GHOST_GetModifierKeyState(GHOST_SystemHandle systemhandle,
423                                                                                                 GHOST_TModifierKeyMask mask,
424                                                                                                 int* isDown);
425
426 /**
427  * Returns the state of a mouse button (ouside the message queue).
428  * @param systemhandle The handle to the system
429  * @param mask          The button state to retrieve.
430  * @param isDown        Pointer to return button state in.
431  * @return                      Indication of success.
432  */
433 extern GHOST_TSuccess GHOST_GetButtonState(GHOST_SystemHandle systemhandle,
434                                                                                    GHOST_TButtonMask mask,
435                                                                                    int* isDown);
436
437
438 /***************************************************************************************
439  ** Drag'n'drop operations
440  ***************************************************************************************/
441
442 /**
443  * Tells if the ongoing drag'n'drop object can be accepted upon mouse drop
444  */
445 extern void GHOST_setAcceptDragOperation(GHOST_WindowHandle windowhandle, GHOST_TInt8 canAccept);
446         
447         
448 /**
449  * Returns the event type.
450  * @param eventhandle The handle to the event
451  * @return The event type.
452  */
453 extern GHOST_TEventType GHOST_GetEventType(GHOST_EventHandle eventhandle);
454
455 /**
456  * Returns the time this event was generated.
457  * @param eventhandle The handle to the event
458  * @return The event generation time.
459  */
460 extern GHOST_TUns64 GHOST_GetEventTime(GHOST_EventHandle eventhandle);
461
462 /**
463  * Returns the window this event was generated on, 
464  * or NULL if it is a 'system' event.
465  * @param eventhandle The handle to the event
466  * @return The generating window.
467  */
468 extern GHOST_WindowHandle GHOST_GetEventWindow(GHOST_EventHandle eventhandle);
469
470 /**
471  * Returns the event data.
472  * @param eventhandle The handle to the event
473  * @return The event data.
474  */
475 extern GHOST_TEventDataPtr GHOST_GetEventData(GHOST_EventHandle eventhandle);
476
477 /**
478  * Returns the timer callback.
479  * @param timertaskhandle       The handle to the timertask
480  * @return The timer callback.
481  */
482 extern GHOST_TimerProcPtr GHOST_GetTimerProc(GHOST_TimerTaskHandle timertaskhandle);
483
484 /**
485  * Changes the timer callback.
486  * @param timertaskhandle The handle to the timertask
487  * @param timerProc The timer callback.
488  */
489 extern void GHOST_SetTimerProc(GHOST_TimerTaskHandle timertaskhandle,
490                                                            GHOST_TimerProcPtr timerProc);
491
492 /**
493  * Returns the timer user data.
494  * @param timertaskhandle       The handle to the timertask
495  * @return The timer user data.
496  */
497 extern GHOST_TUserDataPtr GHOST_GetTimerTaskUserData(GHOST_TimerTaskHandle timertaskhandle);
498         
499 /**
500  * Changes the time user data.
501  * @param timertaskhandle       The handle to the timertask
502  * @param data The timer user data.
503  */
504 extern void GHOST_SetTimerTaskUserData(GHOST_TimerTaskHandle timertaskhandle,
505                                                                            GHOST_TUserDataPtr userData);
506
507 /**
508  * Returns indication as to whether the window is valid.
509  * @param windowhandle The handle to the window
510  * @return The validity of the window.
511  */
512 extern int GHOST_GetValid(GHOST_WindowHandle windowhandle) ;
513
514 /**
515  * Returns the type of drawing context used in this window.
516  * @param windowhandle The handle to the window
517  * @return The current type of drawing context.
518  */
519 extern GHOST_TDrawingContextType GHOST_GetDrawingContextType(GHOST_WindowHandle windowhandle);
520
521 /**
522  * Tries to install a rendering context in this window.
523  * @param windowhandle The handle to the window
524  * @param type  The type of rendering context installed.
525  * @return Indication as to whether installation has succeeded.
526  */
527 extern GHOST_TSuccess GHOST_SetDrawingContextType(GHOST_WindowHandle windowhandle,
528                                                                                                   GHOST_TDrawingContextType type);
529
530 /**
531  * Sets the title displayed in the title bar.
532  * @param windowhandle The handle to the window
533  * @param title The title to display in the title bar.
534  */
535 extern void GHOST_SetTitle(GHOST_WindowHandle windowhandle,
536                                                    const char* title);
537
538 /**
539  * Returns the title displayed in the title bar. The title
540  * should be free'd with free().
541  * 
542  * @param windowhandle The handle to the window
543  * @return The title, free with free().
544  */
545 extern char* GHOST_GetTitle(GHOST_WindowHandle windowhandle);
546
547 /**
548  * Returns the window rectangle dimensions.
549  * These are screen coordinates.
550  * @param windowhandle The handle to the window
551  * @return A handle to the bounding rectangle of the window.
552  */
553 extern GHOST_RectangleHandle GHOST_GetWindowBounds(GHOST_WindowHandle windowhandle);
554
555 /**
556  * Returns the client rectangle dimensions.
557  * The left and top members of the rectangle are always zero.
558  * @param windowhandle The handle to the window
559  * @return A handle to the bounding rectangle of the window.
560  */
561 extern GHOST_RectangleHandle GHOST_GetClientBounds(GHOST_WindowHandle windowhandle);
562
563 /**
564  * Disposes a rectangle object
565  * @param rectanglehandle       Handle to the rectangle.
566  */
567 void GHOST_DisposeRectangle(GHOST_RectangleHandle rectanglehandle);
568
569 /**
570  * Resizes client rectangle width.
571  * @param windowhandle The handle to the window
572  * @param width The new width of the client area of the window.
573  * @return      Indication of success.
574  */
575 extern GHOST_TSuccess GHOST_SetClientWidth(GHOST_WindowHandle windowhandle,
576                                                                                    GHOST_TUns32 width);
577
578 /**
579  * Resizes client rectangle height.
580  * @param windowhandle The handle to the window
581  * @param height The new height of the client area of the window.
582  * @return      Indication of success.
583  */
584 extern GHOST_TSuccess GHOST_SetClientHeight(GHOST_WindowHandle windowhandle,
585                                                                                         GHOST_TUns32 height);
586
587 /**
588  * Resizes client rectangle.
589  * @param windowhandle The handle to the window
590  * @param width         The new width of the client area of the window.
591  * @param height        The new height of the client area of the window.
592  * @return                      Indication of success.
593  */
594 extern GHOST_TSuccess GHOST_SetClientSize(GHOST_WindowHandle windowhandle,
595                                                                                   GHOST_TUns32 width,
596                                                                                   GHOST_TUns32 height);
597
598 /**
599  * Converts a point in screen coordinates to client rectangle coordinates
600  * @param windowhandle The handle to the window
601  * @param inX   The x-coordinate on the screen.
602  * @param inY   The y-coordinate on the screen.
603  * @param outX  The x-coordinate in the client rectangle.
604  * @param outY  The y-coordinate in the client rectangle.
605  */
606 extern void GHOST_ScreenToClient(GHOST_WindowHandle windowhandle,
607                                                                  GHOST_TInt32 inX,
608                                                                  GHOST_TInt32 inY,
609                                                                  GHOST_TInt32* outX,
610                                                                  GHOST_TInt32* outY) ;
611
612 /**
613  * Converts a point in screen coordinates to client rectangle coordinates
614  * @param windowhandle The handle to the window
615  * @param inX   The x-coordinate in the client rectangle.
616  * @param inY   The y-coordinate in the client rectangle.
617  * @param outX  The x-coordinate on the screen.
618  * @param outY  The y-coordinate on the screen.
619  */
620 extern void GHOST_ClientToScreen(GHOST_WindowHandle windowhandle,
621                                                                  GHOST_TInt32 inX,
622                                                                  GHOST_TInt32 inY,
623                                                                  GHOST_TInt32* outX,
624                                                                  GHOST_TInt32* outY);
625
626 /**
627  * Returns the state of the window (normal, minimized, maximized).
628  * @param windowhandle The handle to the window
629  * @return The state of the window.
630  */
631 extern GHOST_TWindowState GHOST_GetWindowState(GHOST_WindowHandle windowhandle);
632
633 /**
634  * Sets the state of the window (normal, minimized, maximized).
635  * @param windowhandle The handle to the window
636  * @param state The state of the window.
637  * @return Indication of success.
638  */
639 extern GHOST_TSuccess GHOST_SetWindowState(GHOST_WindowHandle windowhandle,
640                                                                                    GHOST_TWindowState state);
641
642         
643 /**
644  * Sets the window "modified" status, indicating unsaved changes
645  * @param windowhandle The handle to the window
646  * @param isUnsavedChanges Unsaved changes or not
647  * @return Indication of success.
648  */
649 extern GHOST_TSuccess GHOST_SetWindowModifiedState(GHOST_WindowHandle windowhandle,
650                                                                                                    GHOST_TUns8 isUnsavedChanges);
651         
652 /**
653  * Sets the order of the window (bottom, top).
654  * @param windowhandle The handle to the window
655  * @param order The order of the window.
656  * @return Indication of success.
657  */
658 extern GHOST_TSuccess GHOST_SetWindowOrder(GHOST_WindowHandle windowhandle,
659                                                                                    GHOST_TWindowOrder order);
660
661 /**
662  * Swaps front and back buffers of a window.
663  * @param windowhandle The handle to the window
664  * @return      An intean success indicator.
665  */
666 extern GHOST_TSuccess GHOST_SwapWindowBuffers(GHOST_WindowHandle windowhandle);
667
668 /**
669  * Activates the drawing context of this window.
670  * @param windowhandle The handle to the window
671  * @return      An intean success indicator.
672  */
673 extern GHOST_TSuccess GHOST_ActivateWindowDrawingContext(GHOST_WindowHandle windowhandle);
674
675 /**
676  * Invalidates the contents of this window.
677  * @param windowhandle The handle to the window
678  * @return Indication of success.
679  */
680 extern GHOST_TSuccess GHOST_InvalidateWindow(GHOST_WindowHandle windowhandle);
681
682 /**
683  * Returns the status of the tablet
684  * @param windowhandle The handle to the window
685  * @return Status of tablet
686  */
687 extern const GHOST_TabletData *GHOST_GetTabletData(GHOST_WindowHandle windowhandle);
688
689 /**
690  * Access to rectangle width.
691  * @param rectanglehandle The handle to the rectangle
692  * @return      width of the rectangle
693  */
694 extern GHOST_TInt32 GHOST_GetWidthRectangle(GHOST_RectangleHandle rectanglehandle);
695
696 /**
697  * Access to rectangle height.
698  * @param rectanglehandle The handle to the rectangle
699  * @return      height of the rectangle
700  */
701 extern GHOST_TInt32 GHOST_GetHeightRectangle(GHOST_RectangleHandle rectanglehandle);
702
703 /**
704  * Gets all members of the rectangle.
705  * @param rectanglehandle The handle to the rectangle
706  * @param       l       Pointer to return left coordinate in.
707  * @param       t       Pointer to return top coordinate in.
708  * @param       r       Pointer to return right coordinate in.
709  * @param       b       Pointer to return bottom coordinate in.
710  */
711 extern void GHOST_GetRectangle(GHOST_RectangleHandle rectanglehandle,
712                                                            GHOST_TInt32* l,
713                                                            GHOST_TInt32* t,
714                                                            GHOST_TInt32* r,
715                                                            GHOST_TInt32* b);
716
717 /**
718  * Sets all members of the rectangle.
719  * @param rectanglehandle The handle to the rectangle
720  * @param       l       requested left coordinate of the rectangle
721  * @param       t       requested top coordinate of the rectangle
722  * @param       r       requested right coordinate of the rectangle
723  * @param       b       requested bottom coordinate of the rectangle
724  */
725 extern void GHOST_SetRectangle(GHOST_RectangleHandle rectanglehandle,
726                                                            GHOST_TInt32 l,
727                                                            GHOST_TInt32 t,
728                                                            GHOST_TInt32 r,
729                                                            GHOST_TInt32 b);
730
731 /**
732  * Returns whether this rectangle is empty.
733  * Empty rectangles are rectangles that have width==0 and/or height==0.
734  * @param rectanglehandle The handle to the rectangle
735  * @return      intean value (true == empty rectangle)
736  */
737 extern GHOST_TSuccess GHOST_IsEmptyRectangle(GHOST_RectangleHandle rectanglehandle);
738
739 /**
740  * Returns whether this rectangle is valid.
741  * Valid rectangles are rectangles that have m_l <= m_r and m_t <= m_b. Thus, emapty rectangles are valid.
742  * @param rectanglehandle The handle to the rectangle
743  * @return      intean value (true==valid rectangle)
744  */
745 extern GHOST_TSuccess GHOST_IsValidRectangle(GHOST_RectangleHandle rectanglehandle);
746
747 /**
748  * Grows (or shrinks the rectangle).
749  * The method avoids negative insets making the rectangle invalid
750  * @param rectanglehandle The handle to the rectangle
751  * @param       i       The amount of offset given to each extreme (negative values shrink the rectangle).
752  */
753 extern void GHOST_InsetRectangle(GHOST_RectangleHandle rectanglehandle,
754                                                                  GHOST_TInt32 i);
755
756 /**
757  * Does a union of the rectangle given and this rectangle.
758  * The result is stored in this rectangle.
759  * @param rectanglehandle The handle to the rectangle
760  * @param       r       The rectangle that is input for the union operation.
761  */
762 extern void GHOST_UnionRectangle(GHOST_RectangleHandle rectanglehandle,
763                                                                  GHOST_RectangleHandle anotherrectanglehandle);
764
765 /**
766  * Grows the rectangle to included a point.
767  * @param rectanglehandle The handle to the rectangle
768  * @param       x       The x-coordinate of the point.
769  * @param       y       The y-coordinate of the point.
770  */
771 extern void GHOST_UnionPointRectangle(GHOST_RectangleHandle rectanglehandle,
772                                                                           GHOST_TInt32 x,
773                                                                           GHOST_TInt32 y);
774
775 /**
776  * Returns whether the point is inside this rectangle.
777  * Point on the boundary is considered inside.
778  * @param rectanglehandle The handle to the rectangle
779  * @param x     x-coordinate of point to test.
780  * @param y y-coordinate of point to test.
781  * @return intean value (true if point is inside).
782  */
783 extern GHOST_TSuccess GHOST_IsInsideRectangle(GHOST_RectangleHandle rectanglehandle,
784                                                                                           GHOST_TInt32 x,
785                                                                                           GHOST_TInt32 y);
786
787 /**
788  * Returns whether the rectangle is inside this rectangle.
789  * @param rectanglehandle The handle to the rectangle
790  * @param       r       rectangle to test.
791  * @return      visibility (not, partially or fully visible).
792  */
793 extern GHOST_TVisibility GHOST_GetRectangleVisibility(GHOST_RectangleHandle rectanglehandle,
794                                                                                                           GHOST_RectangleHandle anotherrectanglehandle);
795
796 /**
797  * Sets rectangle members.
798  * Sets rectangle members such that it is centered at the given location.
799  * @param rectanglehandle The handle to the rectangle
800  * @param       cx      requested center x-coordinate of the rectangle
801  * @param       cy      requested center y-coordinate of the rectangle
802  */
803 extern void GHOST_SetCenterRectangle(GHOST_RectangleHandle rectanglehandle,
804                                                                          GHOST_TInt32 cx,
805                                                                          GHOST_TInt32 cy);
806
807 /**
808  * Sets rectangle members.
809  * Sets rectangle members such that it is centered at the given location,
810  * with the width requested.
811  * @param rectanglehandle The handle to the rectangle
812  * @param       cx      requested center x-coordinate of the rectangle
813  * @param       cy      requested center y-coordinate of the rectangle
814  * @param       w       requested width of the rectangle
815  * @param       h       requested height of the rectangle
816  */
817 extern void GHOST_SetRectangleCenter(GHOST_RectangleHandle rectanglehandle,
818                                                                          GHOST_TInt32 cx,
819                                                                          GHOST_TInt32 cy,
820                                                                          GHOST_TInt32 w,
821                                                                          GHOST_TInt32 h);
822
823 /**
824  * Clips a rectangle.
825  * Updates the rectangle given such that it will fit within this one.
826  * This can result in an empty rectangle.
827  * @param rectanglehandle The handle to the rectangle
828  * @param       r       the rectangle to clip
829  * @return      whether clipping has occurred
830  */
831 extern GHOST_TSuccess GHOST_ClipRectangle(GHOST_RectangleHandle rectanglehandle,
832                                                                                   GHOST_RectangleHandle anotherrectanglehandle);
833
834 /**
835  * Return the data from the clipboad
836  * @param       return the selection instead, X11 only feature
837  * @return      clipboard data
838  */
839 extern GHOST_TUns8* GHOST_getClipboard(int selection);
840
841 /**
842  * Put data to the Clipboard
843  * @param       set the selection instead, X11 only feature
844  */
845 extern void GHOST_putClipboard(GHOST_TInt8 *buffer, int selection);
846
847
848
849 /**
850  * Toggles console
851  * @action      0 - Hides
852  *                      1 - Shows
853  *                      2 - Toggles
854  *                      3 - Hides if it runs not from  command line
855  *                      * - Does nothing
856  * @return current status (1 -visible, 0 - hidden)
857  */
858 extern int GHOST_toggleConsole(int action);
859
860 #ifdef __cplusplus
861 }
862 #endif
863
864 #endif