/* 

 * 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 REV_INFO

#ifndef lint

static char rcsid[] = "$XConsortium: WmCEvent.c /main/10 1996/08/09 15:05:39 rswiston $"

#endif

#endif

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

/*

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

/*

 * Included Files:

 */

#include "WmGlobal.h"

#include "WmICCC.h"

#include <X11/Xatom.h>

/*

 * include extern functions

 */

#include "WmCEvent.h"

#include "WmCDecor.h"

#include "WmColormap.h"

#include "WmEvent.h"

#include "WmFeedback.h"

#include "WmFunction.h"

#include "WmIDecor.h"

#include "WmKeyFocus.h"

#ifdef PANELIST

#include "WmPanelP.h"

#endif /* PANELIST */

#include "WmManage.h"

#include "WmMenu.h"

#include "WmProperty.h"

#include "WmProtocol.h"

#include "WmWinConf.h"

#include "WmWinInfo.h"

#include "WmWinList.h"

#include "WmWinState.h"

#ifdef WSM

#include "WmWrkspace.h"

#endif /* WSM */

/*

 * Global Variables:

 */

extern unsigned int buttonModifierMasks[];

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

 *

 *  SetupCButtonBindings (window, buttonSpecs)

 *

 *

 *  Description:

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

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

 *  specified button bindings for window manager functions that apply to

 *  the client window.

 *

 *

 *  Inputs:

 *  ------

 *  window = grab window id

 *

 *  buttonSpecs = list of button bindings for window manager functions

 *

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

void SetupCButtonBindings (Window window, ButtonSpec *buttonSpecs)

{

    ButtonSpec *buttonSpec;

    unsigned int eventMask;

    unsigned int grabState;

    /*

     * If the context of the button binding includes "window" do button

     * grabs to get the button events that invoke window manger functions.

     * !!! don't do redundant grabs !!!

     */

    buttonSpec = buttonSpecs;

    while (buttonSpec)

    {

	if ((buttonSpec->context & F_CONTEXT_WINDOW) &&

	    (buttonSpec->subContext & F_SUBCONTEXT_W_CLIENT))

	{

	    eventMask = ButtonMotionMask | ButtonReleaseMask;

	    if (buttonSpec->eventType == ButtonRelease)

	    {

		/*

		 * Don't include the button down in the grab state.

		 */

		grabState = buttonSpec->state &

				~(buttonModifierMasks[buttonSpec->button]);

	    }

	    else

	    {

		grabState = buttonSpec->state;

	    }

	    WmGrabButton (DISPLAY, buttonSpec->button, grabState,

	        window, False, eventMask, GrabModeSync,

	        GrabModeAsync, None, None);

	}

	/*

	 * If the window context is not "window" a general grab is not

	 * necessary.

	 */

	buttonSpec = buttonSpec->nextButtonSpec;

    }

} /* END OF FUNCTION SetupCButtonBindings */

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

 *

 *  WmDispatchClientEvent (event)

 *

 *

 *  Description:

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

 *  This function detects and dispatches events that are reported to a client

 *  frame or icon window 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.

 *

 *

 *  Outputs:

 *  -------

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

 *      otherwise the event should not be dispatched.

 *

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

Boolean WmDispatchClientEvent (XEvent *event)

