/*
 *  @OPENGROUP_COPYRIGHT@
 *  COPYRIGHT NOTICE
 *  Copyright (c) 1990, 1991, 1992, 1993 Open Software Foundation, Inc.
 *  Copyright (c) 1996, 1997, 1998, 1999, 2000 The Open Group
 *  ALL RIGHTS RESERVED (MOTIF). See the file named COPYRIGHT.MOTIF for
 *  the full copyright text.
 *  
 *  This software is subject to an open license. It may only be
 *  used on, with or for operating systems which are themselves open
 *  source systems. You must contact The Open Group for a license
 *  allowing distribution and sublicensing of this software on, with,
 *  or for operating systems which are not Open Source programs.
 *  
 *  See http://www.opengroup.org/openmotif/license for full
 *  details of the license agreement. Any use, reproduction, or
 *  distribution of the program constitutes recipient's acceptance of
 *  this agreement.
 *  
 *  EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
 *  PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *  KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
 *  WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
 *  OR FITNESS FOR A PARTICULAR PURPOSE
 *  
 *  EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
 *  NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT,
 *  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED
 *  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 *  ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
 *  EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGES.
 */
/* $TOG: WmCmd.c /main/11 1997/03/20 11:15:26 dbl $
 *
 * (c) Copyright 1996 Digital Equipment Corporation.
 * (c) Copyright 1996 Hewlett-Packard Company.
 * (c) Copyright 1996 International Business Machines Corp.
 * (c) Copyright 1996 Sun Microsystems, Inc.
 * (c) Copyright 1996 Novell, Inc. 
 * (c) Copyright 1996 FUJITSU LIMITED.
 * (c) Copyright 1996 Hitachi.
 */

#include <Xm/Xm.h>
#include <Xm/ScrollBarP.h>
#include "./WmWsmLib/utm_send.h"
#include "./WmWsmLib/wsm_proto.h"
#include "WmGlobal.h"
#include "WmFunction.h"
#include "WmCmd.h"
#include "WmMenu.h"
#include "WmResParse.h"
#include "WmWsm.h"
#include "WmDebug.h"
#include "WmWinConf.h"



#define MAX_CLIENT_CMDS 1000





static CARD32 cmdKillList[MAX_CLIENT_CMDS];
static unsigned long cmdKillListIndex;

#define ScrNum(w) (XScreenNumberOfScreen(XtScreen(w)))
#define CCI_TREE(w) (wmGD.Screens[ScrNum(w)].cciTree)
#define CCI_TREE_OF_SCR(scr) (wmGD.Screens[(scr)].cciTree)




/*----------------------------------------------------------------------*
 |                              NewCommand                              |
 *----------------------------------------------------------------------*/
CmdTree *
NewCommand (
     CARD32  commandID,
     CARD32  notifyWindow,
     char   *name,
     char   *defaultName)
	    
{
  CmdTree *ptr = (CmdTree *) XtMalloc(sizeof(CmdTree));

  ptr->commandID    = commandID;
  ptr->notifyWindow = notifyWindow;

  if (name != NULL) ptr->name = XtNewString(name);
  else              ptr->name = XtNewString("");
    
  if (defaultName != NULL) ptr->defaultName = XtNewString(defaultName);
  else                     ptr->defaultName = NULL;

  ptr->subTrees = NULL;

  ptr->next     = NULL;

  return(ptr);
}

/*---------------------------------------------------------------------------*
 |                                  FindCmd                                  |
 *---------------------------------------------------------------------------*/
CmdTree *
FindCmd(
     CARD32    commandID,
     CmdTree  *menuTree)
{
  CmdTree *pCmd;

  if (menuTree != NULL) PRINT("-> %s\n", menuTree->name);

  if (menuTree == NULL)
    {
      PRINT("<- NULL\n");
      return(NULL);
    }

  if (menuTree->commandID == commandID)
    {
      PRINT("<- %d, %s\n", commandID, menuTree->name);
      return(menuTree);
    }

  if ((pCmd = FindCmd(commandID, menuTree->next)) != NULL)
    return(pCmd);

  return(FindCmd(commandID, menuTree->subTrees));
}

/*---------------------------------------------------------------------------*
 |                             FindDuplicateName                             |
 | Scan through commandTree for another defined command with the same name.  |
 | Once found, return the ID of the duplicate.  Note that at most one match  |
 | can be found. If no match is found, 0 is returned.  This should NEVER be  |
 | the value of a command defined by a client.                               |
 *---------------------------------------------------------------------------*/
CARD32
FindDuplicateName(
     CmdTree  *menuTree,
     char     *name)
{
  CmdTree *tmp;
  CARD32  duplicateID;

  if (menuTree == NULL)
    return(0);

  else if ((menuTree->name != NULL) && (strcmp(menuTree->name, name) == 0))
    return(menuTree->commandID);

  else if ((duplicateID = FindDuplicateName(menuTree->subTrees, name)) != 0)
    return(duplicateID);

  else
    return(FindDuplicateName(menuTree->next, name));
}


/*----------------------------------------------------------------------*
 |                              AddCommand                              |
 | Returns true if the commandSet was found and a new command was added.|
 | Note that toplevel commands have 0 as their commandSet.  This will   |
 | always match the top entry in the command tree since it is 0.        |
 *----------------------------------------------------------------------*/
Boolean
AddCommand (
     int      scr,
     CARD32   commandSet,
     CARD32   commandID,
     CARD32   notifyWindow,
     char    *name,
     char    *defaultName,
     CmdTree *ptr)
{
  /*
   *  For each subtree of the cmdtree, look for the commandset.
   *  If found, add the element there else keep looking.
   */

  CmdTree *tmp;
  CARD32 duplicateID;

  if (ptr == NULL) return (False);

  else if (ptr->commandID == commandSet)
    /* FOUND IT */
    {
      if ((duplicateID = FindDuplicateName(CCI_TREE_OF_SCR(scr), name)) != 0)
	{
	  /* a duplicate menu item already exists here, remove it first.
	   */
	  if (ptr->subTrees != NULL)
	    DestroyMenuSpec (&(wmGD.Screens[scr]), commandID);
	  DeleteCommand(commandID, &CCI_TREE_OF_SCR(scr));
	}

      tmp = ptr->subTrees;
      ptr->subTrees = NewCommand(commandID, notifyWindow, name, defaultName);
      ptr->subTrees->next = tmp;

      return(True);
    }

  else
    {
      Boolean found;

      found = AddCommand(scr, commandSet, commandID, notifyWindow,
			 name, defaultName, ptr->next);
      if (!found)
	found = AddCommand(scr, commandSet, commandID, notifyWindow,
			   name, defaultName, ptr->subTrees);

      return (found);
    }
}


/*---------------------------------------------------------------------------*
 |                          RemoveCommandBranch                              |
 | This routine all commands at the specified node in the command tree.      |
 *---------------------------------------------------------------------------*/
void
RemoveCommandBranch (CmdTree *menuTree)
{
  CmdTree *tmp = menuTree;

  while (menuTree != NULL)
    {
      if (menuTree->subTrees != (CmdTree*)NULL)
	RemoveCommandBranch(menuTree->subTrees);

      menuTree = menuTree->next;
      if (tmp->name != NULL)
	XtFree((char*)tmp->name);
      XtFree((char*)tmp);
    }
}


/*---------------------------------------------------------------------------*
 |                              DeleteCommand                                |
 | This routine deletes any matching command entries in the Command Tree.    |
 *---------------------------------------------------------------------------*/
void
DeleteCommand (
     long      commandID,
     CmdTree **pmenuTree)
{
  if ((pmenuTree == NULL) || (*pmenuTree == NULL))
    return;

  else
    {
      CmdTree *tmp  = *pmenuTree;
      CmdTree *prev = NULL;

      while (tmp != (CmdTree *)NULL)

	if (tmp->commandID == commandID)
	  {
	    RemoveCommandBranch(tmp->subTrees); /* remove all sub-commands. */
	    if (prev == (CmdTree *)NULL)
	      *pmenuTree = tmp->next;
	    else
	      prev->next = tmp->next;
	    
	    if (tmp->name != NULL)
	      XtFree((char*)tmp->name);
	    XtFree((char *)tmp);
	    tmp = prev;
	  }

	else
	  {
	    if (tmp->subTrees != (CmdTree *)NULL)
	      DeleteCommand(commandID, &tmp->subTrees);
	    prev = tmp;
	    tmp = tmp->next;
	  }
    }
}


/*----------------------------------------------------------------------*
 |                            DefineCommand                             |
 | hack version - restriction: no spaces allowed in names.              |
 *----------------------------------------------------------------------*/
/*ARGSUSED*/
void
DefineCommand (
     Widget         w,
     Atom           target,
     MessageData    data,
     unsigned long  len,
     int            fmt)
{
  CARD32  commandID, commandSet, selection, duplicateID;
  String  name, defaultLabel;
  Boolean found = False;
  Window  owner;
  XWindowAttributes attr;

  /*
   * check data to make sure somethings there.
   */
  if ((data == NULL) || (len == 0))
    {
      PRINT("Bad data passed to DefineCommand.\n");
      return;
    }

  commandID    = UnpackCARD32(&data);
  selection    = UnpackCARD32(&data); /* selection to use for invoke cmd */
  commandSet   = UnpackCARD32(&data);
  name         = UnpackString(&data);
  defaultLabel = UnpackString(&data);

  PRINT("Define command: %d, %d, '%s', '%s'\n",
	commandID, commandSet, name, defaultLabel);
  
  /*
   *  Add command to menu structure.
   */

  if (CCI_TREE(w) == NULL)
    {
      CCI_TREE(w) = NewCommand(0, 0, NULL, NULL);
    }


  if (commandSet != 0)
    {
      found = AddCommand(ScrNum(w), commandSet, commandID, selection, name,
			 defaultLabel, CCI_TREE(w));
    }
  else
    /*
     * A leaf is being added to the command tree. There should not
     * be any other entries with the same name since matching with
     * the mwm resource file is done on names.  If a duplicate is
     * found, remove it first and any menu spec if it is a command
     * set. 
     */
    if ((duplicateID = FindDuplicateName(CCI_TREE(w), name)) != 0)
      {
	/* a duplicate menu item already exists here, remove it first.
	 */
	DestroyMenuSpec (&(wmGD.Screens[ScrNum(w)]), duplicateID);
	DeleteCommand(duplicateID, &CCI_TREE(w));
      }

  if (!found || commandSet == 0)
    {
      CmdTree *tmp;

      tmp = NewCommand(commandID, selection, name, defaultLabel);
      tmp->next = CCI_TREE(w)->next;
      CCI_TREE(w)->next = tmp;
    }
}



