qbit/xenocara
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
3458219f72
xenocara/app/fvwm/modules/FvwmForm/FvwmForm.c

1578 lines
45 KiB
C
Raw Normal View History

Importing from XF4, plus BSD make infrastructure
2006-11-26 03:53:04 -07:00
/* FvwmForm is original work of Thomas Zuwei Feng.
*
* Copyright Feb 1995, Thomas Zuwei Feng. No guarantees or warantees are
* provided or implied in any way whatsoever. Use this program at your own
* risk. Permission to use, modify, and redistribute this program is hereby
* given, provided that this copyright is kept intact.
*/
#include "config.h"
#include "../../libs/fvwmlib.h"
#include <stdio.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/time.h>
#include <fcntl.h>
#if HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif
#include <X11/Xlib.h>
#include <X11/X.h>
#include <X11/Xutil.h>
#include <X11/cursorfont.h>
#define XK_MISCELLANY
#include <X11/keysymdef.h>
void dummy () {
}
#ifdef DEBUG
#define fprintf fprintf
#else
#define fprintf dummy
#endif
#define TEXT_SPC 3
#define BOX_SPC 3
#define ITEM_HSPC 10
#define ITEM_VSPC 5
/* tba: use dynamic buffer expanding */
#define MAX_LINES 50
#define MAX_ITEMS 100
#define ITEMS_PER_LINE 64
#define CHOICES_PER_SEL 64
#define I_TEXT 1
#define I_INPUT 2
#define I_SELECT 3
#define I_CHOICE 4
#define I_BUTTON 5
#define IS_SINGLE 1
#define IS_MULTIPLE 2
#define IB_CONTINUE 1
#define IB_RESTART 2
#define IB_QUIT 3
typedef union _item {
int type; /* item type, one of I_TEXT .. I_BUTTON */
struct _head { /* common header */
int type;
int win; /* X window id */
char *name; /* identifier name */
int size_x, size_y; /* size of bounding box */
int pos_x, pos_y; /* position of top-left corner */
} header;
struct { /* I_TEXT */
struct _head head;
int n; /* string length */
char *value; /* string to display */
} text;
struct { /* I_INPUT */
struct _head head;
int buf; /* input string buffer */
int n; /* string length */
char *value; /* input string */
char *init_value; /* default string */
char *blanks; /* blank string */
int size; /* input field size */
int left; /* position of the left-most displayed char */
int o_cursor; /* store relative cursor position */
} input;
struct { /* I_SELECT */
struct _head head;
int key; /* one of IS_MULTIPLE, IS_SINGLE */
int n; /* number of choices */
union _item **choices; /* list of choices */
} select;
struct { /* I_CHOICE */
struct _head head;
int on; /* selected or not */
int init_on; /* initially selected or not */
char *value; /* value if selected */
int n; /* text string length */
char *text; /* text string */
union _item *sel; /* selection it belongs to */
} choice;
struct { /* I_BUTTON */
struct _head head;
int key; /* one of IB_CONTINUE, IB_RESTART, IB_QUIT */
int n; /* # of commands */
int len; /* text length */
char *text; /* text string */
int keypress; /* short cut */
/* Fvwm command to execute */
char **commands;
} button;
} Item;
#define L_LEFT 1
#define L_RIGHT 2
#define L_CENTER 3
#define L_LEFTRIGHT 4
typedef struct _line {
int n; /* number of items on the line */
int justify; /* justification */
int size_x, size_y; /* size of bounding rectangle */
Item **items; /* list of items */
} Line;
/* global variables */
char *prog_name; /* program name, e.g. FvwmForm */
int fd_in; /* fd for Fvwm->Module packets */
int fd_out; /* fd for Module->Fvwm packets */
int fd[2]; /* pipe pair */
int fd_err;
FILE *fp_err;
Line lines[MAX_LINES];
int n_lines;
Item items[MAX_ITEMS];
int n_items;
Item def_button;
int grab_server = 0, server_grabbed = 0;
int gx, gy, geom = 0;
int warp_pointer = 0;
Display *dpy;
int fd_x; /* fd for X connection */
Window root, frame, ref;
Colormap d_cmap;
int screen;
int scr_depth;
int max_width, total_height; /* frame size */
enum { c_back, c_fore, c_itemback, c_itemfore, c_itemlo, c_itemhi };
char *color_names[4] = {
"Light Gray", "Black", "Gray50", "Wheat"
};
unsigned long colors[6];
enum { f_text, f_input, f_button };
char *font_names[3] = {
"fixed",
"fixed",
"fixed"
};
Font fonts[3];
XFontStruct *xfs[3];
Cursor xc_ibeam, xc_hand;
GC gc_text, gc_input, gc_button;
Item *cur_text;
int abs_cursor;
int rel_cursor;
static char *buf;
static int N = 8;
/* copy a string until '\0', or up to n chars, and delete trailing spaces */
char *CopyNString (char *cp, int n)
{
char *dp, *bp;
if (n == 0)
n = strlen(cp);
bp = dp = (char *)malloc(n+1);
while (n-- > 0)
*dp++ = *cp++;
while (isspace(*(--dp)));
*(++dp) = '\0';
return bp;
}
/* copy a string until '"', or '\n', or '\0' */
char *CopyQuotedString (char *cp)
{
char *dp, *bp, c;
bp = dp = (char *)malloc(strlen(cp) + 1);
while (1) {
switch (c = *(cp++)) {
case '\\':
*(dp++) = *(cp++);
break;
case '\"':
case '\n':
case '\0':
*dp = '\0';
return bp;
break;
default:
*(dp++) = c;
break;
}
}
}
/* copy a string until the first space */
char *CopySolidString (char *cp)
{
char *dp, *bp, c;
bp = dp = (char *)malloc(strlen(cp) + 1);
while (1) {
c = *(cp++);
if (c == '\\') {
*(dp++) = '\\';
*(dp++) = *(cp++);
} else if (isspace(c) || c == '\0') {
*dp = '\0';
return bp;
} else
*(dp++) = c;
}
}
/* get the font height */
int FontHeight (XFontStruct *xfs)
{
return (xfs->ascent + xfs->descent);
}
/* get the font width, for fixed-width font only */
int FontWidth (XFontStruct *xfs)
{
return (xfs->per_char[0].width);
}
/* read the configuration file */
void ReadConfig ()
{
FILE *fopen();
int prog_name_len, i, j, l, extra;
char *line_buf;
char *cp;
Line *cur_line, *line;
Item *item, *cur_sel, *cur_button;
#define AddToLine(item) { cur_line->items[cur_line->n++] = item; cur_line->size_x += item->header.size_x; if (cur_line->size_y < item->header.size_y) cur_line->size_y = item->header.size_y; }
n_items = 0;
n_lines = 0;
/* default line in case the first *FFLine is missing */
lines[0].n = 0;
lines[0].justify = L_CENTER;
lines[0].size_x = lines[0].size_y = 0;
lines[0].items = (Item **)malloc(sizeof(Item *) * ITEMS_PER_LINE);
cur_line = lines;
/* default button is for initial functions */
cur_button = &def_button;
def_button.button.n = 0;
def_button.button.commands = (char **)malloc(sizeof(char *) * MAX_ITEMS);
def_button.button.key = IB_CONTINUE;
/* default fonts in case the *FFFont's are missing */
xfs[f_text] = xfs[f_input] = xfs[f_button] =
GetFontOrFixed(dpy, "fixed");
fonts[f_text] = fonts[f_input] = fonts[f_button] = xfs[f_text]->fid;
prog_name_len = strlen(prog_name);
while (GetConfigLine(fd,&line_buf),line_buf) {
cp = line_buf;
while (isspace(*cp)) cp++; /* skip blanks */
if (*cp != '*') continue;
if (strncmp(++cp, prog_name, prog_name_len) != 0) continue;
cp += prog_name_len;
/* at this point we have recognized "*FvwmForm" */
if (strncmp(cp, "GrabServer", 10) == 0) {
grab_server = 1;
continue;
}
else if (strncmp(cp, "WarpPointer", 11) == 0) {
warp_pointer = 1;
}
else if (strncmp(cp, "Position", 8) == 0) {
cp += 8;
geom = 1;
while (isspace(*cp)) cp++;
gx = atoi(cp);
while (!isspace(*cp)) cp++;
while (isspace(*cp)) cp++;
gy = atoi(cp);
fprintf(fp_err, "Position @ (%d, %d)\n", gx, gy);
continue;
}
else if (strncmp(cp, "Fore", 4) == 0) {
cp += 4;
while (isspace(*cp)) cp++;
color_names[c_fore] = CopyNString(cp, 0);
fprintf(fp_err, "ColorFore: %s\n", color_names[c_fore]);
continue;
} else if (strncmp(cp, "Back", 4) == 0) {
cp += 4;
while (isspace(*cp)) cp++;
color_names[c_back] = CopyNString(cp, 0);
fprintf(fp_err, "ColorBack: %s\n", color_names[c_back]);
continue;
} else if (strncmp(cp, "ItemFore", 8) == 0) {
cp += 8;
while (isspace(*cp)) cp++;
color_names[c_itemfore] = CopyNString(cp, 0);
fprintf(fp_err, "ColorItemFore: %s\n", color_names[c_itemfore]);
continue;
} else if (strncmp(cp, "ItemBack", 8) == 0) {
cp += 8;
while (isspace(*cp)) cp++;
color_names[c_itemback] = CopyNString(cp, 0);
fprintf(fp_err, "ColorItemBack: %s\n", color_names[c_itemback]);
continue;
} else if (strncmp(cp, "Font", 4) == 0) {
cp += 4;
while (isspace(*cp)) cp++;
font_names[f_text] = CopyNString(cp, 0);
fprintf(fp_err, "Font: %s\n", font_names[f_text]);
xfs[f_text] = GetFontOrFixed(dpy, font_names[f_text]);
fonts[f_text] = xfs[f_text]->fid;
continue;
} else if (strncmp(cp, "ButtonFont", 10) == 0) {
cp += 10;
while (isspace(*cp)) cp++;
font_names[f_button] = CopyNString(cp, 0);
fprintf(fp_err, "ButtonFont: %s\n", font_names[f_button]);
xfs[f_button] = GetFontOrFixed(dpy, font_names[f_button]);
fonts[f_button] = xfs[f_button]->fid;
continue;
} else if (strncmp(cp, "InputFont", 9) == 0) {
cp += 9;
while (isspace(*cp)) cp++;
font_names[f_input] = CopyNString(cp, 0);
fprintf(fp_err, "InputFont: %s\n", font_names[f_input]);
xfs[f_input] = GetFontOrFixed(dpy, font_names[f_input]);
fonts[f_input] = xfs[f_input]->fid;
continue;
} else if (strncmp(cp, "Line", 4) == 0) {
cp += 4;
cur_line = lines + n_lines++;
while (isspace(*cp)) cp++;
if (strncmp(cp, "left", 4) == 0)
cur_line->justify = L_LEFT;
else if (strncmp(cp, "right", 5) == 0)
cur_line->justify = L_RIGHT;
else if (strncmp(cp, "center", 6) == 0)
cur_line->justify = L_CENTER;
else
cur_line->justify = L_LEFTRIGHT;
cur_line->n = 0;
cur_line->items = (Item **)malloc(sizeof(Item *) * ITEMS_PER_LINE);
continue;
} else if (strncmp(cp, "Text", 4) == 0) {
/* syntax: *FFText "<text>" */
cp += 4;
item = items + n_items++;
item->type = I_TEXT;
item->header.name = "";
while (isspace(*cp)) cp++;
if (*cp == '\"')
item->text.value = CopyQuotedString(++cp);
else
item->text.value = "";
item->text.n = strlen(item->text.value);
item->header.size_x = XTextWidth(xfs[f_text], item->text.value,
item->text.n) + 2 * TEXT_SPC;
item->header.size_y = FontHeight(xfs[f_text]) + 2 * TEXT_SPC;
fprintf(fp_err, "Text \"%s\" [%d, %d]\n", item->text.value,
item->header.size_x, item->header.size_y);
AddToLine(item);
continue;
}
else if (strncmp(cp, "Input", 5) == 0) {
/* syntax: *FFInput <name> <size> "<init_value>" */
cp += 5;
item = items + n_items++;
item->type = I_INPUT;
while (isspace(*cp)) cp++;
item->header.name = CopySolidString(cp);
cp += strlen(item->header.name);
while (isspace(*cp)) cp++;
item->input.size = atoi(cp);
while (!isspace(*cp)) cp++;
while (isspace(*cp)) cp++;
if (*cp == '\"')
item->input.init_value = CopyQuotedString(++cp);
else
item->input.init_value = "";
item->input.blanks = (char *)malloc(item->input.size);
for (j = 0; j < item->input.size; j++)
item->input.blanks[j] = ' ';
item->input.buf = strlen(item->input.init_value) + 1;
item->input.value = (char *)malloc(item->input.buf);
item->header.size_x = FontWidth(xfs[f_input]) * item->input.size
+ 2 * TEXT_SPC + 2 * BOX_SPC;
item->header.size_y = FontHeight(xfs[f_input]) + 3 * TEXT_SPC
+ 2 * BOX_SPC;
fprintf(fp_err, "Input, %s, [%d], \"%s\"\n", item->header.name,
item->input.size, item->input.init_value);
AddToLine(item);
}
else if (strncmp(cp, "Selection", 9) == 0) {
/* syntax: *FFSelection <name> single | multiple */
cp += 9;
cur_sel = items + n_items++;
cur_sel->type = I_SELECT;
while (isspace(*cp)) cp++;
cur_sel->header.name = CopySolidString(cp);
cp += strlen(cur_sel->header.name);
while (isspace(*cp)) cp++;
if (strncmp(cp, "multiple", 8) == 0)
cur_sel->select.key = IS_MULTIPLE;
else
cur_sel->select.key = IS_SINGLE;
cur_sel->select.n = 0;
cur_sel->select.choices =
(Item **)malloc(sizeof(Item *) * CHOICES_PER_SEL);
continue;
} else if (strncmp(cp, "Choice", 6) == 0) {
/* syntax: *FFChoice <name> <value> [on | _off_] ["<text>"] */
cp += 6;
item = items + n_items++;
item->type = I_CHOICE;
while (isspace(*cp)) cp++;
item->header.name = CopySolidString(cp);
cp += strlen(item->header.name);
while (isspace(*cp)) cp++;
item->choice.value = CopySolidString(cp);
cp += strlen(item->choice.value);
while (isspace(*cp)) cp++;
if (strncmp(cp, "on", 2) == 0)
item->choice.init_on = 1;
else
item->choice.init_on = 0;
while (!isspace(*cp)) cp++;
while (isspace(*cp)) cp++;
if (*cp == '\"')
item->choice.text = CopyQuotedString(++cp);
else
item->choice.text = "";
item->choice.n = strlen(item->choice.text);
item->choice.sel = cur_sel;
cur_sel->select.choices[cur_sel->select.n++] = item;
item->header.size_y = FontHeight(xfs[f_text]) + 2 * TEXT_SPC;
item->header.size_x = FontHeight(xfs[f_text]) + 4 * TEXT_SPC +
XTextWidth(xfs[f_text], item->choice.text, item->choice.n);
fprintf(fp_err, "Choice %s, \"%s\", [%d, %d]\n", item->header.name,
item->choice.text, item->header.size_x, item->header.size_y);
AddToLine(item);
continue;
} else if (strncmp(cp, "Button", 6) == 0) {
/* syntax: *FFButton continue | restart | quit "<text>" */
cp += 6;
item = items + n_items++;
item->type = I_BUTTON;
item->header.name = "";
while (isspace(*cp)) cp++;
if (strncmp(cp, "restart", 7) == 0)
item->button.key = IB_RESTART;
else if (strncmp(cp, "quit", 4) == 0)
item->button.key = IB_QUIT;
else
item->button.key = IB_CONTINUE;
while (!isspace(*cp)) cp++;
while (isspace(*cp)) cp++;
if (*cp == '\"') {
item->button.text = CopyQuotedString(++cp);
cp += strlen(item->button.text) + 1;
while (isspace(*cp)) cp++;
} else
item->button.text = "";
if (*cp == '^')
item->button.keypress = *(++cp) - '@';
else if (*cp == 'F')
item->button.keypress = 256 + atoi(++cp);
else
item->button.keypress = -1;
item->button.len = strlen(item->button.text);
item->button.n = 0;
item->button.commands = (char **)malloc(sizeof(char *) * MAX_ITEMS);
item->header.size_y = FontHeight(xfs[f_button]) + 2 * TEXT_SPC
+ 2 * BOX_SPC;
item->header.size_x = 2 * TEXT_SPC + 2 * BOX_SPC
+ XTextWidth(xfs[f_button], item->button.text, item->button.len);
AddToLine(item);
cur_button = item;
continue;
} else if (strncmp(cp, "Command", 7) == 0) {
/* syntax: *FFCommand <command> */
cp += 7;
while (isspace(*cp)) cp++;
cur_button->button.commands[cur_button->button.n++] =
CopyNString(cp, 0);
}
} /* end of switch() */
/* get the geometry right */
max_width = 0;
total_height = ITEM_VSPC;
for (l = 0; l < n_lines; l++) {
line = lines + l;
for (i = 0; i < line->n; i++) {
line->items[i]->header.pos_y = total_height;
if (line->items[i]->header.size_y < line->size_y)
line->items[i]->header.pos_y += (line->size_y - line->items[i]->header.size_y) / 2 + 1 ;
}
total_height += ITEM_VSPC + line->size_y;
line->size_x += (line->n + 1) * ITEM_HSPC;
if (line->size_x > max_width)
max_width = line->size_x;
}
for (l = 0; l < n_lines; l++) {
int width;
line = lines + l;
fprintf(fp_err, "Line[%d], %d, %d items\n", l, line->justify, line->n);
switch (line->justify) {
case L_LEFT:
width = ITEM_HSPC;
for (i = 0; i < line->n; i++) {
line->items[i]->header.pos_x = width;
width += ITEM_HSPC + line->items[i]->header.size_x;
}
break;
case L_RIGHT:
width = max_width - line->size_x + ITEM_HSPC;
for (i = 0; i < line->n; i++) {
line->items[i]->header.pos_x = width;
width += ITEM_HSPC + line->items[i]->header.size_x;
}
break;
case L_CENTER:
width = (max_width - line->size_x) / 2 + ITEM_HSPC;
for (i = 0; i < line->n; i++) {
line->items[i]->header.pos_x = width;
fprintf(fp_err, "Line[%d], Item[%d] @ (%d, %d)\n", l, i,
line->items[i]->header.pos_x, line->items[i]->header.pos_y);
width += ITEM_HSPC + line->items[i]->header.size_x;
}
break;
case L_LEFTRIGHT:
/* count the number of inputs on the line - the extra space will be
* shared amongst these if there are any, otherwise it will be added
* as space in between the elements
*/
extra = 0 ;
for (i = 0 ; i < line->n ; i++) {
if (line->items[i]->type == I_INPUT)
extra++ ;
}
if (extra == 0) {
if (line->n < 2) { /* same as L_CENTER */
width = (max_width - line->size_x) / 2 + ITEM_HSPC;
for (i = 0; i < line->n; i++) {
line->items[i]->header.pos_x = width;
width += ITEM_HSPC + line->items[i]->header.size_x;
}
} else {
extra = (max_width - line->size_x) / (line->n - 1);
width = ITEM_HSPC;
for (i = 0; i < line->n; i++) {
line->items[i]->header.pos_x = width;
width += ITEM_HSPC + line->items[i]->header.size_x + extra;
}
}
} else {
extra = (max_width - line->size_x) / extra ;
width = ITEM_HSPC ;
for (i = 0 ; i < line->n ; i++) {
line->items[i]->header.pos_x = width ;
if (line->items[i]->type == I_INPUT)
line->items[i]->header.size_x += extra ;
width += ITEM_HSPC + line->items[i]->header.size_x ;
}
}
break;
}
}
}
#define MAX_INTENSITY 65535
/* allocate color cells */
void GetColors ()
{
Visual* visual = DefaultVisual(dpy, screen);
XColor xc_item;
int red, green, blue, tmp1, tmp2 ;
if (scr_depth < 8) {
colors[c_back] = colors[c_itemback] = WhitePixel(dpy, screen);
colors[c_fore] = colors[c_itemfore] = colors[c_itemlo] = colors[c_itemhi]
= BlackPixel(dpy, screen);
} else if (visual->class == TrueColor ||
visual->class == StaticColor ||
visual->class == StaticGray) {
if (XParseColor(dpy, d_cmap, color_names[c_fore], &xc_item) &&
XAllocColor(dpy, d_cmap, &xc_item))
colors[c_fore] = xc_item.pixel;
else
colors[c_fore] = BlackPixel(dpy, screen);
if (XParseColor(dpy, d_cmap, color_names[c_back], &xc_item) &&
XAllocColor(dpy, d_cmap, &xc_item))
colors[c_back] = xc_item.pixel;
else
colors[c_back] = WhitePixel(dpy, screen);
if (XParseColor(dpy, d_cmap, color_names[c_itemfore], &xc_item) &&
XAllocColor(dpy, d_cmap, &xc_item))
colors[c_itemfore] = xc_item.pixel;
else
colors[c_itemfore] = BlackPixel(dpy, screen);
if (XParseColor(dpy, d_cmap, color_names[c_itemback], &xc_item) &&
XAllocColor(dpy, d_cmap, &xc_item))
colors[c_itemback] = xc_item.pixel;
else
colors[c_itemback] = WhitePixel(dpy, screen);
InitPictureCMap(dpy,root); /* for shadow routines */
colors[c_itemlo] = GetShadow(colors[c_itemback]); /* alloc shadow */
colors[c_itemhi] = GetHilite(colors[c_itemback]); /* alloc shadow */
} else if (!XAllocColorCells(dpy, d_cmap, 0, NULL, 0, colors, 6)) {
colors[c_back] = colors[c_itemback] = WhitePixel(dpy, screen);
colors[c_fore] = colors[c_itemfore] = colors[c_itemlo] = colors[c_itemhi]
= BlackPixel(dpy, screen);
} else {
XStoreNamedColor(dpy, d_cmap, color_names[c_fore], colors[c_fore],
DoRed | DoGreen | DoBlue);
XStoreNamedColor(dpy, d_cmap, color_names[c_back], colors[c_back],
DoRed | DoGreen | DoBlue);
XStoreNamedColor(dpy, d_cmap, color_names[c_itemfore],
colors[c_itemfore], DoRed | DoGreen | DoBlue);
XStoreNamedColor(dpy, d_cmap, color_names[c_itemback],
colors[c_itemback], DoRed | DoGreen | DoBlue);
XParseColor(dpy, d_cmap, color_names[c_itemback], &xc_item);
red = (int) xc_item.red ;
green = (int) xc_item.green ;
blue = (int) xc_item.blue ;
xc_item.red = (60 * red) / 100 ;
xc_item.green = (60 * green) / 100 ;
xc_item.blue = (60 * blue) / 100 ;
xc_item.pixel = colors[c_itemlo];
xc_item.flags = DoRed | DoGreen | DoBlue;
XStoreColor(dpy, d_cmap, &xc_item);
XParseColor(dpy, d_cmap, color_names[c_itemback], &xc_item);
tmp1 = (14 * red) / 10 ;
if (tmp1 > MAX_INTENSITY) tmp1 = MAX_INTENSITY ;
tmp2 = (MAX_INTENSITY + red) / 2 ;
xc_item.red = (tmp1 > tmp2) ? tmp1 : tmp2 ;
tmp1 = (14 * green) / 10 ;
if (tmp1 > MAX_INTENSITY) tmp1 = MAX_INTENSITY ;
tmp2 = (MAX_INTENSITY + green) / 2 ;
xc_item.green = (tmp1 > tmp2) ? tmp1 : tmp2 ;
tmp1 = (14 * blue) / 10 ;
if (tmp1 > MAX_INTENSITY) tmp1 = MAX_INTENSITY ;
tmp2 = (MAX_INTENSITY + blue) / 2 ;
xc_item.blue = (tmp1 > tmp2) ? tmp1 : tmp2 ;
xc_item.pixel = colors[c_itemhi];
xc_item.flags = DoRed | DoGreen | DoBlue;
XStoreColor(dpy, d_cmap, &xc_item);
}
}
/* reset all the values */
void Restart ()
{
int i;
Item *item;
cur_text = NULL;
abs_cursor = rel_cursor = 0;
for (i = 0; i < n_items; i++) {
item = items + i;
switch (item->type) {
case I_INPUT:
if (!cur_text)
cur_text = item;
item->input.n = strlen(item->input.init_value);
strcpy(item->input.value, item->input.init_value);
item->input.left = 0;
item->input.o_cursor = 0;
break;
case I_CHOICE:
item->choice.on = item->choice.init_on;
break;
}
}
}
/* redraw the frame */
void RedrawFrame ()
{
int i, x, y;
Item *item;
for (i = 0; i < n_items; i++) {
item = items + i;
switch (item->type) {
case I_TEXT:
x = item->header.pos_x + TEXT_SPC;
y = item->header.pos_y + TEXT_SPC + xfs[f_text]->ascent;
XDrawImageString(dpy, frame, gc_text, x, y, item->text.value,
item->text.n);
break;
case I_CHOICE:
x = item->header.pos_x + TEXT_SPC + item->header.size_y;
y = item->header.pos_y + TEXT_SPC + xfs[f_text]->ascent;
XDrawImageString(dpy, frame, gc_text, x, y, item->choice.text,
item->choice.n);
break;
}
}
}
/* redraw an item */
void RedrawItem (Item *item, int click)
{
int dx, dy, len, x;
static XSegment xsegs[4];
switch (item->type) {
case I_INPUT:
dx = item->header.size_x - 1;
dy = item->header.size_y - 1;
XSetForeground(dpy, gc_button, colors[c_itemlo]);
xsegs[0].x1 = 0, xsegs[0].y1 = 0;
xsegs[0].x2 = 0, xsegs[0].y2 = dy;
xsegs[1].x1 = 0, xsegs[1].y1 = 0;
xsegs[1].x2 = dx, xsegs[1].y2 = 0;
xsegs[2].x1 = 1, xsegs[2].y1 = 1;
xsegs[2].x2 = 1, xsegs[2].y2 = dy - 1;
xsegs[3].x1 = 1, xsegs[3].y1 = 1;
xsegs[3].x2 = dx - 1, xsegs[3].y2 = 1;
XDrawSegments(dpy, item->header.win, gc_button, xsegs, 4);
XSetForeground(dpy, gc_button, colors[c_itemhi]);
xsegs[0].x1 = 1, xsegs[0].y1 = dy;
xsegs[0].x2 = dx, xsegs[0].y2 = dy;
xsegs[1].x1 = 2, xsegs[1].y1 = dy - 1;
xsegs[1].x2 = dx, xsegs[1].y2 = dy - 1;
xsegs[2].x1 = dx, xsegs[2].y1 = 1;
xsegs[2].x2 = dx, xsegs[2].y2 = dy;
xsegs[3].x1 = dx - 1, xsegs[3].y1 = 2;
xsegs[3].x2 = dx - 1, xsegs[3].y2 = dy;
XDrawSegments(dpy, item->header.win, gc_button, xsegs, 4);
if (click) {
x = BOX_SPC + TEXT_SPC + FontWidth(xfs[f_input]) * abs_cursor - 1;
XSetForeground(dpy, gc_button, colors[c_itemback]);
XDrawLine(dpy, item->header.win, gc_button,
x, BOX_SPC, x, dy - BOX_SPC);
}
len = item->input.n - item->input.left;
if (len > item->input.size)
len = item->input.size;
else
XDrawImageString(dpy, item->header.win, gc_input,
BOX_SPC + TEXT_SPC + FontWidth(xfs[f_input]) * len,
BOX_SPC + TEXT_SPC + xfs[f_input]->ascent,
item->input.blanks, item->input.size - len);
XDrawImageString(dpy, item->header.win, gc_input,
BOX_SPC + TEXT_SPC,
BOX_SPC + TEXT_SPC + xfs[f_input]->ascent,
item->input.value + item->input.left, len);
if (item == cur_text && !click) {
x = BOX_SPC + TEXT_SPC + FontWidth(xfs[f_input]) * abs_cursor - 1;
XDrawLine(dpy, item->header.win, gc_input,
x, BOX_SPC, x, dy - BOX_SPC);
}
break;
case I_CHOICE:
dx = dy = item->header.size_y - 1;
if (item->choice.on) {
XSetForeground(dpy, gc_button, colors[c_itemfore]);
if (item->choice.sel->select.key == IS_MULTIPLE) {
xsegs[0].x1 = 5, xsegs[0].y1 = 5;
xsegs[0].x2 = dx - 5, xsegs[0].y2 = dy - 5;
xsegs[1].x1 = 5, xsegs[1].y1 = dy - 5;
xsegs[1].x2 = dx - 5, xsegs[1].y2 = 5;
XDrawSegments(dpy, item->header.win, gc_button, xsegs, 2);
} else {
XDrawArc(dpy, item->header.win, gc_button,
5, 5, dx - 10, dy - 10, 0, 360 * 64);
}
} else
XClearWindow(dpy, item->header.win);
if (item->choice.on)
XSetForeground(dpy, gc_button, colors[c_itemlo]);
else
XSetForeground(dpy, gc_button, colors[c_itemhi]);
xsegs[0].x1 = 0, xsegs[0].y1 = 0;
xsegs[0].x2 = 0, xsegs[0].y2 = dy;
xsegs[1].x1 = 0, xsegs[1].y1 = 0;
xsegs[1].x2 = dx, xsegs[1].y2 = 0;
xsegs[2].x1 = 1, xsegs[2].y1 = 1;
xsegs[2].x2 = 1, xsegs[2].y2 = dy - 1;
xsegs[3].x1 = 1, xsegs[3].y1 = 1;
xsegs[3].x2 = dx - 1, xsegs[3].y2 = 1;
XDrawSegments(dpy, item->header.win, gc_button, xsegs, 4);
if (item->choice.on)
XSetForeground(dpy, gc_button, colors[c_itemhi]);
else
XSetForeground(dpy, gc_button, colors[c_itemlo]);
xsegs[0].x1 = 1, xsegs[0].y1 = dy;
xsegs[0].x2 = dx, xsegs[0].y2 = dy;
xsegs[1].x1 = 2, xsegs[1].y1 = dy - 1;
xsegs[1].x2 = dx, xsegs[1].y2 = dy - 1;
xsegs[2].x1 = dx, xsegs[2].y1 = 1;
xsegs[2].x2 = dx, xsegs[2].y2 = dy;
xsegs[3].x1 = dx - 1, xsegs[3].y1 = 2;
xsegs[3].x2 = dx - 1, xsegs[3].y2 = dy;
XDrawSegments(dpy, item->header.win, gc_button, xsegs, 4);
break;
case I_BUTTON:
dx = item->header.size_x - 1;
dy = item->header.size_y - 1;
if (click)
XSetForeground(dpy, gc_button, colors[c_itemlo]);
else
XSetForeground(dpy, gc_button, colors[c_itemhi]);
xsegs[0].x1 = 0, xsegs[0].y1 = 0;
xsegs[0].x2 = 0, xsegs[0].y2 = dy;
xsegs[1].x1 = 0, xsegs[1].y1 = 0;
xsegs[1].x2 = dx, xsegs[1].y2 = 0;
xsegs[2].x1 = 1, xsegs[2].y1 = 1;
xsegs[2].x2 = 1, xsegs[2].y2 = dy - 1;
xsegs[3].x1 = 1, xsegs[3].y1 = 1;
xsegs[3].x2 = dx - 1, xsegs[3].y2 = 1;
XDrawSegments(dpy, item->header.win, gc_button, xsegs, 4);
if (click)
XSetForeground(dpy, gc_button, colors[c_itemhi]);
else
XSetForeground(dpy, gc_button, colors[c_itemlo]);
xsegs[0].x1 = 1, xsegs[0].y1 = dy;
xsegs[0].x2 = dx, xsegs[0].y2 = dy;
xsegs[1].x1 = 2, xsegs[1].y1 = dy - 1;
xsegs[1].x2 = dx, xsegs[1].y2 = dy - 1;
xsegs[2].x1 = dx, xsegs[2].y1 = 1;
xsegs[2].x2 = dx, xsegs[2].y2 = dy;
xsegs[3].x1 = dx - 1, xsegs[3].y1 = 2;
xsegs[3].x2 = dx - 1, xsegs[3].y2 = dy;
XDrawSegments(dpy, item->header.win, gc_button, xsegs, 4);
XSetForeground(dpy, gc_button, colors[c_itemfore]);
XDrawImageString(dpy, item->header.win, gc_button,
BOX_SPC + TEXT_SPC,
BOX_SPC + TEXT_SPC + xfs[f_button]->ascent,
item->button.text, item->button.len);
break;
}
XFlush(dpy);
}
void ToggleChoice (Item *item)
{
int i;
Item *sel = item->choice.sel;
if (sel->select.key == IS_SINGLE) {
if (!item->choice.on) {
for (i = 0; i < sel->select.n; i++) {
if (sel->select.choices[i]->choice.on) {
sel->select.choices[i]->choice.on = 0;
RedrawItem(sel->select.choices[i], 0);
}
}
item->choice.on = 1;
RedrawItem(item, 0);
}
} else { /* IS_MULTIPLE */
item->choice.on = !item->choice.on;
RedrawItem(item, 0);
}
}
/* do var substitution for command string */
void ParseCommand (int dn, char *sp, char end, int *dn1, char **sp1)
#define AddChar(chr) { if (dn >= N) { N *= 2; buf = (char *)realloc(buf, N); } buf[dn++] = (chr); }
{
static char var[256];
char c, x, *wp, *cp, *vp;
int i, j, dn2;
Item *item;
while (1) {
c = *(sp++);
if (c == '\0' || c == end) { /* end of substitution */
*dn1 = dn;
*sp1 = sp;
return;
} if (c == '\\') { /* escape char */
AddChar('\\');
AddChar(*(sp++));
goto next_loop;
}
if (c == '$') { /* variable */
if (*sp != '(')
goto normal_char;
wp = ++sp;
vp = var;
while (1) {
x = *(sp++);
if (x == '\\') {
*(vp++) = '\\';
*(vp++) = *(sp++);
}
else if (x == ')' || x == '?' || x == '!') {
*(vp++) = '\0';
break;
}
else if (!isspace(x))
*(vp++) = x;
}
for (i = 0; i < n_items; i++) {
item = items + i;
if (strcmp(var, item->header.name) == 0) {
switch (item->type) {
case I_INPUT:
if (x == ')') {
for (cp = item->input.value; *cp != '\0'; cp++) {
if (*cp == '\"' || *cp == '\'' || *cp == '\\')
AddChar('\\');
AddChar(*cp);
}
} else {
ParseCommand(dn, sp, ')', &dn2, &sp);
if ((x == '?' && strlen(item->input.value) > 0) ||
(x == '!' && strlen(item->input.value) == 0))
dn = dn2;
}
break;
case I_CHOICE:
if (x == ')') {
for (cp = item->choice.value; *cp != '\0'; cp++)
AddChar(*cp);
} else {
ParseCommand(dn, sp, ')', &dn2, &sp);
if ((x == '?' && item->choice.on) ||
(x == '!' && !item->choice.on))
dn = dn2;
}
break;
case I_SELECT:
if (x != ')')
ParseCommand(dn, sp, ')', &dn2, &sp);
AddChar(' ');
for (j = 0; j < item->select.n; j++) {
if (item->select.choices[j]->choice.on) {
for (cp = item->select.choices[j]->choice.value;
*cp != '\0'; cp++)
AddChar(*cp);
AddChar(' ');
}
}
break;
}
goto next_loop;
}
}
goto next_loop;
}
normal_char:
AddChar(c);
next_loop:
;
}
}
/* execute a command */
void DoCommand (Item *cmd)
{
int i, k, dn, len;
char *sp;
/* pre-command */
if (cmd->button.key == IB_QUIT)
XWithdrawWindow(dpy, frame, screen);
for (k = 0; k < cmd->button.n; k++) {
/* construct command */
ParseCommand(0, cmd->button.commands[k], '\0', &dn, &sp);
AddChar('\0');
fprintf(fp_err, "Final command[%d]: [%s]\n", k, buf);
/* send command */
write(fd_out, &ref, sizeof(Window));
len = strlen(buf);
write(fd_out, &len, sizeof(int));
write(fd_out, buf, len);
len = 1;
write(fd_out, &len, sizeof(int));
}
/* post-command */
if (cmd->button.key == IB_QUIT) {
if (grab_server)
XUngrabServer(dpy);
exit(0);
}
if (cmd->button.key == IB_RESTART) {
Restart();
for (i = 0; i < n_items; i++) {
if (items[i].type == I_INPUT) {
XClearWindow(dpy, items[i].header.win);
RedrawItem(items + i, 0);
}
if (items[i].type == I_CHOICE)
RedrawItem(items + i, 0);
}
}
}
/* open the windows */
void OpenWindows ()
{
int i, x, y;
Item *item;
static XColor xcf, xcb;
static XSetWindowAttributes xswa;
static XGCValues xgcv;
static XWMHints wmh = { InputHint, True };
static XSizeHints sh = { PPosition | PSize | USPosition | USSize };
static int xgcv_mask = GCBackground | GCForeground | GCFont;
xc_ibeam = XCreateFontCursor(dpy, XC_xterm);
xc_hand = XCreateFontCursor(dpy, XC_hand2);
xcf.pixel = WhitePixel(dpy, screen);
XQueryColor(dpy, d_cmap, &xcf);
xcb.pixel = colors[c_itemback];
XQueryColor(dpy, d_cmap, &xcb);
XRecolorCursor(dpy, xc_ibeam, &xcf, &xcb);
/* the frame window first */
if (geom) {
if (gx >= 0)
x = gx;
else
x = DisplayWidth(dpy, screen) - max_width + gx;
if (gy >= 0)
y = gy;
else
y = DisplayHeight(dpy, screen) - total_height + gy;
} else {
x = (DisplayWidth(dpy, screen) - max_width) / 2;
y = (DisplayHeight(dpy, screen) - total_height) / 2;
}
frame = XCreateSimpleWindow(dpy, root, x, y, max_width, total_height,
0, BlackPixel(dpy, screen), colors[c_back]);
XSelectInput(dpy, frame, KeyPressMask | ExposureMask);
XStoreName(dpy, frame, prog_name);
XSetWMHints(dpy, frame, &wmh);
sh.x = x, sh.y = y;
sh.width = max_width, sh.height = total_height;
XSetWMNormalHints(dpy, frame, &sh);
xgcv.foreground = colors[c_fore];
xgcv.background = colors[c_back];
xgcv.font = fonts[f_text];
gc_text = XCreateGC(dpy, frame, xgcv_mask, &xgcv);
xgcv.background = colors[c_itemback];
xgcv.foreground = colors[c_itemfore];
xgcv.font = fonts[f_input];
gc_input = XCreateGC(dpy, frame, xgcv_mask, &xgcv);
xgcv.font = fonts[f_button];
gc_button = XCreateGC(dpy, frame, xgcv_mask, &xgcv);
for (i = 0; i < n_items; i++) {
item = items + i;
switch (item->type) {
case I_INPUT:
item->header.win =
XCreateSimpleWindow(dpy, frame,
item->header.pos_x, item->header.pos_y,
item->header.size_x, item->header.size_y,
0, colors[c_back], colors[c_itemback]);
XSelectInput(dpy, item->header.win, ButtonPressMask | ExposureMask);
xswa.cursor = xc_ibeam;
XChangeWindowAttributes(dpy, item->header.win, CWCursor, &xswa);
break;
case I_CHOICE:
item->header.win =
XCreateSimpleWindow(dpy, frame,
item->header.pos_x, item->header.pos_y,
item->header.size_y, item->header.size_y,
0, colors[c_back], colors[c_itemback]);
XSelectInput(dpy, item->header.win, ButtonPressMask | ExposureMask);
xswa.cursor = xc_hand;
XChangeWindowAttributes(dpy, item->header.win, CWCursor, &xswa);
break;
case I_BUTTON:
item->header.win =
XCreateSimpleWindow(dpy, frame,
item->header.pos_x, item->header.pos_y,
item->header.size_x, item->header.size_y,
0, colors[c_back], colors[c_itemback]);
XSelectInput(dpy, item->header.win,
ButtonPressMask | ExposureMask);
xswa.cursor = xc_hand;
XChangeWindowAttributes(dpy, item->header.win, CWCursor, &xswa);
break;
}
}
Restart();
XMapRaised(dpy, frame);
XMapSubwindows(dpy, frame);
if (warp_pointer) {
XWarpPointer(dpy, None, frame, 0, 0, 0, 0,
max_width / 2, total_height - 1);
}
DoCommand(&def_button);
}
/* read something from Fvwm */
void ReadFvwm ()
{
static char buffer[32];
int n;
n = read(fd_in, buffer, 32);
if (n == 0) {
if (grab_server)
XUngrabServer(dpy);
exit(0);
}
}
/* read an X event */
void ReadXServer ()
{
static XEvent event;
int i, old_cursor, keypress;
Item *item, *old_item;
KeySym ks;
char *sp, *dp, *ep;
static unsigned char buf[10], n;
while (XEventsQueued(dpy, QueuedAfterReading)) {
XNextEvent(dpy, &event);
if (event.xany.window == frame) {
switch (event.type) {
case Expose:
RedrawFrame();
if (grab_server && !server_grabbed) {
if (GrabSuccess ==
XGrabPointer(dpy, frame, True, 0, GrabModeAsync, GrabModeAsync,
None, None, CurrentTime))
server_grabbed = 1;
}
break;
case KeyPress: /* we do text input here */
n = XLookupString(&event.xkey, buf, 10, &ks, NULL);
keypress = buf[0];
fprintf(fp_err, "Keypress [%s]\n", buf);
if (n == 0) { /* not a regular key, translate it into one */
switch (ks) {
case XK_Home:
case XK_Begin:
buf[0] = '\001'; /* ^A */
break;
case XK_End:
buf[0] = '\005'; /* ^E */
break;
case XK_Left:
buf[0] = '\002'; /* ^B */
break;
case XK_Right:
buf[0] = '\006'; /* ^F */
break;
case XK_Up:
buf[0] = '\020'; /* ^P */
break;
case XK_Down:
buf[0] = '\016'; /* ^N */
break;
default:
if (ks >= XK_F1 && ks <= XK_F35) {
buf[0] = '\0';
keypress = 257 + ks - XK_F1;
} else
goto no_redraw; /* no action for this event */
}
}
if (!cur_text) { /* no text input fields */
for (i = 0; i < n_items; i++) {
item = items + i;
fprintf(fp_err, "Button[%d], keypress==%d\n", i,
item->button.keypress);
if (item->type == I_BUTTON && item->button.keypress == buf[0]) {
RedrawItem(item, 1);
sleep(1);
RedrawItem(item, 0);
DoCommand(item);
goto no_redraw;
}
}
break;
}
switch (buf[0]) {
case '\001': /* ^A */
old_cursor = abs_cursor;
rel_cursor = 0;
abs_cursor = 0;
cur_text->input.left = 0;
goto redraw_newcursor;
break;
case '\005': /* ^E */
old_cursor = abs_cursor;
rel_cursor = cur_text->input.n;
if ((cur_text->input.left = rel_cursor - cur_text->input.size) < 0)
cur_text->input.left = 0;
abs_cursor = rel_cursor - cur_text->input.left;
goto redraw_newcursor;
break;
case '\002': /* ^B */
old_cursor = abs_cursor;
if (rel_cursor > 0) {
rel_cursor--;
abs_cursor--;
if (abs_cursor <= 0 && rel_cursor > 0) {
abs_cursor++;
cur_text->input.left--;
}
}
goto redraw_newcursor;
break;
case '\006': /* ^F */
old_cursor = abs_cursor;
if (rel_cursor < cur_text->input.n) {
rel_cursor++;
abs_cursor++;
if (abs_cursor >= cur_text->input.size &&
rel_cursor < cur_text->input.n) {
abs_cursor--;
cur_text->input.left++;
}
}
goto redraw_newcursor;
break;
case '\010': /* ^H */
old_cursor = abs_cursor;
if (rel_cursor > 0) {
sp = cur_text->input.value + rel_cursor;
dp = sp - 1;
for (; *dp = *sp, *sp != '\0'; dp++, sp++);
cur_text->input.n--;
rel_cursor--;
if (rel_cursor < abs_cursor) {
abs_cursor--;
if (abs_cursor <= 0 && rel_cursor > 0) {
abs_cursor++;
cur_text->input.left--;
}
} else
cur_text->input.left--;
}
goto redraw_newcursor;
break;
case '\177': /* DEL */
case '\004': /* ^D */
if (rel_cursor < cur_text->input.n) {
sp = cur_text->input.value + rel_cursor + 1;
dp = sp - 1;
for (; *dp = *sp, *sp != '\0'; dp++, sp++);
cur_text->input.n--;
goto redraw;
}
break;
case '\013': /* ^K */
cur_text->input.value[rel_cursor] = '\0';
cur_text->input.n = rel_cursor;
goto redraw;
case '\025': /* ^U */
old_cursor = abs_cursor;
cur_text->input.value[0] = '\0';
cur_text->input.n = cur_text->input.left = 0;
rel_cursor = abs_cursor = 0;
goto redraw_newcursor;
case '\t':
case '\n':
case '\015':
case '\016': /* LINEFEED, TAB, RETURN, ^N, jump to the next field */
for (i = (cur_text - items) + 1; i < n_items; i++) {
item = items + i;
if (item->type == I_INPUT) {
old_item = cur_text;
old_item->input.o_cursor = rel_cursor;
cur_text = item;
RedrawItem(old_item, 1);
rel_cursor = item->input.o_cursor;
abs_cursor = rel_cursor - item->input.left;
goto redraw;
}
}
/* end of all text input fields, check for buttons */
for (i = 0; i < n_items; i++) {
item = items + i;
fprintf(fp_err, "Button[%d], keypress==%d\n", i,
item->button.keypress);
if (item->type == I_BUTTON && item->button.keypress == buf[0]) {
RedrawItem(item, 1);
sleep(1);
RedrawItem(item, 0);
DoCommand(item);
goto no_redraw;
}
}
/* goto the first text input field */
for (i = 0; i < n_items; i++) {
item = items + i;
if (item->type == I_INPUT) {
old_item = cur_text;
old_item->input.o_cursor = rel_cursor;
cur_text = item;
RedrawItem(old_item, 1);
rel_cursor = item->input.o_cursor;
abs_cursor = rel_cursor - item->input.left;
goto redraw;
}
}
break;
default:
old_cursor = abs_cursor;
if((buf[0] >= ' ' &&
buf[0] < '\177') ||
(buf[0] >= 160)) { /* regular or intl char */
if (++(cur_text->input.n) >= cur_text->input.buf) {
cur_text->input.buf += cur_text->input.size;
cur_text->input.value =
(char *)realloc(cur_text->input.value,
cur_text->input.buf);
}
dp = cur_text->input.value + cur_text->input.n;
sp = dp - 1;
ep = cur_text->input.value + rel_cursor;
for (; *dp = *sp, sp != ep; sp--, dp--);
*ep = buf[0];
rel_cursor++;
abs_cursor++;
if (abs_cursor >= cur_text->input.size) {
if (rel_cursor < cur_text->input.n)
abs_cursor = cur_text->input.size - 1;
else
abs_cursor = cur_text->input.size;
cur_text->input.left = rel_cursor - abs_cursor;
}
goto redraw_newcursor;
}
/* unrecognized key press, check for buttons */
for (i = 0; i < n_items; i++) {
item = items + i;
fprintf(fp_err, "Button[%d], keypress==%d\n", i,
item->button.keypress);
if (item->type == I_BUTTON && item->button.keypress == keypress) {
RedrawItem(item, 1);
sleep(1); /* .5 seconds */
RedrawItem(item, 0);
DoCommand(item);
goto no_redraw;
}
}
break;
}
redraw_newcursor:
{
int x, dy;
x = BOX_SPC + TEXT_SPC + FontWidth(xfs[f_input]) * old_cursor - 1;
dy = cur_text->header.size_y - 1;
XSetForeground(dpy, gc_button, colors[c_itemback]);
XDrawLine(dpy, cur_text->header.win, gc_button,
x, BOX_SPC, x, dy - BOX_SPC);
}
redraw:
{
int len, x, dy;
len = cur_text->input.n - cur_text->input.left;
if (len > cur_text->input.size)
len = cur_text->input.size;
else
XDrawImageString(dpy, cur_text->header.win, gc_input,
BOX_SPC + TEXT_SPC +
FontWidth(xfs[f_input]) * len,
BOX_SPC + TEXT_SPC + xfs[f_input]->ascent,
cur_text->input.blanks,
cur_text->input.size - len);
XDrawImageString(dpy, cur_text->header.win, gc_input,
BOX_SPC + TEXT_SPC,
BOX_SPC + TEXT_SPC + xfs[f_input]->ascent,
cur_text->input.value + cur_text->input.left, len);
x = BOX_SPC + TEXT_SPC + FontWidth(xfs[f_input]) * abs_cursor - 1;
dy = cur_text->header.size_y - 1;
XDrawLine(dpy, cur_text->header.win, gc_input,
x, BOX_SPC, x, dy - BOX_SPC);
}
no_redraw:
break; /* end of case KeyPress */
} /* end of switch (event.type) */
continue;
} /* end of if (event.xany.window == frame) */
for (i = 0; i < n_items; i++) {
item = items + i;
if (event.xany.window == item->header.win) {
switch (event.type) {
case Expose:
RedrawItem(item, 0);
break;
case ButtonPress:
if (item->type == I_INPUT) {
old_item = cur_text;
old_item->input.o_cursor = rel_cursor;
cur_text = item;
RedrawItem(old_item, 1);
abs_cursor = (event.xbutton.x - BOX_SPC -
TEXT_SPC + FontWidth(xfs[f_input]) / 2)
/ FontWidth(xfs[f_input]);
if (abs_cursor < 0)
abs_cursor = 0;
if (abs_cursor > item->input.size)
abs_cursor = item->input.size;
rel_cursor = abs_cursor + item->input.left;
if (rel_cursor < 0)
rel_cursor = 0;
if (rel_cursor > item->input.n)
rel_cursor = item->input.n;
if (rel_cursor > 0 && rel_cursor == item->input.left)
item->input.left--;
if (rel_cursor < item->input.n &&
rel_cursor == item->input.left + item->input.size)
item->input.left++;
abs_cursor = rel_cursor - item->input.left;
RedrawItem(item, 0);
}
if (item->type == I_CHOICE)
ToggleChoice(item);
if (item->type == I_BUTTON) {
RedrawItem(item, 1);
XGrabPointer(dpy, item->header.win, False, ButtonReleaseMask,
GrabModeAsync, GrabModeAsync,
None, None, CurrentTime);
}
break;
case ButtonRelease:
RedrawItem(item, 0);
if (grab_server && server_grabbed) {
XGrabPointer(dpy, frame, True, 0, GrabModeAsync, GrabModeAsync,
None, None, CurrentTime);
XFlush(dpy);
} else {
XUngrabPointer(dpy, CurrentTime);
XFlush(dpy);
}
if (event.xbutton.x >= 0 &&
event.xbutton.x < item->header.size_x &&
event.xbutton.y >= 0 &&
event.xbutton.y < item->header.size_y) {
DoCommand(item);
}
break;
}
}
} /* end of for (i = 0 */
} /* while loop */
}
/* main event loop */
void MainLoop ()
{
fd_set fds;
while (1) {
FD_ZERO(&fds);
FD_SET(fd_in, &fds);
FD_SET(fd_x, &fds);
XFlush(dpy);
if (select(32, &fds, NULL, NULL, NULL) > 0) {
if (FD_ISSET(fd_in, &fds))
ReadFvwm();
if (FD_ISSET(fd_x, &fds))
ReadXServer();
}
}
}
/* main procedure */
int main (int argc, char **argv)
{
FILE *fdopen();
int i;
buf = (char *)malloc(N); /* some kludge */
#ifdef DEBUG
fd_err = open(".FvwmFormErrors", O_WRONLY | O_CREAT, 0777);
fp_err = fdopen(fd_err, "w");
#else
fd_err = open("/dev/null", O_WRONLY, 0);
fp_err = fdopen(fd_err, "w");
#endif
/* we get rid of the path from program name */
prog_name = argv[0];
i = strlen(prog_name);
while (prog_name[--i] != '/' && i > 0);
if (i > 0)
prog_name = prog_name + (i + 1);
fprintf(fp_err, "%s started...\n", prog_name);
if (argc < 6) {
#ifndef DEBUG
fprintf(fp_err, "%s must be started by Fvwm.\n", prog_name);
exit(1);
#else
fd_out = 1;
fd_in = 0;
ref = None;
#endif
} else {
if(argc==7)
prog_name = argv[6];
fd_out = atoi(argv[1]);
fd_in = atoi(argv[2]);
ref = strtol(argv[4], NULL, 16);
if (ref == 0) ref = None;
#ifdef DEBUG
fprintf(fp_err, "ref == %d\n", ref);
#endif
}
fd[0]=fd_out;
fd[1]=fd_in;
if (!(dpy = XOpenDisplay(NULL))) {
fprintf(fp_err, "%s: can't open display.\n", prog_name);
exit(1);
}
fd_x = XConnectionNumber(dpy);
screen = DefaultScreen(dpy);
root = RootWindow(dpy, screen);
scr_depth = DefaultDepth(dpy, screen);
d_cmap = DefaultColormap(dpy, screen);
ReadConfig();
GetColors();
OpenWindows();
MainLoop();
return 0;
}
void DeadPipe(int nonsense)
{
exit(0);
}
Reference in New Issue Copy Permalink