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

Go to the documentation of this file.

/*
 * Builtin bitmap image generation/lookup.
 */
 
#include "ctwm.h"
 
#include <stdio.h>
#include <stdlib.h>
 
#include <X11/Xmu/Drawing.h>
 
#include "screen.h"
#include "drawing.h"
#include "icons_builtin.h"
 
#include "image.h"
#include "image_bitmap_builtin.h"
 
 
/*
 * Firstly, the plain built-in titlebar symbols.  These are the ones
 * specified with names like ":resize".  For various reasons, these
 * currently return Pixmap's, unlike most of our other builtins that
 * generate Image's.  Possible cleanup candidate.
 */
#define DEF_BI_PPM(nm) Pixmap nm(unsigned int *widthp, unsigned int *heightp)
static DEF_BI_PPM(CreateXLogoPixmap);
static DEF_BI_PPM(CreateResizePixmap);
static DEF_BI_PPM(CreateQuestionPixmap);
static DEF_BI_PPM(CreateMenuPixmap);
static DEF_BI_PPM(CreateDotPixmap);
 
 
 
/*
 * Look up and return a ":something" (not a ":xpm:something").
 *
 * Names of the form :name refer to hardcoded images that are scaled to
 * look nice in title buttons.  Eventually, it would be nice to put in a
 * menu symbol as well....
 */
Pixmap
get_builtin_plain_pixmap(const char *name, unsigned int *widthp,
                         unsigned int *heightp)
{
    int i;
    static struct {
        char *name;
        DEF_BI_PPM((*proc));
    } pmtab[] = {
        /* Lookup table for our various default pixmaps */
        { TBPM_DOT,         CreateDotPixmap },
        { TBPM_ICONIFY,     CreateDotPixmap },
        { TBPM_RESIZE,      CreateResizePixmap },
        { TBPM_XLOGO,       CreateXLogoPixmap },
        { TBPM_DELETE,      CreateXLogoPixmap },
        { TBPM_MENU,        CreateMenuPixmap },
        { TBPM_QUESTION,    CreateQuestionPixmap },
    };
 
    /* Seatbelts */
    if(!name || name[0] != ':') {
        return None;
    }
    if(!widthp || !heightp) {
        return None;
    }
 
 
    /* Find it */
    for(i = 0; i < (sizeof pmtab) / (sizeof pmtab[0]); i++) {
        if(strcasecmp(pmtab[i].name, name) == 0) {
            Pixmap pm = (*pmtab[i].proc)(widthp, heightp);
            if(pm == None) {
                fprintf(stderr, "%s:  unable to build bitmap \"%s\"\n",
                        ProgramName, name);
                return None;
            }
            return pm;
        }
    }
 
    /* Didn't find it */
    fprintf(stderr, "%s:  no such built-in bitmap \"%s\"\n",
            ProgramName, name);
    return None;
}
 
 
/*
 * Individual generators for those plain pixmaps
 */