/*----------------------------------------------------------------------*
 |                            IncludeCommand                            |
 *----------------------------------------------------------------------*/
/*ARGSUSED*/
void
IncludeCommand (
     Widget         w,
     Atom           target,
     MessageData    data,
     unsigned long  len,
     int            fmt)
{
  CARD32         inLine, commandID, selection, count;
  Window        *windowIDs;
  CmdTree       *tPtr, *pNext;
  int            i, win;
  unsigned long  activeContext = 0L;

  /*
   * check data to make sure somethings there.
   */
  if ((data == NULL) || (len == 0))
    {
      PRINT("Bad data passed to IncludeCommand.\n");
      return;
    }

  inLine    = UnpackCARD32(&data);
  commandID = UnpackCARD32(&data);
  selection = UnpackCARD32(&data);
  count     = UnpackCARD32(&data);

  if (count > 0) windowIDs = (Window *) XtMalloc(sizeof(Window)*count);
  for (win=0; win<count; win++)
  {
      windowIDs[win] = UnpackCARD32(&data);
      PRINT("Got window ID %d.\n", windowIDs[win]);
  }

  /*
   *  Insert on root menu
   */
  if ((windowIDs[0] & WINDOW_MASK) == 0L)
    {
      ShowWaitState (TRUE);
	tPtr = FindCmd (commandID, CCI_TREE(w));
	if (tPtr != NULL)
	{
	    activeContext = F_CONTEXT_ROOT;
	    pNext = tPtr->next;
	    tPtr->next = NULL;
	    InsertTreeOnRootMenu(ACTIVE_PSD, tPtr, selection, inLine);
	    tPtr->next = pNext;
	}
      ShowWaitState (FALSE);
    }

  /*
   * Insert on all clients
   */
  else if ((windowIDs[0] & WINDOW_MASK) == ALL_WINDOWS)
    {
      tPtr = FindCmd (commandID, CCI_TREE(w));
      if (tPtr != NULL)
	{
	  ShowWaitState (TRUE);

	  activeContext = 0L;
	  if (windowIDs[0] &   ICON_ONLY) activeContext |= F_CONTEXT_ICON;
	  if (windowIDs[0] & WINDOW_ONLY) activeContext |= F_CONTEXT_WINDOW;
      
	  pNext = tPtr->next;
	  tPtr->next = NULL;
	  InsertTreeOnAllClients (ACTIVE_PSD, tPtr, selection,
				  activeContext, inLine);
	  tPtr->next = pNext;

	  PRINT("Inserted commandID %d on all windows.\n", commandID);
	  
	  ShowWaitState (FALSE);
	}
      else
	PRINT("ERROR - commandID %d not found in command tree.\n", commandID);
    }

  /*
   * Insert on specified clients
   */
  else
    {
      tPtr = FindCmd (commandID, CCI_TREE(w));
      if (tPtr != NULL)
	{
	  ShowWaitState (TRUE);

	  for (i=0; i<count; i++)
	    {
	      ClientData *pCD;
	      
	      activeContext = 0L;
	      if (windowIDs[i] &   ICON_ONLY)
		activeContext |= F_CONTEXT_ICON;
	      if (windowIDs[i] & WINDOW_ONLY)
		activeContext |= F_CONTEXT_WINDOW;
	      pCD = GetPCD(ScrNum(w), windowIDs[i] & WINDOW_MASK);
	      if (pCD != NULL)
	      {
		  pNext = tPtr->next;
		  tPtr->next = NULL;
		  InsertTreeOnSingleClient (pCD->pSD, pCD, tPtr, selection,
					    activeContext, inLine);
		  tPtr->next = pNext;
	      }
	    }

	  ShowWaitState (FALSE);
	}
      else
	PRINT("ERROR - commandID %d not found in command tree.\n", commandID);
    }

  if (count > 0)
    XtFree((char*)windowIDs);
}



/*----------------------------------------------------------------------*
 |                             EnableCommand                            |
 *----------------------------------------------------------------------*/
/*ARGSUSED*/
void
EnableCommand (
     Widget         w,
     Atom           target,
     MessageData    data,
     unsigned long  len,
     int            fmt)
{
  CARD32         commandID, count;
  Window        *windowIDs;
  CmdTree       *tPtr, *pNext;
  int            i, win;
  unsigned long  activeContext = 0L;

  /*
   * check data to make sure somethings there.
   */
  if ((data == NULL) || (len == 0))
    {
      PRINT("Bad data passed to EnableCommand.\n");
      return;
    }

  commandID = UnpackCARD32(&data);
  count     = UnpackCARD32(&data);

  if (count > 0) windowIDs = (Window *) XtMalloc(sizeof(Window)*count);
  for (win=0; win<count; win++)
    {
      windowIDs[win] = UnpackCARD32(&data);
      PRINT("Got window ID %d.\n", windowIDs[win]);
    }

  /*
   *  Enable on root menu
   */
  if ((windowIDs[0] & WINDOW_MASK) == 0L)
    {
      tPtr = FindCmd (commandID, CCI_TREE(w));
      if (tPtr != NULL)
	{
	  for (i=0; i<count; i++)
	  {
	      activeContext = F_CONTEXT_ROOT;
	      pNext = tPtr->next;
	      tPtr->next = NULL;
	      ModifyClientCommandTree (ACTIVE_PSD, NULL, ROOT, tPtr,
				       ENABLE, activeContext, NULL);
	      tPtr->next = pNext;
	  }
	}
      else
	PRINT("ERROR - commandID %d not found in command tree.\n", commandID);
    }

  /*
   * Enable on all clients
   */
  else if ((windowIDs[0] & WINDOW_MASK) == ALL_WINDOWS)
    {
      tPtr = FindCmd (commandID, CCI_TREE(w));
      if (tPtr != NULL)
	{
	  activeContext = 0L;
	  if (windowIDs[0] &   ICON_ONLY) activeContext |= F_CONTEXT_ICON;
	  if (windowIDs[0] & WINDOW_ONLY) activeContext |= F_CONTEXT_WINDOW;
      
	  pNext = tPtr->next;
	  tPtr->next = NULL;
	  ModifyClientCommandTree (ACTIVE_PSD, NULL, ALL, tPtr, ENABLE,
				   activeContext, NULL);
	  tPtr->next = pNext;

	  PRINT("Enabled commandID %d on all windows.\n", commandID);
	}
      else
	PRINT("ERROR - commandID %d not found in command tree.\n", commandID);
    }

  /*
   * Enable on specified clients
   */
  else
    {
      tPtr = FindCmd (commandID, CCI_TREE(w));
      if (tPtr != NULL)
	{
	  for (i=0; i<count; i++)
	    {
	      ClientData *pCD;

	      activeContext = 0L;
	      if (windowIDs[i] &   ICON_ONLY)
		activeContext |= F_CONTEXT_ICON;
	      if (windowIDs[i] & WINDOW_ONLY)
		activeContext |= F_CONTEXT_WINDOW;
	      
	      pCD = GetPCD(ScrNum(w), windowIDs[i] & WINDOW_MASK);
	      if (pCD != NULL)
	      {
		  pNext = tPtr->next;
		  tPtr->next = NULL;
		  ModifyClientCommandTree (pCD->pSD, pCD, SINGLE, tPtr,
					   ENABLE, activeContext, NULL);
		  tPtr->next = pNext;
	      }
	    }
	}
      else
	PRINT("ERROR - commandID %d not found in command tree.\n", commandID);
    }

  if (count > 0)
    XtFree((char*)windowIDs);
}



/*----------------------------------------------------------------------*
 |                             DisableCommand                            |
 *----------------------------------------------------------------------*/
