home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / evbl0627.zip / everblue_20010627.zip / x11 / Xlib_Grab.c < prev    next >
C/C++ Source or Header  |  1999-11-02  |  7KB  |  280 lines
  1. #include "Xlib_private.h"
  2.  
  3. /* I originally was going to use WinSetCapture() for capturing
  4.  mouse input, but since I needed to grab other info from the
  5.  system input queue I decided to implement it the same way.
  6.  Brian Smith
  7.  */
  8.  
  9. #include "x11pmvk.h"
  10.  
  11. Xlib_Grab *__GrabNull(void)
  12. {
  13.     return NULL;
  14. }
  15.  
  16. void __GrabVoid(void)
  17. {
  18.     return;
  19. }
  20.  
  21. Xlib_Grab *(*Xlib_NewGrab)(void) = __GrabNull;
  22. void (*Xlib_RemoveGrab)(int) = __GrabVoid;
  23. void (*Xlib_RemoveGrabAny)(int) = __GrabVoid;
  24. Xlib_Grab *(*Xlib_FindGrab)(int) = __GrabNull;
  25. PFN Xlib_InputQueueHook = NULL;
  26.  
  27. int XGrabPointer(
  28.     Display*        display,
  29.     Window        grab_window,
  30.     Bool        owner_events,
  31.     unsigned int    event_mask,
  32.     int            pointer_mode,
  33.     int            keyboard_mode,
  34.     Window        confine_to,
  35.     Cursor        cursor,
  36.     Time        time
  37. )
  38. {
  39.     DBUG_ENTER("XGrabPointer")
  40.     Xlib_Grab *new;
  41.     
  42.     /* I think we can safely ignore the Time paramater since
  43.      according to the documentation it is for network synchronization
  44.      problems which should not be an issue here - Brian Smith */
  45.  
  46.     new = Xlib_FindGrab(GrabPointer);
  47.     if (new && new->window != grab_window) 
  48.         DBUG_RETURN(AlreadyGrabbed);
  49.  
  50.     new = Xlib_NewGrab();
  51.     if (!new) DBUG_RETURN(False);
  52.  
  53.     new->type = GrabPointer;
  54.     new->window = grab_window;
  55.     new->owner_events = owner_events;
  56.     new->event_mask = event_mask;
  57.     new->pointer_mode = pointer_mode;
  58.     new->keyboard_mode = keyboard_mode;
  59.     new->cursor = cursor;
  60.     new->time = time;
  61.  
  62.     if(cursor != None)
  63.         XDefineCursor(display, grab_window, cursor);
  64.     DBUG_RETURN(True);
  65. }
  66.  
  67. int XUngrabPointer(Display*        display,   Time    time)
  68. {
  69.     DBUG_ENTER("XUngrabPointer")
  70.     Xlib_Grab *current;
  71.  
  72.     current = Xlib_FindGrab(GrabPointer);
  73.     if (!current) DBUG_RETURN(False);
  74.     XUndefineCursor(display, current->window);
  75.     Xlib_RemoveGrab(GrabPointer);
  76.  
  77.     DBUG_RETURN(True);
  78. }
  79.  
  80. int XAllowEvents(Display *display, int event_mode, Time time)
  81. {
  82.     DBUG_ENTER("XAllowEvents")
  83.     Xlib_Grab *current;
  84.     
  85.     switch(event_mode) {
  86.     case AsyncPointer:
  87.         Xlib_RemoveGrabAny(GrabPointer);
  88.         break;
  89.     case SyncPointer:
  90.         if((current = Xlib_FindGrab(GrabPointer))!=NULL)
  91.             current->special = SyncPointer;
  92.         break;
  93.     case AsyncKeyboard:
  94.         Xlib_RemoveGrabAny(GrabKeyboard);
  95.         break;
  96.     case SyncKeyboard:
  97.         if((current = Xlib_FindGrab(GrabKeyboard))!=NULL)
  98.             current->special = SyncKeyboard;
  99.         break;
  100.     case AsyncBoth:
  101.         Xlib_RemoveGrabAny(GrabKeyboard);
  102.         Xlib_RemoveGrabAny(GrabPointer);
  103.         break;
  104.     case SyncBoth:
  105.         if((current = Xlib_FindGrab(GrabKeyboard))!=NULL)
  106.             current->special = SyncKeyboard;
  107.         if((current = Xlib_FindGrab(GrabPointer))!=NULL)
  108.             current->special = SyncPointer;
  109.         break;
  110.     }
  111.     DBUG_RETURN(True);
  112. }
  113.  
  114. int XGrabButton(
  115.     Display*        display,
  116.     unsigned int    button,
  117.     unsigned int    modifiers,
  118.     Window        grab_window,
  119.     Bool        owner_events,
  120.     unsigned int    event_mask,
  121.     int            pointer_mode,
  122.     int            keyboard_mode,
  123.     Window        confine_to,
  124.     Cursor        cursor
  125. )
  126. {
  127.     DBUG_ENTER("XGrabButton")
  128.     Xlib_Grab *new;
  129.  
  130.     new = Xlib_FindGrab(GrabKey);
  131.     if (new && new->window != grab_window)
  132.         DBUG_RETURN(AlreadyGrabbed);
  133.     
  134.     new = Xlib_NewGrab();
  135.     if (!new) DBUG_RETURN(False);
  136.  
  137.     new->type = GrabKey;
  138.     new->button = button;
  139.     new->modifiers = modifiers;
  140.     new->window = grab_window;
  141.     new->owner_events = owner_events;
  142.     new->pointer_mode = pointer_mode;
  143.     new->keyboard_mode = keyboard_mode;
  144.     
  145.     DBUG_RETURN(True);
  146. }
  147.  
  148. int XUngrabButton(
  149.     Display*        display,
  150.     unsigned int    button,
  151.     unsigned int    modifiers,
  152.     Window        grab_window
  153. )
  154. {
  155.     DBUG_ENTER("XUngrabButton")
  156.     Xlib_RemoveGrab(GrabButton);
  157.     DBUG_RETURN(True);
  158. }
  159.  
  160. int XGrabKey(
  161.     Display*        display,
  162.     int            keycode,
  163.     unsigned int    modifiers,
  164.     Window        grab_window,
  165.     Bool        owner_events,
  166.     int            pointer_mode,
  167.     int            keyboard_mode
  168. )
  169. {
  170.     DBUG_ENTER("XGrabKey")
  171.     Xlib_Grab *new;
  172.  
  173.     new = Xlib_FindGrab(GrabKey);
  174.     if (new && new->window != grab_window)
  175.         DBUG_RETURN(AlreadyGrabbed);
  176.         
  177.     new = Xlib_NewGrab();
  178.     if (!new) DBUG_RETURN(False);
  179.  
  180.     new->type = GrabKey;
  181.     new->keycode = keycode;
  182.     new->modifiers = modifiers;
  183.     new->window = grab_window;
  184.     new->owner_events = owner_events;
  185.     new->pointer_mode = pointer_mode;
  186.     new->keyboard_mode = keyboard_mode;
  187.     
  188.     DBUG_RETURN(True);
  189. }
  190.  
  191. int XUngrabKey(
  192.     Display*        display,
  193.     int            keycode,
  194.     unsigned int    modifiers,
  195.     Window        grab_window
  196. )
  197. {
  198.     DBUG_ENTER("XUngrabKey")
  199.     Xlib_RemoveGrab(GrabKey);
  200.     DBUG_RETURN(True);
  201. }
  202.  
  203. int XGrabKeyboard(
  204.     Display*        display,
  205.     Window        grab_window,
  206.     Bool        owner_events,
  207.     int            pointer_mode,
  208.     int            keyboard_mode,
  209.     Time        time
  210. )
  211. {
  212.     DBUG_ENTER("XGrabKeyboard")
  213.     Xlib_Grab *new;
  214.  
  215.     new = Xlib_FindGrab(GrabKeyboard);
  216.     if (new && new->window != grab_window)
  217.         DBUG_RETURN(AlreadyGrabbed);
  218.         
  219.     new = Xlib_NewGrab();
  220.     if (!new) DBUG_RETURN(False);
  221.  
  222.     new->type = GrabKeyboard;
  223.     new->window = grab_window;
  224.     new->owner_events = owner_events;
  225.     new->pointer_mode = pointer_mode;
  226.     new->keyboard_mode = keyboard_mode;
  227.     new->time = time;
  228.  
  229.     DBUG_RETURN(True);
  230. }
  231.  
  232. int XUngrabKeyboard(Display*       display,  Time     time)
  233. {
  234.     DBUG_ENTER("XUngrabKeyboard")
  235.     Xlib_RemoveGrab(GrabKeyboard);
  236.     DBUG_RETURN(True);
  237. }
  238.  
  239. int XGrabServer(
  240.     Display*        display
  241. )
  242. {
  243.     DBUG_ENTER("XGrabServer")
  244.     Xlib_Grab *new;
  245.  
  246.     if(Xlib_FindGrab(GrabServer))
  247.         DBUG_RETURN(AlreadyGrabbed);
  248.  
  249.     new = Xlib_NewGrab();
  250.     if (!new) DBUG_RETURN(False);
  251.  
  252.     new->type = GrabServer;
  253.     DBUG_RETURN(True);
  254. }
  255.  
  256.  
  257. int XUngrabServer(Display*          display)
  258. {
  259.     DBUG_ENTER("XUngrabServer")
  260.     Xlib_RemoveGrabAny(GrabServer);
  261.     DBUG_RETURN(True);
  262. }
  263.  
  264. int XChangeActivePointerGrab(Display *display, unsigned int event_mask, Cursor cursor, Time time)
  265. {
  266.     DBUG_ENTER("XChangeActivePointerGrab")
  267.     Xlib_Grab *current = Xlib_FindGrab(GrabPointer);
  268.     
  269.     if(current)
  270.     {
  271.         current->event_mask = event_mask;
  272.         current->cursor = cursor;
  273.         current->time = time;
  274.         if(cursor != None)
  275.             XDefineCursor(display, current->window, cursor);
  276.         DBUG_RETURN(True);
  277.     }
  278.     DBUG_RETURN(False);
  279. }
  280.