DEF_BI_PPM(CreateXLogoPixmap)
{
    int h = Scr->TBInfo.width - Scr->TBInfo.border * 2;
    if(h < 0) {
        h = 0;
    }
 
    *widthp = *heightp = (unsigned int) h;
    if(Scr->tbpm.xlogo == None) {
        GC gc, gcBack;
 
        Scr->tbpm.xlogo = XCreatePixmap(dpy, Scr->Root, h, h, 1);
        gc = XCreateGC(dpy, Scr->tbpm.xlogo, 0L, NULL);
        XSetForeground(dpy, gc, 0);
        XFillRectangle(dpy, Scr->tbpm.xlogo, gc, 0, 0, h, h);
        XSetForeground(dpy, gc, 1);
        gcBack = XCreateGC(dpy, Scr->tbpm.xlogo, 0L, NULL);
        XSetForeground(dpy, gcBack, 0);
 
        /*
         * draw the logo large so that it gets as dense as possible; then white
         * out the edges so that they look crisp
         */
        XmuDrawLogo(dpy, Scr->tbpm.xlogo, gc, gcBack, -1, -1, h + 2, h + 2);
        XDrawRectangle(dpy, Scr->tbpm.xlogo, gcBack, 0, 0, h - 1, h - 1);
 
        /*
         * done drawing
         */
        XFreeGC(dpy, gc);
        XFreeGC(dpy, gcBack);
    }
    return Scr->tbpm.xlogo;
}
 
 
DEF_BI_PPM(CreateResizePixmap)
{
    int h = Scr->TBInfo.width - Scr->TBInfo.border * 2;
    if(h < 1) {
        h = 1;
    }
 
    *widthp = *heightp = (unsigned int) h;
    if(Scr->tbpm.resize == None) {
        XPoint  points[3];
        GC gc;
        int w;
        int lw;
 
        /*
         * create the pixmap
         */
        Scr->tbpm.resize = XCreatePixmap(dpy, Scr->Root, h, h, 1);
        gc = XCreateGC(dpy, Scr->tbpm.resize, 0L, NULL);
        XSetForeground(dpy, gc, 0);
        XFillRectangle(dpy, Scr->tbpm.resize, gc, 0, 0, h, h);
        XSetForeground(dpy, gc, 1);
        lw = h / 16;
        if(lw == 1) {
            lw = 0;
        }
        XSetLineAttributes(dpy, gc, lw, LineSolid, CapButt, JoinMiter);
 
        /*
         * draw the resize button,
         */
        w = (h * 2) / 3;
        points[0].x = w;
        points[0].y = 0;
        points[1].x = w;
        points[1].y = w;
        points[2].x = 0;
        points[2].y = w;
        XDrawLines(dpy, Scr->tbpm.resize, gc, points, 3, CoordModeOrigin);
        w = w / 2;
        points[0].x = w;
        points[0].y = 0;
        points[1].x = w;
        points[1].y = w;
        points[2].x = 0;
        points[2].y = w;
        XDrawLines(dpy, Scr->tbpm.resize, gc, points, 3, CoordModeOrigin);
 
        /*
         * done drawing
         */
        XFreeGC(dpy, gc);
    }
    return Scr->tbpm.resize;
}
 
 
#define questionmark_width 8
#define questionmark_height 8
static char questionmark_bits[] = {
    0x38, 0x7c, 0x64, 0x30, 0x18, 0x00, 0x18, 0x18
};
 
DEF_BI_PPM(CreateQuestionPixmap)
{
    *widthp = questionmark_width;
    *heightp = questionmark_height;
    if(Scr->tbpm.question == None) {
        Scr->tbpm.question = XCreateBitmapFromData(dpy, Scr->Root,
                             questionmark_bits,
                             questionmark_width,
                             questionmark_height);
    }
    /*
     * this must succeed or else we are in deep trouble elsewhere
     */
    return Scr->tbpm.question;
}
#undef questionmark_height
#undef questionmark_width
 
 
DEF_BI_PPM(CreateMenuPixmap)
{
    return (CreateMenuIcon(Scr->TBInfo.width - Scr->TBInfo.border * 2, widthp,
                           heightp));
}
 
DEF_BI_PPM(CreateDotPixmap)
{
    int h = Scr->TBInfo.width - Scr->TBInfo.border * 2;
 
    h = h * 3 / 4;
    if(h < 1) {
        h = 1;
    }
    if(!(h & 1)) {
        h--;
    }
    *widthp = *heightp = (unsigned int) h;
    if(Scr->tbpm.delete == None) {
        GC  gc;
        Pixmap pix;
 
        pix = Scr->tbpm.delete = XCreatePixmap(dpy, Scr->Root, h, h, 1);
        gc = XCreateGC(dpy, pix, 0L, NULL);
        XSetLineAttributes(dpy, gc, h, LineSolid, CapRound, JoinRound);
        XSetForeground(dpy, gc, 0L);
        XFillRectangle(dpy, pix, gc, 0, 0, h, h);
        XSetForeground(dpy, gc, 1L);
        XDrawLine(dpy, pix, gc, h / 2, h / 2, h / 2, h / 2);
        XFreeGC(dpy, gc);
    }
    return Scr->tbpm.delete;
}
 
#undef DEF_BI_PPM
 
 
 
/*
 * Next, the "3D/scalable" builtins.  These are the ones specified with
 * names like ":xpm:resize".  I'm not entirely clear on how these differ
 * from ":resize"; they both vary by UseThreeDTitles and look the same.
 * But, whatever.
 *
 * These yield [ctwm struct] Image's rather than [X11 type] Pixmap's.
 */
