xref: /xsrc/external/mit/ctwm/dist/icons.c

/*
 * Copyright 1989 Massachusetts Institute of Technology
 * Copyright 1992 Claude Lecommandeur.
 */

/**********************************************************************
 *
 * $XConsortium: icons.c,v 1.22 91/07/12 09:58:38 dave Exp $
 *
 * Icon releated routines
 *
 * 10-Apr-89 Tom LaStrange        Initial Version.
 *
 * Do the necessary modification to be integrated in ctwm.
 * Can no longer be used for the standard twm.
 *
 * 22-April-92 Claude Lecommandeur.
 *
 *
 **********************************************************************/

#include "ctwm.h"

#include <stdio.h>
#include <stdlib.h>

#include <X11/extensions/shape.h>

#include "drawing.h"
#include "screen.h"
#include "iconmgr.h"
#include "icons.h"
#include "otp.h"
#include "list.h"
#include "parse.h"
#include "util.h"
#include "animate.h"
#include "image.h"
#include "win_utils.h"
#include "workspace_manager.h"
#include "xparsegeometry.h"


static void splitIconRegionEntry(IconEntry *ie, RegGravity grav1,
                                 RegGravity grav2, int w, int h);
static void PlaceIcon(TwmWindow *tmp_win, int def_x, int def_y,
                      int *final_x, int *final_y);
static IconEntry *FindIconEntry(TwmWindow *tmp_win, IconRegion **irp);
static IconEntry *prevIconEntry(IconEntry *ie, IconRegion *ir);
static void mergeEntries(IconEntry *old, IconEntry *ie);
static void ReshapeIcon(Icon *icon);
static int roundUp(int v, int multiple);
static Image *LookupIconNameOrClass(TwmWindow *tmp_win, Icon *icon,
                                    char **pattern);



/*
 ****************************************************************
 *
 * First some bits related to figuring out where icons go.  Lots of
 * IconRegion handling stuff, handling of IconEntry tracking, etc.
 *
 ****************************************************************
 */


/*
 * This function operates in very weird and obtuse ways, especially in
 * how it handles vertical vs. horizontal in weird recursive calls.  Part
 * of this is what previously allowed specs with "hgrav vgrav" instead of
 * the proper "vgrav hgrav" to sorta-work.  This should be broken up at
 * some point into clean h/v functions, but because of the recursion it's
 * not exactly trivial.  The parsing code now enforces v/h, so at least
 * things can be known to come in in the right order initially.  Revisit
 * someday.
 */
static void
splitIconRegionEntry(IconEntry *ie, RegGravity grav1, RegGravity grav2,
                     int w, int h)
{
	switch(grav1) {
		case GRAV_NORTH:
		case GRAV_SOUTH:
			if(w != ie->w) {
				splitIconRegionEntry(ie, grav2, grav1, w, ie->h);
			}
			if(h != ie->h) {
				IconEntry *new = calloc(1, sizeof(IconEntry));
				new->next = ie->next;
				ie->next = new;
				new->x = ie->x;
				new->h = (ie->h - h);
				new->w = ie->w;
				ie->h = h;
				if(grav1 == GRAV_SOUTH) {
					new->y = ie->y;
					ie->y = new->y + new->h;
				}
				else {
					new->y = ie->y + ie->h;
				}
			}
			break;
		case GRAV_EAST:
		case GRAV_WEST:
			if(h != ie->h) {
				splitIconRegionEntry(ie, grav2, grav1, ie->w, h);
			}
			if(w != ie->w) {
				IconEntry *new = calloc(1, sizeof(IconEntry));
				new->next = ie->next;
				ie->next = new;
				new->y = ie->y;
				new->w = (ie->w - w);
				new->h = ie->h;
				ie->w = w;
				if(grav1 == GRAV_EAST) {
					new->x = ie->x;
					ie->x = new->x + new->w;
				}
				else {
					new->x = ie->x + ie->w;
				}
			}
			break;
	}
}


/*
 * Backend for parsing IconRegion config
 */
name_list **
AddIconRegion(const char *geom, RegGravity grav1, RegGravity grav2,
              int stepx, int stepy,
              const char *ijust, const char *just, const char *align)
{
	IconRegion *ir;
	int mask, tmp;

	ir = malloc(sizeof(IconRegion));
	ir->next = NULL;

	if(Scr->LastRegion) {
		Scr->LastRegion->next = ir;
	}
	Scr->LastRegion = ir;
	if(!Scr->FirstRegion) {
		Scr->FirstRegion = ir;
	}

	ir->entries = NULL;
	ir->clientlist = NULL;
	ir->grav1 = grav1;
	ir->grav2 = grav2;
	if(stepx <= 0) {
		stepx = 1;
	}
	if(stepy <= 0) {
		stepy = 1;
	}
	ir->stepx = stepx;
	ir->stepy = stepy;
	ir->x = ir->y = ir->w = ir->h = 0;

	mask = RLayoutXParseGeometry(Scr->Layout, geom, &ir->x, &ir->y,
	                             (unsigned int *)&ir->w, (unsigned int *)&ir->h);

	if(mask & XNegative) {
		ir->x += Scr->rootw - ir->w;
	}
	if(mask & YNegative) {
		ir->y += Scr->rooth - ir->h;
	}

	ir->entries = calloc(1, sizeof(IconEntry));
	ir->entries->x = ir->x;
	ir->entries->y = ir->y;
	ir->entries->w = ir->w;
	ir->entries->h = ir->h;

	if((tmp = ParseTitleJustification(ijust)) < 0) {
		twmrc_error_prefix();
		fprintf(stderr, "ignoring invalid IconRegion argument \"%s\"\n", ijust);
		tmp = TJ_UNDEF;
	}
	ir->TitleJustification = tmp;

	if((tmp = ParseIRJustification(just)) < 0) {
		twmrc_error_prefix();
		fprintf(stderr, "ignoring invalid IconRegion argument \"%s\"\n", just);
		tmp = IRJ_UNDEF;
	}
	ir->Justification = tmp;

	if((tmp = ParseAlignement(align)) < 0) {
		twmrc_error_prefix();
		fprintf(stderr, "ignoring invalid IconRegion argument \"%s\"\n", align);
		tmp = IRA_UNDEF;
	}
	ir->Alignement = tmp;

	return(&(ir->clientlist));
}


