rxvt-unicode/src/misc.C

/*--------------------------------*-C-*---------------------------------*
 * File:        misc.c
 *----------------------------------------------------------------------*
 * $Id: misc.C,v 1.2 2003/11/24 17:31:27 pcg Exp $
 *
 * All portions of code are copyright by their respective author/s.
 * Copyright (c) 1996      mj olesen <olesen@me.QueensU.CA> Queen's Univ at Kingston
 * Copyright (c) 1997,1998 Oezguer Kesim <kesim@math.fu-berlin.de>
 * Copyright (c) 1998-2000 Geoff Wing <gcw@pobox.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *----------------------------------------------------------------------*/

#include "../config.h"          /* NECESSARY */
#include "rxvt.h"               /* NECESSARY */
#include "misc.intpro"          /* PROTOS for internal routines */

/* EXTPROTO */
char *
rxvt_strdup (const char *str)
{
  return str ? strdup (str) : 0;
}

/* EXTPROTO */
char           *
rxvt_r_basename(const char *str)
{
    char           *base = STRRCHR(str, '/');

    return (char *)(base ? base + 1 : str);
}

/*
 * Print an error message
 */
/* EXTPROTO */
void
rxvt_print_error(const char *fmt,...)
{
    va_list         arg_ptr;

    va_start(arg_ptr, fmt);
    fprintf(stderr, APL_NAME ": ");
    vfprintf(stderr, fmt, arg_ptr);
    fprintf(stderr, "\n");
    va_end(arg_ptr);
}

/*
 * check that the first characters of S1 match S2
 *
 * No Match
 *      return: 0
 * Match
 *      return: STRLEN (S2)
 */
/* EXTPROTO */
int
rxvt_Str_match(const char *s1, const char *s2)
{
    int             n = STRLEN(s2);

    return ((STRNCMP(s1, s2, n) == 0) ? n : 0);
}

/* EXTPROTO */
const char     *
rxvt_Str_skip_space(const char *str)
{
    if (str)
        while (*str && isspace(*str))
            str++;
    return str;
}

/*
 * remove leading/trailing space and strip-off leading/trailing quotes.
 * in place.
 */
/* EXTPROTO */
char           *
rxvt_Str_trim(char *str)
{
    char           *r, *s;
    int             n;

    if (!str || !*str)          /* shortcut */
        return str;

/* skip leading spaces */
    for (s = str; *s && isspace(*s); s++) ;
/* goto end of string */
    for (n = 0, r = s; *r++; n++) ;
    r -= 2;
/* dump return */
    if (n > 0 && *r == '\n')
        n--, r--;
/* backtrack along trailing spaces */
    for (; n > 0 && isspace(*r); r--, n--) ;
/* skip matching leading/trailing quotes */
    if (*s == '"' && *r == '"' && n > 1) {
        s++;
        n -= 2;
    }
/* copy back over: forwards copy */
    for (r = str; n; n--)
        *r++ = *s++;
    *r = '\0';

    return str;
}

/*
 * in-place interpretation of string:
 *
 *      backslash-escaped:      "\a\b\E\e\n\r\t", "\octal"
 *      Ctrl chars:     ^@ .. ^_, ^?
 *
 *      Emacs-style:    "M-" prefix
 *
 * Also,
 *      "M-x" prefixed strings, append "\r" if needed
 *      "\E]" prefixed strings (XTerm escape sequence) append ST if needed
 *
 * returns the converted string length
 */
/* EXTPROTO */
int
rxvt_Str_escaped(char *str)
{
    char            ch, *s, *d;
    int             i, num, append = 0;

    if (!str || !*str)
        return 0;

    d = s = str;

    if (*s == 'M' && s[1] == '-') {
        /* Emacs convenience, replace leading `M-..' with `\E..' */
        *d++ = C0_ESC;
        s += 2;
        if (toupper(*s) == 'X')
            /* append carriage-return for `M-xcommand' */
            for (*d++ = 'x', append = '\r', s++; isspace(*s); s++) ;
    }
    for (; (ch = *s++);) {
        if (ch == '\\') {
            ch = *s++;
            if (ch >= '0' && ch <= '7') {       /* octal */
                num = ch - '0';
                for (i = 0; i < 2; i++, s++) {
                    ch = *s;
                    if (ch < '0' || ch > '7')
                        break;
                    num = num * 8 + ch - '0';
                }
                ch = (char)num;
            } else if (ch == 'a')
                ch = C0_BEL;    /* bell */
            else if (ch == 'b')
                ch = C0_BS;     /* backspace */
            else if (ch == 'E' || ch == 'e')
                ch = C0_ESC;    /* escape */
            else if (ch == 'n')
                ch = '\n';      /* newline */
            else if (ch == 'r')
                ch = '\r';      /* carriage-return */
            else if (ch == 't')
                ch = C0_HT;     /* tab */
        } else if (ch == '^') {
            ch = *s++;
            ch = toupper(ch);
            ch = (ch == '?' ? 127 : (ch - '@'));
        }
        *d++ = ch;
    }

/* ESC] is an XTerm escape sequence, must be terminated */
    if (*str == '\0' && str[1] == C0_ESC && str[2] == ']')
        append = CHAR_ST;

/* add trailing character as required */
    if (append && d[-1] != append)
        *d++ = append;
    *d = '\0';

    return (d - str);
}