#define DEF_BI_SPM(nm) Image *nm(ColorPair cp)
static DEF_BI_SPM(Create3DMenuImage);
static DEF_BI_SPM(Create3DDotImage);
static DEF_BI_SPM(Create3DResizeImage);
static DEF_BI_SPM(Create3DZoomImage);
static DEF_BI_SPM(Create3DBarImage);
static DEF_BI_SPM(Create3DVertBarImage);
static DEF_BI_SPM(Create3DCrossImage);
static DEF_BI_SPM(Create3DIconifyImage);
static DEF_BI_SPM(Create3DSunkenResizeImage);
static DEF_BI_SPM(Create3DBoxImage);
 
 
/*
 * Main lookup
 *
 * This is where we find ":xpm:something".  Note that these are _not_
 * XPM's, and have no relation to the configurable XPM support, which we
 * get with images specified as "xpm:something" (no leading colon).
 * That's not confusing at all.
 */
Image *
get_builtin_scalable_pixmap(const char *name, ColorPair cp)
{
    int    i;
    static struct {
        char *name;
        DEF_BI_SPM((*proc));
    } pmtab[] = {
        /* Lookup for ":xpm:" pixmaps */
        { TBPM_3DDOT,       Create3DDotImage },
        { TBPM_3DRESIZE,    Create3DResizeImage },
        { TBPM_3DMENU,      Create3DMenuImage },
        { TBPM_3DZOOM,      Create3DZoomImage },
        { TBPM_3DBAR,       Create3DBarImage },
        { TBPM_3DVBAR,      Create3DVertBarImage },
        { TBPM_3DCROSS,     Create3DCrossImage },
        { TBPM_3DICONIFY,   Create3DIconifyImage },
        { TBPM_3DBOX,       Create3DBoxImage },
        { TBPM_3DSUNKEN_RESIZE, Create3DSunkenResizeImage },
    };
 
    /* Seatbelts */
    if(!name || (strncmp(name, ":xpm:", 5) != 0)) {
        return NULL;
    }
 
    for(i = 0; i < (sizeof pmtab) / (sizeof pmtab[0]); i++) {
        if(strcasecmp(pmtab[i].name, name) == 0) {
            Image *image = (*pmtab[i].proc)(cp);
            if(image == NULL) {
                fprintf(stderr, "%s:  unable to build pixmap \"%s\"\n",
                        ProgramName, name);
                return NULL;
            }
            return image;
        }
    }
 
    fprintf(stderr, "%s:  no such built-in pixmap \"%s\"\n", ProgramName, name);
    return NULL;
}
 
 
 
#define LEVITTE_TEST
static DEF_BI_SPM(Create3DCrossImage)
{
    Image *image;
    int        h;
    int    point;
    int midpoint;
 
    h = Scr->TBInfo.width - Scr->TBInfo.border * 2;
    if(!(h & 1)) {
        h--;
    }
    point = 4;
    midpoint = h / 2;
 
    image = AllocImage();
    if(! image) {
        return (None);
    }
    image->pixmap = XCreatePixmap(dpy, Scr->Root, h, h, Scr->d_depth);
    if(image->pixmap == None) {
        free(image);
        return (None);
    }
 
    Draw3DBorder(image->pixmap, 0, 0, h, h, Scr->TitleButtonShadowDepth, cp,
                 off, true, false);
 
#ifdef LEVITTE_TEST
    FB(cp.shadc, cp.shadd);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point + 1, point - 1, point - 1,
              point + 1);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point + 1, point, point,
              point + 1);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point - 1, point + 1, midpoint - 2,
              midpoint);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, midpoint, midpoint + 2,
              h - point - 3, h - point - 1);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point, point + 1, h - point - 3,
              h - point - 2);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point - 1, h - point - 2,
              midpoint - 2, midpoint);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, midpoint, midpoint - 2,
              h - point - 2, point - 1);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point, h - point - 2,
              h - point - 2, point);
#endif
 
    FB(cp.shadd, cp.shadc);
