/**
*** ParseBack()
*** Parses the options possible to Back
**/
static int ParseBack(char **ss)
{
char *opts[] =
{
"icon",
NULL
};
char *t,*s=*ss;
int r=0;
while(*s && *s!=')')
{
s = trimleft(s);
if(*s==',')
s++;
else switch(GetTokenIndex(s,opts,-1,&s))
{
case 0: /* Icon */
r=1;
fprintf(stderr,"%s: Back(Icon) not supported yet\n",MyName);
break;
default:
t=seekright(&s);
fprintf(stderr,"%s: Illegal back option \"%s\"\n",MyName,(t)?t:"");
if (t)
free(t);
}
}
if(*s)
s++;
*ss=s;
return r;
}
void RTF_DoStyleControl (FILE* f, char* control, char* arg)
{
if(GetTokenIndex(control)==t_s)
{
strcpy(style_number,arg);
}
}
Bool StartButtonParseConfig(char *tline)
{
char *rest;
char *option;
int i;
option = tline + Clength;
i = GetTokenIndex(option, startopts, -1, &rest);
while (*rest && *rest != '\n' && isspace(*rest))
rest++;
switch(i)
{
case 0: /* StartName */
CopyString(&StartName, rest);
break;
case 1: /* StartMenu */
CopyString(&StartPopup, rest);
break;
case 2: /* StartIcon */
CopyString(&StartIconName, rest);
break;
default:
/* unknown option */
return False;
} /* switch */
return True;
}
/**
*** ParseOptions()
**/
void ParseConfiguration(button_info *ub)
{
char *s;
char *items[] =
{
NULL, /* filled out below */
"imagepath",
"colorset",
XINERAMA_CONFIG_STRING,
NULL
};
items[0] = mymalloc(strlen(MyName) + 2);
sprintf(items[0], "*%s", MyName);
/* send config lines with MyName */
InitGetConfigLine(fd, items[0]);
GetConfigLine(fd, &s);
while (s && s[0])
{
char *rest;
switch (GetTokenIndex(s,items,-1,&rest))
{
case -1:
break;
case 0:
if (rest && rest[0] && !config_file)
{
ParseConfigLine(&ub, rest);
}
break;
case 1:
if (imagePath)
{
free(imagePath);
}
CopyString(&imagePath, rest);
break;
case 2:
/* store colorset sent by fvwm */
LoadColorset(rest);
break;
case 3:
/* Xinerama state */
FScreenConfigureModule(rest);
break;
}
GetConfigLine(fd,&s);
}
if (config_file)
{
ParseConfigFile(ub);
}
free(items[0]);
return;
}
/* Parse and set options for this taskbar button (start or launcher). This
* will check for a string of the form (<opt1>,<opt2>...), similar to options
* for an FvwmButtons button. The return value is a pointer to the rest of the
* config line.
*
* Currently this sets just one option, mouseButton. If no "Mouse <n>" option
* is found, mouseButton will be set to 0.
*/
char *ParseButtonOptions(char *pos, int *mouseButton)
{
char *token = NULL;
char *rest;
int i;
static char *buttonOptions[] = {"Mouse", NULL};
*mouseButton = 0;
while (*pos && isspace(*pos))
pos++;
if (*pos != '(')
return pos;
pos++;
while (*pos && isspace(*pos))
pos++;
while (*pos && *pos != ')')
{
pos = GetNextToken(pos, &token);
if (!token)
break;
i = GetTokenIndex(token, buttonOptions, 0, NULL);
switch (i)
{
case 0: /* Mouse */
*mouseButton = strtol(pos, &rest, 10);
pos = rest;
if (*mouseButton < 1 || *mouseButton > NUMBER_OF_EXTENDED_MOUSE_BUTTONS)
{
fprintf(stderr,"%s: Invalid mouse button %d", module->name,
*mouseButton);
*mouseButton = 0;
}
break;
default:
fprintf(stderr,"%s: Invalid taskbar button option '%s'", module->name,
token);
}
while (*pos && *pos != ',' && *pos != ')')
pos++;
if (*pos == ',') {
pos++;
while (*pos && *pos != ',' && *pos != ')')
pos++;
}
free(token);
}
if (*pos)
pos++;
while (*pos && isspace(*pos))
pos++;
return pos;
}
/**
*** ParseTitle()
*** Parses the options possible to Title
**/
static void ParseTitle(char **ss, byte *flags, byte *mask)
{
char *titleopts[] =
{
"left",
"right",
"center",
"side",
NULL
};
char *t,*s=*ss;
while(*s && *s!=')')
{
s = trimleft(s);
if(*s==',')
s++;
else switch(GetTokenIndex(s,titleopts,-1,&s))
{
case 0: /* Left */
*flags&=~b_TitleHoriz;
*mask|=b_TitleHoriz;
break;
case 1: /* Right */
*flags&=~b_TitleHoriz;
*flags|=2;
*mask|=b_TitleHoriz;
break;
case 2: /* Center */
*flags&=~b_TitleHoriz;
*flags|=1;
*mask|=b_TitleHoriz;
break;
case 3: /* Side */
*flags|=b_Horizontal;
*mask|=b_Horizontal;
break;
default:
t=seekright(&s);
fprintf(stderr,"%s: Illegal title option \"%s\"\n",MyName,(t)?t:"");
if (t)
free(t);
}
}
if(*s) s++;
*ss=s;
}
/**
*** ParseSwallow()
*** Parses the options possible to Swallow
**/
static void ParseSwallow(
char **ss, unsigned int *flags, unsigned int *mask, button_info *b)
{
char *swallowopts[] =
{
"nohints", "hints",
"nokill", "kill",
"noclose", "close",
"respawn", "norespawn",
"useold", "noold",
"usetitle", "notitle",
"fvwmmodule", "nofvwmmodule",
"swallownew",
NULL
};
char *t, *s = *ss;
while (*s && *s != ')')
{
s = trimleft(s);
if (*s == ',')
{
s++;
continue;
}
switch (GetTokenIndex(s, swallowopts, -1, &s))
{
case 0: /* NoHints */
*flags |= b_NoHints;
*mask |= b_NoHints;
break;
case 1: /* Hints */
*flags &= ~b_NoHints;
*mask |= b_NoHints;
break;
case 2: /* NoKill */
*flags &= ~b_Kill;
*mask |= b_Kill;
break;
case 3: /* Kill */
*flags |= b_Kill;
*mask |= b_Kill;
break;
case 4: /* NoClose */
*flags |= b_NoClose;
*mask |= b_NoClose;
break;
case 5: /* Close */
*flags &= ~b_NoClose;
*mask |= b_NoClose;
break;
case 6: /* Respawn */
*flags |= b_Respawn;
*mask |= b_Respawn;
b->newflags.do_swallow_new = 0;
break;
case 7: /* NoRespawn */
*flags &= ~b_Respawn;
*mask |= b_Respawn;
b->newflags.do_swallow_new = 0;
break;
case 8: /* UseOld */
*flags |= b_UseOld;
*mask |= b_UseOld;
break;
case 9: /* NoOld */
*flags &= ~b_UseOld;
*mask |= b_UseOld;
break;
case 10: /* UseTitle */
*flags |= b_UseTitle;
*mask |= b_UseTitle;
break;
case 11: /* NoTitle */
*flags &= ~b_UseTitle;
*mask |= b_UseTitle;
break;
case 12: /* FvwmModule */
*flags |= b_FvwmModule;
*mask |= b_FvwmModule;
break;
case 13: /* NoFvwmModule */
*flags &= ~b_FvwmModule;
*mask |= b_FvwmModule;
break;
case 14: /* SwallowNew */
*flags &= ~b_Respawn;
*mask |= b_Respawn;
b->newflags.do_swallow_new = 1;
break;
default:
t = seekright(&s);
fprintf(stderr,
"%s: Illegal Swallow option \"%s\"\n", MyName,
(t) ? t : "");
if (t)
{
free(t);
}
}
}
if (*s)
{
s++;
}
*ss = s;
}
/**
*** ParseConfigLine
**/
static void ParseConfigLine(button_info **ubb, char *s)
{
button_info *ub = *ubb;
char *opts[] =
{
"geometry",
"buttongeometry",
"font",
"padding",
"columns",
"rows",
"back",
"fore",
"frame",
"file",
"pixmap",
"boxsize",
"colorset",
"activecolorset",
"presscolorset",
NULL
};
int i, j, k;
switch (GetTokenIndex(s, opts, -1, &s))
{
case 0:/* Geometry */
{
char geom[64];
i = sscanf(s, "%63s", geom);
if (i == 1)
{
parse_window_geometry(geom, 0);
}
break;
}
case 1:/* ButtonGeometry */
{
char geom[64];
i = sscanf(s, "%63s", geom);
if (i == 1)
{
parse_window_geometry(geom, 1);
}
break;
}
case 2:/* Font */
if (ub->c->font_string)
{
free(ub->c->font_string);
}
CopyStringWithQuotes(&ub->c->font_string, s);
break;
case 3:/* Padding */
i = sscanf(s, "%d %d", &j, &k);
if (i > 0)
{
ub->c->xpad = ub->c->ypad = j;
}
if (i > 1)
{
ub->c->ypad = k;
}
break;
case 4:/* Columns */
i = sscanf(s, "%d", &j);
if (i > 0)
{
ub->c->num_columns = j;
}
break;
case 5:/* Rows */
i = sscanf(s, "%d", &j);
if (i > 0)
{
ub->c->num_rows = j;
}
break;
case 6:/* Back */
if (ub->c->back)
{
free(ub->c->back);
}
CopyString(&(ub->c->back), s);
break;
case 7:/* Fore */
if (ub->c->fore)
{
free(ub->c->fore);
}
CopyString(&(ub->c->fore), s);
break;
case 8:/* Frame */
i = sscanf(s,"%d",&j);
if (i > 0)
{
ub->c->framew = j;
}
break;
case 9:/* File */
s = trimleft(s);
if (config_file)
{
free(config_file);
}
config_file = seekright(&s);
break;
case 10:/* Pixmap */
s = trimleft(s);
if (strncasecmp(s, "none", 4) == 0)
{
ub->c->flags.b_TransBack = 1;
}
else
{
if (ub->c->back_file)
{
free(ub->c->back_file);
}
CopyString(&(ub->c->back_file),s);
}
ub->c->flags.b_IconBack = 1;
break;
case 11: /* BoxSize */
ParseBoxSize(&s, &ub->c->flags);
break;
case 12: /* Colorset */
i = sscanf(s, "%d", &j);
if (i > 0)
{
ub->c->colorset = j;
ub->c->flags.b_Colorset = 1;
AllocColorset(j);
}
else
{
ub->c->flags.b_Colorset = 0;
}
break;
case 13: /* ActiveColorset */
i = sscanf(s, "%d", &j);
if (i > 0)
{
ub->c->activeColorset = j;
ub->c->flags.b_ActiveColorset = 1;
AllocColorset(j);
}
else
{
ub->c->flags.b_ActiveColorset = 0;
}
break;
case 14: /* PressColorset */
i = sscanf(s, "%d", &j);
if (i > 0)
{
ub->c->pressColorset = j;
ub->c->flags.b_PressColorset = 1;
AllocColorset(j);
}
else
{
ub->c->flags.b_PressColorset = 0;
}
break;
default:
s = trimleft(s);
ParseButton(ubb, s);
break;
}
}
static signed int expand_vars_extended(
char *var_name, char *output, cond_rc_t *cond_rc,
const exec_context_t *exc)
{
char *rest;
char dummy[64] = "\0";
char *target = (output) ? output : dummy;
int cs = -1;
int n;
int i;
int l;
int x;
int y;
Pixel pixel = 0;
int val = -12345678;
const char *string = NULL;
char *allocated_string = NULL;
char *quoted_string = NULL;
Bool should_quote = False;
Bool is_numeric = False;
Bool is_target = False;
Bool is_x;
Window context_w = Scr.Root;
FvwmWindow *fw = exc->w.fw;
signed int len = -1;
/* allow partial matches for *.cs, gt, ... etc. variables */
switch ((i = GetTokenIndex(var_name, partial_function_vars, -1, &rest)))
{
case VAR_FG_CS:
case VAR_BG_CS:
case VAR_HILIGHT_CS:
case VAR_SHADOW_CS:
case VAR_FGSH_CS:
if (!isdigit(*rest) || (*rest == '0' && *(rest + 1) != 0))
{
/* not a non-negative integer without leading zeros */
return -1;
}
if (sscanf(rest, "%d%n", &cs, &n) < 1)
{
return -1;
}
if (*(rest + n) != 0)
{
/* trailing characters */
return -1;
}
if (cs < 0)
{
return -1;
}
alloc_colorset(cs);
switch (i)
{
case VAR_FG_CS:
pixel = Colorset[cs].fg;
break;
case VAR_BG_CS:
pixel = Colorset[cs].bg;
break;
case VAR_HILIGHT_CS:
pixel = Colorset[cs].hilite;
break;
case VAR_SHADOW_CS:
pixel = Colorset[cs].shadow;
break;
case VAR_FGSH_CS:
pixel = Colorset[cs].fgsh;
break;
}
is_target = True;
len = pixel_to_color_string(dpy, Pcmap, pixel, target, False);
goto GOT_STRING;
case VAR_GT_:
if (rest == NULL)
{
return -1;
}
string = _(rest);
goto GOT_STRING;
case VAR_INFOSTORE_:
if (rest == NULL)
return -1;
if ((string = get_metainfo_value(rest)) == NULL)
return -1;
goto GOT_STRING;
case VAR_DESK_NAME:
if (sscanf(rest, "%d%n", &cs, &n) < 1)
{
return -1;
}
if (*(rest + n) != 0)
{
/* trailing characters */
return -1;
}
string = GetDesktopName(cs);
if (string == NULL)
{
const char *ddn = _("Desk");
allocated_string = (char *)safemalloc(19 + strlen(ddn));
sprintf(allocated_string, "%s %i", ddn, cs);
string = allocated_string;
}
goto GOT_STRING;
default:
break;
}
/* only exact matches for all other variables */
switch ((i = GetTokenIndex(var_name, function_vars, 0, &rest)))
{
case VAR_DESK_N:
is_numeric = True;
val = Scr.CurrentDesk;
break;
case VAR_DESK_WIDTH:
is_numeric = True;
val = Scr.VxMax + Scr.MyDisplayWidth;
break;
case VAR_DESK_HEIGHT:
is_numeric = True;
val = Scr.VyMax + Scr.MyDisplayHeight;
break;
case VAR_DESK_PAGESX:
is_numeric = True;
val = (int)(Scr.VxMax / Scr.MyDisplayWidth) + 1;
break;
case VAR_DESK_PAGESY:
is_numeric = True;
val = (int)(Scr.VyMax / Scr.MyDisplayHeight) + 1;
break;
case VAR_VP_X:
is_numeric = True;
val = Scr.Vx;
break;
case VAR_VP_Y:
is_numeric = True;
val = Scr.Vy;
break;
case VAR_VP_WIDTH:
is_numeric = True;
val = Scr.MyDisplayWidth;
break;
case VAR_VP_HEIGHT:
is_numeric = True;
val = Scr.MyDisplayHeight;
break;
case VAR_WA_HEIGHT:
is_numeric = True;
val = Scr.Desktops->ewmh_working_area.height;
break;
case VAR_WA_WIDTH:
is_numeric = True;
val = Scr.Desktops->ewmh_working_area.width;
break;
case VAR_WA_X:
is_numeric = True;
val = Scr.Desktops->ewmh_working_area.x;
break;
case VAR_WA_Y:
is_numeric = True;
val = Scr.Desktops->ewmh_working_area.y;
break;
case VAR_DWA_HEIGHT:
is_numeric = True;
val = Scr.Desktops->ewmh_dyn_working_area.height;
break;
case VAR_DWA_WIDTH:
is_numeric = True;
val = Scr.Desktops->ewmh_dyn_working_area.width;
break;
case VAR_DWA_X:
is_numeric = True;
val = Scr.Desktops->ewmh_dyn_working_area.x;
break;
case VAR_DWA_Y:
is_numeric = True;
val = Scr.Desktops->ewmh_dyn_working_area.y;
break;
case VAR_PAGE_NX:
is_numeric = True;
val = (int)(Scr.Vx / Scr.MyDisplayWidth);
break;
case VAR_PAGE_NY:
is_numeric = True;
val = (int)(Scr.Vy / Scr.MyDisplayHeight);
break;
case VAR_W_ID:
if (fw && !IS_EWMH_DESKTOP(FW_W(fw)))
{
is_target = True;
sprintf(target, "0x%x", (int)FW_W(fw));
}
break;
case VAR_W_NAME:
if (fw && !IS_EWMH_DESKTOP(FW_W(fw)))
{
string = fw->name.name;
should_quote = True;
}
break;
case VAR_W_ICONNAME:
if (fw && !IS_EWMH_DESKTOP(FW_W(fw)))
{
string = fw->icon_name.name;
should_quote = True;
}
break;
case VAR_W_ICONFILE:
case VAR_W_MINIICONFILE:
if (fw && !IS_EWMH_DESKTOP(FW_W(fw)))
{
char *t;
t = (i == VAR_W_ICONFILE) ?
fw->icon_bitmap_file : fw->mini_pixmap_file;
/* expand the path if possible */
allocated_string = PictureFindImageFile(t, NULL, R_OK);
if (allocated_string == NULL)
{
string = t;
}
else if (USE_SVG && *allocated_string == ':' &&
(string = strchr(allocated_string + 1, ':')))
{
string++;
}
else
{
string = allocated_string;
}
}
break;
case VAR_W_ICONFILE_SVGOPTS:
case VAR_W_MINIICONFILE_SVGOPTS:
if (fw && !IS_EWMH_DESKTOP(FW_W(fw)))
{
char *t;
if (!USE_SVG)
{
return -1;
}
t = (i == VAR_W_ICONFILE_SVGOPTS) ?
fw->icon_bitmap_file : fw->mini_pixmap_file;
/* expand the path if possible */
allocated_string = PictureFindImageFile(t, NULL, R_OK);
string = allocated_string;
if (string && *string == ':' &&
(t = strchr(string + 1, ':')))
{
*t = 0;
}
else
{
string = "";
}
}
break;
case VAR_W_CLASS:
if (fw && !IS_EWMH_DESKTOP(FW_W(fw)))
{
string = fw->class.res_class;
should_quote = True;
}
break;
case VAR_W_RESOURCE:
if (fw && !IS_EWMH_DESKTOP(FW_W(fw)))
{
string = fw->class.res_name;
should_quote = True;
}
/*#define DEBUG_PARSER*/
static void ParseButton(button_info **uberb, char *s)
{
button_info *b, *ub = *uberb;
int i, j;
char *t, *o;
b = alloc_button(ub, (ub->c->num_buttons)++);
s = trimleft(s);
if (*s == '(' && s++)
{
char *opts[] =
{
"back",
"fore",
"font",
"title",
"icon",
"frame",
"padding",
"swallow",
"panel",
"actionignoresclientwindow",
"actiononpress",
"container",
"end",
"nosize",
"size",
"left",
"right",
"center",
"colorset",
"action",
"id",
"activeicon",
"activetitle",
"pressicon",
"presstitle",
"activecolorset",
"presscolorset",
"top",
NULL
};
s = trimleft(s);
while (*s && *s != ')')
{
Bool is_swallow = False;
if (*s == ',')
{
s++;
s = trimleft(s);
continue;
}
if (isdigit(*s) || *s == '+' || *s == '-')
{
char *geom;
int x, y, flags;
unsigned int w, h;
geom = seekright(&s);
if (geom)
{
flags = XParseGeometry(geom, &x, &y, &w, &h);
if (flags&WidthValue)
{
b->BWidth = w;
}
if (flags&HeightValue)
{
b->BHeight = h;
}
if (flags & XValue)
{
b->BPosX = x;
b->flags.b_PosFixed = 1;
}
if (flags & YValue)
{
b->BPosY = y;
b->flags.b_PosFixed = 1;
}
if (flags & XNegative)
{
b->BPosX = -1 - x;
}
if (flags & YNegative)
{
b->BPosY = -1 - y;
}
free(geom);
}
s = trimleft(s);
continue;
}
switch (GetTokenIndex(s, opts, -1, &s))
{
case 0: /* Back */
s = trimleft(s);
if (*s == '(' && s++ && ParseBack(&s))
{
b->flags.b_IconBack = 1;
}
if (b->flags.b_Back && b->back)
{
free(b->back);
}
b->back = seekright(&s);
if (b->back)
{
b->flags.b_Back = 1;
}
else
{
b->flags.b_IconBack = 0;
b->flags.b_Back = 0;
}
break;
case 1: /* Fore */
if (b->flags.b_Fore && b->fore)
{
free(b->fore);
}
b->fore = seekright(&s);
b->flags.b_Fore = (b->fore ? 1 : 0);
break;
case 2: /* Font */
if (b->flags.b_Font && b->font_string)
{
free(b->font_string);
}
b->font_string = my_get_font(&s);
b->flags.b_Font = (b->font_string ? 1 : 0);
break;
/* ----------------- title --------------- */
case 3: /* Title */
s = trimleft(s);
if (*s == '(' && s++)
{
b->justify = 0;
b->justify_mask = 0;
ParseTitle(
&s, &b->justify,
&b->justify_mask);
if (b->justify_mask)
{
b->flags.b_Justify = 1;
}
}
t = seekright(&s);
if (t && *t && (t[0] != '-' || t[1] != 0))
{
if (b->title)
{
free(b->title);
}
b->title = t;
#ifdef DEBUG_PARSER
fprintf(stderr,
"PARSE: Title \"%s\"\n",
b->title);
#endif
b->flags.b_Title = 1;
}
else
{
fprintf(stderr,
"%s: Missing title argument\n",
MyName);
if (t)
{
free(t);
}
}
break;
/* ------------------ icon --------------- */
case 4: /* Icon */
t = seekright(&s);
if (t && *t && (t[0] != '-' || t[1] != 0))
{
if (b->flags.b_Swallow)
{
fprintf(stderr,
"%s: a button can not "
"have an icon and a "
"swallowed window at "
"the same time. "
"Ignoring icon\n",
MyName);
}
else
{
if (b->icon_file)
{
free(b->icon_file);
}
b->icon_file = t;
b->flags.b_Icon = 1;
}
}
else
{
fprintf(stderr,
"%s: Missing Icon argument\n",
MyName);
if (t)
{
free(t);
}
}
break;
/* ----------------- frame --------------- */
case 5: /* Frame */
i = strtol(s, &t, 10);
if (t > s)
{
b->flags.b_Frame = 1;
b->framew = i;
s = t;
}
else
{
fprintf(stderr,
"%s: Illegal frame argument\n",
MyName);
}
break;
/* ---------------- padding -------------- */
case 6: /* Padding */
i = strtol(s,&t,10);
if (t>s)
{
b->xpad = b->ypad = i;
b->flags.b_Padding = 1;
s = t;
i = strtol(s, &t, 10);
if (t > s)
{
b->ypad = i;
s = t;
}
}
else
{
fprintf(stderr,
"%s: Illegal padding "
"argument\n", MyName);
}
break;
/* ---------------- swallow -------------- */
case 7: /* Swallow */
is_swallow = True;
/* fall through */
case 8: /* Panel */
s = trimleft(s);
if (is_swallow)
{
b->swallow = 0;
b->swallow_mask = 0;
}
else
{
/* set defaults */
b->swallow = b_Respawn;
b->swallow_mask = b_Respawn;
b->slide_direction = SLIDE_UP;
b->slide_position = SLIDE_POSITION_CENTER;
b->slide_context = SLIDE_CONTEXT_PB;
b->relative_x = 0;
b->relative_y = 0;
b->slide_steps = 12;
b->slide_delay_ms = 5;
}
if (*s == '(' && s++)
{
if (is_swallow)
{
ParseSwallow(
&s, &b->swallow,
&b->swallow_mask, b);
}
else
{
ParsePanel(
&s, &b->swallow,
&b->swallow_mask,
&b->slide_direction,
&b->slide_steps,
&b->slide_delay_ms,
&b->panel_flags,
&b->indicator_size,
&b->relative_x,
&b->relative_y,
&b->slide_position,
&b->slide_context);
}
}
t = seekright(&s);
o = seekright(&s);
if (t)
{
if (b->hangon)
{
free(b->hangon);
}
b->hangon = t;
if (is_swallow)
{
if (b->flags.b_Icon)
{
fprintf(stderr,
"%s: a button can not "
"have an icon and a "
"swallowed window at "
"the same time. "
"Ignoring icon\n",
MyName);
b->flags.b_Icon = 0;
}
b->flags.b_Swallow = 1;
b->flags.b_Hangon = 1;
}
else
{
b->flags.b_Panel = 1;
b->flags.b_Hangon = 1;
b->newflags.is_panel = 1;
b->newflags.panel_mapped = 0;
}
b->swallow |= 1;
if (!(b->swallow & b_NoHints))
{
b->hints = (XSizeHints*)
mymalloc(sizeof(XSizeHints));
}
if (o)
{
char *p;
p = module_expand_action(
Dpy, screen, o, NULL,
UberButton->c->fore,
UberButton->c->back);
if (p)
{
if (!(buttonSwallow(b)&b_UseOld))
{
exec_swallow(p,b);
}
if (b->spawn)
{
free(b->spawn);
}
/* Might be needed if
* respawning sometime
*/
b->spawn = o;
free(p);
}
}
}
else
{
fprintf(stderr,
"%s: Missing swallow "
"argument\n", MyName);
if (t)
{
free(t);
}
if (o)
{
free(o);
}
}
/* check if it is a module by command line inspection if
* this hints has not been given in the swallow option */
if (is_swallow && !(b->swallow_mask & b_FvwmModule))
{
if (b->spawn != NULL &&
(strncasecmp(b->spawn, "module", 6) == 0 ||
strncasecmp(b->spawn, "fvwm", 4) == 0))
{
b->swallow |= b_FvwmModule;
}
}
break;
case 9: /* ActionIgnoresClientWindow */
b->flags.b_ActionIgnoresClientWindow = 1;
break;
case 10: /* ActionOnPress */
b->flags.b_ActionOnPress = 1;
break;
/* ---------------- container ------------ */
case 11: /* Container */
/*
* SS: This looks very buggy! The FvwmButtons
* man page suggests it's here to restrict the
* options used with "Container", but it only
* restricts those options appearing _before_
* the "Container" keyword for a button.
* b->flags&=b_Frame|b_Back|b_Fore|b_Padding|b_Action;
*/
MakeContainer(b);
*uberb = b;
s = trimleft(s);
if (*s == '(' && s++)
{
ParseContainer(&s,b);
}
break;
case 12: /* End */
*uberb = ub->parent;
ub->c->buttons[--(ub->c->num_buttons)] = NULL;
free(b);
if (!ub->parent)
{
fprintf(stderr,"%s: Unmatched END in config file\n",MyName);
exit(1);
}
if (ub->parent->c->flags.b_Colorset ||
ub->parent->c->flags.b_ColorsetParent)
{
ub->c->flags.b_ColorsetParent = 1;
}
if (ub->parent->c->flags.b_IconBack || ub->parent->c->flags.b_IconParent)
{
ub->c->flags.b_IconParent = 1;
}
return;
case 13: /* NoSize */
b->flags.b_Size = 1;
b->minx = b->miny = 0;
break;
case 14: /* Size */
i = strtol(s, &t, 10);
j = strtol(t, &o, 10);
if (t > s && o > t)
{
b->minx = i;
b->miny = j;
b->flags.b_Size = 1;
s = o;
}
else
{
fprintf(stderr,
"%s: Illegal size arguments\n",
MyName);
}
break;
case 15: /* Left */
b->flags.b_Left = 1;
b->flags.b_Right = 0;
break;
case 16: /* Right */
b->flags.b_Right = 1;
b->flags.b_Left = 0;
break;
case 17: /* Center */
b->flags.b_Right = 0;
b->flags.b_Left = 0;
break;
case 18: /* Colorset */
i = strtol(s, &t, 10);
if (t > s)
{
b->colorset = i;
b->flags.b_Colorset = 1;
s = t;
AllocColorset(i);
}
else
{
b->flags.b_Colorset = 0;
}
break;
/* ----------------- action -------------- */
case 19: /* Action */
s = trimleft(s);
i = 0;
if (*s == '(')
{
s++;
if (strncasecmp(s, "mouse", 5) != 0)
{
fprintf(stderr,
"%s: Couldn't parse "
"action\n", MyName);
}
s += 5;
i = strtol(s, &t, 10);
s = t;
while (*s && *s != ')')
{
s++;
}
if (*s == ')')
{
s++;
}
}
{
char *r;
char *u = s;
s = GetQuotedString(s, &t, ",)", NULL, "(", ")");
r = s;
if (t && r > u + 1)
{
/* remove unquoted trailing spaces */
r -= 2;
while (r >= u && isspace(*r))
{
r--;
}
r++;
if (isspace(*r))
{
t[strlen(t) - (s - r - 1)] = 0;
}
}
}
if (t)
{
AddButtonAction(b,i,t);
free(t);
}
else
{
fprintf(stderr,
"%s: Missing action argument\n",
MyName);
}
break;
case 20: /* Id */
s = trimleft(s);
s = DoGetNextToken(s, &t, NULL, ",)", &terminator);
/* it should include the delimiter */
if (s && terminator == ')')
{
s--;
}
if (t)
{
if (isalpha(t[0]))
{
/* should check for duplicate ids first... */
b->flags.b_Id = 1;
if (b->id)
{
free(b->id);
}
CopyString(&b->id, t);
}
else
{
fprintf(stderr,
"%s: Incorrect id '%s' "
"ignored\n", MyName, t);
}
free(t);
}
else
{
fprintf(stderr,
"%s: Missing id argument\n",
MyName);
}
break;
/* ------------------ ActiveIcon --------------- */
case 21: /* ActiveIcon */
t = seekright(&s);
if (t && *t && (t[0] != '-' || t[1] != 0))
{
if (b->flags.b_Swallow)
{
fprintf(stderr,
"%s: a button can not "
"have a ActiveIcon and "
"a swallowed window at "
"the same time. "
"Ignoring ActiveIcon.\n",
MyName);
}
else
{
if (b->active_icon_file)
{
free(b->active_icon_file);
}
b->active_icon_file = t;
b->flags.b_ActiveIcon = 1;
}
}
else
{
fprintf(stderr,
"%s: Missing ActiveIcon "
"argument\n", MyName);
if (t)
{
free(t);
}
}
break;
/* --------------- ActiveTitle --------------- */
case 22: /* ActiveTitle */
s = trimleft(s);
if (*s == '(')
{
fprintf(stderr,
"%s: justification not allowed "
"for ActiveTitle.\n", MyName);
}
t = seekright(&s);
if (t && *t && (t[0] != '-' || t[1] != 0))
{
if (b->activeTitle)
{
free(b->activeTitle);
}
b->activeTitle = t;
#ifdef DEBUG_PARSER
fprintf(stderr,
"PARSE: ActiveTitle \"%s\"\n",
b->activeTitle);
#endif
b->flags.b_ActiveTitle = 1;
}
else
{
fprintf(stderr,
"%s: Missing ActiveTitle "
"argument\n", MyName);
if (t)
{
free(t);
}
}
break;
/* --------------- PressIcon --------------- */
case 23: /* PressIcon */
t = seekright(&s);
if (t && *t && (t[0] != '-' || t[1] != 0))
{
if (b->flags.b_Swallow)
{
fprintf(stderr,
"%s: a button can not "
"have a PressIcon and "
"a swallowed window at "
"the same time. "
"Ignoring PressIcon.\n",
MyName);
}
else
{
if (b->press_icon_file)
{
free(b->press_icon_file);
}
b->press_icon_file = t;
b->flags.b_PressIcon = 1;
}
}
else
{
fprintf(stderr,
"%s: Missing PressIcon "
"argument\n", MyName);
if (t)
{
free(t);
}
}
break;
/* --------------- PressTitle --------------- */
case 24: /* PressTitle */
s = trimleft(s);
if (*s == '(')
{
fprintf(stderr,
"%s: justification not allowed "
"for PressTitle.\n", MyName);
}
t = seekright(&s);
if (t && *t && (t[0] != '-' || t[1] != 0))
{
if (b->pressTitle)
{
free(b->pressTitle);
}
b->pressTitle = t;
#ifdef DEBUG_PARSER
fprintf(stderr,
"PARSE: PressTitle \"%s\"\n",
b->pressTitle);
#endif
b->flags.b_PressTitle = 1;
}
else
{
fprintf(stderr,
"%s: Missing PressTitle "
"argument\n", MyName);
if (t)
{
free(t);
}
}
break;
/* --------------- --------------- */
case 25: /* ActiveColorset */
i = strtol(s, &t, 10);
if (t > s)
{
b->activeColorset = i;
b->flags.b_ActiveColorset = 1;
s = t;
AllocColorset(i);
}
else
{
b->flags.b_ActiveColorset = 0;
}
break;
/* --------------- --------------- */
case 26: /* PressColorset */
i = strtol(s, &t, 10);
if (t > s)
{
b->pressColorset = i;
b->flags.b_PressColorset = 1;
s = t;
AllocColorset(i);
}
else
{
b->flags.b_PressColorset = 0;
}
break;
case 27: /* top */
b->flags.b_Top = 1;
break;
/* --------------- --------------- */
default:
t = seekright(&s);
fprintf(stderr,
"%s: Illegal button option \"%s\"\n",
MyName, (t) ? t : "");
if (t)
{
free(t);
}
break;
} /* end switch */
s = trimleft(s);
}
if (s && *s)
{
s++;
s = trimleft(s);
}
}
/* get title and iconname */
if (!b->flags.b_Title)
{
b->title = seekright(&s);
if (b->title && *b->title &&
((b->title)[0] != '-' || (b->title)[1] != 0))
{
b->flags.b_Title = 1;
}
else if (b->title)
{
free(b->title);
}
}
else
{
char *temp;
temp = seekright(&s);
if (temp)
{
free(temp);
}
}
if (!b->flags.b_Icon)
{
b->icon_file = seekright(&s);
if (b->icon_file && b->icon_file &&
((b->icon_file)[0] != '-'||(b->icon_file)[1] != 0))
{
b->flags.b_Icon = 1;
}
else if (b->icon_file)
{
free(b->icon_file);
}
}
else
{
char *temp;
temp = seekright(&s);
if (temp)
{
free(temp);
}
}
s = trimleft(s);
/* Swallow hangon command */
if (strncasecmp(s, "swallow", 7) == 0 || strncasecmp(s, "panel", 7) == 0)
{
if (b->flags.b_Swallow || b->flags.b_Panel)
{
fprintf(stderr,
"%s: Illegal with both old and new swallow!\n",
MyName);
exit(1);
}
s += 7;
/*
* Swallow old 'swallowmodule' command
*/
if (strncasecmp(s, "module", 6) == 0)
{
s += 6;
}
if (b->hangon)
{
free(b->hangon);
}
b->hangon = seekright(&s);
if (!b->hangon)
{
b->hangon = safestrdup("");
}
if (tolower(*s) == 's')
{
b->flags.b_Swallow = 1;
b->flags.b_Hangon = 1;
}
else
{
b->flags.b_Panel = 1;
b->flags.b_Hangon = 1;
}
b->swallow |= 1;
s = trimleft(s);
if (!(b->swallow & b_NoHints))
{
b->hints = (XSizeHints*)mymalloc(sizeof(XSizeHints));
}
if (*s)
{
if (!(buttonSwallow(b) & b_UseOld))
{
SendText(fd, s, 0);
}
b->spawn = safestrdup(s);
}
}
else if (*s)
{
AddButtonAction(b, 0, s);
}
return;
}
Pixel GetColor(char *name)
{
int i;
int n;
int cs;
char *rest;
XColor color;
switch ((i = GetTokenIndex(name, colorset_names, -1, &rest)))
{
case 0:
case 1:
case 2:
case 3:
if (!isdigit(*rest) || (*rest == '0' && *(rest + 1) != 0))
{
/* not a non-negative integer without leading zeros */
fprintf(stderr,
"Invalid colorset number in color '%s'\n",
name);
return 0;
}
sscanf(rest, "%d%n", &cs, &n);
if (*(rest + n) != ']')
{
fprintf(stderr,
"No closing brace after '%d' in color '%s'\n",
cs, name);
return 0;
}
if (*(rest + n + 1) != 0)
{
fprintf(stderr, "Trailing characters after brace in"
" color '%s'\n", name);
return 0;
}
AllocColorset(cs);
switch (i)
{
case 0:
color.pixel = Colorset[cs].fg;
break;
case 1:
color.pixel = Colorset[cs].bg;
break;
case 2:
color.pixel = Colorset[cs].hilite;
break;
case 3:
color.pixel = Colorset[cs].shadow;
break;
}
if (!PictureAllocColor(Pdpy, Pcmap, &color, True))
{
fprintf(stderr, "Cannot allocate color %d from"
" colorset %d\n", i, cs);
return 0;
}
return color.pixel;
default:
break;
}
return GetSimpleColor(name);
}
/*#define DEBUG_PARSER*/
static void ParseButton(button_info **uberb,char *s)
{
button_info *b,*ub=*uberb;
int i,j;
char *t,*o;
b = alloc_button(ub, (ub->c->num_buttons)++);
s = trimleft(s);
if(*s=='(' && s++)
{
char *opts[] =
{
"back",
"fore",
"font",
"title",
"icon",
"frame",
"padding",
"swallow",
"panel",
"action",
"container",
"end",
"nosize",
"size",
"left",
"right",
"center",
"colorset",
NULL
};
s = trimleft(s);
while(*s && *s!=')')
{
Bool is_swallow = False;
if (*s == ',')
{
s++;
s = trimleft(s);
continue;
}
if((*s>='0' && *s<='9') || *s=='+' || *s=='-')
{
char *geom;
int x,y,flags;
unsigned int w,h;
geom=seekright(&s);
if (geom)
{
flags=XParseGeometry(geom, &x, &y, &w, &h);
if(flags&WidthValue)
b->BWidth=w;
if(flags&HeightValue)
b->BHeight=h;
if(flags&XValue)
{
b->BPosX=x;
b->flags|=b_PosFixed;
}
if(flags&YValue)
{
b->BPosY=y;
b->flags|=b_PosFixed;
}
if(flags&XNegative)
b->BPosX=-1-x;
if(flags&YNegative)
b->BPosY=-1-y;
free(geom);
}
s = trimleft(s);
continue;
}
switch(GetTokenIndex(s,opts,-1,&s))
{
case 0: /* Back */
s = trimleft(s);
if(*s=='(' && s++)
if(ParseBack(&s))
b->flags|=b_IconBack;
if(b->flags&b_Back && b->back)
free(b->back);
b->back=seekright(&s);
if(b->back)
{
b->flags|=b_Back;
}
else
b->flags&=~(b_IconBack|b_Back);
break;
case 1: /* Fore */
if(b->flags&b_Fore && b->fore)
free(b->fore);
b->fore=seekright(&s);
if(b->fore)
{
b->flags|=b_Fore;
}
else
b->flags&=~b_Fore;
break;
case 2: /* Font */
if(b->flags&b_Font && b->font_string)
free(b->font_string);
b->font_string = my_get_font(&s);
if(b->font_string)
{
b->flags|=b_Font;
}
else
b->flags&=~b_Font;
break;
/* --------------------------- Title ------------------------- */
case 3: /* Title */
s = trimleft(s);
if(*s=='(' && s++)
{
b->justify=0;
b->justify_mask=0;
ParseTitle(&s,&b->justify,&b->justify_mask);
if(b->justify_mask)
b->flags|=b_Justify;
}
t=seekright(&s);
if(t && *t && (t[0]!='-' || t[1]!=0))
{
if (b->title)
free(b->title);
b->title=t;
#ifdef DEBUG_PARSER
fprintf(stderr,"PARSE: Title \"%s\"\n",b->title);
#endif
b->flags|=b_Title;
}
else
{
fprintf(stderr,"%s: Missing title argument\n",MyName);
if(t)free(t);
}
break;
/* ---------------------------- icon ------------------------- */
case 4: /* Icon */
t=seekright(&s);
if(t && *t && (t[0] != '-' || t[1] != 0))
{
if (b->flags & b_Swallow)
{
fprintf(
stderr,"%s: a button can not have an icon and a swallowed window"
" at the same time. Ignoring icon", MyName);
}
else
{
if (b->icon_file)
free(b->icon_file);
b->icon_file=t;
b->IconWin=None;
b->flags|=b_Icon;
}
}
else
{
fprintf(stderr,"%s: Missing icon argument\n",MyName);
if(t)free(t);
}
break;
/* --------------------------- frame ------------------------- */
case 5: /* Frame */
i=strtol(s,&t,10);
if(t>s)
{
b->flags|=b_Frame;
b->framew=i;
s=t;
}
else
fprintf(stderr,"%s: Illegal frame argument\n",MyName);
break;
/* -------------------------- padding ------------------------ */
case 6: /* Padding */
i=strtol(s,&t,10);
if(t>s)
{
b->xpad=b->ypad=i;
b->flags |= b_Padding;
s=t;
i=strtol(s,&t,10);
if(t>s)
{
b->ypad=i;
s=t;
}
}
else
fprintf(stderr,"%s: Illegal padding argument\n",MyName);
break;
/* -------------------------- swallow ------------------------ */
case 7: /* Swallow */
is_swallow = True;
/* fall through */
case 8: /* Panel */
s = trimleft(s);
if (is_swallow)
{
b->swallow=0;
b->swallow_mask=0;
}
else
{
/* set defaults */
b->swallow = b_Respawn;
b->swallow_mask = b_Respawn;
b->slide_direction = SLIDE_UP;
b->slide_position = SLIDE_POSITION_CENTER;
b->slide_context = SLIDE_CONTEXT_PB;
b->relative_x = 0;
b->relative_y = 0;
b->slide_steps = 12;
b->slide_delay_ms = 5;
}
if(*s=='(' && s++)
{
if (is_swallow)
ParseSwallow(&s, &b->swallow,&b->swallow_mask);
else
ParsePanel(&s, &b->swallow, &b->swallow_mask, &b->slide_direction,
&b->slide_steps, &b->slide_delay_ms, &b->panel_flags,
&b->indicator_size, &b->relative_x, &b->relative_y,
&b->slide_position, &b->slide_context);
}
t=seekright(&s);
o=seekright(&s);
if(t)
{
if (b->hangon)
free(b->hangon);
b->hangon=t;
if (is_swallow)
{
if (b->flags & b_Icon)
{
fprintf(
stderr,"%s: a button can not have an icon and a swallowed "
" window at the same time. Ignoring icon", MyName);
b->flags &= ~ b_Icon;
}
b->flags |= (b_Swallow | b_Hangon);
}
else
{
b->flags |= (b_Panel | b_Hangon);
b->newflags.is_panel = 1;
b->newflags.panel_mapped = 0;
}
b->swallow|=1;
if(!(b->swallow&b_NoHints))
b->hints=(XSizeHints*)mymalloc(sizeof(XSizeHints));
if(o)
{
char *p;
p = expand_action(o, NULL);
if (p)
{
if(!(buttonSwallow(b)&b_UseOld))
SendText(fd,p,0);
if (b->spawn)
free(b->spawn);
b->spawn=o; /* Might be needed if respawning sometime */
free(p);
}
}
}
else
{
fprintf(stderr,"%s: Missing swallow argument\n",MyName);
if(t)
free(t);
if(o)
free(o);
}
break;
/* --------------------------- action ------------------------ */
case 9: /* Action */
s = trimleft(s);
i=0;
if(*s=='(')
{
s++;
if(strncasecmp(s,"mouse",5)!=0)
{
fprintf(stderr,"%s: Couldn't parse action\n",MyName);
}
s+=5;
i=strtol(s,&t,10);
s=t;
while(*s && *s!=')')
s++;
if(*s==')')
s++;
}
{
char *r;
char *u = s;
s = GetQuotedString(s, &t, ",)", NULL, "(", ")");
r = s;
if (t && r > u + 1)
{
/* remove unquoted trailing spaces */
r -= 2;
while (r >= u && isspace(*r))
r--;
r++;
if (isspace(*r))
{
t[strlen(t) - (s - r - 1)] = 0;
}
}
}
if(t)
{
AddButtonAction(b,i,t);
free(t);
}
else
fprintf(stderr,"%s: Missing action argument\n",MyName);
break;
/* -------------------------- container ---------------------- */
case 10: /* Container */
b->flags&=b_Frame|b_Back|b_Fore|b_Padding|b_Action;
MakeContainer(b);
*uberb=b;
s = trimleft(s);
if(*s=='(' && s++)
ParseContainer(&s,b);
break;
case 11: /* End */
*uberb=ub->parent;
ub->c->buttons[--(ub->c->num_buttons)]=NULL;
free(b);
if(!ub->parent)
{
fprintf(stderr,"%s: Unmatched END in config file\n",MyName);
exit(1);
}
return;
case 12: /* NoSize */
b->flags|=b_Size;
b->minx=b->miny=0;
break;
case 13: /* Size */
i=strtol(s,&t,10);
j=strtol(t,&o,10);
if(t>s && o>t)
{
b->minx=i;
b->miny=j;
b->flags|=b_Size;
s=o;
}
else
fprintf(stderr,"%s: Illegal size arguments\n",MyName);
break;
case 14: /* Left */
b->flags |= b_Left;
b->flags &= ~b_Right;
break;
case 15: /* Right */
b->flags |= b_Right;
b->flags &= ~b_Left;
break;
case 16: /* Center */
b->flags &= ~(b_Right|b_Left);
break;
case 17: /* Colorset */
i = strtol(s, &t, 10);
if(t > s)
{
b->colorset = i;
b->flags |= b_Colorset;
s=t;
AllocColorset(i);
}
else
{
b->flags &= ~b_Colorset;
}
break;
default:
t=seekright(&s);
fprintf(stderr,"%s: Illegal button option \"%s\"\n",MyName,
(t)?t:"");
if (t)
free(t);
break;
}
s = trimleft(s);
}
if (s && *s)
{
s++;
s = trimleft(s);
}
}
/* get title and iconname */
if(!(b->flags&b_Title))
{
b->title=seekright(&s);
if(b->title && *b->title && ((b->title)[0]!='-'||(b->title)[1]!=0))
b->flags |= b_Title;
else
if(b->title)free(b->title);
}
else
{
char *temp;
temp = seekright(&s);
if (temp)
free(temp);
}
if(!(b->flags&b_Icon))
{
b->icon_file=seekright(&s);
if(b->icon_file && b->icon_file &&
((b->icon_file)[0]!='-'||(b->icon_file)[1]!=0))
{
b->flags|=b_Icon;
b->IconWin=None;
}
else
if(b->icon_file)free(b->icon_file);
}
else
{
char *temp;
temp = seekright(&s);
if (temp)
free(temp);
}
s = trimleft(s);
/* Swallow hangon command */
if (strncasecmp(s,"swallow",7)==0 || strncasecmp(s,"panel",7)==0)
{
if(b->flags & (b_Swallow | b_Panel))
{
fprintf(stderr,"%s: Illegal with both old and new swallow!\n",
MyName);
exit(1);
}
s+=7;
/*
* Swallow old 'swallowmodule' command
*/
if (strncasecmp(s,"module",6)==0)
{
s+=6;
}
if (b->hangon)
free(b->hangon);
b->hangon=seekright(&s);
if (!b->hangon)
b->hangon = safestrdup("");
if (tolower(*s) == 's')
b->flags |= b_Swallow | b_Hangon;
else
b->flags |= b_Panel | b_Hangon;
b->swallow|=1;
s = trimleft(s);
if(!(b->swallow&b_NoHints))
b->hints=(XSizeHints*)mymalloc(sizeof(XSizeHints));
if(*s)
{
if(!(buttonSwallow(b)&b_UseOld))
SendText(fd,s,0);
b->spawn=safestrdup(s);
}
}
else if(*s)
AddButtonAction(b,0,s);
return;
}
/**
*** ParseSwallow()
*** Parses the options possible to Swallow
**/
static void ParseSwallow(char **ss,byte *flags,byte *mask)
{
char *swallowopts[] =
{
"nohints", "hints",
"nokill","kill",
"noclose", "close",
"respawn","norespawn",
"useold", "noold",
"usetitle", "notitle",
NULL
};
char *t,*s=*ss;
while(*s && *s!=')')
{
s = trimleft(s);
if(*s==',')
s++;
else switch(GetTokenIndex(s,swallowopts,-1,&s))
{
case 0: /* NoHints */
*flags|=b_NoHints;
*mask|=b_NoHints;
break;
case 1: /* Hints */
*flags&=~b_NoHints;
*mask|=b_NoHints;
break;
case 2: /* NoKill */
*flags&=~b_Kill;
*mask|=b_Kill;
break;
case 3: /* Kill */
*flags|=b_Kill;
*mask|=b_Kill;
break;
case 4: /* NoClose */
*flags|=b_NoClose;
*mask|=b_NoClose;
break;
case 5: /* Close */
*flags&=~b_NoClose;
*mask|=b_NoClose;
break;
case 6: /* Respawn */
*flags|=b_Respawn;
*mask|=b_Respawn;
break;
case 7: /* NoRespawn */
*flags&=~b_Respawn;
*mask|=b_Respawn;
break;
case 8: /* UseOld */
*flags|=b_UseOld;
*mask|=b_UseOld;
break;
case 9: /* NoOld */
*flags&=~b_UseOld;
*mask|=b_UseOld;
break;
case 10: /* UseTitle */
*flags|=b_UseTitle;
*mask|=b_UseTitle;
break;
case 11: /* NoTitle */
*flags&=~b_UseTitle;
*mask|=b_UseTitle;
break;
default:
t=seekright(&s);
fprintf(stderr,"%s: Illegal Swallow option \"%s\"\n",MyName,
(t)?t:"");
if (t)
free(t);
}
}
if(*s) s++;
*ss=s;
}
char *expand_action(char *in_action, button_info *b)
{
char *variables[] =
{
"$",
"fg",
"bg",
"left",
"-left",
"right",
"-right",
"top",
"-top",
"bottom",
"-bottom",
"width",
"height",
NULL
};
char *action = NULL;
char *src;
char *dest;
char *string = NULL;
char *rest;
int px;
int py;
int val = 0;
int offset;
int x;
int y;
int f;
int i;
unsigned int w = 0;
unsigned int h = 0;
Window win;
extern int dpw;
extern int dph;
/* create a temporary storage for expanding */
action = (char *)malloc(MAX_MODULE_INPUT_TEXT_LEN);
if (!action)
{
/* could not alloc memory */
return NULL;
}
/* calculate geometry */
if (b)
{
w = buttonWidth(b);
h = buttonHeight(b);
buttonInfo(b, &x, &y, &px, &py, &f);
XTranslateCoordinates(Dpy, MyWindow, Root, x, y, &x, &y, &win);
}
for (src = in_action, dest = action; *src != 0; src++)
{
if (*src != '$')
{
*(dest++) = *src;
}
else
{
char *dest_org = dest;
Bool is_string = False;
Bool is_value = False;
*(dest++) = *(src++);
i = GetTokenIndex(src, variables, -1, &rest);
if (i == -1)
{
src--;
continue;
}
switch (i)
{
case 0: /* $ */
continue;
case 1: /* fg */
string = UberButton->c->fore;
is_string = True;
break;
case 2: /* bg */
string = UberButton->c->back;
is_string = True;
break;
case 3: /* left */
val = x;
is_value = True;
break;
case 4: /* -left */
val = dpw - x - 1;
is_value = True;
break;
case 5: /* right */
val = x + w;
is_value = True;
break;
case 6: /* -right */
val = dpw - x - w - 1;
is_value = True;
break;
case 7: /* top */
val = y;
is_value = True;
break;
case 8: /* -top */
val = dph - y - 1;
is_value = True;
break;
case 9: /* bottom */
val = y + h;
is_value = True;
break;
case 10: /* -bottom */
val = dph - y - h - 1;
is_value = True;
break;
case 11: /* width */
val = w;
is_value = True;
break;
case 12: /* height */
val = h;
is_value = True;
break;
default: /* unknown */
src--;
continue;
} /* switch */
dest = dest_org;
src = --rest;
if (is_value)
{
if (MAX_MODULE_INPUT_TEXT_LEN - (dest - action) <= 16)
{
/* out of space */
free(action);
return NULL;
}
/* print the number into the string */
sprintf(dest, "%d%n", val, &offset);
dest += offset;
}
else if (is_string)
{
if (MAX_MODULE_INPUT_TEXT_LEN - (dest - action) <= strlen(string))
{
/* out of space */
free(action);
return NULL;
}
/* print the colour name into the string */
if (string)
{
sprintf(dest, "%s%n", string, &offset);
dest += offset;
}
}
} /* if */
} /* for */
*dest = 0;
return action;
}
/**
*** ParsePanel()
*** Parses the options possible to Panel
**/
static void ParsePanel(
char **ss, unsigned int *flags, unsigned int *mask, char *direction,
int *steps, int *delay, panel_flags_type *panel_flags,
int *indicator_size, int *rela_x, int *rela_y, char *position,
char *context)
{
char *swallowopts[] =
{
"nohints", "hints",
"nokill", "kill",
"noclose", "close",
"respawn", "norespawn",
"useold", "noold",
"usetitle", "notitle",
"up", "down", "left", "right",
"steps",
"delay",
"smooth",
"noborder",
"indicator",
"position",
NULL
};
char *positionopts[] =
{
"button", "module", "root", "center", "left", "top", "right",
"bottom", "noplr", "noptb", "mlr", "mtb", NULL
};
char *t, *s = *ss;
int n;
while (*s && *s != ')')
{
s = trimleft(s);
if (*s == ',')
{
s++;
continue;
}
switch (GetTokenIndex(s, swallowopts, -1, &s))
{
case 0: /* NoHints */
*flags |= b_NoHints;
*mask |= b_NoHints;
break;
case 1: /* Hints */
*flags &= ~b_NoHints;
*mask |= b_NoHints;
break;
case 2: /* NoKill */
*flags &= ~b_Kill;
*mask |= b_Kill;
break;
case 3: /* Kill */
*flags |= b_Kill;
*mask |= b_Kill;
break;
case 4: /* NoClose */
*flags |= b_NoClose;
*mask |= b_NoClose;
break;
case 5: /* Close */
*flags &= ~b_NoClose;
*mask |= b_NoClose;
break;
case 6: /* Respawn */
*flags |= b_Respawn;
*mask |= b_Respawn;
break;
case 7: /* NoRespawn */
*flags &= ~b_Respawn;
*mask |= b_Respawn;
break;
case 8: /* UseOld */
*flags |= b_UseOld;
*mask |= b_UseOld;
break;
case 9: /* NoOld */
*flags &= ~b_UseOld;
*mask |= b_UseOld;
break;
case 10: /* UseTitle */
*flags |= b_UseTitle;
*mask |= b_UseTitle;
break;
case 11: /* NoTitle */
*flags &= ~b_UseTitle;
*mask |= b_UseTitle;
break;
case 12: /* up */
*direction = SLIDE_UP;
break;
case 13: /* down */
*direction = SLIDE_DOWN;
break;
case 14: /* left */
*direction = SLIDE_LEFT;
break;
case 15: /* right */
*direction = SLIDE_RIGHT;
break;
case 16: /* steps */
sscanf(s, "%d%n", steps, &n);
s += n;
break;
case 17: /* delay */
sscanf(s, "%d%n", delay, &n);
s += n;
break;
case 18: /* smooth */
(*panel_flags).smooth = 1;
break;
case 19: /* noborder */
(*panel_flags).ignore_lrborder = 1;
(*panel_flags).ignore_tbborder = 1;
break;
case 20: /* indicator */
n = 0;
(*panel_flags).panel_indicator = 1;
*indicator_size = 0;
sscanf(s, "%d%n", indicator_size, &n);
if (*indicator_size < 0 || *indicator_size > 100)
{
*indicator_size = 0;
}
s += n;
break;
case 21: /* position */
n = 0;
*rela_x = *rela_y = 0;
while (*s != ',' && *s != ')' && *s)
{
s = trimleft(s);
/* get x and y offset */
if (isdigit(*s) || *s == '+' || *s == '-')
{
sscanf(s, "%i%n", rela_x, &n);
s += n;
if (*s == 'p' || *s == 'P')
{
(*panel_flags).relative_x_pixel = 1;
s++;
}
n = 0;
s = trimleft(s);
sscanf(s, "%i%n", rela_y, &n);
s += n;
if (*s == 'p' || *s == 'P')
{
(*panel_flags).relative_y_pixel = 1;
s++;
}
s = trimleft(s);
}
switch (GetTokenIndex(s, positionopts, -1, &s))
{
case 0: /* button */
*context = SLIDE_CONTEXT_PB;
break;
case 1: /* module */
*context = SLIDE_CONTEXT_MODULE;
break;
case 2: /* root */
*context = SLIDE_CONTEXT_ROOT;
break;
case 3: /* center */
*position = SLIDE_POSITION_CENTER;
break;
case 4: /* left */
*position = SLIDE_POSITION_LEFT_TOP;
break;
case 5: /* top */
*position = SLIDE_POSITION_LEFT_TOP;
break;
case 6: /* right */
*position = SLIDE_POSITION_RIGHT_BOTTOM;
break;
case 7: /* bottom */
*position = SLIDE_POSITION_RIGHT_BOTTOM;
break;
case 8: /* noplr */
(*panel_flags).ignore_lrborder = 1;
break;
case 9: /* noptb */
(*panel_flags).ignore_tbborder = 1;
break;
case 10: /* mlr */
(*panel_flags).buttons_lrborder = 1;
break;
case 11: /* mtb */
(*panel_flags).buttons_tbborder = 1;
break;
default:
t = seekright(&s);
s--;
if (t)
{
fprintf(stderr,
"%s: Illegal Panel "
"position option %s\n",
MyName, (t) ? t : "");
free(t);
}
}
}
break;
default:
t = seekright(&s);
fprintf(stderr,
"%s: Illegal Panel option \"%s\"\n", MyName,
(t) ? t : "");
if (t)
{
free(t);
}
}
}
if (*s)
{
s++;
}
*ss = s;
}
/**
*** ParseContainer()
*** Parses the options possible to Container
**/
static void ParseContainer(char **ss,button_info *b)
{
char *conts[] =
{
"columns",
"rows",
"font",
"frame",
"back",
"fore",
"padding",
"title",
"swallow",
"nosize",
"size",
"boxsize",
"colorset",
NULL
};
char *t, *o, *s = *ss;
int i, j;
while (*s && *s != ')')
{
s = trimleft(s);
if (*s == ',')
{
s++;
continue;
}
switch (GetTokenIndex(s, conts, -1, &s))
{
case 0: /* Columns */
b->c->num_columns = max(1, strtol(s, &t, 10));
s = t;
break;
case 1: /* Rows */
b->c->num_rows = max(1, strtol(s, &t, 10));
s = t;
break;
case 2: /* Font */
if (b->c->font_string)
{
free(b->c->font_string);
}
b->c->font_string = my_get_font(&s);
b->c->flags.b_Font = (b->c->font_string ? 1 : 0);
break;
case 3: /* Frame */
b->c->framew = strtol(s, &t, 10);
b->c->flags.b_Frame = 1;
s = t;
break;
case 4: /* Back */
s = trimleft(s);
if (*s == '(' && s++ && ParseBack(&s))
{
b->c->flags.b_IconBack = 1;
}
if (b->c->back)
{
free(b->c->back);
}
b->c->back = seekright(&s);
if (b->c->back)
{
b->c->flags.b_Back = 1;
}
else
{
b->c->flags.b_IconBack = 0;
b->c->flags.b_Back = 0;
}
break;
case 5: /* Fore */
if (b->c->fore) free(b->c->fore);
b->c->fore = seekright(&s);
b->c->flags.b_Fore = (b->c->fore ? 1 : 0);
break;
case 6: /* Padding */
i = strtol(s, &t, 10);
if (t > s)
{
b->c->xpad = b->c->ypad = i;
s = t;
i = strtol(s, &t, 10);
if (t > s)
{
b->c->ypad = i;
s = t;
}
b->c->flags.b_Padding = 1;
}
else
fprintf(stderr,"%s: Illegal padding argument\n",MyName);
break;
case 7: /* Title - flags */
s = trimleft(s);
if (*s == '(' && s++)
{
b->c->justify = 0;
b->c->justify_mask = 0;
ParseTitle(&s, &b->c->justify, &b->c->justify_mask);
if (b->c->justify_mask)
{
b->c->flags.b_Justify = 1;
}
}
else
{
char *temp;
fprintf(stderr,
"%s: Illegal title in container options\n",
MyName);
temp = seekright(&s);
if (temp)
{
free(temp);
}
}
break;
case 8: /* Swallow - flags */
{
Bool failed = False;
s = trimleft(s);
if (b->c->flags.b_Swallow || b->c->flags.b_Panel)
{
fprintf(stderr, "%s: Multiple Swallow or Panel options are not"
" allowed in a single button", MyName);
failed = True;
}
else if (*s == '(' && s++)
{
b->c->swallow = 0;
b->c->swallow_mask = 0;
ParseSwallow(&s, &b->c->swallow, &b->c->swallow_mask, b);
if (b->c->swallow_mask)
{
b->c->flags.b_Swallow = 1;
}
}
else
{
fprintf(stderr,
"%s: Illegal swallow or panel in container options\n",
MyName);
failed = True;
}
if (failed)
{
char *temp;
temp = seekright(&s);
if (temp)
free(temp);
}
}
break;
case 9: /* NoSize */
b->c->flags.b_Size = 1;
b->c->minx = b->c->miny = 0;
break;
case 10: /* Size */
i = strtol(s, &t, 10);
j = strtol(t, &o, 10);
if (t > s && o > t)
{
b->c->minx = i;
b->c->miny = j;
b->c->flags.b_Size = 1;
s = o;
}
else
fprintf(stderr,"%s: Illegal size arguments\n",MyName);
break;
case 11: /* BoxSize */
ParseBoxSize(&s, &b->c->flags);
break;
case 12: /* Colorset */
i = strtol(s, &t, 10);
if (t > s)
{
b->c->colorset = i;
b->c->flags.b_Colorset = 1;
AllocColorset(i);
s = t;
}
else
{
b->c->flags.b_Colorset = 0;
}
break;
default:
t = seekright(&s);
fprintf(stderr,"%s: Illegal container option \"%s\"\n",MyName, (t)?t:"");
if (t)
free(t);
}
}
if (*s)
{
s++;
}
*ss = s;
}
void RTF_DoBodyControl (FILE * f, char* control,char* arg)
{
short style;
if (gobble) return;
switch (GetTokenIndex(control))
{
case t_stylesheet:
gobble = TRUE; /*perform no output, ignore commands 'til level-1*/
skip_to_level = level-1;
RTF_ParseStyle( f );
break;
case t_fonttbl: /*skip all of these and their contents!*/
case t_colortbl:
case t_info:
gobble = TRUE; /*perform no output, ignore commands 'til level-1*/
skip_to_level = level-1;
break;
case t_pict:
gobble = TRUE; /*perform no output, ignore commands 'til level-1*/
if(skip_to_level>=level || skip_to_level==-1)
skip_to_level = level-1;
break;
case t_s: /*Style*/
if (!curr_heading)
{
style = RTF_MapStyle (arg);
if(style)
{
curr_heading = s_h0 + style;
RTF_PutStr(styles[curr_heading][0]);
ignore_styles = TRUE;
}
}
break;
case t_b: /*Bold*/
RTF_SetStyle(&curr_style,s_bold);
break;
case t_ulw:
case t_uld:
case t_uldb:
case t_ul: /*Underline, maps to "emphasis" HTML style*/
RTF_SetStyle(&curr_style,s_underline);
break;
case t_i: /*Italic*/
RTF_SetStyle(&curr_style,s_italic);
break;
case t_v: /* Hidden*/
RTF_SetStyle(&curr_style,s_hidden);
break;
case t_par: /*Paragraph*/
if (curr_heading!=s_plain) {
RTF_PutStr(styles[curr_heading][1]);
curr_heading = s_plain;
} else {
RTF_PutStr(styles[s_para][0]);
}
ignore_styles = FALSE;
break;
case t_plain: /*reset inline styles*/
RTF_PlainStyle(&curr_style);
break;
case t_cell:
case t_tab:
RTF_PutChar(' ');
break;
case t_endash:
case t_emdash:
RTF_PutChar('-');
break;
case t_line:
case t_row:
RTF_PutStr(styles[s_br][0]);
break;
case t_bullet:
RTF_PutChar('\xb7');
break;
case t_start:
case t_end:
break;
case t_rquote:
//RTF_PutStr("’");
RTF_PutStr("'");
break;
}
}
/* Parse 'goodies' specific resources */
Bool GoodiesParseConfig(char *tline)
{
char *rest;
char *option;
int i;
option = tline + module->namelen+1;
i = GetTokenIndex(option, goodyopts, -1, &rest);
while (*rest && *rest != '\n' && isspace(*rest))
rest++;
switch(i)
{
case 0: /* BellVolume */
BellVolume = atoi(rest);
break;
case 1: /* Mailbox */
if (strcasecmp(rest, "None") == 0)
{
has_mailpath = False;
}
else
{
int len;
UpdateString(&mailpath, rest);
len = strlen(mailpath);
if (len > 0 && mailpath[len-1] == '\n')
mailpath[len-1] = 0;
has_mailpath = True;
}
do_check_mail = (has_mailpath && (mailcheck_interval > 0));
break;
case 2: /* Mailcheck */
mailcheck_interval = MAILCHECK_DEFAULT;
sscanf(rest, "%d", &mailcheck_interval);
do_check_mail = (has_mailpath && (mailcheck_interval > 0));
break;
case 3: /* ClockFormat */
UpdateString(&clockfmt, rest);
do_display_clock = True;
if (clockfmt && clockfmt[0] == '\0' && datefmt && datefmt[0] == '\0')
{
do_display_clock = False;
}
break;
case 4: /* StatusFont */
CopyStringWithQuotes(&statusfont_string, rest);
break;
case 5: /* TipsFore */
CopyString(&TipsFore, rest);
tipscolorset = -1;
break;
case 6: /* TipsBack */
CopyString(&TipsBack, rest);
tipscolorset = -1;
break;
case 7: /* TipsColorset */
tipscolorset = -1;
tipscolorset = atoi(rest);
AllocColorset(tipscolorset);
break;
case 8: /* MailCommand */
CopyString(&MailCmd, rest);
break;
case 9: /* IgnoreOldMail */
IgnoreOldMail = True;
break;
case 10: /* ShowTips */
ShowTips = True;
break;
case 11: /* DateFormat */
UpdateString(&datefmt, rest);
do_display_clock = True;
if (clockfmt && clockfmt[0] == '\0' && datefmt && datefmt[0] == '\0')
{
do_display_clock = False;
}
break;
case 12: /* MailDir */
using_MailDir = True;
break;
default:
/* unknown option */
return False;
} /* switch */
return True;
}
void parse_message_line(char *line)
{
char *rest;
int action = -1;
button_info *b;
char *act;
char *buttonn;
int mousebutton;
silent = False;
do
{
action = GetTokenIndex(line, actions, -1, &rest);
if (action == -1)
{
show_error("Message not understood: %s", line);
return;
}
if (action == 0)
{
silent = True;
break;
}
} while (action == 0);
/* If silent was given (to surpress erros from parsing commands, then
* retokenise the rest of the line, so that token matching for the
* actual command is possible.
*/
if (silent == True) {
line = PeekToken(line, &rest);
action = GetTokenIndex(rest, actions, -1, &rest);
}
/* find out which button */
b = parse_button_id(&rest);
if (!b || !rest)
{
return;
}
switch (action)
{
case 1:
/* ChangeButton */
/* The dimensions of individual buttons (& the overall size of
* the FvwmButtons window) is based on the initial
* configuration for the module. In some configurations,
* dynamically adding/changing a title/icon may mean it no
* longer fits on a button. Currently, there are no checks for
* this occurance. */
while (rest && rest[0] != '\0')
{
char *option_pair;
int option, i;
char *value0, *value;
FvwmPicture *icon;
/* parse option and value and give diagnostics */
rest = GetQuotedString(
rest, &option_pair, ",", NULL, NULL, NULL);
while (isspace(*rest))
{
rest++;
}
if (!option_pair)
continue;
option = GetTokenIndex(
option_pair, button_options, -1, &value0);
if (option < 0)
{
show_error(
"Unsupported button option line '%s'\n",
option_pair);
free(option_pair);
continue;
}
GetNextToken(value0, &value);
free(option_pair);
if (value == NULL)
{
show_error(
"No title/icon to change specified.\n");
continue;
}
switch (option)
{
case 0:
/* Title */
if (b->flags.b_Title)
free(b->title);
b->flags.b_Title = 1;
b->title = value;
value = NULL;
break;
case 2:
/* ActiveTitle */
if (b->flags.b_ActiveTitle)
free(b->activeTitle);
b->flags.b_ActiveTitle = 1;
b->title = value;
value = NULL;
break;
case 4:
/* PressTitle */
if (b->flags.b_PressTitle)
free(b->pressTitle);
b->flags.b_PressTitle = 1;
b->title = value;
value = NULL;
break;
case 6:
/* Colorset */
i = atoi(value);
b->colorset = i;
b->flags.b_Colorset = 1;
AllocColorset(i);
break;
default:
if (
LoadIconFile(
value, &icon, b->colorset) == 0)
{
show_error(
"Cannot load icon \"%s\"\n",
value);
}
else
{
switch (option)
{
case 1: /* Icon */
if (b->flags.b_Icon)
{
free(b->icon_file);
PDestroyFvwmPicture(
Dpy, b->icon);
}
b->flags.b_Icon = 1;
b->icon_file = value;
value = NULL;
b->icon = icon;
break;
case 3: /* ActiveIcon */
if (b->flags.b_ActiveIcon)
{
free(b->active_icon_file);
PDestroyFvwmPicture(
Dpy,
b->activeicon);
}
b->flags.b_ActiveIcon = 1;
b->active_icon_file = value;
value = NULL;
b->activeicon = icon;
break;
case 5: /* PressIcon */
if (b->flags.b_PressIcon)
{
free(b->press_icon_file);
PDestroyFvwmPicture(
Dpy,
b->pressicon);
}
b->flags.b_PressIcon = 1;
b->press_icon_file = value;
value = NULL;
b->pressicon = icon;
break;
}
}
break;
}
if (value)
{
free(value);
}
}
RedrawButton(b, DRAW_FORCE, NULL);
if (UberButton->c->flags.b_TransBack)
{
SetTransparentBackground(UberButton, Width, Height);
}
break;
case 2:
/* ExpandButtonVars */
line = expand_button_vars(b, rest);
if (line)
{
SendText(fd, line, 0);
free(line);
}
break;
case 3:
/* PressButton */
rest = GetQuotedString(rest, &buttonn, "", NULL, NULL, NULL);
if (buttonn)
{
mousebutton = atoi(buttonn);
free(buttonn);
if (
mousebutton <= 0 ||
mousebutton > NUMBER_OF_EXTENDED_MOUSE_BUTTONS)
{
mousebutton = 1;
}
}
else
{
mousebutton = 1;
}
CurrentButton = b;
act = GetButtonAction(b, mousebutton);
ButtonPressProcess(b, &act);
if (act)
{
free(act);
}
CurrentButton = NULL;
break;
}
return;
}
/* translate a colorset spec into a colorset structure */
void parse_colorset(int n, char *line)
{
int i;
int w;
int h;
int tmp;
int percent;
colorset_t *cs;
char *optstring;
char *args;
char *option;
char *tmp_str;
char *fg = NULL;
char *bg = NULL;
char *hi = NULL;
char *sh = NULL;
char *fgsh = NULL;
char *tint = NULL;
char *fg_tint = NULL;
char *bg_tint = NULL;
char *icon_tint = NULL;
Bool have_pixels_changed = False;
Bool has_icon_pixels_changed = False;
Bool has_fg_changed = False;
Bool has_bg_changed = False;
Bool has_sh_changed = False;
Bool has_hi_changed = False;
Bool has_fgsh_changed = False;
Bool has_fg_alpha_changed = False;
Bool has_tint_changed = False;
Bool has_fg_tint_changed = False;
Bool has_bg_tint_changed = False;
Bool has_icon_tint_changed = False;
Bool has_pixmap_changed = False;
Bool has_shape_changed = False;
Bool has_image_alpha_changed = False;
Bool pixmap_is_a_bitmap = False;
Bool do_reload_pixmap = False;
Bool is_server_grabbed = False;
XColor color;
XGCValues xgcv;
static char *name = "parse_colorset";
Window win = Scr.NoFocusWin;
static GC gc = None;
/* initialize statics */
if (gc == None)
{
gc = fvwmlib_XCreateGC(dpy, win, 0, &xgcv);
}
/* make sure it exists and has sensible contents */
alloc_colorset(n);
cs = &Colorset[n];
/*** Parse the options ***/
while (line && *line)
{
/* Read next option specification delimited by a comma or \0.
*/
line = GetQuotedString(
line, &optstring, ",", NULL, NULL, NULL);
if (!optstring)
break;
args = GetNextToken(optstring, &option);
if (!option)
{
free(optstring);
break;
}
switch((i = GetTokenIndex(option, csetopts, 0, NULL)))
{
case 0: /* Foreground */
case 1: /* Fore */
case 2: /* fg */
get_simple_color(
args, &fg, cs, FG_SUPPLIED, FG_CONTRAST,
"contrast");
has_fg_changed = True;
break;
case 3: /* Background */
case 4: /* Back */
case 5: /* bg */
get_simple_color(
args, &bg, cs, BG_SUPPLIED, BG_AVERAGE,
"average");
has_bg_changed = True;
break;
case 6: /* Hilight */
case 7: /* Hilite */
case 8: /* hi */
get_simple_color(args, &hi, cs, HI_SUPPLIED, 0, NULL);
has_hi_changed = True;
break;
case 9: /* Shadow */
case 10: /* Shade */
case 11: /* sh */
get_simple_color(args, &sh, cs, SH_SUPPLIED, 0, NULL);
has_sh_changed = True;
break;
case 12: /* fgsh */
get_simple_color(
args, &fgsh, cs, FGSH_SUPPLIED, 0,NULL);
has_fgsh_changed = True;
break;
case 13: /* fg_alpha */
case 14: /* fgAlpha */
if (GetIntegerArguments(args, NULL, &tmp, 1))
{
if (tmp > 100)
tmp = 100;
else if (tmp < 0)
tmp = 0;
}
else
{
tmp = 100;
}
if (tmp != cs->fg_alpha_percent)
{
cs->fg_alpha_percent = tmp;
has_fg_alpha_changed = True;
}
break;
case 15: /* TiledPixmap */
case 16: /* Pixmap */
case 17: /* AspectPixmap */
has_pixmap_changed = True;
free_colorset_background(cs, True);
tmp_str = PeekToken(args, &args);
if (tmp_str)
{
CopyString(&cs->pixmap_args, tmp_str);
do_reload_pixmap = True;
cs->gradient_type = 0;
/* set the flags */
if (csetopts[i][0] == 'T')
{
cs->pixmap_type = PIXMAP_TILED;
}
else if (csetopts[i][0] == 'A')
{
cs->pixmap_type = PIXMAP_STRETCH_ASPECT;
}
else
{
cs->pixmap_type = PIXMAP_STRETCH;
}
}
/* the pixmap is build later */
break;
case 18: /* Shape */
case 19: /* TiledShape */
case 20: /* AspectShape */
parse_shape(win, cs, i, args, &has_shape_changed);
break;
case 21: /* Plain */
has_pixmap_changed = True;
free_colorset_background(cs, True);
break;
case 22: /* NoShape */
has_shape_changed = True;
if (cs->shape_mask)
{
add_to_junk(cs->shape_mask);
cs->shape_mask = None;
}
break;
case 23: /* Transparent */
/* This is only allowable when the root depth == fvwm
* visual depth otherwise bad match errors happen,
* it may be even more restrictive but my tests (on
* exceed 6.2) show that only == depth is necessary */
if (Pdepth != DefaultDepth(dpy, (DefaultScreen(dpy))))
{
fvwm_msg(
ERR, name, "can't do Transparent "
"when root_depth!=fvwm_depth");
break;
}
has_pixmap_changed = True;
free_colorset_background(cs, True);
cs->pixmap = ParentRelative;
cs->pixmap_type = PIXMAP_STRETCH;
break;
case 24: /* RootTransparent */
if (Pdepth != DefaultDepth(dpy, (DefaultScreen(dpy))))
{
fvwm_msg(
ERR, name, "can't do RootTransparent "
"when root_depth!=fvwm_depth");
break;
}
free_colorset_background(cs, True);
has_pixmap_changed = True;
cs->pixmap_type = PIXMAP_ROOT_PIXMAP_PURE;
do_reload_pixmap = True;
tmp_str = PeekToken(args, &args);
if (StrEquals(tmp_str, "buffer"))
{
cs->allows_buffered_transparency = True;
}
else
{
cs->allows_buffered_transparency = False;
}
cs->is_maybe_root_transparent = True;
break;
case 25: /* Tint */
case 26: /* PixmapTint */
case 27: /* ImageTint */
case 28: /* TintMask */
parse_simple_tint(
cs, args, &tint, TINT_SUPPLIED,
&has_tint_changed, &percent, "tint");
if (has_tint_changed)
{
cs->tint_percent = percent;
}
break;
case 29: /* NoTint */
has_tint_changed = True;
cs->tint_percent = 0;
cs->color_flags &= ~TINT_SUPPLIED;
break;
case 30: /* fgTint */
parse_simple_tint(
cs, args, &fg_tint, FG_TINT_SUPPLIED,
&has_fg_tint_changed, &percent, "fgTint");
if (has_fg_tint_changed)
{
cs->fg_tint_percent = percent;
}
break;
case 31: /* bgTint */
parse_simple_tint(
cs, args, &bg_tint, BG_TINT_SUPPLIED,
&has_bg_tint_changed, &percent, "bgTint");
if (has_bg_tint_changed)
{
cs->bg_tint_percent = percent;
}
break;
case 32: /* dither */
if (cs->pixmap_args || cs->gradient_args)
{
has_pixmap_changed = True;
do_reload_pixmap = True;
}
cs->dither = True;
break;
case 33: /* nodither */
if (cs->pixmap_args || cs->gradient_args)
{
has_pixmap_changed = True;
do_reload_pixmap = True;
}
cs->dither = False;
break;
case 34: /* Alpha */
case 35: /* PixmapAlpha */
case 36: /* ImageAlpha */
if (GetIntegerArguments(args, NULL, &tmp, 1))
{
if (tmp > 100)
tmp = 100;
else if (tmp < 0)
tmp = 0;
}
else
{
tmp = 100;
}
if (tmp != cs->image_alpha_percent)
{
has_image_alpha_changed = True;
cs->image_alpha_percent = tmp;
}
break;
/* dither icon is not dynamic (yet) maybe a bad opt: default
* to False ? */
case 37: /* ditherIcon */
cs->do_dither_icon = True;
break;
case 38: /* DoNotDitherIcon */
cs->do_dither_icon = False;
break;
case 39: /* IconTint */
parse_simple_tint(
cs, args, &icon_tint, ICON_TINT_SUPPLIED,
&has_icon_tint_changed, &percent, "IconTint");
if (has_icon_tint_changed)
{
cs->icon_tint_percent = percent;
has_icon_pixels_changed = True;
}
break;
case 40: /* NoIconTint */
has_icon_tint_changed = True;
if (cs->icon_tint_percent != 0)
{
has_icon_pixels_changed = True;
}
cs->icon_tint_percent = 0;
break;
case 41: /* IconAlpha */
if (GetIntegerArguments(args, NULL, &tmp, 1))
{
if (tmp > 100)
tmp = 100;
else if (tmp < 0)
tmp = 0;
}
else
{
tmp = 100;
}
if (tmp != cs->icon_alpha_percent)
{
has_icon_pixels_changed = True;
cs->icon_alpha_percent = tmp;
}
break;
default:
/* test for ?Gradient */
if (option[0] && StrEquals(&option[1], "Gradient"))
{
cs->gradient_type = toupper(option[0]);
if (!IsGradientTypeSupported(cs->gradient_type))
break;
has_pixmap_changed = True;
free_colorset_background(cs, True);
CopyString(&cs->gradient_args, args);
do_reload_pixmap = True;
if (cs->gradient_type == V_GRADIENT)
{
cs->pixmap_type = PIXMAP_STRETCH_Y;
}
else if (cs->gradient_type == H_GRADIENT)
cs->pixmap_type = PIXMAP_STRETCH_X;
else
cs->pixmap_type = PIXMAP_STRETCH;
}
else
{
fvwm_msg(
WARN, name, "bad colorset pixmap "
"specifier %s %s", option, line);
}
break;
} /* switch */
if (option)
{
free(option);
option = NULL;
}
free(optstring);
optstring = NULL;
} /* while (line && *line) */
/*
* ---------- change the "pixmap" tint colour ----------
*/
if (has_tint_changed)
{
/* user specified colour */
if (tint != NULL)
{
Pixel old_tint = cs->tint;
PictureFreeColors(dpy, Pcmap, &cs->tint, 1, 0, True);
cs->tint = GetColor(tint);
if (old_tint != cs->tint)
{
have_pixels_changed = True;
}
}
else if (tint == NULL)
{
/* default */
Pixel old_tint = cs->tint;
PictureFreeColors(dpy, Pcmap, &cs->tint, 1, 0, True);
cs->tint = GetColor(black);
if (old_tint != cs->tint)
{
have_pixels_changed = True;
}
}
}
/*
* reload the gradient if the tint or the alpha have changed.
* Do this too if we need to recompute the bg average and the
* gradient is tinted (perforemence issue).
*/
if ((has_tint_changed || has_image_alpha_changed ||
(has_bg_changed && (cs->color_flags & BG_AVERAGE) &&
cs->tint_percent > 0)) && cs->gradient_args)
{
do_reload_pixmap = True;
}
/*
* reset the pixmap if the tint or the alpha has changed
*/
if (!do_reload_pixmap &&
(has_tint_changed || has_image_alpha_changed ||
(has_bg_changed && cs->alpha_pixmap != None)))
{
if (cs->pixmap_type == PIXMAP_ROOT_PIXMAP_PURE ||
cs->pixmap_type == PIXMAP_ROOT_PIXMAP_TRAN)
{
do_reload_pixmap = True;
}
else if (cs->picture != NULL && cs->pixmap)
{
XSetClipMask(dpy, gc, cs->picture->mask);
reset_cs_pixmap(cs, gc);
XSetClipMask(dpy, gc, None);
has_pixmap_changed = True;
}
}
/*
* (re)build the pixmap or the gradient
*/
if (do_reload_pixmap)
{
free_colorset_background(cs, False);
has_pixmap_changed = True;
if (cs->pixmap_type == PIXMAP_ROOT_PIXMAP_PURE ||
cs->pixmap_type == PIXMAP_ROOT_PIXMAP_TRAN)
{
cs->pixmap_type = 0;
if (root_pic.pixmap)
{
cs->pixmap = root_pic.pixmap;
cs->width = root_pic.width;
cs->height = root_pic.height;
cs->pixmap_type = PIXMAP_ROOT_PIXMAP_PURE;
#if 0
fprintf(stderr,"Cset %i LoadRoot 0x%lx\n",
n, cs->pixmap);
#endif
}
}
else if (cs->pixmap_args)
{
parse_pixmap(win, gc, cs, &pixmap_is_a_bitmap);
}
else if (cs->gradient_args)
{
cs->pixmap = CreateGradientPixmapFromString(
dpy, win, gc, cs->gradient_type,
cs->gradient_args, &w, &h, &cs->pixels,
&cs->nalloc_pixels, cs->dither);
cs->width = w;
cs->height = h;
}
has_pixmap_changed = True;
}
if (cs->picture != NULL && cs->picture->depth != Pdepth)
{
pixmap_is_a_bitmap = True;
}
/*
* ---------- change the background colour ----------
*/
if (has_bg_changed ||
(has_pixmap_changed && (cs->color_flags & BG_AVERAGE) &&
cs->pixmap != None &&
cs->pixmap != ParentRelative &&
!pixmap_is_a_bitmap))
{
Bool do_set_default_background = False;
Pixmap average_pix = None;
if (cs->color_flags & BG_AVERAGE)
{
if (cs->picture != NULL && cs->picture->picture != None)
{
average_pix = cs->picture->picture;
}
else if (cs->pixmap != ParentRelative)
{
average_pix = cs->pixmap;
}
if (average_pix == root_pic.pixmap)
{
int w;
int h;
XID dummy;
MyXGrabServer(dpy);
is_server_grabbed = True;
if (!XGetGeometry(
dpy, average_pix, &dummy,
(int *)&dummy, (int *)&dummy,
(unsigned int *)&w, (unsigned int *)&h,
(unsigned int *)&dummy,
(unsigned int *)&dummy))
{
average_pix = None;
}
else
{
if (w != cs->width || h != cs->height)
{
average_pix = None;
}
}
if (average_pix == None)
{
MyXUngrabServer(dpy);
is_server_grabbed = False;
}
}
}
/* note: no average for bitmap */
if ((cs->color_flags & BG_AVERAGE) && average_pix)
{
/* calculate average background color */
XColor *colors;
XImage *image;
XImage *mask_image = None;
unsigned int i, j, k = 0;
unsigned long red = 0, blue = 0, green = 0;
unsigned long tred, tblue, tgreen;
double dred = 0.0, dblue = 0.0, dgreen = 0.0;
has_bg_changed = True;
/* create an array to store all the pixmap colors in */
/* Note: this may allocate a lot of memory:
* cs->width * cs->height * 12 and then the rest of the
* procedure can take a lot of times */
colors = (XColor *)safemalloc(
cs->width * cs->height * sizeof(XColor));
/* get the pixmap and mask into an image */
image = XGetImage(
dpy, average_pix, 0, 0, cs->width, cs->height,
AllPlanes, ZPixmap);
if (cs->mask != None)
{
mask_image = XGetImage(
dpy, cs->mask, 0, 0, cs->width,
cs->height, AllPlanes, ZPixmap);
}
if (is_server_grabbed == True)
{
MyXUngrabServer(dpy);
}
if (image != None && mask_image != None)
{
/* only fetch the pixels that are not masked
* out */
for (i = 0; i < cs->width; i++)
{
for (j = 0; j < cs->height; j++)
{
if (
cs->mask == None ||
XGetPixel(
mask_image, i,
j) == 0)
{
colors[k++].pixel =
XGetPixel(
image,
i, j);
}
}
}
}
if (image != None)
{
XDestroyImage(image);
}
if (mask_image != None)
{
XDestroyImage(mask_image);
}
if (k == 0)
{
do_set_default_background = True;
}
else
{
/* look them all up, XQueryColors() can't
* handle more than 256 */
for (i = 0; i < k; i += 256)
{
XQueryColors(
dpy, Pcmap, &colors[i],
min(k - i, 256));
}
/* calculate average, add overflows in a double
* .red is short, red is long */
for (i = 0; i < k; i++)
{
tred = red;
red += colors[i].red;
if (red < tred)
{
dred += (double)tred;
red = colors[i].red;
}
tgreen = green;
green += colors[i].green;
if (green < tgreen)
{
dgreen += (double)tgreen;
green = colors[i].green;
}
tblue = blue;
blue += colors[i].blue;
if (blue < tblue)
{
dblue += (double)tblue;
blue = colors[i].blue;
}
}
dred += red;
dgreen += green;
dblue += blue;
/* get it */
color.red = dred / k;
color.green = dgreen / k;
color.blue = dblue / k;
{
Pixel old_bg = cs->bg;
PictureFreeColors(
dpy, Pcmap, &cs->bg, 1, 0,
True);
PictureAllocColor(
dpy, Pcmap, &color, True);
cs->bg = color.pixel;
if (old_bg != cs->bg)
{
have_pixels_changed = True;
}
}
}
free(colors);
} /* average */
else if ((cs->color_flags & BG_SUPPLIED) && bg != NULL)
{
/* user specified colour */
Pixel old_bg = cs->bg;
PictureFreeColors(dpy, Pcmap, &cs->bg, 1, 0, True);
cs->bg = GetColor(bg);
if (old_bg != cs->bg)
{
have_pixels_changed = True;
}
} /* user specified */
else if (bg == NULL && has_bg_changed)
{
/* default */
do_set_default_background = True;
} /* default */
if (do_set_default_background)
{
Pixel old_bg = cs->bg;
PictureFreeColors(dpy, Pcmap, &cs->bg, 1, 0, True);
cs->bg = GetColor(white);
if (old_bg != cs->bg)
{
have_pixels_changed = True;
}
has_bg_changed = True;
}
if (has_bg_changed)
{
/* save the bg color for tinting */
cs->bg_saved = cs->bg;
}
} /* has_bg_changed */
/*
* ---------- setup the bg tint colour ----------
*/
if (has_bg_tint_changed && cs->bg_tint_percent > 0 && bg_tint != NULL)
{
PictureFreeColors(dpy, Pcmap, &cs->bg_tint, 1, 0, True);
cs->bg_tint = GetColor(bg_tint);
}
/*
* ---------- tint the bg colour ----------
*/
if (has_bg_tint_changed || (has_bg_changed && cs->bg_tint_percent > 0))
{
if (cs->bg_tint_percent == 0)
{
Pixel old_bg = cs->bg;
PictureFreeColors(dpy, Pcmap, &cs->bg, 1, 0, True);
cs->bg = cs->bg_saved;
if (old_bg != cs->bg)
{
have_pixels_changed = True;
has_bg_changed = True;
}
}
else
{
Pixel old_bg = cs->bg;
PictureFreeColors(dpy, Pcmap, &cs->bg, 1, 0, True);
cs->bg = GetTintedPixel(
cs->bg_saved, cs->bg_tint, cs->bg_tint_percent);
if (old_bg != cs->bg)
{
have_pixels_changed = True;
has_bg_changed = True;
}
}
}
/*
* ---------- setup the fg tint colour ----------
*/
if (has_fg_tint_changed && cs->fg_tint_percent > 0 && fg_tint != NULL)
{
PictureFreeColors(dpy, Pcmap, &cs->fg_tint, 1, 0, True);
cs->fg_tint = GetColor(fg_tint);
}
/*
* ---------- change the foreground colour ----------
*/
if (has_fg_changed ||
(has_bg_changed && (cs->color_flags & FG_CONTRAST)))
{
if (cs->color_flags & FG_CONTRAST)
{
Pixel old_fg = cs->fg;
/* calculate contrasting foreground color */
color.pixel = cs->bg;
XQueryColor(dpy, Pcmap, &color);
color.red = (color.red > 32767) ? 0 : 65535;
color.green = (color.green > 32767) ? 0 : 65535;
color.blue = (color.blue > 32767) ? 0 : 65535;
PictureFreeColors(dpy, Pcmap, &cs->fg, 1, 0, True);
PictureAllocColor(dpy, Pcmap, &color, True);
cs->fg = color.pixel;
if (old_fg != cs->fg)
{
have_pixels_changed = True;
has_fg_changed = 1;
}
} /* contrast */
else if ((cs->color_flags & FG_SUPPLIED) && fg != NULL)
{
/* user specified colour */
Pixel old_fg = cs->fg;
PictureFreeColors(dpy, Pcmap, &cs->fg, 1, 0, True);
cs->fg = GetColor(fg);
if (old_fg != cs->fg)
{
have_pixels_changed = True;
has_fg_changed = 1;
}
} /* user specified */
else if (fg == NULL)
{
/* default */
Pixel old_fg = cs->fg;
PictureFreeColors(dpy, Pcmap, &cs->fg, 1, 0, True);
cs->fg = GetColor(black);
if (old_fg != cs->fg)
{
have_pixels_changed = True;
has_fg_changed = 1;
}
}
/* save the fg color for tinting */
cs->fg_saved = cs->fg;
} /* has_fg_changed */
/*
* ---------- tint the foreground colour ----------
*/
if (has_fg_tint_changed || (has_fg_changed && cs->fg_tint_percent > 0))
{
if (cs->fg_tint_percent == 0)
{
Pixel old_fg = cs->fg;
PictureFreeColors(dpy, Pcmap, &cs->fg, 1, 0, True);
cs->fg = cs->fg_saved;
if (old_fg != cs->fg)
{
have_pixels_changed = True;
has_fg_changed = 1;
}
}
else
{
Pixel old_fg = cs->fg;
PictureFreeColors(dpy, Pcmap, &cs->fg, 1, 0, True);
cs->fg = GetTintedPixel(
cs->fg_saved, cs->fg_tint,
cs->fg_tint_percent);
if (old_fg != cs->fg)
{
have_pixels_changed = True;
has_fg_changed = 1;
}
}
}
/*
* ---------- change the hilight colour ----------
*/
if (has_hi_changed ||
(has_bg_changed && !(cs->color_flags & HI_SUPPLIED)))
{
has_hi_changed = 1;
if ((cs->color_flags & HI_SUPPLIED) && hi != NULL)
{
/* user specified colour */
Pixel old_hilite = cs->hilite;
PictureFreeColors(dpy, Pcmap, &cs->hilite, 1, 0, True);
cs->hilite = GetColor(hi);
if (old_hilite != cs->hilite)
{
have_pixels_changed = True;
}
} /* user specified */
else if (hi == NULL)
{
Pixel old_hilite = cs->hilite;
PictureFreeColors(dpy, Pcmap, &cs->hilite, 1, 0, True);
cs->hilite = GetHilite(cs->bg);
if (old_hilite != cs->hilite)
{
have_pixels_changed = True;
}
}
} /* has_hi_changed */
/*
* ---------- change the shadow colour ----------
*/
if (has_sh_changed ||
(has_bg_changed && !(cs->color_flags & SH_SUPPLIED)))
{
has_sh_changed = 1;
if ((cs->color_flags & SH_SUPPLIED) && sh != NULL)
{
/* user specified colour */
Pixel old_shadow = cs->shadow;
PictureFreeColors(dpy, Pcmap, &cs->shadow, 1, 0, True);
cs->shadow = GetColor(sh);
if (old_shadow != cs->shadow)
{
have_pixels_changed = True;
}
} /* user specified */
else if (sh == NULL)
{
Pixel old_shadow = cs->shadow;
PictureFreeColors(dpy, Pcmap, &cs->shadow, 1, 0, True);
cs->shadow = GetShadow(cs->bg);
if (old_shadow != cs->shadow)
{
have_pixels_changed = True;
}
}
} /* has_sh_changed */
/*
* ---------- change the shadow foreground colour ----------
*/
if (has_fgsh_changed ||
((has_fg_changed || has_bg_changed) &&
!(cs->color_flags & FGSH_SUPPLIED)))
{
has_fgsh_changed = 1;
if ((cs->color_flags & FGSH_SUPPLIED) && fgsh != NULL)
{
/* user specified colour */
Pixel old_fgsh = cs->fgsh;
PictureFreeColors(dpy, Pcmap, &cs->fgsh, 1, 0, True);
cs->fgsh = GetColor(fgsh);
if (old_fgsh != cs->fgsh)
{
have_pixels_changed = True;
}
} /* user specified */
else if (fgsh == NULL)
{
Pixel old_fgsh = cs->fgsh;
PictureFreeColors(dpy, Pcmap, &cs->fgsh, 1, 0, True);
cs->fgsh = GetForeShadow(cs->fg, cs->bg);
if (old_fgsh != cs->fgsh)
{
have_pixels_changed = True;
}
}
} /* has_fgsh_changed */
/*
* ------- the pixmap is a bitmap: create here cs->pixmap -------
*/
if (cs->picture != None && pixmap_is_a_bitmap &&
(has_pixmap_changed || has_bg_changed))
{
cs->pixmap = XCreatePixmap(
dpy, win, cs->width, cs->height, Pdepth);
XSetBackground(dpy, gc, cs->bg);
XSetForeground(dpy, gc, cs->fg);
reset_cs_pixmap(cs, gc);
}
/*
* ------- change the masked out parts of the background pixmap -------
*/
if (cs->pixmap != None && cs->pixmap != ParentRelative &&
(!CSETS_IS_TRANSPARENT_ROOT(cs)||
cs->allows_buffered_transparency) &&
(cs->mask != None || cs->alpha_pixmap != None ||
cs->image_alpha_percent < 100 || cs->tint_percent > 0) &&
(has_pixmap_changed || has_bg_changed || has_image_alpha_changed
|| has_tint_changed))
{
/* Now that we know the background colour we can update the
* pixmap background. */
FvwmRenderAttributes fra;
Pixmap temp, mask, alpha;
memset(&fra, 0, sizeof(fra));
temp = XCreatePixmap(dpy, win, cs->width, cs->height, Pdepth);
if (cs->picture != NULL)
{
mask = cs->picture->mask;
alpha = cs->picture->alpha;
}
else
{
mask = None;
alpha = None;
}
XSetForeground(dpy, gc, cs->bg);
XFillRectangle(
dpy, temp, gc, 0, 0, cs->width, cs->height);
fra.mask = FRAM_HAVE_ADDED_ALPHA | FRAM_HAVE_TINT;
fra.added_alpha_percent = cs->image_alpha_percent;
fra.tint = cs->tint;
fra.tint_percent = cs->tint_percent;
PGraphicsRenderPixmaps(
dpy, win, cs->pixmap, mask, alpha, Pdepth, &fra,
temp, gc, Scr.MonoGC, Scr.AlphaGC,
0, 0, cs->width, cs->height,
0, 0, cs->width, cs->height, False);
if (cs->pixmap != root_pic.pixmap)
{
add_to_junk(cs->pixmap);
}
cs->pixmap = temp;
has_pixmap_changed = True;
if (CSETS_IS_TRANSPARENT_ROOT(cs))
{
cs->pixmap_type = PIXMAP_ROOT_PIXMAP_TRAN;
}
} /* has_pixmap_changed */
/*
* ---------- change the icon tint colour ----------
*/
if (has_icon_tint_changed)
{
/* user specified colour */
if (icon_tint != NULL)
{
Pixel old_tint = cs->icon_tint;
PictureFreeColors(
dpy, Pcmap, &cs->icon_tint, 1, 0, True);
cs->icon_tint = GetColor(icon_tint);
if (old_tint != cs->icon_tint)
{
has_icon_pixels_changed = True;
}
}
else
{
/* default */
Pixel old_tint = cs->icon_tint;
PictureFreeColors(
dpy, Pcmap, &cs->icon_tint, 1, 0, True);
cs->icon_tint = GetColor(black);
if (old_tint != cs->icon_tint)
{
has_icon_pixels_changed = True;
}
}
}
/*
* ---------- send new colorset to fvwm and clean up ----------
*/
/* make sure the server has this to avoid races */
XSync(dpy, False);
/* inform modules of the change */
if (have_pixels_changed || has_pixmap_changed || has_shape_changed ||
has_fg_alpha_changed || has_icon_pixels_changed)
{
BroadcastColorset(n);
}
if (fg)
{
free(fg);
}
if (bg)
{
free(bg);
}
if (hi)
{
free(hi);
}
if (sh)
{
free(sh);
}
if (fgsh)
{
free(fgsh);
}
if (tint)
{
free(tint);
}
if (fg_tint)
{
free(fg_tint);
}
if (bg_tint)
{
free(bg_tint);
}
if (icon_tint)
{
free(icon_tint);
}
return;
}
/*
** seemed kind of silly to have check_allowed_function and
** check_allowed_function2 partially overlapping in their checks, so I
** combined them here and made them wrapper functions instead.
*/
Bool is_function_allowed(
int function, char *action_string, const FvwmWindow *t,
request_origin_t request_origin, Bool do_allow_override_mwm_hints)
{
unsigned int functions;
char *functionlist[] = {
MOVE_STRING,
RESIZE_STRING1,
RESIZE_STRING2,
MINIMIZE_STRING,
MINIMIZE_STRING2,
MAXIMIZE_STRING,
CLOSE_STRING1,
CLOSE_STRING2,
CLOSE_STRING3,
CLOSE_STRING4,
NULL
};
if (t == NULL)
{
return True; /* this logic come from animated menu */
}
if (do_allow_override_mwm_hints && HAS_MWM_OVERRIDE_HINTS(t))
{
/* allow everything */
functions = ~0;
}
else
{
/* restrict by mwm hints */
functions = t->functions;
}
/* Hate to do it, but for lack of a better idea, check based on the
* menu entry name */
/* Complex functions are a little tricky, ignore them if no menu item*/
if (function == F_FUNCTION && action_string != NULL)
{
int i;
/* remap to regular actions */
i = GetTokenIndex(action_string, functionlist, -1, NULL);
switch (i)
{
case 0:
function = F_MOVE;
break;
case 1:
function = F_RESIZE;
break;
case 2:
function = F_RESIZE;
break;
case 3:
function = F_ICONIFY;
break;
case 4:
function = F_ICONIFY;
break;
case 5:
function = F_MAXIMIZE;
break;
case 6:
function = F_CLOSE;
break;
case 7:
function = F_DELETE;
break;
case 8:
function = F_DESTROY;
break;
case 9:
function = F_QUIT;
break;
default:
break;
}
}
/* now do the real checks */
switch(function)
{
case F_DELETE:
if (IS_UNCLOSABLE(t))
{
return False;
}
if (IS_TEAR_OFF_MENU(t))
{
/* always allow this on tear off menus */
break;
}
if (!WM_DELETES_WINDOW(t))
{
return False;
}
/* fall through to close clause */
case F_CLOSE:
if (IS_UNCLOSABLE(t))
{
return False;
}
if (IS_TEAR_OFF_MENU(t))
{
/* always allow this on tear off menus */
break;
}
if (!(functions & MWM_FUNC_CLOSE))
{
return False;
}
break;
case F_DESTROY: /* shouldn't destroy always be allowed??? */
if (IS_UNCLOSABLE(t))
{
return False;
}
if (IS_TEAR_OFF_MENU(t))
{
/* always allow this on tear off menus */
break;
}
if (!(functions & MWM_FUNC_CLOSE))
{
return False;
}
break;
case F_RESIZE:
if(!__is_resize_allowed(t, functions, request_origin))
{
return False;
}
break;
case F_ICONIFY:
if ((!IS_ICONIFIED(t) && !(functions & MWM_FUNC_MINIMIZE)) ||
IS_UNICONIFIABLE(t))
{
return False;
}
break;
case F_MAXIMIZE:
if (IS_MAXIMIZE_FIXED_SIZE_DISALLOWED(t) &&
!__is_resize_allowed(t, functions, request_origin))
{
return False;
}
if ((request_origin && !(functions & MWM_FUNC_MAXIMIZE)) ||
IS_UNMAXIMIZABLE(t))
{
return False;
}
break;
case F_MOVE:
/* Move is a funny hint. Keeps it out of the menu, but you're
* still allowed to move. */
if (request_origin && IS_FIXED(t))
{
return False;
}
else if (!request_origin && IS_FIXED_PPOS(t))
{
return False;
}
if (request_origin && !(functions & MWM_FUNC_MOVE))
{
return False;
}
break;
case F_FUNCTION:
default:
break;
} /* end of switch */
/* if we fell through, just return True */
return True;
}
Bool StartButtonParseConfig(char *tline)
{
char *rest;
char *option;
int i, j, k;
int titleRecorded = 0, iconRecorded = 0;
char *tokens[100]; /* This seems really big */
StartAndLaunchButtonItem *tempPtr;
int mouseButton;
char **tmpStrPtr;
option = tline + module->namelen+1;
i = GetTokenIndex(option, startopts, -1, &rest);
while (*rest && *rest != '\n' && isspace(*rest))
{
rest++;
}
switch(i)
{
case 0: /* StartName */
if (First_Start_Button == NULL)
{
First_Start_Button = Last_Start_Button =
(StartAndLaunchButtonItem*)safemalloc(
sizeof(StartAndLaunchButtonItem));
StartAndLaunchButtonItemInit(First_Start_Button);
First_Start_Button->isStartButton = True;
}
else if (First_Start_Button->isStartButton == False)
{
/* shortcut button has been declared before start
* button */
tempPtr = (StartAndLaunchButtonItem*)safemalloc(
sizeof(StartAndLaunchButtonItem));
StartAndLaunchButtonItemInit(tempPtr);
tempPtr->tail = First_Start_Button;
First_Start_Button = tempPtr;
First_Start_Button->isStartButton = True;
}
else if (First_Start_Button->buttonCaption != NULL)
{
/* declarin caption twice, ignore */
break;
}
CopyString(&(First_Start_Button->buttonCaption), rest);
break;
case 1: /* StartMenu */
rest = ParseButtonOptions(rest, &mouseButton);
if (First_Start_Button == NULL)
{
First_Start_Button = Last_Start_Button =
(StartAndLaunchButtonItem*)safemalloc(
sizeof(StartAndLaunchButtonItem));
StartAndLaunchButtonItemInit(First_Start_Button);
First_Start_Button->isStartButton = True;
}
else if (First_Start_Button->isStartButton == False)
{
/* shortcut button has been declared before start
* button */
tempPtr = (StartAndLaunchButtonItem*) safemalloc(
sizeof(StartAndLaunchButtonItem));
StartAndLaunchButtonItemInit(tempPtr);
tempPtr->tail = First_Start_Button;
First_Start_Button = tempPtr;
First_Start_Button->isStartButton = True;
}
tmpStrPtr = (mouseButton ?
&(First_Start_Button->buttonCommands[mouseButton-1])
:
&(First_Start_Button->buttonCommand));
if (*tmpStrPtr)
{
/* declaring command twice, ignore */
break;
}
CopyString(tmpStrPtr, rest);
break;
case 2: /* StartIcon */
if (First_Start_Button == NULL)
{
First_Start_Button = Last_Start_Button =
(StartAndLaunchButtonItem*)safemalloc(
sizeof(StartAndLaunchButtonItem));
StartAndLaunchButtonItemInit(First_Start_Button);
First_Start_Button->isStartButton = True;
}
else if (First_Start_Button->isStartButton == False)
{
/* shortcut button has been declared before start
* button */
tempPtr = (StartAndLaunchButtonItem*) safemalloc(
sizeof(StartAndLaunchButtonItem));
StartAndLaunchButtonItemInit(tempPtr);
tempPtr->tail = First_Start_Button;
First_Start_Button = tempPtr;
First_Start_Button->isStartButton = True;
}
else if (First_Start_Button->buttonIconFileName != NULL)
{
/* declaring icon twice, ignore */
break;
}
CopyString(&(First_Start_Button->buttonIconFileName), rest);
break;
case 3: /* StartCommand */
rest = ParseButtonOptions(rest, &mouseButton);
if (First_Start_Button == NULL)
{
First_Start_Button = Last_Start_Button =
(StartAndLaunchButtonItem*)safemalloc(
sizeof(StartAndLaunchButtonItem));
StartAndLaunchButtonItemInit(First_Start_Button);
First_Start_Button->isStartButton = True;
}
else if (First_Start_Button->isStartButton == False)
{
/* shortcut button has been declared before start
* button */
tempPtr = (StartAndLaunchButtonItem*)safemalloc(
sizeof(StartAndLaunchButtonItem));
StartAndLaunchButtonItemInit(tempPtr);
tempPtr->tail = First_Start_Button;
First_Start_Button = tempPtr;
First_Start_Button->isStartButton = True;
}
tmpStrPtr =
(mouseButton ?
&(First_Start_Button->buttonStartCommands[mouseButton-1]) :
&(First_Start_Button->buttonStartCommand));
if (*tmpStrPtr)
{
/* declaring command twice, ignore */
break;
}
CopyString(tmpStrPtr, rest);
break;
case 4: /* NoDefaultStartButton */
NoDefaultStartButton = True;
break;
case 5: /* Button */
if (Last_Start_Button == NULL)
{
First_Start_Button = Last_Start_Button =
(StartAndLaunchButtonItem*)safemalloc(
sizeof(StartAndLaunchButtonItem));
}
else
{
Last_Start_Button->tail =
(StartAndLaunchButtonItem*) safemalloc(
sizeof(StartAndLaunchButtonItem));
Last_Start_Button = Last_Start_Button->tail;
}
StartAndLaunchButtonItemInit(Last_Start_Button);
j=0;
titleRecorded = iconRecorded = 0;
{
char *strtok_ptr = 0;
tokens[j++] = strtok_r(rest, ",", &strtok_ptr);
while((tokens[j++] = strtok_r(NULL, ",", &strtok_ptr)))
{
while(isspace(*(tokens[j-1])))
{
tokens[j-1]+=sizeof(char);
}
}
}
j--;
for(k=0;k<j;k++)
{
if (strncasecmp(tokens[k], "Title", 5)==0)
{
tokens[j+1] = tokens[k] + ((sizeof(char))*5);
while(*(tokens[j+1])==' ')
tokens[j+1]+=sizeof(char);
CopyString(
&(Last_Start_Button->buttonCaption),
tokens[j+1]);
titleRecorded=1;
}
else if (strncasecmp(tokens[k], "Icon", 4)==0)
{
tokens[j+1] = tokens[k] + ((sizeof(char))*4);
while(*(tokens[j+1])==' ')
tokens[j+1]+=sizeof(char);
CopyString(
&(Last_Start_Button->buttonIconFileName),
tokens[j+1] );
iconRecorded = 1;
}
else if (strncasecmp(tokens[k], "Action", 6)==0)
{
rest = tokens[k] + ((sizeof(char))*6);
rest = ParseButtonOptions(rest, &mouseButton);
tokens[j+1] = rest;
if (mouseButton)
{
tmpStrPtr =
&(Last_Start_Button->
buttonStartCommands
[mouseButton-1]);
}
else
{
tmpStrPtr =
&(Last_Start_Button->
buttonStartCommand);
}
if (!(*tmpStrPtr))
{
/* don't let them set the same action
* twice */
CopyString(tmpStrPtr, tokens[j+1]);
}
}
}
if (titleRecorded==0)
{
CopyString(&(Last_Start_Button->buttonCaption), "\0");
}
if (iconRecorded==0)
{
CopyString(
&(Last_Start_Button->buttonIconFileName),
"\0");
}
break;
case 6: /* WindowButtonsLeftMargin */
if(atoi(rest)>=0)
{
WindowButtonsLeftMargin = atoi(rest);
has_wb_left_margin = 1;
}
break;
case 7: /* WindowButtonsRightMargin */
if(atoi(rest)>=0)
{
WindowButtonsRightMargin = atoi(rest);
has_wb_right_margin = 1;
}
break;
case 8: /* StartButtonRightMargin */
if(atoi(rest)>=0)
{
StartButtonRightMargin = atoi(rest);
}
break;
default:
/* unknown option */
return False;
} /* switch */
return True;
}
/* expands certain variables in a command to be sent by a module */
char *module_expand_action(
Display *dpy, int screen , char *in_action, rectangle *r,
char *forecolor, char *backcolor)
{
char *variables[] =
{
"$",
"fg",
"bg",
"left",
"-left",
"right",
"-right",
"top",
"-top",
"bottom",
"-bottom",
"width",
"height",
NULL
};
char *action = NULL;
char *src;
char *dest;
char *string = NULL;
char *rest;
int val = 0;
int offset;
int i;
char *dest_org;
Bool is_string;
Bool is_value;
Bool has_geom;
Bool has_fg;
Bool has_bg;
rectangle tmpr = { 0, 0, 0, 0 };
has_geom = (r == NULL) ? False : True;
has_fg = (forecolor == NULL) ? False : True;
has_bg = (backcolor == NULL) ? False : True;
if (r == NULL)
{
r = &tmpr;
}
/* create a temporary storage for expanding */
action = mvwm_malloc(MAX_MODULE_INPUT_TEXT_LEN);
for (src = in_action, dest = action; *src != 0; src++)
{
if (*src != '$')
{
*(dest++) = *src;
continue;
}
/* it's a variable */
dest_org = dest;
is_string = False;
is_value = False;
*(dest++) = *(src++);
i = GetTokenIndex(src, variables, -1, &rest);
if (i == -1)
{
src--;
continue;
}
switch (i)
{
case 0: /* $ */
continue;
case 1: /* fg */
string = forecolor;
is_string = has_fg;
break;
case 2: /* bg */
if (backcolor == NULL)
{
continue;
}
string = backcolor;
is_string = has_bg;
break;
case 3: /* left */
val = r->x;
is_value = has_geom;
break;
case 4: /* -left */
val = DisplayWidth(dpy, screen) - r->x - 1;
is_value = has_geom;
break;
case 5: /* right */
val = r->x + r->width;
is_value = has_geom;
break;
case 6: /* -right */
val = DisplayWidth(dpy, screen) - r->x - r->width - 1;
is_value = has_geom;
break;
case 7: /* top */
val = r->y;
is_value = has_geom;
break;
case 8: /* -top */
val = DisplayHeight(dpy, screen) - r->y - 1;
is_value = has_geom;
break;
case 9: /* bottom */
val = r->y + r->height;
is_value = has_geom;
break;
case 10: /* -bottom */
val = DisplayHeight(dpy, screen) - r->y - r->height - 1;
is_value = has_geom;
break;
case 11: /* width */
val = r->width;
is_value = has_geom;
break;
case 12: /* height */
val = r->height;
is_value = has_geom;
break;
default: /* unknown */
src--;
continue;
} /* switch */
if (is_value == False && is_string == False)
{
src--;
continue;
}
dest = dest_org;
src = --rest;
if (is_value)
{
if (MAX_MODULE_INPUT_TEXT_LEN - (dest - action) <= 16)
{
/* out of space */
free(action);
return NULL;
}
/* print the number into the string */
sprintf(dest, "%d%n", val, &offset);
dest += offset;
}
else if (is_string)
{
if (MAX_MODULE_INPUT_TEXT_LEN - (dest - action) <=
strlen(string))
{
/* out of space */
free(action);
return NULL;
}
/* print the colour name into the string */
if (string)
{
sprintf(dest, "%s%n", string, &offset);
dest += offset;
}
}
} /* for */
*dest = 0;
return action;
}
