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>
 * Copyright (c) 2003-2004 Marc Lehmann <pcg@goof.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 */

/* INTPROTO */
char *
rxvt_wcstombs (const wchar_t *str, int len)
{
  mbstate mbs;
  char *r = (char *)rxvt_malloc (len * MB_CUR_MAX + 1);

  char *dst = r;
  while (len--)
    {
      int l = wcrtomb (dst, *str++, mbs);
      if (l < 0)
        *dst++ = '?';
      else
        dst += l;
    }

  *dst++ = 0;

  return r;
}

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

/* INTPROTO */
char *
rxvt_r_basename (const char *str)
{
  char *base = strrchr (str, '/');

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

/*
 * Print an error message
 */
/* INTPROTO */
void
rxvt_vlog (const char *fmt, va_list arg_ptr)
{
  char msg[1024];

  vsnprintf (msg, sizeof msg, fmt, arg_ptr);

  if (GET_R && GET_R->log_hook)
    (*GET_R->log_hook) (msg);
  else
    write (STDOUT_FILENO, msg, strlen (msg));
}

/* INTPROTO */
void
rxvt_log (const char *fmt,...)
{
  va_list arg_ptr;

  va_start (arg_ptr, fmt);
  rxvt_vlog (fmt, arg_ptr);
  va_end (arg_ptr);
}

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

  rxvt_log ("%s: ", RESNAME);

  va_start (arg_ptr, fmt);
  rxvt_vlog (fmt, arg_ptr);
  va_end (arg_ptr);
}

/* INTPROTO */
void
rxvt_fatal (const char *fmt,...)
{
  va_list arg_ptr;

  rxvt_log ("%s: ", RESNAME);

  va_start (arg_ptr, fmt);
  rxvt_vlog (fmt, arg_ptr);
  va_end (arg_ptr);

  rxvt_exit_failure ();
}

class rxvt_failure_exception rxvt_failure_exception;

/* INTPROTO */
void
rxvt_exit_failure ()
{
  throw (rxvt_failure_exception);
}

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

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

/* INTPROTO */
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.
 */
/* INTPROTO */
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
 */
/* INTPROTO */
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
 */
/* INTPROTO */
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;
}

void
rxvt_freecommastring (char **cs)
{
  for (int i = 0; cs[i]; ++i)
    free (cs[i]);

  free (cs);
}

/*----------------------------------------------------------------------*
 * 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;
}

/* INTPROTO */
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)
/* INTPROTO */
void
rxvt_Draw_Shadow (Display *display, 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 (display, win, topShadow, x, y, w, y);
      XDrawLine (display, win, topShadow, x, y, x, h);
      XDrawLine (display, win, botShadow, w, h, w, y + 1);
      XDrawLine (display, win, botShadow, w, h, x + 1, h);
    }
}
#endif

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

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

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

      case 'u':                 /* up triangle */
        XDrawLine (display, win, botShadow, x + w, y + w, x + w / 2, y);
        XDrawLine (display, win, botShadow, x + w, y + w, x, y + w);
        XDrawLine (display, win, topShadow, x, y + w, x + w / 2, y);
        break;
#if 0
      case 's':                 /* square */
        XDrawLine (display, win, topShadow, x + w, y, x, y);
        XDrawLine (display, win, topShadow, x, y, x, y + w);
        XDrawLine (display, win, botShadow, x, y + w, x + w, y + w);
        XDrawLine (display, win, botShadow, x + w, y + w, x + w, y);
        break;