/*
 * Figure out where to put a window's icon based on the IconRegion
 * specifications given in config.  Passed def_[xy] which are used
 * if we don't find a better location ourselves.  Returns the chosen
 * location in final_[xy], and also sets the IconRegion in tmp_win->icon
 * if we chose one.
 */
static void
PlaceIcon(TwmWindow *tmp_win, int def_x, int def_y,
          int *final_x, int *final_y)
{
	IconRegion  *ir, *oldir;
	IconEntry   *ie;
	int         w, h;

	const int iconWidth = tmp_win->icon->border_width * 2
	                      + (Scr->ShrinkIconTitles ? tmp_win->icon->width
	                         : tmp_win->icon->w_width);
	const int iconHeight = tmp_win->icon->border_width * 2
	                       + tmp_win->icon->w_height;

	/*
	 * First, check to see if the window is in a region's client list
	 * (i.e., the win-list on an IconRegion specifier in the config).
	 */
	ie = NULL;
	for(ir = Scr->FirstRegion; ir; ir = ir->next) {
		if(LookInList(ir->clientlist, tmp_win->name, &tmp_win->class)) {
			/*
			 * Found one that claims it.  Figure the necessary local
			 * size, based on the icon's side itself and the grid for
			 * this IR.
			 */
			w = roundUp(iconWidth, ir->stepx);
			h = roundUp(iconHeight, ir->stepy);

			/* Find a currently-unused region that's big enough */
			for(ie = ir->entries; ie; ie = ie->next) {
				if(ie->used) {
					continue;
				}
				if(ie->w >= w && ie->h >= h) {
					/* Bingo */
					break;
				}
			}

			/* If we found one, we're done here */
			if(ie) {
				break;
			}
		}
	}


	/*
	 * If we found a slot in a region claiming it, ie is set to the
	 * IconEntry.  If not, start over and find the first available berth.
	 */
	if(!ie) {
		for(ir = Scr->FirstRegion; ir; ir = ir->next) {
			w = roundUp(iconWidth, ir->stepx);
			h = roundUp(iconHeight, ir->stepy);
			for(ie = ir->entries; ie; ie = ie->next) {
				if(ie->used) {
					continue;
				}
				if(ie->w >= w && ie->h >= h) {
					/* Bingo */
					break;
				}
			}
			if(ie) {
				break;
			}
		}
	}

	/* Stash for comparison */
	oldir = tmp_win->icon->ir;

	/*
	 * If we found an appropriate region, use it.  Else, we have no
	 * better idea, so use the x/y coords the caller passed us as our
	 * basis.
	 */
	if(ie) {
		/* XXX whatever sIRE() does */
		splitIconRegionEntry(ie, ir->grav1, ir->grav2, w, h);

		/* Adjust horizontal positioning based on IconRegionJustification */
		switch(ir->Justification) {
			case IRJ_LEFT:
				*final_x = ie->x;
				break;
			case IRJ_UNDEF:
			case IRJ_CENTER:
				*final_x = ie->x + (ie->w - iconWidth) / 2;
				break;
			case IRJ_RIGHT:
				*final_x = ie->x + ie->w - iconWidth;
				break;
			case IRJ_BORDER:
				if(ir->grav2 == GRAV_EAST) {
					*final_x = ie->x + ie->w - iconWidth;
				}
				else {
					*final_x = ie->x;
				}
				break;
		}

		/* And vertical based on IconRegionAlignement */
		switch(ir->Alignement) {
			case IRA_TOP :
				*final_y = ie->y;
				break;
			case IRA_UNDEF :
			case IRA_CENTER :
				*final_y = ie->y + (ie->h - iconHeight) / 2;
				break;
			case IRA_BOTTOM :
				*final_y = ie->y + ie->h - iconHeight;
				break;
			case IRA_BORDER :
				if(ir->grav1 == GRAV_SOUTH) {
					*final_y = ie->y + ie->h - iconHeight;
				}
				else {
					*final_y = ie->y;
				}
				break;
		}

		/* Tell the win/icon what region it's in, and the entry what's in it */
		tmp_win->icon->ir = ir;
		ie->used = true;
		ie->twm_win = tmp_win;
	}
	else {
		/* No better idea, tell caller to use theirs */
		*final_x = def_x;
		*final_y = def_y;
		tmp_win->icon->ir = NULL;
		return;
		/* XXX Should we be doing the below in this case too? */
	}

	/* Alterations if ShrinkIconTitles is set */
	if(Scr->ShrinkIconTitles && tmp_win->icon->has_title) {
		*final_x -= GetIconOffset(tmp_win->icon);
		if(tmp_win->icon->ir != oldir) {
			ReshapeIcon(tmp_win->icon);
		}
	}

	return;
}


