rxvt-unicode/src/misc.C

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