/* 

 * 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[] = "$TOG: WmManage.c /main/11 1998/01/12 16:45:48 cshi $"

#endif

#endif

/*

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

 */

/*

 * Included Files:

 */

#include "WmGlobal.h"

#include "WmICCC.h"

/*

 * include extern functions

 */

#include "WmCDecor.h"

#include "WmCEvent.h"

#include "WmColormap.h"

#include "WmError.h"

#include "WmEvent.h"

#include "WmFunction.h"

#include "WmGraphics.h"

#include "WmIDecor.h"

#include "WmIconBox.h"

#include "WmImage.h"

#include "WmKeyFocus.h"

#ifdef PANELIST

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

#include 

#include "WmIPC.h"

#endif /* PANELIST */

#include "WmManage.h"

#include "WmMenu.h"

#include "WmProperty.h"

#include "WmProtocol.h"

#include "WmWinInfo.h"

#include "WmWinList.h"

#include "WmWinState.h"

#ifdef WSM

#include "WmPresence.h"

#include "WmWrkspace.h"

#endif /* WSM */

#include "WmXSMP.h"

/*

 * Function Declarations:

 */

#ifdef PANELIST

Boolean IsEmbeddedClient (

    ClientData *pCD, 

    WmFpEmbeddedClientData **ppECD);

Boolean ManageEmbeddedClient ( 

    ClientData *pCD, 

    WmFpEmbeddedClientData *pECD,

    long manageFlags);

Boolean IsPushRecallClient (

    ClientData *pCD, 

    WmFpPushRecallClientData **ppPRCD);

static void HandleSubstructEvents(

        Widget w,

        caddr_t ptr,

        XEvent *event );

Boolean UpdateEmbeddedClientsProperty(

        WmScreenData *pSD );

static void ForceSubpanelWMState(Window win);

static void ReManageWindow (ClientData *pCD);

static void CheckPushRecallClient (ClientData *pCD);

#endif /* PANELIST */

/*

 * Global Variables:

 */

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

 *

 *  AdoptInitialClients (pSD)

 *

 *  Inputs:

 *  -------

 *  pSD = pointer to screen data

 *

 *

 *  Description:

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

 *  This function is called to find client windows that were mapped prior to 

 *  starting (or restarting) the window manager.  These windows are included

 *  in the set of windows managed by the window manager.

 *

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

void AdoptInitialClients (WmScreenData *pSD)