#endif

    }
}
#endif
/*----------------------- end-of-file (C source) -----------------------*/
Revision:	1.16
Committed:	Sun Nov 21 19:04:07 2004 UTC (19 years, 6 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-4_1, rel-4_2, rel-4_3
Changes since 1.15:	+9 -0 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	* Copyright (c) 2003-2004 Marc Lehmann <pcg@goof.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	/* INTPROTO */
31	char *
32	rxvt_wcstombs (const wchar_t *str, int len)
33	{
34	mbstate mbs;
35	char r = (char )rxvt_malloc (len * MB_CUR_MAX + 1);
36
37	char *dst = r;
38	while (len--)
39	{
40	int l = wcrtomb (dst, *str++, mbs);
41	if (l < 0)
42	*dst++ = '?';
43	else
44	dst += l;
45	}
46
47	*dst++ = 0;
48
49	return r;
50	}
51
52	/* INTPROTO */
53	char *
54	rxvt_strdup (const char *str)
55	{
56	return str ? strdup (str) : 0;
57	}
58
59	/* INTPROTO */
60	char *
61	rxvt_r_basename (const char *str)
62	{
63	char *base = strrchr (str, '/');
64
65	return (char *) (base ? base + 1 : str);
66	}
67
68	/*
69	* Print an error message
70	*/
71	/* INTPROTO */
72	void
73	rxvt_vlog (const char *fmt, va_list arg_ptr)
74	{
75	char msg[1024];
76
77	vsnprintf (msg, sizeof msg, fmt, arg_ptr);
78
79	if (GET_R && GET_R->log_hook)
80	(*GET_R->log_hook) (msg);
81	else
82	write (STDOUT_FILENO, msg, strlen (msg));
83	}
84
85	/* INTPROTO */
86	void
87	rxvt_log (const char *fmt,...)
88	{
89	va_list arg_ptr;
90
91	va_start (arg_ptr, fmt);
92	rxvt_vlog (fmt, arg_ptr);
93	va_end (arg_ptr);
94	}
95
96	/*
97	* Print an error message
98	*/
99	/* INTPROTO */
100	void
101	rxvt_warn (const char *fmt,...)
102	{
103	va_list arg_ptr;
104
105	rxvt_log ("%s: ", RESNAME);
106
107	va_start (arg_ptr, fmt);
108	rxvt_vlog (fmt, arg_ptr);
109	va_end (arg_ptr);
110	}
111
112	/* INTPROTO */
113	void
114	rxvt_fatal (const char *fmt,...)
115	{
116	va_list arg_ptr;
117
118	rxvt_log ("%s: ", RESNAME);
119
120	va_start (arg_ptr, fmt);
121	rxvt_vlog (fmt, arg_ptr);
122	va_end (arg_ptr);
123
124	rxvt_exit_failure ();
125	}
126
127	class rxvt_failure_exception rxvt_failure_exception;
128
129	/* INTPROTO */
130	void
131	rxvt_exit_failure ()
132	{
133	throw (rxvt_failure_exception);
134	}
135
136	/*
137	* check that the first characters of S1 match S2
138	*
139	* No Match
140	* return: 0
141	* Match
142	* return: strlen (S2)
143	*/
144	/* INTPROTO */
145	int
146	rxvt_Str_match (const char s1, const char s2)
147	{
148	int n = strlen (s2);
149
150	return ((strncmp (s1, s2, n) == 0) ? n : 0);
151	}
152
153	/* INTPROTO */
154	const char *
155	rxvt_Str_skip_space (const char *str)
156	{
157	if (str)
158	while (str && isspace (str))
159	str++;
160
161	return str;
162	}
163
164	/*
165	* remove leading/trailing space and strip-off leading/trailing quotes.
166	* in place.
167	*/
168	/* INTPROTO */
169	char *
170	rxvt_Str_trim (char *str)
171	{
172	char r, s;
173	int n;
174
175	if (!str \|\| !str) / shortcut */
176	return str;
177
178	/* skip leading spaces */
179	for (s = str; s && isspace (s); s++) ;
180	/* goto end of string */
181	for (n = 0, r = s; *r++; n++) ;
182	r -= 2;
183	/* dump return */
184	if (n > 0 && *r == '\n')
185	n--, r--;
186	/* backtrack along trailing spaces */
187	for (; n > 0 && isspace (*r); r--, n--) ;
188	/* skip matching leading/trailing quotes */
189	if (s == '"' && r == '"' && n > 1)
190	{
191	s++;
192	n -= 2;
193	}
194
195	/* copy back over: forwards copy */
196	for (r = str; n; n--)
197	r++ = s++;
198	*r = '\0';
199
200	return str;
201	}
202
203	/*
204	* in-place interpretation of string:
205	*
206	* backslash-escaped: "\a\b\E\e\n\r\t", "\octal"
207	* Ctrl chars: ^@ .. ^_, ^?
208	*
209	* Emacs-style: "M-" prefix
210	*
211	* Also,
212	* "M-x" prefixed strings, append "\r" if needed
213	* "\E]" prefixed strings (XTerm escape sequence) append ST if needed
214	*
215	* returns the converted string length
216	*/
217	/* INTPROTO */
218	int
219	rxvt_Str_escaped (char *str)
220	{
221	char ch, s, d;
222	int i, num, append = 0;
223
224	if (!str \|\| !*str)
225	return 0;
226
227	d = s = str;
228
229	if (*s == 'M' && s[1] == '-')
230	{
231	/* Emacs convenience, replace leading `M-..' with `\E..' */
232	*d++ = C0_ESC;
233	s += 2;
234	if (toupper (*s) == 'X')
235	/* append carriage-return for `M-xcommand' */
236	for (d++ = 'x', append = '\r', s++; isspace (s); s++) ;
237	}
238	for (; (ch = *s++);)
239	{
240	if (ch == '\\')
241	{
242	ch = *s++;
243	if (ch >= '0' && ch <= '7')
244	{ /* octal */
245	num = ch - '0';
246	for (i = 0; i < 2; i++, s++)
247	{
248	ch = *s;
249	if (ch < '0' \|\| ch > '7')
250	break;
251	num = num * 8 + ch - '0';
252	}
253	ch = (char)num;
254	}
255	else if (ch == 'a')
256	ch = C0_BEL; /* bell */
257	else if (ch == 'b')
258	ch = C0_BS; /* backspace */
259	else if (ch == 'E' \|\| ch == 'e')
260	ch = C0_ESC; /* escape */
261	else if (ch == 'n')
262	ch = '\n'; /* newline */
263	else if (ch == 'r')
264	ch = '\r'; /* carriage-return */
265	else if (ch == 't')
266	ch = C0_HT; /* tab */
267	}
268	else if (ch == '^')
269	{
270	ch = *s++;
271	ch = toupper (ch);
272	ch = (ch == '?' ? 127 : (ch - '@'));
273	}
274	*d++ = ch;
275	}
276
277	/* ESC] is an XTerm escape sequence, must be terminated */
278	if (*str == '\0' && str[1] == C0_ESC && str[2] == ']')
279	append = CHAR_ST;
280
281	/* add trailing character as required */
282	if (append && d[-1] != append)
283	*d++ = append;
284	*d = '\0';
285
286	return (d - str);
287	}
288
289	/*
290	* Split a comma-separated string into an array, stripping leading and
291	* trailing spaces (and paired quotes) from each entry. Empty strings
292	* are properly returned
293	* Caller should free each entry and array when done
294	*/
295	/* INTPROTO */
296	char **
297	rxvt_splitcommastring (const char *cs)
298	{
299	int l, n, p;
300	const char s, t;
301	char **ret;
302
303	if ((s = cs) == NULL)
304	s = "";
305
306	for (n = 1, t = s; *t; t++)
307	if (*t == ',')
308	n++;
309	ret = (char *)malloc ((n + 1) sizeof (char *));
310	ret[n] = NULL;
311
312	for (l = 0, t = s; l < n; l++)
313	{
314	for ( ; t && t != ','; t++) ;
315	p = t - s;
316	ret[l] = (char *)malloc (p + 1);
317	strncpy (ret[l], s, p);
318	ret[l][p] = '\0';
319	rxvt_Str_trim (ret[l]);
320	s = ++t;
321	}
322	return ret;
323	}
324
325	void
326	rxvt_freecommastring (char **cs)
327	{
328	for (int i = 0; cs[i]; ++i)
329	free (cs[i]);
330
331	free (cs);
332	}
333
334	/----------------------------------------------------------------------
335	* file searching
336	*/
337
338	/* #define DEBUG_SEARCH_PATH */
339
340	#if defined (XPM_BACKGROUND) \|\| (MENUBAR_MAX)
341	/*
342	* search for FILE in the current working directory, and within the
343	* colon-delimited PATHLIST, adding the file extension EXT if required.
344	*
345	* FILE is either semi-colon or zero terminated
346	*/
347	/* INTPROTO */
348	char *
349	rxvt_File_search_path (const char pathlist, const char file, const char *ext)
350	{
351	int maxpath, len;
352	const char p, path;
353	char name[256];
354
355	if (!access (file, R_OK)) /* found (plain name) in current directory */
356	return strdup (file);
357
358	/* semi-colon delimited */
359	if ((p = strchr (file, ';')))
360	len = (p - file);
361	else
362	len = strlen (file);
363
364	#ifdef DEBUG_SEARCH_PATH
365	getcwd (name, sizeof (name));
366	fprintf (stderr, "pwd: \"%s\"\n", name);
367	fprintf (stderr, "find: \"%.*s\"\n", len, file);
368	#endif
369
370	/* leave room for an extra '/' and trailing '\0' */
371	maxpath = sizeof (name) - (len + (ext ? strlen (ext) : 0) + 2);
372	if (maxpath <= 0)
373	return NULL;
374
375	/* check if we can find it now */
376	strncpy (name, file, len);
377	name[len] = '\0';
378
379	if (!access (name, R_OK))
380	return strdup (name);
381	if (ext)
382	{
383	strcat (name, ext);
384	if (!access (name, R_OK))
385	return strdup (name);
386	}
387	for (path = pathlist; path != NULL && *path != '\0'; path = p)
388	{
389	int n;
390
391	/* colon delimited */
392	if ((p = strchr (path, ':')) == NULL)
393	p = strchr (path, '\0');
394
395	n = (p - path);
396	if (*p != '\0')
397	p++;
398
399	if (n > 0 && n <= maxpath)
400	{
401	strncpy (name, path, n);
402	if (name[n - 1] != '/')
403	name[n++] = '/';
404	name[n] = '\0';
405	strncat (name, file, len);
406
407	if (!access (name, R_OK))
408	return strdup (name);
409	if (ext)
410	{
411	strcat (name, ext);
412	if (!access (name, R_OK))
413	return strdup (name);
414	}
415	}
416	}
417	return NULL;
418	}
419
420	/* INTPROTO */
421	char *
422	rxvt_File_find (const char file, const char ext, const char *path)
423	{
424	char *f;
425
426	if (file == NULL \|\| *file == '\0')
427	return NULL;
428
429	/* search environment variables here too */
430	if ((f = rxvt_File_search_path (path, file, ext)) == NULL)
431	#ifdef PATH_ENV
432	if ((f = rxvt_File_search_path (getenv (PATH_ENV), file, ext)) == NULL)
433	#endif
434	f = rxvt_File_search_path (getenv ("PATH"), file, ext);
435
436	#ifdef DEBUG_SEARCH_PATH
437	if (f)
438	fprintf (stderr, "found: \"%s\"\n", f);
439	#endif
440
441	return f;
442	}
443	#endif /* defined (XPM_BACKGROUND) \|\| (MENUBAR_MAX) */
444
445	/----------------------------------------------------------------------
446	* miscellaneous drawing routines
447	*/
448
449	/*
450	* Draw top/left and bottom/right border shadows around windows
451	*/
452	#if defined(RXVT_SCROLLBAR) \|\| defined(MENUBAR)
453	/* INTPROTO */
454	void
455	rxvt_Draw_Shadow (Display *display, Window win, GC topShadow, GC botShadow, int x, int y, int w, int h)
456	{
457	int shadow;
458
459	shadow = (w == 0 \|\| h == 0) ? 1 : SHADOW;
460	w += x - 1;
461	h += y - 1;
462	for (; shadow-- > 0; x++, y++, w--, h--)
463	{
464	XDrawLine (display, win, topShadow, x, y, w, y);
465	XDrawLine (display, win, topShadow, x, y, x, h);
466	XDrawLine (display, win, botShadow, w, h, w, y + 1);
467	XDrawLine (display, win, botShadow, w, h, x + 1, h);
468	}
469	}
470	#endif
471
472	/* button shapes */
473	#ifdef MENUBAR
474	/* INTPROTO */
475	void
476	rxvt_Draw_Triangle (Display *display, Window win, GC topShadow, GC botShadow, int x, int y, int w, int type)
477	{
478	switch (type)
479	{
480	case 'r': /* right triangle */
481	XDrawLine (display, win, topShadow, x, y, x, y + w);
482	XDrawLine (display, win, topShadow, x, y, x + w, y + w / 2);
483	XDrawLine (display, win, botShadow, x, y + w, x + w, y + w / 2);
484	break;
485
486	case 'l': /* left triangle */
487	XDrawLine (display, win, botShadow, x + w, y + w, x + w, y);
488	XDrawLine (display, win, botShadow, x + w, y + w, x, y + w / 2);
489	XDrawLine (display, win, topShadow, x, y + w / 2, x + w, y);
490	break;
491
492	case 'd': /* down triangle */
493	XDrawLine (display, win, topShadow, x, y, x + w / 2, y + w);
494	XDrawLine (display, win, topShadow, x, y, x + w, y);
495	XDrawLine (display, win, botShadow, x + w, y, x + w / 2, y + w);
496	break;
497
498	case 'u': /* up triangle */
499	XDrawLine (display, win, botShadow, x + w, y + w, x + w / 2, y);
500	XDrawLine (display, win, botShadow, x + w, y + w, x, y + w);
501	XDrawLine (display, win, topShadow, x, y + w, x + w / 2, y);
502	break;
503	#if 0
504	case 's': /* square */
505	XDrawLine (display, win, topShadow, x + w, y, x, y);
506	XDrawLine (display, win, topShadow, x, y, x, y + w);
507	XDrawLine (display, win, botShadow, x, y + w, x + w, y + w);
508	XDrawLine (display, win, botShadow, x + w, y + w, x + w, y);
509	break;
510	#endif
511
512	}
513	}
514	#endif
515	/----------------------- end-of-file (C source) -----------------------/