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

Go to the documentation of this file.

/*
 * Colormap handling
 */
 
#include "ctwm.h"
 
#include <stdio.h>
#include <stdlib.h>
 
#include "colormaps.h"
#include "screen.h"
 
 
/*
 * From events.c; imported manually since I'm not listing it in events.h
 * because nowhere but here needs it.
 */
extern bool ColortableThrashing;
 
static Bool UninstallRootColormapQScanner(Display *display, XEvent *ev,
                char *args);
 
 
/***********************************************************************
 *
 *  Procedure:
 *      InstallWindowColormaps - install the colormaps for one twm window
 *
 *  Inputs:
 *      type    - type of event that caused the installation
 *      tmp     - for a subset of event types, the address of the
 *                window structure, whose colormaps are to be installed.
 *
 ***********************************************************************
 *
 * Previously in events.c
 */
bool
InstallWindowColormaps(int type, TwmWindow *tmp)
{
    if(tmp) {
        return InstallColormaps(type, &tmp->cmaps);
    }
    else {
        return InstallColormaps(type, NULL);
    }
}
 
 
bool
InstallColormaps(int type, Colormaps *cmaps)
{
    int i, j, n, number_cwins, state;
    ColormapWindow **cwins, *cwin, **maxcwin = NULL;
    TwmColormap *cmap;
    char *row, *scoreboard;
 
    switch(type) {
        case EnterNotify:
        case LeaveNotify:
        case DestroyNotify:
        default:
            /* Save the colormap to be loaded for when force loading of
             * root colormap(s) ends.
             */
            Scr->cmapInfo.pushed_cmaps = cmaps;
            /* Don't load any new colormap if root colormap(s) has been
             * force loaded.
             */
            if(Scr->cmapInfo.root_pushes) {
                return false;
            }
            /* Don't reload the current window colormap list.
            if (Scr->cmapInfo.cmaps == cmaps)
                return false;
             */
            if(Scr->cmapInfo.cmaps) {
                for(i = Scr->cmapInfo.cmaps->number_cwins,
                                cwins = Scr->cmapInfo.cmaps->cwins; i-- > 0; cwins++) {
                    (*cwins)->colormap->state &= ~CM_INSTALLABLE;
                }
            }
            Scr->cmapInfo.cmaps = cmaps;
            break;
 
        case PropertyNotify:
        case VisibilityNotify:
        case ColormapNotify:
            break;
    }
 
    number_cwins = Scr->cmapInfo.cmaps->number_cwins;
    cwins = Scr->cmapInfo.cmaps->cwins;
    scoreboard = Scr->cmapInfo.cmaps->scoreboard;
 
    ColortableThrashing = false; /* in case installation aborted */
 
    state = CM_INSTALLED;
 
    for(i = 0; i < number_cwins; i++) {
        cwins[i]->colormap->state &= ~CM_INSTALL;
    }
    for(i = n = 0; i < number_cwins && n < Scr->cmapInfo.maxCmaps; i++) {
        cwin = cwins[i];
        cmap = cwin->colormap;
        if(cmap->state & CM_INSTALL) {
            continue;
        }
        cmap->state |= CM_INSTALLABLE;
        cmap->w = cwin->w;
        if(cwin->visibility != VisibilityFullyObscured) {
            row = scoreboard + (i * (i - 1) / 2);
            for(j = 0; j < i; j++)
                if(row[j] && (cwins[j]->colormap->state & CM_INSTALL)) {
                    break;
                }
            if(j != i) {
                continue;
            }
            n++;
            maxcwin = &cwins[i];
            state &= (cmap->state & CM_INSTALLED);
            cmap->state |= CM_INSTALL;
        }
    }
 
    // Hack: special-case startup
    if(!dpy) {
        return true;
    }
 
    Scr->cmapInfo.first_req = NextRequest(dpy);
 
    for(; n > 0 && maxcwin >= &cwins[0]; maxcwin--) {
        cmap = (*maxcwin)->colormap;
        if(cmap->state & CM_INSTALL) {
            cmap->state &= ~CM_INSTALL;
            if(!(state & CM_INSTALLED)) {
                cmap->install_req = NextRequest(dpy);
                /* printf ("XInstallColormap : %x, %x\n", cmap, cmap->c); */
                XInstallColormap(dpy, cmap->c);
            }
            cmap->state |= CM_INSTALLED;
            n--;
        }
    }
    return true;
}
 
 
 
