Put engine initialization code in per-engine function
[xboard.git] / filebrowser / draw.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 "selfile.h"
29 #include "xstat.h"
30 #include <X11/StringDefs.h>
31 #include <X11/Xaw/Scrollbar.h>
32 #include <X11/Xaw/Cardinals.h>
33
34 #define SF_DEFAULT_FONT "9x15"
35
36 #ifdef ABS
37 #undef ABS
38 #endif
39 #define ABS(x) (((x) < 0) ? (-(x)) : (x))
40
41 /* added missing prototypes */
42 extern char SFstatChar(struct stat*);
43 extern int SFchdir(char *);
44 void SFvSliderMovedCallback(Widget, int, int);
45
46 typedef struct {
47         char *fontname;
48 } TextData, *textPtr;
49
50 int SFcharWidth, SFcharAscent, SFcharHeight;
51
52 int SFcurrentInvert[3] = { -1, -1, -1 };
53
54 static GC SFlineGC, SFscrollGC, SFinvertGC, SFtextGC;
55
56 static XtResource textResources[] = {
57         {XtNfont, XtCFont, XtRString, sizeof (char *),
58                 XtOffset(textPtr, fontname), XtRString, SF_DEFAULT_FONT},
59 };
60
61 static XFontStruct *SFfont;
62
63 static int SFcurrentListY;
64
65 static XtIntervalId SFscrollTimerId;
66
67 void
68 SFinitFont()
69 {
70         TextData        *data;
71
72         data = XtNew(TextData);
73
74         XtGetApplicationResources(selFileForm, (XtPointer) data, textResources,
75                 XtNumber(textResources), (Arg *) NULL, ZERO);
76
77         SFfont = XLoadQueryFont(SFdisplay, data->fontname);
78         if (!SFfont) {
79                 SFfont = XLoadQueryFont(SFdisplay, SF_DEFAULT_FONT);
80                 if (!SFfont) {
81                         char    sbuf[256];
82
83                         (void) sprintf(sbuf, "XsraSelFile: can't get font %s",
84                                 SF_DEFAULT_FONT);
85
86                         XtAppError(SFapp, sbuf);
87                 }
88         }
89
90         SFcharWidth = (SFfont->max_bounds.width + SFfont->min_bounds.width) / 2;
91         SFcharAscent = SFfont->max_bounds.ascent;
92         SFcharHeight = SFcharAscent + SFfont->max_bounds.descent;
93         return;
94 }
95
96 void
97 SFcreateGC()
98 {
99         XGCValues       gcValues;
100         XRectangle      rectangles[1];
101
102         gcValues.foreground = SFfore;
103
104         SFlineGC = XtGetGC(
105                 selFileLists[0],
106                 (XtGCMask)
107                         GCForeground            |
108                         0,
109                 &gcValues
110         );
111
112         SFscrollGC = XtGetGC(
113                 selFileLists[0],
114                 (XtGCMask)
115                         0,
116                 &gcValues
117         );
118
119         gcValues.function = GXinvert;
120         gcValues.plane_mask = (SFfore ^ SFback);
121
122         SFinvertGC = XtGetGC(
123                 selFileLists[0],
124                 (XtGCMask)
125                         GCFunction              |
126                         GCPlaneMask             |
127                         0,
128                 &gcValues
129         );
130
131         gcValues.foreground = SFfore;
132         gcValues.background = SFback;
133         gcValues.font = SFfont->fid;
134
135         SFtextGC = XCreateGC(
136                 SFdisplay,
137                 XtWindow(selFileLists[0]),
138                 (unsigned long)
139                         GCForeground            |
140                         GCBackground            |
141                         GCFont                  |
142                         0,
143                 &gcValues
144         );
145
146         rectangles[0].x = SFlineToTextH + SFbesideText;
147         rectangles[0].y = 0;
148         rectangles[0].width = SFcharsPerEntry * SFcharWidth;
149         rectangles[0].height = SFupperY + 1;
150
151         XSetClipRectangles(
152                 SFdisplay,
153                 SFtextGC,
154                 0,
155                 0,
156                 rectangles,
157                 1,
158                 Unsorted
159         );
160         return;
161 }
162
163 void
164 SFclearList(n, doScroll)
165         int     n;
166         int     doScroll;
167 {
168         SFDir   *dir;
169
170         SFcurrentInvert[n] = -1;
171
172         XClearWindow(SFdisplay, XtWindow(selFileLists[n]));
173
174         XDrawSegments(SFdisplay, XtWindow(selFileLists[n]), SFlineGC, SFsegs,
175                 2);
176
177         if (doScroll) {
178                 dir = &(SFdirs[SFdirPtr + n]);
179
180                 if ((SFdirPtr + n < SFdirEnd) && dir->nEntries && dir->nChars) {
181                         XawScrollbarSetThumb(
182                                 selFileVScrolls[n],
183                                 (float) (((double) dir->vOrigin) /
184                                         dir->nEntries),
185                                 (float) (((double) ((dir->nEntries < SFlistSize)
186                                         ? dir->nEntries : SFlistSize)) /
187                                         dir->nEntries)
188                         );
189
190                         XawScrollbarSetThumb(
191                                 selFileHScrolls[n],
192                                 (float) (((double) dir->hOrigin) / dir->nChars),
193                                 (float) (((double) ((dir->nChars <
194                                         SFcharsPerEntry) ? dir->nChars :
195                                         SFcharsPerEntry)) / dir->nChars)
196                         );
197                 } else {
198                         XawScrollbarSetThumb(selFileVScrolls[n], (float) 0.0,
199                                 (float) 1.0);
200                         XawScrollbarSetThumb(selFileHScrolls[n], (float) 0.0,
201                                 (float) 1.0);
202                 }
203         }
204         return;
205 }
206
207 static void
208 SFdeleteEntry(dir, entry)
209         SFDir   *dir;
210         SFEntry *entry;
211 {
212         register SFEntry        *e;
213         register SFEntry        *end;
214         int                     n;
215         int                     idx;
216
217         idx = entry - dir->entries;
218
219         if (idx < dir->beginSelection) {
220                 dir->beginSelection--;
221         }
222         if (idx <= dir->endSelection) {
223                 dir->endSelection--;
224         }
225         if (dir->beginSelection > dir->endSelection) {
226                 dir->beginSelection = dir->endSelection = -1;
227         }
228
229         if (idx < dir->vOrigin) {
230                 dir->vOrigin--;
231         }
232
233         XtFree(entry->real);
234
235         end = &(dir->entries[dir->nEntries - 1]);
236
237         for (e = entry; e < end; e++) {
238                 *e = *(e + 1);
239         }
240
241         if (!(--dir->nEntries)) {
242                 return;
243         }
244
245         n = dir - &(SFdirs[SFdirPtr]);
246         if ((n < 0) || (n > 2)) {
247                 return;
248         }
249
250         XawScrollbarSetThumb(
251                 selFileVScrolls[n],
252                 (float) (((double) dir->vOrigin) / dir->nEntries),
253                 (float) (((double) ((dir->nEntries < SFlistSize) ?
254                         dir->nEntries : SFlistSize)) / dir->nEntries)
255         );
256         return;
257 }
258
259 static void
260 SFwriteStatChar(name, last, statBuf)
261         char            *name;
262         int             last;
263         struct stat     *statBuf;
264 {
265         name[last] = SFstatChar(statBuf);
266         return;
267 }
268
269 static int
270 SFstatAndCheck(dir, entry)
271         SFDir   *dir;
272         SFEntry *entry;
273 {
274         struct stat     statBuf;
275         char            save;
276         int             last;
277
278         /*
279          * must be restored before returning
280          */
281         save = *(dir->path);
282         *(dir->path) = 0;
283
284         if (!SFchdir(SFcurrentPath)) {
285                 last = strlen(entry->real) - 1;
286                 entry->real[last] = 0;
287                 entry->statDone = 1;
288                 if (
289                         (!stat(entry->real, &statBuf))
290
291 #ifdef S_IFLNK
292
293                      || (!lstat(entry->real, &statBuf))
294
295 #endif /* ndef S_IFLNK */
296
297                 ) {
298                         if (SFfunc) {
299                                 char *shown;
300
301                                 shown = NULL;
302                                 if (SFfunc(entry->real, &shown, &statBuf)) {
303                                         if (shown) {
304                                                 int len;
305
306                                                 len = strlen(shown);
307                                                 entry->shown = XtMalloc(
308                                                         (unsigned) (len + 2)
309                                                 );
310                                                 (void) strcpy(entry->shown,
311                                                         shown);
312                                                 SFwriteStatChar(
313                                                         entry->shown,
314                                                         len,
315                                                         &statBuf
316                                                 );
317                                                 entry->shown[len + 1] = 0;
318                                         }
319                                 } else {
320                                         SFdeleteEntry(dir, entry);
321
322                                         *(dir->path) = save;
323                                         return 1;
324                                 }
325                         }
326                         SFwriteStatChar(entry->real, last, &statBuf);
327                 } else {
328                         entry->real[last] = ' ';
329                 }
330         }
331
332         *(dir->path) = save;
333         return 0;
334 }
335
336 static void
337 SFdrawStrings(w, dir, from, to)
338         register Window w;
339         register SFDir  *dir;
340         register int    from;
341         register int    to;
342 {
343         register int            i;
344         register SFEntry        *entry;
345         int                     x;
346
347         x = SFtextX - dir->hOrigin * SFcharWidth;
348
349         if (dir->vOrigin + to >= dir->nEntries) {
350                 to = dir->nEntries - dir->vOrigin - 1;
351         }
352         for (i = from; i <= to; i++) {
353                 entry = &(dir->entries[dir->vOrigin + i]);
354                 if (!(entry->statDone)) {
355                         if (SFstatAndCheck(dir, entry)) {
356                                 if (dir->vOrigin + to >= dir->nEntries) {
357                                         to = dir->nEntries - dir->vOrigin - 1;
358                                 }
359                                 i--;
360                                 continue;
361                         }
362                 }
363                 XDrawImageString(
364                         SFdisplay,
365                         w,
366                         SFtextGC,
367                         x,
368                         SFtextYoffset + i * SFentryHeight,
369                         entry->shown,
370                         strlen(entry->shown)
371                 );
372                 if (dir->vOrigin + i == dir->beginSelection) {
373                         XDrawLine(
374                                 SFdisplay,
375                                 w,
376                                 SFlineGC,
377                                 SFlineToTextH + 1,
378                                 SFlowerY + i * SFentryHeight,
379                                 SFlineToTextH + SFentryWidth - 2,
380                                 SFlowerY + i * SFentryHeight
381                         );
382                 }
383                 if (
384                         (dir->vOrigin + i >= dir->beginSelection) &&
385                         (dir->vOrigin + i <= dir->endSelection)
386                 ) {
387                         SFcompletionSegs[0].y1 = SFcompletionSegs[1].y1 =
388                                 SFlowerY + i * SFentryHeight;
389                         SFcompletionSegs[0].y2 = SFcompletionSegs[1].y2 =
390                                 SFlowerY + (i + 1) * SFentryHeight - 1;
391                         XDrawSegments(
392                                 SFdisplay,
393                                 w,
394                                 SFlineGC,
395                                 SFcompletionSegs,
396                                 2
397                         );
398                 }
399                 if (dir->vOrigin + i == dir->endSelection) {
400                         XDrawLine(
401                                 SFdisplay,
402                                 w,
403                                 SFlineGC,
404                                 SFlineToTextH + 1,
405                                 SFlowerY + (i + 1) * SFentryHeight - 1,
406                                 SFlineToTextH + SFentryWidth - 2,
407                                 SFlowerY + (i + 1) * SFentryHeight - 1
408                         );
409                 }
410         }
411         return;
412 }
413
414 void
415 SFdrawList(n, doScroll)
416         int     n;
417         int     doScroll;
418 {
419         SFDir   *dir;
420         Window  w;
421
422         SFclearList(n, doScroll);
423
424         if (SFdirPtr + (3-NR) + n < SFdirEnd) {
425                 dir = &(SFdirs[SFdirPtr + n + (3-NR)]);
426                 w = XtWindow(selFileLists[n]);
427                 XDrawImageString(
428                         SFdisplay,
429                         w,
430                         SFtextGC,
431                         SFtextX - dir->hOrigin * SFcharWidth,
432                         SFlineToTextV + SFaboveAndBelowText + SFcharAscent,
433                         dir->dir,
434                         strlen(dir->dir)
435                 );
436                 SFdrawStrings(w, dir, 0, SFlistSize - 1);
437         }
438         return;
439 }
440
441 void
442 SFdrawLists(doScroll)
443         int     doScroll;
444 {
445         int     i;
446
447         for (i = 0; i < NR; i++) {
448                 SFdrawList(i, doScroll);
449         }
450         return;
451 }
452
453 static void
454 SFinvertEntry(n)
455         register int    n;
456 {
457         XFillRectangle(
458                 SFdisplay,
459                 XtWindow(selFileLists[n]),
460                 SFinvertGC,
461                 SFlineToTextH,
462                 SFcurrentInvert[n] * SFentryHeight + SFlowerY,
463                 SFentryWidth,
464                 SFentryHeight
465         );
466         return;
467 }
468
469 static unsigned long
470 SFscrollTimerInterval()
471 {
472         static int      maxVal = 200;
473         static int      varyDist = 50;
474         static int      minDist = 50;
475         int             t;
476         int             dist;
477
478         if (SFcurrentListY < SFlowerY) {
479                 dist = SFlowerY - SFcurrentListY;
480         } else if (SFcurrentListY > SFupperY) {
481                 dist = SFcurrentListY - SFupperY;
482         } else {
483                 return (unsigned long) 1;
484         }
485
486         t = maxVal - ((maxVal / varyDist) * (dist - minDist));
487
488         if (t < 1) {
489                 t = 1;
490         }
491
492         if (t > maxVal) {
493                 t = maxVal;
494         }
495
496         return (unsigned long) t;
497 }
498
499 static void
500 SFscrollTimer(p, id)
501         XtPointer       p;
502         XtIntervalId    *id;
503 {
504         SFDir   *dir;
505         int     save;
506         int     n;
507
508         n = (int)(intptr_t) p;
509
510         dir = &(SFdirs[SFdirPtr + n]);
511         save = dir->vOrigin;
512
513         if (SFcurrentListY < SFlowerY) {
514                 if (dir->vOrigin > 0) {
515                         SFvSliderMovedCallback(selFileVScrolls[n], n,
516                                 dir->vOrigin - 1);
517                 }
518         } else if (SFcurrentListY > SFupperY) {
519                 if (dir->vOrigin < dir->nEntries - SFlistSize) {
520                         SFvSliderMovedCallback(selFileVScrolls[n], n,
521                                 dir->vOrigin + 1);
522                 }
523         }
524
525         if (dir->vOrigin != save) {
526                 if (dir->nEntries) {
527                     XawScrollbarSetThumb(
528                         selFileVScrolls[n],
529                         (float) (((double) dir->vOrigin) / dir->nEntries),
530                         (float) (((double) ((dir->nEntries < SFlistSize) ?
531                                 dir->nEntries : SFlistSize)) / dir->nEntries)
532                     );
533                 }
534         }
535
536         if (SFbuttonPressed) {
537                 SFscrollTimerId = XtAppAddTimeOut(SFapp,
538                         SFscrollTimerInterval(), SFscrollTimer, (XtPointer)(intptr_t) n);
539         }
540 }
541
542 static int
543 SFnewInvertEntry(n, event)
544         register int            n;
545         register XMotionEvent   *event;
546 {
547         register int    x, y;
548         register int    new;
549         static int      SFscrollTimerAdded = 0;
550
551         x = event->x;
552         y = event->y;
553
554         if (SFdirPtr + n >= SFdirEnd) {
555                 return -1;
556         } else if (
557                 (x >= 0)        && (x <= SFupperX) &&
558                 (y >= SFlowerY) && (y <= SFupperY)
559         ) {
560                 register SFDir *dir = &(SFdirs[SFdirPtr + n]);
561
562                 if (SFscrollTimerAdded) {
563                         SFscrollTimerAdded = 0;
564                         XtRemoveTimeOut(SFscrollTimerId);
565                 }
566
567                 new = (y - SFlowerY) / SFentryHeight;
568                 if (dir->vOrigin + new >= dir->nEntries) {
569                         return -1;
570                 }
571                 return new;
572         } else {
573                 if (SFbuttonPressed) {
574                         SFcurrentListY = y;
575                         if (!SFscrollTimerAdded) {
576                                 SFscrollTimerAdded = 1;
577                                 SFscrollTimerId = XtAppAddTimeOut(SFapp,
578                                         SFscrollTimerInterval(), SFscrollTimer,
579                                         (XtPointer)(intptr_t) n);
580                         }
581                 }
582
583                 return -1;
584         }
585 }
586
587 /* ARGSUSED */
588 void
589 SFenterList(w, n, event)
590         Widget                          w;
591         register int                    n;
592         register XEnterWindowEvent      *event;
593 {
594         register int    new;
595
596         /* sanity */
597         if (SFcurrentInvert[n] != -1) {
598                 SFinvertEntry(n);
599                 SFcurrentInvert[n] = -1;
600         }
601
602         new = SFnewInvertEntry(n, (XMotionEvent *) event);
603         if (new != -1) {
604                 SFcurrentInvert[n] = new;
605                 SFinvertEntry(n);
606         }
607 }
608
609 /* ARGSUSED */
610 void
611 SFleaveList(w, n, event)
612         Widget          w;
613         register int    n;
614         XEvent          *event;
615 {
616         if (SFcurrentInvert[n] != -1) {
617                 SFinvertEntry(n);
618                 SFcurrentInvert[n] = -1;
619         }
620 }
621
622 /* ARGSUSED */
623 void
624 SFmotionList(w, n, event)
625         Widget                  w;
626         register int            n;
627         register XMotionEvent   *event;
628 {
629         register int    new;
630
631         new = SFnewInvertEntry(n, event);
632
633         if (new != SFcurrentInvert[n]) {
634                 if (SFcurrentInvert[n] != -1) {
635                         SFinvertEntry(n);
636                 }
637                 SFcurrentInvert[n] = new;
638                 if (new != -1) {
639                         SFinvertEntry(n);
640                 }
641         }
642         return;
643 }
644
645 /* ARGSUSED */
646 void
647 SFvSliderMovedCallback(w, n, new)
648         Widget  w;
649         int     n;
650         int     new;
651 {
652         int             old;
653         register Window win;
654         SFDir           *dir;
655
656         dir = &(SFdirs[SFdirPtr + n]);
657
658
659         old = dir->vOrigin;
660         if(new == -1) new = old + 1; else if(new == -2) new = old - 1; // [HGM] indicates scroll direction on mousewheel event
661         if(new < 0 || new > dir->nEntries - SFlistSize) return;
662         dir->vOrigin = new;
663
664         if (old == new) {
665                 return;
666         }
667
668         win = XtWindow(selFileLists[n]);
669
670         if (ABS(new - old) < SFlistSize) {
671                 if (new > old) {
672                         XCopyArea(
673                                 SFdisplay,
674                                 win,
675                                 win,
676                                 SFscrollGC,
677                                 SFlineToTextH,
678                                 SFlowerY + (new - old) * SFentryHeight,
679                                 SFentryWidth + SFlineToTextH,
680                                 (SFlistSize - (new - old)) * SFentryHeight,
681                                 SFlineToTextH,
682                                 SFlowerY
683                         );
684                         XClearArea(
685                                 SFdisplay,
686                                 win,
687                                 SFlineToTextH,
688                                 SFlowerY + (SFlistSize - (new - old)) *
689                                         SFentryHeight,
690                                 SFentryWidth + SFlineToTextH,
691                                 (new - old) * SFentryHeight,
692                                 False
693                         );
694                         SFdrawStrings(win, dir, SFlistSize - (new - old),
695                                 SFlistSize - 1);
696                 } else {
697                         XCopyArea(
698                                 SFdisplay,
699                                 win,
700                                 win,
701                                 SFscrollGC,
702                                 SFlineToTextH,
703                                 SFlowerY,
704                                 SFentryWidth + SFlineToTextH,
705                                 (SFlistSize - (old - new)) * SFentryHeight,
706                                 SFlineToTextH,
707                                 SFlowerY + (old - new) * SFentryHeight
708                         );
709                         XClearArea(
710                                 SFdisplay,
711                                 win,
712                                 SFlineToTextH,
713                                 SFlowerY,
714                                 SFentryWidth + SFlineToTextH,
715                                 (old - new) * SFentryHeight,
716                                 False
717                         );
718                         SFdrawStrings(win, dir, 0, old - new);
719                 }
720         } else {
721                 XClearArea(
722                         SFdisplay,
723                         win,
724                         SFlineToTextH,
725                         SFlowerY,
726                         SFentryWidth + SFlineToTextH,
727                         SFlistSize * SFentryHeight,
728                         False
729                 );
730                 SFdrawStrings(win, dir, 0, SFlistSize - 1);
731         }
732 }
733
734 /* ARGSUSED */
735 void
736 SFvFloatSliderMovedCallback(w, n, fnew)
737         Widget  w;
738         int     n;
739         float   *fnew;
740 {
741         int     new;
742
743         new = (*fnew) * SFdirs[SFdirPtr + n].nEntries;
744
745         SFvSliderMovedCallback(w, n, new);
746 }
747
748
749 /* ARGSUSED */
750 void
751 SFvAreaSelectedCallback(w, n, pnew)
752         Widget  w;
753         int     n;
754         int     pnew;
755 {
756         SFDir   *dir;
757         int     new;
758
759         dir = &(SFdirs[SFdirPtr + n]);
760
761         new = dir->vOrigin +
762                 (((double) pnew) / SFvScrollHeight) * dir->nEntries;
763
764         if (new > dir->nEntries - SFlistSize) {
765                 new = dir->nEntries - SFlistSize;
766         }
767
768         if (new < 0) {
769                 new = 0;
770         }
771
772         if (dir->nEntries) {
773                 float   f;
774
775                 f = ((double) new) / dir->nEntries;
776
777                 XawScrollbarSetThumb(
778                         w,
779                         f,
780                         (float) (((double) ((dir->nEntries < SFlistSize) ?
781                                 dir->nEntries : SFlistSize)) / dir->nEntries)
782                 );
783         }
784
785         SFvSliderMovedCallback(w, n, new);
786 }
787
788 /* ARGSUSED */
789 void
790 SFhSliderMovedCallback(w, n, new)
791         Widget  w;
792         int     n;
793         float   *new;
794 {
795         SFDir   *dir;
796         int     save;
797
798         dir = &(SFdirs[SFdirPtr + n]);
799         save = dir->hOrigin;
800         dir->hOrigin = (*new) * dir->nChars;
801         if (dir->hOrigin == save) {
802                 return;
803         }
804
805         SFdrawList(n, SF_DO_NOT_SCROLL);
806 }
807
808 /* ARGSUSED */
809 void
810 SFhAreaSelectedCallback(w, n, pnew)
811         Widget  w;
812         int     n;
813         int     pnew;
814 {
815         SFDir   *dir;
816         int     new;
817
818         dir = &(SFdirs[SFdirPtr + n]);
819
820         new = dir->hOrigin +
821                 (((double) pnew) / SFhScrollWidth) * dir->nChars;
822
823         if (new > dir->nChars - SFcharsPerEntry) {
824                 new = dir->nChars - SFcharsPerEntry;
825         }
826
827         if (new < 0) {
828                 new = 0;
829         }
830
831         if (dir->nChars) {
832                 float   f;
833
834                 f = ((double) new) / dir->nChars;
835
836                 XawScrollbarSetThumb(
837                         w,
838                         f,
839                         (float) (((double) ((dir->nChars < SFcharsPerEntry) ?
840                                 dir->nChars : SFcharsPerEntry)) / dir->nChars)
841                 );
842
843                 SFhSliderMovedCallback(w, n, &f);
844         }
845 }
846
847 /* ARGSUSED */
848 void
849 SFpathSliderMovedCallback(w, client_data, new)
850         Widget          w;
851         XtPointer       client_data;
852         float   *new;
853 {
854         SFDir           *dir;
855         int             n;
856         XawTextPosition pos;
857         int     SFdirPtrSave;
858
859         SFdirPtrSave = SFdirPtr;
860         SFdirPtr = (*new) * SFdirEnd;
861         if (SFdirPtr == SFdirPtrSave) {
862                 return;
863         }
864
865         SFdrawLists(SF_DO_SCROLL);
866
867         n = 2;
868         while (SFdirPtr + n >= SFdirEnd) {
869                 n--;
870         }
871
872         dir = &(SFdirs[SFdirPtr + n]);
873
874         pos = dir->path - SFcurrentPath;
875
876         if (!strncmp(SFcurrentPath, SFstartDir, strlen(SFstartDir))) {
877                 pos -= strlen(SFstartDir);
878                 if (pos < 0) {
879                         pos = 0;
880                 }
881         }
882
883         XawTextSetInsertionPoint(selFileField, pos);
884 }
885
886 /* ARGSUSED */
887
888 void
889 SFpathAreaSelectedCallback(w, client_data, pnew)
890         Widget          w;
891         XtPointer       client_data;
892         int             pnew;
893 {
894         int     new;
895         float   f;
896
897         new = SFdirPtr + (((double) pnew) / SFpathScrollWidth) * SFdirEnd;
898
899         if (new > SFdirEnd - 3) {
900                 new = SFdirEnd - 3;
901         }
902
903         if (new < 0) {
904                 new = 0;
905         }
906
907         f = ((double) new) / SFdirEnd;
908
909         XawScrollbarSetThumb(
910                 w,
911                 f,
912                 (float) (((double) ((SFdirEnd < 3) ? SFdirEnd : 3)) /
913                         SFdirEnd)
914         );
915
916         SFpathSliderMovedCallback(w, (XtPointer) NULL, &f);
917 }
918
919 Boolean
920 SFworkProc()
921 {
922         register SFDir          *dir;
923         register SFEntry        *entry;
924
925         for (dir = &(SFdirs[SFdirEnd - 1]); dir >= SFdirs; dir--) {
926                 if (!(dir->nEntries)) {
927                         continue;
928                 }
929                 for (
930                         entry = &(dir->entries[dir->nEntries - 1]);
931                         entry >= dir->entries;
932                         entry--
933                 ) {
934                         if (!(entry->statDone)) {
935                                 (void) SFstatAndCheck(dir, entry);
936                                 return False;
937                         }
938                 }
939         }
940
941         SFworkProcAdded = 0;
942
943         return True;
944 }