/*
 * Look up an IconEntry holding the icon for a given window, and
 * optionally stash its IconRegion in irp.  Used internally in
 * IconDown().
 */
static IconEntry *
FindIconEntry(TwmWindow *tmp_win, IconRegion **irp)
{
	IconRegion  *ir;
	IconEntry   *ie;

	for(ir = Scr->FirstRegion; ir; ir = ir->next) {
		for(ie = ir->entries; ie; ie = ie->next)
			if(ie->twm_win == tmp_win) {
				if(irp) {
					*irp = ir;
				}
				return ie;
			}
	}
	return NULL;
}


/*
 * Find prior IE in list.  Used internally in IconDown().
 */
static IconEntry *
prevIconEntry(IconEntry *ie, IconRegion *ir)
{
	IconEntry   *ip;

	if(ie == ir->entries) {
		return NULL;
	}
	for(ip = ir->entries; ip->next != ie; ip = ip->next)
		;
	return ip;
}


/*
 * Merge two adjacent IconEntry's.  old is being freed; and is adjacent
 * to ie.  Merge regions together.
 */
static void
mergeEntries(IconEntry *old, IconEntry *ie)
{
	if(old->y == ie->y) {
		ie->w = old->w + ie->w;
		if(old->x < ie->x) {
			ie->x = old->x;
		}
	}
	else {
		ie->h = old->h + ie->h;
		if(old->y < ie->y) {
			ie->y = old->y;
		}
	}
}




/*
 ****************************************************************
 *
 * Next, the bits related to creating and putting together the icon
 * windows, as well as destroying them.
 *
 ****************************************************************
 */


/*
 * Create the window scaffolding for an icon.  Called when we need to
 * make one, e.g. the first time a window is iconified.
 */