/***********************************************************************
 *
 *  Procedures:
 *      <Uni/I>nstallRootColormap - Force (un)loads root colormap(s)
 *
 *         These matching routines provide a mechanism to insure that
 *         the root colormap(s) is installed during operations like
 *         rubber banding or menu display that require colors from
 *         that colormap.  Calls may be nested arbitrarily deeply,
 *         as long as there is one UninstallRootColormap call per
 *         InstallRootColormap call.
 *
 *         The final UninstallRootColormap will cause the colormap list
 *         which would otherwise have be loaded to be loaded, unless
 *         Enter or Leave Notify events are queued, indicating some
 *         other colormap list would potentially be loaded anyway.
 ***********************************************************************
 *
 * Previously in events.c
 */
void
InstallRootColormap(void)
{
    Colormaps *tmp;
    if(Scr->cmapInfo.root_pushes == 0) {
        /*
         * The saving and restoring of cmapInfo.pushed_window here
         * is a slimy way to remember the actual pushed list and
         * not that of the root window.
         */
        tmp = Scr->cmapInfo.pushed_cmaps;
        InstallColormaps(0, &Scr->RootColormaps);
        Scr->cmapInfo.pushed_cmaps = tmp;
    }
    Scr->cmapInfo.root_pushes++;
}
 
 
/* ARGSUSED*/
static Bool
UninstallRootColormapQScanner(Display *display, XEvent *ev,
                              char *args)
{
    if(!*args) {
        if(ev->type == EnterNotify) {
            if(ev->xcrossing.mode != NotifyGrab) {
                *args = 1;
            }
        }
        else if(ev->type == LeaveNotify) {
            if(ev->xcrossing.mode == NotifyNormal) {
                *args = 1;
            }
        }
    }
 
    return (False);
}
 
 
void
UninstallRootColormap(void)
{
    char args;
    XEvent dummy;
 
    if(Scr->cmapInfo.root_pushes) {
        Scr->cmapInfo.root_pushes--;
    }
 
    if(!Scr->cmapInfo.root_pushes) {
        /*
         * If we have subsequent Enter or Leave Notify events,
         * we can skip the reload of pushed colormaps.
         */
        XSync(dpy, 0);
        args = 0;
        XCheckIfEvent(dpy, &dummy, UninstallRootColormapQScanner, &args);
 
        if(!args) {
            InstallColormaps(0, Scr->cmapInfo.pushed_cmaps);
        }
    }
}
 
 
/*
 * Create a TwmColormap struct and tie it to an [X] Colormap.  Places
 * that need to mess with colormaps and look up the metainfo we hang off
 * them need to look this up and find it via the X Context.
 *
 * Previously in add_window.c
 */
TwmColormap *
CreateTwmColormap(Colormap c)
{
    TwmColormap *cmap;
    cmap = malloc(sizeof(TwmColormap));
    if(!cmap) {
        return NULL;
    }
    cmap->c = c;
    cmap->state = 0;
    cmap->install_req = 0;
    cmap->w = None;
    cmap->refcnt = 1;
 
    if(XSaveContext(dpy, c, ColormapContext, (XPointer) cmap)) {
        free(cmap);
        return NULL;
    }
    return (cmap);
}
 
 
/*
 * Put together a ColormapWindow struct.  This is a thing we hang off a
 * TwmWindow for some colormap tracking stuff.
 *
 * Previously in add_window.c
 */
