/*****************************************************************************/
/**       Copyright 1988 by Evans & Sutherland Computer Corporation,        **/
/**                          Salt Lake City, Utah                           **/
/**  Portions Copyright 1989 by the Massachusetts Institute of Technology   **/
/**                        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    **/
/**    names of Evans & Sutherland and M.I.T. not be used in advertising    **/
/**    in publicity pertaining to distribution of the  software  without    **/
/**    specific, written prior permission.                                  **/
/**                                                                         **/
/**    EVANS & SUTHERLAND AND M.I.T. DISCLAIM ALL WARRANTIES WITH REGARD    **/
/**    TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES  OF  MERCHANT-    **/
/**    ABILITY  AND  FITNESS,  IN  NO  EVENT SHALL EVANS & SUTHERLAND OR    **/
/**    M.I.T. 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.                                     **/
/*****************************************************************************/


/***********************************************************************
 *
 * $XConsortium: resize.c,v 1.80 91/05/11 17:35:42 dave Exp $
 *
 * window resizing borrowed from the "wm" window manager
 *
 * 11-Dec-87 Thomas E. LaStrange                File created
 *
 ***********************************************************************/

#include <stdio.h>
#include "twm.h"
#include "parse.h"
#include "util.h"
#include "resize.h"
#include "add_window.h"
#include "screen.h"
#include "desktop.h"
#include "events.h"
#include "menus.h"

#define MINHEIGHT 0     /* had been 32 */
#define MINWIDTH 0      /* had been 60 */

static int dragx;       /* all these variables are used */
static int dragy;       /* in resize operations */
static int dragWidth;
static int dragHeight;

int origx;
int origy;
int origWidth;
int origHeight;

static int clampTop;
static int clampBottom;
static int clampLeft;
static int clampRight;
static int clampDX;
static int clampDY;

static int last_width;
static int last_height;

static int resize_context;

/* set in menus.c:ExecuteFunction(), cleared in *EndResize() - djhjr - 9/5/98 */
int resizing_window = 0;

/* djhjr - 4/6/98 */
void PaintBorderAndTitlebar();

/* djhjr - 4/17/98 */
static void DoVirtualMoveResize();

/* djhjr - 9/10/99 */
void ResizeTwmWindowContents();

/* djhjr - 9/13/02 */
static void SetVirtualDesktopIncrs();
static void EndResizeAdjPointer();

static void do_auto_clamp (tmp_win, evp)
    TwmWindow *tmp_win;
    XEvent *evp;
{
    Window junkRoot;
    int x, y, h, v, junkbw;
    unsigned int junkMask;

    switch (evp->type) {
      case ButtonPress:
	x = evp->xbutton.x_root;
	y = evp->xbutton.y_root;
	break;
      case KeyPress:
	x = evp->xkey.x_root;
	y = evp->xkey.y_root;
	break;
      default:
	if (!XQueryPointer (dpy, Scr->Root, &junkRoot, &junkRoot,
			    &x, &y, &junkbw, &junkbw, &junkMask))
	  return;
    }

    h = ((x - dragx) / (dragWidth < 3 ? 1 : (dragWidth / 3)));
    v = ((y - dragy - tmp_win->title_height) /
	 (dragHeight < 3 ? 1 : (dragHeight / 3)));

    if (h <= 0) {
	clampLeft = 1;
	clampDX = (x - dragx);
    } else if (h >= 2) {
	clampRight = 1;
	clampDX = (x - dragx - dragWidth);
    }

    if (v <= 0) {
	clampTop = 1;
	clampDY = (y - dragy);
    } else if (v >= 2) {
	clampBottom = 1;
	clampDY = (y - dragy - dragHeight);
    }
}


/***********************************************************************
 *
 *  Procedure:
 *      StartResize - begin a window resize operation
 *
 *  Inputs:
 *      ev      - the event structure (button press)
 *      tmp_win - the TwmWindow pointer
 *      fromtitlebar - action invoked from titlebar button
 *
 ***********************************************************************
 */

void
StartResize(evp, tmp_win, fromtitlebar, context)
XEvent *evp;
TwmWindow *tmp_win;
Bool fromtitlebar;
int context;
{
    Window      junkRoot;
    unsigned int junkbw, junkDepth;

    resize_context = context;

    SetVirtualDesktopIncrs(tmp_win);	/* djhjr - 9/13/02 */

    if (context == C_VIRTUAL_WIN)
	    ResizeWindow = tmp_win->VirtualDesktopDisplayWindow;
    else
	    ResizeWindow = tmp_win->frame;

/* djhjr - 7/17/98
	* djhjr - 4/15/98 *
	if (!Scr->NoGrabServer)
*/
	{
		/* added test - djhjr - 4/7/98 */
		if (!tmp_win->opaque_resize)
			XGrabServer(dpy);
	}
    if (context == C_VIRTUAL_WIN)
	    XGrabPointer(dpy, Scr->VirtualDesktopDisplay, True,
			 ButtonPressMask | ButtonReleaseMask |
			 ButtonMotionMask | PointerMotionHintMask,
			 GrabModeAsync, GrabModeAsync,
			 Scr->Root, Scr->ResizeCursor, CurrentTime);
    else
	    XGrabPointer(dpy, Scr->Root, True,
			 ButtonPressMask | ButtonReleaseMask |
			 ButtonMotionMask | PointerMotionHintMask,
			 GrabModeAsync, GrabModeAsync,
			 Scr->Root, Scr->ResizeCursor, CurrentTime);

    XGetGeometry(dpy, (Drawable) ResizeWindow, &junkRoot,
        &dragx, &dragy, (unsigned int *)&dragWidth, (unsigned int *)&dragHeight, &junkbw,
                 &junkDepth);

    if (context != C_VIRTUAL_WIN) {
	    dragx += tmp_win->frame_bw;
	    dragy += tmp_win->frame_bw;
    }
    origx = dragx;
    origy = dragy;
    origWidth = dragWidth;
    origHeight = dragHeight;
    clampTop = clampBottom = clampLeft = clampRight = clampDX = clampDY = 0;

    if (Scr->AutoRelativeResize && !fromtitlebar)
      do_auto_clamp (tmp_win, evp);

/* use initialized size... djhjr - 5/9/96
	Scr->SizeStringOffset = SIZE_HINDENT;
    XResizeWindow (dpy, Scr->SizeWindow,
		   Scr->SizeStringWidth + SIZE_HINDENT * 2,
		   Scr->SizeFont.height + SIZE_VINDENT * 2);
*/

    XMapRaised(dpy, Scr->SizeWindow);
    if (!tmp_win->opaque_resize) InstallRootColormap();
    last_width = 0;
    last_height = 0;
    DisplaySize(tmp_win, origWidth, origHeight);

    if (resize_context == C_VIRTUAL_WIN)
	    MoveOutline (Scr->VirtualDesktopDisplay, dragx,
			 dragy, dragWidth,
			 dragHeight,
			 tmp_win->frame_bw, 0);
    else
	/* added this 'if ... else' - djhjr - 4/6/98 */
	if (tmp_win->opaque_resize)
	{
		SetupWindow (tmp_win,
			dragx - tmp_win->frame_bw, dragy - tmp_win->frame_bw,
			dragWidth, dragHeight, -1);
		PaintBorderAndTitlebar(tmp_win);
	}
	else
	    MoveOutline (Scr->Root, dragx - tmp_win->frame_bw,
			 dragy - tmp_win->frame_bw, dragWidth + 2 * tmp_win->frame_bw,
			 dragHeight + 2 * tmp_win->frame_bw,
/* djhjr - 4/24/96
			 tmp_win->frame_bw, tmp_win->title_height);
*/
		tmp_win->frame_bw, tmp_win->title_height + tmp_win->frame_bw3D);
}