void
CreateIconWindow(TwmWindow *tmp_win, int def_x, int def_y)
{
	unsigned long event_mask;
	unsigned long valuemask;            /* mask for create windows */
	XSetWindowAttributes attributes;    /* attributes for create windows */
	int final_x, final_y;
	int x;
	Icon        *icon;
	Image       *image = NULL;
	char        *pattern;

	icon = malloc(sizeof(struct Icon));

	icon->otp           = NULL;
	icon->border        = Scr->IconBorderColor;
	icon->iconc.fore    = Scr->IconC.fore;
	icon->iconc.back    = Scr->IconC.back;
	icon->title_shrunk  = false;

	GetColorFromList(Scr->IconBorderColorL, tmp_win->name, &tmp_win->class,
	                 &icon->border);
	GetColorFromList(Scr->IconForegroundL, tmp_win->name, &tmp_win->class,
	                 &icon->iconc.fore);
	GetColorFromList(Scr->IconBackgroundL, tmp_win->name, &tmp_win->class,
	                 &icon->iconc.back);
	if(Scr->use3Diconmanagers && !Scr->BeNiceToColormap) {
		GetShadeColors(&icon->iconc);
	}

	FB(icon->iconc.fore, icon->iconc.back);

	icon->match   = match_none;
	icon->image   = NULL;
	icon->ir      = NULL;

	tmp_win->forced = false;
	icon->w_not_ours = false;

	pattern = NULL;

	/* now go through the steps to get an icon window,  if ForceIcon is
	 * set, then no matter what else is defined, the bitmap from the
	 * .twmrc file is used
	 */
	if(Scr->ForceIcon) {
		image = LookupIconNameOrClass(tmp_win, icon, &pattern);
	}

#ifdef EWMH
	/*
	 * Look to see if there is a _NET_WM_ICON property to provide an icon.
	 */
	if(image == NULL) {
		image = EwmhGetIcon(Scr, tmp_win);
		if(image != NULL) {
			icon->match   = match_net_wm_icon;
			icon->width   = image->width;
			icon->height  = image->height;
			icon->image   = image;
		}
	}
#endif /* EWMH */

	/* if the pixmap is still NULL, we didn't get one from the above code,
	 * that could mean that ForceIcon was not set, or that the window
	 * was not in the Icons list, now check the WM hints for an icon
	 */
	if(image == NULL && tmp_win->wmhints->flags & IconPixmapHint) {
		unsigned int IconDepth, IconWidth, IconHeight;

		if(XGetGeometry(dpy, tmp_win->wmhints->icon_pixmap,
		                &JunkRoot, &JunkX, &JunkY, &IconWidth, &IconHeight, &JunkBW, &IconDepth)) {
			image = AllocImage();
			image->width  = IconWidth;
			image->height = IconHeight;
			image->pixmap = XCreatePixmap(dpy, Scr->Root, image->width,
			                              image->height, Scr->d_depth);
			if(IconDepth == Scr->d_depth)
				XCopyArea(dpy, tmp_win->wmhints->icon_pixmap, image->pixmap, Scr->NormalGC,
				          0, 0, image->width, image->height, 0, 0);
			else
				XCopyPlane(dpy, tmp_win->wmhints->icon_pixmap, image->pixmap, Scr->NormalGC,
				           0, 0, image->width, image->height, 0, 0, 1);

			icon->width   = image->width;
			icon->height  = image->height;
			icon->match   = match_icon_pixmap_hint;

			if((tmp_win->wmhints->flags & IconMaskHint) &&
			                XGetGeometry(dpy, tmp_win->wmhints->icon_mask,
			                             &JunkRoot, &JunkX, &JunkY, &IconWidth, &IconHeight, &JunkBW, &IconDepth) &&
			                (IconDepth == 1)) {
				GC gc;

				image->mask = XCreatePixmap(dpy, Scr->Root, IconWidth, IconHeight, 1);
				if(image->mask) {
					gc = XCreateGC(dpy, image->mask, 0, NULL);
					if(gc) {
						XCopyArea(dpy, tmp_win->wmhints->icon_mask, image->mask, gc,
						          0, 0, IconWidth, IconHeight, 0, 0);
						XFreeGC(dpy, gc);
					}
				}
			}
			icon->image = image;
		}
	}

	/* if we still haven't got an icon, let's look in the Icon list
	 * if ForceIcon is not set
	 */
	if(image == NULL && !Scr->ForceIcon) {
		image = LookupIconNameOrClass(tmp_win, icon, &pattern);
	}

	/* if we still don't have an icon, assign the UnknownIcon */
	if(image == NULL && Scr->UnknownImage != NULL) {
		image = Scr->UnknownImage;
		icon->match   = match_unknown_default;
		icon->width   = image->width;
		icon->height  = image->height;
		icon->image   = image;
	}

	if(image == NULL) {
		icon->height = 0;
		icon->width  = 0;
		valuemask    = 0;
	}
	else {
		valuemask = CWBackPixmap;
		attributes.background_pixmap = image->pixmap;
	}

	icon->border_width = Scr->IconBorderWidth;
	if(Scr->NoIconTitlebar ||
	                LookInNameList(Scr->NoIconTitle, tmp_win->icon_name) ||
	                LookInList(Scr->NoIconTitle, tmp_win->name, &tmp_win->class)) {
		icon->w_width  = icon->width;
		icon->w_height = icon->height;
		icon->x = 0;
		icon->y = 0;
		icon->has_title = false;
	}
	else {
		XRectangle inc_rect;
		XRectangle logical_rect;

		XmbTextExtents(Scr->IconFont.font_set,
		               tmp_win->icon_name, strlen(tmp_win->icon_name),
		               &inc_rect, &logical_rect);
		icon->w_width = logical_rect.width;

		icon->w_width += 2 * (Scr->IconManagerShadowDepth + ICON_MGR_IBORDER);
		if(icon->w_width > Scr->MaxIconTitleWidth) {
			icon->w_width = Scr->MaxIconTitleWidth;
		}
		if(icon->w_width < icon->width) {
			icon->x  = (icon->width - icon->w_width) / 2;
			icon->x += Scr->IconManagerShadowDepth + ICON_MGR_IBORDER;
			icon->w_width = icon->width;
		}
		else {
			icon->x = Scr->IconManagerShadowDepth + ICON_MGR_IBORDER;
		}
		icon->y = icon->height + Scr->IconFont.height + Scr->IconManagerShadowDepth;
		icon->w_height = icon->height + Scr->IconFont.height +
		                 2 * (Scr->IconManagerShadowDepth + ICON_MGR_IBORDER);
		icon->has_title = true;
		if(icon->height) {
			icon->border_width = 0;
		}
	}

	event_mask = 0;
	if(tmp_win->wmhints->flags & IconWindowHint) {
		icon->w = tmp_win->wmhints->icon_window;
		if(tmp_win->forced ||
		                XGetGeometry(dpy, icon->w, &JunkRoot, &JunkX, &JunkY,
		                             (unsigned int *)&icon->w_width, (unsigned int *)&icon->w_height,
		                             &JunkBW, &JunkDepth) == 0) {
			icon->w = None;
			tmp_win->wmhints->flags &= ~IconWindowHint;
		}
		else {
			image = NULL;
			icon->w_not_ours = true;
			icon->width  = icon->w_width;
			icon->height = icon->w_height;
			icon->image  = image;
			icon->has_title = false;
			event_mask = 0;
		}
	}
	else {
		icon->w = None;
	}

	if((image != NULL) &&
	                image->mask != None &&
	                !(tmp_win->wmhints->flags & IconWindowHint)) {
		icon->border_width = 0;
	}
	if(icon->w == None) {
		icon->w = XCreateSimpleWindow(dpy, Scr->Root,
		                              0, 0,
		                              icon->w_width, icon->w_height,
		                              icon->border_width, icon->border, icon->iconc.back);
		event_mask = ExposureMask;
	}

	if(Scr->AutoRaiseIcons || Scr->ShrinkIconTitles) {
		event_mask |= EnterWindowMask | LeaveWindowMask;
	}
	event_mask |= KeyPressMask | ButtonPressMask | ButtonReleaseMask;

	if(icon->w_not_ours) {
		XWindowAttributes wattr;

		XGetWindowAttributes(dpy, icon->w, &wattr);
		if(wattr.all_event_masks & ButtonPressMask) {
			event_mask &= ~ButtonPressMask;
		}
	}
	XSelectInput(dpy, icon->w, event_mask);

	if(icon->width == 0) {
		icon->width = icon->w_width;
	}
	icon->bm_w = None;
	if(image && !(tmp_win->wmhints->flags & IconWindowHint)) {
		XRectangle rect;

		x = GetIconOffset(icon);
		icon->bm_w = XCreateWindow(dpy, icon->w, x, 0,
		                           icon->width,
		                           icon->height,
		                           0, Scr->d_depth,
		                           CopyFromParent,
		                           Scr->d_visual, valuemask,
		                           &attributes);
		if(image->mask) {
			XShapeCombineMask(dpy, icon->bm_w, ShapeBounding, 0, 0, image->mask, ShapeSet);
			XShapeCombineMask(dpy, icon->w,    ShapeBounding, x, 0, image->mask, ShapeSet);
		}
		else if(icon->has_title) {
			rect.x      = x;
			rect.y      = 0;
			rect.width  = icon->width;
			rect.height = icon->height;
			XShapeCombineRectangles(dpy, icon->w, ShapeBounding,
			                        0, 0, &rect, 1, ShapeSet, 0);
		}
		if(icon->has_title) {
			if(Scr->ShrinkIconTitles) {
				rect.x      = x;
				rect.y      = icon->height;
				rect.width  = icon->width;
				rect.height = icon->w_height - icon->height;
				icon->title_shrunk = true;
			}
			else {
				rect.x      = 0;
				rect.y      = icon->height;
				rect.width  = icon->w_width;
				rect.height = icon->w_height - icon->height;
				icon->title_shrunk = false;
			}
			XShapeCombineRectangles(dpy, icon->w, ShapeBounding,
			                        0, 0, &rect, 1, ShapeUnion, 0);
		}
	}

	if(pattern != NULL) {
		AddToList(&tmp_win->iconslist, pattern, icon);
	}

	tmp_win->icon = icon;
	/* I need to figure out where to put the icon window now, because
	 * getting here means that I am going to make the icon visible
	 */
	final_x = final_y = 0;
	if(tmp_win->wmhints->flags & IconPositionHint) {
		final_x = tmp_win->wmhints->icon_x;
		final_y = tmp_win->wmhints->icon_y;
	}
	else {
		if(visible(tmp_win)) {
			PlaceIcon(tmp_win, def_x, def_y, &final_x, &final_y);
		}
	}

	if(visible(tmp_win) || (tmp_win->wmhints->flags & IconPositionHint)) {
		if(final_x > Scr->rootw) {
			final_x = Scr->rootw - icon->w_width - (2 * Scr->IconBorderWidth);
		}
		if(Scr->ShrinkIconTitles && icon->bm_w) {
			if(final_x + (icon->w_width - icon->width) < 0) {
				final_x = 0;
			}
		}
		else {
			if(final_x < 0) {
				final_x = 0;
			}
		}
		if(final_y > Scr->rooth)
			final_y = Scr->rooth - icon->height -
			          Scr->IconFont.height - 6 - (2 * Scr->IconBorderWidth);
		if(final_y < 0) {
			final_y = 0;
		}

		XMoveWindow(dpy, icon->w, final_x, final_y);
		icon->w_x = final_x;
		icon->w_y = final_y;
	}
	tmp_win->iconified = true;
	OtpAdd(tmp_win, IconWin);

	XMapSubwindows(dpy, icon->w);
	XSaveContext(dpy, icon->w, TwmContext, (XPointer)tmp_win);
	XSaveContext(dpy, icon->w, ScreenContext, (XPointer)Scr);
	XDefineCursor(dpy, icon->w, Scr->IconCursor);
	MaybeAnimate = true;
}