ColormapWindow *
CreateColormapWindow(Window w, bool creating_parent, bool property_window)
{
    ColormapWindow *cwin;
    TwmColormap *cmap;
    XWindowAttributes attributes;
 
    cwin = malloc(sizeof(ColormapWindow));
    if(cwin == NULL) {
        return NULL;
    }
 
    // Common
    cwin->w = w;
 
    /*
     * Assume that windows in colormap list are
     * obscured if we are creating the parent window.
     * Otherwise, we assume they are unobscured.
     */
    cwin->visibility = creating_parent ?
                       VisibilityPartiallyObscured : VisibilityUnobscured;
    cwin->refcnt = 1;
 
 
    // Stub for special cases
    if(dpy == NULL) {
        cwin->colormap = NULL;
        cwin->colormap = calloc(1, sizeof(TwmColormap));
        cwin->colormap->refcnt = 1;
 
        return cwin;
    }
 
 
    if(!XGetWindowAttributes(dpy, w, &attributes) ||
                    XSaveContext(dpy, w, ColormapContext, (XPointer) cwin)) {
        free(cwin);
        return (NULL);
    }
 
    if(XFindContext(dpy, attributes.colormap,  ColormapContext,
                    (XPointer *)&cwin->colormap) == XCNOENT) {
        cwin->colormap = cmap = CreateTwmColormap(attributes.colormap);
        if(!cmap) {
            XDeleteContext(dpy, w, ColormapContext);
            free(cwin);
            return (NULL);
        }
    }
    else {
        cwin->colormap->refcnt++;
    }
 
    /*
     * If this is a ColormapWindow property window and we
     * are not monitoring ColormapNotify or VisibilityNotify
     * events, we need to.
     */
    if(property_window &&
                    (attributes.your_event_mask &
                     (ColormapChangeMask | VisibilityChangeMask)) !=
                    (ColormapChangeMask | VisibilityChangeMask)) {
        XSelectInput(dpy, w, attributes.your_event_mask |
                     (ColormapChangeMask | VisibilityChangeMask));
    }
 
    return (cwin);
}
 
 
/*
 * Do something with looking up stuff from WM_COLORMAPS_WINDOWS (relating
 * to windows with their own colormap) and finding or putting this window
 * into it.
 *
 * XXX Someone should figure it out better than that...
 *
 * Previously in add_window.c
 */