/*ARGSUSED*/
void
DisableCommand (
     Widget         w,
     Atom           target,
     MessageData    data,
     unsigned long  len,
     int            fmt)
{
  CARD32         commandID, count;
  Window        *windowIDs;
  CmdTree       *tPtr, *pNext;
  int            i, win;
  unsigned long  activeContext = 0L;

  /*
   * check data to make sure somethings there.
   */
  if ((data == NULL) || (len == 0))
    {
      PRINT("Bad data passed to DisableCommand.\n");
      return;
    }

  commandID = UnpackCARD32(&data);
  count     = UnpackCARD32(&data);

  if (count > 0) windowIDs = (Window *) XtMalloc(sizeof(Window)*count);
  for (win=0; win<count; win++)
    {
      windowIDs[win] = UnpackCARD32(&data);
      PRINT("Got window ID %d.\n", windowIDs[win]);
    }

  /*
   *  Disable on root menu
   */
  if ((windowIDs[0] & WINDOW_MASK) == 0L)
    {
      tPtr = FindCmd (commandID, CCI_TREE(w));
      if (tPtr != NULL)
	{
	  for (i=0; i<count; i++)
	  {
	      activeContext = F_CONTEXT_ROOT;
	      pNext = tPtr->next;
	      tPtr->next = NULL;
	      ModifyClientCommandTree (ACTIVE_PSD, NULL, ROOT, tPtr,
				       DISABLE, activeContext, NULL);
	      tPtr->next = pNext;
	  }
	}
      else
	PRINT("ERROR - commandID %d not found in command tree.\n", commandID);
    }

  /*
   * Disable on all clients
   */
  else if ((windowIDs[0] & WINDOW_MASK) == ALL_WINDOWS)
    {
      tPtr = FindCmd (commandID, CCI_TREE(w));
      if (tPtr != NULL)
	{
	  activeContext = 0L;
	  if (windowIDs[0] &   ICON_ONLY) activeContext |= F_CONTEXT_ICON;
	  if (windowIDs[0] & WINDOW_ONLY) activeContext |= F_CONTEXT_WINDOW;
      
	  pNext = tPtr->next;
	  tPtr->next = NULL;
	  ModifyClientCommandTree (ACTIVE_PSD, NULL, ALL, tPtr,
				   DISABLE, activeContext, NULL);
	  tPtr->next = pNext;

	  PRINT("Disabled commandID %d on all windows.\n", commandID);
	}
      else
	PRINT("ERROR - commandID %d not found in command tree.\n", commandID);
    }

  /*
   * Disable on specified clients
   */
  else
    {
      tPtr = FindCmd (commandID, CCI_TREE(w));
      if (tPtr != NULL)
	{
	  for (i=0; i<count; i++)
	    {
	      ClientData *pCD;

	      activeContext = 0L;
	      if (windowIDs[i] &   ICON_ONLY)
		activeContext |= F_CONTEXT_ICON;
	      if (windowIDs[i] & WINDOW_ONLY)
		activeContext |= F_CONTEXT_WINDOW;
	      
	      pCD = GetPCD(ScrNum(w), windowIDs[i] & WINDOW_MASK);
	      if (pCD != NULL)
	      {
		  pNext = tPtr->next;
		  tPtr->next = NULL;
		  ModifyClientCommandTree (pCD->pSD, pCD, SINGLE, tPtr,
					   DISABLE, activeContext, NULL);
		  tPtr->next = pNext;
	      }
	    }
	}
      else
	PRINT("ERROR - commandID %d not found in command tree.\n", commandID);
    }

  if (count > 0)
    XtFree((char*)windowIDs);
}



/*----------------------------------------------------------------------*
 |                             RenameCommand                            |
 *----------------------------------------------------------------------*/
/*ARGSUSED*/
void
RenameCommand (
     Widget         w,
     Atom           target,
     MessageData    data,
     unsigned long  len,
     int            fmt)
{
  CARD32         commandID, count;
  Window        *windowIDs;
  CmdTree       *tPtr, *pNext;
  int            i, win;
  unsigned long  activeContext = 0L;
  String	 newname;

  /*
   * check data to make sure somethings there.
   */
  if ((data == NULL) || (len == 0))
    {
      PRINT("Bad data passed to RenameCommand.\n");
      return;
    }

  commandID = UnpackCARD32(&data);
  newname   = UnpackString(&data);
  count     = UnpackCARD32(&data);

  if (count > 0) windowIDs = (Window *) XtMalloc(sizeof(Window)*count);
  for (win=0; win<count; win++)
    {
      windowIDs[win] = UnpackCARD32(&data);
      PRINT("Got window ID %d.\n", windowIDs[win]);
    }

  /*
   *  Rename on root menu
   */
  if ((windowIDs[0] & WINDOW_MASK) == 0L)
    {
      tPtr = FindCmd (commandID, CCI_TREE(w));
      if (tPtr != NULL)
	{
	  for (i=0; i<count; i++)
	  {
	      activeContext = F_CONTEXT_ROOT;
	      pNext = tPtr->next;
	      tPtr->next = NULL;
	      ModifyClientCommandTree (ACTIVE_PSD, NULL, ROOT, tPtr,
				       RENAME, activeContext, newname);
	      tPtr->next = pNext;
	  }
	}
      else
	PRINT("ERROR - commandID %d not found in command tree.\n", commandID);
    }

  /*
   * Rename on all clients
   */
  else if ((windowIDs[0] & WINDOW_MASK) == ALL_WINDOWS)
    {
      tPtr = FindCmd (commandID, CCI_TREE(w));
      if (tPtr != NULL)
	{
	  activeContext = 0L;
	  if (windowIDs[0] &   ICON_ONLY) activeContext |= F_CONTEXT_ICON;
	  if (windowIDs[0] & WINDOW_ONLY) activeContext |= F_CONTEXT_WINDOW;
      
	  pNext = tPtr->next;
	  tPtr->next = NULL;
	  ModifyClientCommandTree (ACTIVE_PSD, NULL, ALL, tPtr,
				   RENAME, activeContext, newname);
	  tPtr->next = pNext;

	  PRINT("Renamed commandID %d on all windows.\n", commandID);
	}
      else
	PRINT("ERROR - commandID %d not found in command tree.\n", commandID);
    }

  /*
   * Rename on specified clients
   */
  else
    {
      tPtr = FindCmd (commandID, CCI_TREE(w));
      if (tPtr != NULL)
	{
	  for (i=0; i<count; i++)
	    {
	      ClientData *pCD;

	      activeContext = 0L;
	      if (windowIDs[i] &   ICON_ONLY)
		activeContext |= F_CONTEXT_ICON;
	      if (windowIDs[i] & WINDOW_ONLY)
		activeContext |= F_CONTEXT_WINDOW;
	      
	      pCD = GetPCD(ScrNum(w), windowIDs[i] & WINDOW_MASK);
	      if (pCD != NULL)
	      {
		  pNext = tPtr->next;
		  tPtr->next = NULL;
		  ModifyClientCommandTree (pCD->pSD, pCD, SINGLE, tPtr,
					   RENAME, activeContext, newname);
		  tPtr->next = pNext;
	      }
	    }
	}
      else
	PRINT("ERROR - commandID %d not found in command tree.\n", commandID);
    }

  if (count > 0)
    XtFree((char*)windowIDs);
}



/*----------------------------------------------------------------------*
 |                             RemoveCommand                            |
 *----------------------------------------------------------------------*/
/*ARGSUSED*/
void
RemoveCommand (
     Widget         w,
     Atom           target,
     MessageData    data,
     unsigned long  len,
     int            fmt)
{
  CARD32         commandID, count;
  Window        *windowIDs;
  CmdTree       *tPtr, *pNext;
  int            i, win;
  unsigned long  activeContext = 0L;

  /*
   * check data to make sure somethings there.
   */
  if ((data == NULL) || (len == 0))
    {
      PRINT("Bad data passed to RemoveCommand.\n");
      return;
    }

  commandID = UnpackCARD32(&data);
  count     = UnpackCARD32(&data);

  if (count > 0) windowIDs = (Window *) XtMalloc(sizeof(Window)*count);
  for (win=0; win<count; win++)
    {
      windowIDs[win] = UnpackCARD32(&data);
      PRINT("Got window ID %d.\n", windowIDs[win]);
    }

  /*
   *  Remove on root menu
   */
  if ((windowIDs[0] & WINDOW_MASK) == 0L)
    {
      tPtr = FindCmd (commandID, CCI_TREE(w));
      if (tPtr != NULL)
	{
	  for (i=0; i<count; i++)
	  {
	      activeContext = F_CONTEXT_ROOT;
	      pNext = tPtr->next;
	      tPtr->next = NULL;
	      ModifyClientCommandTree (ACTIVE_PSD, NULL, ROOT, tPtr,
				       REMOVE, activeContext, NULL);
	      tPtr->next = pNext;
	  }
	}
      else
	PRINT("ERROR - commandID %d not found in command tree.\n", commandID);
    }

  /*
   * Remove on all clients
   */
  else if ((windowIDs[0] & WINDOW_MASK) == ALL_WINDOWS)
    {
      tPtr = FindCmd (commandID, CCI_TREE(w));
      if (tPtr != NULL)
	{
	  activeContext = 0L;
	  if (windowIDs[0] &   ICON_ONLY) activeContext |= F_CONTEXT_ICON;
	  if (windowIDs[0] & WINDOW_ONLY) activeContext |= F_CONTEXT_WINDOW;
      
	  pNext = tPtr->next;
	  tPtr->next = NULL;
	  ModifyClientCommandTree (ACTIVE_PSD, NULL, ALL, tPtr, REMOVE,
				   activeContext, NULL);
	  tPtr->next = pNext;

	  PRINT("Removed commandID %d on all windows.\n", commandID);
	}
      else
	PRINT("ERROR - commandID %d not found in command tree.\n", commandID);
    }

  /*
   * Remove on specified clients
   */
  else
    {
      tPtr = FindCmd (commandID, CCI_TREE(w));
      if (tPtr != NULL)
	{
	  for (i=0; i<count; i++)
	  {
	      ClientData *pCD;
	      
	      activeContext = 0L;
	      if (windowIDs[i] &   ICON_ONLY)
		activeContext |= F_CONTEXT_ICON;
	      if (windowIDs[i] & WINDOW_ONLY)
		activeContext |= F_CONTEXT_WINDOW;

	      pCD = GetPCD(ScrNum(w), windowIDs[i] & WINDOW_MASK);
	      if (pCD != NULL)
	      {
		  pNext = tPtr->next;
		  tPtr->next = NULL;
		  ModifyClientCommandTree (pCD->pSD, pCD, SINGLE, tPtr,
					   REMOVE, activeContext, NULL);
		  tPtr->next = pNext;
	      }
	    }
	}
      else
	PRINT("ERROR - commandID %d not found in command tree.\n", commandID);
    }

  if (count > 0)
    XtFree((char*)windowIDs);
}