/*
 * Delete TwmWindow.iconslist.
 * Call it before deleting TwmWindow.icon, since we need to check
 * that we're not deleting that Icon.
 */
void
DeleteIconsList(TwmWindow *tmp_win)
{
	/*
	 * Only the list itself needs to be freed, since the pointers it
	 * contains point into various lists that belong to Scr.
	 *
	 * Rhialto: Hmmmm not quite sure about that! CreateIconWindow() above
	 * always allocates a struct Icon, and doesn't attach it to Scr...
	 * It is probably correct for the Image pointers inside those Icons though.
	 */
	name_list *nptr;
	name_list *next;

	for(nptr = tmp_win->iconslist; nptr != NULL;) {
		next = nptr->next;
		Icon *icon = (Icon *)nptr->ptr;
		if(icon != tmp_win->icon) {
			DeleteIcon(icon);
		}
		free(nptr->name);
		free(nptr);
		nptr = next;
	}
	tmp_win->iconslist = NULL;
}


/*
 * Delete a single Icon.  Called iteratively from DeleteIconList(), and
 * directly during window destruction.
 */
void
DeleteIcon(Icon *icon)
{
	if(icon->w && !icon->w_not_ours) {
		XDestroyWindow(dpy, icon->w);
	}
	ReleaseIconImage(icon);
	free(icon);
}


/*
 * Delete the Image from an icon, if it is not a shared one.  match_list
 * ands match_unknown_default need not be freed.
 *
 * Formerly ReleaseImage()
 */
void
ReleaseIconImage(Icon *icon)
{
	if(icon->match == match_icon_pixmap_hint ||
	                icon->match == match_net_wm_icon) {
		FreeImage(icon->image);
	}
}




/*
 ****************************************************************
 *
 * Bringing an icon up or down.
 *
 ****************************************************************
 */


/*
 * Show up an icon.  Note that neither IconUp nor IconDown actually map
 * or unmap the icon window; that's handled by the callers.  These
 * functions limit themselves to figuring out where it should be, moving
 * it (still unmapped) there, and linking/unlinking it from the iconentry
 * lists.
 */
