/*
* 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
GsExposeArea(GR_WINDOW *wp, GR_COORD rootx, GR_COORD rooty, GR_SIZE width,
GR_SIZE height, GR_WINDOW *stopwp)
{
if (!wp->output || wp->unmapcount || wp == stopwp)
return;
/*
* First see if the area overlaps the window including the border.
* If not, then there is nothing more to do.
*/
if ((rootx >= wp->x + wp->width + wp->bordersize) ||
(rooty >= wp->y + wp->height + wp->bordersize) ||
(rootx + width <= wp->x - wp->bordersize) ||
(rooty + height <= wp->y - wp->bordersize))
return;
/*
* The area does overlap the window. See if the area overlaps
* the border, and if so, then redraw it.
*/
if ((rootx < wp->x) || (rooty < wp->y) ||
(rootx + width > wp->x + wp->width) ||
(rooty + height > wp->y + wp->height))
GsDrawBorder(wp);
/*
* Now clear the window itself in the specified area,
* which might cause an exposure event.
*/
GsWpClearWindow(wp, rootx - wp->x, rooty - wp->y,
width, height, GR_TRUE);
/*
* Now do the same for all the children.
*/
for (wp = wp->children; wp; wp = wp->siblings)
GsExposeArea(wp, rootx, rooty, width, height, stopwp);
}
/*
* 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.
* If temp is set, then window is being mapped again after a temporary
* unmap, so don't reset focus or generate mouse/focus events.
*/
void GsWpMapWindow(GR_WINDOW *wp, GR_BOOL temp)
{
if (wp == rootwp) {
GsError(GR_ERROR_ILLEGAL_ON_ROOT_WINDOW, wp->id);
return;
}
if (wp->unmapcount)
--wp->unmapcount;
if (!temp && wp->unmapcount == 0) {
GsCheckMouseWindow();
GsCheckFocusWindow();
GsCheckCursor();
}
/* send update event if just mapped*/
if (wp->unmapcount == 0) {
GsDeliverUpdateEvent(wp, GR_UPDATE_MAP, wp->x, wp->y,
wp->width, wp->height);
}
/*
* If the window is an output window and just became visible,
* then draw its border, clear it to the background color, and
* generate an exposure event.
*/
if (wp->output && (wp->unmapcount == 0)) {
GsDrawBorder(wp);
GsWpClearWindow(wp, 0, 0, wp->width, wp->height, GR_TRUE);
}
/*
* Do the same thing for the children.
*/
for (wp = wp->children; wp; wp = wp->siblings)
GsWpMapWindow(wp, temp);
}
/*
* Unmap 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.
* If temp_unmap set, don't reset focus or generate mouse/focus events,
* as window will be mapped again momentarily (window move, resize, etc)
*/
void GsWpUnmapWindow(GR_WINDOW *wp, GR_BOOL temp_unmap)
{
GR_WINDOW *pwp; /* parent window */
GR_WINDOW *sibwp; /* sibling window */
GR_WINDOW *childwp; /* child window */
GR_SIZE bs; /* border size of this window */
if (wp == rootwp) {
GsError(GR_ERROR_ILLEGAL_ON_ROOT_WINDOW, wp->id);
return;
}
if (wp == clipwp)
clipwp = NULL;
++wp->unmapcount;
for (childwp = wp->children; childwp; childwp = childwp->siblings)
GsWpUnmapWindow(childwp, temp_unmap);
if (!temp_unmap && wp == mousewp) {
GsCheckMouseWindow();
GsCheckCursor();
}
if (!temp_unmap && wp == focuswp) {
if (focusfixed)
/* don't revert to mouse enter/leave focus if fixed*/
focuswp = rootwp;
else {
focusfixed = GR_FALSE;
GsCheckFocusWindow();
}
}
/* Send update event if just unmapped*/
if (wp->unmapcount == 1) {
GsDeliverUpdateEvent(wp,
(temp_unmap? GR_UPDATE_UNMAPTEMP: GR_UPDATE_UNMAP),
0, 0, 0, 0);
}
/*
* If this is an input-only window or the parent window is
* still unmapped, then we are all done.
*/
if (!wp->output || wp->parent->unmapcount)
return;
/*
* Clear the area in the parent for this window, causing an
* exposure event for it. Take into account the border size.
*/
bs = wp->bordersize;
pwp = wp->parent;
GsWpClearWindow(pwp, wp->x - pwp->x - bs, wp->y - pwp->y - bs,
wp->width + bs * 2, wp->height + bs * 2, GR_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;
GsExposeArea(sibwp, wp->x - bs, wp->y - bs,
wp->width + bs * 2, wp->height + bs * 2, NULL);
}
}
/*
* Map the window to possibly make it and its children visible on the screen.
* This is a recursive routine which realizes this window and all of its
* children, and causes exposure events for those windows which become visible.
* If temp is set, then window is being mapped again after a temporary
* unmap, so don't reset focus or generate mouse/focus events.
*/
void
GsWpRealizeWindow(GR_WINDOW *wp, GR_BOOL temp)
{
if (wp == rootwp) {
GsError(GR_ERROR_ILLEGAL_ON_ROOT_WINDOW, wp->id);
return;
}
/*printf("RealizeWindow %d, map %d realized %d, parent_realized %d\n",
wp->id, wp->mapped, wp->realized, wp->parent->realized);*/
#define OLDWAY 0
#if OLDWAY /* old way, doesn't quite work with unmap/map yourself*/
/*
* If window is already realized, or if window
* isn't set to be mapped, or parent isn't
* realized, then we're done
*/
if (wp->realized || !wp->mapped || !wp->parent->realized)
return;
#else /* new way, still small bug with xfreecell and popup windows*/
/* if window is already realized, we're done*/
if (wp->realized)
return;
/*
* Send map update event for window manager or others
*/
/* send map update event if not temp unmap/map*/
if (!temp) {
GsDeliverUpdateEvent(wp, GR_UPDATE_MAP, wp->x, wp->y,
wp->width, wp->height);
}
/*
* If window isn't set to be mapped, or parent isn't
* realized, then we're done
*/
if (!wp->mapped || !wp->parent->realized)
return;
#endif
/* set window visible flag*/
wp->realized = GR_TRUE;
if (!temp) {
GsCheckMouseWindow();
GsCheckFocusWindow();
GsCheckCursor();
}
#if OLDWAY
/* send map update event if not temp unmap/map*/
if (!temp) {
GsDeliverUpdateEvent(wp, GR_UPDATE_MAP, wp->x, wp->y,
wp->width, wp->height);
}
#endif
/*
* If the window is an output window, then draw its border,
* clear it to the background color, and generate an exposure event.
*/
if (wp->output) {
GsDrawBorder(wp);
GsWpClearWindow(wp, 0, 0, wp->width, wp->height, GR_TRUE);
}
/*
* Do the same thing for the children.
*/
for (wp = wp->children; wp; wp = wp->siblings)
GsWpRealizeWindow(wp, temp);
}
