Drag'n'drop : moved "setAcceptDragOperation" functions at window level
[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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18  *
19  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
20  * All rights reserved.
21  *
22  * The Original Code is: all of this file.
23  *
24  * Contributor(s): none yet.
25  *
26  * ***** END GPL LICENSE BLOCK *****
27  */
28 /**
29  * @file        GHOST_C-api.h
30  * GHOST C-API function and type declarations.
31  * The C-API wraps the C++ objects with the 
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 #define GHOST_DECLARE_HANDLE(name) typedef struct name##__ { int unused; } *name
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  * @return      A handle to the new window ( == NULL if creation failed).
166  */
167 extern GHOST_WindowHandle GHOST_CreateWindow(GHOST_SystemHandle systemhandle,
168         char* title,
169         GHOST_TInt32 left,
170         GHOST_TInt32 top,
171         GHOST_TUns32 width,
172         GHOST_TUns32 height,
173         GHOST_TWindowState state,
174         GHOST_TDrawingContextType type,
175         const int stereoVisual);
176
177 /**
178  * Returns the window user data.
179  * @param windowhandle  The handle to the window
180  * @return The window user data.
181  */
182 extern GHOST_TUserDataPtr GHOST_GetWindowUserData(GHOST_WindowHandle windowhandle);
183         
184 /**
185  * Changes the window user data.
186  * @param windowhandle  The handle to the window
187  * @param data The window user data.
188  */
189 extern void GHOST_SetWindowUserData(GHOST_WindowHandle windowhandle, 
190         GHOST_TUserDataPtr userdata);
191
192 /**
193  * Dispose a window.
194  * @param systemhandle The handle to the system
195  * @param       window Handle to the window to be disposed.
196  * @return      Indication of success.
197  */
198 extern GHOST_TSuccess GHOST_DisposeWindow(GHOST_SystemHandle systemhandle,
199                                                                                   GHOST_WindowHandle windowhandle);
200
201 /**
202  * Returns whether a window is valid.
203  * @param systemhandle The handle to the system
204  * @param       window Handle to the window to be checked.
205  * @return      Indication of validity.
206  */
207 extern int GHOST_ValidWindow(GHOST_SystemHandle systemhandle,
208                                                                                 GHOST_WindowHandle windowhandle);
209
210 /**
211  * Begins full screen mode.
212  * @param systemhandle The handle to the system
213  * @param setting       The new setting of the display.
214  * @return                      A handle to the window displayed in full screen.
215  *                                      This window is invalid after full screen has been ended.
216  */
217 extern GHOST_WindowHandle GHOST_BeginFullScreen(GHOST_SystemHandle systemhandle,
218         GHOST_DisplaySetting* setting,
219         const int stereoVisual);
220
221 /**
222  * Ends full screen mode.
223  * @param systemhandle The handle to the system
224  * @return      Indication of success.
225  */
226 extern GHOST_TSuccess GHOST_EndFullScreen(GHOST_SystemHandle systemhandle);
227
228 /**
229  * Returns current full screen mode status.
230  * @param systemhandle The handle to the system
231  * @return The current status.
232  */
233 extern int GHOST_GetFullScreen(GHOST_SystemHandle systemhandle);
234
235 /***************************************************************************************
236  ** Event management functionality
237  ***************************************************************************************/
238
239 /**
240  * Retrieves events from the system and stores them in the queue.
241  * @param systemhandle The handle to the system
242  * @param waitForEvent Boolean to indicate that ProcessEvents should
243  * wait (block) until the next event before returning.
244  * @return Indication of the presence of events.
245  */
246 extern int GHOST_ProcessEvents(GHOST_SystemHandle systemhandle, int waitForEvent);
247
248 /**
249  * Retrieves events from the queue and send them to the event consumers.
250  * @param systemhandle The handle to the system
251  * @return Indication of the presence of events.
252  */
253 extern int GHOST_DispatchEvents(GHOST_SystemHandle systemhandle);
254
255 /**
256  * Adds the given event consumer to our list.
257  * @param systemhandle The handle to the system
258  * @param consumerhandle The event consumer to add.
259  * @return Indication of success.
260  */
261 extern GHOST_TSuccess GHOST_AddEventConsumer(GHOST_SystemHandle systemhandle,
262                                                                                           GHOST_EventConsumerHandle consumerhandle);
263         
264
265 /***************************************************************************************
266  ** N-degree of freedom device management functionality
267  ***************************************************************************************/
268  
269 /**
270 * Open N-degree of freedom devices
271  */
272 extern int GHOST_OpenNDOF(GHOST_SystemHandle systemhandle, 
273                            GHOST_WindowHandle windowhandle,
274                           GHOST_NDOFLibraryInit_fp setNdofLibraryInit, 
275                           GHOST_NDOFLibraryShutdown_fp setNdofLibraryShutdown,
276                           GHOST_NDOFDeviceOpen_fp setNdofDeviceOpen
277                           );
278
279 /***************************************************************************************
280  ** Cursor management functionality
281  ***************************************************************************************/
282
283 /**
284  * Returns the current cursor shape.
285  * @param windowhandle The handle to the window
286  * @return      The current cursor shape.
287  */
288 extern GHOST_TStandardCursor GHOST_GetCursorShape(GHOST_WindowHandle windowhandle);
289
290 /**
291  * Set the shape of the cursor.
292  * @param windowhandle The handle to the window
293  * @param       cursor  The new cursor shape type id.
294  * @return      Indication of success.
295  */
296 extern GHOST_TSuccess GHOST_SetCursorShape(GHOST_WindowHandle windowhandle,
297                                                                                    GHOST_TStandardCursor cursorshape);
298
299 /**
300  * Set the shape of the cursor to a custom cursor.
301  * @param windowhandle The handle to the window
302  * @param       bitmap  The bitmap data for the cursor.
303  * @param       mask    The mask data for the cursor.
304  * @param       hotX    The X coordinate of the cursor hotspot.
305  * @param       hotY    The Y coordinate of the cursor hotspot.
306  * @return      Indication of success.
307  */
308 extern GHOST_TSuccess GHOST_SetCustomCursorShape(GHOST_WindowHandle windowhandle,
309                                                                                                  GHOST_TUns8 bitmap[16][2], 
310                                                                                                  GHOST_TUns8 mask[16][2], 
311                                                                                                  int hotX, 
312                                                                                                  int hotY);
313 /**
314  * Set the shape of the cursor to a custom cursor of specified size.
315  * @param windowhandle The handle to the window
316  * @param       bitmap  The bitmap data for the cursor.
317  * @param       mask    The mask data for the cursor.
318  * @parm    sizex, sizey  The size of the cursor
319  * @param       hotX    The X coordinate of the cursor hotspot.
320  * @param       hotY    The Y coordinate of the cursor hotspot.
321  * @param   fg_color, bg_color  Colors of the cursor
322  * @return      Indication of success.
323   */
324 extern GHOST_TSuccess GHOST_SetCustomCursorShapeEx(GHOST_WindowHandle windowhandle,
325                                                                                                  GHOST_TUns8 *bitmap, 
326                                                                                                  GHOST_TUns8 *mask, 
327                                                                                                  int sizex, int sizey, 
328                                                                                                  int hotX,  int hotY,
329                                                                                                  int fg_color, int bg_color );
330
331 /**
332  * Returns the visibility state of the cursor.
333  * @param windowhandle The handle to the window
334  * @return      The visibility state of the cursor.
335  */
336 extern int GHOST_GetCursorVisibility(GHOST_WindowHandle windowhandle);
337
338 /**
339  * Shows or hides the cursor.
340  * @param windowhandle The handle to the window
341  * @param       visible The new visibility state of the cursor.
342  * @return      Indication of success.
343  */
344 extern GHOST_TSuccess GHOST_SetCursorVisibility(GHOST_WindowHandle windowhandle,
345                                                                                                 int visible);
346
347 /**
348  * Returns the current location of the cursor (location in screen coordinates)
349  * @param systemhandle The handle to the system
350  * @param x                     The x-coordinate of the cursor.
351  * @param y                     The y-coordinate of the cursor.
352  * @return                      Indication of success.
353  */
354 extern GHOST_TSuccess GHOST_GetCursorPosition(GHOST_SystemHandle systemhandle,
355                                                                                           GHOST_TInt32* x,
356                                                                                           GHOST_TInt32* y);
357
358 /**
359  * Updates the location of the cursor (location in screen coordinates).
360  * Not all operating systems allow the cursor to be moved (without the input device being moved).
361  * @param systemhandle The handle to the system
362  * @param x                     The x-coordinate of the cursor.
363  * @param y                     The y-coordinate of the cursor.
364  * @return                      Indication of success.
365  */
366 extern GHOST_TSuccess GHOST_SetCursorPosition(GHOST_SystemHandle systemhandle,
367                                                                                           GHOST_TInt32 x,
368                                                                                           GHOST_TInt32 y);
369
370 /**
371  * Grabs the cursor for a modal operation, to keep receiving
372  * events when the mouse is outside the window. X11 only, others
373  * do this automatically.
374  * @param windowhandle The handle to the window
375  * @param       mode The new grab state of the cursor.
376  * @param       bounds The grab ragion (optional) - left,top,right,bottom
377  * @return      Indication of success.
378  */
379 extern GHOST_TSuccess GHOST_SetCursorGrab(GHOST_WindowHandle windowhandle,
380                                                                                                 GHOST_TGrabCursorMode mode,
381                                                                                                 int* bounds);
382
383 /***************************************************************************************
384  ** Access to mouse button and keyboard states.
385  ***************************************************************************************/
386
387 /**
388  * Returns the state of a modifier key (ouside the message queue).
389  * @param systemhandle The handle to the system
390  * @param mask          The modifier key state to retrieve.
391  * @param isDown        Pointer to return modifier state in.
392  * @return                      Indication of success.
393  */
394 extern GHOST_TSuccess GHOST_GetModifierKeyState(GHOST_SystemHandle systemhandle,
395                                                                                                 GHOST_TModifierKeyMask mask,
396                                                                                                 int* isDown);
397
398 /**
399  * Returns the state of a mouse button (ouside the message queue).
400  * @param systemhandle The handle to the system
401  * @param mask          The button state to retrieve.
402  * @param isDown        Pointer to return button state in.
403  * @return                      Indication of success.
404  */
405 extern GHOST_TSuccess GHOST_GetButtonState(GHOST_SystemHandle systemhandle,
406                                                                                    GHOST_TButtonMask mask,
407                                                                                    int* isDown);
408
409
410 /***************************************************************************************
411  ** Drag'n'drop operations
412  ***************************************************************************************/
413
414 /**
415  * Tells if the ongoing drag'n'drop object can be accepted upon mouse drop
416  */
417 extern void GHOST_setAcceptDragOperation(GHOST_WindowHandle windowhandle, GHOST_TInt8 canAccept);
418         
419         
420 /**
421  * Returns the event type.
422  * @param eventhandle The handle to the event
423  * @return The event type.
424  */
425 extern GHOST_TEventType GHOST_GetEventType(GHOST_EventHandle eventhandle);
426
427 /**
428  * Returns the time this event was generated.
429  * @param eventhandle The handle to the event
430  * @return The event generation time.
431  */
432 extern GHOST_TUns64 GHOST_GetEventTime(GHOST_EventHandle eventhandle);
433
434 /**
435  * Returns the window this event was generated on, 
436  * or NULL if it is a 'system' event.
437  * @param eventhandle The handle to the event
438  * @return The generating window.
439  */
440 extern GHOST_WindowHandle GHOST_GetEventWindow(GHOST_EventHandle eventhandle);
441
442 /**
443  * Returns the event data.
444  * @param eventhandle The handle to the event
445  * @return The event data.
446  */
447 extern GHOST_TEventDataPtr GHOST_GetEventData(GHOST_EventHandle eventhandle);
448
449 /**
450  * Returns the timer callback.
451  * @param timertaskhandle       The handle to the timertask
452  * @return The timer callback.
453  */
454 extern GHOST_TimerProcPtr GHOST_GetTimerProc(GHOST_TimerTaskHandle timertaskhandle);
455
456 /**
457  * Changes the timer callback.
458  * @param timertaskhandle The handle to the timertask
459  * @param timerProc The timer callback.
460  */
461 extern void GHOST_SetTimerProc(GHOST_TimerTaskHandle timertaskhandle,
462                                                            GHOST_TimerProcPtr timerProc);
463
464 /**
465  * Returns the timer user data.
466  * @param timertaskhandle       The handle to the timertask
467  * @return The timer user data.
468  */
469 extern GHOST_TUserDataPtr GHOST_GetTimerTaskUserData(GHOST_TimerTaskHandle timertaskhandle);
470         
471 /**
472  * Changes the time user data.
473  * @param timertaskhandle       The handle to the timertask
474  * @param data The timer user data.
475  */
476 extern void GHOST_SetTimerTaskUserData(GHOST_TimerTaskHandle timertaskhandle,
477                                                                            GHOST_TUserDataPtr userData);
478
479 /**
480  * Returns indication as to whether the window is valid.
481  * @param windowhandle The handle to the window
482  * @return The validity of the window.
483  */
484 extern int GHOST_GetValid(GHOST_WindowHandle windowhandle) ;
485
486 /**
487  * Returns the type of drawing context used in this window.
488  * @param windowhandle The handle to the window
489  * @return The current type of drawing context.
490  */
491 extern GHOST_TDrawingContextType GHOST_GetDrawingContextType(GHOST_WindowHandle windowhandle);
492
493 /**
494  * Tries to install a rendering context in this window.
495  * @param windowhandle The handle to the window
496  * @param type  The type of rendering context installed.
497  * @return Indication as to whether installation has succeeded.
498  */
499 extern GHOST_TSuccess GHOST_SetDrawingContextType(GHOST_WindowHandle windowhandle,
500                                                                                                   GHOST_TDrawingContextType type);
501
502 /**
503  * Sets the title displayed in the title bar.
504  * @param windowhandle The handle to the window
505  * @param title The title to display in the title bar.
506  */
507 extern void GHOST_SetTitle(GHOST_WindowHandle windowhandle,
508                                                    char* title);
509
510 /**
511  * Returns the title displayed in the title bar. The title
512  * should be free'd with free().
513  * 
514  * @param windowhandle The handle to the window
515  * @return The title, free with free().
516  */
517 extern char* GHOST_GetTitle(GHOST_WindowHandle windowhandle);
518
519 /**
520  * Returns the window rectangle dimensions.
521  * These are screen coordinates.
522  * @param windowhandle The handle to the window
523  * @return A handle to the bounding rectangle of the window.
524  */
525 extern GHOST_RectangleHandle GHOST_GetWindowBounds(GHOST_WindowHandle windowhandle);
526
527 /**
528  * Returns the client rectangle dimensions.
529  * The left and top members of the rectangle are always zero.
530  * @param windowhandle The handle to the window
531  * @return A handle to the bounding rectangle of the window.
532  */
533 extern GHOST_RectangleHandle GHOST_GetClientBounds(GHOST_WindowHandle windowhandle);
534
535 /**
536  * Disposes a rectangle object
537  * @param rectanglehandle       Handle to the rectangle.
538  */
539 void GHOST_DisposeRectangle(GHOST_RectangleHandle rectanglehandle);
540
541 /**
542  * Resizes client rectangle width.
543  * @param windowhandle The handle to the window
544  * @param width The new width of the client area of the window.
545  * @return      Indication of success.
546  */
547 extern GHOST_TSuccess GHOST_SetClientWidth(GHOST_WindowHandle windowhandle,
548                                                                                    GHOST_TUns32 width);
549
550 /**
551  * Resizes client rectangle height.
552  * @param windowhandle The handle to the window
553  * @param height The new height of the client area of the window.
554  * @return      Indication of success.
555  */
556 extern GHOST_TSuccess GHOST_SetClientHeight(GHOST_WindowHandle windowhandle,
557                                                                                         GHOST_TUns32 height);
558
559 /**
560  * Resizes client rectangle.
561  * @param windowhandle The handle to the window
562  * @param width         The new width of the client area of the window.
563  * @param height        The new height of the client area of the window.
564  * @return                      Indication of success.
565  */
566 extern GHOST_TSuccess GHOST_SetClientSize(GHOST_WindowHandle windowhandle,
567                                                                                   GHOST_TUns32 width,
568                                                                                   GHOST_TUns32 height);
569
570 /**
571  * Converts a point in screen coordinates to client rectangle coordinates
572  * @param windowhandle The handle to the window
573  * @param inX   The x-coordinate on the screen.
574  * @param inY   The y-coordinate on the screen.
575  * @param outX  The x-coordinate in the client rectangle.
576  * @param outY  The y-coordinate in the client rectangle.
577  */
578 extern void GHOST_ScreenToClient(GHOST_WindowHandle windowhandle,
579                                                                  GHOST_TInt32 inX,
580                                                                  GHOST_TInt32 inY,
581                                                                  GHOST_TInt32* outX,
582                                                                  GHOST_TInt32* outY) ;
583
584 /**
585  * Converts a point in screen coordinates to client rectangle coordinates
586  * @param windowhandle The handle to the window
587  * @param inX   The x-coordinate in the client rectangle.
588  * @param inY   The y-coordinate in the client rectangle.
589  * @param outX  The x-coordinate on the screen.
590  * @param outY  The y-coordinate on the screen.
591  */
592 extern void GHOST_ClientToScreen(GHOST_WindowHandle windowhandle,
593                                                                  GHOST_TInt32 inX,
594                                                                  GHOST_TInt32 inY,
595                                                                  GHOST_TInt32* outX,
596                                                                  GHOST_TInt32* outY);
597
598 /**
599  * Returns the state of the window (normal, minimized, maximized).
600  * @param windowhandle The handle to the window
601  * @return The state of the window.
602  */
603 extern GHOST_TWindowState GHOST_GetWindowState(GHOST_WindowHandle windowhandle);
604
605 /**
606  * Sets the state of the window (normal, minimized, maximized).
607  * @param windowhandle The handle to the window
608  * @param state The state of the window.
609  * @return Indication of success.
610  */
611 extern GHOST_TSuccess GHOST_SetWindowState(GHOST_WindowHandle windowhandle,
612                                                                                    GHOST_TWindowState state);
613
614         
615 /**
616  * Sets the window "modified" status, indicating unsaved changes
617  * @param windowhandle The handle to the window
618  * @param isUnsavedChanges Unsaved changes or not
619  * @return Indication of success.
620  */
621 extern GHOST_TSuccess GHOST_SetWindowModifiedState(GHOST_WindowHandle windowhandle,
622                                                                                                    GHOST_TUns8 isUnsavedChanges);
623         
624 /**
625  * Sets the order of the window (bottom, top).
626  * @param windowhandle The handle to the window
627  * @param order The order of the window.
628  * @return Indication of success.
629  */
630 extern GHOST_TSuccess GHOST_SetWindowOrder(GHOST_WindowHandle windowhandle,
631                                                                                    GHOST_TWindowOrder order);
632
633 /**
634  * Swaps front and back buffers of a window.
635  * @param windowhandle The handle to the window
636  * @return      An intean success indicator.
637  */
638 extern GHOST_TSuccess GHOST_SwapWindowBuffers(GHOST_WindowHandle windowhandle);
639
640 /**
641  * Activates the drawing context of this window.
642  * @param windowhandle The handle to the window
643  * @return      An intean success indicator.
644  */
645 extern GHOST_TSuccess GHOST_ActivateWindowDrawingContext(GHOST_WindowHandle windowhandle);
646
647 /**
648  * Invalidates the contents of this window.
649  * @param windowhandle The handle to the window
650  * @return Indication of success.
651  */
652 extern GHOST_TSuccess GHOST_InvalidateWindow(GHOST_WindowHandle windowhandle);
653
654 /**
655  * Returns the status of the tablet
656  * @param windowhandle The handle to the window
657  * @return Status of tablet
658  */
659 extern const GHOST_TabletData *GHOST_GetTabletData(GHOST_WindowHandle windowhandle);
660
661 /**
662  * Access to rectangle width.
663  * @param rectanglehandle The handle to the rectangle
664  * @return      width of the rectangle
665  */
666 extern GHOST_TInt32 GHOST_GetWidthRectangle(GHOST_RectangleHandle rectanglehandle);
667
668 /**
669  * Access to rectangle height.
670  * @param rectanglehandle The handle to the rectangle
671  * @return      height of the rectangle
672  */
673 extern GHOST_TInt32 GHOST_GetHeightRectangle(GHOST_RectangleHandle rectanglehandle);
674
675 /**
676  * Gets all members of the rectangle.
677  * @param rectanglehandle The handle to the rectangle
678  * @param       l       Pointer to return left coordinate in.
679  * @param       t       Pointer to return top coordinate in.
680  * @param       r       Pointer to return right coordinate in.
681  * @param       b       Pointer to return bottom coordinate in.
682  */
683 extern void GHOST_GetRectangle(GHOST_RectangleHandle rectanglehandle,
684                                                            GHOST_TInt32* l,
685                                                            GHOST_TInt32* t,
686                                                            GHOST_TInt32* r,
687                                                            GHOST_TInt32* b);
688
689 /**
690  * Sets all members of the rectangle.
691  * @param rectanglehandle The handle to the rectangle
692  * @param       l       requested left coordinate of the rectangle
693  * @param       t       requested top coordinate of the rectangle
694  * @param       r       requested right coordinate of the rectangle
695  * @param       b       requested bottom coordinate of the rectangle
696  */
697 extern void GHOST_SetRectangle(GHOST_RectangleHandle rectanglehandle,
698                                                            GHOST_TInt32 l,
699                                                            GHOST_TInt32 t,
700                                                            GHOST_TInt32 r,
701                                                            GHOST_TInt32 b);
702
703 /**
704  * Returns whether this rectangle is empty.
705  * Empty rectangles are rectangles that have width==0 and/or height==0.
706  * @param rectanglehandle The handle to the rectangle
707  * @return      intean value (true == empty rectangle)
708  */
709 extern GHOST_TSuccess GHOST_IsEmptyRectangle(GHOST_RectangleHandle rectanglehandle);
710
711 /**
712  * Returns whether this rectangle is valid.
713  * Valid rectangles are rectangles that have m_l <= m_r and m_t <= m_b. Thus, emapty rectangles are valid.
714  * @param rectanglehandle The handle to the rectangle
715  * @return      intean value (true==valid rectangle)
716  */
717 extern GHOST_TSuccess GHOST_IsValidRectangle(GHOST_RectangleHandle rectanglehandle);
718
719 /**
720  * Grows (or shrinks the rectangle).
721  * The method avoids negative insets making the rectangle invalid
722  * @param rectanglehandle The handle to the rectangle
723  * @param       i       The amount of offset given to each extreme (negative values shrink the rectangle).
724  */
725 extern void GHOST_InsetRectangle(GHOST_RectangleHandle rectanglehandle,
726                                                                  GHOST_TInt32 i);
727
728 /**
729  * Does a union of the rectangle given and this rectangle.
730  * The result is stored in this rectangle.
731  * @param rectanglehandle The handle to the rectangle
732  * @param       r       The rectangle that is input for the union operation.
733  */
734 extern void GHOST_UnionRectangle(GHOST_RectangleHandle rectanglehandle,
735                                                                  GHOST_RectangleHandle anotherrectanglehandle);
736
737 /**
738  * Grows the rectangle to included a point.
739  * @param rectanglehandle The handle to the rectangle
740  * @param       x       The x-coordinate of the point.
741  * @param       y       The y-coordinate of the point.
742  */
743 extern void GHOST_UnionPointRectangle(GHOST_RectangleHandle rectanglehandle,
744                                                                           GHOST_TInt32 x,
745                                                                           GHOST_TInt32 y);
746
747 /**
748  * Returns whether the point is inside this rectangle.
749  * Point on the boundary is considered inside.
750  * @param rectanglehandle The handle to the rectangle
751  * @param x     x-coordinate of point to test.
752  * @param y y-coordinate of point to test.
753  * @return intean value (true if point is inside).
754  */
755 extern GHOST_TSuccess GHOST_IsInsideRectangle(GHOST_RectangleHandle rectanglehandle,
756                                                                                           GHOST_TInt32 x,
757                                                                                           GHOST_TInt32 y);
758
759 /**
760  * Returns whether the rectangle is inside this rectangle.
761  * @param rectanglehandle The handle to the rectangle
762  * @param       r       rectangle to test.
763  * @return      visibility (not, partially or fully visible).
764  */
765 extern GHOST_TVisibility GHOST_GetRectangleVisibility(GHOST_RectangleHandle rectanglehandle,
766                                                                                                           GHOST_RectangleHandle anotherrectanglehandle);
767
768 /**
769  * Sets rectangle members.
770  * Sets rectangle members such that it is centered at the given location.
771  * @param rectanglehandle The handle to the rectangle
772  * @param       cx      requested center x-coordinate of the rectangle
773  * @param       cy      requested center y-coordinate of the rectangle
774  */
775 extern void GHOST_SetCenterRectangle(GHOST_RectangleHandle rectanglehandle,
776                                                                          GHOST_TInt32 cx,
777                                                                          GHOST_TInt32 cy);
778
779 /**
780  * Sets rectangle members.
781  * Sets rectangle members such that it is centered at the given location,
782  * with the width requested.
783  * @param rectanglehandle The handle to the rectangle
784  * @param       cx      requested center x-coordinate of the rectangle
785  * @param       cy      requested center y-coordinate of the rectangle
786  * @param       w       requested width of the rectangle
787  * @param       h       requested height of the rectangle
788  */
789 extern void GHOST_SetRectangleCenter(GHOST_RectangleHandle rectanglehandle,
790                                                                          GHOST_TInt32 cx,
791                                                                          GHOST_TInt32 cy,
792                                                                          GHOST_TInt32 w,
793                                                                          GHOST_TInt32 h);
794
795 /**
796  * Clips a rectangle.
797  * Updates the rectangle given such that it will fit within this one.
798  * This can result in an empty rectangle.
799  * @param rectanglehandle The handle to the rectangle
800  * @param       r       the rectangle to clip
801  * @return      whether clipping has occurred
802  */
803 extern GHOST_TSuccess GHOST_ClipRectangle(GHOST_RectangleHandle rectanglehandle,
804                                                                                   GHOST_RectangleHandle anotherrectanglehandle);
805
806 /**
807  * Return the data from the clipboad
808  * @param       return the selection instead, X11 only feature
809  * @return      clipboard data
810  */
811 extern GHOST_TUns8* GHOST_getClipboard(int selection);
812
813 /**
814  * Put data to the Clipboard
815  * @param       set the selection instead, X11 only feature
816  */
817 extern void GHOST_putClipboard(GHOST_TInt8 *buffer, int selection);
818
819 #ifdef __cplusplus
820 }
821 #endif
822
823 #endif