{

    ClientData * pCD = NULL;

#ifndef	IBM_169380

    ClientData **cmap_window_data = NULL;

#endif

    Boolean dispatchEvent = False;

    /*

     * Detect and dispatch non-widget events that have been reported to

     * an icon or a client window frame.

     */

#ifndef IBM_169380

    if ((XFindContext (DISPLAY, event->xany.window, wmGD.windowContextType,

            (caddr_t *)&pCD)) &&

        (XFindContext (DISPLAY, event->xany.window, wmGD.cmapWindowContextType,

            (caddr_t *)&cmap_window_data)))

#else

    if (XFindContext (DISPLAY, event->xany.window, wmGD.windowContextType,

	    (caddr_t *)&pCD))

#endif

    {

	/*

	 *  Set active screen if we're not sure. 

	 */

	if (wmGD.queryScreen)

	    DetermineActiveScreen (event);

	/*

	 * Handle events on windows that are made by mwm for

	 * non-client-specific functions.  Also handle "leftover"

	 * events on windows that used to be managed by mwm

	 * (e.g. ConfigureRequest events).

	 */

	return (HandleEventsOnSpecialWindows (event));

    }

#ifndef IBM_169380

    if (cmap_window_data)

    /*

     * Event is on a subwindow that is specified in one or more toplevel

     * window's WM_COLORMAP_WINDOWS property.  (Most likely this is a

     * ColormapNotify event.)  It could have more than one pCD associated

     * with it, so we have to choose one.  If one of the pCD's currently has

     * the Colormap Focus, then let's use that one.  Otherwise, just use

     * the 1st one.

     */

    {

        int j;

        for (j = 0; cmap_window_data[j]; j++)

        {

            if (ACTIVE_PSD->colormapFocus == cmap_window_data[j])

            {

                pCD = cmap_window_data[j];

                break;

            }

        }

        /*

         * None of the pCD's in the list have Colormap Focus.  So, just

         * set pCD to the 1st one in the list.

         */

        if (!pCD)

            pCD = cmap_window_data[0];

    }

#endif

    /*

     *  Set active screen if this is not a FocusOut event.

     *  We don't need to set it on focus out AND we use

     *  (SCREEN_FOR_CLIENT(pCD) != ACTIVE_SCREEN) in

     *  in HandleCFocusOut to determine if a new colormap needs

     *  to be installed.

     */

    if (!(event->type == FocusOut))

    {

	SetActiveScreen (PSD_FOR_CLIENT(pCD));

    }

#ifdef WSM

    /* Get workspace specific client data */

    SetClientWsIndex (pCD);

#endif /* WSM */

    /*

     * Handle events on top-level client windows.

     */

    if (event->xany.window == pCD->client)

    {

	return (HandleEventsOnClientWindow (pCD, event));

    }

    /*

     * Handle events on windows created by mwm (for icons and client window

     * frames) and on non-top-level client windows (e.g., colormap

     * windows).

     */

    switch (event->type)

    {

	case ButtonPress:

	{

	    dispatchEvent = HandleCButtonPress (pCD, (XButtonEvent *)event);

	    break;

	}

	case ButtonRelease:

	{

	    if (wmGD.menuActive)

	    {

		dispatchEvent = True; /* have the toolkit dispatch the event */

	    }

	    else

	    {

		HandleCButtonRelease (pCD, (XButtonEvent *)event);

	    }

	    break;

	}

	case KeyPress:

	{

	    dispatchEvent = HandleCKeyPress (pCD, (XKeyEvent *)event);

	    break;

	}

	case MotionNotify:

	{

	    HandleCMotionNotify (pCD, (XMotionEvent *)event);

	    break;

	}

	case Expose:

	{

	    /* 

	     * If multiple expose events, wait for last one.

	     */

	    if (event->xexpose.count == 0) 

	    {

		if (event->xexpose.window == ICON_FRAME_WIN(pCD))

		{

		    IconExposureProc (pCD, True);

		    if (P_ICON_BOX(pCD))

		    {

			dispatchEvent = True;

		    }

		}

		else if (event->xexpose.window == 

			     pCD->pSD->activeIconTextWin)

		{

		    PaintActiveIconText (pCD, FALSE);

		}

		else if (!(pCD->clientFlags & CLIENT_DESTROYED))

		{

		    if ((event->xexpose.window == pCD->clientFrameWin) ||

			 (event->xexpose.window == pCD->clientTitleWin))

		    {

			FrameExposureProc (pCD);

		    }

		    if (event->xexpose.window == pCD->clientBaseWin)

		    {

			BaseWinExposureProc (pCD);

		    }

		}

#ifdef PANELIST

		else if (pCD->clientFlags & FRONT_PANEL_BOX)

		{

	        /*

		 *

		 *  Then this client is the shell for the 

		 *  front panel and we want the toolkit to repaint

		 *  it.

		 *

		 */

		    dispatchEvent = True;

		}

#endif /* PANELIST */

	    }

	    break;

	}

	case EnterNotify:

	{

	    HandleCEnterNotify (pCD, (XEnterWindowEvent *)event);

	    break;

	}

	case LeaveNotify:

	{

	    HandleCLeaveNotify (pCD, (XLeaveWindowEvent *)event);

	    break;

	}

	case FocusIn:

	{

	    dispatchEvent = HandleCFocusIn (pCD, (XFocusChangeEvent *)event);

	    break;

	}

	case FocusOut:

	{

	    dispatchEvent = HandleCFocusOut (pCD, (XFocusChangeEvent *)event);

	    break;

	}

	case DestroyNotify:

	{

	    if (((XDestroyWindowEvent *)event)->window == pCD->client)

	    {

	        pCD->clientFlags |= CLIENT_DESTROYED;

	        UnManageWindow (pCD);

	    }

	    break;

	}

	case UnmapNotify:

	{

	    /*

	     * This event is generated when a managed  client window is 

	     * unmapped by the client or when the window manager unmaps the

	     * client window; check the wmMapCount to determine if this is

	     * the result of a window manager unmap. If this is a client

	     * unmap then the window is to be withdrawn from window manager

	     * control.

	     */

	    if (((XUnmapEvent *)event)->window == pCD->client)

	    {

	        if (pCD->wmUnmapCount)

	        {

		    pCD->wmUnmapCount--;

	        }

	        else

	        {

		    UnManageWindow (pCD);

	        }

            }

	    break;

	}

	case MapRequest:

	{

	    /*

	     * This is a request to change the state of the client window from

	     * iconic (minimized) to normal.

	     */

#ifdef WSM

            if (!ClientInWorkspace (ACTIVE_WS, pCD))

	    {

		if (pCD->absentMapBehavior == AMAP_BEHAVIOR_IGNORE)

		{

		    SetClientState (pCD, NORMAL_STATE|UNSEEN_STATE, 

				    GetTimestamp ());

		}

		else

		{

		    HonorAbsentMapBehavior(pCD);

		    SetClientState (pCD, NORMAL_STATE, GetTimestamp ());

		}

	    }

	    else

	    {

		SetClientState (pCD, NORMAL_STATE, GetTimestamp ());

	    }

#else /* WSM */

	    SetClientState (pCD, NORMAL_STATE, GetTimestamp ());

#endif /* WSM */

	    break;

	}

	case ConfigureRequest:

	{

	    HandleCConfigureRequest (pCD, (XConfigureRequestEvent *)event);

	    break;

	}

	case ColormapNotify:

	{

	    /*

	     * Process changes to client window colormaps:

	     */

	    HandleCColormapNotify (pCD, (XColormapEvent *)event);

	    break;

	}

	case ClientMessage:

	{

	    /*

	     * Handle client message events.

	     */

	    HandleClientMessage (pCD, (XClientMessageEvent *)event);

	    break;

	}

	case ReparentNotify:

	{

	    if ((((XReparentEvent *)event)->window == pCD->client) &&

		(((XReparentEvent *)event)->parent != pCD->clientBaseWin))

	    {

		/*

		 * The window was reparented away from the frame.

		 * Unmanage to clean up the now empty frame.

		 *

		 * Note: We get here when the reparent is done while

		 * the client is unmapped (e.g. iconified). Otherwise

		 * the reparent will generate an UnmapNotify which

		 * will also cause us to unmanage the client.

		 */

		UnManageWindow (pCD);

	      }

	    break;

	}

    } /* end of event.type switch */

    return (dispatchEvent);

} /* END OF FUNCTION WmDispatchClientEvent */

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

 *

 *  HandleEventsOnSpecialWindows (pEvent)

 *

 *

 *  Description:

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

 *  Handles events on special window manager windows and "leftover" events

 *  from destroyed client window frames.

 *

 *

 *  Inputs:

 *  ------

 *  pEvent = pointer to an XEvent structure

 *

 * 

 *  Outputs:

 *  -------

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

 *      otherwise the event should not be dispatched.

 *

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