/*---------------------------------------------------------------------------*
 |                           RemoveMatchingCommands                          |
 | Recursively removes commands that match a given window in the specified   |
 | command tree.                                                             |
 *---------------------------------------------------------------------------*/
/*ARGSUSED*/
void
RemoveMatchingCommands (
     int    scr,
     Window clientWindow,
     CmdTree *tree)
{
  if (tree == NULL)
    return;

  if (tree->subTrees != NULL)
    RemoveMatchingCommands(scr, clientWindow, tree->subTrees);

  if (tree->notifyWindow == clientWindow)
    {
      cmdKillList[ cmdKillListIndex++ ] = tree->commandID;
    }

  if (tree->next != NULL)
    RemoveMatchingCommands(scr, clientWindow, tree->next);
}



/*---------------------------------------------------------------------------*
 |                           RemoveCommandsForClient                         |
 | This function will remove any command that was inserted by this client.   |
 *---------------------------------------------------------------------------*/
void
RemoveCommandsForClient (
     int    scr,
     Window clientWindow)
{
  int i;

  ShowWaitState (TRUE);

  cmdKillListIndex = 0;
  RemoveMatchingCommands(scr, clientWindow, CCI_TREE_OF_SCR(scr));

  /*
   * Remove any matching commands on the root menu.
   */
  for (i = 0;  i < cmdKillListIndex;  i++)
    {
      CmdTree *tPtr, *pNext;
      MenuSpec *pMS;
      WmScreenData *pSD = ACTIVE_PSD;

      while (tPtr = FindCmd (cmdKillList[ i ], CCI_TREE_OF_SCR(scr)))
	{
	  /* make sure ModifyClientCommandTree can't muck with cmdTree. */
	  pNext = tPtr->next;
	  tPtr->next = NULL;

	  ModifyClientCommandTree (pSD, NULL, ALL, tPtr,
				   REMOVE, F_CONTEXT_ALL, NULL);
	  /* restore tree. */
	  tPtr->next = pNext;

	  /*
	   * if this command caused a menu spec to be created, remove it.
	   */
	  DestroyMenuSpec(pSD, cmdKillList[i]);

	  /*
	   * Now delete the matching entry in the command tree.
	   */
	  DeleteCommand(cmdKillList[ i ], &CCI_TREE_OF_SCR(scr));
	}
    }

  ShowWaitState (FALSE);
}


/*---------------------------------------------------------------------------*
 |                            InvokeMessageReply                             |
 *---------------------------------------------------------------------------*/
/*ARGSUSED*/
void
InvokeMessageReply (Widget w, XtPointer clientData, XtPointer callData)
{
  PRINT("Invoke message reply received.\n");
}



/*---------------------------------------------------------------------------*
 |                            SendInvokeMessage                              |
 | Send a convert request to the client that owns the menu command.          |
 *---------------------------------------------------------------------------*/
void
SendInvokeMessage (
     CARD32 commandID,
     CARD32 clientWindow,
     Atom   selection,
     Time   time)
{
  MessageData  msg, fulldata;
  unsigned long size;

  size = (unsigned long)(sizeof(CARD32) + sizeof(CARD32));
  msg = fulldata = (MessageData)XtMalloc(sizeof(CARD8) * size);
  msg = PackCARD32(msg, commandID);
  msg = PackCARD32(msg, clientWindow);

  UTMSendMessage(ACTIVE_PSD->utmShell,
		 selection,
		 wmGD._MOTIF_WM_INVOKE_COMMAND,
		 (XtPointer)fulldata, size, WSM_PROTO_FMT,
		 InvokeMessageReply, NULL, /* no client data */
		 time);
}

/*----------------------------------------------------------------------*
 |                             CopyMwmGadget
 *----------------------------------------------------------------------*/

static void
CopyMwmGadget(GadgetRectangle *mwm_gadget, GadgetRectangle *auto_gadget)
{
	auto_gadget->id = mwm_gadget->id;
	auto_gadget->rect.x = mwm_gadget->rect.x;
	auto_gadget->rect.y = mwm_gadget->rect.y;
	auto_gadget->rect.width = mwm_gadget->rect.width;
	auto_gadget->rect.height = mwm_gadget->rect.height;
}


/*----------------------------------------------------------------------*
 |                             FillInvalidInfo
 *----------------------------------------------------------------------*/

static void
FillInvalidInfo(GadgetRectangle *auto_gadget)
{
	auto_gadget->id = INVALID;
	auto_gadget->rect.x = auto_gadget->rect.y = auto_gadget->rect.width =
	auto_gadget->rect.height = INVALID;
}


/*----------------------------------------------------------------------*
 |                             GetMinimizeInfo
 *----------------------------------------------------------------------*/

static void
GetMinimizeInfo(ClientData *pcd, XtPointer reply)
{
  /*
   * This function packs data about the minimize button in the following
   * order : 1. gadget count 2. id  3. x position 4. y position 5. width
   *         6. height
   */


  GadgetRectangle minimize_button;
  CARD32 filledCount;
  int i;
  Window frameWin;
  Boolean minFound = False;

      




   filledCount = pcd->cTitleGadgets;
   frameWin = pcd->clientFrameWin;
      
	
   for (i=0; i < filledCount; i++)
 	if (pcd->pTitleGadgets[i].id == FRAME_MINIMIZE)
	   {
	        CopyMwmGadget (&(pcd->pTitleGadgets[i]), &minimize_button); 
		minFound = True;
	   }

   if (minFound == False)
	FillInvalidInfo (&minimize_button);
	
		

      reply = PackCARD32 (reply, (CARD32)filledCount);
      reply = PackCARD32(reply, (CARD32)minimize_button.id);
      reply = PackCARD32 (reply, (CARD32)minimize_button.rect.x);
      reply = PackCARD32 (reply, (CARD32)minimize_button.rect.y);
      reply = PackCARD32 (reply, (CARD32)minimize_button.rect.width);
      reply = PackCARD32 (reply, (CARD32)minimize_button.rect.height); 
      reply = PackCARD32 (reply, (CARD32)frameWin);

}

/*----------------------------------------------------------------------*
 |                             GetMaximizeInfo
 *----------------------------------------------------------------------*/

static void
GetMaximizeInfo(ClientData *pcd, XtPointer reply)
{

  /*
   * This function packs data about the maximize button in the following
   * order : 1. gadget count 2. id  3. x position 4. y position 5. width
   *         6. height 7. event window
   */

      int i;
      GadgetRectangle maximize_button;
      CARD32 filledCount;
      Window frameWin;
      Boolean maxFound = False;


      filledCount = pcd->cTitleGadgets;
      frameWin = pcd->clientFrameWin;


      for (i=0; i < filledCount; i++)
	{
     
        if (pcd->pTitleGadgets[i].id == FRAME_MAXIMIZE)
	  {
	    CopyMwmGadget (&(pcd->pTitleGadgets[i]),&maximize_button);
	    maxFound = True;
          }

      	}
      
      if (maxFound == False)
	FillInvalidInfo (&maximize_button);



	reply = PackCARD32 (reply, (CARD32)filledCount);
	reply = PackCARD32 (reply, (CARD32)maximize_button.id);
	reply = PackCARD32 (reply, (CARD32)maximize_button.rect.x);
	reply = PackCARD32 (reply, (CARD32)maximize_button.rect.y);
	reply = PackCARD32 (reply, (CARD32)maximize_button.rect.width);
	reply = PackCARD32 (reply, (CARD32)maximize_button.rect.height);
	reply = PackCARD32 (reply, (CARD32)frameWin);
}


/*----------------------------------------------------------------------*
 |                             GetIconInfo
 *----------------------------------------------------------------------*/

