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