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, 3 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
Changes since 1.2:	+8 -1 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	pcg	1.1	/---------------------------------C----------------------------------
2			* File: misc.c
3			----------------------------------------------------------------------
4	pcg	1.3	* $Id: misc.C,v 1.2 2003/11/24 17:31:27 pcg Exp $
5	pcg	1.1	*
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	pcg	1.3	char *
32			rxvt_strdup (const char *str)
33			{
34			return str ? strdup (str) : 0;
35			}
36
37			/* EXTPROTO */
38	pcg	1.1	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) -----------------------/