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 *
#	User	Rev	Content
1	pcg	1.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	pcg	1.3	char *
31			rxvt_strdup (const char *str)
32			{
33			return str ? strdup (str) : 0;
34			}
35
36			/* EXTPROTO */
37	pcg	1.1	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) -----------------------/