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

Go to the documentation of this file.

/*
 * Routines using in setting up the config for workspace stuff.
 */
 
#include "ctwm.h"
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
#include "image.h"
#include "list.h"
#include "occupation.h"
#include "screen.h"
#include "util.h"
#include "workspace_config.h"
#include "workspace_utils.h"
 
 
// Temp; x-ref desc in workspace_utils
extern bool useBackgroundInfo;
 
 
/*
 * Create a workspace.  This is what gets called when parsing
 * WorkSpaces {} config file entries.
 *
 * WorkSpaces {
 *  "One" { name background foreground backback backfore "backpix.jpg" }
 *  #         |      |           |        |       |            |
 *  #     WS name    |      Button Text   |   Map/Root FG      |
 *  #            Button BG             Map BG            Map/Root BG img
 * }
 */
void
AddWorkSpace(const char *name, const char *background, const char *foreground,
             const char *backback, const char *backfore, const char *backpix)
{
    WorkSpace *ws;
 
    /* XXX Shouldn't just silently return if we're already at max...  */
    if(Scr->workSpaceMgr.count == MAXWORKSPACE) {
        return;
    }
 
    /* Init.  Label can change over time, but starts the same as name. */
    ws = calloc(1, sizeof(WorkSpace));
    ws->name  = strdup(name);
    ws->label = strdup(name);
    ws->number = Scr->workSpaceMgr.count++;
 
    /* We're a new entry on the "everything" list */
    fullOccupation |= (1 << ws->number);
 
 
    /*
     * FB/BG colors for the button state may be specified, or fallback to
     * the icon manager's if not.
     */
    if(background == NULL) {
        ws->cp.back = Scr->IconManagerC.back;
    }
    else {
        GetColor(Scr->Monochrome, &(ws->cp.back), background);
    }
 
    if(foreground == NULL) {
        ws->cp.fore = Scr->IconManagerC.fore;
    }
    else {
        GetColor(Scr->Monochrome, &(ws->cp.fore), foreground);
    }
 
    /* Shadows for 3d buttons derived from that */
#ifdef COLOR_BLIND_USER
    ws->cp.shadc = Scr->White;
    ws->cp.shadd = Scr->Black;
#else
    if(!Scr->BeNiceToColormap) {
        GetShadeColors(&ws->cp);
    }
#endif
 
 
    /*
     * Map-state fb/bg color, as well as root win background.
     */
    if(backback == NULL) {
        GetColor(Scr->Monochrome, &(ws->backcp.back), "Black");
    }
    else {
        GetColor(Scr->Monochrome, &(ws->backcp.back), backback);
        useBackgroundInfo = true;
    }
 
    if(backfore == NULL) {
        GetColor(Scr->Monochrome, &(ws->backcp.fore), "White");
    }
    else {
        GetColor(Scr->Monochrome, &(ws->backcp.fore), backfore);
        useBackgroundInfo = true;
    }
 
 
    /* Maybe there's an image to stick on the root as well */
    ws->image = GetImage(backpix, ws->backcp);
    if(ws->image != NULL) {
        useBackgroundInfo = true;
    }
 
 
    /* Put ourselves on the end of the workspace list */
    if(Scr->workSpaceMgr.workSpaceList == NULL) {
        Scr->workSpaceMgr.workSpaceList = ws;
    }
    else {
        WorkSpace *wstmp = Scr->workSpaceMgr.workSpaceList;
        while(wstmp->next != NULL) {
            wstmp = wstmp->next;
        }
        wstmp->next = ws;
    }
 
    /* There's at least one defined WS now */
    Scr->workSpaceManagerActive = true;
 
    return;
}
 
 
 
/*
 * MapWindowCurrentWorkSpace {} parsing
 */
void
WMapCreateCurrentBackGround(const char *border,
                            const char *background, const char *foreground,
                            const char *pixmap)
{
    Image *image;
    WorkSpaceMgr *ws = &Scr->workSpaceMgr;
 
    ws->curBorderColor = Scr->Black;
    ws->curColors.back = Scr->White;
    ws->curColors.fore = Scr->Black;
    ws->curImage       = NULL;
 
    if(border == NULL) {
        return;
    }
    GetColor(Scr->Monochrome, &ws->curBorderColor, border);
    if(background == NULL) {
        return;
    }
    ws->curPaint = true;
    GetColor(Scr->Monochrome, &ws->curColors.back, background);
    if(foreground == NULL) {
        return;
    }
    GetColor(Scr->Monochrome, &ws->curColors.fore, foreground);
 
    if(pixmap == NULL) {
        return;
    }
    if((image = GetImage(pixmap, Scr->workSpaceMgr.curColors)) == NULL) {
        fprintf(stderr, "Can't find pixmap %s\n", pixmap);
        return;
    }
    ws->curImage = image;
}
 
 
 
/*
 * MapWindowDefaultWorkSpace {} parsing
 */
void
WMapCreateDefaultBackGround(const char *border,
                            const char *background, const char *foreground,
                            const char *pixmap)
{
    Image *image;
    WorkSpaceMgr *ws = &Scr->workSpaceMgr;
 
    ws->defBorderColor = Scr->Black;
    ws->defColors.back = Scr->White;
    ws->defColors.fore = Scr->Black;
    ws->defImage       = NULL;
 
    if(border == NULL) {
        return;
    }
    GetColor(Scr->Monochrome, &ws->defBorderColor, border);
    if(background == NULL) {
        return;
    }
    GetColor(Scr->Monochrome, &ws->defColors.back, background);
    if(foreground == NULL) {
        return;
    }
    GetColor(Scr->Monochrome, &ws->defColors.fore, foreground);
    if(pixmap == NULL) {
        return;
    }
    if((image = GetImage(pixmap, ws->defColors)) == NULL) {
        return;
    }
    ws->defImage = image;
}