Split usounds.c and usystem.c from xboard.c
[xboard.git] / filebrowser / path.c
1 /*
2  * Copyright 1989 Software Research Associates, Inc., Tokyo, Japan
3  *
4  * Permission to use, copy, modify, and distribute this software and its
5  * documentation for any purpose and without fee is hereby granted, provided
6  * that the above copyright notice appear in all copies and that both that
7  * copyright notice and this permission notice appear in supporting
8  * documentation, and that the name of Software Research Associates not be used
9  * in advertising or publicity pertaining to distribution of the software
10  * without specific, written prior permission.  Software Research Associates
11  * makes no representations about the suitability of this software for any
12  * purpose.  It is provided "as is" without express or implied warranty.
13  *
14  * SOFTWARE RESEARCH ASSOCIATES DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
15  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
16  * IN NO EVENT SHALL SOFTWARE RESEARCH ASSOCIATES BE LIABLE FOR ANY SPECIAL,
17  * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
18  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
19  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
20  * PERFORMANCE OF THIS SOFTWARE.
21  *
22  * Author: Erik M. van der Poel
23  *         Software Research Associates, Inc., Tokyo, Japan
24  *         erik@sra.co.jp
25  */
26
27 #include <stdio.h>
28 #include <stdlib.h> /* for qsort */
29 #include "config.h"
30
31 #ifdef SEL_FILE_IGNORE_CASE
32 #include <ctype.h>
33 #endif /* def SEL_FILE_IGNORE_CASE */
34
35 #include <X11/Xos.h>
36 #include <pwd.h>
37 #include "xstat.h"
38 #include "selfile.h"
39 #include <X11/Xaw/Scrollbar.h>
40
41 #ifndef MAXPATHLEN
42 #define MAXPATHLEN 1024
43 #endif /* ndef MAXPATHLEN */
44
45 #ifdef HAS_DIRENT_H
46 extern uid_t getuid();
47 #endif /* def HAS_DIRENT_H */
48
49 typedef struct {
50         char    *name;
51         char    *dir;
52 } SFLogin;
53
54 SFDir *SFdirs = NULL;
55
56 int SFdirEnd;
57
58 int SFdirPtr;
59
60 int SFbuttonPressed = 0;
61
62 static int SFdoNotTouchDirPtr = 0;
63
64 static int SFdoNotTouchVorigin = 0;
65
66 static SFDir SFrootDir, SFhomeDir;
67
68 static SFLogin *SFlogins;
69
70 static int SFtwiddle = 0;
71
72 void SFsetText(char *path);
73
74 int
75 SFchdir(path)
76         char    *path;
77 {
78         int     result;
79
80         result = 0;
81
82         if (strcmp(path, SFcurrentDir)) {
83                 result = chdir(path);
84                 if (!result) {
85                   (void) strncpy(SFcurrentDir, path, MAXPATHLEN);
86                 }
87         }
88
89         return result;
90 }
91
92 static void
93 SFfree(i)
94         int     i;
95 {
96         register SFDir  *dir;
97         register int    j;
98
99         dir = &(SFdirs[i]);
100
101         for (j = dir->nEntries - 1; j >= 0; j--) {
102                 if (dir->entries[j].shown != dir->entries[j].real) {
103                         XtFree(dir->entries[j].shown);
104                 }
105                 XtFree(dir->entries[j].real);
106         }
107
108         XtFree((char *) dir->entries);
109
110         XtFree(dir->dir);
111
112         dir->dir = NULL;
113         return;
114 }
115
116 static void
117 SFstrdup(s1, s2)
118         char    **s1;
119         char    *s2;
120 {
121         *s1 = strcpy(XtMalloc((unsigned) (strlen(s2) + 1)), s2);
122         return;
123 }
124
125 static void
126 SFunreadableDir(dir)
127         SFDir   *dir;
128 {
129         char    *cannotOpen = "<cannot open> ";
130
131         dir->entries = (SFEntry *) XtMalloc(sizeof(SFEntry));
132         dir->entries[0].statDone = 1;
133         SFstrdup(&dir->entries[0].real, cannotOpen);
134         dir->entries[0].shown = dir->entries[0].real;
135         dir->nEntries = 1;
136         dir->nChars = strlen(cannotOpen);
137         return;
138 }
139
140 #ifdef SEL_FILE_IGNORE_CASE
141 static
142 SFstrncmp(p, q, n)
143         register char   *p, *q;
144         register int    n;
145 {
146         register char   c1, c2;
147         char            *psave, *qsave;
148         int             nsave;
149
150         psave = p;
151         qsave = q;
152         nsave = n;
153
154         c1 = *p++;
155         if (islower(c1)) {
156                 c1 = toupper(c1);
157         }
158         c2 = *q++;
159         if (islower(c2)) {
160                 c2 = toupper(c2);
161         }
162
163         while ((--n >= 0) && (c1 == c2)) {
164                 if (!c1) {
165                         return strncmp(psave, qsave, nsave);
166                 }
167                 c1 = *p++;
168                 if (islower(c1)) {
169                         c1 = toupper(c1);
170                 }
171                 c2 = *q++;
172                 if (islower(c2)) {
173                         c2 = toupper(c2);
174                 }
175         }
176
177         if (n < 0) {
178                 return strncmp(psave, qsave, nsave);
179         }
180
181         return c1 - c2;
182 }
183 #endif /* def SEL_FILE_IGNORE_CASE */
184
185 static void
186 SFreplaceText(dir, str)
187         SFDir   *dir;
188         char    *str;
189 {
190         int     len;
191
192         *(dir->path) = 0;
193         len = strlen(str);
194         if (str[len - 1] == '/') {
195                 (void) strcat(SFcurrentPath, str);
196         } else {
197                 (void) strncat(SFcurrentPath, str, len - 1);
198         }
199         if (strncmp(SFcurrentPath, SFstartDir, strlen(SFstartDir))) {
200                 SFsetText(SFcurrentPath);
201         } else {
202                 SFsetText(&(SFcurrentPath[strlen(SFstartDir)]));
203         }
204
205         SFtextChanged();
206         return;
207 }
208
209 static void
210 SFexpand(str)
211         char    *str;
212 {
213         int     len;
214         int     cmp;
215         char    *name, *growing;
216         SFDir   *dir;
217         SFEntry *entry, *max;
218
219         len = strlen(str);
220
221         dir = &(SFdirs[SFdirEnd - 1]);
222
223         if (dir->beginSelection == -1) {
224                 SFstrdup(&str, str);
225                 SFreplaceText(dir, str);
226                 XtFree(str);
227                 return;
228         } else if (dir->beginSelection == dir->endSelection) {
229                 SFreplaceText(dir, dir->entries[dir->beginSelection].shown);
230                 return;
231         }
232
233         max = &(dir->entries[dir->endSelection + 1]);
234
235         name = dir->entries[dir->beginSelection].shown;
236         SFstrdup(&growing, name);
237
238         cmp = 0;
239         while (!cmp) {
240                 entry = &(dir->entries[dir->beginSelection]);
241                 while (entry < max) {
242                         if (cmp = strncmp(growing, entry->shown, len)) {
243                                 break;
244                         }
245                         entry++;
246                 }
247                 len++;
248         }
249
250         /*
251          * SFreplaceText() expects filename
252          */
253         growing[len - 2] = ' ';
254
255         growing[len - 1] = 0;
256         SFreplaceText(dir, growing);
257         XtFree(growing);
258 }
259
260 static int
261 SFfindFile(dir, str)
262         SFDir           *dir;
263         register char   *str;
264 {
265         register int    i, last, max;
266         register char   *name, save;
267         SFEntry         *entries;
268         int             len;
269         int             begin, end;
270         int             result;
271
272         len = strlen(str);
273
274         if (str[len - 1] == ' ') {
275                 SFexpand(str);
276                 return 1;
277         } else if (str[len - 1] == '/') {
278                 len--;
279         }
280
281         max = dir->nEntries;
282
283         entries = dir->entries;
284
285         i = 0;
286         while (i < max) {
287                 name = entries[i].shown;
288                 last = strlen(name) - 1;
289                 save = name[last];
290                 name[last] = 0;
291
292 #ifdef SEL_FILE_IGNORE_CASE
293                 result = SFstrncmp(str, name, len);
294 #else /* def SEL_FILE_IGNORE_CASE */
295                 result = strncmp(str, name, len);
296 #endif /* def SEL_FILE_IGNORE_CASE */
297
298                 name[last] = save;
299                 if (result <= 0) {
300                         break;
301                 }
302                 i++;
303         }
304         begin = i;
305         while (i < max) {
306                 name = entries[i].shown;
307                 last = strlen(name) - 1;
308                 save = name[last];
309                 name[last] = 0;
310
311 #ifdef SEL_FILE_IGNORE_CASE
312                 result = SFstrncmp(str, name, len);
313 #else /* def SEL_FILE_IGNORE_CASE */
314                 result = strncmp(str, name, len);
315 #endif /* def SEL_FILE_IGNORE_CASE */
316
317                 name[last] = save;
318                 if (result) {
319                         break;
320                 }
321                 i++;
322         }
323         end = i;
324
325         if (begin != end) {
326                 if (
327                         (dir->beginSelection != begin) ||
328                         (dir->endSelection != end - 1)
329                 ) {
330                         dir->changed = 1;
331                         dir->beginSelection = begin;
332                         if (str[strlen(str) - 1] == '/') {
333                                 dir->endSelection = begin;
334                         } else {
335                                 dir->endSelection = end - 1;
336                         }
337                 }
338         } else {
339                 if (dir->beginSelection != -1) {
340                         dir->changed = 1;
341                         dir->beginSelection = -1;
342                         dir->endSelection = -1;
343                 }
344         }
345
346         if (
347                 SFdoNotTouchVorigin ||
348                 ((begin > dir->vOrigin) && (end < dir->vOrigin + SFlistSize))
349         ) {
350                 SFdoNotTouchVorigin = 0;
351                 return 0;
352         }
353
354         i = begin - 1;
355         if (i > max - SFlistSize) {
356                 i = max - SFlistSize;
357         }
358         if (i < 0) {
359                 i = 0;
360         }
361
362         if (dir->vOrigin != i) {
363                 dir->vOrigin = i;
364                 dir->changed = 1;
365         }
366
367         return 0;
368 }
369
370 static void
371 SFunselect()
372 {
373         SFDir   *dir;
374
375         dir = &(SFdirs[SFdirEnd - 1]);
376         if (dir->beginSelection != -1) {
377                 dir->changed = 1;
378         }
379         dir->beginSelection = -1;
380         dir->endSelection = -1;
381         return;
382 }
383
384 static int
385 SFcompareLogins(p, q)
386         SFLogin *p, *q;
387 {
388         return strcmp(p->name, q->name);
389 }
390
391 static void
392 SFgetHomeDirs()
393 {
394         struct passwd   *pw;
395         int             alloc;
396         int             i;
397         SFEntry         *entries = NULL;
398         int             len;
399         int             maxChars;
400
401         {
402                         alloc = 1;
403                         i = 1;
404                         entries = (SFEntry *) XtMalloc(sizeof(SFEntry));
405                         SFlogins = (SFLogin *) XtMalloc(sizeof(SFLogin));
406                         entries[0].real = XtMalloc(3);
407                         (void) strcpy(entries[0].real, "~");
408                         entries[0].shown = entries[0].real;
409                         entries[0].statDone = 1;
410                         SFlogins[0].name = "";
411                         pw = getpwuid((int) getuid());
412                         SFstrdup(&SFlogins[0].dir, pw ? pw->pw_dir : "/");
413                         maxChars = 0;
414         }
415
416         (void) setpwent();
417
418         while ((pw = getpwent()) && (*(pw->pw_name))) {
419                         if (i >= alloc) {
420                                 alloc *= 2;
421                                 entries = (SFEntry *) XtRealloc(
422                                         (char *) entries,
423                                         (unsigned) (alloc * sizeof(SFEntry))
424                                 );
425                                 SFlogins = (SFLogin *) XtRealloc(
426                                         (char *) SFlogins,
427                                         (unsigned) (alloc * sizeof(SFLogin))
428                                 );
429                         }
430                         len = strlen(pw->pw_name);
431                         entries[i].real = XtMalloc((unsigned) (len + 3));
432                         (void) strcat(strcpy(entries[i].real, "~"),
433                                 pw->pw_name);
434                         entries[i].shown = entries[i].real;
435                         entries[i].statDone = 1;
436                         if (len > maxChars) {
437                                 maxChars = len;
438                         }
439                         SFstrdup(&SFlogins[i].name, pw->pw_name);
440                         SFstrdup(&SFlogins[i].dir, pw->pw_dir);
441                         i++;
442         }
443
444         SFhomeDir.dir                   = XtMalloc(1)   ;
445         SFhomeDir.dir[0]                = 0             ;
446         SFhomeDir.path                  = SFcurrentPath ;
447         SFhomeDir.entries               = entries       ;
448         SFhomeDir.nEntries              = i             ;
449         SFhomeDir.vOrigin               = 0             ;       /* :-) */
450         SFhomeDir.nChars                = maxChars + 2  ;
451         SFhomeDir.hOrigin               = 0             ;
452         SFhomeDir.changed               = 1             ;
453         SFhomeDir.beginSelection        = -1            ;
454         SFhomeDir.endSelection          = -1            ;
455
456         qsort((char *) entries, (size_t)i, sizeof(SFEntry), SFcompareEntries);
457         qsort((char *) SFlogins, (size_t)i, sizeof(SFLogin), SFcompareLogins);
458
459         for (i--; i >= 0; i--) {
460                 (void) strcat(entries[i].real, "/");
461         }
462         return;
463 }
464
465 static int
466 SFfindHomeDir(begin, end)
467         char    *begin, *end;
468 {
469         char    save;
470         char    *theRest;
471         int     i;
472
473         save = *end;
474         *end = 0;
475
476         for (i = SFhomeDir.nEntries - 1; i >= 0; i--) {
477                 if (!strcmp(SFhomeDir.entries[i].real, begin)) {
478                         *end = save;
479                         SFstrdup(&theRest, end);
480                         (void) strcat(strcat(strncpy(SFcurrentPath,SFlogins[i].dir,
481                                                      MAXPATHLEN), "/"),
482                                       theRest);
483                         XtFree(theRest);
484                         SFsetText(SFcurrentPath);
485                         SFtextChanged();
486                         return 1;
487                 }
488         }
489
490         *end = save;
491
492         return 0;
493 }
494
495 void
496 SFupdatePath()
497 {
498         static int      alloc;
499         static int      wasTwiddle = 0;
500         char            *begin, *end;
501         int             i, j;
502         int             prevChange;
503         int             SFdirPtrSave, SFdirEndSave;
504         SFDir           *dir;
505
506         if (!SFdirs) {
507                 SFdirs = (SFDir *) XtMalloc((alloc = 10) * sizeof(SFDir));
508                 dir = &(SFdirs[0]);
509                 SFstrdup(&dir->dir, "/");
510                 (void) SFchdir("/");
511                 (void) SFgetDir(dir);
512                 for (j = 1; j < alloc; j++) {
513                         SFdirs[j].dir = NULL;
514                 }
515                 dir->path = SFcurrentPath + 1;
516                 dir->vOrigin = 0;
517                 dir->hOrigin = 0;
518                 dir->changed = 1;
519                 dir->beginSelection = -1;
520                 dir->endSelection = -1;
521                 SFhomeDir.dir = NULL;
522         }
523
524         SFdirEndSave = SFdirEnd;
525         SFdirEnd = 1;
526
527         SFdirPtrSave = SFdirPtr;
528         SFdirPtr = 0;
529
530         begin = NULL;
531
532         if (SFcurrentPath[0] == '~') {
533                 if (!SFtwiddle) {
534                         SFtwiddle = 1;
535                         dir = &(SFdirs[0]);
536                         SFrootDir = *dir;
537                         if (!SFhomeDir.dir) {
538                                 SFgetHomeDirs();
539                         }
540                         *dir = SFhomeDir;
541                         dir->changed = 1;
542                 }
543                 end = SFcurrentPath;
544                 SFdoNotTouchDirPtr = 1;
545                 wasTwiddle = 1;
546         } else {
547                 if (SFtwiddle) {
548                         SFtwiddle = 0;
549                         dir = &(SFdirs[0]);
550                         *dir = SFrootDir;
551                         dir->changed = 1;
552                 }
553                 end = SFcurrentPath + 1;
554         }
555
556         i = 0;
557
558         prevChange = 0;
559
560         while (*end) {
561                 while (*end++ == '/') {
562                         ;
563                 }
564                 end--;
565                 begin = end;
566                 while ((*end) && (*end++ != '/')) {
567                         ;
568                 }
569                 if ((end - SFcurrentPath <= SFtextPos) && (*(end - 1) == '/')) {
570                         SFdirPtr = i - 1;
571                         if (SFdirPtr < 0) {
572                                 SFdirPtr = 0;
573                         }
574                 }
575                 if (*begin) {
576                         if (*(end - 1) == '/') {
577                                 char save = *end;
578
579                                 if (SFtwiddle) {
580                                         if (SFfindHomeDir(begin, end)) {
581                                                 return;
582                                         }
583                                 }
584                                 *end = 0;
585                                 i++;
586                                 SFdirEnd++;
587                                 if (i >= alloc) {
588                                         SFdirs = (SFDir *) XtRealloc(
589                                                 (char *) SFdirs,
590                                                 (unsigned) ((alloc *= 2) *
591                                                         sizeof(SFDir))
592                                         );
593                                         for (j = alloc / 2; j < alloc; j++) {
594                                                 SFdirs[j].dir = NULL;
595                                         }
596                                 }
597                                 dir = &(SFdirs[i]);
598                                 if (
599                                         (!(dir->dir)) ||
600                                         prevChange ||
601                                         strcmp(dir->dir, begin)
602                                 ) {
603                                         if (dir->dir) {
604                                                 SFfree(i);
605                                         }
606                                         prevChange = 1;
607                                         SFstrdup(&dir->dir, begin);
608                                         dir->path = end;
609                                         dir->vOrigin = 0;
610                                         dir->hOrigin = 0;
611                                         dir->changed = 1;
612                                         dir->beginSelection = -1;
613                                         dir->endSelection = -1;
614                                         (void) SFfindFile(dir - 1, begin);
615                                         if (
616                                                 SFchdir(SFcurrentPath) ||
617                                                 SFgetDir(dir)
618                                         ) {
619                                                 SFunreadableDir(dir);
620                                                 break;
621                                         }
622                                 }
623                                 *end = save;
624                                 if (!save) {
625                                         SFunselect();
626                                 }
627                         } else {
628                                 if (SFfindFile(&(SFdirs[SFdirEnd-1]), begin)) {
629                                         return;
630                                 }
631                         }
632                 } else {
633                         SFunselect();
634                 }
635         }
636
637         if ((end == SFcurrentPath + 1) && (!SFtwiddle)) {
638                 SFunselect();
639         }
640
641         for (i = SFdirEnd; i < alloc; i++) {
642                 if (SFdirs[i].dir) {
643                         SFfree(i);
644                 }
645         }
646
647         if (SFdoNotTouchDirPtr) {
648                 if (wasTwiddle) {
649                         wasTwiddle = 0;
650                         SFdirPtr = SFdirEnd - 1;
651                         if (SFdirPtr < 0) {
652                                 SFdirPtr = 0;
653                         }
654                 } else {
655                         SFdirPtr = SFdirPtrSave;
656                 }
657                 SFdoNotTouchDirPtr = 0;
658         }
659
660         if ((SFdirPtr != SFdirPtrSave) || (SFdirEnd != SFdirEndSave)) {
661                 XawScrollbarSetThumb(
662                         selFileHScroll,
663                         (float) (((double) SFdirPtr) / SFdirEnd),
664                         (float) (((double) ((SFdirEnd < NR) ? SFdirEnd : NR)) /
665                                 SFdirEnd)
666                 );
667         }
668
669         if (SFdirPtr != SFdirPtrSave) {
670                 SFdrawLists(SF_DO_SCROLL);
671         } else {
672                 for (i = 0; i < NR; i++) {
673                         if (SFdirPtr + i < SFdirEnd) {
674                                 if (SFdirs[SFdirPtr + i].changed) {
675                                         SFdirs[SFdirPtr + i].changed = 0;
676                                         SFdrawList(i, SF_DO_SCROLL);
677                                 }
678                         } else {
679                                 SFclearList(i, SF_DO_SCROLL);
680                         }
681                 }
682         }
683         return;
684 }
685
686 /* ARGSUSED */
687 void
688 SFbuttonPressList(w, n, event)
689         Widget                  w;
690         int                     n;
691         XButtonPressedEvent     *event;
692 {
693         int dir = 0;
694         if(event->button == Button4) dir = -2; // kludge to indicate relative motion
695         if(event->button == Button5) dir = -1;
696         if(dir) SFvSliderMovedCallback(w, n, dir); else
697         SFbuttonPressed = 1;
698 }
699
700 /* ARGSUSED */
701 void
702 SFbuttonReleaseList(w, n, event)
703         Widget                  w;
704         int                     n;
705         XButtonReleasedEvent    *event;
706 {
707         SFDir   *dir;
708         static int lastClick;
709
710         if(event->button == Button4 || event->button == Button5) return; // [HGM] mouse wheel does not select
711         SFbuttonPressed = 0;
712
713         if (SFcurrentInvert[n] != -1) {
714                 if (n < 2) {
715                         SFdoNotTouchDirPtr = 1;
716                 }
717                 SFdoNotTouchVorigin = 1;
718                 dir = &(SFdirs[SFdirPtr + n]);
719                 SFreplaceText(
720                         dir,
721                         dir->entries[dir->vOrigin + SFcurrentInvert[n]].shown
722                 );
723                 SFmotionList(w, n, (XMotionEvent *) event);
724                 if(lastClick == 256*n + SFcurrentInvert[n]) SFstatus = SEL_FILE_OK; // [HGM] double click implies OK
725         }
726         lastClick = 256*n + SFcurrentInvert[n];
727 }
728
729 static int
730 SFcheckDir(n, dir)
731         int             n;
732         SFDir           *dir;
733 {
734         struct stat     statBuf;
735         int             i;
736
737         if (
738                 (!stat(".", &statBuf)) &&
739                 (statBuf.st_mtime != dir->mtime)
740         ) {
741
742                 /*
743                  * If the pointer is currently in the window that we are about
744                  * to update, we must warp it to prevent the user from
745                  * accidentally selecting the wrong file.
746                  */
747                 if (SFcurrentInvert[n] != -1) {
748                         XWarpPointer(
749                                 SFdisplay,
750                                 None,
751                                 XtWindow(selFileLists[n]),
752                                 0,
753                                 0,
754                                 0,
755                                 0,
756                                 0,
757                                 0
758                         );
759                 }
760
761                 for (i = dir->nEntries - 1; i >= 0; i--) {
762                         if (dir->entries[i].shown != dir->entries[i].real) {
763                                 XtFree(dir->entries[i].shown);
764                         }
765                         XtFree(dir->entries[i].real);
766                 }
767                 XtFree((char *) dir->entries);
768                 if (SFgetDir(dir)) {
769                         SFunreadableDir(dir);
770                 }
771                 if (dir->vOrigin > dir->nEntries - SFlistSize) {
772                         dir->vOrigin = dir->nEntries - SFlistSize;
773                 }
774                 if (dir->vOrigin < 0) {
775                         dir->vOrigin = 0;
776                 }
777                 if (dir->hOrigin > dir->nChars - SFcharsPerEntry) {
778                         dir->hOrigin = dir->nChars - SFcharsPerEntry;
779                 }
780                 if (dir->hOrigin < 0) {
781                         dir->hOrigin = 0;
782                 }
783                 dir->beginSelection = -1;
784                 dir->endSelection = -1;
785                 SFdoNotTouchVorigin = 1;
786                 if ((dir + 1)->dir) {
787                         (void) SFfindFile(dir, (dir + 1)->dir);
788                 } else {
789                         (void) SFfindFile(dir, dir->path);
790                 }
791
792                 if (!SFworkProcAdded) {
793                         (void) XtAppAddWorkProc(SFapp, SFworkProc, NULL);
794                         SFworkProcAdded = 1;
795                 }
796
797                 return 1;
798         }
799
800         return 0;
801 }
802
803 /* Return a single character describing what kind of file STATBUF is.  */
804
805 char
806 SFstatChar (statBuf)
807         struct stat *statBuf;
808 {
809         if (S_ISDIR (statBuf->st_mode)) {
810                 return '/';
811         } else if (S_ISREG (statBuf->st_mode)) {
812           return S_ISXXX (statBuf->st_mode) ? '*' : ' ';
813 #ifdef S_ISSOCK
814         } else if (S_ISSOCK (statBuf->st_mode)) {
815                 return '=';
816 #endif /* S_ISSOCK */
817         } else {
818                 return ' ';
819         }
820 }
821
822 static int
823 SFcheckFiles(dir)
824         SFDir   *dir;
825 {
826         int             from, to;
827         int             result;
828         char            old, new;
829         int             i;
830         char            *str;
831         int             last;
832         struct stat     statBuf;
833
834         result = 0;
835
836         from = dir->vOrigin;
837         to = dir->vOrigin + SFlistSize;
838         if (to > dir->nEntries) {
839                 to = dir->nEntries;
840         }
841
842         for (i = from; i < to; i++) {
843                 str = dir->entries[i].real;
844                 last = strlen(str) - 1;
845                 old = str[last];
846                 str[last] = 0;
847                 if (stat(str, &statBuf)) {
848                         new = ' ';
849                 } else {
850                         new = SFstatChar(&statBuf);
851                 }
852                 str[last] = new;
853                 if (new != old) {
854                         result = 1;
855                 }
856         }
857
858         return result;
859 }
860
861 void
862 SFdirModTimer(cl, id)
863         XtPointer       cl;
864         XtIntervalId    *id;
865 {
866         static int      n = -1;
867         static int      f = 0;
868         char            save;
869         SFDir           *dir;
870
871         if ((!SFtwiddle) && (SFdirPtr < SFdirEnd)) {
872                 n++;
873                 if ((n > NR-1) || (SFdirPtr + n >= SFdirEnd)) {
874                         n = 0;
875                         f++;
876                         if ((f > NR-1) || (SFdirPtr + f >= SFdirEnd)) {
877                                 f = 0;
878                         }
879                 }
880                 dir = &(SFdirs[SFdirPtr + n]);
881                 save = *(dir->path);
882                 *(dir->path) = 0;
883                 if (SFchdir(SFcurrentPath)) {
884                         *(dir->path) = save;
885
886                         /*
887                          * force a re-read
888                          */
889                         *(dir->dir) = 0;
890
891                         SFupdatePath();
892                 } else {
893                         *(dir->path) = save;
894                         if (
895                                 SFcheckDir(n, dir) ||
896                                 ((f == n) && SFcheckFiles(dir))
897                         ) {
898                                 SFdrawList(n, SF_DO_SCROLL);
899                         }
900                 }
901         }
902
903         SFdirModTimerId = XtAppAddTimeOut(SFapp, (unsigned long) 1000,
904                 SFdirModTimer, (XtPointer) NULL);
905 }