rxvt-unicode/src/misc.C

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