/* 

 * Motif

 *

 * Copyright (c) 1987-2012, The Open Group. All rights reserved.

 *

 * These libraries and programs are free software; you can

 * redistribute them and/or modify them under the terms of the GNU

 * Lesser General Public License as published by the Free Software

 * Foundation; either version 2 of the License, or (at your option)

 * any later version.

 *

 * These libraries and programs are distributed in the hope that

 * they will be useful, but WITHOUT ANY WARRANTY; without even the

 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

 * PURPOSE. See the GNU Lesser General Public License for more

 * details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with these librararies and programs; if not, write

 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth

 * Floor, Boston, MA 02110-1301 USA

*/ 

/* 

 * Motif Release 1.2.4

*/ 

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#ifdef REV_INFO

#ifndef lint

static char rcsid[] = "$XConsortium: WmEvent.c /main/7 1996/11/20 15:27:47 rswiston $"

#endif

#endif

/*

 * (c) Copyright 1987, 1988, 1989, 1990, 1993, 1994 HEWLETT-PACKARD COMPANY 

 * (c) Copyright 1993, 1994 International Business Machines Corp.

 * (c) Copyright 1993, 1994 Sun Microsystems, Inc.

 * (c) Copyright 1993, 1994 Novell, Inc.

 */

/*

 * Included Files:

 */

#include "WmGlobal.h"

/*

 * include extern functions

 */

#include "WmEvent.h"

#ifdef WSM

#include "WmBackdrop.h"

#endif /* WSM */

#include "WmCDInfo.h"

#include "WmCDecor.h"

#include "WmCEvent.h"

#include "WmColormap.h"

#include "WmFunction.h"

#include "WmKeyFocus.h"

#ifdef PANELIST

#include "WmPanelP.h"  /* for typedef in WmManage.h */

#endif /* PANELIST */

#include "WmManage.h"

#include "WmMenu.h"

#ifdef WSM

#include "WmICCC.h"

#include "WmProperty.h"

#endif /* WSM */

#include "WmWinInfo.h"

#include "WmWinState.h"

#ifdef PANELIST

#include "WmResNames.h"

#include "WmResParse.h"

#include "WmParse.h"

#include "WmParseP.h"

#endif /* PANELIST */

#include <Xm/RowColumnP.h> /* for MS_LastManagedMenuTime */

extern XmMenuState _XmGetMenuState();

#ifdef WSM

/*

 * FUNCTION PARSER TABLE

 */

typedef struct {

   char         * funcName;

   Context        greyedContext;

   unsigned int   resource;

   long           mgtMask;

   WmFunction     wmFunction;

   Boolean       (*parseProc)();

} FunctionTableEntry;

#endif /* WSM */

/*

 * Global Variables:

 */

extern unsigned int buttonModifierMasks[];

#ifdef WSM

int smAckState = SM_UNITIALIZED;

extern FunctionTableEntry functionTable[];

extern int F_NOP_INDEX;

#endif /* WSM */

#ifndef MOTIF_ONE_DOT_ONE

#include <Xm/MenuShellP.h>

#endif

/*************************************<->*************************************

 *

 *  InitEventHandling ()

 *

 *

 *  Description:

 *  -----------

 *  This function initializes window manager event handling in preparation

 *  for managing client windows.

 *

 *

 *  Inputs:

 *  ------

 *  wmGD = (keySpecs)

 *

 *************************************<->***********************************/

void InitEventHandling (void)