{

    Window  root;

    Window  parent;

    Window *clients;

#ifdef WSM

    int nAncillaries, iAnc;

    Window *pAncillaryWindows, *pWin1;

    WmWorkspaceData *pWS0;

#endif /* WSM */

    unsigned int     nclients;

    ClientData *pcd = NULL;

    PropWMState *wmStateProp;

    Boolean manageOnRestart;

    int i,j;

    long manageFlags;

#ifdef WSM

    /* 

     * Generate list of ancillary windows (not to be managed)

     */

    nAncillaries = 2 + pSD->numWorkspaces;

    pAncillaryWindows = (Window *) XtMalloc (sizeof(Window)*(nAncillaries));

    if (!pAncillaryWindows)

    {

	Warning (((char *)GETMESSAGE(46, 1, "Insufficient memory to adopt initial clients")));

	ExitWM (WM_ERROR_EXIT_VALUE);

    }

    pWS0 = pSD->pWS;

    pWin1 = pAncillaryWindows;

    for (iAnc = 0; iAnc < pSD->numWorkspaces; iAnc++)

    {

	*pWin1 = XtWindow((pWS0)->workspaceTopLevelW);

	pWin1++;

	pWS0++;

    }

    *pWin1++ = XtWindow (pSD->screenTopLevelW);

    *pWin1 = pSD->activeIconTextWin;

#endif /* WSM */

    /*

     * Look for mapped top-level windows and start managing them:

     */

    if (XQueryTree (DISPLAY, pSD->rootWindow, &root, &parent, &clients,

	    &nclients))

    {

#ifndef DONT_FILTER_ICON_WINDOWS

	/*

	 * Filter out icon windows so they don't get managed as a client

	 * window.  Icon windows will be process in SetupClientIconWindow().

	 */

	XWMHints *tmphint;

	for (i = 0; i < nclients; i++) {

	    if (clients[i]) {

		if ((tmphint = XGetWMHints (DISPLAY, clients[i])) != NULL) {

		    if (tmphint->flags & IconWindowHint) {

			for (j = 0; j < nclients; j++) {

			    if (clients[j] == tmphint->icon_window) {

				clients[j] = None;

				break;

			    }

			}

		    }

		    XFree ((char *) tmphint);

		}

	    }

	}

#endif

	for (i = 0; i < nclients; i++)

	{

	    /* determine if the client window should be managed by wm */

#ifdef WSM

            if (InWindowList (clients[i], pAncillaryWindows, nAncillaries))

            {

		/* don't manage ancillary window manager windows */

                continue;

	    }

#else /* WSM */

            if ((clients[i] == XtWindow (pSD->screenTopLevelW)) ||

		(clients[i] == XtWindow (pSD->pActiveWS->workspaceTopLevelW)) ||

		(clients[i] == pSD->activeIconTextWin))

            {

		/* don't manage ancillary window manager windows */

                continue;

	    }

#endif /* WSM */

	    if (!XFindContext (DISPLAY, clients[i], wmGD.windowContextType,

	        (caddr_t *)&pcd)) 

	    {

		/* don't manage a window we've already established a 

		   context for (e.g. icon windows) */

		continue;

	    }

	    if (!WmGetWindowAttributes (clients[i]))

            {

		/* can't access the window; ignore it */

		continue;

            }

	    /* window attributes are put into the global cache */

	    /*

	     * Get the window WM_STATE property value to determine the

	     * initial window state if the wm is being restarted.

	     */

	    manageFlags = MANAGEW_WM_STARTUP;

	    manageOnRestart = True;

	    if (wmGD.wmRestarted)

	    {

		manageFlags |= MANAGEW_WM_RESTART;

		if ((wmStateProp = GetWMState (clients[i])) != NULL)

		{

		    if (wmStateProp->state == IconicState)

		    {

			manageFlags |= MANAGEW_WM_RESTART_ICON;

		    }

		    else if (wmStateProp->state != NormalState)

		    {

			manageOnRestart = False;

		    }

		    XFree ((char *)wmStateProp);

		}

		else 

		{

		    manageOnRestart = False;

		}

	    }

	    /*

	     * Don't manage any override_redirect windows (mapped or not).

	     * Manage an unmapped window if it has a WM_STATE property

	     *   and it is not Withdrawn.

	     * Manage any window that is mapped.

	     */

	    if ((wmGD.windowAttributes.override_redirect != True) &&

		((wmGD.wmRestarted && manageOnRestart) ||

		 (wmGD.windowAttributes.map_state != IsUnmapped)))

	    {

		ManageWindow (pSD, clients[i], manageFlags);

	    }

	}

	if (nclients)

	{

	    XFree ((char *)clients);

	}

    }

#ifdef WSM

    if (pAncillaryWindows)

    {

	XtFree ((char *) pAncillaryWindows);

    }

#endif /* WSM  */

} /* END OF FUNCTION AdoptInitialClients */

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

 *

 *  ManageWindow (pSD, clientWindow, manageFlags)

 *

 *

 *  Description:

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

 *  This is the highlevel function that is used to include a window in

 *  the set of windows that are managed by the window manager.  The window

 *  gets reparented and decorated, gets an icon, is setup for window

 *  management event handling, etc.  Client windows that are controlled

 *  by the window manager (e.g., the icon box) are also managed with

 *  this function.

 *

 *

 *  Inputs:

 *  ------

 *  clientWindow = window of the client that we should manage

 *

 *  manageFlags	= additional control information 

 *

 * 

 *  Outputs:

 *  -------

 *  pCD = initialized client data

 *

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

void 

ManageWindow (WmScreenData *pSD, Window clientWindow, long manageFlags)