/*
 * Split a comma-separated string into an array, stripping leading and
 * trailing spaces (and paired quotes) from each entry.  Empty strings
 * are properly returned
 * Caller should free each entry and array when done
 */
/* EXTPROTO */
char          **
rxvt_splitcommastring(const char *cs)
{
    int             l, n, p;
    const char     *s, *t;
    char          **ret;

    if ((s = cs) == NULL)
        s = "";

    for (n = 1, t = s; *t; t++)
        if (*t == ',')
            n++;
    ret = (char **)malloc((n + 1) * sizeof(char *));
    ret[n] = NULL;

    for (l = 0, t = s; l < n; l++) {
        for ( ; *t && *t != ','; t++) ;
        p = t - s;
        ret[l] = (char *)malloc(p + 1);
        strncpy(ret[l], s, p);
        ret[l][p] = '\0';
        rxvt_Str_trim(ret[l]);
        s = ++t;
    }
    return ret;
}

/*----------------------------------------------------------------------*
 * file searching
 */

/* #define DEBUG_SEARCH_PATH */

#if defined (XPM_BACKGROUND) || (MENUBAR_MAX)
/*
 * search for FILE in the current working directory, and within the
 * colon-delimited PATHLIST, adding the file extension EXT if required.
 *
 * FILE is either semi-colon or zero terminated
 */
/* INTPROTO */
char           *
rxvt_File_search_path(const char *pathlist, const char *file, const char *ext)
{
    int             maxpath, len;
    const char     *p, *path;
    char            name[256];

    if (!access(file, R_OK))    /* found (plain name) in current directory */
        return STRDUP(file);

/* semi-colon delimited */
    if ((p = STRCHR(file, ';')))
        len = (p - file);
    else
        len = STRLEN(file);

#ifdef DEBUG_SEARCH_PATH
    getcwd(name, sizeof(name));
    fprintf(stderr, "pwd: \"%s\"\n", name);
    fprintf(stderr, "find: \"%.*s\"\n", len, file);
#endif

/* leave room for an extra '/' and trailing '\0' */
    maxpath = sizeof(name) - (len + (ext ? STRLEN(ext) : 0) + 2);
    if (maxpath <= 0)
        return NULL;

/* check if we can find it now */
    STRNCPY(name, file, len);
    name[len] = '\0';

    if (!access(name, R_OK))
        return STRDUP(name);
    if (ext) {
        STRCAT(name, ext);
        if (!access(name, R_OK))
            return STRDUP(name);
    }
    for (path = pathlist; path != NULL && *path != '\0'; path = p) {
        int             n;

        /* colon delimited */
        if ((p = STRCHR(path, ':')) == NULL)
            p = STRCHR(path, '\0');

        n = (p - path);
        if (*p != '\0')
            p++;

        if (n > 0 && n <= maxpath) {
            STRNCPY(name, path, n);
            if (name[n - 1] != '/')
                name[n++] = '/';
            name[n] = '\0';
            STRNCAT(name, file, len);

            if (!access(name, R_OK))
                return STRDUP(name);
            if (ext) {
                STRCAT(name, ext);
                if (!access(name, R_OK))
                    return STRDUP(name);
            }
        }
    }
    return NULL;
}