void
IconUp(TwmWindow *tmp_win)
{
	int         x, y;
	int         defx, defy;

	/*
	 * If the client specified a particular location, let's use it (this might
	 * want to be an option at some point).  Otherwise, try to fit within the
	 * icon region.
	 */
	if(tmp_win->wmhints->flags & IconPositionHint) {
		return;
	}

	if(tmp_win->icon_moved) {
		struct IconRegion *ir;
		unsigned int iww, iwh;

		if(!XGetGeometry(dpy, tmp_win->icon->w, &JunkRoot, &defx, &defy,
		                 &iww, &iwh, &JunkBW, &JunkDepth)) {
			return;
		}

		x = defx + ((int) iww) / 2;
		y = defy + ((int) iwh) / 2;

		for(ir = Scr->FirstRegion; ir; ir = ir->next) {
			if(x >= ir->x && x < (ir->x + ir->w) &&
			                y >= ir->y && y < (ir->y + ir->h)) {
				break;
			}
		}
		if(!ir) {
			return;        /* outside icon regions, leave alone */
		}
	}

	defx = -100;
	defy = -100;
	PlaceIcon(tmp_win, defx, defy, &x, &y);
	if(x != defx || y != defy) {
		XMoveWindow(dpy, tmp_win->icon->w, x, y);
		tmp_win->icon->w_x = x;
		tmp_win->icon->w_y = y;
		tmp_win->icon_moved = false;    /* since we've restored it */
	}
	MaybeAnimate = true;
	return;
}


/*
 * Remove an icon from its displayed IconEntry.  x-ref comment on
 * IconUp().
 */
void
IconDown(TwmWindow *tmp_win)
{
	IconEntry   *ie, *ip, *in;
	IconRegion  *ir;

	ie = FindIconEntry(tmp_win, &ir);
	if(ie) {
		ie->twm_win = NULL;
		ie->used = false;
		ip = prevIconEntry(ie, ir);
		in = ie->next;
		for(;;) {
			if(ip && ip->used == false &&
			                ((ip->x == ie->x && ip->w == ie->w) ||
			                 (ip->y == ie->y && ip->h == ie->h))) {
				ip->next = ie->next;
				mergeEntries(ie, ip);
				free(ie);
				ie = ip;
				ip = prevIconEntry(ip, ir);
			}
			else if(in && in->used == false &&
			                ((in->x == ie->x && in->w == ie->w) ||
			                 (in->y == ie->y && in->h == ie->h))) {
				ie->next = in->next;
				mergeEntries(in, ie);
				free(in);
				in = ie->next;
			}
			else {
				break;
			}
		}
	}
}




/*
 ****************************************************************
 *
 * Funcs related to drawing the icon.
 *
 ****************************************************************
 */


/*
 * Slightly misnamed: draws the text label under an icon.
 */
void
PaintIcon(TwmWindow *tmp_win)
{
	int         width, twidth, mwidth, len, x;
	Icon        *icon;
	XRectangle ink_rect;
	XRectangle logical_rect;

	if(!tmp_win || !tmp_win->icon) {
		return;
	}
	icon = tmp_win->icon;
	if(!icon->has_title) {
		return;
	}

	x     = 0;
	width = icon->w_width;
	if(Scr->ShrinkIconTitles && icon->title_shrunk) {
		x     = GetIconOffset(icon);
		width = icon->width;
	}
	len    = strlen(tmp_win->icon_name);
	XmbTextExtents(Scr->IconFont.font_set,
	               tmp_win->icon_name, len,
	               &ink_rect, &logical_rect);
	twidth = logical_rect.width;
	mwidth = width - 2 * (Scr->IconManagerShadowDepth + ICON_MGR_IBORDER);
	if(Scr->use3Diconmanagers) {
		Draw3DBorder(icon->w, x, icon->height, width,
		             Scr->IconFont.height +
		             2 * (Scr->IconManagerShadowDepth + ICON_MGR_IBORDER),
		             Scr->IconManagerShadowDepth, icon->iconc, off, false, false);
	}
	while((len > 0) && (twidth > mwidth)) {
		len--;
		XmbTextExtents(Scr->IconFont.font_set,
		               tmp_win->icon_name, len,
		               &ink_rect, &logical_rect);
		twidth = logical_rect.width;
	}
	FB(icon->iconc.fore, icon->iconc.back);
	XmbDrawString(dpy, icon->w, Scr->IconFont.font_set, Scr->NormalGC,
	              x + ((mwidth - twidth) / 2) +
	              Scr->IconManagerShadowDepth + ICON_MGR_IBORDER,
	              icon->y, tmp_win->icon_name, len);
}


/*
 * Handling for ShrinkIconTitles; when pointer is away from them, shrink
 * the titles down to the width of the image, and expand back out when it
 * enters.
 */
void
ShrinkIconTitle(TwmWindow *tmp_win)
{
	Icon        *icon;
	XRectangle  rect;

	if(!tmp_win || !tmp_win->icon) {
		return;
	}
	icon = tmp_win->icon;
	if(!icon->has_title) {
		return;
	}
	if(icon->w_width == icon->width) {
		return;
	}
	if(icon->height  == 0) {
		return;
	}

	rect.x      = GetIconOffset(icon);
	rect.y      = 0;
	rect.width  = icon->width;
	rect.height = icon->w_height;
	XShapeCombineRectangles(dpy, icon->w, ShapeBounding, 0, 0, &rect, 1,
	                        ShapeIntersect, 0);
	icon->title_shrunk = true;
	XClearArea(dpy, icon->w, 0, icon->height, icon->w_width,
	           icon->w_height - icon->height, True);
}