#ifdef LEVITTE_TEST
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point + 2, point + 1,
              h - point - 1, h - point - 2);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point + 2, point, midpoint,
              midpoint - 2);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, midpoint + 2, midpoint, h - point,
              h - point - 2);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, h - point, h - point - 2,
              h - point - 2, h - point);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, h - point - 1, h - point - 2,
              h - point - 2, h - point - 1);
#else
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point, point, h - point - 1,
              h - point - 1);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point - 1, point, h - point - 1,
              h - point);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point, point - 1, h - point,
              h - point - 1);
#endif
 
#ifdef LEVITTE_TEST
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point, h - point - 1, point,
              h - point - 1);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, h - point - 1, point,
              h - point - 1, point);
#else
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point, h - point - 1,
              h - point - 1, point);
#endif
#ifdef LEVITTE_TEST
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point + 1, h - point - 1,
              h - point - 1, point + 1);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point + 1, h - point, midpoint,
              midpoint + 2);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, midpoint + 2, midpoint, h - point,
              point + 1);
#else
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point - 1, h - point - 1,
              h - point - 1, point - 1);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point, h - point, h - point,
              point);
#endif
 
    image->width  = h;
    image->height = h;
 
    return (image);
}
#undef LEVITTE_TEST
 
static DEF_BI_SPM(Create3DIconifyImage)
{
    Image *image;
    int     h;
    int point;
 
    h = Scr->TBInfo.width - Scr->TBInfo.border * 2;
    if(!(h & 1)) {
        h--;
    }
    point = ((h / 2 - 2) * 2 + 1) / 3;
 
    image = AllocImage();
    if(! image) {
        return (None);
    }
    image->pixmap = XCreatePixmap(dpy, Scr->Root, h, h, Scr->d_depth);
    if(image->pixmap == None) {
        free(image);
        return (None);
    }
 
    Draw3DBorder(image->pixmap, 0, 0, h, h, Scr->TitleButtonShadowDepth, cp,
                 off, true, false);
    FB(cp.shadd, cp.shadc);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point, point, h / 2, h - point);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, point, point, h - point, point);
 
    FB(cp.shadc, cp.shadd);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, h - point, point, h / 2 + 1,
              h - point);
    XDrawLine(dpy, image->pixmap, Scr->NormalGC, h - point - 1, point + 1,
              h / 2 + 1, h - point - 1);
 
    image->width  = h;
    image->height = h;
 
    return (image);
}
 
static DEF_BI_SPM(Create3DSunkenResizeImage)
{
    int     h;
    Image *image;
 
    h = Scr->TBInfo.width - Scr->TBInfo.border * 2;
    if(!(h & 1)) {
        h--;
    }
 
    image = AllocImage();
    if(! image) {
        return (None);
    }
    image->pixmap = XCreatePixmap(dpy, Scr->Root, h, h, Scr->d_depth);
    if(image->pixmap == None) {
        free(image);
        return (None);
    }
 
    Draw3DBorder(image->pixmap, 0, 0, h, h, Scr->TitleButtonShadowDepth, cp,
                 off, true, false);
    Draw3DBorder(image->pixmap, 3, 3, h - 6, h - 6, 1, cp, on, true, false);
    Draw3DBorder(image->pixmap, 3, ((h - 6) / 3) + 3, ((h - 6) * 2 / 3) + 1,
                 ((h - 6) * 2 / 3) + 1, 1, cp, on, true, false);
    Draw3DBorder(image->pixmap, 3, ((h - 6) * 2 / 3) + 3, ((h - 6) / 3) + 1,
                 ((h - 6) / 3) + 1, 1, cp, on, true, false);
 
    image->width  = h;
    image->height = h;
 
    return (image);
}
 
static DEF_BI_SPM(Create3DBoxImage)
{
    int     h;
    Image   *image;
 
    h = Scr->TBInfo.width - Scr->TBInfo.border * 2;
    if(!(h & 1)) {
        h--;
    }
 
    image = AllocImage();
    if(! image) {
        return (None);
    }
    image->pixmap = XCreatePixmap(dpy, Scr->Root, h, h, Scr->d_depth);
    if(image->pixmap == None) {
        free(image);
        return (None);
    }
 
    Draw3DBorder(image->pixmap, 0, 0, h, h, Scr->TitleButtonShadowDepth, cp,
                 off, true, false);
    Draw3DBorder(image->pixmap, (h / 2) - 4, (h / 2) - 4, 9, 9, 1, cp,
                 off, true, false);
 
    image->width  = h;
    image->height = h;
 
    return (image);
}
 