/* added the passed 'context' - djhjr - 2/22/99 */
void
MenuStartResize(tmp_win, x, y, w, h, context)
TwmWindow *tmp_win;
int x, y, w, h;
int context;
{
	/* djhjr - 2/22/99 */
	resize_context = context;

    SetVirtualDesktopIncrs(tmp_win);	/* djhjr - 9/13/02 */

/* djhjr - 7/17/98
	* djhjr - 4/15/98 *
	if (!Scr->NoGrabServer)
*/
	{
		/* added test - djhjr - 4/7/98 */
		if (!tmp_win->opaque_resize)
			XGrabServer(dpy);
	}
    XGrabPointer(dpy, Scr->Root, True,
        ButtonPressMask | ButtonMotionMask | PointerMotionMask,
        GrabModeAsync, GrabModeAsync,
        Scr->Root, Scr->ResizeCursor, CurrentTime);
    dragx = x + tmp_win->frame_bw;
    dragy = y + tmp_win->frame_bw;
    origx = dragx;
    origy = dragy;
    dragWidth = origWidth = w; /* - 2 * tmp_win->frame_bw; */
    dragHeight = origHeight = h; /* - 2 * tmp_win->frame_bw; */
    clampTop = clampBottom = clampLeft = clampRight = clampDX = clampDY = 0;
    last_width = 0;
    last_height = 0;

/* use initialized size... djhjr - 5/9/96
    Scr->SizeStringOffset = SIZE_HINDENT;
    XResizeWindow (dpy, Scr->SizeWindow,
		   Scr->SizeStringWidth + SIZE_HINDENT * 2,
		   Scr->SizeFont.height + SIZE_VINDENT * 2);
*/

    XMapRaised(dpy, Scr->SizeWindow);
    if (!tmp_win->opaque_resize) InstallRootColormap();
    DisplaySize(tmp_win, origWidth, origHeight);

	/* added this 'if ... else' - djhjr - 4/6/98 */
	if (tmp_win->opaque_resize)
	{
		SetupWindow (tmp_win,
			dragx - tmp_win->frame_bw, dragy - tmp_win->frame_bw,
			dragWidth, dragHeight, -1);
		PaintBorderAndTitlebar(tmp_win);
	}
	else
    MoveOutline (Scr->Root, dragx - tmp_win->frame_bw,
		 dragy - tmp_win->frame_bw,
		 dragWidth + 2 * tmp_win->frame_bw,
		 dragHeight + 2 * tmp_win->frame_bw,
/* djhjr - 4/23/96
		 tmp_win->frame_bw, tmp_win->title_height);
*/
		 tmp_win->frame_bw, tmp_win->title_height + tmp_win->frame_bw3D);
}

/***********************************************************************
 *
 *  Procedure:
 *      AddStartResize - begin a windorew resize operation from AddWindow
 *
 *  Inputs:
 *      tmp_win - the TwmWindow pointer
 *
 ***********************************************************************
 */

void
AddStartResize(tmp_win, x, y, w, h)
TwmWindow *tmp_win;
int x, y, w, h;
{
	/* djhjr - 2/22/99 */
	resize_context = C_WINDOW;

    SetVirtualDesktopIncrs(tmp_win);	/* djhjr - 9/13/02 */

/* djhjr - 7/17/98
	* djhjr - 4/15/98 *
	if (!Scr->NoGrabServer)
*/
	{
		/* added test - djhjr - 4/7/98 */
		if (!tmp_win->opaque_resize)
			XGrabServer(dpy);
	}

    XGrabPointer(dpy, Scr->Root, True,
        ButtonReleaseMask | ButtonMotionMask | PointerMotionHintMask,
        GrabModeAsync, GrabModeAsync,
        Scr->Root, Scr->ResizeCursor, CurrentTime);

    dragx = x + tmp_win->frame_bw;
    dragy = y + tmp_win->frame_bw;
    origx = dragx;
    origy = dragy;
    dragWidth = origWidth = w - 2 * tmp_win->frame_bw;
    dragHeight = origHeight = h - 2 * tmp_win->frame_bw;
    clampTop = clampBottom = clampLeft = clampRight = clampDX = clampDY = 0;
/*****
    if (Scr->AutoRelativeResize) {
	clampRight = clampBottom = 1;
    }
*****/
    last_width = 0;
    last_height = 0;
    DisplaySize(tmp_win, origWidth, origHeight);
}



/*
 * Functionally identical with DoResize(), except that this
 * handles a virtual window differently, but it isn't used anyway.
 * djhjr - 10/6/02
 */
#if 0
void
MenuDoResize(x_root, y_root, tmp_win)
int x_root;
int y_root;
TwmWindow *tmp_win;
{
    int action;

    action = 0;

    x_root -= clampDX;
    y_root -= clampDY;

    if (clampTop) {
        int         delta = y_root - dragy;
        if (dragHeight - delta < MINHEIGHT) {
            delta = dragHeight - MINHEIGHT;
            clampTop = 0;
        }
        dragy += delta;
        dragHeight -= delta;
        action = 1;
    }
    else if (y_root <= dragy/* ||
             y_root == findRootInfo(root)->rooty*/) {
        dragy = y_root;
        dragHeight = origy + origHeight -
            y_root;
        clampBottom = 0;
        clampTop = 1;
	clampDY = 0;
        action = 1;
    }
    if (clampLeft) {
        int         delta = x_root - dragx;
        if (dragWidth - delta < MINWIDTH) {
            delta = dragWidth - MINWIDTH;
            clampLeft = 0;
        }
        dragx += delta;
        dragWidth -= delta;
        action = 1;
    }
    else if (x_root <= dragx/* ||
             x_root == findRootInfo(root)->rootx*/) {
        dragx = x_root;
        dragWidth = origx + origWidth -
            x_root;
        clampRight = 0;
        clampLeft = 1;
	clampDX = 0;
        action = 1;
    }
    if (clampBottom) {
        int         delta = y_root - dragy - dragHeight;
        if (dragHeight + delta < MINHEIGHT) {
            delta = MINHEIGHT - dragHeight;
            clampBottom = 0;
        }
        dragHeight += delta;
        action = 1;
    }
    else if (y_root >= dragy + dragHeight - 1/* ||
           y_root == findRootInfo(root)->rooty
           + findRootInfo(root)->rootheight - 1*/) {
        dragy = origy;
        dragHeight = 1 + y_root - dragy;
        clampTop = 0;
        clampBottom = 1;
	clampDY = 0;
        action = 1;
    }
    if (clampRight) {
        int         delta = x_root - dragx - dragWidth;
        if (dragWidth + delta < MINWIDTH) {
            delta = MINWIDTH - dragWidth;
            clampRight = 0;
        }
        dragWidth += delta;
        action = 1;
    }
    else if (x_root >= dragx + dragWidth - 1/* ||
             x_root == findRootInfo(root)->rootx +
             findRootInfo(root)->rootwidth - 1*/) {
        dragx = origx;
        dragWidth = 1 + x_root - origx;
        clampLeft = 0;
        clampRight = 1;
	clampDX = 0;
        action = 1;
    }

    if (action) {
        ConstrainSize (tmp_win, &dragWidth, &dragHeight);
        if (clampLeft)
            dragx = origx + origWidth - dragWidth;
        if (clampTop)
            dragy = origy + origHeight - dragHeight;

	if (resize_context == C_VIRTUAL_WIN)
		MoveOutline(Scr->VirtualDesktopDisplay,
			    dragx,
			    dragy,
			    dragWidth,
			    dragHeight,
			    tmp_win->frame_bw, 0);
	else {
	/* added this 'if ... else' - djhjr - 4/6/98 */
	if (tmp_win->opaque_resize)
	{
		SetupWindow (tmp_win,
			dragx - tmp_win->frame_bw, dragy - tmp_win->frame_bw,
			dragWidth, dragHeight, -1);

		/* force the redraw of a door - djhjr - 2/28/99 */
		{
			TwmDoor *door;

			if (XFindContext(dpy, tmp_win->w, DoorContext, (caddr_t *)&door) != XCNOENT)
				RedoDoorName(tmp_win, door);
		}

		/* force the redraw of the desktop - djhjr - 2/28/99 */
		if (!strcmp(tmp_win->class.res_class, VTWM_DESKTOP_CLASS))
		{
			ResizeDesktopDisplay(dragWidth, dragHeight);

			Draw3DBorder(Scr->VirtualDesktopDisplayOuter, 0, 0,
					Scr->VirtualDesktopMaxWidth + (Scr->VirtualDesktopBevelWidth * 2),
					Scr->VirtualDesktopMaxHeight + (Scr->VirtualDesktopBevelWidth * 2),
					Scr->VirtualDesktopBevelWidth, Scr->VirtualC, off, False, False);
		}

		/* force the redraw of an icon manager - djhjr - 3/1/99 */
		if (tmp_win->iconmgr)
		{
			struct WList *list;
			int ncols = tmp_win->iconmgrp->cur_columns;
			if (ncols == 0) ncols = 1;

/* djhjr - 4/24/96
			tmp_win->iconmgrp->width = (int) ((dragWidth *
*/
			tmp_win->iconmgrp->width = (int) (((dragWidth - 2 * tmp_win->frame_bw3D) *

				   (long) tmp_win->iconmgrp->columns)
				  / ncols);
			PackIconManager(tmp_win->iconmgrp);

			list = tmp_win->iconmgrp->first;
			while (list)
			{
				RedoListWindow(list->twm);
				list = list->next;
			}
		}

		PaintBorderAndTitlebar(tmp_win);

		/* djhjr - 4/15/98 */
		/* added '&& !resizing_window' - djhjr - 11/7/03 */
		if (!Scr->NoGrabServer && !resizing_window)
		{
			/* these let the application window be drawn - djhjr - 4/14/98 */
			XUngrabServer(dpy); XSync(dpy, 0); XGrabServer(dpy);
		}
	}
	else
		MoveOutline(Scr->Root,
			    dragx - tmp_win->frame_bw,
			    dragy - tmp_win->frame_bw,
			    dragWidth + 2 * tmp_win->frame_bw,
			    dragHeight + 2 * tmp_win->frame_bw,
/* djhjr - 4/24/96
			    tmp_win->frame_bw, tmp_win->title_height);
*/
	    tmp_win->frame_bw, tmp_win->title_height + tmp_win->frame_bw3D);

		/* djhjr - 4/17/98 */
		if (Scr->VirtualReceivesMotionEvents)
			DoVirtualMoveResize(tmp_win, dragx, dragy, dragWidth, dragHeight);
	}
    }

    DisplaySize(tmp_win, dragWidth, dragHeight);
}
#endif