void
ExpandIconTitle(TwmWindow *tmp_win)
{
	Icon        *icon;
	XRectangle  rect;

	if(!tmp_win || !tmp_win->icon) {
		return;
	}
	icon = tmp_win->icon;
	if(!icon->has_title) {
		return;
	}
	if(icon->w_width == icon->width) {
		return;
	}
	if(icon->height  == 0) {
		return;
	}

	rect.x      = 0;
	rect.y      = icon->height;
	rect.width  = icon->w_width;
	rect.height = icon->w_height - icon->height;
	XShapeCombineRectangles(dpy, icon->w, ShapeBounding, 0, 0, &rect, 1, ShapeUnion,
	                        0);
	icon->title_shrunk = false;
	XClearArea(dpy, icon->w, 0, icon->height, icon->w_width,
	           icon->w_height - icon->height, True);
}


/*
 * Setup X Shape'ing around icons and their titles.
 *
 * XXX should this be checking HasShape?  It seems to be called
 * unconditionally...
 */
static void
ReshapeIcon(Icon *icon)
{
	int x;
	XRectangle  rect;

	if(!icon) {
		return;
	}
	x = GetIconOffset(icon);
	XMoveWindow(dpy, icon->bm_w, x, 0);

	if(icon->image && icon->image->mask) {
		XShapeCombineMask(dpy, icon->w, ShapeBounding, x, 0, icon->image->mask,
		                  ShapeSet);
	}
	else {
		rect.x      = x;
		rect.y      = 0;
		rect.width  = icon->width;
		rect.height = icon->height;
		XShapeCombineRectangles(dpy, icon->w, ShapeBounding, 0, 0, &rect, 1, ShapeSet,
		                        0);
	}
	rect.x      = x;
	rect.y      = icon->height;
	rect.width  = icon->width;
	rect.height = icon->w_height - icon->height;
	XShapeCombineRectangles(dpy, icon->w, ShapeBounding, 0, 0, &rect, 1, ShapeUnion,
	                        0);
}


/*
 * Figure horizontal positioning/offset for the icon image within its
 * window.
 */
int
GetIconOffset(Icon *icon)
{
	TitleJust justif;

	if(!icon) {
		return 0;
	}

	justif = icon->ir ? icon->ir->TitleJustification : Scr->IconJustification;
	switch(justif) {
		case TJ_LEFT:
			return 0;

		case TJ_CENTER:
			return ((icon->w_width - icon->width) / 2);

		case TJ_RIGHT:
			return (icon->w_width - icon->width);

		default:
			/* Can't happen? */
			fprintf(stderr, "%s(): Invalid TitleJustification %d\n",
			        __func__, justif);
			return 0;
	}
}


/*
 * [Re-]lookup the image for an icon and [re-]layout it.
 */
void
RedoIcon(TwmWindow *win)
{
	Icon *icon, *old_icon;
	char *pattern;

	old_icon = win->icon;

	if(old_icon && (old_icon->w_not_ours || old_icon->match != match_list)) {
		RedoIconName(win);
		return;
	}
	icon = NULL;
	if((pattern = LookPatternInNameList(Scr->IconNames, win->icon_name))) {
		icon = LookInNameList(win->iconslist, pattern);
	}
	else if((pattern = LookPatternInNameList(Scr->IconNames, win->name))) {
		icon = LookInNameList(win->iconslist, pattern);
	}
	else if((pattern = LookPatternInList(Scr->IconNames, win->name,
	                                     &win->class))) {
		icon = LookInNameList(win->iconslist, pattern);
	}
	if(pattern == NULL) {
		RedoIconName(win);
		return;
	}
	if(icon != NULL) {
		if(old_icon == icon) {
			RedoIconName(win);
			return;
		}
		if(win->icon_on && visible(win)) {
			IconDown(win);
			if(old_icon && old_icon->w) {
				XUnmapWindow(dpy, old_icon->w);
			}
			win->icon = icon;
			OtpReassignIcon(win, old_icon);
			IconUp(win);
			OtpRaise(win, IconWin);
			XMapWindow(dpy, win->icon->w);
		}
		else {
			win->icon = icon;
			OtpReassignIcon(win, old_icon);
		}
		RedoIconName(win);
	}
	else {
		if(win->icon_on && visible(win)) {
			IconDown(win);
			if(old_icon && old_icon->w) {
				XUnmapWindow(dpy, old_icon->w);
			}
			/*
			 * If the icon name/class was found on one of the above lists,
			 * the call to CreateIconWindow() will find it again there
			 * and keep track of it on win->iconslist for eventual
			 * deallocation. (It is now checked that the current struct
			 * Icon is also already on that list)
			 */
			OtpFreeIcon(win);
			bool saveForceIcon = Scr->ForceIcon;
			Scr->ForceIcon = true;
			CreateIconWindow(win, -100, -100);
			Scr->ForceIcon = saveForceIcon;
			OtpRaise(win, IconWin);
			XMapWindow(dpy, win->icon->w);
		}
		else {
			OtpFreeIcon(win);
			win->icon = NULL;
			WMapUpdateIconName(win);
		}
		RedoIconName(win);
	}
}


/*
 * Resize the icon window, and reposition the image and name within it.
 * (a lot of the actual repositioning gets done during the later expose).
 */