void
FetchWmColormapWindows(TwmWindow *tmp)
{
    int i, j;
    Window *cmap_windows = NULL;
    bool can_free_cmap_windows = false;
    int number_cmap_windows = 0;
    ColormapWindow **cwins = NULL;
    bool previnst;
 
    number_cmap_windows = 0;
 
    previnst = (Scr->cmapInfo.cmaps == &tmp->cmaps && tmp->cmaps.number_cwins);
    if(previnst) {
        cwins = tmp->cmaps.cwins;
        for(i = 0; i < tmp->cmaps.number_cwins; i++) {
            cwins[i]->colormap->state = 0;
        }
    }
 
    if(XGetWMColormapWindows(dpy, tmp->w, &cmap_windows,
                             &number_cmap_windows) &&
                    number_cmap_windows > 0) {
 
        /*
         * check if the top level is in the list, add to front if not
         */
        for(i = 0; i < number_cmap_windows; i++) {
            if(cmap_windows[i] == tmp->w) {
                break;
            }
        }
        if(i == number_cmap_windows) {   /* not in list */
            Window *new_cmap_windows =
                    calloc((number_cmap_windows + 1), sizeof(Window));
 
            if(!new_cmap_windows) {
                fprintf(stderr,
                        "%s:  unable to allocate %d element colormap window array\n",
                        ProgramName, number_cmap_windows + 1);
                goto done;
            }
            new_cmap_windows[0] = tmp->w;  /* add to front */
            for(i = 0; i < number_cmap_windows; i++) {   /* append rest */
                new_cmap_windows[i + 1] = cmap_windows[i];
            }
            XFree(cmap_windows);
            can_free_cmap_windows = true;  /* do not use XFree any more */
            cmap_windows = new_cmap_windows;
            number_cmap_windows++;
        }
 
        cwins = calloc(number_cmap_windows, sizeof(ColormapWindow *));
        if(cwins) {
            for(i = 0; i < number_cmap_windows; i++) {
 
                /*
                 * Copy any existing entries into new list.
                 */
                for(j = 0; j < tmp->cmaps.number_cwins; j++) {
                    if(tmp->cmaps.cwins[j]->w == cmap_windows[i]) {
                        cwins[i] = tmp->cmaps.cwins[j];
                        cwins[i]->refcnt++;
                        break;
                    }
                }
 
                /*
                 * If the colormap window is not being pointed by
                 * some other applications colormap window list,
                 * create a new entry.
                 */
                if(j == tmp->cmaps.number_cwins) {
                    if(XFindContext(dpy, cmap_windows[i], ColormapContext,
                                    (XPointer *)&cwins[i]) == XCNOENT) {
                        if((cwins[i] = CreateColormapWindow(cmap_windows[i],
                                                            tmp->cmaps.number_cwins == 0,
                                                            true)) == NULL) {
                            int k;
                            for(k = i + 1; k < number_cmap_windows; k++) {
                                cmap_windows[k - 1] = cmap_windows[k];
                            }
                            i--;
                            number_cmap_windows--;
                        }
                    }
                    else {
                        cwins[i]->refcnt++;
                    }
                }
            }
        }
    }
 
    /* No else here, in case we bailed out of clause above.
     */
    if(number_cmap_windows == 0) {
 
        number_cmap_windows = 1;
 
        cwins = malloc(sizeof(ColormapWindow *));
        if(XFindContext(dpy, tmp->w, ColormapContext, (XPointer *)&cwins[0]) ==
                        XCNOENT)
            cwins[0] = CreateColormapWindow(tmp->w,
                                            tmp->cmaps.number_cwins == 0, false);
        else {
            cwins[0]->refcnt++;
        }
    }
 
    if(tmp->cmaps.number_cwins) {
        free_cwins(tmp);
    }
 
    tmp->cmaps.cwins = cwins;
    tmp->cmaps.number_cwins = number_cmap_windows;
    if(number_cmap_windows > 1)
        tmp->cmaps.scoreboard =
                calloc(1, ColormapsScoreboardLength(&tmp->cmaps));
 
    if(previnst) {
        InstallColormaps(PropertyNotify, NULL);
    }
 
done:
    if(cmap_windows) {
        if(can_free_cmap_windows) {
            free(cmap_windows);
        }
        else {
            XFree(cmap_windows);
        }
    }
}
 
 
/*
 * BumpWindowColormap - rotate our internal copy of WM_COLORMAP_WINDOWS.
 * This is the backend for f.colormap.
 *
 * Previously in functions.c
 */
void
BumpWindowColormap(TwmWindow *tmp, int inc)
{
    int i, j;
    bool previously_installed;
    ColormapWindow **cwins;
 
    if(!tmp) {
        return;
    }
 
    if(inc && tmp->cmaps.number_cwins > 0) {
        cwins = calloc(tmp->cmaps.number_cwins, sizeof(ColormapWindow *));
        if(cwins) {
            previously_installed = (Scr->cmapInfo.cmaps == &tmp->cmaps &&
                                    tmp->cmaps.number_cwins);
            if(previously_installed) {
                for(i = tmp->cmaps.number_cwins; i-- > 0;) {
                    tmp->cmaps.cwins[i]->colormap->state = 0;
                }
            }
 
            for(i = 0; i < tmp->cmaps.number_cwins; i++) {
                j = i - inc;
                if(j >= tmp->cmaps.number_cwins) {
                    j -= tmp->cmaps.number_cwins;
                }
                else if(j < 0) {
                    j += tmp->cmaps.number_cwins;
                }
                cwins[j] = tmp->cmaps.cwins[i];
            }
 
            free(tmp->cmaps.cwins);
 
            tmp->cmaps.cwins = cwins;
 
            if(tmp->cmaps.number_cwins > 1)
                memset(tmp->cmaps.scoreboard, 0,
                       ColormapsScoreboardLength(&tmp->cmaps));
 
            if(previously_installed) {
                InstallColormaps(PropertyNotify, NULL);
            }
        }
    }
    else {
        FetchWmColormapWindows(tmp);
    }
    return;
}
 
 
/*
 * Handlers for creating and linkin in, as well as deleting, a StdCmap
 * for a given XStandardColormap.
 *
 * Previously in util.c
 */