/* EXTPROTO */
char           *
rxvt_File_find(const char *file, const char *ext, const char *path)
{
    char           *f;

    if (file == NULL || *file == '\0')
        return NULL;

/* search environment variables here too */
    if ((f = rxvt_File_search_path(path, file, ext)) == NULL)
#ifdef PATH_ENV
        if ((f = rxvt_File_search_path(getenv(PATH_ENV), file, ext)) == NULL)
#endif
            f = rxvt_File_search_path(getenv("PATH"), file, ext);

#ifdef DEBUG_SEARCH_PATH
    if (f)
        fprintf(stderr, "found: \"%s\"\n", f);
#endif

    return f;
}
#endif                          /* defined (XPM_BACKGROUND) || (MENUBAR_MAX) */

/*----------------------------------------------------------------------*
 * miscellaneous drawing routines
 */

/*
 * Draw top/left and bottom/right border shadows around windows
 */
#if defined(RXVT_SCROLLBAR) || defined(MENUBAR)
/* EXTPROTO */
void
rxvt_Draw_Shadow(Display *Xdisplay, Window win, GC topShadow, GC botShadow, int x, int y, int w, int h)
{
    int             shadow;

    shadow = (w == 0 || h == 0) ? 1 : SHADOW;
    w += x - 1;
    h += y - 1;
    for (; shadow-- > 0; x++, y++, w--, h--) {
        XDrawLine(Xdisplay, win, topShadow, x, y, w, y);
        XDrawLine(Xdisplay, win, topShadow, x, y, x, h);
        XDrawLine(Xdisplay, win, botShadow, w, h, w, y + 1);
        XDrawLine(Xdisplay, win, botShadow, w, h, x + 1, h);
    }
}
#endif