static void
GetIconInfo(ClientData *pcd, XtPointer reply, Boolean use_icon_box)
{

   IconBoxData *icon_box;
   XmScrollBarWidget  hScrollBar, vScrollBar;
   Widget frameWidget, scrollWidget, shellWidget;

   

   CARD32 iconX, iconY, iconWidth, iconHeight ;
   CARD32 hMin, hMax, hSliderAreaWidth, hSliderX, hSliderAreaX,
          vMin, vMax, vSliderAreaHeight, vSliderY, vSliderAreaY;
   CARD32 rightArrowX, rightArrowY, leftArrowX, leftArrowY, 
          topArrowX, topArrowY, bottomArrowX, bottomArrowY;
   CARD32 iconBoxX, iconBoxY, iconBoxWidth, iconBoxHeight;
   Window frameWin, scrollWin, hScrollWin, vScrollWin, iconShellWin, iconFrameWin;
   CARD32 lastRow, lastCol;
   CARD32 iPlaceW, iPlaceH;
   CARD32 useIconBox;
   
   
   icon_box = pcd->pIconBox;
   useIconBox = pcd->pSD->useIconBox;
   



       /*
	* IconBox info
	*/
       if (use_icon_box == True)
	 {
	   hScrollBar =  (XmScrollBarWidget)icon_box->hScrollBar;

	   hMin = hScrollBar->scrollBar.minimum;
	   hMax = hScrollBar->scrollBar.maximum;
	   hSliderAreaWidth = hScrollBar->scrollBar.slider_area_width;
	   hSliderX = hScrollBar->scrollBar.slider_x;
	   hSliderAreaX = hScrollBar->scrollBar.slider_area_x;
	   leftArrowX = hScrollBar->core.x + 
	                  hScrollBar->scrollBar.arrow1_x +
	                  (hScrollBar->scrollBar.arrow_width/2);
	   leftArrowY = hScrollBar->core.y + 
	                  hScrollBar->scrollBar.arrow1_y +
	                  (hScrollBar->scrollBar.arrow_height/2);

	   rightArrowX = hScrollBar->core.x + hScrollBar->scrollBar.arrow2_x
	                  + (hScrollBar->scrollBar.arrow_width/2);
	   rightArrowY = hScrollBar->core.y + hScrollBar->scrollBar.arrow2_y
	                  + (hScrollBar->scrollBar.arrow_height/2);

	   vScrollBar =  (XmScrollBarWidget)icon_box->vScrollBar;

	   vMin = vScrollBar->scrollBar.minimum;
	   vMax = vScrollBar->scrollBar.maximum;
	   vSliderAreaHeight = vScrollBar->scrollBar.slider_area_height;
	   vSliderY = vScrollBar->scrollBar.slider_y;
	   vSliderAreaY = vScrollBar->scrollBar.slider_area_y;

	   topArrowX = vScrollBar->core.x + vScrollBar->scrollBar.arrow1_x
	                  + (vScrollBar->scrollBar.arrow_width/2);
	   topArrowY = vScrollBar->core.y + vScrollBar->scrollBar.arrow1_y
	                  + (vScrollBar->scrollBar.arrow_height/2);

	   bottomArrowX = vScrollBar->core.x + vScrollBar->scrollBar.arrow2_x
	                  + (vScrollBar->scrollBar.arrow_width/2);
	   bottomArrowY = hScrollBar->core.y + hScrollBar->scrollBar.arrow2_y
	                  + (hScrollBar->scrollBar.arrow_height/2);


	   

	   shellWidget = icon_box->shellWidget;


	   iconBoxX = shellWidget->core.x;
	   iconBoxY = shellWidget->core.y;
	   iconBoxWidth = shellWidget->core.width;
	   iconBoxHeight = shellWidget->core.height;
	   iconShellWin = XtWindow (shellWidget);


	   frameWidget = icon_box->frameWidget;
	   frameWin = XtWindow (frameWidget);

	   scrollWidget = icon_box->scrolledWidget;
	   scrollWin = XtWindow (scrollWidget);
	   
	   hScrollWin = XtWindow (hScrollBar);
	   vScrollWin = XtWindow (vScrollBar);
	   
	   lastCol = icon_box->lastCol;
	   lastRow = icon_box->lastRow;
	   iPlaceW = icon_box->IPD.iPlaceW;
	   iPlaceH = icon_box->IPD.iPlaceH;
	}


       /*
	* icon info
	*/

       iconX = pcd->iconX;
       iconY = pcd->iconY;
       iconWidth = pcd->pSD->iconWidth;


       iconHeight = pcd->pSD->iconHeight;
       iconFrameWin = pcd->iconFrameWin;



       reply = PackCARD32 (reply,(CARD32)useIconBox);
       reply = PackCARD32 (reply,(CARD32)iconX);
       reply = PackCARD32 (reply,(CARD32)iconY);
       reply = PackCARD32 (reply,(CARD32)iconWidth);
       reply = PackCARD32 (reply,(CARD32)iconHeight);
       reply = PackCARD32 (reply,(CARD32)iconFrameWin);

       if (use_icon_box == True)
	 {
	   reply = PackCARD32 (reply,(CARD32)hMin);
	   reply = PackCARD32 (reply,(CARD32)hMax);
	   reply = PackCARD32 (reply,(CARD32)hSliderAreaWidth);
	   reply = PackCARD32 (reply,(CARD32)hSliderX);
	   reply = PackCARD32 (reply,(CARD32)hSliderAreaX);
	   reply = PackCARD32 (reply,(CARD32)vMin);
	   reply = PackCARD32 (reply,(CARD32)vMax);
	   reply = PackCARD32 (reply,(CARD32)vSliderAreaHeight);
	   reply = PackCARD32 (reply,(CARD32)vSliderY);
	   reply = PackCARD32 (reply,(CARD32)vSliderAreaY);
	   reply = PackCARD32 (reply,(CARD32)rightArrowX);
	   reply = PackCARD32 (reply,(CARD32)rightArrowY);
	   reply = PackCARD32 (reply,(CARD32)leftArrowX);
	   reply = PackCARD32 (reply,(CARD32)leftArrowY);
	   reply = PackCARD32 (reply,(CARD32)topArrowX);
	   reply = PackCARD32 (reply,(CARD32)topArrowY);
	   reply = PackCARD32 (reply,(CARD32)bottomArrowX);
	   reply = PackCARD32 (reply,(CARD32)bottomArrowY);
	   reply = PackCARD32 (reply,(CARD32)iconBoxX);
	   reply = PackCARD32 (reply,(CARD32)iconBoxY);
	   reply = PackCARD32 (reply,(CARD32)iconBoxWidth);
	   reply = PackCARD32 (reply,(CARD32)iconBoxHeight);
	   reply = PackCARD32 (reply,(CARD32)iconShellWin);
	   reply = PackCARD32 (reply,(CARD32)frameWin);
	   reply = PackCARD32 (reply,(CARD32)scrollWin);
	   reply = PackCARD32 (reply,(CARD32)hScrollWin);
	   reply = PackCARD32 (reply,(CARD32)vScrollWin);
	   reply = PackCARD32 (reply,(CARD32)lastCol);
	   reply = PackCARD32 (reply,(CARD32)lastRow);
	   reply = PackCARD32 (reply,(CARD32)iPlaceH);
	   reply = PackCARD32 (reply,(CARD32)iPlaceW);
	   
	}

}

/*----------------------------------------------------------------------*
 |                             GetMoveInfo
 *----------------------------------------------------------------------*/

static void
GetMoveInfo(ClientData *pcd, XtPointer reply)

{
      int i;
      GadgetRectangle title;
      GadgetRectangle menu;
      CARD32 filledCount;
      CARD32 upperBorderWidth, lowerBorderWidth;
      CARD32 windowX, windowY;
      Window frameWin;

      Boolean titleFound = False;
      Boolean system_found = False;


      filledCount = pcd->cTitleGadgets;
      upperBorderWidth = pcd->frameInfo.upperBorderWidth;
      lowerBorderWidth = pcd->frameInfo.lowerBorderWidth;
      windowX = pcd->clientX;
      windowY = pcd->clientY;
      frameWin = pcd->clientFrameWin;

      for (i=0; i < filledCount; i++)
	{
	  if (pcd->pTitleGadgets[i].id == FRAME_TITLE)
	    {
		CopyMwmGadget (&(pcd->pTitleGadgets[i]), &title);
		titleFound = True;
	    }

	  if (pcd->pTitleGadgets[i].id == FRAME_SYSTEM)
	    {
	      CopyMwmGadget (&(pcd->pTitleGadgets[i]), &menu);
	      system_found = True;
	    }

        }

        if (titleFound == False)
	 FillInvalidInfo (&title);

        if (system_found == False)
	 FillInvalidInfo (&menu);
			  

	 reply = PackCARD32 (reply, (CARD32)filledCount);
	 reply = PackCARD32 (reply, (CARD32)title.id);
	 reply = PackCARD32 (reply, (CARD32)title.rect.x);
	 reply = PackCARD32 (reply, (CARD32)title.rect.y);
	 reply = PackCARD32 (reply, (CARD32)title.rect.width);
	 reply = PackCARD32 (reply, (CARD32)title.rect.height);
       	 reply = PackCARD32 (reply, (CARD32)menu.id);
	 reply = PackCARD32 (reply, (CARD32)menu.rect.x);
	 reply = PackCARD32 (reply, (CARD32)menu.rect.y);
	 reply = PackCARD32 (reply, (CARD32)menu.rect.width);
	 reply = PackCARD32 (reply, (CARD32)menu.rect.height);
	 reply = PackCARD32 (reply, (CARD32)upperBorderWidth);
	 reply = PackCARD32 (reply, (CARD32)lowerBorderWidth);
	 reply = PackCARD32 (reply, (CARD32)windowX);
	 reply = PackCARD32 (reply, (CARD32)windowY);
	 reply = PackCARD32 (reply, (CARD32)frameWin);

    }




/*----------------------------------------------------------------------*
 |                             GetResizeInfo
 *----------------------------------------------------------------------*/

static void
GetResizeInfo(ClientData *pcd, XtPointer reply, int dir)
{
      int i;
      GadgetRectangle east_resize, west_resize, gravity_resize, title;
      CARD32  upperBorderWidth, lowerBorderWidth;
      Window frameWin;
      int filledCount;
      Boolean titleFound = False;


      filledCount = pcd->cTitleGadgets;

      if (!(pcd->decor & MWM_DECOR_RESIZEH))
      	FillInvalidInfo (&gravity_resize);
      else
	{
		CopyMwmGadget (&pcd->pResizeGadgets[dir], &gravity_resize);
		CopyMwmGadget (&pcd->pResizeGadgets[WM_WEST], &west_resize);
		CopyMwmGadget (&pcd->pResizeGadgets[WM_EAST], &east_resize);
	}


       for (i=0; i < filledCount; i++)
	if (pcd->pTitleGadgets[i].id == FRAME_TITLE)
	   {
	      CopyMwmGadget (&(pcd->pTitleGadgets[i]), &title);
              titleFound = True;
	   }

	if (titleFound == False)
	   FillInvalidInfo (&title);
		


	    

        upperBorderWidth = pcd->frameInfo.upperBorderWidth;
        lowerBorderWidth = pcd->frameInfo.lowerBorderWidth;
	frameWin = pcd->clientFrameWin;

		


	 reply = PackCARD32 (reply, (CARD32)east_resize.id);
	 reply = PackCARD32 (reply, (CARD32)east_resize.rect.width);
	 reply = PackCARD32 (reply, (CARD32)west_resize.id);
	 reply = PackCARD32 (reply, (CARD32)west_resize.rect.width);
	 reply = PackCARD32 (reply, (CARD32)gravity_resize.id);
	 reply = PackCARD32 (reply, (CARD32)gravity_resize.rect.x);
	 reply = PackCARD32 (reply, (CARD32)gravity_resize.rect.y);
	 reply = PackCARD32 (reply, (CARD32)gravity_resize.rect.width);
	 reply = PackCARD32 (reply, (CARD32)gravity_resize.rect.height);
	 reply = PackCARD32 (reply, (CARD32)title.id);
	 reply = PackCARD32 (reply, (CARD32)title.rect.x);
	 reply = PackCARD32 (reply, (CARD32)title.rect.y);
	 reply = PackCARD32 (reply, (CARD32)title.rect.width);
	 reply = PackCARD32 (reply, (CARD32)title.rect.height);
	 reply = PackCARD32 (reply, (CARD32)upperBorderWidth);
	 reply = PackCARD32 (reply, (CARD32)lowerBorderWidth);
	 reply = PackCARD32 (reply, (CARD32)frameWin);
}