void
InsertRGBColormap(Atom a, XStandardColormap *maps, int nmaps,
                  bool replace)
{
    StdCmap *sc = NULL;
 
    if(replace) {                       /* locate existing entry */
        for(sc = Scr->StdCmapInfo.head; sc; sc = sc->next) {
            if(sc->atom == a) {
                break;
            }
        }
    }
 
    if(!sc) {                           /* no existing, allocate new */
        sc = calloc(1, sizeof(StdCmap));
        if(!sc) {
            fprintf(stderr, "%s:  unable to allocate %lu bytes for StdCmap\n",
                    ProgramName, (unsigned long) sizeof(StdCmap));
            return;
        }
        replace = false;  // Didn't find one, can't replace
    }
 
    if(replace) {                       /* just update contents */
        if(sc->maps) {
            XFree(sc->maps);
        }
        if(sc == Scr->StdCmapInfo.mru) {
            Scr->StdCmapInfo.mru = NULL;
        }
    }
    else {                              /* else appending */
        sc->next = NULL;
        sc->atom = a;
        if(Scr->StdCmapInfo.tail) {
            Scr->StdCmapInfo.tail->next = sc;
        }
        else {
            Scr->StdCmapInfo.head = sc;
        }
        Scr->StdCmapInfo.tail = sc;
    }
    sc->nmaps = nmaps;
    sc->maps = maps;
 
    return;
}
 
 
void
RemoveRGBColormap(Atom a)
{
    StdCmap *sc, *prev;
 
    prev = NULL;
    for(sc = Scr->StdCmapInfo.head; sc; sc = sc->next) {
        if(sc->atom == a) {
            break;
        }
        prev = sc;
    }
    if(sc) {                            /* found one */
        if(sc->maps) {
            XFree(sc->maps);
        }
        if(prev) {
            prev->next = sc->next;
        }
        if(Scr->StdCmapInfo.head == sc) {
            Scr->StdCmapInfo.head = sc->next;
        }
        if(Scr->StdCmapInfo.tail == sc) {
            Scr->StdCmapInfo.tail = prev;
        }
        if(Scr->StdCmapInfo.mru == sc) {
            Scr->StdCmapInfo.mru = NULL;
        }
    }
    return;
}
 
 
/*
 * Go through all the properties of the root window and setup
 * XStandardColormap's and our StdCmap's for any of them that are
 * actually RGB_COLORMAP types.  We're not actually _checking_ the types,
 * just letting XGetRGBColormaps() refuse to handle probably most of
 * them.  Called during startup.
 *
 * Previouly in util.c
 */
void
LocateStandardColormaps(void)
{
    Atom *atoms;
    int natoms;
    int i;
 
    atoms = XListProperties(dpy, Scr->Root, &natoms);
    for(i = 0; i < natoms; i++) {
        XStandardColormap *maps = NULL;
        int nmaps;
 
        if(XGetRGBColormaps(dpy, Scr->Root, &maps, &nmaps, atoms[i])) {
            /* if got one, then append to current list */
            InsertRGBColormap(atoms[i], maps, nmaps, false);
        }
    }
    if(atoms) {
        XFree(atoms);
    }
    return;
}
 
 
/*
 * Clear out and free TwmWindow.cmaps (struct Colormaps) bits for a window.
 *
 * Previously in events.c
 */
void
free_cwins(TwmWindow *tmp)
{
    int i;
    TwmColormap *cmap;
 
    if(tmp->cmaps.number_cwins) {
        for(i = 0; i < tmp->cmaps.number_cwins; i++) {
            if(--tmp->cmaps.cwins[i]->refcnt == 0) {
                cmap = tmp->cmaps.cwins[i]->colormap;
                if(--cmap->refcnt == 0) {
                    XDeleteContext(dpy, cmap->c, ColormapContext);
                    free(cmap);
                }
                XDeleteContext(dpy, tmp->cmaps.cwins[i]->w, ColormapContext);
                free(tmp->cmaps.cwins[i]);
            }
        }
        free(tmp->cmaps.cwins);
        if(tmp->cmaps.number_cwins > 1) {
            free(tmp->cmaps.scoreboard);
            tmp->cmaps.scoreboard = NULL;
        }
        tmp->cmaps.number_cwins = 0;
    }
}