/usr/src/RPM/BUILD/ctwm-4.1.0/icons.c

Go to the documentation of this file.

/*
 * 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;
}