static DEF_BI_SPM(Create3DDotImage)
{
    Image *image;
    int   h;
    static int idepth = 2;
 
    h = Scr->TBInfo.width - Scr->TBInfo.border * 2;
    if(!(h & 1)) {
        h--;
    }
 
    image = AllocImage();
    if(! image) {
        return (None);
    }
    image->pixmap = XCreatePixmap(dpy, Scr->Root, h, h, Scr->d_depth);
    if(image->pixmap == None) {
        free(image);
        return (None);
    }
 
    Draw3DBorder(image->pixmap, 0, 0, h, h, Scr->TitleButtonShadowDepth, cp,
                 off, true, false);
    Draw3DBorder(image->pixmap, (h / 2) - idepth,
                 (h / 2) - idepth,
                 2 * idepth + 1,
                 2 * idepth + 1,
                 idepth, cp, off, true, false);
    image->width  = h;
    image->height = h;
    return (image);
}
 
static DEF_BI_SPM(Create3DBarImage)
{
    Image *image;
    int   h;
    static int idepth = 2;
 
    h = Scr->TBInfo.width - Scr->TBInfo.border * 2;
    if(!(h & 1)) {
        h--;
    }
 
    image = AllocImage();
    if(! image) {
        return (None);
    }
    image->pixmap = XCreatePixmap(dpy, Scr->Root, h, h, Scr->d_depth);
    if(image->pixmap == None) {
        free(image);
        return (None);
    }
 
    Draw3DBorder(image->pixmap, 0, 0, h, h, Scr->TitleButtonShadowDepth, cp,
                 off, true, false);
    Draw3DBorder(image->pixmap,
                 Scr->TitleButtonShadowDepth + 2,
                 (h / 2) - idepth,
                 h - 2 * (Scr->TitleButtonShadowDepth + 2),
                 2 * idepth + 1,
                 idepth, cp, off, true, false);
    image->width  = h;
    image->height = h;
    return (image);
}
 
static DEF_BI_SPM(Create3DVertBarImage)
{
    Image *image;
    int   h;
    static int idepth = 2;
 
    h = Scr->TBInfo.width - Scr->TBInfo.border * 2;
    if(!(h & 1)) {
        h--;
    }
 
    image = AllocImage();
    if(! image) {
        return (None);
    }
    image->pixmap = XCreatePixmap(dpy, Scr->Root, h, h, Scr->d_depth);
    if(image->pixmap == None) {
        free(image);
        return (None);
    }
 
    Draw3DBorder(image->pixmap, 0, 0, h, h, Scr->TitleButtonShadowDepth, cp,
                 off, true, false);
    Draw3DBorder(image->pixmap,
                 (h / 2) - idepth,
                 Scr->TitleButtonShadowDepth + 2,
                 2 * idepth + 1,
                 h - 2 * (Scr->TitleButtonShadowDepth + 2),
                 idepth, cp, off, true, false);
    image->width  = h;
    image->height = h;
    return (image);
}
 
static DEF_BI_SPM(Create3DMenuImage)
{
    Image *image;
    int   h, i;
 
    h = Scr->TBInfo.width - Scr->TBInfo.border * 2;
    if(!(h & 1)) {
        h--;
    }
 
    image = AllocImage();
    if(! image) {
        return (None);
    }
    image->pixmap = XCreatePixmap(dpy, Scr->Root, h, h, Scr->d_depth);
    if(image->pixmap == None) {
        free(image);
        return (None);
    }
 
    Draw3DBorder(image->pixmap, 0, 0, h, h, Scr->TitleButtonShadowDepth, cp,
                 off, true, false);
    for(i = 4; i < h - 7; i += 5) {
        Draw3DBorder(image->pixmap, 4, i, h - 8, 4, 2, cp, off, true, false);
    }
    image->width  = h;
    image->height = h;
    return (image);
}
 
