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

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

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