/***********************************************************************
 *
 *  Procedure:
 *      DoResize - move the rubberband around.  This is called for
 *                 each motion event when we are resizing
 *
 *  Inputs:
 *      x_root  - the X corrdinate in the root window
 *      y_root  - the Y corrdinate in the root window
 *      tmp_win - the current twm window
 *
 ***********************************************************************
 */

void
DoResize(x_root, y_root, tmp_win)
int x_root;
int y_root;
TwmWindow *tmp_win;
{
    int action;

    action = 0;

    x_root -= clampDX;
    y_root -= clampDY;

    if (clampTop) {
        int         delta = y_root - dragy;
        if (dragHeight - delta < MINHEIGHT) {
            delta = dragHeight - MINHEIGHT;
            clampTop = 0;
        }
        dragy += delta;
        dragHeight -= delta;
        action = 1;
    }
    else if (y_root <= dragy/* ||
             y_root == findRootInfo(root)->rooty*/) {
        dragy = y_root;
        dragHeight = origy + origHeight -
            y_root;
        clampBottom = 0;
        clampTop = 1;
	clampDY = 0;
        action = 1;
    }
    if (clampLeft) {
        int         delta = x_root - dragx;
        if (dragWidth - delta < MINWIDTH) {
            delta = dragWidth - MINWIDTH;
            clampLeft = 0;
        }
        dragx += delta;
        dragWidth -= delta;
        action = 1;
    }
    else if (x_root <= dragx/* ||
             x_root == findRootInfo(root)->rootx*/) {
        dragx = x_root;
        dragWidth = origx + origWidth -
            x_root;
        clampRight = 0;
        clampLeft = 1;
	clampDX = 0;
        action = 1;
    }
    if (clampBottom) {
        int         delta = y_root - dragy - dragHeight;
        if (dragHeight + delta < MINHEIGHT) {
            delta = MINHEIGHT - dragHeight;
            clampBottom = 0;
        }
        dragHeight += delta;
        action = 1;
    }
    else if (y_root >= dragy + dragHeight - 1/* ||
           y_root == findRootInfo(root)->rooty
           + findRootInfo(root)->rootheight - 1*/) {
        dragy = origy;
        dragHeight = 1 + y_root - dragy;
        clampTop = 0;
        clampBottom = 1;
	clampDY = 0;
        action = 1;
    }
    if (clampRight) {
        int         delta = x_root - dragx - dragWidth;
        if (dragWidth + delta < MINWIDTH) {
            delta = MINWIDTH - dragWidth;
            clampRight = 0;
        }
        dragWidth += delta;
        action = 1;
    }
    else if (x_root >= dragx + dragWidth - 1/* ||
             x_root == findRootInfo(root)->rootx +
             findRootInfo(root)->rootwidth - 1*/) {
        dragx = origx;
        dragWidth = 1 + x_root - origx;
        clampLeft = 0;
        clampRight = 1;
	clampDX = 0;
        action = 1;
    }

    if (action) {
        ConstrainSize (tmp_win, &dragWidth, &dragHeight);
        if (clampLeft)
            dragx = origx + origWidth - dragWidth;
        if (clampTop)
            dragy = origy + origHeight - dragHeight;

		/* added this 'if() ... else' - djhjr - 4/6/98 */
		if (tmp_win->opaque_resize)
		{
			SetupWindow(tmp_win,
				dragx - tmp_win->frame_bw, dragy - tmp_win->frame_bw,
				dragWidth, dragHeight, -1);

			/* force the redraw of a door - djhjr - 2/28/99 */
			{
				TwmDoor *door;

				if (XFindContext(dpy, tmp_win->w, DoorContext, (caddr_t *)&door) != XCNOENT)
					RedoDoorName(tmp_win, door);
			}

			/* force the redraw of the desktop - djhjr - 2/28/99 */
			if (!strcmp(tmp_win->class.res_class, VTWM_DESKTOP_CLASS))
			{
				ResizeDesktopDisplay(dragWidth, dragHeight);

				Draw3DBorder(Scr->VirtualDesktopDisplayOuter, 0, 0,
						Scr->VirtualDesktopMaxWidth + (Scr->VirtualDesktopBevelWidth * 2),
						Scr->VirtualDesktopMaxHeight + (Scr->VirtualDesktopBevelWidth * 2),
						Scr->VirtualDesktopBevelWidth, Scr->VirtualC, off, False, False);
			}

			/* force the redraw of an icon manager - djhjr - 3/1/99 */
			if (tmp_win->iconmgr)
			{
				struct WList *list;
				int ncols = tmp_win->iconmgrp->cur_columns;
				if (ncols == 0) ncols = 1;

/* djhjr - 4/24/96
				tmp_win->iconmgrp->width = (int) ((dragWidth *
*/
				tmp_win->iconmgrp->width = (int) (((dragWidth - 2 * tmp_win->frame_bw3D) *

					   (long) tmp_win->iconmgrp->columns)
					  / ncols);
				PackIconManager(tmp_win->iconmgrp);

				list = tmp_win->iconmgrp->first;
				while (list)
				{
					RedoListWindow(list->twm);
					list = list->next;
				}
			}

			PaintBorderAndTitlebar(tmp_win);

			/* djhjr - 4/15/98 */
			/* added '&& !resizing_window' - djhjr - 11/7/03 */
			if (!Scr->NoGrabServer && !resizing_window)
			{
				/* these let the application window be drawn - djhjr - 4/14/98 */
				XUngrabServer(dpy); XSync(dpy, 0); XGrabServer(dpy);
			}
		}
		else
        MoveOutline(Scr->Root,
            dragx - tmp_win->frame_bw,
            dragy - tmp_win->frame_bw,
            dragWidth + 2 * tmp_win->frame_bw,
            dragHeight + 2 * tmp_win->frame_bw,
/* djhjr - 4/24/96
	    tmp_win->frame_bw, tmp_win->title_height);
*/
	    tmp_win->frame_bw, tmp_win->title_height + tmp_win->frame_bw3D);

		/* djhjr - 4/17/98 */
		if (Scr->VirtualReceivesMotionEvents)
			DoVirtualMoveResize(tmp_win, dragx, dragy, dragWidth, dragHeight);
    }

    DisplaySize(tmp_win, dragWidth, dragHeight);
}

/* djhjr - 9/13/02 */
static void
SetVirtualDesktopIncrs(tmp_win)
TwmWindow *tmp_win;
{
    if (strcmp(tmp_win->class.res_class, VTWM_DESKTOP_CLASS) == 0)
    {
	if (Scr->snapRealScreen)
	{
	    Scr->VirtualDesktopDisplayTwin->hints.flags |= PResizeInc;
	    Scr->VirtualDesktopDisplayTwin->hints.width_inc =
			SCALE_D(Scr->VirtualDesktopPanDistanceX);
	    Scr->VirtualDesktopDisplayTwin->hints.height_inc =
			SCALE_D(Scr->VirtualDesktopPanDistanceY);
	}
	else
	    Scr->VirtualDesktopDisplayTwin->hints.flags &= ~PResizeInc;

	XSetWMNormalHints(dpy, tmp_win->w,
			&Scr->VirtualDesktopDisplayTwin->hints);
    }
}