static DEF_BI_SPM(Create3DResizeImage)
{
    Image *image;
    int   h;
 
    h = Scr->TBInfo.width - Scr->TBInfo.border * 2;
    if(!(h & 1)) {
        h--;
    }
 
    image = AllocImage();
    if(! image) {
        return (None);
    }
    image->pixmap = XCreatePixmap(dpy, Scr->Root, h, h, Scr->d_depth);
    if(image->pixmap == None) {
        free(image);
        return (None);
    }
 
    Draw3DBorder(image->pixmap, 0, 0, h, h, Scr->TitleButtonShadowDepth, cp,
                 off, true, false);
    Draw3DBorder(image->pixmap, 0, h / 4, ((3 * h) / 4) + 1, ((3 * h) / 4) + 1,
                 2, cp, off, true, false);
    Draw3DBorder(image->pixmap, 0, h / 2, (h / 2) + 1, (h / 2) + 1, 2, cp, off,
                 true, false);
    image->width  = h;
    image->height = h;
    return (image);
}
 
static DEF_BI_SPM(Create3DZoomImage)
{
    Image *image;
    int         h;
    static int idepth = 2;
 
    h = Scr->TBInfo.width - Scr->TBInfo.border * 2;
    if(!(h & 1)) {
        h--;
    }
 
    image = AllocImage();
    if(! image) {
        return (None);
    }
    image->pixmap = XCreatePixmap(dpy, Scr->Root, h, h, Scr->d_depth);
    if(image->pixmap == None) {
        free(image);
        return (None);
    }
 
    Draw3DBorder(image->pixmap, 0, 0, h, h, Scr->TitleButtonShadowDepth, cp,
                 off, true, false);
    Draw3DBorder(image->pixmap, Scr->TitleButtonShadowDepth + 2,
                 Scr->TitleButtonShadowDepth + 2,
                 h - 2 * (Scr->TitleButtonShadowDepth + 2),
                 h - 2 * (Scr->TitleButtonShadowDepth + 2),
                 idepth, cp, off, true, false);
 
    image->width  = h;
    image->height = h;
    return (image);
}
 
#undef DEF_BI_SPM
 
 
 
/*
 * And the animated builtins.  These are the ones specified with names
 * like "%xpm:resize".
 *
 * These yield [ctwm struct] Image's.
 */
#define DEF_BI_ASPM(nm) Image *nm(ColorPair cp)
 
/* Backend generators */
static Image *Create3DResizeAnimation(bool in, bool left, bool top,
                                      ColorPair cp);
static Image *Create3DMenuAnimation(bool up, ColorPair cp);
static Image *Create3DZoomAnimation(bool in, bool out, int n, ColorPair cp);
 
/* Frontends */
/* Using: ResizeAnimation */
static DEF_BI_ASPM(Create3DResizeInTopAnimation);
static DEF_BI_ASPM(Create3DResizeOutTopAnimation);
static DEF_BI_ASPM(Create3DResizeInBotAnimation);
static DEF_BI_ASPM(Create3DResizeOutBotAnimation);
/* Using: MenuAnimation */
static DEF_BI_ASPM(Create3DMenuUpAnimation);
static DEF_BI_ASPM(Create3DMenuDownAnimation);
/* Using: ZoomAnimation */
static DEF_BI_ASPM(Create3DMazeOutAnimation);
static DEF_BI_ASPM(Create3DMazeInAnimation);
static DEF_BI_ASPM(Create3DZoomInAnimation);
static DEF_BI_ASPM(Create3DZoomOutAnimation);
static DEF_BI_ASPM(Create3DZoomInOutAnimation);
 
 
/*
 * Entry for animated pixmaps
 *
 * This is where we find "%xpm:something".  Note that as above, these are
 * _not_ XPM's, and have no relation to the configurable XPM support,
 * which we get with images specified as "xpm:something" (no leading
 * colon).  Still not confusing at _all_.
 */
