Subversion Repositories or1k_old

/*
 * Copyright (c) 1999 Greg Haerr <greg@censoft.com>
 * Portions Copyright (c) 1991 David I. Bell
 *
 * Non-Win32 API helper routines for window showing/hiding/exposing
 */
#include "windows.h"
#include "wintern.h"
#include <stdlib.h>
 
/* Redraw all windows*/
void
MwRedrawScreen(void)
{
	/* redraw all windows except desktop window*/
	MwExposeArea(rootwp, 0, 0, rootwp->winrect.right,
		rootwp->winrect.bottom);
 
	/* redraw desktop window*/
	PostMessage(rootwp, WM_PAINT, 0, 0L);
}
 
/*
 * Hide the window to make it and its children invisible on the screen.
 * This is a recursive routine which increments the unmapcount values for
 * this window and all of its children, and causes exposure events for
 * windows which are newly uncovered.
 */
void
MwHideWindow(HWND hwnd,BOOL bChangeFocus, BOOL bSendMsg)
{
	HWND	wp = hwnd;
	HWND	pwp;		/* parent window */
	HWND	sibwp;		/* sibling window */
	HWND	childwp;	/* child window */
 
	if (wp == rootwp)
		return;
 
	++mwpaintNC;		/* experimental NC paint handling*/
 
	/* send hide message if currently visible*/
	if(bSendMsg && wp->unmapcount == 0)
		SendMessage(wp, WM_SHOWWINDOW, FALSE, 0L);
 
	wp->unmapcount++;
 
	for (childwp = wp->children; childwp; childwp = childwp->siblings)
		MwHideWindow(childwp, bChangeFocus, bSendMsg);
 
	if (wp == mousewp) {
		MwCheckMouseWindow();
		MwCheckCursor();
	}
 
	if (bChangeFocus && wp == focuswp)
		SetFocus(rootwp->children? rootwp->children: rootwp);
 
	/*
	 * If the parent window is still unmapped, then we are all done.
	 */
	if (wp->parent->unmapcount)
		return;
 
	/*
	 * Clear the area in the parent for this window, causing an
	 * exposure event for it.
	 */
	pwp = wp->parent;
	MwClearWindow(pwp, wp->winrect.left - pwp->winrect.left,
		wp->winrect.top - pwp->winrect.top,
		wp->winrect.right - wp->winrect.left,
		wp->winrect.bottom - wp->winrect.top, TRUE);
 
	/*
	 * Finally clear and redraw all parts of our lower sibling
	 * windows that were covered by this window.
	 */
	sibwp = wp;
	while (sibwp->siblings) {
		sibwp = sibwp->siblings;
		MwExposeArea(sibwp, wp->winrect.left, wp->winrect.top,
			wp->winrect.right - wp->winrect.left,
			wp->winrect.bottom - wp->winrect.top);
	}
}
 
/*
 * Map the window to possibly make it and its children visible on the screen.
 * This is a recursive routine which decrements the unmapcount values for
 * this window and all of its children, and causes exposure events for
 * those windows which become visible.
 */
void
MwShowWindow(HWND hwnd, BOOL bSendMsg)
{
	HWND	wp = hwnd;
 
	if (wp == rootwp)
		return;
 
	++mwpaintNC;		/* experimental NC paint handling*/
 
	if (wp->unmapcount)
		wp->unmapcount--;
 
	if (wp->unmapcount == 0) {
		SendMessage(wp, WM_SHOWWINDOW, TRUE, 0L);
		MwCheckMouseWindow();
		MwCheckCursor();
	}
 
	/*
	 * If the window just became visible,
	 * then draw its border, clear it to the background color, and
	 * generate an exposure event.
	 */
	if (wp->unmapcount == 0) {
		/*MwDrawBorder(wp);*/
		MwClearWindow(wp, 0, 0, wp->winrect.right - wp->winrect.left,
			wp->winrect.bottom - wp->winrect.top, TRUE);
	}
 
	/*
	 * Do the same thing for the children.
	 */
	for (wp = wp->children; wp; wp = wp->siblings)
		MwShowWindow(wp, bSendMsg);
}
 
/*
 * Raise a window to the highest level among its siblings.
 */
void
MwRaiseWindow(HWND hwnd)
{
	HWND	wp = hwnd;
	HWND	prevwp;
	BOOL	overlap;
 
	if (!wp || wp == rootwp)
		return;
 
	++mwpaintNC;		/* experimental NC paint handling*/
 
	/*
	 * If this is already the highest window then we are done.
	 */
	prevwp = wp->parent->children;
	if (prevwp == wp)
		return;
 
	/*
	 * Find the sibling just before this window so we can unlink it.
	 * Also, determine if any sibling ahead of us overlaps the window.
	 * Remember that for exposure events.
	 */
	overlap = FALSE;
	while (prevwp->siblings != wp) {
		overlap |= MwCheckOverlap(prevwp, wp);
		prevwp = prevwp->siblings;
	}
	overlap |= MwCheckOverlap(prevwp, wp);
 
	/*
	 * Now unlink the window and relink it in at the front of the
	 * sibling chain.
	 */
	prevwp->siblings = wp->siblings;
	wp->siblings = wp->parent->children;
	wp->parent->children = wp;
 
	/*
	 * Finally redraw the window if necessary.
	 */
	if (overlap) {
		/*MwDrawBorder(wp);*/
		MwExposeArea(wp, wp->winrect.left, wp->winrect.top,
			wp->winrect.right - wp->winrect.left,
			wp->winrect.bottom - wp->winrect.top);
	}
}
 
/*
 * Lower a window to the lowest level among its siblings.
 */