{

    ClientData *pCD;

    int initialState;

    int i;

    Boolean sendConfigNotify;

#ifdef WSM

    WmWorkspaceData *pwsi;

#endif /* WSM */

#ifdef PANELIST 

    WmFpEmbeddedClientData *pECD;

#endif /* PANELIST */

    /*

     * Get client information including window attributes and window

     * property values.  Use this information to determine how the window

     * is to be managed.

     */

    if (!(pCD = GetClientInfo (pSD, clientWindow, manageFlags)))

    {

	/* error getting client info; do not manage the client window */

	return;

    }

#ifdef PANELIST

    /*

     *  Handle case of transients that derive from embedded clients.

     */

    if (wmGD.dtSD && (wmGD.dtSD == pCD->pSD))

    {

	if (pCD->transientLeader && pCD->transientLeader->pECD)

	{

	    WmPanelistObject  pPanelist;

	    ClientData *pCDfp = NULL;

	    pPanelist = (WmPanelistObject) pCD->pSD->wPanelist;

	    (void) XFindContext (DISPLAY, XtWindow(O_Shell (pPanelist)),

		      wmGD.windowContextType, (caddr_t *)&pCDfp);

	    pCD->transientLeader = pCDfp;

	}

    }

    if (IsEmbeddedClient (pCD, &pECD))

    {

	/*

	 * This client is embedded in the front panel 

	 */

	if (ManageEmbeddedClient(pCD, pECD, manageFlags))

	{

	    /*

	     *   ...then we've embedded it in the front

	     *   panel--no further processing required.

	     */

#ifdef WSM

	    if (smAckState == SM_START_ACK)

	    {

		SendClientMsg( wmGD.dtSmWindow, 

			      (long) wmGD.xa_DT_SM_WM_PROTOCOL,

			      (long) wmGD.xa_DT_WM_WINDOW_ACK,

			      CurrentTime, NULL, 0);

	    }

#endif /* WSM */

	    return;

	}

    }

    /*

     *  Handle case of transients that derive from embedded clients.

     *  !!!!

     */

#if 0

    if (pCD->transientLeader && pCD->transientLeader->pAccessPanel)

    {

        pCD->transientLeader = 

	    pCD->transientLeader->pAccessPanel->pCD_accessPanel;

    }

#endif 

#endif /* PANELIST */

#ifdef WSM

    if (pCD->inputMode == MWM_INPUT_SYSTEM_MODAL)

    {

	/*

	 * Put system modal windows in all workspaces to

	 * avoid the race condition of the window coming up

	 * just as the user switches workspaces.

	 */

	pCD->dtwmFunctions |= DtWM_FUNCTION_OCCUPY_WS;

	F_AddToAllWorkspaces(0, pCD, 0);

	pCD->dtwmFunctions &= ~DtWM_FUNCTION_OCCUPY_WS;

    }

#endif /* WSM */

    if (manageFlags & MANAGEW_WM_RESTART)

    {

	if (manageFlags & MANAGEW_WM_RESTART_ICON)

	{

	    pCD->clientState = MINIMIZED_STATE;

	}

	else

	{

	    pCD->clientState = NORMAL_STATE;

	}

    }

    /*

     * Setup the initial placement of the client window.  Do interactive

     * placement if configured.

     */

    sendConfigNotify = InitClientPlacement (pCD, manageFlags);

    /*

     * Make a window frame for the client window and reparent the client

     * window.

     */

    if (!FrameWindow (pCD))

    {

	/*

	 * Error in framing the window; clean up the wm resources made

	 * up to this point for the client window. Do not manage the

	 * client window.

	 */

	UnManageWindow (pCD);

	return;

    }

    /*

     * Send config notify if the client's been moved/resized

     */

    if (sendConfigNotify)

    {

	SendConfigureNotify (pCD);

    }

    /*

     * Send client offset message if:

     *

     *   1. The client is interested.

     *   2. The position we report to the user is not the client's real

     *      position.

     *   3. There is a client offset to report.

     */

    if ((pCD->protocolFlags & PROTOCOL_MWM_OFFSET) &&

	(wmGD.positionIsFrame) && 

	((pCD->clientOffset.x != 0) ||

	 (pCD->clientOffset.y != 0)))

    { 

	SendClientOffsetMessage (pCD);

    }

    /*

     * Make an icon for the client window if it is not a valid transient

     * window.

     */

#ifdef WSM

    if ((pCD->clientFunctions & MWM_FUNC_MINIMIZE) &&

	(pCD->transientLeader == NULL))

    {

	/* 

	 * Make icons frames 

	 * Only make one icon frame for root icons.

	 * Make one per workspace for icon box icons.

	 */

	for (i = 0; i < pCD->numInhabited; i++)

	{

	    if (pwsi = GetWorkspaceData(pCD->pSD, pCD->pWsList[i].wsID))

	    {

		if ((pCD->pSD->useIconBox && 

                     !(manageFlags & MANAGEW_WM_CLIENTS) &&

		     !(pCD->clientFlags & FRONT_PANEL_BOX)) || (i == 0))

		{

		    /*

		     *   Make icon inside an icon box for non-root case

		     */

		    if (!MakeIcon (pwsi, pCD)) 

		    { 

			/*

			 * Error in making an icon for the client window; 

			 * clean up the wm resources; do not manage the 

			 * client window.

			 */

			UnManageWindow (pCD);

			return;

		    }

		    else 

		    {

			XSaveContext (DISPLAY, pCD->pWsList[i].iconFrameWin, 

				wmGD.windowContextType, (caddr_t)pCD);

			if (pCD->iconWindow && pCD->pWsList[i].iconFrameWin)

			{

			    XGrabButton (DISPLAY, AnyButton, AnyModifier, 

				pCD->pWsList[i].iconFrameWin, True,

				ButtonPressMask|ButtonReleaseMask|

				    ButtonMotionMask,

				GrabModeAsync, GrabModeAsync, None, 

				wmGD.workspaceCursor);

			}

		    }

		}

		else 

		{

		    /* 

		     *  Make root icons for a client

		     */

 		    if ((pCD->clientFunctions & MWM_FUNC_MINIMIZE) &&

 			(pCD->transientLeader == NULL))

 		    {

 			if ((i == 0) &&

 			    (!MakeIcon (pwsi, pCD)))

 			{

 			    /*

 			     * Error in making an icon for the client 

 			     * window; clean up the wm resources; do 

 			     * not manage the client window.

 			     */

 			    UnManageWindow (pCD);

 			    return;

 			}

 			else

 			{

 			    /* copy root icon frame reference to other 

 			     * workspaces

			     */

 			    pCD->pWsList[i].iconFrameWin = 

 				    pCD->pWsList[0].iconFrameWin;

 			}

 		    }

		}

	    }

	}

    }

#else /* WSM */

    if ((pCD->clientFunctions & MWM_FUNC_MINIMIZE) &&

        (pCD->transientLeader == NULL) && 

	  !MakeIcon (pCD->pSD->pActiveWS, pCD))

    {

	/*

	 * Error in making an icon for the client window; clean up the wm

	 * resources; do not manage the client window.

	 */

	UnManageWindow (pCD);

	return;

    }

#endif /* WSM */

    /*

     * Register window contexts to facilitate event handling:

     */

    XSaveContext (DISPLAY, pCD->clientFrameWin, wmGD.windowContextType,

	(caddr_t)pCD);

    XSaveContext (DISPLAY, pCD->clientBaseWin, wmGD.windowContextType,

	(caddr_t)pCD);

    if (DECOUPLE_TITLE_APPEARANCE(pCD) && pCD->clientTitleWin)

    {

	/* 

	 * handle exposures on title bar if it has its own appearance

	 */

	XSaveContext (DISPLAY, pCD->clientTitleWin, wmGD.windowContextType,

	    (caddr_t)pCD);

    }

#ifndef WSM

    if (pCD->iconFrameWin)

    {

	XSaveContext (DISPLAY, pCD->iconFrameWin, wmGD.windowContextType,

	    (caddr_t)pCD);

    }

#endif /* WSM */

    if (pCD->clientCmapCount > 0)

    {

	for (i = 0; i < pCD->clientCmapCount; i++)

	{

	    if (pCD->cmapWindows[i] != pCD->client)

	    {

#ifndef	IBM_169380

		AddColormapWindowReference(pCD, pCD->cmapWindows[i]);

#else

	        XSaveContext (DISPLAY, pCD->cmapWindows[i],

		    wmGD.windowContextType, (caddr_t)pCD);

#endif

	    }

	}

    }

    pCD->clientFlags |= CLIENT_CONTEXT_SAVED;

    /*

     * Setup button binding handling for actions that apply to the client

     * window.

     */

    if (BUTTON_SPECS(pCD))

    {

	SetupCButtonBindings (pCD->clientBaseWin, BUTTON_SPECS(pCD));

    }

#ifndef WSM

    if (pCD->iconWindow && pCD->iconFrameWin)

    {

	XGrabButton (DISPLAY, AnyButton, AnyModifier, pCD->iconFrameWin, True,

	    ButtonPressMask | ButtonReleaseMask | ButtonMotionMask,

	    GrabModeAsync, GrabModeAsync, None, wmGD.workspaceCursor);

    }

#endif /* WSM */

    /*

     * Setup key binding handling for system menu accelerators.

     */

    if (pCD->systemMenuSpec &&

        (pCD->systemMenuSpec->accelKeySpecs))

    {

	SetupKeyBindings (pCD->systemMenuSpec->accelKeySpecs,

			  pCD->clientFrameWin, GrabModeSync, F_CONTEXT_ALL);

#ifdef WSM

	for (i = 0; i < pCD->numInhabited; i++)

	{

	    if (!pCD->pWsList[i].pIconBox && pCD->pWsList[i].iconFrameWin)

	    {

		SetupKeyBindings (pCD->systemMenuSpec->accelKeySpecs,

			      pCD->pWsList[i].iconFrameWin, GrabModeSync, 

			      F_CONTEXT_ALL);

	    }

	}

#else /* WSM */

	if (!pCD->pIconBox && pCD->iconFrameWin)

	{

	    SetupKeyBindings (pCD->systemMenuSpec->accelKeySpecs,

			      pCD->iconFrameWin, GrabModeSync, F_CONTEXT_ALL);

	}

#endif /* WSM */

    }

#ifdef WSM

  for (i = 0; i < pCD->numInhabited; i++)

  {

    if (!pCD->pWsList[i].pIconBox && pCD->pWsList[i].iconFrameWin)

#else /* WSM */

    if (!pCD->pIconBox && pCD->iconFrameWin)

#endif /* WSM */

    {

	static int iconKeySpec = 1;

	static int iconAccelSpec = 1;

        if ((iconKeySpec != 0) && KEY_SPECS(pCD))

        {

#ifdef WSM

	    iconKeySpec = SetupKeyBindings (KEY_SPECS(pCD), 

				pCD->pWsList[i].iconFrameWin,

				GrabModeSync, F_CONTEXT_ICON);

#else /* WSM */

	    iconKeySpec = SetupKeyBindings (KEY_SPECS(pCD), pCD->iconFrameWin,

				GrabModeSync, F_CONTEXT_ICON);

#endif /* WSM */

        }

        if ((iconAccelSpec != 0) && ACCELERATOR_MENU_COUNT(pCD))

        {

	    int n;

	    iconAccelSpec = 0;

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

	    {

#ifdef WSM

	        iconAccelSpec += SetupKeyBindings (

			    ACCELERATOR_MENU_SPECS(pCD)[n]->accelKeySpecs,

			    pCD->pWsList[i].iconFrameWin, GrabModeSync,

			    F_CONTEXT_ICON);

#else /* WSM */

	        iconAccelSpec += SetupKeyBindings (

			    ACCELERATOR_MENU_SPECS(pCD)[n]->accelKeySpecs,

			    pCD->iconFrameWin, GrabModeSync,

			    F_CONTEXT_ICON);

#endif /* WSM */

	    }

	}

    }

#ifdef WSM

  }

#endif /* WSM */

    /*

     * Setup keyboard focus handling if policy is "explicit".

     */

    if (wmGD.keyboardFocusPolicy == KEYBOARD_FOCUS_EXPLICIT)

    {

	DoExplicitSelectGrab (pCD->clientBaseWin);

    }

#ifdef WSM

    UpdateWorkspacePresenceProperty(pCD);

#endif /* WSM */

    /*

     * Make sure the client window has been reparented ...

     */

    if (!(manageFlags & MANAGEW_WM_CLIENTS))

    {

        XSync (DISPLAY, False);

        if (pCD->clientFlags & CLIENT_DESTROYED)

        {

	    UnManageWindow (pCD);

	    return;

        }

    }

    /*

     * Setup the initial display state for the client window:

     */

    initialState = pCD->clientState;

#ifdef WSM

    if (!ClientInWorkspace (pSD->pActiveWS, pCD))

    {

	initialState |= UNSEEN_STATE;

    }

#endif /* WSM */

    pCD->clientState = WITHDRAWN_STATE;

    pCD->clientFlags &= ~WM_INITIALIZATION;

#ifdef WSM

    /* 

     * Add to stacking list using the client's zero'th workspace

     * instead of the current one because it may not be in 

     * the current one.

     */

    AddClientToList (GetWorkspaceData (pSD, pCD->pWsList[0].wsID),

	pCD, True /*on top*/);

#else /* WSM */

    AddClientToList (pSD->pActiveWS, pCD, True /*on top*/);

#endif /* WSM */

    SetClientState (pCD, initialState, GetTimestamp());

    /*

     * Set the keyboard input focus to the newly managed window if appropriate:

     * - focus is automatically set only if the focus policy is explicit

     * - if there is a system modal window active then set the focus only

     *   if the new window is in the system modal heirarchy

     * - focus is automatically set if startupKeyFocus is selected or

     *   the new window is a system modal window or the current focus window

     *   has the new window as an application modal subordinate

     * - don't automatically set the focus if the window is minimized or

     *   is a window that generally doesn't take input

     */

    if ((wmGD.keyboardFocusPolicy == KEYBOARD_FOCUS_EXPLICIT) &&

	((pCD->inputMode == MWM_INPUT_SYSTEM_MODAL) ||

	 ((!wmGD.systemModalActive ||

	   (wmGD.systemModalClient == FindTransientTreeLeader (pCD))) &&

	  (wmGD.startupKeyFocus ||

	   (wmGD.keyboardFocus && (IS_APP_MODALIZED(wmGD.keyboardFocus)))) &&

	  !(manageFlags &

	    (MANAGEW_WM_STARTUP | MANAGEW_WM_RESTART | MANAGEW_WM_CLIENTS)) &&

	  (pCD->clientState != MINIMIZED_STATE) &&

#ifdef WSM

          !(pCD->clientState & UNSEEN_STATE) &&

#endif /* WSM */

	  (pCD->inputFocusModel ||

	   (pCD->protocolFlags & PROTOCOL_WM_TAKE_FOCUS)))))

    {

	Do_Focus_Key (pCD, GetTimestamp() , ALWAYS_SET_FOCUS);

    }

    else if ((pCD->inputMode == MWM_INPUT_SYSTEM_MODAL) ||

	     (wmGD.keyboardFocus && IS_APP_MODALIZED(wmGD.keyboardFocus)))

    {

	Do_Focus_Key ((ClientData *)NULL, GetTimestamp() , ALWAYS_SET_FOCUS);

    }

#ifdef WSM

    if (smAckState == SM_START_ACK)

    {

	SendClientMsg( wmGD.dtSmWindow, (long) wmGD.xa_DT_SM_WM_PROTOCOL,

		      (long) wmGD.xa_DT_WM_WINDOW_ACK,

		      CurrentTime, NULL, 0);

    }

    /*

     * Free the initial property list. This will force

     * reads of properties that change after the initial

     * management (see HasProperty() function.)

     */

    DiscardInitialPropertyList (pCD);

#endif /* WSM */

#ifdef PANELIST

    CheckPushRecallClient (pCD);

#endif /* PANELIST */

} /* END OF FUNCTION ManageWindow */

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

 *

 *  UnManageWindow (pCD)

 *

 *

 *  Description:

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

 *  This function removes a top-level client window and it's transients

 *  from the set of windows that is managed by the window manager.  

 *

 *

 *  Inputs:

 *  ------

 *  pCD 	- pointer to client data of window to unmanage

 *

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

void UnManageWindow (ClientData *pCD)

{

#ifdef PANELIST

    if (pCD->pECD)

    {

	WmFpEmbeddedClientData *pECD;

	pECD = (WmFpEmbeddedClientData *) pCD->pECD;

	XtRemoveEventHandler(XtWindowToWidget (DISPLAY1, pECD->winParent),

		(SubstructureRedirectMask | SubstructureNotifyMask),

	        False,

		(XtEventHandler)HandleSubstructEvents,

		(XtPointer)(pCD));

	pECD->pCD = NULL;

	UpdateEmbeddedClientsProperty (pCD->pSD);

    }

    if (pCD->pPRCD)

    {

	WmFpPushRecallClientData *pPRCD;

	int j;