/***********************************************************************
 *
 *  Procedure:
 *      DisplaySize - display the size in the dimensions window
 *
 *  Inputs:
 *      tmp_win - the current twm window
 *      width   - the width of the rubber band
 *      height  - the height of the rubber band
 *
 ***********************************************************************
 */

void
DisplaySize(tmp_win, width, height)
TwmWindow *tmp_win;
int width;
int height;
{
    char str[100];
    int i, dwidth, dheight;

    if (last_width == width && last_height == height)
        return;

    last_width = width;
    last_height = height;

    if (resize_context == C_VIRTUAL_WIN) {
	    dheight = SCALE_U(height) - tmp_win->title_height;
	    dwidth = SCALE_U(width);
    } else {
/* djhjr - 4/24/96
	    dheight = height - tmp_win->title_height;
	    dwidth = width;
*/
		dheight = height - tmp_win->title_height - 2 * tmp_win->frame_bw3D;
		dwidth = width - 2 * tmp_win->frame_bw3D;

    }

    /*
     * ICCCM says that PMinSize is the default is no PBaseSize is given,
     * and vice-versa.
     * Don't adjust if window is the virtual desktop - djhjr - 9/13/02
     */
    if (tmp_win->hints.flags&(PMinSize|PBaseSize) && tmp_win->hints.flags & PResizeInc)
    {
	if (tmp_win->hints.flags & PBaseSize)
	{
	    dwidth -= tmp_win->hints.base_width;
	    dheight -= tmp_win->hints.base_height;
	} else if (strcmp(tmp_win->class.res_class, VTWM_DESKTOP_CLASS) != 0)
	{
	    dwidth -= tmp_win->hints.min_width;
	    dheight -= tmp_win->hints.min_height;
	}
    }

    if (tmp_win->hints.flags & PResizeInc)
    {
        dwidth /= tmp_win->hints.width_inc;
        dheight /= tmp_win->hints.height_inc;
    }

/*
 * Non-SysV systems - specifically, BSD-derived systems - return a
 * pointer to the string, not its length. Submitted by Goran Larsson
    i = sprintf (str, "%5d x %-5d", dwidth, dheight);
 */
    sprintf (str, "%5d x %-5d", dwidth, dheight);
    i = strlen (str);

    XRaiseWindow(dpy, Scr->SizeWindow);
    /* font was font.font->fid - djhjr - 9/14/03 */
    FBF(Scr->DefaultC.fore, Scr->DefaultC.back, Scr->SizeFont);
/* djhjr - 9/14/03 */
#ifndef NO_I18N_SUPPORT
    MyFont_DrawImageString (dpy, Scr->SizeWindow, &Scr->SizeFont,
#else
    XDrawImageString (dpy, Scr->SizeWindow,
#endif
			  Scr->NormalGC,

/* djhjr - 5/9/96
		      Scr->SizeStringOffset,
*/
			  (Scr->SizeStringWidth -
/* djhjr - 9/14/03 */
#ifndef NO_I18N_SUPPORT
			   MyFont_TextWidth(&Scr->SizeFont,
#else
			   XTextWidth(Scr->SizeFont.font,
#endif
					str, i)) / 2,

/* djhjr - 4/29/98
			Scr->SizeFont.font->ascent + SIZE_VINDENT,
*/
			/* was 'Scr->use3Dborders' - djhjr - 8/11/98 */
/* djhjr 9/14/03
			Scr->SizeFont.font->ascent +
*/
			Scr->SizeFont.ascent +
				 SIZE_VINDENT +
				 ((Scr->InfoBevelWidth > 0) ? Scr->InfoBevelWidth : 0),

			str, i);

	/* I know, I know, but the above code overwrites it... djhjr - 5/9/96 */
	/* was 'Scr->use3Dborders' - djhjr - 8/11/98 */
	if (Scr->InfoBevelWidth > 0)
	    Draw3DBorder(Scr->SizeWindow, 0, 0,
				Scr->SizeStringWidth,

/* djhjr - 4/29/98
				(unsigned int) (Scr->SizeFont.height + SIZE_VINDENT*2),
				BW, Scr->DefaultC, off, False, False);
*/
				/* was 'Scr->use3Dborders' - djhjr - 8/11/98 */
				(unsigned int) (Scr->SizeFont.height + SIZE_VINDENT*2) +
					((Scr->InfoBevelWidth > 0) ? 2 * Scr->InfoBevelWidth : 0),
				Scr->InfoBevelWidth, Scr->DefaultC, off, False, False);
}

/***********************************************************************
 *
 *  Procedure:
 *      EndResize - finish the resize operation
 *
 ***********************************************************************
 */

void
EndResize()
{
    TwmWindow *tmp_win;

#ifdef DEBUG
    fprintf(stderr, "EndResize\n");
#endif

    if (resize_context == C_VIRTUAL_WIN)
	    MoveOutline(Scr->VirtualDesktopDisplay, 0, 0, 0, 0, 0, 0);
    else
	    MoveOutline(Scr->Root, 0, 0, 0, 0, 0, 0);
    XUnmapWindow(dpy, Scr->SizeWindow);

    XFindContext(dpy, ResizeWindow, TwmContext, (caddr_t *)&tmp_win);

    if (resize_context == C_VIRTUAL_WIN) {
	    /* scale up */
	    dragWidth = SCALE_U(dragWidth);
	    dragHeight = SCALE_U(dragHeight);
	    dragx = SCALE_U(dragx);
	    dragy = SCALE_U(dragy);
    }

    ConstrainSize (tmp_win, &dragWidth, &dragHeight);

    if (dragWidth != tmp_win->frame_width ||
        dragHeight != tmp_win->frame_height)
            tmp_win->zoomed = ZOOM_NONE;

    SetupWindow (tmp_win, dragx - tmp_win->frame_bw, dragy - tmp_win->frame_bw,
		 dragWidth, dragHeight, -1);

    EndResizeAdjPointer(tmp_win);	/* djhjr - 9/13/02 */

	/* added test for opaque resizing - djhjr - 2/28/99, 3/1/99 */
	if (!tmp_win->opaque_resize)
	{
		/* was inline code - djhjr - 9/10/99 */
		ResizeTwmWindowContents(tmp_win, dragWidth, dragHeight);
	}

#if 0 /* done in menus.c:ExecuteFunction() - djhjr - 10/6/02 */
    if (!Scr->NoRaiseResize) {
        XRaiseWindow(dpy, tmp_win->frame);
        
	RaiseStickyAbove (); /* DSE */
	RaiseAutoPan();
    }

    UninstallRootColormap();

    /* the resize can have cause the window to move on the screen, hence on the virtual
     * desktop - need to fix the virtual coords */
    tmp_win->virtual_frame_x = R_TO_V_X(dragx);
    tmp_win->virtual_frame_y = R_TO_V_Y(dragy);

    /* UpdateDesktop(tmp_win); Stig */
    MoveResizeDesktop(tmp_win, Scr->NoRaiseResize); /* Stig */
#endif

#if 0 /* done in menus.c:ExecuteFunction() - djhjr - 10/11/01 */
	/* djhjr - 6/4/98 */
	/* don't re-map if the window is the virtual desktop - djhjr - 2/28/99 */
	if (Scr->VirtualReceivesMotionEvents &&
			/* !tmp_win->opaque_resize && */
			tmp_win->w != Scr->VirtualDesktopDisplayOuter)
	{
		XUnmapWindow(dpy, Scr->VirtualDesktopDisplay);
		XMapWindow(dpy, Scr->VirtualDesktopDisplay);
	}
#endif

    ResizeWindow = None;

	/* djhjr - 9/5/98 */
	resizing_window = 0;
}

/* added the passed 'context' - djhjr - 9/30/02 */
void
MenuEndResize(tmp_win, context)
TwmWindow *tmp_win;
int context;
{
    /* added this 'if (...) ... else' - djhjr - 2/22/99 */
    if (resize_context == C_VIRTUAL_WIN)
	    MoveOutline(Scr->VirtualDesktopDisplay, 0, 0, 0, 0, 0, 0);
    else
	    MoveOutline(Scr->Root, 0, 0, 0, 0, 0, 0);
    XUnmapWindow(dpy, Scr->SizeWindow);

    ConstrainSize (tmp_win, &dragWidth, &dragHeight);

	/* djhjr - 9/19/96 */
	if (dragWidth != tmp_win->frame_width || dragHeight != tmp_win->frame_height)
		tmp_win->zoomed = ZOOM_NONE;

/* djhjr - 10/6/02
    AddingX = dragx;
    AddingY = dragy;
    AddingW = dragWidth + (2 * tmp_win->frame_bw);
    AddingH = dragHeight + (2 * tmp_win->frame_bw);
    SetupWindow (tmp_win, AddingX, AddingY, AddingW, AddingH, -1);
*/
    SetupWindow (tmp_win, dragx - tmp_win->frame_bw, dragy - tmp_win->frame_bw,
		 dragWidth, dragHeight, -1);

    /* djhjr - 9/13/02 9/30/02 */
    if (context != C_VIRTUAL_WIN)
	EndResizeAdjPointer(tmp_win);

	/* added test for opaque resizing - djhjr - 2/28/99, 3/1/99 */
	if (!tmp_win->opaque_resize)
	{
		/* was inline code - djhjr - 9/10/99 */
		ResizeTwmWindowContents(tmp_win, dragWidth, dragHeight);
	}

#if 0 /* done in menus.c:ExecuteFunction() - djhjr - 10/11/01 */
	/* djhjr - 6/4/98 */
	/* don't re-map if the window is the virtual desktop - djhjr - 2/28/99 */
	if (Scr->VirtualReceivesMotionEvents &&
			/* !tmp_win->opaque_resize && */
			tmp_win->w != Scr->VirtualDesktopDisplayOuter)
	{
		XUnmapWindow(dpy, Scr->VirtualDesktopDisplay);
		XMapWindow(dpy, Scr->VirtualDesktopDisplay);
	}
#endif

	/* djhjr - 9/5/98 */
	resizing_window = 0;
}



/***********************************************************************
 *
 *  Procedure:
 *      AddEndResize - finish the resize operation for AddWindow
 *
 ***********************************************************************
 */

void
AddEndResize(tmp_win)
TwmWindow *tmp_win;
{

#ifdef DEBUG
    fprintf(stderr, "AddEndResize\n");
#endif

    /* djhjr - 2/22/99 */
    MoveOutline(Scr->Root, 0, 0, 0, 0, 0, 0);
    XUnmapWindow(dpy, Scr->SizeWindow);

    ConstrainSize (tmp_win, &dragWidth, &dragHeight);
    AddingX = dragx;
    AddingY = dragy;
    AddingW = dragWidth + (2 * tmp_win->frame_bw);
    AddingH = dragHeight + (2 * tmp_win->frame_bw);

    EndResizeAdjPointer(tmp_win);	/* djhjr - 9/13/02 */

	/* djhjr - 9/19/96 */
	if (dragWidth != tmp_win->frame_width || dragHeight != tmp_win->frame_height)
		tmp_win->zoomed = ZOOM_NONE;

#if 0 /* done in add_window.c:AddMoveAndResize() - djhjr - 10/11/01 */
	/* djhjr - 6/4/98 */
	if (Scr->VirtualReceivesMotionEvents/* && !tmp_win->opaque_resize*/)
	{
		XUnmapWindow(dpy, Scr->VirtualDesktopDisplay);
		XMapWindow(dpy, Scr->VirtualDesktopDisplay);
	}
#endif

	/* djhjr - 9/5/98 */
	resizing_window = 0;
}

/* djhjr - 9/13/02 */
static void
EndResizeAdjPointer(tmp_win)
TwmWindow *tmp_win;
{
    int x, y, bw = tmp_win->frame_bw + tmp_win->frame_bw3D;

    XQueryPointer(dpy, Scr->Root, &JunkRoot, &JunkChild,
		  &JunkX, &JunkY, &JunkBW, &JunkBW, &JunkBW);
    XTranslateCoordinates(dpy, Scr->Root, tmp_win->frame,
			  JunkX, JunkY, &x, &y, &JunkChild);

    /* for borderless windows */
    if (bw == 0) bw = 4;

    /* (tmp_win->frame_bw) == no 3D borders */
    
    if (x <= 0)
    {
	if (y < tmp_win->title_height)
	    x = tmp_win->title_x + ((tmp_win->frame_bw) ? (bw / 2) : -(bw / 2));
	else
	    x = ((tmp_win->frame_bw) ? -(bw / 2) : (bw / 2));
    }
    if (x >= tmp_win->frame_width)
    {
	if (y < tmp_win->title_height)
	    x = tmp_win->title_x + tmp_win->title_width + (bw / 2);
	else
	    x = tmp_win->frame_width + ((tmp_win->frame_bw) ? (bw / 2) : -(bw / 2));
    }

    if (y <= tmp_win->title_height)
    {
	if (x >= tmp_win->title_x - ((tmp_win->frame_bw) ? 0 : bw) &&
		x < tmp_win->title_x + tmp_win->title_width + bw)
	{
	    if (y <= 0)
		y = ((tmp_win->frame_bw) ? -(bw / 2) : (bw / 2));
	}
	else
	    y = tmp_win->title_height + ((tmp_win->frame_bw) ? -(bw / 2) : (bw / 2));
    }
    if (y >= tmp_win->frame_height)
	y = tmp_win->frame_height + ((tmp_win->frame_bw) ? (bw / 2) : -(bw / 2));

    XWarpPointer(dpy, None, tmp_win->frame, 0, 0, 0, 0, x, y);
}

/***********************************************************************
 *
 *  Procedure:
 *      ConstrainSize - adjust the given width and height to account for the
 *              constraints imposed by size hints
 *
 *      The general algorithm, especially the aspect ratio stuff, is
 *      borrowed from uwm's CheckConsistency routine.
 *
 ***********************************************************************/

void ConstrainSize (tmp_win, widthp, heightp)
    TwmWindow *tmp_win;
    int *widthp, *heightp;
{
#define makemult(a,b) ((b==1) ? (a) : (((int)((a)/(b))) * (b)) )
#define _min(a,b) (((a) < (b)) ? (a) : (b))

    int minWidth, minHeight, maxWidth, maxHeight, xinc, yinc, delta;
    int baseWidth, baseHeight;
    int dwidth = *widthp, dheight = *heightp;


/* djhjr - 4/24/96
    dheight -= tmp_win->title_height;
*/
    dwidth  -= 2 * tmp_win->frame_bw3D;
    dheight -= (tmp_win->title_height + 2 * tmp_win->frame_bw3D);

    if (tmp_win->hints.flags & PMinSize) {
        minWidth = tmp_win->hints.min_width;
        minHeight = tmp_win->hints.min_height;
    } else if (tmp_win->hints.flags & PBaseSize) {
        minWidth = tmp_win->hints.base_width;
        minHeight = tmp_win->hints.base_height;
    } else
        minWidth = minHeight = 1;

    if (resize_context == C_VIRTUAL_WIN) {
	    minWidth = SCALE_D(minWidth);
	    minHeight = SCALE_D(minHeight);
    }

    if (tmp_win->hints.flags & PBaseSize) {
	baseWidth = tmp_win->hints.base_width;
	baseHeight = tmp_win->hints.base_height;
    } else if (tmp_win->hints.flags & PMinSize) {
	baseWidth = tmp_win->hints.min_width;
	baseHeight = tmp_win->hints.min_height;
    } else
	baseWidth = baseHeight = 0;

    if (resize_context == C_VIRTUAL_WIN) {
	    baseWidth = SCALE_D(baseWidth);
	    baseHeight = SCALE_D(baseHeight);
    }

    if (tmp_win->hints.flags & PMaxSize) {
        maxWidth = _min (Scr->MaxWindowWidth, tmp_win->hints.max_width);
        maxHeight = _min (Scr->MaxWindowHeight, tmp_win->hints.max_height);
    } else {
        maxWidth = Scr->MaxWindowWidth;
	maxHeight = Scr->MaxWindowHeight;
    }

    if (resize_context == C_VIRTUAL_WIN) {
	    maxWidth = SCALE_D(maxWidth);
	    maxHeight = SCALE_D(maxHeight);
    }

    if (tmp_win->hints.flags & PResizeInc) {
        xinc = tmp_win->hints.width_inc;
        yinc = tmp_win->hints.height_inc;
    } else
        xinc = yinc = 1;

    if (resize_context == C_VIRTUAL_WIN) {
	    xinc = SCALE_D(xinc);
	    yinc = SCALE_D(yinc);
    }

    /*
     * First, clamp to min and max values
     */
    if (dwidth < minWidth) dwidth = minWidth;
    if (dheight < minHeight) dheight = minHeight;

    if (dwidth > maxWidth) dwidth = maxWidth;
    if (dheight > maxHeight) dheight = maxHeight;


    /*
     * Second, fit to base + N * inc
     */
    dwidth = ((dwidth - baseWidth) / xinc * xinc) + baseWidth;
    dheight = ((dheight - baseHeight) / yinc * yinc) + baseHeight;


    /*
     * Third, adjust for aspect ratio
     */
#define maxAspectX tmp_win->hints.max_aspect.x
#define maxAspectY tmp_win->hints.max_aspect.y
#define minAspectX tmp_win->hints.min_aspect.x
#define minAspectY tmp_win->hints.min_aspect.y
    /*
     * The math looks like this:
     *
     * minAspectX    dwidth     maxAspectX
     * ---------- <= ------- <= ----------
     * minAspectY    dheight    maxAspectY
     *
     * If that is multiplied out, then the width and height are
     * invalid in the following situations:
     *
     * minAspectX * dheight > minAspectY * dwidth
     * maxAspectX * dheight < maxAspectY * dwidth
     *
     */

    if (tmp_win->hints.flags & PAspect)
    {
        if (minAspectX * dheight > minAspectY * dwidth)
        {
            delta = makemult(minAspectX * dheight / minAspectY - dwidth,
                             xinc);
            if (dwidth + delta <= maxWidth) dwidth += delta;
            else
            {
                delta = makemult(dheight - dwidth*minAspectY/minAspectX,
                                 yinc);
                if (dheight - delta >= minHeight) dheight -= delta;
            }
        }

        if (maxAspectX * dheight < maxAspectY * dwidth)
        {
            delta = makemult(dwidth * maxAspectY / maxAspectX - dheight,
                             yinc);
            if (dheight + delta <= maxHeight) dheight += delta;
            else
            {
                delta = makemult(dwidth - maxAspectX*dheight/maxAspectY,
                                 xinc);
                if (dwidth - delta >= minWidth) dwidth -= delta;
            }
        }
    }


    /*
     * Fourth, account for border width and title height
     */
/* djhjr - 4/26/96
    *widthp = dwidth;
    *heightp = dheight + tmp_win->title_height;
*/
    *widthp = dwidth + 2 * tmp_win->frame_bw3D;
    *heightp = dheight + tmp_win->title_height + 2 * tmp_win->frame_bw3D;

}


/***********************************************************************
 *
 *  Procedure:
 *      SetupWindow - set window sizes, this was called from either
 *              AddWindow, EndResize, or HandleConfigureNotify.
 *
 *  Inputs:
 *      tmp_win - the TwmWindow pointer
 *      x       - the x coordinate of the upper-left outer corner of the frame
 *      y       - the y coordinate of the upper-left outer corner of the frame
 *      w       - the width of the frame window w/o border
 *      h       - the height of the frame window w/o border
 *      bw      - the border width of the frame window or -1 not to change
 *
 *  Special Considerations:
 *      This routine will check to make sure the window is not completely
 *      off the display, if it is, it'll bring some of it back on.
 *
 *      The tmp_win->frame_XXX variables should NOT be updated with the
 *      values of x,y,w,h prior to calling this routine, since the new
 *      values are compared against the old to see whether a synthetic
 *      ConfigureNotify event should be sent.  (It should be sent if the
 *      window was moved but not resized.)
 *
 ***********************************************************************
 */

void SetupWindow (tmp_win, x, y, w, h, bw)
    TwmWindow *tmp_win;
    int x, y, w, h, bw;
{
    SetupFrame (tmp_win, x, y, w, h, bw, False);
}

void SetupFrame (tmp_win, x, y, w, h, bw, sendEvent)
    TwmWindow *tmp_win;
    int x, y, w, h, bw;
    Bool sendEvent;			/* whether or not to force a send */
{
    XWindowChanges frame_wc, xwc;
    unsigned long frame_mask, xwcm;
    int title_width, title_height;
    int reShape;

#ifdef DEBUG
    fprintf (stderr, "SetupWindow: x=%d, y=%d, w=%d, h=%d, bw=%d\n",
	     x, y, w, h, bw);
#endif

    if ((tmp_win->virtual_frame_x + tmp_win->frame_width) < 0)
 	    x = 16; /* one "average" cursor width */
    if (x >= Scr->VirtualDesktopWidth)
 	    x = Scr->VirtualDesktopWidth - 16;
    if ((tmp_win->virtual_frame_y + tmp_win->frame_height) < 0)
 	    y = 16; /* one "average" cursor width */
    if (y >= Scr->VirtualDesktopHeight)
 	    y = Scr->VirtualDesktopHeight - 16;

    if (bw < 0)
      bw = tmp_win->frame_bw;		/* -1 means current frame width */

    if (tmp_win->iconmgr) {
/* djhjr - 4/24/96
		tmp_win->iconmgrp->width = w;
        h = tmp_win->iconmgrp->height + tmp_win->title_height;
*/
		tmp_win->iconmgrp->width = w - (2 * tmp_win->frame_bw3D);
        h = tmp_win->iconmgrp->height + tmp_win->title_height + (2 * tmp_win->frame_bw3D);

    }

    /*
     * According to the July 27, 1988 ICCCM draft, we should send a
     * "synthetic" ConfigureNotify event to the client if the window
     * was moved but not resized.
     */
    if (((x != tmp_win->frame_x || y != tmp_win->frame_y) &&
	 (w == tmp_win->frame_width && h == tmp_win->frame_height)) ||
	(bw != tmp_win->frame_bw))
      sendEvent = TRUE;

    xwcm = CWWidth;
/* djhjr 8 4/24/96
    title_width = xwc.width = w;
*/
    title_width  = xwc.width = w - (2 * tmp_win->frame_bw3D);
    title_height = Scr->TitleHeight + bw;

    ComputeWindowTitleOffsets (tmp_win, xwc.width, True);

    reShape = (tmp_win->wShaped ? TRUE : FALSE);
    if (tmp_win->squeeze_info)		/* check for title shaping */
    {
	title_width = tmp_win->rightx + Scr->TBInfo.rightoff;
	if (title_width < xwc.width)
	{
	    xwc.width = title_width;
	    if (tmp_win->frame_height != h ||
	    	tmp_win->frame_width != w ||
		tmp_win->frame_bw != bw ||
	    	title_width != tmp_win->title_width)
	    	reShape = TRUE;
	}
	else
	{
	    if (!tmp_win->wShaped) reShape = TRUE;
	    title_width = xwc.width;
	}
    }

    tmp_win->title_width = title_width;
    if (tmp_win->title_height) tmp_win->title_height = title_height;

    if (tmp_win->title_w) {
	if (bw != tmp_win->frame_bw) {
	    xwc.border_width = bw;
/* djhjr - 4/24/96
	    tmp_win->title_x = xwc.x = -bw;
	    tmp_win->title_y = xwc.y = -bw;
*/
	    tmp_win->title_x = xwc.x = tmp_win->frame_bw3D - bw;
	    tmp_win->title_y = xwc.y = tmp_win->frame_bw3D - bw;

	    xwcm |= (CWX | CWY | CWBorderWidth);
	}

	XConfigureWindow(dpy, tmp_win->title_w, xwcm, &xwc);
    }

/* djhjr - 4/24/96
    tmp_win->attr.width = w;
    tmp_win->attr.height = h - tmp_win->title_height;
*/
    tmp_win->attr.width  = w - (2 * tmp_win->frame_bw3D);
    tmp_win->attr.height = h - tmp_win->title_height - (2 * tmp_win->frame_bw3D);

/* djhjr - 4/25/96
    XMoveResizeWindow (dpy, tmp_win->w, 0, tmp_win->title_height,
		       w, h - tmp_win->title_height);
*/

    /*
     * fix up frame and assign size/location values in tmp_win
     */

    frame_mask = 0;
    if (bw != tmp_win->frame_bw) {
	frame_wc.border_width = tmp_win->frame_bw = bw;
	frame_mask |= CWBorderWidth;
    }
    frame_wc.x = tmp_win->frame_x = x;
    frame_wc.y = tmp_win->frame_y = y;
    frame_wc.width = tmp_win->frame_width = w;
    frame_wc.height = tmp_win->frame_height = h;
    frame_mask |= (CWX | CWY | CWWidth | CWHeight);
    XConfigureWindow (dpy, tmp_win->frame, frame_mask, &frame_wc);
    tmp_win->virtual_frame_x = R_TO_V_X(tmp_win->frame_x);
    tmp_win->virtual_frame_y = R_TO_V_Y(tmp_win->frame_y);

	/* djhjr - 4/24/96 */
    XMoveResizeWindow (dpy, tmp_win->w, tmp_win->frame_bw3D,
			tmp_win->title_height + tmp_win->frame_bw3D,
			tmp_win->attr.width, tmp_win->attr.height);

    /*
     * fix up highlight window
     */

    if (tmp_win->title_height && tmp_win->hilite_w)
    {
/* djhjr - 4/2/98
	xwc.width = (tmp_win->rightx - tmp_win->highlightx);
	if (Scr->TBInfo.nright > 0) xwc.width -= Scr->TitlePadding;

	* djhjr - 4/24/96 *
	if (Scr->use3Dtitles) xwc.width -= 4;
*/
	xwc.width = ComputeHighlightWindowWidth(tmp_win);

        if (xwc.width <= 0) {
            xwc.x = Scr->MyDisplayWidth;	/* move offscreen */
            xwc.width = 1;
        } else {
            xwc.x = tmp_win->highlightx;
        }

        xwcm = CWX | CWWidth;
        XConfigureWindow(dpy, tmp_win->hilite_w, xwcm, &xwc);
    }

    if (HasShape && reShape) {
	SetFrameShape (tmp_win);
    }

    if (sendEvent)
    {
	    SendConfigureNotify(tmp_win, x, y);
    }
}

/* djhjr - 4/6/98 */
void
PaintBorderAndTitlebar(tmp_win)
TwmWindow *tmp_win;
{
	if (tmp_win->highlight)
		SetBorder(tmp_win, True);
	else
	{
		/* was 'Scr->use3Dborders' - djhjr - 8/11/98 */
		if (Scr->BorderBevelWidth > 0) PaintBorders(tmp_win, True);

		if (tmp_win->titlebuttons)
		{
			int i, nb = Scr->TBInfo.nleft + Scr->TBInfo.nright;
			TBWindow *tbw;

			for (i = 0, tbw = tmp_win->titlebuttons; i < nb; i++, tbw++)
				PaintTitleButton(tmp_win, tbw, 0);
		}
	}

	PaintTitle(tmp_win);
	PaintTitleHighlight(tmp_win, on);	/* djhjr - 10/25/02 */
}


/* djhjr - 4/17/98 */
static void
DoVirtualMoveResize(tmp_win, x, y, w, h)
TwmWindow *tmp_win;
int x, y, w, h;
{
	int fw = tmp_win->frame_width, fh = tmp_win->frame_height;

	tmp_win->virtual_frame_x = R_TO_V_X(x - tmp_win->frame_bw);
	tmp_win->virtual_frame_y = R_TO_V_Y(y - tmp_win->frame_bw);
	if (!tmp_win->opaque_resize)
	{
		tmp_win->frame_width = w + 2 * tmp_win->frame_bw;
		tmp_win->frame_height = h + 2 * tmp_win->frame_bw;
	}

/* djhjr - 5/27/03
	MoveResizeDesktop(tmp_win, Scr->NoRaiseResize);
*/
	MoveResizeDesktop(tmp_win, TRUE);

	tmp_win->frame_width = fw; tmp_win->frame_height = fh;
}


/**********************************************************************
 *  Rutgers mod #1   - rocky.
 *  Procedure:
 *         fullzoom - zooms window to full height of screen or
 *                    to full height and width of screen. (Toggles
 *                    so that it can undo the zoom - even when switching
 *                    between fullzoom and vertical zoom.)
 *
 *  Inputs:
 *         tmp_win - the TwmWindow pointer
 *
 *
 **********************************************************************
 */

void
fullzoom(tmp_win,flag)
TwmWindow *tmp_win;
int flag;
{
	Window junkRoot;
	unsigned int junkbw, junkDepth;
	int basex, basey;
	int frame_bw_times_2;

	XGetGeometry(dpy, (Drawable) tmp_win->frame, &junkRoot, &dragx, &dragy,
		(unsigned int *)&dragWidth, (unsigned int *)&dragHeight, &junkbw,
		&junkDepth);

	basex = basey = 0;

	if (tmp_win->zoomed == flag)
	{
		dragHeight = tmp_win->save_frame_height;
		dragWidth = tmp_win->save_frame_width;
		dragx = tmp_win->save_frame_x;
		dragy = tmp_win->save_frame_y;
		tmp_win->zoomed = ZOOM_NONE;
	}
	else
	{
		if (tmp_win->zoomed == ZOOM_NONE)
		{
			tmp_win->save_frame_x = dragx;
			tmp_win->save_frame_y = dragy;
			tmp_win->save_frame_width = dragWidth;
			tmp_win->save_frame_height = dragHeight;
		}

		tmp_win->zoomed = flag;

		frame_bw_times_2 = 2 * tmp_win->frame_bw;

		switch (flag)
		{
			case ZOOM_NONE:
				break;
			case F_ZOOM:
				dragx = tmp_win->save_frame_x;
				dragy=basey;
				dragWidth = tmp_win->save_frame_width;
				dragHeight = Scr->MyDisplayHeight - frame_bw_times_2;
				break;
			case F_HORIZOOM:
				dragx = basex;
				dragy = tmp_win->save_frame_y;
				dragWidth = Scr->MyDisplayWidth - frame_bw_times_2;
				dragHeight = tmp_win->save_frame_height;
				break;
			case F_FULLZOOM:
				dragx = basex;
				dragy = basey;
				dragWidth = Scr->MyDisplayWidth - frame_bw_times_2;
				dragHeight = Scr->MyDisplayHeight - frame_bw_times_2;
				break;
			case F_LEFTZOOM:
				dragx = basex;
				dragy = basey;
				dragWidth = Scr->MyDisplayWidth / 2 - frame_bw_times_2;
				dragHeight = Scr->MyDisplayHeight - frame_bw_times_2;
				break;
			case F_RIGHTZOOM:
				dragx = basex + Scr->MyDisplayWidth / 2;
				dragy = basey;
				dragWidth = Scr->MyDisplayWidth / 2 - frame_bw_times_2;
				dragHeight = Scr->MyDisplayHeight - frame_bw_times_2;
				break;
			case F_TOPZOOM:
				dragx = basex;
				dragy = basey;
				dragWidth = Scr->MyDisplayWidth - frame_bw_times_2;
				dragHeight = Scr->MyDisplayHeight / 2 - frame_bw_times_2;
				break;
			case F_BOTTOMZOOM:
				dragx = basex;
				dragy = basey + Scr->MyDisplayHeight / 2;
				dragWidth = Scr->MyDisplayWidth - frame_bw_times_2;
				dragHeight = Scr->MyDisplayHeight / 2 - frame_bw_times_2;
				break;
		}
	}

	if (!Scr->NoRaiseResize) {
		XRaiseWindow(dpy, tmp_win->frame);

		RaiseStickyAbove(); /* DSE */
		RaiseAutoPan();
	}

	ConstrainSize(tmp_win, &dragWidth, &dragHeight);
	SetupWindow (tmp_win, dragx , dragy , dragWidth, dragHeight, -1);

	/* djhjr - 9/10/99 */
	ResizeTwmWindowContents(tmp_win, dragWidth, dragHeight);

	/* 9/21/96 - djhjr */
	if ((Scr->WarpCursor || LookInList(Scr->WarpCursorL, tmp_win->full_name, &tmp_win->class)))
		WarpToWindow (tmp_win);

	XUngrabPointer (dpy, CurrentTime);
	XUngrabServer (dpy);
}

/*
 * adjust contents of iconmgrs, doors and the desktop - djhjr - 9/10/99
 */
void ResizeTwmWindowContents(tmp_win, width, height)
    TwmWindow *tmp_win;
	int width, height;
{
	TwmDoor *door;
	int ncols;

	if (tmp_win->iconmgr)
	{
		ncols = tmp_win->iconmgrp->cur_columns;
		if (ncols == 0) ncols = 1;

/* djhjr - 4/24/96
		tmp_win->iconmgrp->width = (int) ((width *
*/
		tmp_win->iconmgrp->width =
				(int)(((width - 2 * tmp_win->frame_bw3D) *

				(long) tmp_win->iconmgrp->columns) / ncols);
		PackIconManager(tmp_win->iconmgrp);
	}
	else if (tmp_win->w == Scr->VirtualDesktopDisplayOuter)
		ResizeDesktopDisplay(width, height);
	else if (XFindContext(dpy, tmp_win->w, DoorContext, (caddr_t *)&door) != XCNOENT)
		RedoDoorName(tmp_win, door);
}

void SetFrameShape (tmp)
    TwmWindow *tmp;
{
    /*
     * see if the titlebar needs to move
     */
    if (tmp->title_w) {
	int oldx = tmp->title_x, oldy = tmp->title_y;
	ComputeTitleLocation (tmp);
	if (oldx != tmp->title_x || oldy != tmp->title_y)
	  XMoveWindow (dpy, tmp->title_w, tmp->title_x, tmp->title_y);
    }

    /*
     * The frame consists of the shape of the contents window offset by
     * title_height or'ed with the shape of title_w (which is always
     * rectangular).
     */
    if (tmp->wShaped) {
	/*
	 * need to do general case
	 */
	XShapeCombineShape (dpy, tmp->frame, ShapeBounding,
/* djhjr - 4/24/96
			    0, tmp->title_height, tmp->w,
*/
			    tmp->frame_bw3D, tmp->title_height + tmp->frame_bw3D, tmp->w,

			    ShapeBounding, ShapeSet);
	if (tmp->title_w) {
	    XShapeCombineShape (dpy, tmp->frame, ShapeBounding,
				tmp->title_x + tmp->frame_bw,
				tmp->title_y + tmp->frame_bw,
				tmp->title_w, ShapeBounding,
				ShapeUnion);
	}
    } else {
	/*
	 * can optimize rectangular contents window
	 */
	if (tmp->squeeze_info) {
	    XRectangle  newBounding[3];
	    XRectangle  newClip[3];
	    int count = 3, order = YXSorted, fbw2 = 2 * tmp->frame_bw;
	    int client_width = tmp->attr.width + fbw2 + 2 * tmp->frame_bw3D;

	    /*
	     * Build the border clipping rectangles; one around title, one
	     * around window.  The title_[xy] field already have had frame_bw
	     * subtracted off them so that they line up properly in the frame.
	     *
	     * The frame_width and frame_height do *not* include borders.
	     */
	    /* border */
/* djhjr - 4/24/96
	    newBounding[0].x = tmp->title_x;
	    newBounding[0].y = tmp->title_y;
	    newBounding[0].width = tmp->title_width + fbw2;
	    newBounding[0].height = tmp->title_height;
	    newBounding[1].x = -tmp->frame_bw;
	    newBounding[1].y = Scr->TitleHeight;
	    newBounding[1].width = tmp->attr.width + fbw2;
	    newBounding[1].height = tmp->attr.height + fbw2;
*/
	    newBounding[0].x = tmp->title_x - tmp->frame_bw3D;
	    newBounding[0].y = tmp->title_y - tmp->frame_bw3D;
	    newBounding[0].width = tmp->title_width + fbw2 + 2 * tmp->frame_bw3D;
	    newBounding[0].height = tmp->title_height + tmp->frame_bw3D;

	    /* was 'Scr->use3Dborders' - djhjr - 8/11/98 */
	    if (Scr->BorderBevelWidth > 0 &&
			newBounding[0].width < client_width)
	    {
		/* re-ordered arrays for XYSorted - djhjr - 11/5/03 */
		newBounding[1].x = -tmp->frame_bw3D;
		newBounding[1].y = tmp->title_height;
		newBounding[1].width = tmp->attr.width + 3 * tmp->frame_bw3D;
		newBounding[1].height = tmp->frame_bw3D;
		newBounding[2].x = -tmp->frame_bw;
		newBounding[2].y = Scr->TitleHeight + tmp->frame_bw3D;
		newBounding[2].width = client_width;
		newBounding[2].height = tmp->attr.height + fbw2 + tmp->frame_bw3D;
	    }
	    else
	    {
		newBounding[1].x = -tmp->frame_bw;
		newBounding[1].y = Scr->TitleHeight + tmp->frame_bw3D;
		newBounding[1].width = client_width;
		newBounding[1].height = tmp->attr.height + fbw2 + tmp->frame_bw3D;
		count = 2;
		order = YXBanded;
	    }

	    /* insides */
/* djhjr - 4/24/96
	    newClip[0].x = tmp->title_x + tmp->frame_bw;
	    newClip[0].y = 0;
	    newClip[0].width = tmp->title_width;
	    newClip[0].height = Scr->TitleHeight;
	    newClip[1].x = 0;
	    newClip[1].y = tmp->title_height;
	    newClip[1].width = tmp->attr.width;
	    newClip[1].height = tmp->attr.height;
*/
	    newClip[0].x = tmp->title_x + tmp->frame_bw - tmp->frame_bw3D;
	    newClip[0].y = 0;
	    newClip[0].width = tmp->title_width + 2 * tmp->frame_bw3D;
	    newClip[0].height = Scr->TitleHeight + tmp->frame_bw3D;

	    if (count == 3)
	    {
		/* re-ordered arrays for XYSorted - djhjr - 11/5/03 */
		newClip[1].x = newBounding[1].x;
		newClip[1].y = newBounding[1].y;
		newClip[1].width = newBounding[1].width;
		newClip[1].height = newBounding[1].height;
		newClip[2].x = 0;
		newClip[2].y = tmp->title_height + tmp->frame_bw3D;
		newClip[2].width = client_width;
		newClip[2].height = tmp->attr.height + tmp->frame_bw3D;
	    }
	    else
	    {
		newClip[1].x = 0;
		newClip[1].y = tmp->title_height + tmp->frame_bw3D;
		newClip[1].width = client_width;
		newClip[1].height = tmp->attr.height + tmp->frame_bw3D;
	    }

	    XShapeCombineRectangles (dpy, tmp->frame, ShapeBounding, 0, 0,
				     newBounding, count, ShapeSet, order);
	    XShapeCombineRectangles (dpy, tmp->frame, ShapeClip, 0, 0,
				     newClip, count, ShapeSet, order);
	} else {
	    (void) XShapeCombineMask (dpy, tmp->frame, ShapeBounding, 0, 0,
 				      None, ShapeSet);
	    (void) XShapeCombineMask (dpy, tmp->frame, ShapeClip, 0, 0,
				      None, ShapeSet);
	}
    }
}

/*
 * Squeezed Title:
 *
 *                         tmp->title_x
 *                   0     |
 *  tmp->title_y   ........+--------------+.........  -+,- tmp->frame_bw
 *             0   : ......| +----------+ |....... :  -++
 *                 : :     | |          | |      : :   ||-Scr->TitleHeight
 *                 : :     | |          | |      : :   ||
 *                 +-------+ +----------+ +--------+  -+|-tmp->title_height
 *                 | +---------------------------+ |  --+
 *                 | |                           | |
 *                 | |                           | |
 *                 | |                           | |
 *                 | |                           | |
 *                 | |                           | |
 *                 | +---------------------------+ |
 *                 +-------------------------------+
 *
 *
 * Unsqueezed Title:
 *
 *                 tmp->title_x
 *                 | 0
 *  tmp->title_y   +-------------------------------+  -+,tmp->frame_bw
 *             0   | +---------------------------+ |  -+'
 *                 | |                           | |   |-Scr->TitleHeight
 *                 | |                           | |   |
 *                 + +---------------------------+ +  -+
 *                 |-+---------------------------+-|
 *                 | |                           | |
 *                 | |                           | |
 *                 | |                           | |
 *                 | |                           | |
 *                 | |                           | |
 *                 | +---------------------------+ |
 *                 +-------------------------------+
 *
 *
 *
 * Dimensions and Positions:
 *
 *     frame orgin                 (0, 0)
 *     frame upper left border     (-tmp->frame_bw, -tmp->frame_bw)
 *     frame size w/o border       tmp->frame_width , tmp->frame_height
 *     frame/title border width    tmp->frame_bw
 *     extra title height w/o bdr  tmp->title_height = TitleHeight + frame_bw
 *     title window height         Scr->TitleHeight
 *     title origin w/o border     (tmp->title_x, tmp->title_y)
 *     client origin               (0, Scr->TitleHeight + tmp->frame_bw)
 *     client size                 tmp->attr.width , tmp->attr.height
 *
 * When shaping, need to remember that the width and height of rectangles
 * are really deltax and deltay to lower right handle corner, so they need
 * to have -1 subtracted from would normally be the actual extents.
 */