void
RedoIconName(TwmWindow *win)
{
	int x;
	XRectangle ink_rect;
	XRectangle logical_rect;

	if(Scr->NoIconTitlebar ||
	                LookInNameList(Scr->NoIconTitle, win->icon_name) ||
	                LookInList(Scr->NoIconTitle, win->name, &win->class)) {
		WMapUpdateIconName(win);
		return;
	}
	if(win->iconmanagerlist) {
		/* let the expose event cause the repaint */
		XClearArea(dpy, win->iconmanagerlist->w, 0, 0, 0, 0, True);

		if(Scr->SortIconMgr) {
			SortIconManager(win->iconmanagerlist->iconmgr);
		}
	}

	if(!win->icon  || !win->icon->w) {
		WMapUpdateIconName(win);
		return;
	}

	if(win->icon->w_not_ours) {
		WMapUpdateIconName(win);
		return;
	}

	XmbTextExtents(Scr->IconFont.font_set,
	               win->icon_name, strlen(win->icon_name),
	               &ink_rect, &logical_rect);
	win->icon->w_width = logical_rect.width;
	win->icon->w_width += 2 * (Scr->IconManagerShadowDepth + ICON_MGR_IBORDER);
	if(win->icon->w_width > Scr->MaxIconTitleWidth) {
		win->icon->w_width = Scr->MaxIconTitleWidth;
	}

	if(win->icon->w_width < win->icon->width) {
		win->icon->x = (win->icon->width - win->icon->w_width) / 2;
		win->icon->x += Scr->IconManagerShadowDepth + ICON_MGR_IBORDER;
		win->icon->w_width = win->icon->width;
	}
	else {
		win->icon->x = Scr->IconManagerShadowDepth + ICON_MGR_IBORDER;
	}

	x = GetIconOffset(win->icon);
	win->icon->y = win->icon->height + Scr->IconFont.height +
	               Scr->IconManagerShadowDepth;
	win->icon->w_height = win->icon->height + Scr->IconFont.height +
	                      2 * (Scr->IconManagerShadowDepth + ICON_MGR_IBORDER);

	XResizeWindow(dpy, win->icon->w, win->icon->w_width,
	              win->icon->w_height);
	if(win->icon->bm_w) {
		XRectangle rect;

		XMoveWindow(dpy, win->icon->bm_w, x, 0);
		XMapWindow(dpy, win->icon->bm_w);
		if(win->icon->image && win->icon->image->mask) {
			XShapeCombineMask(dpy, win->icon->bm_w, ShapeBounding, 0, 0,
			                  win->icon->image->mask, ShapeSet);
			XShapeCombineMask(dpy, win->icon->w, ShapeBounding, x, 0,
			                  win->icon->image->mask, ShapeSet);
		}
		else if(win->icon->has_title) {
			rect.x      = x;
			rect.y      = 0;
			rect.width  = win->icon->width;
			rect.height = win->icon->height;
			XShapeCombineRectangles(dpy, win->icon->w, ShapeBounding,
			                        0, 0, &rect, 1, ShapeSet, 0);
		}
		if(win->icon->has_title) {
			if(Scr->ShrinkIconTitles && win->icon->title_shrunk) {
				rect.x      = x;
				rect.y      = win->icon->height;
				rect.width  = win->icon->width;
				rect.height = win->icon->w_height - win->icon->height;
			}
			else {
				rect.x      = 0;
				rect.y      = win->icon->height;
				rect.width  = win->icon->w_width;
				rect.height = win->icon->w_height - win->icon->height;
			}
			XShapeCombineRectangles(dpy,  win->icon->w, ShapeBounding, 0,
			                        0, &rect, 1, ShapeUnion, 0);
		}
	}
	if(Scr->ShrinkIconTitles &&
	                win->icon->title_shrunk &&
	                win->icon_on && (visible(win))) {
		IconDown(win);
		IconUp(win);
	}
	if(win->isicon) {
		XClearArea(dpy, win->icon->w, 0, 0, 0, 0, True);
	}

	WMapUpdateIconName(win);
}




/*
 ****************************************************************
 *
 * Misc internal utils.
 *
 ****************************************************************
 */


/*
 * What it says on the tin.
 */
static int
roundUp(int v, int multiple)
{
	return ((v + multiple - 1) / multiple) * multiple;
}


/*
 * Find the image set in Icons{} for a TwmWindow if possible.  Return the
 * image, record its provenance inside *icon, and pass back what pattern
 * it matched in **pattern.
 */
static Image *
LookupIconNameOrClass(TwmWindow *tmp_win, Icon *icon, char **pattern)
{
	char *icon_name = NULL;
	Image *image;
	Matchtype matched = match_none;

	icon_name = LookInNameList(Scr->IconNames, tmp_win->icon_name);
	if(icon_name != NULL) {
		*pattern = LookPatternInNameList(Scr->IconNames, tmp_win->icon_name);
		matched = match_list;
	}

	if(matched == match_none) {
		icon_name = LookInNameList(Scr->IconNames, tmp_win->name);
		if(icon_name != NULL) {
			*pattern = LookPatternInNameList(Scr->IconNames, tmp_win->name);
			matched = match_list;
		}
	}

	if(matched == match_none) {
		icon_name = LookInList(Scr->IconNames, tmp_win->name, &tmp_win->class);
		if(icon_name != NULL) {
			*pattern = LookPatternInList(Scr->IconNames, tmp_win->name,
			                             &tmp_win->class);
			matched = match_list;
		}
	}

	if((image  = GetImage(icon_name, icon->iconc)) != NULL) {
		icon->match  = matched;
		icon->image  = image;
		icon->width  = image->width;
		icon->height = image->height;
		tmp_win->forced = true;
	}
	else {
		icon->match = match_none;
		*pattern = NULL;
	}

	return image;
}