R6.6 is the Xorg base-lineXORG-MAIN

1 files changed, 3035 insertions, 0 deletions

diff --git a/src/menus.c b/src/menus.c
new file mode 100644
index 0000000..83fe792
--- /dev/null
+++ b/src/menus.c
@@ -0,0 +1,3035 @@
+/*****************************************************************************/
+/*
+
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/**       Copyright 1988 by Evans & Sutherland Computer Corporation,        **/
+/**                          Salt Lake City, Utah                           **/
+/**                        Cambridge, Massachusetts                         **/
+/**                                                                         **/
+/**                           All Rights Reserved                           **/
+/**                                                                         **/
+/**    Permission to use, copy, modify, and distribute this software and    **/
+/**    its documentation  for  any  purpose  and  without  fee is hereby    **/
+/**    granted, provided that the above copyright notice appear  in  all    **/
+/**    copies and that both  that  copyright  notice  and  this  permis-    **/
+/**    sion  notice appear in supporting  documentation,  and  that  the    **/
+/**    name of Evans & Sutherland not be used in advertising    **/
+/**    in publicity pertaining to distribution of the  software  without    **/
+/**    specific, written prior permission.                                  **/
+/**                                                                         **/
+/**    EVANS & SUTHERLAND DISCLAIMs ALL WARRANTIES WITH REGARD    **/
+/**    TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES  OF  MERCHANT-    **/
+/**    ABILITY  AND  FITNESS,  IN  NO  EVENT SHALL EVANS & SUTHERLAND    **/
+/**    BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL  DAM-    **/
+/**    AGES OR  ANY DAMAGES WHATSOEVER  RESULTING FROM LOSS OF USE, DATA    **/
+/**    OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER    **/
+/**    TORTIOUS ACTION, ARISING OUT OF OR IN  CONNECTION  WITH  THE  USE    **/
+/**    OR PERFORMANCE OF THIS SOFTWARE.                                     **/
+/*****************************************************************************/
+
+
+/***********************************************************************
+ *
+ * $Xorg: menus.c,v 1.6 2001/02/09 02:05:36 xorgcvs Exp $
+ *
+ * twm menu code
+ *
+ * 17-Nov-87 Thomas E. LaStrange		File created
+ *
+ ***********************************************************************/
+
+#include <stdio.h>
+#include <X11/Xos.h>
+#include "twm.h"
+#include "gc.h"
+#include "menus.h"
+#include "resize.h"
+#include "events.h"
+#include "util.h"
+#include "parse.h"
+#include "gram.h"
+#include "screen.h"
+#include <X11/Xmu/CharSet.h>
+#include <X11/bitmaps/menu12>
+#include "version.h"
+#include <X11/extensions/sync.h>
+#include <X11/SM/SMlib.h>
+
+extern XEvent Event;
+
+int RootFunction = 0;
+MenuRoot *ActiveMenu = NULL;		/* the active menu */
+MenuItem *ActiveItem = NULL;		/* the active menu item */
+int MoveFunction;			/* either F_MOVE or F_FORCEMOVE */
+int WindowMoved = FALSE;
+int menuFromFrameOrWindowOrTitlebar = FALSE;
+
+int ConstMove = FALSE;		/* constrained move variables */
+int ConstMoveDir;
+int ConstMoveX;
+int ConstMoveY;
+int ConstMoveXL;
+int ConstMoveXR;
+int ConstMoveYT;
+int ConstMoveYB;
+ 
+/* Globals used to keep track of whether the mouse has moved during
+   a resize function. */
+int ResizeOrigX;
+int ResizeOrigY;
+
+int MenuDepth = 0;		/* number of menus up */
+static struct {
+    int x;
+    int y;
+} MenuOrigins[MAXMENUDEPTH];
+static Cursor LastCursor;
+
+void WarpAlongRing(), WarpToWindow();
+
+extern char *Action;
+extern int Context;
+extern TwmWindow *ButtonWindow, *Tmp_win;
+extern XEvent Event, ButtonEvent;
+extern char *InitFile;
+static void Identify();
+
+#define SHADOWWIDTH 5			/* in pixels */
+
+
+
+/***********************************************************************
+ *
+ *  Procedure:
+ *	InitMenus - initialize menu roots
+ *
+ ***********************************************************************
+ */
+
+void
+InitMenus()
+{
+    int i, j, k;
+    FuncKey *key, *tmp;
+
+    for (i = 0; i < MAX_BUTTONS+1; i++)
+	for (j = 0; j < NUM_CONTEXTS; j++)
+	    for (k = 0; k < MOD_SIZE; k++)
+	    {
+		Scr->Mouse[i][j][k].func = 0;
+		Scr->Mouse[i][j][k].item = NULL;
+	    }
+
+    Scr->DefaultFunction.func = 0;
+    Scr->WindowFunction.func = 0;
+
+    if (FirstScreen)
+    {
+	for (key = Scr->FuncKeyRoot.next; key != NULL;)
+	{
+	    free(key->name);
+	    tmp = key;
+	    key = key->next;
+	    free((char *) tmp);
+	}
+	Scr->FuncKeyRoot.next = NULL;
+    }
+
+}
+
+
+
+/***********************************************************************
+ *
+ *  Procedure:
+ *	AddFuncKey - add a function key to the list
+ *
+ *  Inputs:
+ *	name	- the name of the key
+ *	cont	- the context to look for the key press in
+ *	mods	- modifier keys that need to be pressed
+ *	func	- the function to perform
+ *	win_name- the window name (if any)
+ *	action	- the action string associated with the function (if any)
+ *
+ ***********************************************************************
+ */
+
+Bool AddFuncKey (name, cont, mods, func, win_name, action)
+    char *name;
+    int cont, mods, func;
+    char *win_name;
+    char *action;
+{
+    FuncKey *tmp;
+    KeySym keysym;
+    KeyCode keycode;
+
+    /*
+     * Don't let a 0 keycode go through, since that means AnyKey to the
+     * XGrabKey call in GrabKeys().
+     */
+    if ((keysym = XStringToKeysym(name)) == NoSymbol ||
+	(keycode = XKeysymToKeycode(dpy, keysym)) == 0)
+    {
+	return False;
+    }
+
+    /* see if there already is a key defined for this context */
+    for (tmp = Scr->FuncKeyRoot.next; tmp != NULL; tmp = tmp->next)
+    {
+	if (tmp->keysym == keysym &&
+	    tmp->cont == cont &&
+	    tmp->mods == mods)
+	    break;
+    }
+
+    if (tmp == NULL)
+    {
+	tmp = (FuncKey *) malloc(sizeof(FuncKey));
+	tmp->next = Scr->FuncKeyRoot.next;
+	Scr->FuncKeyRoot.next = tmp;
+    }
+
+    tmp->name = name;
+    tmp->keysym = keysym;
+    tmp->keycode = keycode;
+    tmp->cont = cont;
+    tmp->mods = mods;
+    tmp->func = func;
+    tmp->win_name = win_name;
+    tmp->action = action;
+
+    return True;
+}
+
+
+
+int CreateTitleButton (name, func, action, menuroot, rightside, append)
+    char *name;
+    int func;
+    char *action;
+    MenuRoot *menuroot;
+    Bool rightside;
+    Bool append;
+{
+    TitleButton *tb = (TitleButton *) malloc (sizeof(TitleButton));
+
+    if (!tb) {
+	fprintf (stderr,
+		 "%s:  unable to allocate %d bytes for title button\n",
+		 ProgramName, sizeof(TitleButton));
+	return 0;
+    }
+
+    tb->next = NULL;
+    tb->name = name;			/* note that we are not copying */
+    tb->bitmap = None;			/* WARNING, values not set yet */
+    tb->width = 0;			/* see InitTitlebarButtons */
+    tb->height = 0;			/* ditto */
+    tb->func = func;
+    tb->action = action;
+    tb->menuroot = menuroot;
+    tb->rightside = rightside;
+    if (rightside) {
+	Scr->TBInfo.nright++;
+    } else {
+	Scr->TBInfo.nleft++;
+    }
+
+    /*
+     * Cases for list:
+     * 
+     *     1.  empty list, prepend left       put at head of list
+     *     2.  append left, prepend right     put in between left and right
+     *     3.  append right                   put at tail of list
+     *
+     * Do not refer to widths and heights yet since buttons not created
+     * (since fonts not loaded and heights not known).
+     */
+    if ((!Scr->TBInfo.head) || ((!append) && (!rightside))) {	/* 1 */
+	tb->next = Scr->TBInfo.head;
+	Scr->TBInfo.head = tb;
+    } else if (append && rightside) {	/* 3 */
+	register TitleButton *t;
+	for /* SUPPRESS 530 */
+	  (t = Scr->TBInfo.head; t->next; t = t->next);
+	t->next = tb;
+	tb->next = NULL;
+    } else {				/* 2 */
+	register TitleButton *t, *prev = NULL;
+	for (t = Scr->TBInfo.head; t && !t->rightside; t = t->next) {
+	    prev = t;
+	}
+	if (prev) {
+	    tb->next = prev->next;
+	    prev->next = tb;
+	} else {
+	    tb->next = Scr->TBInfo.head;
+	    Scr->TBInfo.head = tb;
+	}
+    }
+
+    return 1;
+}
+
+
+
+/*
+ * InitTitlebarButtons - Do all the necessary stuff to load in a titlebar
+ * button.  If we can't find the button, then put in a question; if we can't
+ * find the question mark, something is wrong and we are probably going to be
+ * in trouble later on.
+ */
+void InitTitlebarButtons ()
+{
+    TitleButton *tb;
+    int h;
+
+    /*
+     * initialize dimensions
+     */
+    Scr->TBInfo.width = (Scr->TitleHeight -
+			 2 * (Scr->FramePadding + Scr->ButtonIndent));
+    Scr->TBInfo.pad = ((Scr->TitlePadding > 1)
+		       ? ((Scr->TitlePadding + 1) / 2) : 1);
+    h = Scr->TBInfo.width - 2 * Scr->TBInfo.border;
+
+    /*
+     * add in some useful buttons and bindings so that novices can still
+     * use the system.
+     */
+    if (!Scr->NoDefaults) {
+	/* insert extra buttons */
+	if (!CreateTitleButton (TBPM_ICONIFY, F_ICONIFY, "", (MenuRoot *) NULL,
+				False, False)) {
+	    fprintf (stderr, "%s:  unable to add iconify button\n",
+		     ProgramName);
+	}
+	if (!CreateTitleButton (TBPM_RESIZE, F_RESIZE, "", (MenuRoot *) NULL,
+				True, True)) {
+	    fprintf (stderr, "%s:  unable to add resize button\n",
+		     ProgramName);
+	}
+	AddDefaultBindings ();
+    }
+    ComputeCommonTitleOffsets ();
+
+    /*
+     * load in images and do appropriate centering
+     */
+
+    for (tb = Scr->TBInfo.head; tb; tb = tb->next) {
+	tb->bitmap = FindBitmap (tb->name, &tb->width, &tb->height);
+	if (!tb->bitmap) {
+	    tb->bitmap = FindBitmap (TBPM_QUESTION, &tb->width, &tb->height);
+	    if (!tb->bitmap) {		/* cannot happen (see util.c) */
+		fprintf (stderr,
+			 "%s:  unable to add titlebar button \"%s\"\n",
+			 ProgramName, tb->name);
+	    }
+	}
+
+	tb->dstx = (h - tb->width + 1) / 2;
+	if (tb->dstx < 0) {		/* clip to minimize copying */
+	    tb->srcx = -(tb->dstx);
+	    tb->width = h;
+	    tb->dstx = 0;
+	} else {
+	    tb->srcx = 0;
+	}
+	tb->dsty = (h - tb->height + 1) / 2;
+	if (tb->dsty < 0) {
+	    tb->srcy = -(tb->dsty);
+	    tb->height = h;
+	    tb->dsty = 0;
+	} else {
+	    tb->srcy = 0;
+	}
+    }
+}
+
+
+
+PaintEntry(mr, mi, exposure)
+MenuRoot *mr;
+MenuItem *mi;
+int exposure;
+{
+    int y_offset;
+    int text_y;
+    GC gc;
+
+#ifdef DEBUG_MENUS
+    fprintf(stderr, "Paint entry\n");
+#endif
+    y_offset = mi->item_num * Scr->EntryHeight;
+    text_y = y_offset + Scr->MenuFont.y;
+
+    if (mi->func != F_TITLE)
+    {
+	int x, y;
+
+	if (mi->state)
+	{
+	    XSetForeground(dpy, Scr->NormalGC, mi->hi_back);
+
+	    XFillRectangle(dpy, mr->w, Scr->NormalGC, 0, y_offset,
+		mr->width, Scr->EntryHeight);
+
+	    FBF(mi->hi_fore, mi->hi_back, Scr->MenuFont.font->fid);
+
+	    XDrawString(dpy, mr->w, Scr->NormalGC, mi->x,
+		text_y, mi->item, mi->strlen);
+
+	    gc = Scr->NormalGC;
+	}
+	else
+	{
+	    if (mi->user_colors || !exposure)
+	    {
+		XSetForeground(dpy, Scr->NormalGC, mi->back);
+
+		XFillRectangle(dpy, mr->w, Scr->NormalGC, 0, y_offset,
+		    mr->width, Scr->EntryHeight);
+
+		FBF(mi->fore, mi->back, Scr->MenuFont.font->fid);
+		gc = Scr->NormalGC;
+	    }
+	    else
+		gc = Scr->MenuGC;
+
+	    XDrawString(dpy, mr->w, gc, mi->x,
+		text_y, mi->item, mi->strlen);
+	}
+
+	if (mi->func == F_MENU)
+	{
+	    /* create the pull right pixmap if needed */
+	    if (Scr->pullPm == None)
+	    {
+		Scr->pullPm = CreateMenuIcon (Scr->MenuFont.height,
+					     &Scr->pullW, &Scr->pullH);
+	    }
+	    x = mr->width - Scr->pullW - 5;
+	    y = y_offset + ((Scr->MenuFont.height - Scr->pullH) / 2);
+	    XCopyPlane(dpy, Scr->pullPm, mr->w, gc, 0, 0,
+		Scr->pullW, Scr->pullH, x, y, 1);
+	}
+    }
+    else
+    {
+	int y;
+
+	XSetForeground(dpy, Scr->NormalGC, mi->back);
+
+	/* fill the rectangle with the title background color */
+	XFillRectangle(dpy, mr->w, Scr->NormalGC, 0, y_offset,
+	    mr->width, Scr->EntryHeight);
+
+	{
+	    XSetForeground(dpy, Scr->NormalGC, mi->fore);
+	    /* now draw the dividing lines */
+	    if (y_offset)
+	      XDrawLine (dpy, mr->w, Scr->NormalGC, 0, y_offset,
+			 mr->width, y_offset);
+	    y = ((mi->item_num+1) * Scr->EntryHeight)-1;
+	    XDrawLine(dpy, mr->w, Scr->NormalGC, 0, y, mr->width, y);
+	}
+
+	FBF(mi->fore, mi->back, Scr->MenuFont.font->fid);
+	/* finally render the title */
+	XDrawString(dpy, mr->w, Scr->NormalGC, mi->x,
+	    text_y, mi->item, mi->strlen);
+    }
+}
+    
+
+
+PaintMenu(mr, e)
+MenuRoot *mr;
+XEvent *e;
+{
+    MenuItem *mi;
+
+    for (mi = mr->first; mi != NULL; mi = mi->next)
+    {
+	int y_offset = mi->item_num * Scr->EntryHeight;
+
+	/* be smart about handling the expose, redraw only the entries
+	 * that we need to
+	 */
+	if (e->xexpose.y < (y_offset + Scr->EntryHeight) &&
+	    (e->xexpose.y + e->xexpose.height) > y_offset)
+	{
+	    PaintEntry(mr, mi, True);
+	}
+    }
+    XSync(dpy, 0);
+}
+
+
+
+static Bool fromMenu;
+
+UpdateMenu()
+{
+    MenuItem *mi;
+    int i, x, y, x_root, y_root, entry;
+    int done;
+    MenuItem *badItem = NULL;
+
+    fromMenu = TRUE;
+
+    while (TRUE)
+    {
+	/* block until there is an event */
+        if (!menuFromFrameOrWindowOrTitlebar) {
+	  XMaskEvent(dpy,
+		     ButtonPressMask | ButtonReleaseMask |
+		     EnterWindowMask | ExposureMask |
+		     VisibilityChangeMask | LeaveWindowMask |
+		     ButtonMotionMask, &Event);
+	}
+	if (Event.type == MotionNotify) {
+	    /* discard any extra motion events before a release */
+	    while(XCheckMaskEvent(dpy,
+		ButtonMotionMask | ButtonReleaseMask, &Event))
+		if (Event.type == ButtonRelease)
+		    break;
+	}
+
+	if (!DispatchEvent ())
+	    continue;
+
+	if (Event.type == ButtonRelease || Cancel) {
+	  menuFromFrameOrWindowOrTitlebar = FALSE;
+	  fromMenu = FALSE;
+	  return;
+	}
+
+	if (Event.type != MotionNotify)
+	    continue;
+
+	done = FALSE;
+	XQueryPointer( dpy, ActiveMenu->w, &JunkRoot, &JunkChild,
+	    &x_root, &y_root, &x, &y, &JunkMask);
+
+	/* if we haven't recieved the enter notify yet, wait */
+	if (ActiveMenu && !ActiveMenu->entered)
+	    continue;
+
+	XFindContext(dpy, ActiveMenu->w, ScreenContext, (caddr_t *)&Scr);
+
+	if (x < 0 || y < 0 ||
+	    x >= ActiveMenu->width || y >= ActiveMenu->height)
+	{
+	    if (ActiveItem && ActiveItem->func != F_TITLE)
+	    {
+		ActiveItem->state = 0;
+		PaintEntry(ActiveMenu, ActiveItem, False);
+	    }
+	    ActiveItem = NULL;
+	    continue;
+	}
+
+	/* look for the entry that the mouse is in */
+	entry = y / Scr->EntryHeight;
+	for (i = 0, mi = ActiveMenu->first; mi != NULL; i++, mi=mi->next)
+	{
+	    if (i == entry)
+		break;
+	}
+
+	/* if there is an active item, we might have to turn it off */
+	if (ActiveItem)
+	{
+	    /* is the active item the one we are on ? */
+	    if (ActiveItem->item_num == entry && ActiveItem->state)
+		done = TRUE;
+
+	    /* if we weren't on the active entry, let's turn the old
+	     * active one off 
+	     */
+	    if (!done && ActiveItem->func != F_TITLE)
+	    {
+		ActiveItem->state = 0;
+		PaintEntry(ActiveMenu, ActiveItem, False);
+	    }
+	}
+
+	/* if we weren't on the active item, change the active item and turn
+	 * it on 
+	 */
+	if (!done)
+	{
+	    ActiveItem = mi;
+	    if (ActiveItem->func != F_TITLE && !ActiveItem->state)
+	    {
+		ActiveItem->state = 1;
+		PaintEntry(ActiveMenu, ActiveItem, False);
+	    }
+	}
+
+	/* now check to see if we were over the arrow of a pull right entry */
+	if (ActiveItem->func == F_MENU && 
+	    ((ActiveMenu->width - x) < (ActiveMenu->width >> 1)))
+	{
+	    MenuRoot *save = ActiveMenu;
+	    int savex = MenuOrigins[MenuDepth - 1].x; 
+	    int savey = MenuOrigins[MenuDepth - 1].y;
+
+	    if (MenuDepth < MAXMENUDEPTH) {
+		PopUpMenu (ActiveItem->sub, 
+			   (savex + (ActiveMenu->width >> 1)), 
+			   (savey + ActiveItem->item_num * Scr->EntryHeight)
+			   /*(savey + ActiveItem->item_num * Scr->EntryHeight +
+			    (Scr->EntryHeight >> 1))*/, False);
+	    } else if (!badItem) {
+		Bell(XkbBI_MinorError,0,None);
+		badItem = ActiveItem;
+	    }
+
+	    /* if the menu did get popped up, unhighlight the active item */
+	    if (save != ActiveMenu && ActiveItem->state)
+	    {
+		ActiveItem->state = 0;
+		PaintEntry(save, ActiveItem, False);
+		ActiveItem = NULL;
+	    }
+	}
+	if (badItem != ActiveItem) badItem = NULL;
+	XFlush(dpy);
+    }
+
+}
+
+
+
+/***********************************************************************
+ *
+ *  Procedure:
+ *	NewMenuRoot - create a new menu root
+ *
+ *  Returned Value:
+ *	(MenuRoot *)
+ *
+ *  Inputs:
+ *	name	- the name of the menu root
+ *
+ ***********************************************************************
+ */
+
+MenuRoot *
+NewMenuRoot(name)
+    char *name;
+{
+    MenuRoot *tmp;
+
+#define UNUSED_PIXEL ((unsigned long) (~0))	/* more than 24 bits */
+
+    tmp = (MenuRoot *) malloc(sizeof(MenuRoot));
+    tmp->hi_fore = UNUSED_PIXEL;
+    tmp->hi_back = UNUSED_PIXEL;
+    tmp->name = name;
+    tmp->prev = NULL;
+    tmp->first = NULL;
+    tmp->last = NULL;
+    tmp->items = 0;
+    tmp->width = 0;
+    tmp->mapped = NEVER_MAPPED;
+    tmp->pull = FALSE;
+    tmp->w = None;
+    tmp->shadow = None;
+    tmp->real_menu = FALSE;
+
+    if (Scr->MenuList == NULL)
+    {
+	Scr->MenuList = tmp;
+	Scr->MenuList->next = NULL;
+    }
+
+    if (Scr->LastMenu == NULL)
+    {
+	Scr->LastMenu = tmp;
+	Scr->LastMenu->next = NULL;
+    }
+    else
+    {
+	Scr->LastMenu->next = tmp;
+	Scr->LastMenu = tmp;
+	Scr->LastMenu->next = NULL;
+    }
+
+    if (strcmp(name, TWM_WINDOWS) == 0)
+	Scr->Windows = tmp;
+
+    return (tmp);
+}
+
+
+
+/***********************************************************************
+ *
+ *  Procedure:
+ *	AddToMenu - add an item to a root menu
+ *
+ *  Returned Value:
+ *	(MenuItem *)
+ *
+ *  Inputs:
+ *	menu	- pointer to the root menu to add the item
+ *	item	- the text to appear in the menu
+ *	action	- the string to possibly execute
+ *	sub	- the menu root if it is a pull-right entry
+ *	func	- the numeric function
+ *	fore	- foreground color string
+ *	back	- background color string
+ *
+ ***********************************************************************
+ */
+
+MenuItem *
+AddToMenu(menu, item, action, sub, func, fore, back)
+    MenuRoot *menu;
+    char *item, *action;
+    MenuRoot *sub;
+    int func;
+    char *fore, *back;
+{
+    MenuItem *tmp;
+    int width;
+
+#ifdef DEBUG_MENUS
+    fprintf(stderr, "adding menu item=\"%s\", action=%s, sub=%d, f=%d\n",
+	item, action, sub, func);
+#endif
+
+    tmp = (MenuItem *) malloc(sizeof(MenuItem));
+    tmp->root = menu;
+
+    if (menu->first == NULL)
+    {
+	menu->first = tmp;
+	tmp->prev = NULL;
+    }
+    else
+    {
+	menu->last->next = tmp;
+	tmp->prev = menu->last;
+    }
+    menu->last = tmp;
+
+    tmp->item = item;
+    tmp->strlen = strlen(item);
+    tmp->action = action;
+    tmp->next = NULL;
+    tmp->sub = NULL;
+    tmp->state = 0;
+    tmp->func = func;
+
+    if (!Scr->HaveFonts) CreateFonts();
+    width = XTextWidth(Scr->MenuFont.font, item, tmp->strlen);
+    if (width <= 0)
+	width = 1;
+    if (width > menu->width)
+	menu->width = width;
+
+    tmp->user_colors = FALSE;
+    if (Scr->Monochrome == COLOR && fore != NULL)
+    {
+	int save;
+
+	save = Scr->FirstTime;
+	Scr->FirstTime = TRUE;
+	GetColor(COLOR, &tmp->fore, fore);
+	GetColor(COLOR, &tmp->back, back);
+	Scr->FirstTime = save;
+	tmp->user_colors = TRUE;
+    }
+    if (sub != NULL)
+    {
+	tmp->sub = sub;
+	menu->pull = TRUE;
+    }
+    tmp->item_num = menu->items++;
+
+    return (tmp);
+}
+
+
+
+MakeMenus()
+{
+    MenuRoot *mr;
+
+    for (mr = Scr->MenuList; mr != NULL; mr = mr->next)
+    {
+	if (mr->real_menu == FALSE)
+	    continue;
+
+	MakeMenu(mr);
+    }
+}
+
+
+
+MakeMenu(mr)
+MenuRoot *mr;
+{
+    MenuItem *start, *end, *cur, *tmp;
+    XColor f1, f2, f3;
+    XColor b1, b2, b3;
+    XColor save_fore, save_back;
+    int num, i;
+    int fred, fgreen, fblue;
+    int bred, bgreen, bblue;
+    int width;
+    unsigned long valuemask;
+    XSetWindowAttributes attributes;
+    Colormap cmap = Scr->TwmRoot.cmaps.cwins[0]->colormap->c;
+
+    Scr->EntryHeight = Scr->MenuFont.height + 4;
+
+    /* lets first size the window accordingly */
+    if (mr->mapped == NEVER_MAPPED)
+    {
+	if (mr->pull == TRUE)
+	{
+	    mr->width += 16 + 10;
+	}
+
+	width = mr->width + 10;
+
+	for (cur = mr->first; cur != NULL; cur = cur->next)
+	{
+	    if (cur->func != F_TITLE)
+		cur->x = 5;
+	    else
+	    {
+		cur->x = width - XTextWidth(Scr->MenuFont.font, cur->item,
+		    cur->strlen);
+		cur->x /= 2;
+	    }
+	}
+	mr->height = mr->items * Scr->EntryHeight;
+	mr->width += 10;
+
+	if (Scr->Shadow)
+	{
+	    /*
+	     * Make sure that you don't draw into the shadow window or else
+	     * the background bits there will get saved
+	     */
+	    valuemask = (CWBackPixel | CWBorderPixel);
+	    attributes.background_pixel = Scr->MenuShadowColor;
+	    attributes.border_pixel = Scr->MenuShadowColor;
+	    if (Scr->SaveUnder) {
+		valuemask |= CWSaveUnder;
+		attributes.save_under = True;
+	    }
+	    mr->shadow = XCreateWindow (dpy, Scr->Root, 0, 0,
+					(unsigned int) mr->width, 
+					(unsigned int) mr->height,
+					(unsigned int)0,
+					CopyFromParent, 
+					(unsigned int) CopyFromParent,
+					(Visual *) CopyFromParent,
+					valuemask, &attributes);
+	}
+
+	valuemask = (CWBackPixel | CWBorderPixel | CWEventMask);
+	attributes.background_pixel = Scr->MenuC.back;
+	attributes.border_pixel = Scr->MenuC.fore;
+	attributes.event_mask = (ExposureMask | EnterWindowMask);
+	if (Scr->SaveUnder) {
+	    valuemask |= CWSaveUnder;
+	    attributes.save_under = True;
+	}
+	if (Scr->BackingStore) {
+	    valuemask |= CWBackingStore;
+	    attributes.backing_store = Always;
+	}
+	mr->w = XCreateWindow (dpy, Scr->Root, 0, 0, (unsigned int) mr->width,
+			       (unsigned int) mr->height, (unsigned int) 1,
+			       CopyFromParent, (unsigned int) CopyFromParent,
+			       (Visual *) CopyFromParent,
+			       valuemask, &attributes);
+
+
+	XSaveContext(dpy, mr->w, MenuContext, (caddr_t)mr);
+	XSaveContext(dpy, mr->w, ScreenContext, (caddr_t)Scr);
+
+	mr->mapped = UNMAPPED;
+    }
+
+    /* get the default colors into the menus */
+    for (tmp = mr->first; tmp != NULL; tmp = tmp->next)
+    {
+	if (!tmp->user_colors) {
+	    if (tmp->func != F_TITLE) {
+		tmp->fore = Scr->MenuC.fore;
+		tmp->back = Scr->MenuC.back;
+	    } else {
+		tmp->fore = Scr->MenuTitleC.fore;
+		tmp->back = Scr->MenuTitleC.back;
+	    }
+	}
+
+	if (mr->hi_fore != UNUSED_PIXEL)
+	{
+	    tmp->hi_fore = mr->hi_fore;
+	    tmp->hi_back = mr->hi_back;
+	}
+	else
+	{
+	    tmp->hi_fore = tmp->back;
+	    tmp->hi_back = tmp->fore;
+	}
+    }
+
+    if (Scr->Monochrome == MONOCHROME || !Scr->InterpolateMenuColors)
+	return;
+
+    start = mr->first;
+    while (TRUE)
+    {
+	for (; start != NULL; start = start->next)
+	{
+	    if (start->user_colors)
+		break;
+	}
+	if (start == NULL)
+	    break;
+
+	for (end = start->next; end != NULL; end = end->next)
+	{
+	    if (end->user_colors)
+		break;
+	}
+	if (end == NULL)
+	    break;
+
+	/* we have a start and end to interpolate between */
+	num = end->item_num - start->item_num;
+
+	f1.pixel = start->fore;
+	XQueryColor(dpy, cmap, &f1);
+	f2.pixel = end->fore;
+	XQueryColor(dpy, cmap, &f2);
+
+	b1.pixel = start->back;
+	XQueryColor(dpy, cmap, &b1);
+	b2.pixel = end->back;
+	XQueryColor(dpy, cmap, &b2);
+
+	fred = ((int)f2.red - (int)f1.red) / num;
+	fgreen = ((int)f2.green - (int)f1.green) / num;
+	fblue = ((int)f2.blue - (int)f1.blue) / num;
+
+	bred = ((int)b2.red - (int)b1.red) / num;
+	bgreen = ((int)b2.green - (int)b1.green) / num;
+	bblue = ((int)b2.blue - (int)b1.blue) / num;
+
+	f3 = f1;
+	f3.flags = DoRed | DoGreen | DoBlue;
+
+	b3 = b1;
+	b3.flags = DoRed | DoGreen | DoBlue;
+
+	num -= 1;
+	for (i = 0, cur = start->next; i < num; i++, cur = cur->next)
+	{
+	    f3.red += fred;
+	    f3.green += fgreen;
+	    f3.blue += fblue;
+	    save_fore = f3;
+
+	    b3.red += bred;
+	    b3.green += bgreen;
+	    b3.blue += bblue;
+	    save_back = b3;
+
+	    XAllocColor(dpy, cmap, &f3);
+	    XAllocColor(dpy, cmap, &b3);
+	    cur->hi_back = cur->fore = f3.pixel;
+	    cur->hi_fore = cur->back = b3.pixel;
+	    cur->user_colors = True;
+
+	    f3 = save_fore;
+	    b3 = save_back;
+	}
+	start = end;
+    }
+}
+
+
+
+/***********************************************************************
+ *
+ *  Procedure:
+ *	PopUpMenu - pop up a pull down menu
+ *
+ *  Inputs:
+ *	menu	- the root pointer of the menu to pop up
+ *	x, y	- location of upper left of menu
+ *      center	- whether or not to center horizontally over position
+ *
+ ***********************************************************************
+ */
+
+Bool PopUpMenu (menu, x, y, center)
+    MenuRoot *menu;
+    int x, y;
+    Bool center;
+{
+    int WindowNameOffset, WindowNameCount;
+    TwmWindow **WindowNames;
+    TwmWindow *tmp_win2,*tmp_win3;
+    int i;
+    int (*compar)() = 
+      (Scr->CaseSensitive ? strcmp : XmuCompareISOLatin1);
+
+    if (!menu) return False;
+
+    InstallRootColormap();
+
+    if (menu == Scr->Windows)
+    {
+	TwmWindow *tmp_win;
+
+	/* this is the twm windows menu,  let's go ahead and build it */
+
+	DestroyMenu (menu);
+
+	menu->first = NULL;
+	menu->last = NULL;
+	menu->items = 0;
+	menu->width = 0;
+	menu->mapped = NEVER_MAPPED;
+  	AddToMenu(menu, "TWM Windows", NULLSTR, NULL, F_TITLE,NULLSTR,NULLSTR);
+  
+        WindowNameOffset=(char *)Scr->TwmRoot.next->name -
+                               (char *)Scr->TwmRoot.next;
+        for(tmp_win = Scr->TwmRoot.next , WindowNameCount=0;
+            tmp_win != NULL;
+            tmp_win = tmp_win->next)
+          WindowNameCount++;
+        WindowNames =
+          (TwmWindow **)malloc(sizeof(TwmWindow *)*WindowNameCount);
+        WindowNames[0] = Scr->TwmRoot.next;
+        for(tmp_win = Scr->TwmRoot.next->next , WindowNameCount=1;
+            tmp_win != NULL;
+            tmp_win = tmp_win->next,WindowNameCount++)
+        {
+            tmp_win2 = tmp_win;
+            for (i=0;i<WindowNameCount;i++)
+            {
+                if ((*compar)(tmp_win2->name,WindowNames[i]->name) < 0)
+                {
+                    tmp_win3 = tmp_win2;
+                    tmp_win2 = WindowNames[i];
+                    WindowNames[i] = tmp_win3;
+                }
+            }
+            WindowNames[WindowNameCount] = tmp_win2;
+        }
+        for (i=0; i<WindowNameCount; i++)
+        {
+            AddToMenu(menu, WindowNames[i]->name, (char *)WindowNames[i],
+                      NULL, F_POPUP,NULL,NULL);
+        }
+        free(WindowNames);
+
+	MakeMenu(menu);
+    }
+
+    if (menu->w == None || menu->items == 0) return False;
+
+    /* Prevent recursively bringing up menus. */
+    if (menu->mapped == MAPPED) return False;
+
+    /*
+     * Dynamically set the parent;  this allows pull-ups to also be main
+     * menus, or to be brought up from more than one place.
+     */
+    menu->prev = ActiveMenu;
+
+    XGrabPointer(dpy, Scr->Root, True,
+	ButtonPressMask | ButtonReleaseMask |
+	ButtonMotionMask | PointerMotionHintMask,
+	GrabModeAsync, GrabModeAsync,
+	Scr->Root, Scr->MenuCursor, CurrentTime);
+
+    ActiveMenu = menu;
+    menu->mapped = MAPPED;
+    menu->entered = FALSE;
+
+    if (center) {
+	x -= (menu->width / 2);
+	y -= (Scr->EntryHeight / 2);	/* sticky menus would be nice here */
+    }
+
+    /*
+     * clip to screen
+     */
+    if (x + menu->width > Scr->MyDisplayWidth) {
+	x = Scr->MyDisplayWidth - menu->width;
+    }
+    if (x < 0) x = 0;
+    if (y + menu->height > Scr->MyDisplayHeight) {
+	y = Scr->MyDisplayHeight - menu->height;
+    }
+    if (y < 0) y = 0;
+
+    MenuOrigins[MenuDepth].x = x;
+    MenuOrigins[MenuDepth].y = y;
+    MenuDepth++;
+
+    XMoveWindow(dpy, menu->w, x, y);
+    if (Scr->Shadow) {
+	XMoveWindow (dpy, menu->shadow, x + SHADOWWIDTH, y + SHADOWWIDTH);
+    }
+    if (Scr->Shadow) {
+	XRaiseWindow (dpy, menu->shadow);
+    }
+    XMapRaised(dpy, menu->w);
+    if (Scr->Shadow) {
+	XMapWindow (dpy, menu->shadow);
+    }
+    XSync(dpy, 0);
+    return True;
+}
+
+
+
+/***********************************************************************
+ *
+ *  Procedure:
+ *	PopDownMenu - unhighlight the current menu selection and
+ *		take down the menus
+ *
+ ***********************************************************************
+ */
+
+PopDownMenu()
+{
+    MenuRoot *tmp;
+
+    if (ActiveMenu == NULL)
+	return;
+
+    if (ActiveItem)
+    {
+	ActiveItem->state = 0;
+	PaintEntry(ActiveMenu, ActiveItem, False);
+    }
+
+    for (tmp = ActiveMenu; tmp != NULL; tmp = tmp->prev)
+    {
+	if (Scr->Shadow) {
+	    XUnmapWindow (dpy, tmp->shadow);
+	}
+	XUnmapWindow(dpy, tmp->w);
+	tmp->mapped = UNMAPPED;
+	UninstallRootColormap();
+    }
+
+    XFlush(dpy);
+    ActiveMenu = NULL;
+    ActiveItem = NULL;
+    MenuDepth = 0;
+    if (Context == C_WINDOW || Context == C_FRAME || Context == C_TITLE)
+      menuFromFrameOrWindowOrTitlebar = TRUE;
+}
+
+
+
+/***********************************************************************
+ *
+ *  Procedure:
+ *	FindMenuRoot - look for a menu root
+ *
+ *  Returned Value:
+ *	(MenuRoot *)  - a pointer to the menu root structure 
+ *
+ *  Inputs:
+ *	name	- the name of the menu root 
+ *
+ ***********************************************************************
+ */
+
+MenuRoot *
+FindMenuRoot(name)
+    char *name;
+{
+    MenuRoot *tmp;
+
+    for (tmp = Scr->MenuList; tmp != NULL; tmp = tmp->next)
+    {
+	if (strcmp(name, tmp->name) == 0)
+	    return (tmp);
+    }
+    return NULL;
+}
+
+
+
+static Bool belongs_to_twm_window (t, w)
+    register TwmWindow *t;
+    register Window w;
+{
+    if (!t) return False;
+
+    if (w == t->frame || w == t->title_w || w == t->hilite_w ||
+	w == t->icon_w || w == t->icon_bm_w) return True;
+    
+    if (t && t->titlebuttons) {
+	register TBWindow *tbw;
+	register int nb = Scr->TBInfo.nleft + Scr->TBInfo.nright;
+	for (tbw = t->titlebuttons; nb > 0; tbw++, nb--) {
+	    if (tbw->window == w) return True;
+	}
+    }
+    return False;
+}
+
+
+
+
+/***********************************************************************
+ *
+ *  Procedure:
+ *	resizeFromCenter -
+ *
+ ***********************************************************************
+ */
+
+
+extern int AddingX;
+extern int AddingY;
+extern int AddingW;
+extern int AddingH;
+
+void resizeFromCenter(w, tmp_win)
+     Window w;
+     TwmWindow *tmp_win;
+{
+  int lastx, lasty, width, height, bw2;
+  int namelen;
+  XEvent event;
+
+  namelen = strlen (tmp_win->name);
+  bw2 = tmp_win->frame_bw * 2;
+  AddingW = tmp_win->attr.width + bw2;
+  AddingH = tmp_win->attr.height + tmp_win->title_height + bw2;
+  width = (SIZE_HINDENT + XTextWidth (Scr->SizeFont.font,
+				      tmp_win->name, namelen));
+  height = Scr->SizeFont.height + SIZE_VINDENT * 2;
+  XGetGeometry(dpy, w, &JunkRoot, &origDragX, &origDragY,
+	       (unsigned int *)&DragWidth, (unsigned int *)&DragHeight, 
+	       &JunkBW, &JunkDepth);
+  XWarpPointer(dpy, None, w,
+	       0, 0, 0, 0, DragWidth/2, DragHeight/2);   
+  XQueryPointer (dpy, Scr->Root, &JunkRoot, 
+		 &JunkChild, &JunkX, &JunkY,
+		 &AddingX, &AddingY, &JunkMask);
+/*****
+  Scr->SizeStringOffset = width +
+    XTextWidth(Scr->SizeFont.font, ": ", 2);
+  XResizeWindow (dpy, Scr->SizeWindow, Scr->SizeStringOffset +
+		 Scr->SizeStringWidth, height);
+  XDrawImageString (dpy, Scr->SizeWindow, Scr->NormalGC, width,
+		    SIZE_VINDENT + Scr->SizeFont.font->ascent,
+		    ": ", 2);
+*****/
+  lastx = -10000;
+  lasty = -10000;
+/*****
+  MoveOutline(Scr->Root,
+	      origDragX - JunkBW, origDragY - JunkBW,
+	      DragWidth * JunkBW, DragHeight * JunkBW,
+	      tmp_win->frame_bw,
+	      tmp_win->title_height);
+*****/
+  MenuStartResize(tmp_win, origDragX, origDragY, DragWidth, DragHeight);
+  while (TRUE)
+    {
+      XMaskEvent(dpy,
+		 ButtonPressMask | PointerMotionMask, &event);
+      
+      if (event.type == MotionNotify) {
+	/* discard any extra motion events before a release */
+	while(XCheckMaskEvent(dpy,
+			      ButtonMotionMask | ButtonPressMask, &event))
+	  if (event.type == ButtonPress)
+	    break;
+      }
+      
+      if (event.type == ButtonPress)
+	{
+	  MenuEndResize(tmp_win);
+	  XMoveResizeWindow(dpy, w, AddingX, AddingY, AddingW, AddingH);
+	  break;
+	}
+      
+/*    if (!DispatchEvent ()) continue; */
+
+      if (event.type != MotionNotify) {
+	continue;
+      }
+      
+      /*
+       * XXX - if we are going to do a loop, we ought to consider
+       * using multiple GXxor lines so that we don't need to 
+       * grab the server.
+       */
+      XQueryPointer(dpy, Scr->Root, &JunkRoot, &JunkChild,
+		    &JunkX, &JunkY, &AddingX, &AddingY, &JunkMask);
+      
+      if (lastx != AddingX || lasty != AddingY)
+	{
+	  MenuDoResize(AddingX, AddingY, tmp_win);
+	  
+	  lastx = AddingX;
+	  lasty = AddingY;
+	}
+      
+    }
+} 
+
+
+
+/***********************************************************************
+ *
+ *  Procedure:
+ *	ExecuteFunction - execute a twm root function
+ *
+ *  Inputs:
+ *	func	- the function to execute
+ *	action	- the menu action to execute 
+ *	w	- the window to execute this function on
+ *	tmp_win	- the twm window structure
+ *	event	- the event that caused the function
+ *	context - the context in which the button was pressed
+ *	pulldown- flag indicating execution from pull down menu
+ *
+ *  Returns:
+ *	TRUE if should continue with remaining actions else FALSE to abort
+ *
+ ***********************************************************************
+ */
+
+/* for F_WARPTO */
+#define true 1
+#define false 0
+int
+WarpThere(t) 
+    TwmWindow* t; 
+{
+    if (Scr->WarpUnmapped || t->mapped) {
+        if (!t->mapped) DeIconify (t);
+        if (!Scr->NoRaiseWarp) XRaiseWindow (dpy, t->frame);
+        WarpToWindow (t); 
+        return true; 
+    }    
+    return false;
+}
+
+extern int MovedFromKeyPress;
+
+int
+ExecuteFunction(func, action, w, tmp_win, eventp, context, pulldown)
+    int func;
+    char *action;
+    Window w;
+    TwmWindow *tmp_win;
+    XEvent *eventp;
+    int context;
+    int pulldown;
+{
+    static Time last_time = 0;
+    char tmp[200];
+    char *ptr;
+    char buff[MAX_FILE_SIZE];
+    int count, fd;
+    Window rootw;
+    int origX, origY;
+    int do_next_action = TRUE;
+    int moving_icon = FALSE;
+    Bool fromtitlebar = False;
+    extern int ConstrainedMoveTime;
+
+    RootFunction = 0;
+    if (Cancel)
+	return TRUE;			/* XXX should this be FALSE? */
+
+    switch (func)
+    {
+    case F_UPICONMGR:
+    case F_LEFTICONMGR:
+    case F_RIGHTICONMGR:
+    case F_DOWNICONMGR:
+    case F_FORWICONMGR:
+    case F_BACKICONMGR:
+    case F_NEXTICONMGR:
+    case F_PREVICONMGR:
+    case F_NOP:
+    case F_TITLE:
+    case F_DELTASTOP:
+    case F_RAISELOWER:
+    case F_WARPTOSCREEN:
+    case F_WARPTO:
+    case F_WARPRING:
+    case F_WARPTOICONMGR:
+    case F_COLORMAP:
+	break;
+    default:
+        XGrabPointer(dpy, Scr->Root, True,
+            ButtonPressMask | ButtonReleaseMask,
+            GrabModeAsync, GrabModeAsync,
+            Scr->Root, Scr->WaitCursor, CurrentTime);
+	break;
+    }
+
+    switch (func)
+    {
+    case F_NOP:
+    case F_TITLE:
+	break;
+
+    case F_DELTASTOP:
+	if (WindowMoved) do_next_action = FALSE;
+	break;
+
+    case F_RESTART:
+    {
+	extern SmcConn smcConn;
+
+	XSync (dpy, 0);
+	Reborder (eventp->xbutton.time);
+	XSync (dpy, 0);
+	if (smcConn)
+	    SmcCloseConnection (smcConn, 0, NULL);
+	execvp(*Argv, Argv);
+	fprintf (stderr, "%s:  unable to restart:  %s\n", ProgramName, *Argv);
+	break;
+    }
+
+    case F_UPICONMGR:
+    case F_DOWNICONMGR:
+    case F_LEFTICONMGR:
+    case F_RIGHTICONMGR:
+    case F_FORWICONMGR:
+    case F_BACKICONMGR:
+	MoveIconManager(func);
+        break;
+
+    case F_NEXTICONMGR:
+    case F_PREVICONMGR:
+	JumpIconManager(func);
+        break;
+
+    case F_SHOWLIST:
+	if (Scr->NoIconManagers)
+	    break;
+	DeIconify(Scr->iconmgr.twm_win);
+	XRaiseWindow(dpy, Scr->iconmgr.twm_win->frame);
+	break;
+
+    case F_HIDELIST:
+	if (Scr->NoIconManagers)
+	    break;
+	HideIconManager ();
+	break;
+
+    case F_SORTICONMGR:
+	if (DeferExecution(context, func, Scr->SelectCursor))
+	    return TRUE;
+
+	{
+	    int save_sort;
+
+	    save_sort = Scr->SortIconMgr;
+	    Scr->SortIconMgr = TRUE;
+
+	    if (context == C_ICONMGR)
+		SortIconManager((IconMgr *) NULL);
+	    else if (tmp_win->iconmgr)
+		SortIconManager(tmp_win->iconmgrp);
+	    else 
+		Bell(XkbBI_Info,0,tmp_win->w);
+
+	    Scr->SortIconMgr = save_sort;
+	}
+	break;
+
+    case F_IDENTIFY:
+	if (DeferExecution(context, func, Scr->SelectCursor))
+	    return TRUE;
+
+	Identify(tmp_win);
+	break;
+
+    case F_VERSION:
+	Identify ((TwmWindow *) NULL);
+	break;
+
+    case F_AUTORAISE:
+	if (DeferExecution(context, func, Scr->SelectCursor))
+	    return TRUE;
+
+	tmp_win->auto_raise = !tmp_win->auto_raise;
+	if (tmp_win->auto_raise) ++(Scr->NumAutoRaises);
+	else --(Scr->NumAutoRaises);
+	break;
+
+    case F_BEEP:
+	Bell(XkbBI_Info,0,None);
+	break;
+
+    case F_POPUP:
+	tmp_win = (TwmWindow *)action;
+	if (Scr->WindowFunction.func != 0)
+	{
+	   ExecuteFunction(Scr->WindowFunction.func,
+			   Scr->WindowFunction.item->action,
+			   w, tmp_win, eventp, C_FRAME, FALSE);
+	}
+	else
+	{
+	    DeIconify(tmp_win);
+	    XRaiseWindow (dpy, tmp_win->frame);
+	}
+	break;
+
+    case F_RESIZE:
+	EventHandler[EnterNotify] = HandleUnknown;
+	EventHandler[LeaveNotify] = HandleUnknown;
+	if (DeferExecution(context, func, Scr->MoveCursor))
+	    return TRUE;
+
+	PopDownMenu();
+
+	if (pulldown)
+	    XWarpPointer(dpy, None, Scr->Root, 
+		0, 0, 0, 0, eventp->xbutton.x_root, eventp->xbutton.y_root);
+
+	if (w != tmp_win->icon_w) {	/* can't resize icons */
+
+	  if ((Context == C_FRAME || Context == C_WINDOW || Context == C_TITLE)
+	      && fromMenu) 
+	    resizeFromCenter(w, tmp_win);
+	  else {
+	    /*
+	     * see if this is being done from the titlebar
+	     */
+	    fromtitlebar = 
+	      belongs_to_twm_window (tmp_win, eventp->xbutton.window);
+	    
+	    /* Save pointer position so we can tell if it was moved or
+	       not during the resize. */
+	    ResizeOrigX = eventp->xbutton.x_root;
+	    ResizeOrigY = eventp->xbutton.y_root;
+	    
+	    StartResize (eventp, tmp_win, fromtitlebar);
+	    
+	    do {
+	      XMaskEvent(dpy,
+			   ButtonPressMask | ButtonReleaseMask |
+			   EnterWindowMask | LeaveWindowMask |
+			   ButtonMotionMask, &Event);
+		
+		if (fromtitlebar && Event.type == ButtonPress) {
+		  fromtitlebar = False;
+		    continue;
+		  }
+		
+	    	if (Event.type == MotionNotify) {
+		  /* discard any extra motion events before a release */
+		  while
+		    (XCheckMaskEvent
+		     (dpy, ButtonMotionMask | ButtonReleaseMask, &Event))
+		      if (Event.type == ButtonRelease)
+			break;
+		}
+	      
+	      if (!DispatchEvent ()) continue;
+	      
+	    } while (!(Event.type == ButtonRelease || Cancel));
+	    return TRUE;
+	  }
+	} 
+	break;
+
+
+    case F_ZOOM:
+    case F_HORIZOOM:
+    case F_FULLZOOM:
+    case F_LEFTZOOM:
+    case F_RIGHTZOOM:
+    case F_TOPZOOM:
+    case F_BOTTOMZOOM:
+	if (DeferExecution(context, func, Scr->SelectCursor))
+	    return TRUE;
+	fullzoom(tmp_win, func);
+	break;
+
+    case F_MOVE:
+    case F_FORCEMOVE:
+	if (DeferExecution(context, func, Scr->MoveCursor))
+	    return TRUE;
+
+	PopDownMenu();
+	rootw = eventp->xbutton.root;
+	MoveFunction = func;
+
+	if (pulldown)
+	    XWarpPointer(dpy, None, Scr->Root, 
+		0, 0, 0, 0, eventp->xbutton.x_root, eventp->xbutton.y_root);
+
+	EventHandler[EnterNotify] = HandleUnknown;
+	EventHandler[LeaveNotify] = HandleUnknown;
+
+	if (!Scr->NoGrabServer || !Scr->OpaqueMove) {
+	    XGrabServer(dpy);
+	}
+	XGrabPointer(dpy, eventp->xbutton.root, True,
+	    ButtonPressMask | ButtonReleaseMask |
+	    ButtonMotionMask | PointerMotionMask, /* PointerMotionHintMask */
+	    GrabModeAsync, GrabModeAsync,
+	    Scr->Root, Scr->MoveCursor, CurrentTime);
+
+	if (context == C_ICON && tmp_win->icon_w)
+	{
+	    w = tmp_win->icon_w;
+	    DragX = eventp->xbutton.x;
+	    DragY = eventp->xbutton.y;
+	    moving_icon = TRUE;
+	}
+
+	else if (w != tmp_win->icon_w)
+	{
+	    XTranslateCoordinates(dpy, w, tmp_win->frame,
+		eventp->xbutton.x, 
+		eventp->xbutton.y, 
+		&DragX, &DragY, &JunkChild);
+
+	    w = tmp_win->frame;
+	}
+
+	DragWindow = None;
+
+	XGetGeometry(dpy, w, &JunkRoot, &origDragX, &origDragY,
+	    (unsigned int *)&DragWidth, (unsigned int *)&DragHeight, &JunkBW,
+	    &JunkDepth);
+
+	origX = eventp->xbutton.x_root;
+	origY = eventp->xbutton.y_root;
+	CurrentDragX = origDragX;
+	CurrentDragY = origDragY;
+
+	/*
+	 * only do the constrained move if timer is set; need to check it
+	 * in case of stupid or wicked fast servers
+	 */
+	if (ConstrainedMoveTime && 
+	    (eventp->xbutton.time - last_time) < ConstrainedMoveTime)
+	{
+	    int width, height;
+
+	    ConstMove = TRUE;
+	    ConstMoveDir = MOVE_NONE;
+	    ConstMoveX = eventp->xbutton.x_root - DragX - JunkBW;
+	    ConstMoveY = eventp->xbutton.y_root - DragY - JunkBW;
+	    width = DragWidth + 2 * JunkBW;
+	    height = DragHeight + 2 * JunkBW;
+	    ConstMoveXL = ConstMoveX + width/3;
+	    ConstMoveXR = ConstMoveX + 2*(width/3);
+	    ConstMoveYT = ConstMoveY + height/3;
+	    ConstMoveYB = ConstMoveY + 2*(height/3);
+
+	    XWarpPointer(dpy, None, w,
+		0, 0, 0, 0, DragWidth/2, DragHeight/2);
+
+	    XQueryPointer(dpy, w, &JunkRoot, &JunkChild,
+		&JunkX, &JunkY, &DragX, &DragY, &JunkMask);
+	}
+	last_time = eventp->xbutton.time;
+
+	if (!Scr->OpaqueMove)
+	{
+	    InstallRootColormap();
+	    if (!Scr->MoveDelta)
+	    {
+		/*
+		 * Draw initial outline.  This was previously done the
+		 * first time though the outer loop by dropping out of
+		 * the XCheckMaskEvent inner loop down to one of the
+		 * MoveOutline's below.
+		 */
+		MoveOutline(rootw,
+		    origDragX - JunkBW, origDragY - JunkBW,
+		    DragWidth + 2 * JunkBW, DragHeight + 2 * JunkBW,
+		    tmp_win->frame_bw,
+		    moving_icon ? 0 : tmp_win->title_height);
+		/*
+		 * This next line causes HandleReleaseNotify to call
+		 * XRaiseWindow().  This is solely to preserve the
+		 * previous behaviour that raises a window being moved
+		 * on button release even if you never actually moved
+		 * any distance (unless you move less than MoveDelta or
+		 * NoRaiseMove is set or OpaqueMove is set).
+		 */
+		DragWindow = w;
+	    }
+	}
+
+	/*
+	 * see if this is being done from the titlebar
+	 */
+	fromtitlebar = belongs_to_twm_window (tmp_win, eventp->xbutton.window);
+
+	if (menuFromFrameOrWindowOrTitlebar) {
+	  /* warp the pointer to the middle of the window */
+	  XWarpPointer(dpy, None, Scr->Root, 0, 0, 0, 0, 
+		       origDragX + DragWidth / 2, 
+		       origDragY + DragHeight / 2);
+	  XFlush(dpy);
+	}
+	
+	while (TRUE)
+	{
+	    long releaseEvent = menuFromFrameOrWindowOrTitlebar ? 
+	                          ButtonPress : ButtonRelease;
+	    long movementMask = menuFromFrameOrWindowOrTitlebar ?
+	                          PointerMotionMask : ButtonMotionMask;
+
+	    /* block until there is an interesting event */
+	    XMaskEvent(dpy, ButtonPressMask | ButtonReleaseMask |
+				    EnterWindowMask | LeaveWindowMask |
+				    ExposureMask | movementMask |
+				    VisibilityChangeMask, &Event);
+
+	    /* throw away enter and leave events until release */
+	    if (Event.xany.type == EnterNotify ||
+		Event.xany.type == LeaveNotify) continue; 
+
+	    if (Event.type == MotionNotify) {
+		/* discard any extra motion events before a logical release */
+		while(XCheckMaskEvent(dpy,
+		    movementMask | releaseEvent, &Event))
+		    if (Event.type == releaseEvent)
+			break;
+	    }
+
+	    /* test to see if we have a second button press to abort move */
+	    if (!menuFromFrameOrWindowOrTitlebar &&  !MovedFromKeyPress) {
+	        if (Event.type == ButtonPress && DragWindow != None) {
+		    if (Scr->OpaqueMove)
+		      XMoveWindow (dpy, DragWindow, origDragX, origDragY);
+		    else
+		        MoveOutline(Scr->Root, 0, 0, 0, 0, 0, 0);
+		    DragWindow = None;
+                }
+	    }
+	    if (fromtitlebar && Event.type == ButtonPress) {
+		fromtitlebar = False;
+		CurrentDragX = origX = Event.xbutton.x_root;
+		CurrentDragY = origY = Event.xbutton.y_root;
+		XTranslateCoordinates (dpy, rootw, tmp_win->frame,
+				       origX, origY,
+				       &DragX, &DragY, &JunkChild);
+		continue;
+	    }
+
+	    if (!DispatchEvent2 ()) continue;
+
+	    if (Cancel)
+	    {
+		WindowMoved = FALSE;
+		if (!Scr->OpaqueMove)
+		    UninstallRootColormap();
+		    return TRUE;	/* XXX should this be FALSE? */
+	    }
+	    if (Event.type == releaseEvent)
+	    {
+		MoveOutline(rootw, 0, 0, 0, 0, 0, 0);
+		if (moving_icon &&
+		    ((CurrentDragX != origDragX ||
+		      CurrentDragY != origDragY)))
+		  tmp_win->icon_moved = TRUE;
+		if (!Scr->OpaqueMove && menuFromFrameOrWindowOrTitlebar)
+		  XMoveWindow(dpy, DragWindow, 
+			      Event.xbutton.x_root - DragWidth / 2,
+			      Event.xbutton.y_root - DragHeight / 2);
+		break;
+	    }
+
+	    /* something left to do only if the pointer moved */
+	    if (Event.type != MotionNotify)
+		continue;
+
+	    XQueryPointer(dpy, rootw, &(eventp->xmotion.root), &JunkChild,
+		&(eventp->xmotion.x_root), &(eventp->xmotion.y_root),
+		&JunkX, &JunkY, &JunkMask);
+
+	    if (DragWindow == None &&
+		abs(eventp->xmotion.x_root - origX) < Scr->MoveDelta &&
+	        abs(eventp->xmotion.y_root - origY) < Scr->MoveDelta)
+		continue;
+
+	    WindowMoved = TRUE;
+	    DragWindow = w;
+
+	    if (!Scr->NoRaiseMove && Scr->OpaqueMove)	/* can't restore... */
+	      XRaiseWindow(dpy, DragWindow);
+
+	    if (ConstMove)
+	    {
+		switch (ConstMoveDir)
+		{
+		    case MOVE_NONE:
+			if (eventp->xmotion.x_root < ConstMoveXL ||
+			    eventp->xmotion.x_root > ConstMoveXR)
+			    ConstMoveDir = MOVE_HORIZ;
+
+			if (eventp->xmotion.y_root < ConstMoveYT ||
+			    eventp->xmotion.y_root > ConstMoveYB)
+			    ConstMoveDir = MOVE_VERT;
+
+			XQueryPointer(dpy, DragWindow, &JunkRoot, &JunkChild,
+			    &JunkX, &JunkY, &DragX, &DragY, &JunkMask);
+			break;
+
+		    case MOVE_VERT:
+			ConstMoveY = eventp->xmotion.y_root - DragY - JunkBW;
+			break;
+
+		    case MOVE_HORIZ:
+			ConstMoveX= eventp->xmotion.x_root - DragX - JunkBW;
+			break;
+		}
+
+		if (ConstMoveDir != MOVE_NONE)
+		{
+		    int xl, yt, xr, yb, w, h;
+
+		    xl = ConstMoveX;
+		    yt = ConstMoveY;
+		    w = DragWidth + 2 * JunkBW;
+		    h = DragHeight + 2 * JunkBW;
+
+		    if (Scr->DontMoveOff && MoveFunction != F_FORCEMOVE)
+		    {
+			xr = xl + w;
+			yb = yt + h;
+
+			if (xl < 0)
+			    xl = 0;
+			if (xr > Scr->MyDisplayWidth)
+			    xl = Scr->MyDisplayWidth - w;
+
+			if (yt < 0)
+			    yt = 0;
+			if (yb > Scr->MyDisplayHeight)
+			    yt = Scr->MyDisplayHeight - h;
+		    }
+		    CurrentDragX = xl;
+		    CurrentDragY = yt;
+		    if (Scr->OpaqueMove)
+			XMoveWindow(dpy, DragWindow, xl, yt);
+		    else
+			MoveOutline(eventp->xmotion.root, xl, yt, w, h,
+			    tmp_win->frame_bw, 
+			    moving_icon ? 0 : tmp_win->title_height);
+		}
+	    }
+	    else if (DragWindow != None)
+	    {
+		int xl, yt, xr, yb, w, h;
+		if (!menuFromFrameOrWindowOrTitlebar) {
+		  xl = eventp->xmotion.x_root - DragX - JunkBW;
+		  yt = eventp->xmotion.y_root - DragY - JunkBW;
+		}
+		else {
+		  xl = eventp->xmotion.x_root - (DragWidth / 2);
+		  yt = eventp->xmotion.y_root - (DragHeight / 2);
+		}		  
+		w = DragWidth + 2 * JunkBW;
+		h = DragHeight + 2 * JunkBW;
+
+		if (Scr->DontMoveOff && MoveFunction != F_FORCEMOVE)
+		{
+		    xr = xl + w;
+		    yb = yt + h;
+
+		    if (xl < 0)
+			xl = 0;
+		    if (xr > Scr->MyDisplayWidth)
+			xl = Scr->MyDisplayWidth - w;
+
+		    if (yt < 0)
+			yt = 0;
+		    if (yb > Scr->MyDisplayHeight)
+			yt = Scr->MyDisplayHeight - h;
+		}
+
+		CurrentDragX = xl;
+		CurrentDragY = yt;
+		if (Scr->OpaqueMove)
+		    XMoveWindow(dpy, DragWindow, xl, yt);
+		else
+		    MoveOutline(eventp->xmotion.root, xl, yt, w, h,
+			tmp_win->frame_bw,
+			moving_icon ? 0 : tmp_win->title_height);
+	    }
+
+	}
+        MovedFromKeyPress = False;
+
+
+	if (!Scr->OpaqueMove && DragWindow == None)
+	    UninstallRootColormap();
+
+        break;
+
+    case F_FUNCTION:
+	{
+	    MenuRoot *mroot;
+	    MenuItem *mitem;
+
+	    if ((mroot = FindMenuRoot(action)) == NULL)
+	    {
+		fprintf (stderr, "%s: couldn't find function \"%s\"\n", 
+			 ProgramName, action);
+		return TRUE;
+	    }
+
+	    if (NeedToDefer(mroot) && DeferExecution(context, func, Scr->SelectCursor))
+		return TRUE;
+	    else
+	    {
+		for (mitem = mroot->first; mitem != NULL; mitem = mitem->next)
+		{
+		    if (!ExecuteFunction (mitem->func, mitem->action, w,
+					  tmp_win, eventp, context, pulldown))
+		      break;
+		}
+	    }
+	}
+	break;
+
+    case F_DEICONIFY:
+    case F_ICONIFY:
+	if (DeferExecution(context, func, Scr->SelectCursor))
+	    return TRUE;
+
+	if (tmp_win->icon)
+	{
+	    DeIconify(tmp_win);
+	}
+        else if (func == F_ICONIFY)
+	{
+	    Iconify (tmp_win, eventp->xbutton.x_root - 5,
+		     eventp->xbutton.y_root - 5);
+	}
+	break;
+
+    case F_RAISELOWER:
+	if (DeferExecution(context, func, Scr->SelectCursor))
+	    return TRUE;
+
+	if (!WindowMoved) {
+	    XWindowChanges xwc;
+
+	    xwc.stack_mode = Opposite;
+	    if (w != tmp_win->icon_w)
+	      w = tmp_win->frame;
+	    XConfigureWindow (dpy, w, CWStackMode, &xwc);
+	}
+	break;
+	
+    case F_RAISE:
+	if (DeferExecution(context, func, Scr->SelectCursor))
+	    return TRUE;
+
+	/* check to make sure raise is not from the WindowFunction */
+	if (w == tmp_win->icon_w && Context != C_ROOT) 
+	    XRaiseWindow(dpy, tmp_win->icon_w);
+	else
+	    XRaiseWindow(dpy, tmp_win->frame);
+
+	break;
+
+    case F_LOWER:
+	if (DeferExecution(context, func, Scr->SelectCursor))
+	    return TRUE;
+
+	if (w == tmp_win->icon_w)
+	    XLowerWindow(dpy, tmp_win->icon_w);
+	else
+	    XLowerWindow(dpy, tmp_win->frame);
+
+	break;
+
+    case F_FOCUS:
+	if (DeferExecution(context, func, Scr->SelectCursor))
+	    return TRUE;
+
+	if (tmp_win->icon == FALSE)
+	{
+	    if (!Scr->FocusRoot && Scr->Focus == tmp_win)
+	    {
+		FocusOnRoot();
+	    }
+	    else
+	    {
+		if (Scr->Focus != NULL) {
+		    SetBorder (Scr->Focus, False);
+		    if (Scr->Focus->hilite_w)
+		      XUnmapWindow (dpy, Scr->Focus->hilite_w);
+		}
+
+		InstallWindowColormaps (0, tmp_win);
+		if (tmp_win->hilite_w) XMapWindow (dpy, tmp_win->hilite_w);
+		SetBorder (tmp_win, True);
+		SetFocus (tmp_win, eventp->xbutton.time);
+		Scr->FocusRoot = FALSE;
+		Scr->Focus = tmp_win;
+	    }
+	}
+	break;
+
+    case F_DESTROY:
+	if (DeferExecution(context, func, Scr->DestroyCursor))
+	    return TRUE;
+
+	if (tmp_win->iconmgr)
+	    Bell(XkbBI_MinorError,0,tmp_win->w);
+	else
+	    XKillClient(dpy, tmp_win->w);
+	break;
+
+    case F_DELETE:
+	if (DeferExecution(context, func, Scr->DestroyCursor))
+	    return TRUE;
+
+	if (tmp_win->iconmgr)		/* don't send ourself a message */
+	  HideIconManager ();
+	else if (tmp_win->protocols & DoesWmDeleteWindow)
+	  SendDeleteWindowMessage (tmp_win, LastTimestamp());
+	else
+	  Bell(XkbBI_MinorError,0,tmp_win->w);
+	break;
+
+    case F_SAVEYOURSELF:
+	if (DeferExecution (context, func, Scr->SelectCursor))
+	  return TRUE;
+
+	if (tmp_win->protocols & DoesWmSaveYourself)
+	  SendSaveYourselfMessage (tmp_win, LastTimestamp());
+	else
+	  Bell(XkbBI_MinorError,0,tmp_win->w);
+	break;
+
+    case F_CIRCLEUP:
+	XCirculateSubwindowsUp(dpy, Scr->Root);
+	break;
+
+    case F_CIRCLEDOWN:
+	XCirculateSubwindowsDown(dpy, Scr->Root);
+	break;
+
+    case F_EXEC:
+	PopDownMenu();
+	if (!Scr->NoGrabServer) {
+	    XUngrabServer (dpy);
+	    XSync (dpy, 0);
+	}
+	Execute(action);
+	break;
+
+    case F_UNFOCUS:
+	FocusOnRoot();
+	break;
+
+    case F_CUT:
+	strcpy(tmp, action);
+	strcat(tmp, "\n");
+	XStoreBytes(dpy, tmp, strlen(tmp));
+	break;
+
+    case F_CUTFILE:
+	ptr = XFetchBytes(dpy, &count);
+	if (ptr) {
+	    if (sscanf (ptr, "%s", tmp) == 1) {
+		XFree (ptr);
+		ptr = ExpandFilename(tmp);
+		if (ptr) {
+		    fd = open (ptr, 0);
+		    if (fd >= 0) {
+			count = read (fd, buff, MAX_FILE_SIZE - 1);
+			if (count > 0) XStoreBytes (dpy, buff, count);
+			close(fd);
+		    } else {
+			fprintf (stderr, 
+				 "%s:  unable to open cut file \"%s\"\n", 
+				 ProgramName, tmp);
+		    }
+		    if (ptr != tmp) free (ptr);
+		} 
+	    } else {
+		XFree(ptr);
+	    }
+	} else {
+	    fprintf(stderr, "%s:  cut buffer is empty\n", ProgramName);
+	}
+	break;
+
+    case F_WARPTOSCREEN:
+	{
+	    if (strcmp (action, WARPSCREEN_NEXT) == 0) {
+		WarpToScreen (Scr->screen + 1, 1);
+	    } else if (strcmp (action, WARPSCREEN_PREV) == 0) {
+		WarpToScreen (Scr->screen - 1, -1);
+	    } else if (strcmp (action, WARPSCREEN_BACK) == 0) {
+		WarpToScreen (PreviousScreen, 0);
+	    } else {
+		WarpToScreen (atoi (action), 0);
+	    }
+	}
+	break;
+
+    case F_COLORMAP:
+	{
+	    if (strcmp (action, COLORMAP_NEXT) == 0) {
+		BumpWindowColormap (tmp_win, 1);
+	    } else if (strcmp (action, COLORMAP_PREV) == 0) {
+		BumpWindowColormap (tmp_win, -1);
+	    } else {
+		BumpWindowColormap (tmp_win, 0);
+	    }
+	}
+	break;
+
+    case F_WARPTO:
+	{
+	    register TwmWindow *t;
+	    int len;
+
+	    len = strlen(action);
+
+	    for (t = Scr->TwmRoot.next; t != NULL; t = t->next) {
+		if (!strncmp(action, t->name, len)) 
+                    if (WarpThere(t)) break;
+	    }
+	    if (!t) {
+		for (t = Scr->TwmRoot.next; t != NULL; t = t->next) {
+		    if (!strncmp(action, t->class.res_name, len)) 
+                        if (WarpThere(t)) break;
+		}
+		if (!t) {
+		    for (t = Scr->TwmRoot.next; t != NULL; t = t->next) {
+			if (!strncmp(action, t->class.res_class, len)) 
+                            if (WarpThere(t)) break;
+		    }
+		}
+	    }
+
+	    if (!t) 
+		Bell(XkbBI_MinorError,0,None);
+	}
+	break;
+
+    case F_WARPTOICONMGR:
+	{
+	    TwmWindow *t;
+	    int len;
+	    Window raisewin = None, iconwin = None;
+
+	    len = strlen(action);
+	    if (len == 0) {
+		if (tmp_win && tmp_win->list) {
+		    raisewin = tmp_win->list->iconmgr->twm_win->frame;
+		    iconwin = tmp_win->list->icon;
+		} else if (Scr->iconmgr.active) {
+		    raisewin = Scr->iconmgr.twm_win->frame;
+		    iconwin = Scr->iconmgr.active->w;
+		}
+	    } else {
+		for (t = Scr->TwmRoot.next; t != NULL; t = t->next) {
+		    if (strncmp (action, t->icon_name, len) == 0) {
+			if (t->list && t->list->iconmgr->twm_win->mapped) {
+			    raisewin = t->list->iconmgr->twm_win->frame;
+			    iconwin = t->list->icon;
+			    break;
+			}
+		    }
+		}
+	    }
+
+	    if (raisewin) {
+		XRaiseWindow (dpy, raisewin);
+		XWarpPointer (dpy, None, iconwin, 0,0,0,0, 5, 5);
+	    } else {
+		Bell(XkbBI_MinorError,0,None);
+	    }
+	}
+	break;
+	
+    case F_WARPRING:
+	switch (action[0]) {
+	  case 'n':
+	    WarpAlongRing (&eventp->xbutton, True);
+	    break;
+	  case 'p':
+	    WarpAlongRing (&eventp->xbutton, False);
+	    break;
+	  default:
+	    Bell(XkbBI_MinorError,0,None);
+	    break;
+	}
+	break;
+
+    case F_FILE:
+	action = ExpandFilename(action);
+	fd = open(action, 0);
+	if (fd >= 0)
+	{
+	    count = read(fd, buff, MAX_FILE_SIZE - 1);
+	    if (count > 0)
+		XStoreBytes(dpy, buff, count);
+
+	    close(fd);
+	}
+	else
+	{
+	    fprintf (stderr, "%s:  unable to open file \"%s\"\n", 
+		     ProgramName, action);
+	}
+	break;
+
+    case F_REFRESH:
+	{
+	    XSetWindowAttributes attributes;
+	    unsigned long valuemask;
+
+	    valuemask = (CWBackPixel | CWBackingStore | CWSaveUnder);
+	    attributes.background_pixel = Scr->Black;
+	    attributes.backing_store = NotUseful;
+	    attributes.save_under = False;
+	    w = XCreateWindow (dpy, Scr->Root, 0, 0,
+			       (unsigned int) Scr->MyDisplayWidth,
+			       (unsigned int) Scr->MyDisplayHeight,
+			       (unsigned int) 0,
+			       CopyFromParent, (unsigned int) CopyFromParent,
+			       (Visual *) CopyFromParent, valuemask,
+			       &attributes);
+	    XMapWindow (dpy, w);
+	    XDestroyWindow (dpy, w);
+	    XFlush (dpy);
+	}
+	break;
+
+    case F_WINREFRESH:
+	if (DeferExecution(context, func, Scr->SelectCursor))
+	    return TRUE;
+
+	if (context == C_ICON && tmp_win->icon_w)
+	    w = XCreateSimpleWindow(dpy, tmp_win->icon_w,
+		0, 0, 9999, 9999, 0, Scr->Black, Scr->Black);
+	else
+	    w = XCreateSimpleWindow(dpy, tmp_win->frame,
+		0, 0, 9999, 9999, 0, Scr->Black, Scr->Black);
+
+	XMapWindow(dpy, w);
+	XDestroyWindow(dpy, w);
+	XFlush(dpy);
+	break;
+
+    case F_QUIT:
+	Done();
+	break;
+
+    case F_PRIORITY:
+	if (HasSync)
+	{
+	    if (DeferExecution (context, func, Scr->SelectCursor))
+		return TRUE;
+	    (void)XSyncSetPriority(dpy, tmp_win->w, atoi(action));
+        }
+	break;
+    }
+
+    if (ButtonPressed == -1) XUngrabPointer(dpy, CurrentTime);
+    return do_next_action;
+}
+
+
+
+/***********************************************************************
+ *
+ *  Procedure:
+ *	DeferExecution - defer the execution of a function to the
+ *	    next button press if the context is C_ROOT
+ *
+ *  Inputs:
+ *	context	- the context in which the mouse button was pressed
+ *	func	- the function to defer
+ *	cursor	- the cursor to display while waiting
+ *
+ ***********************************************************************
+ */
+
+int
+DeferExecution(context, func, cursor)
+int context, func;
+Cursor cursor;
+{
+  if (context == C_ROOT)
+    {
+	LastCursor = cursor;
+	XGrabPointer(dpy, Scr->Root, True,
+	    ButtonPressMask | ButtonReleaseMask,
+	    GrabModeAsync, GrabModeAsync,
+	    Scr->Root, cursor, CurrentTime);
+
+	RootFunction = func;
+
+	return (TRUE);
+    }
+    
+    return (FALSE);
+}
+
+
+
+/***********************************************************************
+ *
+ *  Procedure:
+ *	ReGrab - regrab the pointer with the LastCursor;
+ *
+ ***********************************************************************
+ */
+
+ReGrab()
+{
+    XGrabPointer(dpy, Scr->Root, True,
+	ButtonPressMask | ButtonReleaseMask,
+	GrabModeAsync, GrabModeAsync,
+	Scr->Root, LastCursor, CurrentTime);
+}
+
+
+
+/***********************************************************************
+ *
+ *  Procedure:
+ *	NeedToDefer - checks each function in the list to see if it
+ *		is one that needs to be defered.
+ *
+ *  Inputs:
+ *	root	- the menu root to check
+ *
+ ***********************************************************************
+ */
+
+NeedToDefer(root)
+MenuRoot *root;
+{
+    MenuItem *mitem;
+
+    for (mitem = root->first; mitem != NULL; mitem = mitem->next)
+    {
+	switch (mitem->func)
+	{
+	case F_IDENTIFY:
+	case F_RESIZE:
+	case F_MOVE:
+	case F_FORCEMOVE:
+	case F_DEICONIFY:
+	case F_ICONIFY:
+	case F_RAISELOWER:
+	case F_RAISE:
+	case F_LOWER:
+	case F_FOCUS:
+	case F_DESTROY:
+	case F_WINREFRESH:
+	case F_ZOOM:
+	case F_FULLZOOM:
+	case F_HORIZOOM:
+        case F_RIGHTZOOM:
+        case F_LEFTZOOM:
+        case F_TOPZOOM:
+        case F_BOTTOMZOOM:
+	case F_AUTORAISE:
+	    return TRUE;
+	}
+    }
+    return FALSE;
+}
+
+
+
+/***********************************************************************
+ *
+ *  Procedure:
+ *	Execute - execute the string by /bin/sh
+ *
+ *  Inputs:
+ *	s	- the string containing the command
+ *
+ ***********************************************************************
+ */
+
+#if defined(sun) && defined(SVR4)
+static int System (s)
+    char *s;
+{
+    int pid, status;
+    if ((pid = fork ()) == 0) {
+	(void) setpgrp();
+	execl ("/bin/sh", "sh", "-c", s, 0);
+    } else
+	waitpid (pid, &status, 0);
+    return status;
+}
+#define system(s) System(s)
+#endif
+
+void
+Execute(s)
+    char *s;
+{
+    static char buf[256];
+    char *ds = DisplayString (dpy);
+    char *colon, *dot1;
+    char oldDisplay[256];
+    char *doisplay;
+    int restorevar = 0;
+
+    oldDisplay[0] = '\0';
+    doisplay=getenv("DISPLAY");
+    if (doisplay)
+	strcpy (oldDisplay, doisplay);
+
+    /*
+     * Build a display string using the current screen number, so that
+     * X programs which get fired up from a menu come up on the screen
+     * that they were invoked from, unless specifically overridden on
+     * their command line.
+     */
+    colon = strrchr (ds, ':');
+    if (colon) {			/* if host[:]:dpy */
+	strcpy (buf, "DISPLAY=");
+	strcat (buf, ds);
+	colon = buf + 8 + (colon - ds);	/* use version in buf */
+	dot1 = strchr (colon, '.');	/* first period after colon */
+	if (!dot1) dot1 = colon + strlen (colon);  /* if not there, append */
+	(void) sprintf (dot1, ".%d", Scr->screen);
+	putenv (buf);
+	restorevar = 1;
+    }
+
+    (void) system (s);
+
+    if (restorevar) {		/* why bother? */
+	(void) sprintf (buf, "DISPLAY=%s", oldDisplay);
+	putenv (buf);
+    }
+}
+
+
+
+/***********************************************************************
+ *
+ *  Procedure:
+ *	FocusOnRoot - put input focus on the root window
+ *
+ ***********************************************************************
+ */
+
+void
+FocusOnRoot()
+{
+    SetFocus ((TwmWindow *) NULL, LastTimestamp());
+    if (Scr->Focus != NULL)
+    {
+	SetBorder (Scr->Focus, False);
+	if (Scr->Focus->hilite_w) XUnmapWindow (dpy, Scr->Focus->hilite_w);
+    }
+    InstallWindowColormaps(0, &Scr->TwmRoot);
+    Scr->Focus = NULL;
+    Scr->FocusRoot = TRUE;
+}
+
+DeIconify(tmp_win)
+TwmWindow *tmp_win;
+{
+    TwmWindow *t;
+
+    /* de-iconify the main window */
+    if (tmp_win->icon)
+    {
+	if (tmp_win->icon_on)
+	    Zoom(tmp_win->icon_w, tmp_win->frame);
+	else if (tmp_win->group != (Window) 0)
+	{
+	    for (t = Scr->TwmRoot.next; t != NULL; t = t->next)
+	    {
+		if (tmp_win->group == t->w && t->icon_on)
+		{
+		    Zoom(t->icon_w, tmp_win->frame);
+		    break;
+		}
+	    }
+	}
+    }
+
+    XMapWindow(dpy, tmp_win->w);
+    tmp_win->mapped = TRUE;
+    if (Scr->NoRaiseDeicon)
+	XMapWindow(dpy, tmp_win->frame);
+    else
+	XMapRaised(dpy, tmp_win->frame);
+    SetMapStateProp(tmp_win, NormalState);
+
+    if (tmp_win->icon_w) {
+	XUnmapWindow(dpy, tmp_win->icon_w);
+	IconDown (tmp_win);
+    }
+    if (tmp_win->list)
+	XUnmapWindow(dpy, tmp_win->list->icon);
+    if ((Scr->WarpCursor ||
+	 LookInList(Scr->WarpCursorL, tmp_win->full_name, &tmp_win->class)) &&
+	tmp_win->icon)
+      WarpToWindow (tmp_win);
+    tmp_win->icon = FALSE;
+    tmp_win->icon_on = FALSE;
+
+
+    /* now de-iconify transients */
+	for (t = Scr->TwmRoot.next; t != NULL; t = t->next)
+	{
+	  if (t->transient && t->transientfor == tmp_win->w)
+	    {
+	      if (t->icon_on)
+		Zoom(t->icon_w, t->frame);
+	      else
+		Zoom(tmp_win->icon_w, t->frame);
+	      
+	      XMapWindow(dpy, t->w);
+	      t->mapped = TRUE;
+	      if (Scr->NoRaiseDeicon)
+		XMapWindow(dpy, t->frame);
+	      else
+		XMapRaised(dpy, t->frame);
+	      SetMapStateProp(t, NormalState);
+	      
+	      if (t->icon_w) {
+		XUnmapWindow(dpy, t->icon_w);
+		IconDown (t);
+	      }
+	      if (t->list) XUnmapWindow(dpy, t->list->icon);
+	      t->icon = FALSE;
+	      t->icon_on = FALSE;
+	    }
+	}
+    
+    XSync (dpy, 0);
+}
+
+
+
+Iconify(tmp_win, def_x, def_y)
+TwmWindow *tmp_win;
+int def_x, def_y;
+{
+    TwmWindow *t;
+    int iconify;
+    XWindowAttributes winattrs;
+    unsigned long eventMask;
+
+    iconify = ((!tmp_win->iconify_by_unmapping) || tmp_win->transient);
+    if (iconify)
+    {
+	if (tmp_win->icon_w == (Window) 0)
+	    CreateIconWindow(tmp_win, def_x, def_y);
+	else
+	    IconUp(tmp_win);
+	XMapRaised(dpy, tmp_win->icon_w);
+    }
+    if (tmp_win->list)
+	XMapWindow(dpy, tmp_win->list->icon);
+
+    XGetWindowAttributes(dpy, tmp_win->w, &winattrs);
+    eventMask = winattrs.your_event_mask;
+
+    /* iconify transients first */
+    for (t = Scr->TwmRoot.next; t != NULL; t = t->next)
+      {
+	if (t->transient && t->transientfor == tmp_win->w)
+	  {
+	    if (iconify)
+	      {
+		if (t->icon_on)
+			Zoom(t->icon_w, tmp_win->icon_w);
+		else
+		  Zoom(t->frame, tmp_win->icon_w);
+	      }
+	    
+	    /*
+	     * Prevent the receipt of an UnmapNotify, since that would
+	     * cause a transition to the Withdrawn state.
+	     */
+	    t->mapped = FALSE;
+	    XSelectInput(dpy, t->w, eventMask & ~StructureNotifyMask);
+	    XUnmapWindow(dpy, t->w);
+	    XSelectInput(dpy, t->w, eventMask);
+	    XUnmapWindow(dpy, t->frame);
+	    if (t->icon_w)
+	      XUnmapWindow(dpy, t->icon_w);
+	    SetMapStateProp(t, IconicState);
+	    SetBorder (t, False);
+	    if (t == Scr->Focus)
+	      {
+		SetFocus ((TwmWindow *) NULL, LastTimestamp());
+		Scr->Focus = NULL;
+		Scr->FocusRoot = TRUE;
+	      }
+	    if (t->list) XMapWindow(dpy, t->list->icon);
+	    t->icon = TRUE;
+	    t->icon_on = FALSE;
+	  }
+      } 
+    
+    if (iconify)
+	Zoom(tmp_win->frame, tmp_win->icon_w);
+
+    /*
+     * Prevent the receipt of an UnmapNotify, since that would
+     * cause a transition to the Withdrawn state.
+     */
+    tmp_win->mapped = FALSE;
+    XSelectInput(dpy, tmp_win->w, eventMask & ~StructureNotifyMask);
+    XUnmapWindow(dpy, tmp_win->w);
+    XSelectInput(dpy, tmp_win->w, eventMask);
+    XUnmapWindow(dpy, tmp_win->frame);
+    SetMapStateProp(tmp_win, IconicState);
+
+    SetBorder (tmp_win, False);
+    if (tmp_win == Scr->Focus)
+    {
+	SetFocus ((TwmWindow *) NULL, LastTimestamp());
+	Scr->Focus = NULL;
+	Scr->FocusRoot = TRUE;
+    }
+    tmp_win->icon = TRUE;
+    if (iconify)
+	tmp_win->icon_on = TRUE;
+    else
+	tmp_win->icon_on = FALSE;
+    XSync (dpy, 0);
+}
+
+
+
+static void Identify (t)
+TwmWindow *t;
+{
+    int i, n, twidth, width, height;
+    int x, y;
+    unsigned int wwidth, wheight, bw, depth;
+    Window junk;
+    int px, py, dummy;
+    unsigned udummy;
+
+    n = 0;
+    (void) sprintf(Info[n++], "Twm version:  %s", Version);
+    Info[n++][0] = '\0';
+
+    if (t) {
+	XGetGeometry (dpy, t->w, &JunkRoot, &JunkX, &JunkY,
+		      &wwidth, &wheight, &bw, &depth);
+	(void) XTranslateCoordinates (dpy, t->w, Scr->Root, 0, 0,
+				      &x, &y, &junk);
+	(void) sprintf(Info[n++], "Name             = \"%s\"", t->full_name);
+	(void) sprintf(Info[n++], "Class.res_name   = \"%s\"", t->class.res_name);
+	(void) sprintf(Info[n++], "Class.res_class  = \"%s\"", t->class.res_class);
+	Info[n++][0] = '\0';
+	(void) sprintf(Info[n++], "Geometry/root    = %dx%d+%d+%d", wwidth, wheight,
+		x, y);
+	(void) sprintf(Info[n++], "Border width     = %d", bw);
+	(void) sprintf(Info[n++], "Depth            = %d", depth);
+	if (HasSync)
+	{
+	    int priority;
+	    (void)XSyncGetPriority(dpy, t->w, &priority);
+	    (void) sprintf(Info[n++], "Priority         = %d", priority);
+	}
+    }
+
+    Info[n++][0] = '\0';
+    (void) sprintf(Info[n++], "Click to dismiss....");
+
+    /* figure out the width and height of the info window */
+    height = n * (Scr->DefaultFont.height+2);
+    width = 1;
+    for (i = 0; i < n; i++)
+    {
+	twidth = XTextWidth(Scr->DefaultFont.font, Info[i],
+	    strlen(Info[i]));
+	if (twidth > width)
+	    width = twidth;
+    }
+    if (InfoLines) XUnmapWindow(dpy, Scr->InfoWindow);
+
+    width += 10;		/* some padding */
+    if (XQueryPointer (dpy, Scr->Root, &JunkRoot, &JunkChild, &px, &py,
+		       &dummy, &dummy, &udummy)) {
+	px -= (width / 2);
+	py -= (height / 3);
+	if (px + width + BW2 >= Scr->MyDisplayWidth) 
+	  px = Scr->MyDisplayWidth - width - BW2;
+	if (py + height + BW2 >= Scr->MyDisplayHeight) 
+	  py = Scr->MyDisplayHeight - height - BW2;
+	if (px < 0) px = 0;
+	if (py < 0) py = 0;
+    } else {
+	px = py = 0;
+    }
+    XMoveResizeWindow(dpy, Scr->InfoWindow, px, py, width, height);
+    XMapRaised(dpy, Scr->InfoWindow); 
+    InfoLines = n;
+}
+
+
+
+SetMapStateProp(tmp_win, state)
+TwmWindow *tmp_win;
+int state;
+{
+    unsigned long data[2];		/* "suggested" by ICCCM version 1 */
+  
+    data[0] = (unsigned long) state;
+    data[1] = (unsigned long) (tmp_win->iconify_by_unmapping ? None : 
+			   tmp_win->icon_w);
+
+    XChangeProperty (dpy, tmp_win->w, _XA_WM_STATE, _XA_WM_STATE, 32, 
+		 PropModeReplace, (unsigned char *) data, 2);
+}
+
+
+
+Bool GetWMState (w, statep, iwp)
+    Window w;
+    int *statep;
+    Window *iwp;
+{
+    Atom actual_type;
+    int actual_format;
+    unsigned long nitems, bytesafter;
+    unsigned long *datap = NULL;
+    Bool retval = False;
+
+    if (XGetWindowProperty (dpy, w, _XA_WM_STATE, 0L, 2L, False, _XA_WM_STATE,
+			    &actual_type, &actual_format, &nitems, &bytesafter,
+			    (unsigned char **) &datap) != Success || !datap)
+      return False;
+
+    if (nitems <= 2) {			/* "suggested" by ICCCM version 1 */
+	*statep = (int) datap[0];
+	*iwp = (Window) datap[1];
+	retval = True;
+    }
+
+    XFree ((char *) datap);
+    return retval;
+}
+
+
+
+WarpToScreen (n, inc)
+    int n, inc;
+{
+    Window dumwin;
+    int x, y, dumint;
+    unsigned int dummask;
+    ScreenInfo *newscr = NULL;
+
+    while (!newscr) {
+					/* wrap around */
+	if (n < 0) 
+	  n = NumScreens - 1;
+	else if (n >= NumScreens)
+	  n = 0;
+
+	newscr = ScreenList[n];
+	if (!newscr) {			/* make sure screen is managed */
+	    if (inc) {			/* walk around the list */
+		n += inc;
+		continue;
+	    }
+	    fprintf (stderr, "%s:  unable to warp to unmanaged screen %d\n", 
+		     ProgramName, n);
+	    Bell(XkbBI_MinorError,0,None);
+	    return;
+	}
+    }
+
+    if (Scr->screen == n) return;	/* already on that screen */
+
+    PreviousScreen = Scr->screen;
+    XQueryPointer (dpy, Scr->Root, &dumwin, &dumwin, &x, &y,
+		   &dumint, &dumint, &dummask);
+
+    XWarpPointer (dpy, None, newscr->Root, 0, 0, 0, 0, x, y);
+    return;
+}
+
+
+
+
+/*
+ * BumpWindowColormap - rotate our internal copy of WM_COLORMAP_WINDOWS
+ */
+
+BumpWindowColormap (tmp, inc)
+    TwmWindow *tmp;
+    int inc;
+{
+    int i, j, previously_installed;
+    ColormapWindow **cwins;
+
+    if (!tmp) return;
+
+    if (inc && tmp->cmaps.number_cwins > 0) {
+	cwins = (ColormapWindow **) malloc(sizeof(ColormapWindow *)*
+					   tmp->cmaps.number_cwins);
+	if (cwins) {		
+	    if ((previously_installed =
+		/* SUPPRESS 560 */(Scr->cmapInfo.cmaps == &tmp->cmaps &&
+	        tmp->cmaps.number_cwins))) {
+		for (i = tmp->cmaps.number_cwins; i-- > 0; )
+		    tmp->cmaps.cwins[i]->colormap->state = 0;
+	    }
+
+	    for (i = 0; i < tmp->cmaps.number_cwins; i++) {
+		j = i - inc;
+		if (j >= tmp->cmaps.number_cwins)
+		    j -= tmp->cmaps.number_cwins;
+		else if (j < 0)
+		    j += tmp->cmaps.number_cwins;
+		cwins[j] = tmp->cmaps.cwins[i];
+	    }
+
+	    free((char *) tmp->cmaps.cwins);
+
+	    tmp->cmaps.cwins = cwins;
+
+	    if (tmp->cmaps.number_cwins > 1)
+		bzero (tmp->cmaps.scoreboard, 
+		       ColormapsScoreboardLength(&tmp->cmaps));
+
+	    if (previously_installed)
+		InstallWindowColormaps(PropertyNotify, (TwmWindow *) NULL);
+	}
+    } else
+	FetchWmColormapWindows (tmp);
+}
+
+
+
+HideIconManager ()
+{
+    SetMapStateProp (Scr->iconmgr.twm_win, WithdrawnState);
+    XUnmapWindow(dpy, Scr->iconmgr.twm_win->frame);
+    if (Scr->iconmgr.twm_win->icon_w)
+      XUnmapWindow (dpy, Scr->iconmgr.twm_win->icon_w);
+    Scr->iconmgr.twm_win->mapped = FALSE;
+    Scr->iconmgr.twm_win->icon = TRUE;
+}
+
+
+
+
+SetBorder (tmp, onoroff)
+    TwmWindow *tmp;
+    Bool onoroff;
+{
+    if (tmp->highlight) {
+	if (onoroff) {
+	    XSetWindowBorder (dpy, tmp->frame, tmp->border);
+	    if (tmp->title_w) 
+	      XSetWindowBorder (dpy, tmp->title_w, tmp->border);
+	} else {
+	    XSetWindowBorderPixmap (dpy, tmp->frame, tmp->gray);
+	    if (tmp->title_w) 
+	      XSetWindowBorderPixmap (dpy, tmp->title_w, tmp->gray);
+	}
+    }
+}
+
+
+
+DestroyMenu (menu)
+    MenuRoot *menu;
+{
+    MenuItem *item;
+
+    if (menu->w) {
+	XDeleteContext (dpy, menu->w, MenuContext);
+	XDeleteContext (dpy, menu->w, ScreenContext);
+	if (Scr->Shadow) XDestroyWindow (dpy, menu->shadow);
+	XDestroyWindow(dpy, menu->w);
+    }
+
+    for (item = menu->first; item; ) {
+	MenuItem *tmp = item;
+	item = item->next;
+	free ((char *) tmp);
+    }
+}
+
+
+
+/*
+ * warping routines
+ */
+void WarpAlongRing (ev, forward)
+    XButtonEvent *ev;
+    Bool forward;
+{
+    TwmWindow *r, *head;
+
+    if (Scr->RingLeader)
+      head = Scr->RingLeader;
+    else if (!(head = Scr->Ring)) 
+      return;
+
+    if (forward) {
+	for (r = head->ring.next; r != head; r = r->ring.next) {
+	    if (!r || r->mapped) break;
+	}
+    } else {
+	for (r = head->ring.prev; r != head; r = r->ring.prev) {
+	    if (!r || r->mapped) break;
+	}
+    }
+
+    if (r && r != head) {
+	TwmWindow *p = Scr->RingLeader, *t;
+
+	Scr->RingLeader = r;
+	WarpToWindow (r);
+
+	if (p && p->mapped &&
+	    XFindContext (dpy, ev->window, TwmContext, (caddr_t *)&t) == XCSUCCESS &&
+	    p == t) {
+	    p->ring.cursor_valid = True;
+	    p->ring.curs_x = ev->x_root - t->frame_x;
+	    p->ring.curs_y = ev->y_root - t->frame_y;
+	    if (p->ring.curs_x < -p->frame_bw || 
+		p->ring.curs_x >= p->frame_width + p->frame_bw ||
+		p->ring.curs_y < -p->frame_bw || 
+		p->ring.curs_y >= p->frame_height + p->frame_bw) {
+		/* somehow out of window */
+		p->ring.curs_x = p->frame_width / 2;
+		p->ring.curs_y = p->frame_height / 2;
+	    }
+	}
+    }
+}
+
+
+
+void WarpToWindow (t)
+    TwmWindow *t;
+{
+    int x, y;
+
+    if (t->auto_raise || !Scr->NoRaiseWarp) AutoRaiseWindow (t);
+    if (t->ring.cursor_valid) {
+	x = t->ring.curs_x;
+	y = t->ring.curs_y;
+    } else {
+	x = t->frame_width / 2;
+	y = t->frame_height / 2;
+    }
+    XWarpPointer (dpy, None, t->frame, 0, 0, 0, 0, x, y);
+}
+
+
+
+
+/*
+ * ICCCM Client Messages - Section 4.2.8 of the ICCCM dictates that all
+ * client messages will have the following form:
+ *
+ *     event type	ClientMessage
+ *     message type	_XA_WM_PROTOCOLS
+ *     window		tmp->w
+ *     format		32
+ *     data[0]		message atom
+ *     data[1]		time stamp
+ */
+static void send_clientmessage (w, a, timestamp)
+    Window w;
+    Atom a;
+    Time timestamp;
+{
+    XClientMessageEvent ev;
+
+    ev.type = ClientMessage;
+    ev.window = w;
+    ev.message_type = _XA_WM_PROTOCOLS;
+    ev.format = 32;
+    ev.data.l[0] = a;
+    ev.data.l[1] = timestamp;
+    XSendEvent (dpy, w, False, 0L, (XEvent *) &ev);
+}
+
+SendDeleteWindowMessage (tmp, timestamp)
+    TwmWindow *tmp;
+    Time timestamp;
+{
+    send_clientmessage (tmp->w, _XA_WM_DELETE_WINDOW, timestamp);
+}
+
+SendSaveYourselfMessage (tmp, timestamp)
+    TwmWindow *tmp;
+    Time timestamp;
+{
+    send_clientmessage (tmp->w, _XA_WM_SAVE_YOURSELF, timestamp);
+}
+
+
+SendTakeFocusMessage (tmp, timestamp)
+    TwmWindow *tmp;
+    Time timestamp;
+{
+    send_clientmessage (tmp->w, _XA_WM_TAKE_FOCUS, timestamp);
+}