/*----------------------------------------------------------------------*
 |                             GetWindowMenuUnpostInfo
 *----------------------------------------------------------------------*/

static void
GetWindowMenuUnpostInfo(ClientData *pcd, XtPointer reply)
{

    MenuSpec *menuSpec;

    CARD32 clientState;
    CARD32 menuWin;
    CARD32 frameWin;

    menuSpec = pcd->systemMenuSpec;
    

    clientState = pcd->clientState;
    menuWin = XtWindow (menuSpec->menuWidget);
    frameWin = pcd->clientFrameWin;

    reply = PackCARD32 (reply,clientState);
    reply = PackCARD32 (reply,menuWin);
    reply = PackCARD32 (reply,frameWin);
    
}

/*----------------------------------------------------------------------*
 |                             GetFocusInfo
 *----------------------------------------------------------------------*/

static void
GetFocusInfo(ClientData *pcd, XtPointer reply)
{


  GadgetRectangle title;
  CARD32 filledCount;
  int i;
  Window frameWin;
  Boolean titleFound = False;

      

      filledCount = pcd->cTitleGadgets;
      frameWin = pcd->clientFrameWin;

      for (i=0; i < filledCount; i++)
        {
          if (pcd->pTitleGadgets[i].id == FRAME_TITLE)
            {
	      CopyMwmGadget (&(pcd->pTitleGadgets[i]), &title);
              titleFound = True;

            }
	}


   if (titleFound == False)
	FillInvalidInfo (&title);
	
		

      reply = PackCARD32 (reply, (CARD32)filledCount);
      reply = PackCARD32(reply, (CARD32)title.id);
      reply = PackCARD32 (reply, (CARD32)title.rect.x);
      reply = PackCARD32 (reply, (CARD32)title.rect.y);
      reply = PackCARD32 (reply, (CARD32)title.rect.width);
      reply = PackCARD32 (reply, (CARD32)title.rect.height);
      reply = PackCARD32 (reply, (CARD32)frameWin);

}

/*----------------------------------------------------------------------*
 |                             GetWindowMenuPostInfo
 *----------------------------------------------------------------------*/

static void
GetWindowMenuPostInfo(ClientData *pcd, XtPointer reply)
{
      int i;
      GadgetRectangle title;
      GadgetRectangle menu;
      CARD32 filledCount;
      Window frameWin;


      Boolean titleFound = False;
      Boolean systemFound = False;


      filledCount = pcd->cTitleGadgets;
      frameWin = pcd->clientFrameWin;

      for (i=0; i < filledCount; i++)
        {
          if (pcd->pTitleGadgets[i].id == FRAME_TITLE)
            {
	      CopyMwmGadget (&(pcd->pTitleGadgets[i]), &title);
              titleFound = True;

            }

          if (pcd->pTitleGadgets[i].id == FRAME_SYSTEM)
            {
	      CopyMwmGadget (&(pcd->pTitleGadgets[i]), &menu);
              systemFound = True;
            }

        }


        if (titleFound == False)
		FillInvalidInfo (&title);

        if (systemFound == False)
          	FillInvalidInfo (&menu);


        reply = PackCARD32 (reply, (CARD32)filledCount);
	reply = PackCARD32 (reply, (CARD32)title.id);
        reply = PackCARD32 (reply, (CARD32)title.rect.x);
        reply = PackCARD32 (reply, (CARD32)title.rect.y);
        reply = PackCARD32 (reply, (CARD32)title.rect.width);
        reply = PackCARD32 (reply, (CARD32)title.rect.height);
	reply = PackCARD32 (reply, (CARD32)menu.id);
        reply = PackCARD32 (reply, (CARD32)menu.rect.x);
        reply = PackCARD32 (reply, (CARD32)menu.rect.y);
        reply = PackCARD32 (reply, (CARD32)menu.rect.width);
        reply = PackCARD32 (reply, (CARD32)menu.rect.height);
        reply = PackCARD32 (reply, (CARD32)frameWin);
}


/*----------------------------------------------------------------------*
 |                             GetIconMenuItemSelectInfo
 *----------------------------------------------------------------------*/