Boolean HandleEventsOnSpecialWindows (XEvent *pEvent)

{

    Boolean dispatchEvent = True;

#ifdef WSM

    WmScreenData *pSD;

#endif /* WSM */

    /*

     * The window is not a root window or a client frame window.  Check for

     * a special window manager window.  Have the toolkit dispatch the event

     * if the event is not on a special window.

     */

    if (pEvent->xany.window == ACTIVE_ROOT)

    {

	if (pEvent->type == FocusIn)

	{

	    SetKeyboardFocus ((ClientData *) NULL, REFRESH_LAST_FOCUS);

	}

    }

    else if (pEvent->xany.window == ACTIVE_PSD->feedbackWin)

    {

	if (pEvent->type == Expose)

	{

	    if (pEvent->xexpose.count == 0)

	    {

	        PaintFeedbackWindow(ACTIVE_PSD);

	    }

	}

	dispatchEvent = False; /* don't have the toolkit dispatch the event */

    }

    else if (pEvent->xany.window == ACTIVE_PSD->inputScreenWindow)

    {

	if (pEvent->type == ButtonPress)

	{

	    F_Beep (NULL, (ClientData *) NULL, (XEvent *) NULL);

	}

	else if ((wmGD.keyboardFocusPolicy == KEYBOARD_FOCUS_POINTER) &&

		 (pEvent->type == EnterNotify))

	{

	    HandleWsEnterNotify ((XEnterWindowEvent *)pEvent);

	}

	dispatchEvent = False; /* don't have the toolkit dispatch the event */

    }

#ifdef  WSM

    else if (!XFindContext (DISPLAY, pEvent->xany.window,

		    wmGD.mwmWindowContextType, (caddr_t *)&pSD))

    {

	if ((pEvent->type == PropertyNotify) &&

	    (pEvent->xproperty.atom == wmGD.xa_DT_WM_REQUEST) &&

	    (pEvent->xproperty.state == PropertyNewValue))

	{

	    HandleDtWmRequest (pSD, pEvent);

	}

	if (pEvent->type == ClientMessage)

	{

	    HandleDtWmClientMessage ((XClientMessageEvent *)pEvent);

	}

    }

#endif /* WSM */

    else

    {

	/*

	 * Events may come in for a client frame base window that no

	 * longer exists (the client window was just unmanaged but the

	 * the client did some action before the un-reparenting was

	 * actually done).  Confirm that this is the case and then

	 * handle the request as if it came in as a root window event.

	 */

	switch (pEvent->type)

	{

	    case ConfigureRequest:

	    {

		if (GetParentWindow (pEvent->xconfigurerequest.window) ==

		    ACTIVE_ROOT)

		{

		    /*

		     * This is an event for a client base window that

		     * no longer exists.  Handle the event as if it is a

		     * root window event.

		     */

		    dispatchEvent =  WmDispatchWsEvent (pEvent);

		}

		break;

	    }

	    case MapRequest:

	    {

		if (GetParentWindow (pEvent->xmaprequest.window) ==

		    ACTIVE_ROOT)

		{

		    /*

		     * This is an event for a client base window that

		     * no longer exists.  Handle the event as if it is a

		     * root window event.

		     */

		    dispatchEvent = WmDispatchWsEvent (pEvent);

		}

		break;

	    }

	}

    }

    return (dispatchEvent);

} /* END OF FUNCTION HandleEventsOnSpecialWindows */

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

 *

 *  HandleEventsOnClientWindow (pCD, pEvent)

 *

 *

 *  Description:

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

 *  Handles events on a client top-level window.

 *

 *

 *  Inputs:

 *  ------

 *  pCD = pointer to client data

 *

 *  pEvent = pointer to an XEvent structure

 *

 * 

 *  Outputs:

 *  -------

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

 *      otherwise the event should not be dispatched.

 *

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