Image *
get_builtin_animated_pixmap(const char *name, ColorPair cp)
{
    int    i;
    static struct {
        char *name;
        DEF_BI_ASPM((*proc));
    } pmtab[] = {
        /* Lookup for "%xpm:" pixmaps */
        { "%xpm:resize-out-top", Create3DResizeInTopAnimation },
        { "%xpm:resize-in-top",  Create3DResizeOutTopAnimation },
        { "%xpm:resize-out-bot", Create3DResizeInBotAnimation },
        { "%xpm:resize-in-bot",  Create3DResizeOutBotAnimation },
        { "%xpm:menu-up",        Create3DMenuUpAnimation },
        { "%xpm:menu-down",      Create3DMenuDownAnimation },
        { "%xpm:maze-out",       Create3DMazeOutAnimation },
        { "%xpm:maze-in",        Create3DMazeInAnimation },
        { "%xpm:resize",         Create3DZoomOutAnimation }, // compat
        { "%xpm:zoom-out",       Create3DZoomOutAnimation },
        { "%xpm:zoom-in",        Create3DZoomInAnimation },
        { "%xpm:zoom-inout",     Create3DZoomInOutAnimation },
    };
 
    /* Seatbelts */
    if(!name || (strncmp(name, "%xpm:", 5) != 0)) {
        return NULL;
    }
 
    for(i = 0; i < (sizeof pmtab) / (sizeof pmtab[0]); i++) {
        if(strcasecmp(pmtab[i].name, name) == 0) {
            Image *image = (*pmtab[i].proc)(cp);
            if(image == NULL) {
                fprintf(stderr, "%s:  unable to build pixmap \"%s\"\n",
                        ProgramName, name);
                return NULL;
            }
            return image;
        }
    }
 
    fprintf(stderr, "%s:  no such built-in pixmap \"%s\"\n", ProgramName, name);
    return (None);
}
 
 
/*
 * First a couple generator functions the actual functions use
 */
static Image *
Create3DResizeAnimation(bool in, bool left, bool top,
                        ColorPair cp)
{
    int         h, i, j;
    Image       *image, *im, *im1;
 
    h = Scr->TBInfo.width - Scr->TBInfo.border * 2;
    if(!(h & 1)) {
        h--;
    }
 
    image = im1 = NULL;
    for(i = (in ? 0 : (h / 4) - 1); (i < h / 4) && (i >= 0); i += (in ? 1 : -1)) {
        im = AllocImage();
        if(! im) {
            return NULL;
        }
        im->pixmap = XCreatePixmap(dpy, Scr->Root, h, h, Scr->d_depth);
        if(im->pixmap == None) {
            free(im);
            return NULL;
        }
        Draw3DBorder(im->pixmap, 0, 0, h, h, Scr->TitleButtonShadowDepth, cp,
                     off, true, false);
        for(j = i; j <= h; j += (h / 4)) {
            Draw3DBorder(im->pixmap, (left ? 0 : j), (top ? 0 : j),
                         h - j, h - j, 2, cp, off, true, false);
        }
        im->mask   = None;
        im->width  = h;
        im->height = h;
        im->next   = NULL;
        if(image == NULL) {
            image = im1 = im;
        }
        else {
            im1->next = im;
            im1 = im;
        }
    }
    if(im1 != None) {
        im1->next = image;
    }
    return image;
}
 
static Image *
Create3DMenuAnimation(bool up, ColorPair cp)
{
    int   h, i, j;
    Image *image, *im, *im1;
 
    h = Scr->TBInfo.width - Scr->TBInfo.border * 2;
    if(!(h & 1)) {
        h--;
    }
 
    image = im1 = NULL;
    for(j = (up ? 4 : 0); j != (up ? -1 : 5); j += (up ? -1 : 1)) {
        im = AllocImage();
        if(! im) {
            return NULL;
        }
        im->pixmap = XCreatePixmap(dpy, Scr->Root, h, h, Scr->d_depth);
        if(im->pixmap == None) {
            free(im);
            return NULL;
        }
        Draw3DBorder(im->pixmap, 0, 0, h, h, Scr->TitleButtonShadowDepth, cp,
                     off, true, false);
        for(i = j; i < h - 3; i += 5) {
            Draw3DBorder(im->pixmap, 4, i, h - 8, 4, 2, cp, off, true, false);
        }
        im->mask   = None;
        im->width  = h;
        im->height = h;
        im->next   = NULL;
        if(image == NULL) {
            image = im1 = im;
        }
        else {
            im1->next = im;
            im1 = im;
        }
    }
    if(im1 != None) {
        im1->next = image;
    }
    return image;
}
 