void
MwLowerWindow(HWND hwnd)
{
	HWND	wp = hwnd;
	HWND	prevwp;
	HWND	sibwp;		/* sibling window */
	HWND	expwp;		/* siblings being exposed */
 
	if (!wp || wp == rootwp || !wp->siblings)
		return;
 
	++mwpaintNC;		/* experimental NC paint handling*/
 
	/*
	 * Find the sibling just before this window so we can unlink us.
	 */
	prevwp = wp->parent->children;
	if (prevwp != wp) {
		while (prevwp->siblings != wp)
			prevwp = prevwp->siblings;
	}
 
	/*
	 * Remember the first sibling that is after us, so we can
	 * generate exposure events for the remaining siblings.  Then
	 * walk down the sibling chain looking for the last sibling.
	 */
	expwp = wp->siblings;
	sibwp = wp;
	while (sibwp->siblings)
		sibwp = sibwp->siblings;
 
	/*
	 * Now unlink the window and relink it in at the end of the
	 * sibling chain.
	 */
	if (prevwp == wp)
		wp->parent->children = wp->siblings;
	else
		prevwp->siblings = wp->siblings;
	sibwp->siblings = wp;
 
	wp->siblings = NULL;
 
	/*
	 * Finally redraw the sibling windows which this window covered
	 * if they overlapped our window.
	 */
	while (expwp && (expwp != wp)) {
		if (MwCheckOverlap(wp, expwp))
			MwExposeArea(expwp, wp->winrect.left, wp->winrect.top,
				wp->winrect.right - wp->winrect.left,
				wp->winrect.bottom - wp->winrect.top);
		expwp = expwp->siblings;
	}
}
 
/*
 * Check to see if the first window overlaps the second window.
 */
BOOL
MwCheckOverlap(HWND topwp, HWND botwp)
{
	MWCOORD	minx1;
	MWCOORD	miny1;
	MWCOORD	maxx1;
	MWCOORD	maxy1;
	MWCOORD	minx2;
	MWCOORD	miny2;
	MWCOORD	maxx2;
	MWCOORD	maxy2;
 
	if (topwp->unmapcount || botwp->unmapcount)
		return FALSE;
 
	minx1 = topwp->winrect.left;
	miny1 = topwp->winrect.top;
	maxx1 = topwp->winrect.right - 1;
	maxy1 = topwp->winrect.bottom - 1;
 
	minx2 = botwp->winrect.left;
	miny2 = botwp->winrect.top;
	maxx2 = botwp->winrect.right - 1;
	maxy2 = botwp->winrect.bottom - 1;
 
	if (minx1 > maxx2 || minx2 > maxx1 || miny1 > maxy2 || miny2 > maxy1)
		return FALSE;
 
	return TRUE;
}
 
/*
 * Clear the specified area of a window and possibly make an exposure event.
 * This sets the area window to its background color.  If the exposeflag is
 * nonzero, then this also creates an exposure event for the window.
 */
void
MwClearWindow(HWND wp, MWCOORD x, MWCOORD y, MWCOORD width, MWCOORD height,
	BOOL exposeflag)
{
	if (wp->unmapcount)
		return;
 
	/*
	 * Reduce the arguments so that they actually lie within the window.
	 */
	if (x < 0) {
		width += x;
		x = 0;
	}
	if (y < 0) {
		height += y;
		y = 0;
	}
	if (x + width > wp->winrect.right - wp->winrect.left)
		width = (wp->winrect.right - wp->winrect.left) - x;
	if (y + height > wp->winrect.bottom - wp->winrect.top)
		height = (wp->winrect.bottom - wp->winrect.top) - y;
 
	/*
	 * Now see if the region is really in the window.  If not, then
	 * do nothing.
	 */
	if (x >= (wp->winrect.right - wp->winrect.left) ||
	    y >= (wp->winrect.bottom - wp->winrect.top) ||
	    width <= 0 || height <= 0)
		return;
 
	/*
	 * Now do the exposure if required.
	 */
	if (exposeflag)
		MwDeliverExposureEvent(wp, x, y, width, height);
}
 
/*
 * Handle the exposing of the specified absolute region of the screen,
 * starting with the specified window.  That window and all of its
 * children will be redrawn and/or exposure events generated if they
 * overlap the specified area.  This is a recursive routine.
 */
void
MwExposeArea(HWND wp, MWCOORD rootx, MWCOORD rooty, MWCOORD width,
	MWCOORD height)
{
	if (wp->unmapcount)
		return;
 
	++mwpaintNC;		/* experimental NC paint handling*/
 
	/*
	 * First see if the area overlaps the window including the border.
	 * If not, then there is nothing more to do.
	 */
	if (rootx >= wp->winrect.right || rooty >= wp->winrect.bottom ||
	    (rootx + width) <= wp->winrect.left ||
	    (rooty + height) <= wp->winrect.top)
		return;
 
#if 0
	/*
	 * The area does overlap the window.  See if the area overlaps
	 * the border, and if so, then redraw it.
	 */
	if (rootx < wp->winrect.left || rooty < wp->winrect.top ||
		(rootx + width) > wp->winrect.right ||
		(rooty + height) > wp->winrect.bottom)
			MwDrawBorder(wp);
#endif
 
	/*
	 * Now clear the window itself in the specified area,
	 * which might cause an exposure event.
	 */
	MwClearWindow(wp, rootx - wp->winrect.left, rooty - wp->winrect.top,
		width, height, TRUE);
 
	/*
	 * Now do the same for all the children.
	 */
	for (wp = wp->children; wp; wp = wp->siblings)
		MwExposeArea(wp, rootx, rooty, width, height);
}