Boolean HandleEventsOnClientWindow (ClientData *pCD, XEvent *pEvent)

{

    Boolean doXtDispatchEvent = True;

#ifndef NO_SHAPE

    if (pEvent->type == (wmGD.shapeEventBase+ShapeNotify))

    {

        HandleCShapeNotify (pCD, (XShapeEvent *)pEvent);

    }

    else

#endif /* NO_SHAPE */

    switch (pEvent->type)

    {

	case ColormapNotify:

	{

	    /*

	     * Process changes to top-level client window colormaps:

	     */

	    HandleCColormapNotify (pCD, (XColormapEvent *)pEvent);

	    doXtDispatchEvent = False;

	    break;

	}

	case PropertyNotify:

	{

	    /*

	     * Process property changes on managed client windows:

	     */

	    HandleCPropertyNotify (pCD, (XPropertyEvent *)pEvent);

	    doXtDispatchEvent = False;

	    break;

	}

	case ClientMessage:

	{

	    /*

	     * Handle client message events.

	     */

	    HandleClientMessage (pCD, (XClientMessageEvent *)pEvent);

	    break;

	}

    }

    return (doXtDispatchEvent);

} /* END OF FUNCTION HandleEventsOnClientWindow */

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

 *

 *  HandleCPropertyNotify (pCD, propertyEvent)

 *

 *

 *  Description:

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

 *  This function handles propertyNotify events (indicating window property

 *  changes) that are reported to the client window.

 *

 *

 *  Inputs:

 *  ------

 *  pCD = pointer to the client data for the client window that got the event

 *

 *  propertyEvent = propertyNotify event that was received

 *

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