{

    WmScreenData *pSD;

    XSetWindowAttributes setAttributes;

    unsigned long base_mask;

    unsigned int n, scr;

    /*

     * Prepare to get root (workspace) window events that are used to

     * manage client windows.  Setup accelerator event processing.

     */

    base_mask = SubstructureRedirectMask | FocusChangeMask;

    /* handle entry of root window */

    base_mask |= EnterWindowMask | LeaveWindowMask;

    for (scr=0; scr

    {

	pSD = &(wmGD.Screens[scr]);

        if (pSD->managed) 

        {

	    setAttributes.event_mask = base_mask;

	    if (pSD->buttonBindings)

	    {

		/*

		 * The desktop menu and button bindings for window 

		 * manager functions use button press and button 

		 * release events.

		 */

		setAttributes.event_mask |= 

		    (ButtonPressMask | ButtonReleaseMask);

	    }

            XChangeWindowAttributes (DISPLAY, pSD->rootWindow, 

                CWEventMask, &setAttributes);

	    /*

	     * Setup event handling for "accelerated" window management 

	     * functions done with key bindings.

	     */

            if (pSD->keySpecs)

            {

        	SetupKeyBindings (pSD->keySpecs, pSD->rootWindow, 

		    GrabModeSync, F_CONTEXT_ALL);

            }

	    if (pSD->acceleratorMenuCount)

	    {

		for (n = 0; n < pSD->acceleratorMenuCount; n++)

		{

		SetupKeyBindings (

		    pSD->acceleratorMenuSpecs[n]->accelKeySpecs,

		    pSD->rootWindow, GrabModeSync, F_CONTEXT_ALL);

		}

	    }

	} /* end if (managed) */

    }  /* end for (all screens) */

} /* END OF FUNCTION InitEventHandling */

/*************************************<->*************************************

 *

 *  _WmGrabMasks (modifiers, pnum_masks)

 *

 *

 *  Description:

 *  -----------

 *  This function returns a set of grab masks to use that effectively

 *  filters out the effects of locking modifiers. Redundant masks

 *  are removed.

 *

 *

 *  Inputs:

 *  ------

 *  modifiers		- keymask of modifiers

 *

 *  Outputs:

 *  ------

 *  *pnum_masks		- number of masks returned

 *

 *  Return:

 *  -------

 *  pointer to a NULL-terminated list of modifier masks. This memory is

 *  statically allocated and reused. Do no free or modify. Make a copy

 *  if you need to keep it. 

 *

 *************************************<->***********************************/

static unsigned int *

_WmGrabMasks ( unsigned int modifiers, int *pnum_masks )

{

    static unsigned int	*pRetMasks = NULL;

    static int len_ret_masks = 0;

    int num_masks;

    int num_ret_masks;

    int i,j;

    unsigned int mask;

    /* count the number of masks in the lock sequence */

    for (num_masks=0; wmGD.pLockMaskSequence[num_masks] != 0; num_masks++);

    /* insure we have enough space for our returned masks */

    if ((pRetMasks == NULL) || (len_ret_masks < num_masks+2))

    {

	if (pRetMasks != NULL) 

			XtFree ((char *)pRetMasks);

	len_ret_masks = num_masks+2;

	pRetMasks = (unsigned int *) 

			XtCalloc (len_ret_masks, sizeof(unsigned int));

    }

    /* fill up the array of masks we return */

    num_ret_masks = 0;

    for (i=0; i

    {

	/* combine with this set of locking mods */

	mask = (modifiers | wmGD.pLockMaskSequence[i]);

	/* skip if exact match */

	if (mask == modifiers) continue;

	/* add this mask to the list if not already there */

        for (j=0; j

	{

	    if (mask == pRetMasks[j])

		break;

	}

	if (j >= num_ret_masks)

	{

	    /* we don't have this mask yet, add it */

	    pRetMasks[num_ret_masks] = mask;

	    num_ret_masks++;

	}

    }

    /*

     * Add the original mask to the list at the end

     */

    pRetMasks[num_ret_masks++] = modifiers;

    pRetMasks[num_ret_masks] = 0;		/* terminator */

    *pnum_masks = num_ret_masks;

    return (pRetMasks);

}

/*************************************<->*************************************

 *

 *  WmGrabKey (display, keycode, modifiers, grab_window, owner_events,

 *		pointer_mode, keyboard_mode)

 *

 *

 *  Description:

 *  -----------

 *  This function does several grabs on a key to make sure the

 *  key is grabbed irrespective of the state of locking modifiers

 *  It is a wrapper for XGrabKey, so the parameters are all the

 *  same.

 *

 *

 *  Inputs:

 *  ------

 *  display		- X server connection

 *  keycode		- keycode to grab

 *  modifiers		- keymask of modifiers

 *  grab_window		- window to do grab on

 *  owner_events	- does app receive events normally?

 *  pointer_mode	- pointer event processing during grab

 *  keyboard_mode	- keyboard event processing during grab

 *  wmGD.pLockMaskSequence	- extra modifier masks to grab with

 *

 *  Return:

 *  -------

 *  The function is asynchronous.

 *

 *************************************<->***********************************/

void

WmGrabKey (

	Display		*display,

	int		keycode,

	unsigned int	modifiers,

	Window		grab_window,

	Bool		owner_events,

	int		pointer_mode,

	int		keyboard_mode 

	  )

{

    unsigned int	*pGrabMasks;

    int			i, num_masks;

    pGrabMasks = _WmGrabMasks (modifiers, &num_masks);

    for (i=0; i

    {

	XGrabKey (display, keycode, *pGrabMasks, grab_window,

	        owner_events, pointer_mode, keyboard_mode);

    }

}

/*************************************<->*************************************

 *

 *  WmGrabButton (display, button, modifiers, grab_window, owner_events,

 *		event_mask, pointer_mode, keyboard_mode, confine_to, cursor)

 *

 *

 *  Description:

 *  -----------

 *  This function does several grabs on a button to make sure the

 *  button is grabbed irrespective of the state of locking modifiers

 *  It is a wrapper for XGrabButton, so the parameters are all the

 *  same.

 *

 *

 *  Inputs:

 *  ------

 *  display		- X server connection 

 *  button		- button to grab

 *  modifiers		- keymask of modifiers

 *  grab_window		- window to do grab on

 *  event_mask		- event mask in effect during grab

 *  owner_events	- does app receive events normally?

 *  pointer_mode	- pointer event processing during grab

 *  keyboard_mode	- keyboard event processing during grab

 *  confine_to		- window to confine the pointer to

 *  cursor		- cursor to be displayed during grab

 *  wmGD.pLockMaskSequence	- extra modifier masks to grab with

 *

 *  Return:

 *  -------

 *  The function is asynchronous.

 *

 *************************************<->***********************************/

void

WmGrabButton (

	Display		*display,

	unsigned int	button,

	unsigned int	modifiers,

	Window		grab_window,

	unsigned int	event_mask,

	Bool		owner_events,

	int		pointer_mode,

	int		keyboard_mode,

	Window		confine_to,

	Cursor		cursor

	  )

{

    unsigned int	*pGrabMasks;

    int			i, num_masks;

    pGrabMasks = _WmGrabMasks (modifiers, &num_masks);

    for (i=0; i

    {

	XGrabButton (display, button, *pGrabMasks, grab_window, event_mask,

	        owner_events, pointer_mode, keyboard_mode, confine_to,

		cursor);

    }

}

/*************************************<->*************************************

 *

 *  WmUngrabButton (display, button, modifiers, grab_window)

 *

 *

 *  Description:

 *  -----------

 *  This function is the complement of WmGrabButton. It does several 

 *  ungrabs on a button to undo the set of grabs done to ignore

 *  the state of locking modifiers.

 *

 *  It is a wrapper for XUngrabButton, so the parameters are all the

 *  same.

 *

 *

 *  Inputs:

 *  ------

 *  display		- X server connection 

 *  button		- button to grab

 *  modifiers		- keymask of modifiers

 *  grab_window		- window to do grab on

 *  wmGD.pLockMaskSequence	- extra modifier masks to grab with

 *

 *  Return:

 *  -------

 *  The function is asynchronous.

 *

 *************************************<->***********************************/

void

WmUngrabButton (

	Display		*display,

	unsigned int	button,

	unsigned int	modifiers,

	Window		grab_window 

	  )

{

    unsigned int	*pGrabMasks;

    int			i, num_masks;

    pGrabMasks = _WmGrabMasks (modifiers, &num_masks);

    for (i=0; i

    {

	XUngrabButton (display, button, *pGrabMasks, grab_window);

    }

}

/*************************************<->*************************************

 *

 *  SetupKeyBindings (keySpecs, grabWindow, keyboardMode, context)

 *

 *

 *  Description:

 *  -----------

 *  This function sets up the event handling necessary to support user

 *  specified key bindings for window manager functions.

 *

 *

 *  Inputs:

 *  ------

 *  keySpecs = list of key bindings for window manager functions.

 *

 *  grabWindow = window that is to be associated with the passive key grab.

 *

 *  keyboardMode = indicates keyboard mode for grab.

 *

 *  context = context of key binding to set

 *

 *

 *  Outputs:

 *  -------

 *  RETURN = number of key bindings set

 *

 *************************************<->***********************************/

int SetupKeyBindings (KeySpec *keySpecs, Window grabWindow, int keyboardMode, long context)

{

    KeySpec *keySpec;

    int setCount = 0;

    Boolean iconContext;

    /*

     * Use key grabs to get the keys that invoke window manger functions.

     */

    iconContext = (context == F_CONTEXT_ICON);

    keySpec = keySpecs;

    while (keySpec)

    {

#ifdef OLD_CODE

	if (((keySpec->context == F_CONTEXT_ICON) && iconContext) ||

	    ((keySpec->context != F_CONTEXT_ICON) && !iconContext))

#endif

	if (((F_CONTEXT_ICON == (keySpec->context ^

				 (F_CONTEXT_ICONBOX     |

				  F_SUBCONTEXT_IB_IICON |

				  F_SUBCONTEXT_IB_WICON))) &&

             iconContext) ||

            ((F_CONTEXT_ICON != (keySpec->context ^

				 (F_CONTEXT_ICONBOX     |

				  F_SUBCONTEXT_IB_IICON |

				  F_SUBCONTEXT_IB_WICON))) &&

             !iconContext))

	{

	    WmGrabKey (DISPLAY, keySpec->keycode, keySpec->state, grabWindow,

	        False, GrabModeAsync, keyboardMode);

	    setCount++;

	}

	keySpec = keySpec->nextKeySpec;

    }

    return (setCount);

} /* END OF FUNCTION SetupKeyBindings */

/*************************************<->*************************************

 *

 *  WmDispatchMenuEvent (event)

 *

 *

 *  Description:

 *  -----------

 *  This function detects and processes events that affect menu behavior that

 *  are NOT dispatched (processed) by the toolkit.  The events may cause the 

 *  menu to be unposted, may trigger hotspot processing, or may represent 

 *  menu accelerators.  This processing is generally done when the system 

 *  menu is posted in "sticky" mode.

 *

 *

 *  Inputs:

 *  ------

 *  event = This is an X event that has been retrieved by XtNextEvent.

 *  wmGD.menuActive == nonNULL

 *

 *

 *  Outputs:

 *  -------

 *  RETURN = If True the event should be dispatched by the toolkit,

 *      otherwise the event should not be dispatched.

 *

 *************************************<->***********************************/

Boolean WmDispatchMenuEvent (XButtonEvent *event)

{

    ClientData *pCD = wmGD.menuClient;

    Boolean     doXtDispatchEvent = True;

    Boolean     checkContext;

    Context     context = 0;

     /* For fixing the bug CR 5227 */

     XKeyEvent *keyEvent;

     KeySpec   *keySpecs;

     MenuButton   *menuBtnPtr;

    if (event->type == KeyPress)

    {

        if (wmGD.menuActive->accelKeySpecs)

        {

	   /*

	    * Check to see if the KeyPress is a menu accelerator

	    * (don't require context match for system menu accelerators).

	    * If so, the active menu will be unposted and the KeyPress event 

	    * will not be sent on to the toolkit.

	    */

  	    checkContext = (!pCD || (pCD->systemMenuSpec != wmGD.menuActive));

	    if (checkContext)

	    {

                if (pCD)

                {

            	    if (pCD->clientState == MINIMIZED_STATE)

            	    {

            	        context = F_CONTEXT_ICON;

            	    }

            	    else if (pCD->clientState == NORMAL_STATE)

            	    {

            	        context = F_CONTEXT_NORMAL;

            	    }

            	    else

            	    {

            	        context = F_CONTEXT_MAXIMIZE;

            	    }

                }

                else

                {

            	    context = F_CONTEXT_ROOT;

                }

	    }

	    /* Begin fixing CR 5227 */

	    keySpecs = wmGD.menuActive->accelKeySpecs;

	    keyEvent = (XKeyEvent *)event;

	    menuBtnPtr = wmGD.menuActive->menuButtons + 

	                 (wmGD.menuActive->menuButtonSize - 1);

	    while (keySpecs)

	      {

                if ((keyEvent->keycode == keySpecs->keycode) &&

		    ((keyEvent->state == keySpecs->state) ||

		    (NOLOCKMOD(keyEvent->state) == keySpecs->state))

                   && ((!checkContext) || (context & keySpecs->context)))

                 {

                    doXtDispatchEvent =  

                            XtIsSensitive(menuBtnPtr->buttonWidget);

                    break;

                 } 

                 keySpecs = keySpecs->nextKeySpec;

                 menuBtnPtr--;

                } 

	    doXtDispatchEvent = doXtDispatchEvent &&

		HandleKeyPress ((XKeyEvent *)event, 

				wmGD.menuActive->accelKeySpecs,

				checkContext, context, 

				TRUE, (ClientData *)NULL);

        }

        if (wmGD.menuActive && wmGD.menuUnpostKeySpec)

        {

	    if ((wmGD.menuUnpostKeySpec->keycode == event->button) &&

		((wmGD.menuUnpostKeySpec->state == event->state) ||

		 (wmGD.menuUnpostKeySpec->state == NOLOCKMOD(event->state))))

	    {

	        /*

	         * This is an alternate key for unposting a menu from the

	         * keyboard (in addition to [ESC]).

	         */

	        UnpostMenu (wmGD.menuActive);

	        doXtDispatchEvent = False;

	    }

        }

#ifdef ROOT_ICON_MENU

        if (wmGD.menuActive && wmGD.F_NextKeySpec)

        {

            if (((wmGD.F_NextKeySpec->state == event->state) ||

                 (wmGD.F_NextKeySpec->state == NOLOCKMOD(event->state))) &&

                (wmGD.F_NextKeySpec->keycode == event->button))

            {

                /*

                 * This is a key spec to traverse to the next window

                 * via the keyboard.

                 */

                UnpostMenu (wmGD.menuActive);

                doXtDispatchEvent = False;

            }

        }

        if (wmGD.menuActive && wmGD.F_PrevKeySpec)

        {

            if (((wmGD.F_PrevKeySpec->state == event->state) ||

                 (wmGD.F_PrevKeySpec->state == NOLOCKMOD(event->state))) &&

                (wmGD.F_PrevKeySpec->keycode == event->button))

            {

                /*

                 * This is a key spec to traverse to the previous window

                 * via the keyboard.

                 */

                UnpostMenu (wmGD.menuActive);

                doXtDispatchEvent = False;

            }

        }

#endif /*  ROOT_ICON_MENU */

    }

    else if (wmGD.checkHotspot &&

	     ((event->type == ButtonPress) || 

	      (event->type == ButtonRelease)) &&

	     (event->x_root >= wmGD.hotspotRectangle.x) &&

	     (event->y_root >= wmGD.hotspotRectangle.y) &&

	     (event->x_root < (wmGD.hotspotRectangle.x + 

	                       (short) wmGD.hotspotRectangle.width)) &&

	     (event->y_root < (wmGD.hotspotRectangle.y + 

	                       (short) wmGD.hotspotRectangle.height))&&

#ifdef WSM

	     (pCD || 

	      (wmGD.rootButtonClick && wmGD.clickData.clickPending)))

#else /* WSM */

	     pCD)

#endif /* WSM */

    {

	/*   ^^^

	 * Added check for NULL pCD in the above condition.

	 * We should never get here with a NULL pCD, but, 

	 * sometimes our UnmapCallback for a menu does not

	 * get called, so..., we get to this point because

	 * wmGD.menuActive is not cleared, but, wmGD.menuClient 

	 * is set to NULL when we unmanage the client window.

	 */

	/*

	 * The event triggers hotspot processing for the system menu button

	 * or an icon.

	 */

	if (event->type == ButtonRelease)

	{

#ifdef WSM

          if (pCD)

	  {

#endif /* WSM */

	    /*

	     * The system menu is posted from a system menu button or an

	     * icon.  By doing a button release over the system menu button

	     * or icon the system menu that is posted is put into keyboard

	     * traversal mode.

	     */

	    ProcessClickBRelease (event, pCD, wmGD.clickData.context,

		wmGD.clickData.subContext);

	    if (wmGD.clickData.context == F_SUBCONTEXT_W_SYSTEM)

	    {

		PopGadgetOut (pCD, FRAME_SYSTEM);

	    }

#ifdef MOTIF_ONE_DOT_ONE

	    TraversalOn (pCD->systemMenuSpec);

	    doXtDispatchEvent = False;

#else

 	    _XmGetMenuState(XtParent(pCD->systemMenuSpec->menuWidget))

		->MS_LastManagedMenuTime = ((XButtonEvent *)event)->time;

	    doXtDispatchEvent = True;

#endif

#ifdef WSM

          }

	  else if ((!wmGD.clickData.pCD) && 

	      (((XButtonEvent *)event)->button == wmGD.clickData.button) &&

	      ((((XButtonEvent *)event)->state == 

				wmGD.clickData.releaseState) ||

	       (NOLOCKMOD(((XButtonEvent *)event)->state) == 

				wmGD.clickData.releaseState)))

	  {

	      /*

	       * This is a button release over the root. Check for

	       * root menu click and keep the menu up in a sticky

	       * fashion.

	       */

		Time timeDiff;

		/* 

		 * Check click time 

		 */

		 if (((XButtonEvent *)event)->time > wmGD.clickData.time)

		 {

		   timeDiff = 

		     ((XButtonEvent *)event)->time - wmGD.clickData.time;

		 }

		 else

		 {

		   timeDiff = 

		     ~wmGD.clickData.time + ((XButtonEvent *)event)->time + 1;

		 }

		 if (timeDiff < wmGD.doubleClickTime)

		 {

#ifdef MOTIF_ONE_DOT_ONE

		   TraversalOn (wmGD.menuActive);

		   doXtDispatchEvent = False;

#else

		   _XmGetMenuState (XtParent(wmGD.menuActive->menuWidget))

		       ->MS_LastManagedMenuTime =

			   ((XButtonEvent *)event)->time;

		   doXtDispatchEvent = True;

#endif

		 }

	    wmGD.clickData.clickPending = False;

	    }

#endif /* WSM */

	}

	else

	{

	    /*

	     * A button press over a system menu button or an icon when the

	     * system menu is posted indicates that a double-click action is

	     * to be done if appropriate and the menu is to be taken

	     * out of traversal mode (done by the menu widget).

	     */

	    ProcessClickBPress (event, pCD, wmGD.clickData.context,

				wmGD.clickData.subContext);

	    if (wmGD.clickData.subContext == F_SUBCONTEXT_W_SYSTEM)

	    {

		PushGadgetIn (pCD, FRAME_SYSTEM);

	    }

	    if (wmGD.clickData.doubleClickContext == F_SUBCONTEXT_W_SYSTEM)

	    {

		if (wmGD.systemButtonClick2 &&

		    (pCD->clientFunctions & MWM_FUNC_CLOSE))

		{

		    /*

		     * Close the client window.  Cancel other system menu

		     * button actions.

		     */

		    UnpostMenu (pCD->systemMenuSpec);

		    F_Kill (NULL, pCD, (XEvent *) event);

		    doXtDispatchEvent = False;

		}

	    }

	    else

	    if (wmGD.clickData.doubleClickContext == F_SUBCONTEXT_I_ALL)

	    {

		/*

		 * Normalize the icon.

		 */

		int newState;

		UnpostMenu (pCD->systemMenuSpec);

		if (pCD->maxConfig)

		{

		    newState = MAXIMIZED_STATE;

		}

		else

		{

		    newState = NORMAL_STATE;

		}

		SetClientState (pCD, newState, event->time);

		wmGD.clickData.clickPending = False;

		wmGD.clickData.doubleClickPending = False;

		doXtDispatchEvent = False;

	    }

	    else

	    if ((wmGD.clickData.doubleClickContext == F_SUBCONTEXT_IB_IICON)||

		(wmGD.clickData.doubleClickContext == F_SUBCONTEXT_IB_WICON))

            {

                /*

                 * Raise the Window and Normalize

                 */

                UnpostMenu (pCD->systemMenuSpec);

		F_Restore_And_Raise ((String)NULL, pCD, (XEvent *)NULL);

/*		F_Normalize_And_Raise ((String)NULL, pCD, (XEvent *)NULL);

*/                doXtDispatchEvent = False;

            }

	    /*

	     * Else no special button press processing; have the toolkit

	     * dispatch the event to the menu widgets.

	     */

	}

    }

    return (doXtDispatchEvent);

} /* END OF FUNCTION WmDispatchMenuEvent */

/*************************************<->*************************************

 *

 *  WmDispatchWsEvent (event)

 *

 *

 *  Description:

 *  -----------

 *  This function detects and dispatches events that are reported to the root

 *  (workspace) window and that are not widget-related (i.e. they would not be

 *  dispatched by the Xtk intrinsics).

 *

 *

 *  Inputs:

 *  ------

 *  event = This is an X event that has been retrieved by XtNextEvent.

 *

 *