static void CreateOrUpdateGoodyGC(void)
{
XGCValues gcval;
unsigned long gcmask;
Pixel pfore;
Pixel pback;
if (colorset >= 0)
{
pfore = Colorset[colorset].fg;
pback = Colorset[colorset].bg;
}
else
{
pfore = fore;
pback = back;
}
gcmask = GCForeground | GCBackground | GCGraphicsExposures;
gcval.foreground = pfore;
gcval.background = pback;
gcval.graphics_exposures = False;
if (FStatusFont->font != NULL)
{
gcval.font = FStatusFont->font->fid;
gcmask = GCFont;
}
if (statusgc)
XChangeGC(dpy, statusgc, gcmask, &gcval);
else
statusgc = fvwmlib_XCreateGC(dpy, win, gcmask, &gcval);
if (do_check_mail)
{
if (mailpix)
XFreePixmap(dpy, mailpix);
mailpix = XCreatePixmapFromBitmapData(
dpy, win, (char *)minimail_bits, minimail_width, minimail_height,
pfore, pback, Pdepth);
if (wmailpix)
XFreePixmap(dpy, wmailpix);
wmailpix = XCreatePixmapFromBitmapData(
dpy, win, (char *)minimail_bits, minimail_width, minimail_height,
PictureBlackPixel(), PictureWhitePixel(), Pdepth);
goodies_width += minimail_width + 7;
}
else if (do_display_clock)
{
goodies_width += 3;
}
else
{
goodies_width += 0;
}
}
/*
* alloc_colorset() grows the size of the Colorset array to include set n
* colorset_t *Colorset will be altered
* returns the address of the member
*/
void alloc_colorset(int n)
{
/* do nothing if it already exists */
if (n < nColorsets)
{
return;
}
else
{
Colorset = (colorset_t *)saferealloc(
(char *)Colorset, (n + 1) * sizeof(colorset_t));
memset(
&Colorset[nColorsets], 0,
(n + 1 - nColorsets) * sizeof(colorset_t));
}
if (n == 0)
{
update_root_pixmap(0);
}
/* initialize new colorsets to black on gray */
while (nColorsets <= n)
{
colorset_t *ncs = &Colorset[nColorsets];
if (PictureUseBWOnly())
{
char g_bits[] = {0x0a, 0x05, 0x0a, 0x05,
0x08, 0x02, 0x08, 0x02,
0x01, 0x02, 0x04, 0x08};
/* monochrome monitors get black on white */
/* with a gray pixmap background */
ncs->fg = GetColor(black);
ncs->bg = GetColor(white);
ncs->hilite = GetColor(white);
ncs->shadow = GetColor(black);
ncs->fgsh = GetColor(white);
ncs->tint = GetColor(black);
ncs->icon_tint = GetColor(black);
ncs->pixmap = XCreatePixmapFromBitmapData(
dpy, Scr.NoFocusWin,
&g_bits[4 * (nColorsets % 3)], 4, 4,
PictureBlackPixel(), PictureWhitePixel(),
Pdepth);
ncs->width = 4;
ncs->height = 4;
}
else
{
ncs->fg = GetColor(black);
ncs->bg = GetColor(gray);
ncs->hilite = GetHilite(ncs->bg);
ncs->shadow = GetShadow(ncs->bg);
ncs->fgsh = GetForeShadow(ncs->fg, ncs->bg);
ncs->tint = GetColor(black);
ncs->icon_tint = GetColor(black);
}
ncs->fg_tint = ncs->bg_tint = GetColor(black);
/* set flags for fg contrast, bg average */
/* in case just a pixmap is given */
ncs->color_flags = FG_CONTRAST | BG_AVERAGE;
ncs->fg_saved = ncs->fg;
ncs->fg_alpha_percent = 100;
ncs->image_alpha_percent = 100;
ncs->icon_alpha_percent = 100;
ncs->tint_percent = 0;
ncs->icon_tint_percent = 0;
ncs->fg_tint_percent = ncs->bg_tint_percent = 0;
ncs->dither = (PictureDitherByDefault())? True:False;
nColorsets++;
}
}
void FScreenInit(Display *dpy)
{
static Bool is_initialised = False;
int dummy_rc;
SUPPRESS_UNUSED_VAR_WARNING(dummy_rc);
if (is_initialised)
{
return;
}
is_initialised = True;
disp = dpy;
if (FScreenXineramaEmulation)
{
int count;
int w;
int h;
int ws;
unsigned long scr;
Window root;
XSetWindowAttributes attributes;
scr = DefaultScreen(disp);
root = RootWindow(disp, scr);
/* xinerama emulation simulates xinerama on a single screen:
*
* actual screen
* +---------------------+--------------+
* | | |
* | | |
* | | |
* | | simulated |
* | | screen 2 |
* | simulated screen 1 | |
* | | |
* | | |
* | | |
* | | |
* +---------------------+ |
* | blank area | |
* | | |
* +---------------------+--------------+
*/
count = 2;
total_screens_xi = count;
screens_xi = (XineramaScreenInfo *)
safemalloc(sizeof(XineramaScreenInfo) * (1 + count));
/* calculate the faked sub screen dimensions */
w = DisplayWidth(disp, scr);
ws = 3 * w / 5;
h = DisplayHeight(disp, scr);
screens_xi[1].screen_number = 0;
screens_xi[1].x_org = 0;
screens_xi[1].y_org = h / 16;
screens_xi[1].width = ws;
screens_xi[1].height = 7 * h / 8;
screens_xi[2].screen_number = 1;
screens_xi[2].x_org = ws;
screens_xi[2].y_org = 0;
screens_xi[2].width = w - ws;
screens_xi[2].height = 7 * h / 8;
/* add delimiter */
attributes.background_pixel = PictureWhitePixel();
attributes.override_redirect = True;
blank_w = XCreateWindow(
disp, root, 0, screens_xi[1].y_org - 1,
screens_xi[1].width, 2, 0, CopyFromParent,
CopyFromParent, CopyFromParent,
CWBackPixel|CWOverrideRedirect, &attributes);
blank2_w = XCreateWindow(
disp, root, 0,
screens_xi[1].y_org + screens_xi[1].height - 1,
screens_xi[1].width, 2, 0, CopyFromParent,
CopyFromParent, CopyFromParent,
CWBackPixel|CWOverrideRedirect, &attributes);
blank3_w = XCreateWindow(
disp, root, screens_xi[2].x_org,
screens_xi[2].height - 1, w - screens_xi[2].x_org, 2,
0, CopyFromParent, CopyFromParent, CopyFromParent,
CWBackPixel|CWOverrideRedirect, &attributes);
vert_w = XCreateWindow(
disp, root, screens_xi[2].x_org - 1, 0, 2, h, 0,
CopyFromParent, CopyFromParent, CopyFromParent,
CWBackPixel|CWOverrideRedirect, &attributes);
}
else if (FScreenHaveXinerama &&
XineramaQueryExtension(disp, &dummy_rc, &dummy_rc) &&
XineramaIsActive(disp))
{
int count;
XineramaScreenInfo *info;
info = FXineramaQueryScreens(disp, &count);
total_screens_xi = count;
screens_xi = (XineramaScreenInfo *)
safemalloc(sizeof(XineramaScreenInfo) *
(1 + count));
memcpy(screens_xi + 1, info,
sizeof(XineramaScreenInfo) * count);
XFree(info);
}
else
{
total_screens_xi = 0;
screens_xi =
(XineramaScreenInfo *)safemalloc(
sizeof(XineramaScreenInfo)*1);
}
total_screens = total_screens_xi;
screens = screens_xi;
/* Now, fill screens[0] with global screen parameters */
screens_xi[0].screen_number = -1;
screens_xi[0].x_org = 0;
screens_xi[0].y_org = 0;
screens_xi[0].width = DisplayWidth (disp, DefaultScreen(disp));
screens_xi[0].height = DisplayHeight(disp, DefaultScreen(disp));
/* Fill in the screen range */
FScreenSetState(is_xinerama_enabled);
return;
}