void HandleCPropertyNotify (ClientData *pCD, XPropertyEvent *propertyEvent)

{

    switch (propertyEvent->atom)

    {

        case XA_WM_HINTS:

	{

	    ProcessWmHints (pCD, FALSE /*not first time*/);

	    break;

	}

        case XA_WM_NORMAL_HINTS:

	{

	    ProcessWmNormalHints (pCD, FALSE /*not first time*/, 0);

	    break;

	}

        case XA_WM_NAME:

	{

	    ProcessWmWindowTitle (pCD, FALSE /*not first time*/);

	    break;

	}

        case XA_WM_ICON_NAME:

	{

	    ProcessWmIconTitle (pCD, FALSE /*not first time*/);

	    break;

	}

        case XA_WM_CLASS:

	{

	    break;

	}

        case XA_WM_COMMAND:

	{

	    if (pCD->clientFlags & CLIENT_TERMINATING)

	    {

		DeleteClientWmTimers (pCD);

		XKillClient (DISPLAY, pCD->client);

	    }

	    break;

	}

        case XA_WM_TRANSIENT_FOR:

        {

	    /*

	     * here we handle the special case of dialogs that are

	     * mapped before the windows they are transient for are

	     * mapped.  Xm handles this case by waiting for the

	     * transient_for window to appear before setting the

	     * WM_TRANSIENT_FOR property on the dialog.  Mwm has to

	     * notice this property change and re-organize things

	     * so the dialog is treated as a transient window.

	     *

	     * Note that we also handle the case of the WM_TRANSIENT_FOR

	     * property being removed. 

	     */

	    DeleteClientFromList (pCD->pSD->pActiveWS, pCD);

	    ProcessWmTransientFor(pCD);

	    AddClientToList(pCD->pSD->pActiveWS, pCD, True);

	    if (pCD->transientLeader != NULL)

		StackTransientWindow(pCD);

	    break;

	}

	default:

	{

	    if (propertyEvent->atom == wmGD.xa_WM_PROTOCOLS)

	    {

		ProcessWmProtocols (pCD);

	    }

#ifdef WSM

	    else if (propertyEvent->atom == wmGD.xa_DT_WORKSPACE_HINTS)

	    {

		(void) ProcessWorkspaceHints (pCD);

	    }

#endif /* WSM */

	    else if (propertyEvent->atom == wmGD.xa_MWM_MESSAGES)

	    {

		if (pCD->protocolFlags & PROTOCOL_MWM_MESSAGES)

		{

		    ProcessMwmMessages (pCD);

		}

	    }

	    else if (propertyEvent->atom == wmGD.xa_SM_CLIENT_ID)

	    {

		ProcessSmClientID(pCD);

	    }

	    else if (propertyEvent->atom == wmGD.xa_WMSAVE_HINT)

	    {

		ProcessWmSaveHint(pCD);

	    }

	    else if (propertyEvent->atom == wmGD.xa_WM_COLORMAP_WINDOWS)

	    {

		if (propertyEvent->state == PropertyNewValue)

		{

		    ProcessWmColormapWindows (pCD);

		}

		else

		{

		    /* property was deleted */

		    ResetColormapData (pCD, NULL, 0);

		}

		if ((ACTIVE_PSD->colormapFocus == pCD) &&

		    ((pCD->clientState == NORMAL_STATE) ||

		     (pCD->clientState == MAXIMIZED_STATE)))

		{

		    /*

		     * The client window has the colormap focus, install the

		     * colormap.

		     */

#ifndef OLD_COLORMAP /* colormap */

		    /*

		     * We just changed the colormaps list,

		     * so we need to re-run the whole thing.

		     */

		    pCD->clientCmapFlagsInitialized = 0;

		    ProcessColormapList (ACTIVE_PSD, pCD);

#else /* OSF original */

		    WmInstallColormap (ACTIVE_PSD, pCD->clientColormap);

#endif

		}

	    }

	    break;

	}

    }

} /* END OF FUNCTION HandleCPropertyNotify */

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

 *

 *  HandleCButtonPress (pCD, buttonEvent)

 *

 *

 *  Description:

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

 *  This function does window management actions associated with a button

 *  press event on the client window (including frame) or icon.

 *

 *

 *  Inputs: