home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / lib / Xt / PassivGrab.c.orig < prev    next >
Encoding:
Text File  |  1993-07-21  |  27.4 KB  |  1,033 lines
  1. /* $XConsortium: PassivGrab.c,v 1.20 92/05/11 17:44:00 converse Exp $ */
  2.  
  3. /********************************************************
  4.  
  5. Copyright (c) 1988 by Hewlett-Packard Company
  6. Copyright (c) 1987, 1988, 1989,1990 by Digital Equipment Corporation, Maynard, 
  7.               Massachusetts, and the Massachusetts Institute of Technology, 
  8.               Cambridge, Massachusetts
  9.  
  10. Permission to use, copy, modify, and distribute this software 
  11. and its documentation for any purpose and without fee is hereby 
  12. granted, provided that the above copyright notice appear in all 
  13. copies and that both that copyright notice and this permission 
  14. notice appear in supporting documentation, and that the names of 
  15. Hewlett-Packard, Digital or  M.I.T.  not be used in advertising or 
  16. publicity pertaining to distribution of the software without specific, 
  17. written prior permission.
  18.  
  19. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  20. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  21. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  22. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  23. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  24. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  25. SOFTWARE.
  26.  
  27. ********************************************************/
  28.  
  29. #include "IntrinsicI.h"
  30. #include "StringDefs.h"
  31. #include "PassivGraI.h"
  32.  
  33. static String XtNinvalidWidget = "invalidWidget";
  34.  
  35. /* typedef unsigned long Mask; */
  36. #define BITMASK(i) (((Mask)1) << ((i) & 31))
  37. #define MASKIDX(i) ((i) >> 5)
  38. #define MASKWORD(buf, i) buf[MASKIDX(i)]
  39. #define BITSET(buf, i) MASKWORD(buf, i) |= BITMASK(i)
  40. #define BITCLEAR(buf, i) MASKWORD(buf, i) &= ~BITMASK(i)
  41. #define GETBIT(buf, i) (MASKWORD(buf, i) & BITMASK(i))
  42. #define MasksPerDetailMask 8
  43.  
  44. #define pDisplay(grabPtr) (((grabPtr)->widget)->core.screen->display)
  45. #define pWindow(grabPtr) (((grabPtr)->widget)->core.window)
  46.  
  47.  
  48. /***************************************************************************/
  49. /*********************** Internal Support Routines *************************/
  50. /***************************************************************************/
  51.  
  52. /*
  53.  * Turn off (clear) the bit in the specified detail mask which is associated
  54.  * with the detail.
  55.  */
  56.  
  57. static void DeleteDetailFromMask(ppDetailMask, detail)
  58.     Mask **ppDetailMask;
  59.     unsigned short detail;
  60. {
  61.     Mask *pDetailMask = *ppDetailMask;
  62.  
  63.     if (!pDetailMask) {
  64.     int i;
  65.     pDetailMask = (Mask *)XtMalloc(sizeof(Mask) * MasksPerDetailMask);
  66.     for (i = MasksPerDetailMask; --i >= 0; )
  67.         pDetailMask[i] = ~0;
  68.     *ppDetailMask = pDetailMask;
  69.     }
  70.     BITCLEAR((pDetailMask), detail);
  71. }
  72.  
  73.  
  74. /*
  75.  * Make an exact copy of the specified detail mask.
  76.  */
  77.  
  78. static Mask *CopyDetailMask(pOriginalDetailMask)
  79.     Mask *pOriginalDetailMask;
  80. {
  81.     Mask *pTempMask;
  82.     int i;
  83.     
  84.     if (!pOriginalDetailMask)
  85.     return NULL;
  86.     
  87.     pTempMask = (Mask *)XtMalloc(sizeof(Mask) * MasksPerDetailMask);
  88.     
  89.     for ( i = 0; i < MasksPerDetailMask; i++)
  90.       pTempMask[i]= pOriginalDetailMask[i];
  91.     
  92.     return pTempMask;
  93. }
  94.  
  95.  
  96. /*
  97.  * Allocate a new grab entry, and fill in all of the fields using the
  98.  * specified parameters.
  99.  */
  100.  
  101. static XtServerGrabPtr CreateGrab(widget, ownerEvents, modifiers,
  102.                   keybut, pointer_mode, keyboard_mode,
  103.                   event_mask, confine_to, cursor, need_ext)
  104.     Widget    widget;
  105.     Boolean    ownerEvents;
  106.     Modifiers    modifiers;
  107.     KeyCode     keybut;
  108.     int        pointer_mode, keyboard_mode;
  109.     Mask    event_mask;
  110.     Window     confine_to;
  111.     Cursor     cursor;
  112.     Boolean    need_ext;
  113. {
  114.     XtServerGrabPtr grab;
  115.     
  116.     if (confine_to || cursor)
  117.     need_ext = True;
  118.     grab = (XtServerGrabPtr)XtMalloc(sizeof(XtServerGrabRec) +
  119.                      (need_ext ? sizeof(XtServerGrabExtRec)
  120.                       : 0));
  121.     grab->next = NULL;
  122.     grab->widget = widget;
  123.     grab->ownerEvents = ownerEvents;
  124.     grab->pointerMode = pointer_mode;
  125.     grab->keyboardMode = keyboard_mode;
  126.     grab->eventMask = event_mask;
  127.     grab->hasExt = need_ext;
  128.     grab->modifiers = modifiers;
  129.     grab->keybut = keybut;
  130.     if (need_ext) {
  131.     XtServerGrabExtPtr ext = GRABEXT(grab);
  132.     ext->pModifiersMask = NULL;
  133.     ext->pKeyButMask = NULL;
  134.     ext->confineTo = confine_to;
  135.     ext->cursor = cursor;
  136.     }
  137.     return grab;
  138. }
  139.  
  140.  
  141. /*
  142.  * Free up the space occupied by a grab entry.
  143.  */
  144.  
  145. static void FreeGrab(pGrab)
  146.     XtServerGrabPtr pGrab;
  147. {
  148.     if (pGrab->hasExt) {
  149.     XtServerGrabExtPtr ext = GRABEXT(pGrab);
  150.     if (ext->pModifiersMask)
  151.         XtFree((char *)ext->pModifiersMask);
  152.     if (ext->pKeyButMask)
  153.         XtFree((char *)ext->pKeyButMask);
  154.     }
  155.     XtFree((char *)pGrab);
  156. }
  157.  
  158. typedef struct _DetailRec {
  159.     unsigned short     exact;
  160.     Mask          *pMask;
  161. } DetailRec, *DetailPtr;
  162.  
  163. /*
  164.  * If the first detail is set to 'exception' and the second detail
  165.  * is contained in the mask of the first, then TRUE is returned.
  166.  */
  167.  
  168. static Bool IsInGrabMask(firstDetail, secondDetail, exception)
  169.     register DetailPtr firstDetail, secondDetail;
  170.     unsigned short exception;
  171. {
  172.     if (firstDetail->exact == exception) {
  173.     if (!firstDetail->pMask)
  174.         return TRUE;
  175.       
  176.     /* (at present) never called with two non-null pMasks */
  177.     if (secondDetail->exact == exception)
  178.         return FALSE;
  179.       
  180.     if (GETBIT(firstDetail->pMask, secondDetail->exact))
  181.         return TRUE;
  182.     }
  183.     
  184.     return FALSE;
  185. }
  186.  
  187.  
  188. /*
  189.  * If neither of the details is set to 'exception', and they match
  190.  * exactly, then TRUE is returned.
  191.  */
  192.  
  193. static Bool IdenticalExactDetails(firstExact, secondExact, exception)
  194.     unsigned short firstExact, secondExact, exception;
  195. {
  196.     if ((firstExact == exception) || (secondExact == exception))
  197.     return FALSE;
  198.     
  199.     if (firstExact == secondExact)
  200.     return TRUE;
  201.     
  202.     return FALSE;
  203. }
  204.  
  205.  
  206. /*
  207.  * If the first detail is set to 'exception', and its mask has the bit
  208.  * enabled which corresponds to the second detail, OR if neither of the
  209.  * details is set to 'exception' and the details match exactly, then
  210.  * TRUE is returned.
  211.  */
  212.  
  213. static Bool DetailSupersedesSecond(firstDetail, secondDetail, exception)
  214.     register DetailPtr firstDetail, secondDetail;
  215.     unsigned short exception;
  216. {
  217.     if (IsInGrabMask(firstDetail, secondDetail, exception))
  218.     return TRUE;
  219.     
  220.     if (IdenticalExactDetails(firstDetail->exact, secondDetail->exact,
  221.                   exception))
  222.     return TRUE;
  223.     
  224.     return FALSE;
  225. }
  226.  
  227.  
  228. /*
  229.  * If the two grab events match exactly, or if the first grab entry
  230.  * 'encompasses' the second grab entry, then TRUE is returned.
  231.  */
  232.  
  233. static Bool GrabSupersedesSecond(pFirstGrab, pSecondGrab)
  234.     register XtServerGrabPtr pFirstGrab, pSecondGrab;
  235. {
  236.     DetailRec first, second;
  237.  
  238.     first.exact = pFirstGrab->modifiers;
  239.     if (pFirstGrab->hasExt)
  240.     first.pMask = GRABEXT(pFirstGrab)->pModifiersMask;
  241.     else
  242.     first.pMask = NULL;
  243.     second.exact = pSecondGrab->modifiers;
  244.     if (pSecondGrab->hasExt)
  245.     second.pMask = GRABEXT(pSecondGrab)->pModifiersMask;
  246.     else
  247.     second.pMask = NULL;
  248.     if (!DetailSupersedesSecond(&first, &second, (unsigned short)AnyModifier))
  249.       return FALSE;
  250.     
  251.     first.exact = pFirstGrab->keybut;
  252.     if (pFirstGrab->hasExt)
  253.     first.pMask = GRABEXT(pFirstGrab)->pKeyButMask;
  254.     else
  255.     first.pMask = NULL;
  256.     second.exact = pSecondGrab->keybut;
  257.     if (pSecondGrab->hasExt)
  258.     second.pMask = GRABEXT(pSecondGrab)->pKeyButMask;
  259.     else
  260.     second.pMask = NULL;
  261.     if (DetailSupersedesSecond(&first, &second, (unsigned short)AnyKey))
  262.       return TRUE;
  263.     
  264.     return FALSE;
  265. }
  266.  
  267.  
  268. /*
  269.  * Two grabs are considered to be matching if either of the following are true:
  270.  *
  271.  * 1) The two grab entries match exactly, or the first grab entry
  272.  *    encompasses the second grab entry.
  273.  * 2) The second grab entry encompasses the first grab entry.
  274.  * 3) The keycodes match exactly, and one entry's modifiers encompasses
  275.  *    the others.
  276.  * 4) The keycode for one entry encompasses the other, and the detail
  277.  *    for the other entry encompasses the first.
  278.  */
  279.  
  280. static Bool GrabMatchesSecond(pFirstGrab, pSecondGrab)
  281.     register XtServerGrabPtr pFirstGrab, pSecondGrab;
  282. {
  283.     DetailRec firstD, firstM, secondD, secondM;
  284.  
  285.     if (pDisplay(pFirstGrab) != pDisplay(pSecondGrab))
  286.     return FALSE;
  287.     
  288.     if (GrabSupersedesSecond(pFirstGrab, pSecondGrab))
  289.     return TRUE;
  290.     
  291.     if (GrabSupersedesSecond(pSecondGrab, pFirstGrab))
  292.     return TRUE;
  293.     
  294.     firstD.exact = pFirstGrab->keybut;
  295.     firstM.exact = pFirstGrab->modifiers;
  296.     if (pFirstGrab->hasExt) {
  297.     firstD.pMask = GRABEXT(pFirstGrab)->pKeyButMask;
  298.     firstM.pMask = GRABEXT(pFirstGrab)->pModifiersMask;
  299.     } else {
  300.     firstD.pMask = NULL;
  301.     firstM.pMask = NULL;
  302.     }
  303.     secondD.exact = pSecondGrab->keybut;
  304.     secondM.exact = pSecondGrab->modifiers;
  305.     if (pSecondGrab->hasExt) {
  306.     secondD.pMask = GRABEXT(pSecondGrab)->pKeyButMask;
  307.     secondM.pMask = GRABEXT(pSecondGrab)->pModifiersMask;
  308.     } else {
  309.     secondD.pMask = NULL;
  310.     secondM.pMask = NULL;
  311.     }
  312.  
  313.     if (DetailSupersedesSecond(&secondD, &firstD, (unsigned short)AnyKey) &&
  314.     DetailSupersedesSecond(&firstM, &secondM, (unsigned short)AnyModifier))
  315.     return TRUE;
  316.     
  317.     if (DetailSupersedesSecond(&firstD, &secondD, (unsigned short)AnyKey) && 
  318.     DetailSupersedesSecond(&secondM, &firstM, (unsigned short)AnyModifier))
  319.     return TRUE;
  320.     
  321.     return FALSE;
  322. }
  323.  
  324.  
  325. /*
  326.  * Delete a grab combination from the passive grab list.  Each entry will
  327.  * be checked to see if it is affected by the grab being deleted.  This
  328.  * may result in multiple entries being modified/deleted.
  329.  */
  330.  
  331. static void DeleteServerGrabFromList(passiveListPtr, pMinuendGrab)
  332.     XtServerGrabPtr     *passiveListPtr;    
  333.     XtServerGrabPtr     pMinuendGrab;
  334. {
  335.     register XtServerGrabPtr *next;
  336.     register XtServerGrabPtr grab;
  337.     register XtServerGrabExtPtr ext;
  338.     
  339.     for (next = passiveListPtr; grab = *next; )
  340.     {
  341.     if (GrabMatchesSecond(grab, pMinuendGrab) && 
  342.         (pDisplay(grab) == pDisplay(pMinuendGrab)))
  343.     {
  344.         if (GrabSupersedesSecond(pMinuendGrab, grab))
  345.         {
  346.         /*
  347.          * The entry being deleted encompasses the list entry,
  348.          * so delete the list entry.
  349.          */
  350.         *next = grab->next;
  351.         FreeGrab(grab);
  352.         continue;
  353.         }
  354.  
  355.         if (!grab->hasExt) {
  356.         grab = (XtServerGrabPtr)
  357.             XtRealloc((char *)grab, (sizeof(XtServerGrabRec) +
  358.                          sizeof(XtServerGrabExtRec)));
  359.         *next = grab;
  360.         grab->hasExt = True;
  361.         ext = GRABEXT(grab);
  362.         ext->pKeyButMask = NULL;
  363.         ext->pModifiersMask = NULL;
  364.         ext->confineTo = None;
  365.         ext->cursor = None;
  366.         } else
  367.         ext = GRABEXT(grab);
  368.         if ((grab->keybut == AnyKey) && (grab->modifiers != AnyModifier))
  369.         {
  370.         /*
  371.          * If the list entry has the key detail of AnyKey, and
  372.          * a modifier detail not set to AnyModifier, then we
  373.          * simply need to turn off the key detail bit in the
  374.          * list entry's key detail mask.
  375.          */
  376.         DeleteDetailFromMask(&ext->pKeyButMask, pMinuendGrab->keybut);
  377.         } else if ((grab->modifiers == AnyModifier) &&
  378.                (grab->keybut != AnyKey)) {
  379.         /*
  380.          * The list entry has a specific key detail, but its
  381.          * modifier detail is set to AnyModifier; so, we only
  382.          * need to turn off the specified modifier combination
  383.          * in the list entry's modifier mask.
  384.          */
  385.         DeleteDetailFromMask(&ext->pModifiersMask,
  386.                      pMinuendGrab->modifiers);
  387.         } else if ((pMinuendGrab->keybut != AnyKey) &&
  388.                (pMinuendGrab->modifiers != AnyModifier)) {
  389.         /*
  390.          * The list entry has a key detail of AnyKey and a
  391.          * modifier detail of AnyModifier; the entry being
  392.          * deleted has a specific key and a specific modifier
  393.          * combination.  Therefore, we need to mask off the
  394.          * keycode from the list entry, and also create a
  395.          * new entry for this keycode, which has a modifier
  396.          * mask set to AnyModifier & ~(deleted modifiers).
  397.          */
  398.         XtServerGrabPtr pNewGrab;
  399.                   
  400.         DeleteDetailFromMask(&ext->pKeyButMask, pMinuendGrab->keybut);
  401.         pNewGrab = CreateGrab(grab->widget,
  402.                       (Boolean)grab->ownerEvents,
  403.                       (Modifiers)AnyModifier,
  404.                       pMinuendGrab->keybut,
  405.                       (int)grab->pointerMode,
  406.                       (int)grab->keyboardMode,
  407.                       (Mask)0, (Window)0, (Cursor)0, True);
  408.         GRABEXT(pNewGrab)->pModifiersMask =
  409.             CopyDetailMask(ext->pModifiersMask);
  410.                   
  411.         DeleteDetailFromMask(&GRABEXT(pNewGrab)->pModifiersMask,
  412.                      pMinuendGrab->modifiers);
  413.                   
  414.         pNewGrab->next = *passiveListPtr;
  415.         *passiveListPtr = pNewGrab;
  416.         } else if (pMinuendGrab->keybut == AnyKey) {
  417.         /*
  418.          * The list entry has keycode AnyKey and modifier
  419.          * AnyModifier; the entry being deleted has
  420.          * keycode AnyKey and specific modifiers.  So we
  421.          * simply need to mask off the specified modifier
  422.          * combination.
  423.          */
  424.         DeleteDetailFromMask(&ext->pModifiersMask,
  425.                      pMinuendGrab->modifiers);
  426.         } else {
  427.         /*
  428.          * The list entry has keycode AnyKey and modifier
  429.          * AnyModifier; the entry being deleted has a
  430.          * specific keycode and modifier AnyModifier.  So 
  431.          * we simply need to mask off the specified 
  432.          * keycode.
  433.          */
  434.         DeleteDetailFromMask(&ext->pKeyButMask, pMinuendGrab->keybut);
  435.         }
  436.     }
  437.     next = &(*next)->next;
  438.     }
  439. }
  440.  
  441. static void DestroyPassiveList(passiveListPtr)
  442.     XtServerGrabPtr    *passiveListPtr;
  443. {
  444.     XtServerGrabPtr    next, grab;
  445.  
  446.     for (next = *passiveListPtr; next; ) {
  447.     grab = next;
  448.     next = grab->next;
  449.       
  450.     /* not necessary to explicitly ungrab key or button;
  451.      * window is being destroyed so server will take care of it.
  452.      */ 
  453.  
  454.     FreeGrab(grab);
  455.     }
  456. }
  457.  
  458.  
  459. /*
  460.  * This function is called at widget destroy time to clean up
  461.  */
  462. /*ARGSUSED*/
  463. void _XtDestroyServerGrabs(w, closure, call_data)
  464.     Widget        w;
  465.     XtPointer        closure;
  466.     XtPointer        call_data; /* unused */
  467. {
  468.     XtPerWidgetInput    pwi = (XtPerWidgetInput)closure;
  469.     XtPerDisplayInput    pdi;
  470.     
  471.     pdi = _XtGetPerDisplayInput(XtDisplay(w));
  472.     
  473.     /* Remove the active grab, if necessary */
  474.     if ((pdi->keyboard.grabType != XtNoServerGrab) && 
  475.     (pdi->keyboard.grab.widget == w))
  476.     XtUngrabKeyboard(w, CurrentTime);
  477.     if ((pdi->pointer.grabType != XtNoServerGrab) && 
  478.     (pdi->pointer.grab.widget == w))
  479.     XtUngrabPointer(w, CurrentTime);
  480.     
  481.     DestroyPassiveList(&pwi->keyList);
  482.     DestroyPassiveList(&pwi->ptrList);
  483.  
  484.     _XtFreePerWidgetInput(w, pwi);
  485. }
  486.  
  487. /*
  488.  * If the incoming event is on the passive grab list, then activate
  489.  * the grab.  The grab will remain in effect until the key is released.
  490.  */
  491.  
  492. #if NeedFunctionPrototypes
  493. XtServerGrabPtr _XtCheckServerGrabsOnWidget (
  494.     XEvent         *event,
  495.     Widget        widget,
  496.     _XtBoolean        isKeyboard
  497.     )
  498. #else
  499. XtServerGrabPtr _XtCheckServerGrabsOnWidget (event, widget, isKeyboard)
  500.     XEvent         *event;
  501.     Widget        widget;
  502.     Boolean        isKeyboard;
  503. #endif
  504. {
  505.     register XtServerGrabPtr grab;
  506.     XtServerGrabRec     tempGrab;
  507.     XtServerGrabPtr    *passiveListPtr;
  508.     XtPerWidgetInput    pwi;
  509.  
  510.     if (!(pwi = _XtGetPerWidgetInput(widget, FALSE)))
  511.     return (XtServerGrabPtr)NULL;
  512.  
  513.     if (isKeyboard)
  514.     passiveListPtr = &pwi->keyList;
  515.     else
  516.     passiveListPtr = &pwi->ptrList;
  517.  
  518.     /*
  519.      * if either there is no entry in the context manager or the entry
  520.      * is empty, or the keyboard is grabed, then no work to be done
  521.      */
  522.     if (!*passiveListPtr)
  523.     return (XtServerGrabPtr)NULL;
  524.     
  525.     tempGrab.widget = widget;
  526.     tempGrab.keybut = event->xkey.keycode; /* also xbutton.button */
  527.     tempGrab.modifiers = event->xkey.state; /*also xbutton.state*/
  528.     tempGrab.hasExt = False;
  529.  
  530.     for (grab = *passiveListPtr; grab; grab = grab->next) {
  531.     if (GrabMatchesSecond(&tempGrab, grab))
  532.         return (grab);
  533.     }
  534.     return (XtServerGrabPtr)NULL;
  535. }
  536.  
  537. /*
  538.  * This handler is needed to guarantee that we see releases on passive
  539.  * button grabs for widgets that haven't selected for button release.
  540.  */
  541.  
  542. /*ARGSUSED*/
  543. static void  ActiveHandler (widget, pdi, event, cont)
  544.     Widget         widget;
  545.     XtPointer        pdi;
  546.     XEvent         *event;
  547.     Boolean        *cont;
  548. {
  549.     /* nothing */
  550. }
  551.  
  552.  
  553. /*
  554.  *    MakeGrab
  555.  */
  556. static void  MakeGrab(grab, passiveListPtr, isKeyboard, pdi, pwi)
  557.     XtServerGrabPtr    grab;
  558.     XtServerGrabPtr    *passiveListPtr;
  559.     Boolean        isKeyboard;
  560.     XtPerDisplayInput    pdi;
  561.     XtPerWidgetInput    pwi;
  562. {
  563.     if (!isKeyboard && !pwi->active_handler_added) {
  564.     XtAddEventHandler(grab->widget, ButtonReleaseMask, FALSE,
  565.               ActiveHandler, (XtPointer)pdi);
  566.     pwi->active_handler_added = TRUE;
  567.     }
  568.     
  569.     if (isKeyboard) {
  570.     XGrabKey(pDisplay(grab),
  571.          grab->keybut, grab->modifiers,
  572.          pWindow(grab), grab->ownerEvents,
  573.          grab->pointerMode, grab->keyboardMode);
  574.     } else {
  575.     Window confineTo = None;
  576.     Cursor cursor = None;
  577.  
  578.     if (grab->hasExt) {
  579.         confineTo = GRABEXT(grab)->confineTo;
  580.         cursor = GRABEXT(grab)->cursor;
  581.     }
  582.     XGrabButton(pDisplay(grab),
  583.             grab->keybut, grab->modifiers,
  584.             pWindow(grab), grab->ownerEvents, grab->eventMask,
  585.             grab->pointerMode, grab->keyboardMode,
  586.             confineTo, cursor);
  587.     }
  588.  
  589.     /* Add the new grab entry to the passive key grab list */
  590.     grab->next = *passiveListPtr;
  591.     *passiveListPtr = grab;
  592. }
  593.  
  594. static void MakeGrabs(passiveListPtr, isKeyboard, pdi)
  595.     XtServerGrabPtr    *passiveListPtr;
  596.     Boolean        isKeyboard;
  597.     XtPerDisplayInput    pdi;
  598. {
  599.     XtServerGrabPtr    next = *passiveListPtr;
  600.     XtServerGrabPtr    grab;
  601.     XtPerWidgetInput    pwi;
  602.     /*
  603.      * make MakeGrab build a new list that has had the merge
  604.      * processing done on it. Start with an empty list
  605.      * (passiveListPtr).
  606.      */
  607.     *passiveListPtr = NULL;
  608.     while (next)
  609.       {
  610.       grab = next;
  611.       next = grab->next;
  612.       pwi = _XtGetPerWidgetInput(grab->widget, FALSE);
  613.       MakeGrab(grab, passiveListPtr, isKeyboard, pdi, pwi);
  614.       }
  615. } 
  616.    
  617. /*
  618.  * This function is the event handler attached to the associated widget
  619.  * when grabs need to be added, but the widget is not yet realized.  When
  620.  * it is first mapped, this handler will be invoked, and it will add all
  621.  * needed grabs.
  622.  */
  623.  
  624. /*ARGSUSED*/
  625. static void  RealizeHandler (widget, closure, event, cont)
  626.     Widget         widget;
  627.     XtPointer        closure;
  628.     XEvent         *event;    /* unused */
  629.     Boolean        *cont;    /* unused */
  630. {
  631.     XtPerWidgetInput    pwi = (XtPerWidgetInput)closure;
  632.     XtPerDisplayInput    pdi = _XtGetPerDisplayInput(XtDisplay(widget));
  633.     
  634.     MakeGrabs(&pwi->keyList, KEYBOARD, pdi);
  635.     MakeGrabs(&pwi->ptrList, POINTER, pdi);
  636.  
  637.     XtRemoveEventHandler(widget, XtAllEvents, True,
  638.              RealizeHandler, (XtPointer)pwi);
  639.     pwi->realize_handler_added = FALSE;
  640. }
  641.  
  642. /***************************************************************************/
  643. /**************************** Global Routines ******************************/
  644. /***************************************************************************/
  645.  
  646.  
  647. /*
  648.  * Routine used by an application to set up a passive grab for a key/modifier
  649.  * combination.
  650.  */
  651.  
  652. static
  653. void GrabKeyOrButton (widget, keyOrButton, modifiers, owner_events,
  654.                pointer_mode, keyboard_mode, event_mask,
  655.                confine_to, cursor, isKeyboard)
  656.     Widget    widget;
  657.     KeyCode    keyOrButton;
  658.     Modifiers    modifiers;
  659.     Boolean    owner_events;
  660.     int     pointer_mode;
  661.     int     keyboard_mode;
  662.     Mask    event_mask;
  663.     Window     confine_to;
  664.     Cursor     cursor;
  665.     Boolean    isKeyboard;
  666. {
  667.     XtServerGrabPtr    *passiveListPtr;
  668.     XtServerGrabPtr     newGrab;
  669.     XtPerWidgetInput    pwi;
  670.     XtPerDisplayInput    pdi;
  671.     
  672.     
  673.     if (!XtIsWidget(widget)){
  674.     XtAppWarningMsg(XtWidgetToApplicationContext(widget),
  675.              XtNinvalidWidget, "grabKeyOrButton", XtCXtToolkitError,
  676.              "Widget specified in grab is not a widget",
  677.              (String *)NULL, (Cardinal *)NULL);
  678.     return;
  679.     }
  680.     
  681.     pwi = _XtGetPerWidgetInput(widget, TRUE);
  682.     if (isKeyboard)
  683.       passiveListPtr = &pwi->keyList;
  684.     else
  685.       passiveListPtr = &pwi->ptrList;
  686.     pdi = _XtGetPerDisplayInput(XtDisplay(widget));
  687.     
  688.     newGrab = CreateGrab(widget, owner_events, modifiers, 
  689.              keyOrButton, pointer_mode, keyboard_mode, 
  690.              event_mask, confine_to, cursor, False);
  691.     /*
  692.      *  if the widget is realized then process the entry into the grab
  693.      * list. else if the list is empty (i.e. first time) then add the
  694.      * event handler. then add the raw entry to the list for processing
  695.      * in the handler at realize time.
  696.      */
  697.     if (XtIsRealized(widget))
  698.       MakeGrab(newGrab, passiveListPtr, isKeyboard, pdi, pwi);
  699.     else {
  700.     if (!pwi->realize_handler_added)
  701.         {
  702.         XtAddEventHandler(widget, StructureNotifyMask, FALSE,
  703.                   RealizeHandler,
  704.                   (XtPointer)pwi);
  705.         pwi->realize_handler_added = TRUE;
  706.         }
  707.     
  708.     while (*passiveListPtr)
  709.         passiveListPtr = &(*passiveListPtr)->next;
  710.     *passiveListPtr = newGrab;
  711.     }
  712. }
  713.  
  714.  
  715. static
  716. void   UngrabKeyOrButton (widget, keyOrButton, modifiers, isKeyboard)
  717.     Widget    widget;
  718.     int        keyOrButton;
  719.     Modifiers    modifiers;
  720.     Boolean    isKeyboard;
  721. {
  722.     XtServerGrabRec     tempGrab;
  723.     XtPerWidgetInput    pwi;
  724.     
  725.     if (!XtIsWidget(widget)){
  726.     XtAppWarningMsg(XtWidgetToApplicationContext(widget),
  727.              XtNinvalidWidget, "ungrabKeyOrButton", XtCXtToolkitError,
  728.              "Widget specified in ungrab is not a widget",
  729.              (String *)NULL, (Cardinal *)NULL);
  730.     return;
  731.     }
  732.     
  733.     /* Build a temporary grab list entry */
  734.     tempGrab.widget = widget;
  735.     tempGrab.modifiers = modifiers;
  736.     tempGrab.keybut = keyOrButton;
  737.     tempGrab.hasExt = False;
  738.     
  739.     
  740.     pwi = _XtGetPerWidgetInput(widget, FALSE);
  741.     
  742.     /*
  743.      * if there is no entry in the context manager then somethings wrong
  744.      */
  745.     if (!pwi)
  746.       {
  747.       XtAppWarningMsg(XtWidgetToApplicationContext(widget),
  748.                "invalidGrab", "ungrabKeyOrButton", XtCXtToolkitError,
  749.                "Attempt to remove nonexistent passive grab",
  750.                (String *)NULL, (Cardinal *)NULL);
  751.       return;
  752.       }
  753.  
  754.     if (XtIsRealized(widget))
  755.       {
  756.       if (isKeyboard)
  757.         XUngrabKey(widget->core.screen->display,
  758.                keyOrButton, (unsigned int)modifiers,
  759.                widget->core.window);
  760.       else
  761.         XUngrabButton(widget->core.screen->display,
  762.               keyOrButton, (unsigned int)modifiers, 
  763.               widget->core.window);
  764.       }
  765.  
  766.    
  767.     /* Delete all entries which are encompassed by the specified grab. */
  768.     DeleteServerGrabFromList(isKeyboard ? &pwi->keyList : &pwi->ptrList,
  769.                  &tempGrab);
  770. }
  771.  
  772. #if NeedFunctionPrototypes
  773. void  XtGrabKey (
  774.     Widget    widget,
  775.     _XtKeyCode    keycode,
  776.     Modifiers    modifiers,
  777.     _XtBoolean    owner_events,
  778.     int     pointer_mode,
  779.     int     keyboard_mode
  780.     )
  781. #else
  782. void  XtGrabKey (widget, keycode, modifiers, owner_events,
  783.          pointer_mode, keyboard_mode)
  784.     Widget    widget;
  785.     KeyCode    keycode;
  786.     Modifiers    modifiers;
  787.     Boolean    owner_events;
  788.     int     pointer_mode;
  789.     int     keyboard_mode;
  790. #endif
  791. {
  792.     GrabKeyOrButton(widget, (KeyCode)keycode, modifiers, owner_events,
  793.             pointer_mode, keyboard_mode, 
  794.             (Mask)0, (Window)None, (Cursor)None, KEYBOARD);
  795. }
  796.  
  797. #if NeedFunctionPrototypes
  798. void  XtGrabButton(
  799.     Widget    widget,
  800.     int        button,
  801.     Modifiers    modifiers,
  802.     _XtBoolean    owner_events,
  803.     unsigned int event_mask,
  804.     int     pointer_mode,
  805.     int     keyboard_mode,
  806.     Window     confine_to,
  807.     Cursor     cursor
  808.     )
  809. #else
  810. void  XtGrabButton(widget, button, modifiers, owner_events,
  811.            event_mask, pointer_mode, keyboard_mode,
  812.            confine_to, cursor)
  813.     Widget    widget;
  814.     int        button;
  815.     Modifiers    modifiers;
  816.     Boolean    owner_events;
  817.     unsigned int event_mask;
  818.     int     pointer_mode;
  819.     int     keyboard_mode;
  820.     Window     confine_to;
  821.     Cursor     cursor;
  822. #endif
  823. {
  824.     GrabKeyOrButton(widget, (KeyCode)button, modifiers, owner_events,
  825.             pointer_mode, keyboard_mode, 
  826.             (Mask)event_mask, confine_to, cursor, POINTER);
  827. }
  828.  
  829.  
  830. /*
  831.  * Routine used by an application to clear a passive grab for a key/modifier
  832.  * combination.
  833.  */
  834.  
  835. #if NeedFunctionPrototypes
  836. void   XtUngrabKey (
  837.     Widget    widget,
  838.     _XtKeyCode    keycode,
  839.     Modifiers    modifiers
  840.     )
  841. #else
  842. void   XtUngrabKey (widget, keycode, modifiers)
  843.     Widget    widget;
  844.     KeyCode    keycode;
  845.     Modifiers    modifiers;
  846. #endif
  847. {
  848.  
  849.     UngrabKeyOrButton(widget, (int)keycode, modifiers, KEYBOARD);
  850. }
  851.  
  852. void   XtUngrabButton (widget, button, modifiers)
  853.     Widget    widget;
  854.     unsigned int button;
  855.     Modifiers    modifiers;
  856. {
  857.  
  858.     UngrabKeyOrButton(widget, (KeyCode)button, modifiers, POINTER);
  859. }
  860.  
  861. /*
  862.  * Active grab of Device. clear any client side grabs so we dont lock
  863.  */
  864. static int GrabDevice (widget, owner_events,
  865.                pointer_mode, keyboard_mode, 
  866.                event_mask, confine_to, cursor, time, isKeyboard)
  867.     Widget    widget;
  868.     Boolean    owner_events;
  869.     int     pointer_mode;
  870.     int     keyboard_mode;
  871.     Mask    event_mask;
  872.     Window     confine_to;
  873.     Cursor     cursor;
  874.     Time    time;
  875.     Boolean    isKeyboard;
  876. {
  877.     XtPerDisplayInput    pdi;
  878.     int            returnVal;
  879.     
  880.     if (!XtIsWidget(widget) || !XtIsRealized(widget))
  881.       XtAppErrorMsg(XtWidgetToApplicationContext(widget),
  882.             XtNinvalidWidget, "grabDevice", XtCXtToolkitError,
  883.             "Grab widget must be a realized widget",
  884.             (String*)NULL, (Cardinal*)NULL);
  885.     
  886.     pdi = _XtGetPerDisplayInput(XtDisplay(widget));
  887.     
  888.     if (!isKeyboard)
  889.       returnVal = XGrabPointer(XtDisplay(widget), XtWindow(widget), 
  890.                    owner_events, event_mask,
  891.                    pointer_mode, keyboard_mode,
  892.                    confine_to, cursor, time);
  893.     else
  894.       returnVal = XGrabKeyboard(XtDisplay(widget), XtWindow(widget), 
  895.                 owner_events, pointer_mode, 
  896.                 keyboard_mode, time);
  897.  
  898.     if (returnVal == GrabSuccess) {
  899.       XtDevice        device;
  900.       
  901.       device = isKeyboard ? &pdi->keyboard : &pdi->pointer;
  902.       /* fill in the server grab rec */
  903.       device->grab.widget = widget;
  904.       device->grab.modifiers = 0;
  905.       device->grab.keybut = 0;
  906.       device->grab.ownerEvents = owner_events;
  907.       device->grab.pointerMode = pointer_mode;
  908.       device->grab.keyboardMode = keyboard_mode;
  909.       device->grab.hasExt = False;
  910.       device->grabType = XtActiveServerGrab;
  911.       pdi->activatingKey = (KeyCode)0;
  912.       }
  913.     return returnVal;
  914. }
  915.  
  916. static void   UngrabDevice(widget, time, isKeyboard)
  917.     Widget    widget;
  918.     Time    time;
  919.     Boolean    isKeyboard;
  920. {
  921.     XtPerDisplayInput    pdi = _XtGetPerDisplayInput(XtDisplay(widget));
  922.     XtDevice        device = isKeyboard ? &pdi->keyboard : &pdi->pointer;
  923.  
  924.     if (!XtIsWidget(widget) || !XtIsRealized(widget))
  925.       XtAppErrorMsg(XtWidgetToApplicationContext(widget),
  926.             XtNinvalidWidget, "ungrabDevice", XtCXtToolkitError,
  927.             "Grab widget must be a realized widget",
  928.             (String*)NULL, (Cardinal*)NULL);
  929.      
  930.     if (device->grabType != XtNoServerGrab)
  931.       {
  932.       if (device->grabType != XtPseudoPassiveServerGrab)
  933.         {
  934.         if (isKeyboard)
  935.           XUngrabKeyboard(XtDisplay(widget), time);
  936.         else
  937.           XUngrabPointer(XtDisplay(widget), time);
  938.         }
  939.       device->grabType = XtNoServerGrab;
  940.       pdi->activatingKey = (KeyCode)0;
  941.       }
  942. }
  943.  
  944.  
  945. /*
  946.  * Active grab of keyboard. clear any client side grabs so we dont lock
  947.  */
  948. #if NeedFunctionPrototypes
  949. int XtGrabKeyboard (
  950.     Widget    widget,
  951.     _XtBoolean    owner_events,
  952.     int     pointer_mode,
  953.     int     keyboard_mode,
  954.     Time    time
  955.     )
  956. #else
  957. int XtGrabKeyboard (widget, owner_events,
  958.             pointer_mode, keyboard_mode, time)
  959.     Widget    widget;
  960.     Boolean    owner_events;
  961.     int     pointer_mode;
  962.     int     keyboard_mode;
  963.     Time    time;
  964. #endif
  965. {
  966.     return (GrabDevice (widget, owner_events,
  967.             pointer_mode, keyboard_mode, 
  968.             (Mask)0, (Window)None, (Cursor)None, time, KEYBOARD));
  969. }
  970.  
  971.  
  972. /*
  973.  * Ungrab the keyboard
  974.  */
  975.  
  976. void   XtUngrabKeyboard(widget, time)
  977.     Widget    widget;
  978.     Time    time;
  979. {
  980.     UngrabDevice(widget, time, KEYBOARD);
  981. }
  982.  
  983.  
  984.  
  985.  
  986. /*
  987.  * grab the pointer
  988.  */
  989. #if NeedFunctionPrototypes
  990. int XtGrabPointer (
  991.     Widget    widget,
  992.     _XtBoolean    owner_events,
  993.     unsigned int event_mask,
  994.     int     pointer_mode,
  995.     int     keyboard_mode,
  996.     Window     confine_to,
  997.     Cursor     cursor,
  998.     Time    time
  999.     )
  1000. #else
  1001. int XtGrabPointer (widget, owner_events, event_mask,
  1002.            pointer_mode, keyboard_mode, 
  1003.            confine_to, cursor, time)
  1004.     Widget    widget;
  1005.     Boolean    owner_events;
  1006.     unsigned int event_mask;
  1007.     int     pointer_mode;
  1008.     int     keyboard_mode;
  1009.     Window     confine_to;
  1010.     Cursor     cursor;
  1011.     Time    time;
  1012. #endif
  1013. {
  1014.     return (GrabDevice (widget, owner_events,
  1015.             pointer_mode, keyboard_mode, 
  1016.             (Mask)event_mask, confine_to, 
  1017.             cursor, time, POINTER));
  1018. }
  1019.  
  1020.  
  1021. /*
  1022.  * Ungrab the pointer
  1023.  */
  1024.  
  1025. void   XtUngrabPointer(widget, time)
  1026.     Widget    widget;
  1027.     Time    time;
  1028. {
  1029.     UngrabDevice(widget, time, POINTER);
  1030. }
  1031.  
  1032.  
  1033.