static Image *
Create3DZoomAnimation(bool in, bool out, int n, ColorPair cp)
{
    int         h, i, j, k;
    Image       *image, *im, *im1;
 
    h = Scr->TBInfo.width - Scr->TBInfo.border * 2;
    if(!(h & 1)) {
        h--;
    }
 
    if(n == 0) {
        n = (h / 2) - 2;
    }
 
    image = im1 = NULL;
    for(j = (out ? -1 : 1) ; j < (in ? 2 : 0); j += 2) {
        for(k = (j > 0 ? 0 : n - 1) ; (k >= 0) && (k < n); k += j) {
            im = AllocImage();
            im->pixmap = XCreatePixmap(dpy, Scr->Root, h, h, Scr->d_depth);
            Draw3DBorder(im->pixmap, 0, 0, h, h, Scr->TitleButtonShadowDepth,
                         cp, off, true, false);
            for(i = 2 + k; i < (h / 2); i += n) {
                Draw3DBorder(im->pixmap, i, i, h - (2 * i), h - (2 * i), 2, cp,
                             off, true, false);
            }
            im->mask   = None;
            im->width  = h;
            im->height = h;
            im->next   = NULL;
            if(image == NULL) {
                image = im1 = im;
            }
            else {
                im1->next = im;
                im1 = im;
            }
        }
    }
    if(im1 != None) {
        im1->next = image;
    }
    return image;
}
 
 
/*
 * And the wrapper funcs for making the images
 */
static DEF_BI_ASPM(Create3DResizeInTopAnimation)
{
    return Create3DResizeAnimation(true, false, true, cp);
}
 
static DEF_BI_ASPM(Create3DResizeOutTopAnimation)
{
    return Create3DResizeAnimation(false, false, true, cp);
}
 
static DEF_BI_ASPM(Create3DResizeInBotAnimation)
{
    return Create3DResizeAnimation(true, true, false, cp);
}
 
static DEF_BI_ASPM(Create3DResizeOutBotAnimation)
{
    return Create3DResizeAnimation(false, true, false, cp);
}
 
 
static DEF_BI_ASPM(Create3DMenuUpAnimation)
{
    return Create3DMenuAnimation(true, cp);
}
 
static DEF_BI_ASPM(Create3DMenuDownAnimation)
{
    return Create3DMenuAnimation(false, cp);
}
 
 
static DEF_BI_ASPM(Create3DMazeInAnimation)
{
    return Create3DZoomAnimation(true, false, 6, cp);
}
 
static DEF_BI_ASPM(Create3DMazeOutAnimation)
{
    return Create3DZoomAnimation(false, true, 6, cp);
}
 
static DEF_BI_ASPM(Create3DZoomInAnimation)
{
    return Create3DZoomAnimation(true, false, 0, cp);
}
 
static DEF_BI_ASPM(Create3DZoomOutAnimation)
{
    return Create3DZoomAnimation(false, true, 0, cp);
}
 
static DEF_BI_ASPM(Create3DZoomInOutAnimation)
{
    return Create3DZoomAnimation(true, true, 0, cp);
}
 
#undef DEF_BI_ASPM
 
 
/*
 * Lastly, some gray/black pixmaps that are used in window border and
 * hilite bars.
 */
#define BG_WIDTH  2
#define BG_HEIGHT 2
 
Pixmap
mk_blackgray_pixmap(const char *which, Drawable dw,
                    unsigned long fg, unsigned long bg)
{
    unsigned char gray_bits[]  = { 0x02, 0x01 };
    unsigned char black_bits[] = { 0xFF, 0xFF };
    char *bits;
 
    /* Which are we asking for? */
    if(strcmp(which, "black") == 0) {
        bits = (char *)black_bits;
    }
    else if(strcmp(which, "gray") == 0) {
        bits = (char *)gray_bits;
    }
    else {
        fprintf(stderr, "%s(): Invalid which arg '%s'\n", __func__, which);
        return None;
    }
 
    /* Make it */
    return XCreatePixmapFromBitmapData(dpy, dw,
                                       bits, BG_WIDTH, BG_HEIGHT,
                                       fg, bg, Scr->d_depth);
}
 
void
get_blackgray_size(int *width, int *height)
{
    if(width) {
        *width  = BG_WIDTH;
    }
    if(height) {
        *height = BG_HEIGHT;
    }
}
 
#undef BG_HEIGHT
#undef BG_WIDTH