static void
GetIconMenuItemSelectInfo(ClientData *pcd, XtPointer reply, Boolean use_icon_box)
{
  MenuSpec *menuSpec;
  int menuItemCount,sensitiveCount;
  Window menuWin, frameWin;
  int sensitive[MAX_MENU_ITEMS];
  int itemY[MAX_MENU_ITEMS];
  char itemName[MAX_MENU_ITEMS][25];


   IconBoxData *icon_box;
   XmScrollBarWidget  hScrollBar, vScrollBar;
   Widget frameWidget, scrollWidget, shellWidget;
  
  MenuButton              *NewMenuButton;
  MenuItem                *NewMenuItem;
  int n;
  CARD32 iconX, iconY, iconWidth, iconHeight;
  CARD32 hMin, hMax, hSliderAreaWidth, hSliderX, hSliderAreaX,
          vMin, vMax, vSliderAreaHeight, vSliderY, vSliderAreaY;
  CARD32 rightArrowX, rightArrowY, leftArrowX, leftArrowY, 
          topArrowX, topArrowY, bottomArrowX, bottomArrowY;
  CARD32 iconBoxX, iconBoxY, iconBoxWidth, iconBoxHeight;
  Window scrollWin, hScrollWin, vScrollWin, iconShellWin, iconFrameWin;
  CARD32 lastRow, lastCol;
  CARD32 iPlaceW, iPlaceH;
  CARD32 clientState;
  CARD32 useIconBox;



  useIconBox = pcd->pSD->useIconBox;

  icon_box = pcd->pIconBox;

  menuSpec = pcd->systemMenuSpec;

  if (menuSpec == NULL)
    return;

  menuItemCount = menuSpec->menuButtonCount;

  for (n = 0; n < menuItemCount && n < MAX_MENU_ITEMS; n++)
    {
      itemName[n][0] = '\0';
      sensitive[n] = FALSE;
    }

  menuWin = XtWindow (menuSpec->menuWidget);
  frameWin = pcd->clientFrameWin;
  clientState = pcd->clientState;

      sensitiveCount = 0;

      for (n = 0, NewMenuButton = menuSpec->menuButtons;
	   n < menuSpec->menuButtonCount;
	   n++, NewMenuButton++)
	{
	  if (NewMenuButton->managed == FALSE)
            continue;

	  NewMenuItem = NewMenuButton->menuItem;
	  sensitive[n] = NewMenuButton->buttonWidget->core.sensitive;
	  itemY[n] = NewMenuButton->buttonWidget->core.y +
                            (NewMenuButton->buttonWidget->core.height / 2);
	  strcpy(itemName[n], NewMenuItem->label);

	  if (sensitive[n] == TRUE)
            sensitiveCount++;
	}


  


       if (use_icon_box == True)
	 {
	   hScrollBar =  (XmScrollBarWidget)icon_box->hScrollBar;
	   hMin = hScrollBar->scrollBar.minimum;
	   hMax = hScrollBar->scrollBar.maximum;
	   hSliderAreaWidth = hScrollBar->scrollBar.slider_area_width;
	   hSliderX = hScrollBar->scrollBar.slider_x;
	   hSliderAreaX = hScrollBar->scrollBar.slider_area_x;
	   leftArrowX = hScrollBar->core.x + 
	                  hScrollBar->scrollBar.arrow1_x +
	                  (hScrollBar->scrollBar.arrow_width/2);
	   leftArrowY = hScrollBar->core.y + 
	                  hScrollBar->scrollBar.arrow1_y +
	                  (hScrollBar->scrollBar.arrow_height/2);

	   rightArrowX = hScrollBar->core.x + hScrollBar->scrollBar.arrow2_x
	                  + (hScrollBar->scrollBar.arrow_width/2);
	   rightArrowY = hScrollBar->core.y + hScrollBar->scrollBar.arrow2_y
	                  + (hScrollBar->scrollBar.arrow_height/2);

	   vScrollBar =  (XmScrollBarWidget)icon_box->vScrollBar;

	   vMin = vScrollBar->scrollBar.minimum;
	   vMax = vScrollBar->scrollBar.maximum;
	   vSliderAreaHeight = vScrollBar->scrollBar.slider_area_height;
	   vSliderY = vScrollBar->scrollBar.slider_y;
	   vSliderAreaY = vScrollBar->scrollBar.slider_area_y;

	   topArrowX = vScrollBar->core.x + vScrollBar->scrollBar.arrow1_x
	                  + (vScrollBar->scrollBar.arrow_width/2);
	   topArrowY = vScrollBar->core.y + vScrollBar->scrollBar.arrow1_y
	                  + (vScrollBar->scrollBar.arrow_height/2);

	   bottomArrowX = vScrollBar->core.x + vScrollBar->scrollBar.arrow2_x
	                  + (vScrollBar->scrollBar.arrow_width/2);
	   bottomArrowY = hScrollBar->core.y + hScrollBar->scrollBar.arrow2_y
	                  + (hScrollBar->scrollBar.arrow_height/2);


	   

	   shellWidget = icon_box->shellWidget;


	   iconBoxX = shellWidget->core.x;
	   iconBoxY = shellWidget->core.y;
	   iconBoxWidth = shellWidget->core.width;
	   iconBoxHeight = shellWidget->core.height;
	   iconShellWin = XtWindow (shellWidget);


	   frameWidget = icon_box->frameWidget;
	   frameWin = XtWindow (frameWidget);

	   scrollWidget = icon_box->scrolledWidget;
	   scrollWin = XtWindow (scrollWidget);
	   
	   hScrollWin = XtWindow (hScrollBar);
	   vScrollWin = XtWindow (vScrollBar);
	   
	   lastCol = icon_box->lastCol;
	   lastRow = icon_box->lastRow;
	   iPlaceW = icon_box->IPD.iPlaceW;
	   iPlaceH = icon_box->IPD.iPlaceH;
	}


       /*
	* icon info
	*/

       iconX = pcd->iconX;
       iconY = pcd->iconY;
       iconWidth = pcd->pSD->iconWidth;
       iconHeight = pcd->pSD->iconHeight;
       iconFrameWin = pcd->iconFrameWin;



      reply = PackCARD32 (reply, (CARD32)clientState);
      reply = PackCARD32 (reply, (CARD32)menuItemCount);
      reply = PackCARD32 (reply, (CARD32)sensitiveCount);
      reply = PackCARD32 (reply, (CARD32)menuWin);
      reply = PackCARD32 (reply, (CARD32)frameWin);
      for (n=0; n < menuItemCount && n < MAX_MENU_ITEMS; n++)
	{
	  reply = PackCARD32 (reply, (CARD32)sensitive[n]);
	  reply = PackCARD32 (reply, (CARD32)itemY[n]);	
	  reply = PackString (reply, (String)itemName[n]);		
	}

       reply = PackCARD32 (reply,(CARD32)use_icon_box);
       reply = PackCARD32 (reply,(CARD32)iconX);
       reply = PackCARD32 (reply,(CARD32)iconY);
       reply = PackCARD32 (reply,(CARD32)iconWidth);
       reply = PackCARD32 (reply,(CARD32)iconHeight);
       reply = PackCARD32 (reply,(CARD32)iconFrameWin);

       if (use_icon_box == True)
	 {
	   reply = PackCARD32 (reply,(CARD32)hMin);
	   reply = PackCARD32 (reply,(CARD32)hMax);
	   reply = PackCARD32 (reply,(CARD32)hSliderAreaWidth);
	   reply = PackCARD32 (reply,(CARD32)hSliderX);
	   reply = PackCARD32 (reply,(CARD32)hSliderAreaX);
	   reply = PackCARD32 (reply,(CARD32)vMin);
	   reply = PackCARD32 (reply,(CARD32)vMax);
	   reply = PackCARD32 (reply,(CARD32)vSliderAreaHeight);
	   reply = PackCARD32 (reply,(CARD32)vSliderY);
	   reply = PackCARD32 (reply,(CARD32)vSliderAreaY);
	   reply = PackCARD32 (reply,(CARD32)rightArrowX);
	   reply = PackCARD32 (reply,(CARD32)rightArrowY);
	   reply = PackCARD32 (reply,(CARD32)leftArrowX);
	   reply = PackCARD32 (reply,(CARD32)leftArrowY);
	   reply = PackCARD32 (reply,(CARD32)topArrowX);
	   reply = PackCARD32 (reply,(CARD32)topArrowY);
	   reply = PackCARD32 (reply,(CARD32)bottomArrowX);
	   reply = PackCARD32 (reply,(CARD32)bottomArrowY);
	   reply = PackCARD32 (reply,(CARD32)iconBoxX);
	   reply = PackCARD32 (reply,(CARD32)iconBoxY);
	   reply = PackCARD32 (reply,(CARD32)iconBoxWidth);
	   reply = PackCARD32 (reply,(CARD32)iconBoxHeight);
	   reply = PackCARD32 (reply,(CARD32)iconShellWin);
	   reply = PackCARD32 (reply,(CARD32)frameWin);
	   reply = PackCARD32 (reply,(CARD32)scrollWin);
	   reply = PackCARD32 (reply,(CARD32)hScrollWin);
	   reply = PackCARD32 (reply,(CARD32)vScrollWin);
	   reply = PackCARD32 (reply,(CARD32)lastCol);
	   reply = PackCARD32 (reply,(CARD32)lastRow);
	   reply = PackCARD32 (reply,(CARD32)iPlaceH);
	   reply = PackCARD32 (reply,(CARD32)iPlaceW);
	   
	}

}




/*----------------------------------------------------------------------*
 |                             GetItemSelectInfo
 *----------------------------------------------------------------------*/

static void
GetWindowItemSelectInfo(ClientData *pcd, XtPointer reply)
{
  MenuSpec *menuSpec;
  CARD32 menuItemCount,sensitiveCount;
  Window menuWin, frameWin;
  CARD32 sensitive[MAX_MENU_ITEMS];
  CARD32 itemY[MAX_MENU_ITEMS];
  char itemName[MAX_MENU_ITEMS][MAX_NAME_LEN + 1];
  
  MenuButton              *NewMenuButton;
  MenuItem                *NewMenuItem;
  int n;


  menuSpec = pcd->systemMenuSpec;

  if (menuSpec == NULL)
    return;

  menuItemCount = menuSpec->menuButtonCount;

  for (n = 0; n < menuItemCount && n < MAX_MENU_ITEMS; n++)
    {
      itemName[n][0] = '\0';
      sensitive[n] = FALSE;
    }

  menuWin = XtWindow (menuSpec->menuWidget);
  frameWin = pcd->clientFrameWin;

   sensitiveCount = 0;

      for (n = 0, NewMenuButton = menuSpec->menuButtons;
	   n < menuSpec->menuButtonCount;
	   n++, NewMenuButton++)
	{
	  if (NewMenuButton->managed == FALSE)
            continue;

	  NewMenuItem = NewMenuButton->menuItem;
	  sensitive[n] = NewMenuButton->buttonWidget->core.sensitive;
	  itemY[n] = NewMenuButton->buttonWidget->core.y +
                            (NewMenuButton->buttonWidget->core.height / 2);
	  strcpy(itemName[n], NewMenuItem->label);

	  if (sensitive[n] == TRUE)
            sensitiveCount++;
	}

      reply = PackCARD32 (reply, (CARD32)menuItemCount);
      reply = PackCARD32 (reply, (CARD32)sensitiveCount);
      reply = PackCARD32 (reply, (CARD32)menuWin);
      reply = PackCARD32 (reply, (CARD32)frameWin);
      for (n=0; n < menuItemCount && n < MAX_MENU_ITEMS; n++)
	{
	  reply = PackCARD32 (reply, (CARD32)sensitive[n]);
	  reply = PackCARD32 (reply, (CARD32)itemY[n]);	
	  reply = PackString (reply, (String)itemName[n]);		
	}

}


/*----------------------------------------------------------------------*
 |                             GetItemCheckInfo
 *----------------------------------------------------------------------*/

static void
GetItemCheckInfo(ClientData *pcd, XtPointer reply)
{
  MenuSpec *menuSpec;
  int menuItemCount;
  int clientState;
  int titleGadgetCount;
  int titleId, systemId, minimizeId, maximizeId, northwestId;
  int upperBorderWidth, lowerBorderWidth;
  Window menuWin;
  char itemName[MAX_MENU_ITEMS][MAX_NAME_LEN + 1];
  
  MenuButton              *NewMenuButton;
  MenuItem                *NewMenuItem;
  int i,filledCount;
  Boolean titleFound, systemFound, minimizeFound, maximizeFound = False;

  menuSpec = pcd->systemMenuSpec;

  if (menuSpec == NULL)
    return;

  menuItemCount = menuSpec->menuButtonCount;

  for (i = 0; i < menuItemCount && i < MAX_MENU_ITEMS; i++)
      itemName[i][0] = '\0'; 

  menuWin = XtWindow (menuSpec->menuWidget);

      for (i = 0, NewMenuButton = menuSpec->menuButtons;
	   i < menuSpec->menuButtonCount;
	   i++, NewMenuButton++)
	{
	  if (NewMenuButton->managed == FALSE)
            continue;

	  NewMenuItem = NewMenuButton->menuItem;
	  strcpy (itemName[i],NewMenuItem->label);

	}

      filledCount = pcd->cTitleGadgets;

      for (i=0; i < filledCount; i++)
        {
          if (pcd->pTitleGadgets[i].id == FRAME_TITLE)
	      { 
		  titleId = FRAME_TITLE;
		  titleFound = True;
	      }
	  else
          if (pcd->pTitleGadgets[i].id == FRAME_SYSTEM)
	      {
		  systemId = FRAME_SYSTEM;
		  systemFound = True;
	      }

	  else
          if (pcd->pTitleGadgets[i].id == FRAME_MINIMIZE)
	      {
		  minimizeId = FRAME_MINIMIZE;
		  minimizeFound = True;
	      }
	  else
          if (pcd->pTitleGadgets[i].id == FRAME_MAXIMIZE)
	      {
		  maximizeId = FRAME_MAXIMIZE;
		  maximizeFound = True;
	      }


        }

   if (titleFound == False)
       titleId = INVALID;
   if (systemFound == False)
       systemId = INVALID;
   if (minimizeFound == False)
       minimizeId = INVALID;
   if (maximizeFound == False)
       maximizeId = INVALID;

   if (!(pcd->decor & MWM_DECOR_RESIZEH))
       northwestId = INVALID;
   else
       northwestId = pcd->pResizeGadgets[WM_NORTHWEST].id;

  upperBorderWidth = pcd->frameInfo.upperBorderWidth;
  lowerBorderWidth = pcd->frameInfo.lowerBorderWidth;
      	



  clientState = pcd->clientState;

  reply = PackCARD32 (reply, (CARD32)clientState);
  reply = PackCARD32 (reply, (CARD32)menuWin);
  reply = PackCARD32 (reply, (CARD32)menuItemCount);
  for (i=0; i < menuItemCount && i < MAX_MENU_ITEMS; i++)
      reply = PackString (reply, (String)itemName[i]);		
  reply = PackCARD32 (reply, (CARD32)filledCount);
  reply = PackCARD32 (reply, (CARD32)titleId);
  reply = PackCARD32 (reply, (CARD32)systemId);	
  reply = PackCARD32 (reply, (CARD32)minimizeId);	  
  reply = PackCARD32 (reply, (CARD32)maximizeId);	
  reply = PackCARD32 (reply, (CARD32)northwestId);	
  reply = PackCARD32 (reply, (CARD32)upperBorderWidth);	
  reply = PackCARD32 (reply, (CARD32)lowerBorderWidth);	
}


/*----------------------------------------------------------------------*
 |                             GetRaiseInfo
 *----------------------------------------------------------------------*/

static void
GetRaiseInfo(ClientData *pcd, XtPointer reply)
{

  CARD32 state = pcd->clientState;
  reply = PackCARD32 (reply, (CARD32)state);
}


/*----------------------------------------------------------------------*
 |                             GetAutomationData
 *----------------------------------------------------------------------*/
void
GetAutomationData (XtPointer input, Atom *outputType, XtPointer *output, unsigned long *outputLen, int *outputFmt)
{
  ClientData *pcd;
  CARD32 infoWanted;
  
  Window winId;  
  XtPointer reply;
  int size;

  int i, n, menuItemCount;
  MenuItem *menu_item;





  winId        = UnpackCARD32(&input);
  infoWanted    = UnpackCARD32(&input);


  
  /*
   * Get client data associated with window if the widget making the request.
   */

  if ((pcd = GetPCD (0,winId)) == NULL)
    {

      PRINT ("Can't get client data\n");
      return;
    }


  size = 0;

  switch (infoWanted)
      {
	case WINDOW_MINIMIZE_INFO:
	  size += sizeof(CARD32) * 7;
	  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	  GetMinimizeInfo (pcd,*output);
          break;

	case WINDOW_MAXIMIZE_INFO:
	  size += sizeof (CARD32) * 7;
	  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	  GetMaximizeInfo(pcd,*output);
          break;

        case WINDOW_RAISE_INFO:
	  size += sizeof (CARD32);
	  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	  GetRaiseInfo(pcd, *output);
	  break;

        case WINDOW_MOVE_INFO:
	   SetGrabServer();    /* tell mwm not to grab server */
	   size += sizeof (CARD32) * 16;
	    *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	   GetMoveInfo(pcd,*output);
	   break;

	case WINDOW_RESIZE_NORTH_INFO:
	  SetGrabServer();    /* tell mwm not to grab server */
	  size += sizeof (CARD32) * 17;
	  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	  GetResizeInfo(pcd,*output,WM_NORTH);
	  break;

	case WINDOW_RESIZE_SOUTH_INFO:
	  SetGrabServer();    /* tell mwm not to grab server */
	  size += sizeof (CARD32) * 17;
	  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	  GetResizeInfo(pcd,*output,WM_SOUTH);
	  break;

	case WINDOW_RESIZE_EAST_INFO:
	  SetGrabServer();    /* tell mwm not to grab server */
	  size += sizeof (CARD32) * 17;
	  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	  GetResizeInfo(pcd,*output,WM_EAST);
	  break;

	case WINDOW_RESIZE_WEST_INFO:
	  SetGrabServer();    /* tell mwm not to grab server */
	  size += sizeof (CARD32) * 17;
	  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	  GetResizeInfo(pcd,*output,WM_WEST);
	  break;

	case WINDOW_RESIZE_NORTHEAST_INFO:
	  SetGrabServer();    /* tell mwm not to grab server */
	  size += sizeof (CARD32) * 17;
	  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	  GetResizeInfo(pcd,*output,WM_NORTHEAST);
	  break;


	case WINDOW_RESIZE_NORTHWEST_INFO:
	  SetGrabServer();    /* tell mwm not to grab server */
	  size += sizeof (CARD32) * 17;
	  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	  GetResizeInfo(pcd,*output,WM_NORTHWEST);
	  break;


	case WINDOW_RESIZE_SOUTHEAST_INFO:
	  SetGrabServer();    /* tell mwm not to grab server */
	  size += sizeof (CARD32) * 17;
	  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	  GetResizeInfo(pcd,*output,WM_SOUTHEAST);
	  break;


	case WINDOW_RESIZE_SOUTHWEST_INFO:
	  SetGrabServer();    /* tell mwm not to grab server */
	  size += sizeof (CARD32) * 17;
	  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	  GetResizeInfo(pcd,*output,WM_SOUTHWEST);
	  break;


	case WINDOW_MENU_ITEM_SELECT_INFO:
	  if (pcd->systemMenuSpec)
	      menuItemCount = pcd->systemMenuSpec->menuButtonCount;
	  size += sizeof(CARD32) * 4;
	  for (n=0; n < menuItemCount && n < MAX_MENU_ITEMS; n++)
	      {
		  menu_item = pcd->systemMenuSpec->menuButtons->menuItem;
		  size += sizeof (CARD32);    /* sensitive */
		  size += sizeof (CARD32);    /* itemY */
		  size += sizeof (CARD16) + ((strlen(menu_item->label) + 1) * sizeof(CARD8)); /*itemName */
	      }
	 *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	  GetWindowItemSelectInfo(pcd,*output);
	  break;
      
	case WINDOW_DEICONIFY_INFO:
	  if (pcd->pSD->useIconBox == True)
	      {
		  size += sizeof (CARD32) * 37;
		  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
		  GetIconInfo(pcd,*output,True);
	      }
	  else
	      {
		  size += sizeof (CARD32) * 6;
		  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
		  GetIconInfo(pcd,*output,False);
	      }
	  break;


	case WINDOW_MENU_POST_INFO:
	   size += sizeof (CARD32) * 12;
	   *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	   GetWindowMenuPostInfo(pcd,*output);
	   break;

	case WINDOW_FOCUS_INFO:
	   size += sizeof (CARD32) * 7;
	   *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	   GetFocusInfo(pcd,*output);
	   break;


	case WINDOW_MENU_UNPOST_INFO:
	   size += sizeof (CARD32) * 3;
	   *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	   GetWindowMenuUnpostInfo(pcd,*output);
	   break;

	case WINDOW_MENU_ITEM_CHECK_INFO:
	  if (pcd->systemMenuSpec)
	      menuItemCount = pcd->systemMenuSpec->menuButtonCount;
	  size += sizeof(CARD32) * 11;
	  for (n=0; n < menuItemCount && n < MAX_MENU_ITEMS; n++)
	      {
		  menu_item = pcd->systemMenuSpec->menuButtons->menuItem;
		  size += sizeof (CARD16) + (strlen(menu_item->label + 1) * sizeof(CARD8)); /*itemName */
	      }
	 *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	  GetItemCheckInfo(pcd, *output);
	  break;

	case ICON_MOVE_INFO:
	  {
	      SetGrabServer();    /* tell mwm not to grab server */
	      size += sizeof (CARD32) * 6;
	      *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	      GetIconInfo(pcd,*output,False);
	      break;
	  }

	case ICON_MENU_POST_INFO:
	  if (pcd->pSD->useIconBox == True)
	      {
		  size += sizeof (CARD32) * 37;
		  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
		  GetIconInfo(pcd,*output,True);
	      }
	  else
	      {
		  size += sizeof (CARD32) * 6;
		  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
		  GetIconInfo(pcd,*output,False);
	      }
	  break;

	case ICON_MENU_UNPOST_INFO:
	  if (pcd->pSD->useIconBox == True)
	      {
		  size += sizeof (CARD32) * 37;
		  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
		  GetIconInfo(pcd,*output,True);

	      }
	  else
	      {
		  size += sizeof (CARD32) * 6;
		  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
		  GetIconInfo(pcd,*output,False);
	      }
	  break;

	case ICON_MENU_ITEM_SELECT_INFO:
	  if (pcd->systemMenuSpec)
	      menuItemCount = pcd->systemMenuSpec->menuButtonCount;
	  size += sizeof(CARD32) * 11;
	  for (n=0; n < menuItemCount && n < MAX_MENU_ITEMS; n++)
	      {
		  size += sizeof (CARD32);    /* sensitive */
		  size += sizeof (CARD32);    /* itemY */
		  menu_item = pcd->systemMenuSpec->menuButtons->menuItem;
		  size += sizeof (CARD16) + ((strlen(menu_item->label) + 1) * sizeof(CARD8)); /*itemName */
	      }
	  if (pcd->pSD->useIconBox == True)
		  size += sizeof (CARD32) * 37;
	  else
	  	  size += sizeof (CARD32) * 6;
	  *output = (XtPointer)XtMalloc(sizeof(CARD8) * size);
	  GetIconMenuItemSelectInfo (pcd,*output,pcd->pSD->useIconBox);
	  break;


	default:
	  PRINT ("Illegal operation from Automation");
	  break;
      }

	*outputLen = (unsigned long)size;
	*outputFmt = WSM_PROTO_FMT;
	
}