/* button shapes */
#ifdef MENUBAR
/* EXTPROTO */
void
rxvt_Draw_Triangle(Display *Xdisplay, Window win, GC topShadow, GC botShadow, int x, int y, int w, int type)
{
    switch (type) {
    case 'r':                   /* right triangle */
        XDrawLine(Xdisplay, win, topShadow, x, y, x, y + w);
        XDrawLine(Xdisplay, win, topShadow, x, y, x + w, y + w / 2);
        XDrawLine(Xdisplay, win, botShadow, x, y + w, x + w, y + w / 2);
        break;

    case 'l':                   /* left triangle */
        XDrawLine(Xdisplay, win, botShadow, x + w, y + w, x + w, y);
        XDrawLine(Xdisplay, win, botShadow, x + w, y + w, x, y + w / 2);
        XDrawLine(Xdisplay, win, topShadow, x, y + w / 2, x + w, y);
        break;

    case 'd':                   /* down triangle */
        XDrawLine(Xdisplay, win, topShadow, x, y, x + w / 2, y + w);
        XDrawLine(Xdisplay, win, topShadow, x, y, x + w, y);
        XDrawLine(Xdisplay, win, botShadow, x + w, y, x + w / 2, y + w);
        break;

    case 'u':                   /* up triangle */
        XDrawLine(Xdisplay, win, botShadow, x + w, y + w, x + w / 2, y);
        XDrawLine(Xdisplay, win, botShadow, x + w, y + w, x, y + w);
        XDrawLine(Xdisplay, win, topShadow, x, y + w, x + w / 2, y);
        break;
#if 0
    case 's':                   /* square */
        XDrawLine(Xdisplay, win, topShadow, x + w, y, x, y);
        XDrawLine(Xdisplay, win, topShadow, x, y, x, y + w);
        XDrawLine(Xdisplay, win, botShadow, x, y + w, x + w, y + w);
        XDrawLine(Xdisplay, win, botShadow, x + w, y + w, x + w, y);
        break;
#endif
    }
}
#endif
/*----------------------- end-of-file (C source) -----------------------*/
Revision:	1.3
Committed:	Sat Jan 31 00:20:21 2004 UTC (20 years, 5 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
Changes since 1.2:	+8 -1 lines
Log Message:	* empty log message *
#	Content
1	/---------------------------------C----------------------------------
2	* File: misc.c
3	----------------------------------------------------------------------
4	* $Id: misc.C,v 1.2 2003/11/24 17:31:27 pcg Exp $
5	*
6	* All portions of code are copyright by their respective author/s.
7	* Copyright (c) 1996 mj olesen <olesen@me.QueensU.CA> Queen's Univ at Kingston
8	* Copyright (c) 1997,1998 Oezguer Kesim <kesim@math.fu-berlin.de>
9	* Copyright (c) 1998-2000 Geoff Wing <gcw@pobox.com>
10	*
11	* This program is free software; you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; either version 2 of the License, or
14	* (at your option) any later version.
15	*
16	* This program is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.
20	*
21	* You should have received a copy of the GNU General Public License
22	* along with this program; if not, write to the Free Software
23	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24	----------------------------------------------------------------------/
25
26	#include "../config.h" /* NECESSARY */
27	#include "rxvt.h" /* NECESSARY */
28	#include "misc.intpro" /* PROTOS for internal routines */
29
30	/* EXTPROTO */
31	char *
32	rxvt_strdup (const char *str)
33	{
34	return str ? strdup (str) : 0;
35	}
36
37	/* EXTPROTO */
38	char *
39	rxvt_r_basename(const char *str)
40	{
41	char *base = STRRCHR(str, '/');
42
43	return (char *)(base ? base + 1 : str);
44	}
45
46	/*
47	* Print an error message
48	*/
49	/* EXTPROTO */
50	void
51	rxvt_print_error(const char *fmt,...)
52	{
53	va_list arg_ptr;
54
55	va_start(arg_ptr, fmt);
56	fprintf(stderr, APL_NAME ": ");
57	vfprintf(stderr, fmt, arg_ptr);
58	fprintf(stderr, "\n");
59	va_end(arg_ptr);
60	}
61
62	/*
63	* check that the first characters of S1 match S2
64	*
65	* No Match
66	* return: 0
67	* Match
68	* return: STRLEN (S2)
69	*/
70	/* EXTPROTO */
71	int
72	rxvt_Str_match(const char s1, const char s2)
73	{
74	int n = STRLEN(s2);
75
76	return ((STRNCMP(s1, s2, n) == 0) ? n : 0);
77	}
78
79	/* EXTPROTO */
80	const char *
81	rxvt_Str_skip_space(const char *str)
82	{
83	if (str)
84	while (str && isspace(str))
85	str++;
86	return str;
87	}
88
89	/*
90	* remove leading/trailing space and strip-off leading/trailing quotes.
91	* in place.
92	*/
93	/* EXTPROTO */
94	char *
95	rxvt_Str_trim(char *str)
96	{
97	char r, s;
98	int n;
99
100	if (!str \|\| !str) / shortcut */
101	return str;
102
103	/* skip leading spaces */
104	for (s = str; s && isspace(s); s++) ;
105	/* goto end of string */
106	for (n = 0, r = s; *r++; n++) ;
107	r -= 2;
108	/* dump return */
109	if (n > 0 && *r == '\n')
110	n--, r--;
111	/* backtrack along trailing spaces */
112	for (; n > 0 && isspace(*r); r--, n--) ;
113	/* skip matching leading/trailing quotes */
114	if (s == '"' && r == '"' && n > 1) {
115	s++;
116	n -= 2;
117	}
118	/* copy back over: forwards copy */
119	for (r = str; n; n--)
120	r++ = s++;
121	*r = '\0';
122
123	return str;
124	}
125
126	/*
127	* in-place interpretation of string:
128	*
129	* backslash-escaped: "\a\b\E\e\n\r\t", "\octal"
130	* Ctrl chars: ^@ .. ^_, ^?
131	*
132	* Emacs-style: "M-" prefix
133	*
134	* Also,
135	* "M-x" prefixed strings, append "\r" if needed
136	* "\E]" prefixed strings (XTerm escape sequence) append ST if needed
137	*
138	* returns the converted string length
139	*/
140	/* EXTPROTO */
141	int
142	rxvt_Str_escaped(char *str)
143	{
144	char ch, s, d;
145	int i, num, append = 0;
146
147	if (!str \|\| !*str)
148	return 0;
149
150	d = s = str;
151
152	if (*s == 'M' && s[1] == '-') {
153	/* Emacs convenience, replace leading `M-..' with `\E..' */
154	*d++ = C0_ESC;
155	s += 2;
156	if (toupper(*s) == 'X')
157	/* append carriage-return for `M-xcommand' */
158	for (d++ = 'x', append = '\r', s++; isspace(s); s++) ;
159	}
160	for (; (ch = *s++);) {
161	if (ch == '\\') {
162	ch = *s++;
163	if (ch >= '0' && ch <= '7') { /* octal */
164	num = ch - '0';
165	for (i = 0; i < 2; i++, s++) {
166	ch = *s;
167	if (ch < '0' \|\| ch > '7')
168	break;
169	num = num * 8 + ch - '0';
170	}
171	ch = (char)num;
172	} else if (ch == 'a')
173	ch = C0_BEL; /* bell */
174	else if (ch == 'b')
175	ch = C0_BS; /* backspace */
176	else if (ch == 'E' \|\| ch == 'e')
177	ch = C0_ESC; /* escape */
178	else if (ch == 'n')
179	ch = '\n'; /* newline */
180	else if (ch == 'r')
181	ch = '\r'; /* carriage-return */
182	else if (ch == 't')
183	ch = C0_HT; /* tab */
184	} else if (ch == '^') {
185	ch = *s++;
186	ch = toupper(ch);
187	ch = (ch == '?' ? 127 : (ch - '@'));
188	}
189	*d++ = ch;
190	}
191
192	/* ESC] is an XTerm escape sequence, must be terminated */
193	if (*str == '\0' && str[1] == C0_ESC && str[2] == ']')
194	append = CHAR_ST;
195
196	/* add trailing character as required */
197	if (append && d[-1] != append)
198	*d++ = append;
199	*d = '\0';
200
201	return (d - str);
202	}
203
204	/*
205	* Split a comma-separated string into an array, stripping leading and
206	* trailing spaces (and paired quotes) from each entry. Empty strings
207	* are properly returned
208	* Caller should free each entry and array when done
209	*/
210	/* EXTPROTO */
211	char **
212	rxvt_splitcommastring(const char *cs)
213	{
214	int l, n, p;
215	const char s, t;
216	char **ret;
217
218	if ((s = cs) == NULL)
219	s = "";
220
221	for (n = 1, t = s; *t; t++)
222	if (*t == ',')
223	n++;
224	ret = (char *)malloc((n + 1) sizeof(char *));
225	ret[n] = NULL;
226
227	for (l = 0, t = s; l < n; l++) {
228	for ( ; t && t != ','; t++) ;
229	p = t - s;
230	ret[l] = (char *)malloc(p + 1);
231	strncpy(ret[l], s, p);
232	ret[l][p] = '\0';
233	rxvt_Str_trim(ret[l]);
234	s = ++t;
235	}
236	return ret;
237	}
238
239	/----------------------------------------------------------------------
240	* file searching
241	*/
242
243	/* #define DEBUG_SEARCH_PATH */
244
245	#if defined (XPM_BACKGROUND) \|\| (MENUBAR_MAX)
246	/*
247	* search for FILE in the current working directory, and within the
248	* colon-delimited PATHLIST, adding the file extension EXT if required.
249	*
250	* FILE is either semi-colon or zero terminated
251	*/
252	/* INTPROTO */
253	char *
254	rxvt_File_search_path(const char pathlist, const char file, const char *ext)
255	{
256	int maxpath, len;
257	const char p, path;
258	char name[256];
259
260	if (!access(file, R_OK)) /* found (plain name) in current directory */
261	return STRDUP(file);
262
263	/* semi-colon delimited */
264	if ((p = STRCHR(file, ';')))
265	len = (p - file);
266	else
267	len = STRLEN(file);
268
269	#ifdef DEBUG_SEARCH_PATH
270	getcwd(name, sizeof(name));
271	fprintf(stderr, "pwd: \"%s\"\n", name);
272	fprintf(stderr, "find: \"%.*s\"\n", len, file);
273	#endif
274
275	/* leave room for an extra '/' and trailing '\0' */
276	maxpath = sizeof(name) - (len + (ext ? STRLEN(ext) : 0) + 2);
277	if (maxpath <= 0)
278	return NULL;
279
280	/* check if we can find it now */
281	STRNCPY(name, file, len);
282	name[len] = '\0';
283
284	if (!access(name, R_OK))
285	return STRDUP(name);
286	if (ext) {
287	STRCAT(name, ext);
288	if (!access(name, R_OK))
289	return STRDUP(name);
290	}
291	for (path = pathlist; path != NULL && *path != '\0'; path = p) {
292	int n;
293
294	/* colon delimited */
295	if ((p = STRCHR(path, ':')) == NULL)
296	p = STRCHR(path, '\0');
297
298	n = (p - path);
299	if (*p != '\0')
300	p++;
301
302	if (n > 0 && n <= maxpath) {
303	STRNCPY(name, path, n);
304	if (name[n - 1] != '/')
305	name[n++] = '/';
306	name[n] = '\0';
307	STRNCAT(name, file, len);
308
309	if (!access(name, R_OK))
310	return STRDUP(name);
311	if (ext) {
312	STRCAT(name, ext);
313	if (!access(name, R_OK))
314	return STRDUP(name);
315	}
316	}
317	}
318	return NULL;
319	}
320
321	/* EXTPROTO */
322	char *
323	rxvt_File_find(const char file, const char ext, const char *path)
324	{
325	char *f;
326
327	if (file == NULL \|\| *file == '\0')
328	return NULL;
329
330	/* search environment variables here too */
331	if ((f = rxvt_File_search_path(path, file, ext)) == NULL)
332	#ifdef PATH_ENV
333	if ((f = rxvt_File_search_path(getenv(PATH_ENV), file, ext)) == NULL)
334	#endif
335	f = rxvt_File_search_path(getenv("PATH"), file, ext);
336
337	#ifdef DEBUG_SEARCH_PATH
338	if (f)
339	fprintf(stderr, "found: \"%s\"\n", f);
340	#endif
341
342	return f;
343	}
344	#endif /* defined (XPM_BACKGROUND) \|\| (MENUBAR_MAX) */
345
346	/----------------------------------------------------------------------
347	* miscellaneous drawing routines
348	*/
349
350	/*
351	* Draw top/left and bottom/right border shadows around windows
352	*/
353	#if defined(RXVT_SCROLLBAR) \|\| defined(MENUBAR)
354	/* EXTPROTO */
355	void
356	rxvt_Draw_Shadow(Display *Xdisplay, Window win, GC topShadow, GC botShadow, int x, int y, int w, int h)
357	{
358	int shadow;
359
360	shadow = (w == 0 \|\| h == 0) ? 1 : SHADOW;
361	w += x - 1;
362	h += y - 1;
363	for (; shadow-- > 0; x++, y++, w--, h--) {
364	XDrawLine(Xdisplay, win, topShadow, x, y, w, y);
365	XDrawLine(Xdisplay, win, topShadow, x, y, x, h);
366	XDrawLine(Xdisplay, win, botShadow, w, h, w, y + 1);
367	XDrawLine(Xdisplay, win, botShadow, w, h, x + 1, h);
368	}
369	}
370	#endif
371
372	/* button shapes */
373	#ifdef MENUBAR
374	/* EXTPROTO */
375	void
376	rxvt_Draw_Triangle(Display *Xdisplay, Window win, GC topShadow, GC botShadow, int x, int y, int w, int type)
377	{
378	switch (type) {
379	case 'r': /* right triangle */
380	XDrawLine(Xdisplay, win, topShadow, x, y, x, y + w);
381	XDrawLine(Xdisplay, win, topShadow, x, y, x + w, y + w / 2);
382	XDrawLine(Xdisplay, win, botShadow, x, y + w, x + w, y + w / 2);
383	break;
384
385	case 'l': /* left triangle */
386	XDrawLine(Xdisplay, win, botShadow, x + w, y + w, x + w, y);
387	XDrawLine(Xdisplay, win, botShadow, x + w, y + w, x, y + w / 2);
388	XDrawLine(Xdisplay, win, topShadow, x, y + w / 2, x + w, y);
389	break;
390
391	case 'd': /* down triangle */
392	XDrawLine(Xdisplay, win, topShadow, x, y, x + w / 2, y + w);
393	XDrawLine(Xdisplay, win, topShadow, x, y, x + w, y);
394	XDrawLine(Xdisplay, win, botShadow, x + w, y, x + w / 2, y + w);
395	break;
396
397	case 'u': /* up triangle */
398	XDrawLine(Xdisplay, win, botShadow, x + w, y + w, x + w / 2, y);
399	XDrawLine(Xdisplay, win, botShadow, x + w, y + w, x, y + w);
400	XDrawLine(Xdisplay, win, topShadow, x, y + w, x + w / 2, y);
401	break;
402	#if 0
403	case 's': /* square */
404	XDrawLine(Xdisplay, win, topShadow, x + w, y, x, y);
405	XDrawLine(Xdisplay, win, topShadow, x, y, x, y + w);
406	XDrawLine(Xdisplay, win, botShadow, x, y + w, x + w, y + w);
407	XDrawLine(Xdisplay, win, botShadow, x + w, y + w, x + w, y);
408	break;
409	#endif
410	}
411	}
412	#endif
413	/----------------------- end-of-file (C source) -----------------------/