开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Modem编程 > 查看源码
file.c
资源名称：minicom-1.83.tar.gz　[点击查看]
上传用户：tianjinjs
上传日期：2007-01-05
资源大小：309k
文件大小：19k
源码类别：

Modem编程

开发平台：

Unix_Linux

file.c：源码内容
  1. /*
  2.  * file.c Functions to handle file selector.
  3.  *
  4.  * This file is part of the minicom communications package,
  5.  * Copyright 1991-1995 Miquel van Smoorenburg.
  6.  *
  7.  * This file created from code mostly cadged from "dial.c"
  8.  * by Miquel van Smoorenburg.  Written by James S. Seymour.
  9.  * Copyright (c) 1998 by James S. Seymour (jseymour@jimsun.LinxNet.com)
  10.  *      Some mods for i18n  
  11.  *         Copyright (c) 1998 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  12.  *
  13.  * This program is free software; you can redistribute it and/or
  14.  * modify it under the terms of the GNU General Public License
  15.  * as published by the Free Software Foundation; either version
  16.  * 2 of the License, or (at your option) any later version.
  17.  */
  18. #include "port.h"
  19. #include "minicom.h"
  20. #include "intl.h"
  21. #include "getsdir.h"
  23. _PROTO(extern int wildmat, (char *s, char *p));
  25. /* We want the ANSI offsetof macro to do some dirty stuff. */
  26. #ifndef offsetof
  27. #  define offsetof(type, member) ((int) &((type *)0)->member)
  28. #endif
  30. /* Values for the "flags". */
  31. #define FL_ECHO 0x01 /* Local echo on/off. */
  32. #define FL_DEL 0x02 /* Backspace or DEL */
  33. #define FL_WRAP 0x04 /* Use autowrap. */
  34. #define FL_ANSI 0x08 /* Type of term emulation */
  35. #define FL_TAG 0x80 /* This entry is tagged. */
  36. #define FL_SAVE 0x0f /* Which portions of flags to save. */
  38. #define FILE_MWTR 1 /* main window top row */
  39. #define SUBM_OKAY 5 /* last entry in sub-menu */
  41. static int nrents = 1;
  43. _PROTO(static void file_tell, (char *s));
  44. /*
  45.  * replaced by macro (on test basis)
  46. _PROTO(static GETSDIR_ENTRY *getno, (int no, GETSDIR_ENTRY *dirdat));
  47.  */
  48. _PROTO(static void dhili, (int k));
  49. _PROTO(static void prdir, (WIN *dirw, int top, int cur, 
  50.     GETSDIR_ENTRY *dirdat, int longest));
  51. _PROTO(static void prone, (WIN *dirw, int top, int cur, 
  52.     GETSDIR_ENTRY *dirdat, int longest, int inverse));
  53. _PROTO(static void *set_work_dir, (void *existing, size_t min_len));
  54. _PROTO(static int new_filedir, (GETSDIR_ENTRY *o_dirdat, int flushit));
  55. _PROTO(static void goto_filedir, (char *new_dir, int absolut));
  56. _PROTO(static int tag_untag, (char *pat, int tag));
  57. _PROTO(static char *concat_list, (GETSDIR_ENTRY *d));
  58. _PROTO(static int init_filedir, (void));
  60. static WIN *dsub;
  61. #define WHAT_NR_OPTIONS 6
  62. static char *what =  N_(" [Goto]  [Prev]  [Show]  [Tag]  [Untag]  [Okay] ");
  63. /*                       123456789012345678901234567890123456789012345678
  64.                                   1         2         3         4        */
  65. static int dprev;
  67. /* Little menu. */
  68. static char *d_yesno[] = { N_("   Yes  "), N_("   No   "), CNULL };
  71. /*
  72.  * Tell a little message
  73.  */
  74. static void
  75. file_tell(s)
  76. char *s;
  77. {
  78.   WIN *w;
  80.   w = mc_tell(s);
  81.   sleep(1);
  82.   wclose(w, 1);
  83. }
  85. /*
  86.  * Highlight a choice in the horizontal menu.
  87.  */
  88. static void
  89. dhili(k)
  90. int k;
  91. {
  92.     int what_len = strlen (_(what)),
  93.         what_option_len = what_len / WHAT_NR_OPTIONS,
  94.         initial_y = (76 - (what_len >= 76 ? 74 : what_len)) / 2;
  95.        
  96.     if(k == dprev)
  97. return;
  99.     if(dprev >= 0) {
  100. wlocate(dsub, initial_y + what_option_len*dprev, 0);
  101. if(!useattr) {
  102.     wputs(dsub, " ");
  103. } else {
  104.     wsetattr(dsub, stdattr);
  105.     wprintf(dsub, "%*.*s", what_option_len - 1, what_option_len - 1,
  106.                           _(what) + what_option_len*dprev);
  107. }
  108.     }
  109.     dprev = k;
  110.     wlocate(dsub, initial_y + what_option_len*k, 0);
  111.     if(!useattr) {
  112. wputs(dsub, ">");
  113.     } else {
  114. wsetattr(dsub, XA_REVERSE | stdattr);
  115. wprintf(dsub, "%*.*s", what_option_len - 1, what_option_len - 1,
  116.                               _(what) + what_option_len*k);
  117. wsetattr(dsub, stdattr);
  118.     }
  119. }
  121. /*
  122.  */
  123. #define getno(n,d) ((n) >= nrents? (GETSDIR_ENTRY *) NULL : &((d)[n]))
  125. /*
  126.  * Get entry "no" in list.
  127. static GETSDIR_ENTRY *
  128. getno(no, dirdat)
  129. int no;
  130. GETSDIR_ENTRY *dirdat;
  131. {
  132.     if(no >= nrents)
  133. return((GETSDIR_ENTRY *) NULL);
  135.     return(&dirdat[no]);
  136. }
  137.  */
  139. /*
  140.  * Print the directory. Only draw from "cur" to bottom.
  141.  */
  142. static void
  143. prdir(dirw, top, cur, dirdat, longest)
  144. WIN *dirw;
  145. int top, cur;
  146. GETSDIR_ENTRY *dirdat;
  147. int longest;
  148. {
  149.     int f, start;
  150.     GETSDIR_ENTRY *d;
  151.     char f_str[BUFSIZ];
  152.     char t_str[BUFSIZ];
  154.     start = cur - top;
  155.     dirflush = 0;
  156.     sprintf(f_str, " %%-%ds", longest + 2);
  157.     wlocate(dirw, 0, start + FILE_MWTR);
  158.     for(f = start; f < dirw->ys - (1 + FILE_MWTR); f++) {
  159. if((d = getno(f + top, dirdat)) == (GETSDIR_ENTRY *) NULL)
  160.     break;
  161. if(d->cflags & FL_TAG)
  162.     wsetattr(dirw, XA_REVERSE | stdattr);
  163. if(S_ISDIR(d->mode)) {
  164.     snprintf(t_str, sizeof(t_str), "[%s]", d->fname);
  165.     wprintf(dirw, f_str, t_str);
  166. }
  167. else
  168.     wprintf(dirw, f_str, d->fname);
  169. wsetattr(dirw, XA_NORMAL | stdattr);
  170. wputc(dirw, 'n');
  171.     }
  172.     dirflush = 1;
  173.     wflush();
  174. }
  176. /*
  177.  * Print one directory entry.
  178.  */
  179. static void
  180. prone(dirw, top, cur, dirdat, longest, inverse)
  181. WIN *dirw;
  182. int top, cur;
  183. GETSDIR_ENTRY *dirdat;
  184. int longest;
  185. int inverse;
  186. {
  187.     char f_str[BUFSIZ];
  188.     char t_str[BUFSIZ];
  190.     dirflush = 0;
  191.     sprintf(f_str, " %%-%ds", longest + 2);
  192.     /*
  193.     if(dirdat->cflags & FL_TAG)
  194. wsetattr(dirw, XA_REVERSE | stdattr);
  195.      */
  196.     if(inverse)
  197. wsetattr(dirw, XA_REVERSE | stdattr);
  198.     if(S_ISDIR(dirdat->mode)) {
  199. snprintf(t_str, sizeof(t_str),  "[%s]", dirdat->fname);
  200. wprintf(dirw, f_str, t_str);
  201.     }
  202.     else
  203. wprintf(dirw, f_str, dirdat->fname);
  204.     wsetattr(dirw, XA_NORMAL | stdattr);
  205.     dirflush = 1;
  206.     wflush();
  207. }
  209. static WIN *main_w;
  210. static GETSDIR_ENTRY *dirdat, *d;
  211. static int cur = 0;
  212. static int ocur = 0;
  213. static int subm = SUBM_OKAY;
  214. static int quit = 0;
  215. static int top = 0;
  216. static int c = 0;
  217. static int pgud = 0;
  218. static int first = 1;
  219. static char *s;
  220. static int longest;
  221. static char file_title[BUFSIZ];
  222. static char cwd_str[BUFSIZ];
  223. static char *prev_dir = NULL;
  224. static char *work_dir = NULL;
  225. static char *d_work_dir = NULL;
  226. static char *u_work_dir = NULL;
  227. static int min_len = 1;
  228. static char wc_str[128] = "";
  229. static char wc_mem[128] = "";
  230. static int tag_cnt = 0;
  231. static int how_many = 0;
  232. static int down_loading = 0;
  233. static char *ret_buf = NULL;
  236. static void *
  237. set_work_dir(existing, min_len)
  238. void *existing;
  239. size_t min_len;
  240. {
  241.     void *vp;
  243.     vp = existing == NULL? malloc(min_len) : realloc(existing, min_len);
  245.     if(down_loading)
  246. d_work_dir = vp;
  247.     else
  248. u_work_dir = vp;
  250.     return(vp);
  251. }
  254. /*
  255.  * Initialize new file directory.
  256.  *
  257.  * Sets the current working directory.  Non-0 return = no change.
  258.  */
  259. static int
  260. new_filedir(o_dirdat, flushit)
  261. GETSDIR_ENTRY *o_dirdat;
  262. int flushit;
  263. {
  264.     static int dp_len = 0;
  265.     static char cwd_str_fmt[BUFSIZ] = "";
  266.     int new_dp_len,
  267.         fmt_len;
  268.     char disp_dir[80];
  269.     int what_len = strlen (_(what)),
  270.         initial_y = (76 - (what_len >= 76 ? 74 : what_len)) / 2;
  272.     cur      =  0;
  273.     ocur     =  0;
  274.     subm     =  SUBM_OKAY;
  275.     quit     =  0;
  276.     top      =  0;
  277.     c        =  0;
  278.     pgud     =  0;
  279.     first    =  1;
  280.     min_len  =  1;
  281.     dprev    = -1;
  282.     tag_cnt  =  0;
  284.     /* got to do some error-checking here!!!  Maybe use mcd(), too! */
  285.     if(prev_dir != NULL)
  286. free(prev_dir);
  287.     prev_dir = getcwd(NULL, BUFSIZ);
  289.     /*
  290.      * get last directory
  291.      */
  292.     work_dir = down_loading? d_work_dir : u_work_dir;
  294.     /*
  295.      * init working directory to default?
  296.      */
  297.     if(work_dir == NULL) {
  298. char *s = down_loading? (P_DOWNDIR) : (P_UPDIR);
  299. min_len = 1;
  301. if(*s != '/')
  302.     min_len += strlen(homedir) + 1;
  303. min_len += strlen(s);
  304. if(min_len < BUFSIZ)
  305.     min_len = BUFSIZ;
  307. work_dir = set_work_dir(NULL, min_len);
  309. if(*s == '/')
  310.   strncpy(work_dir, s, min_len);
  311. else
  312.   snprintf(work_dir, min_len, "%s/%s", homedir, s);
  313.     }
  314.     /* lop-off trailing "/" for consistency */
  315.     if(strlen(work_dir) > 1 && work_dir[strlen(work_dir) - 1] == '/')
  316. work_dir[strlen(work_dir) - 1] = (char) 0;
  318.     chdir(work_dir);
  320.     /* All right, draw the file directory! */
  322.     if(flushit) {
  323. dirflush = 0;
  324. winclr(main_w);
  325. wredraw(main_w, 1);
  326.     }
  328.     wcursor(main_w, CNORMAL);
  330.     /* select <a file|one or more files|a directory> for <upload|download> */
  331.     snprintf(file_title, sizeof(file_title), _("Select %s for %s"),
  332.       how_many? (how_many < 0? _("one or more files") : _("a file"))
  333.     : _("a directory"),
  334.       down_loading? _("download") : _("upload"));
  335.     wtitle(main_w, TMID, file_title);
  336.     if((new_dp_len = strlen(work_dir)) > dp_len) {
  337.       dp_len = new_dp_len;
  338.       snprintf(cwd_str_fmt, sizeof(cwd_str_fmt),
  339.        _("Directory: %%-%ds"), dp_len);
  340.     }
  341.     if (new_dp_len + (fmt_len = strlen(cwd_str_fmt)) > 75) {
  342.       snprintf(disp_dir, sizeof(disp_dir),
  343.        "...%s", work_dir + new_dp_len - 73 + fmt_len);
  344.       snprintf(cwd_str, sizeof(cwd_str), cwd_str_fmt, disp_dir);
  345.     }
  346.     else
  347.       snprintf(cwd_str, sizeof(cwd_str), cwd_str_fmt, work_dir);
  348.     wlocate(main_w, 0, 0);
  349.     wputs(main_w, cwd_str);
  351.     wlocate(dsub, initial_y, 0);
  352.     wputs(dsub, _(what));
  354.     wsetregion(main_w, 1, main_w->ys - FILE_MWTR);
  355.     main_w->doscroll = 0;
  357.     /* old dir to discard? */
  358.     if(o_dirdat != (GETSDIR_ENTRY *) NULL)
  359. free(o_dirdat);
  361.     /* get sorted directory */
  362.     if((nrents = getsdir(".", wc_str,
  363.       GETSDIR_PARNT|GETSDIR_NSORT|GETSDIR_DIRSF, 0, &dirdat, &longest)) < 0) {
  364. /* we really want to announce the error here!!! */
  365. wclose(main_w, 1);
  366. wclose(dsub, 1);
  367. free(dirdat);
  368. return(-1);
  369.     }
  371.     prdir(main_w, top, top, dirdat, longest);  
  372.     wlocate(main_w, initial_y, main_w->ys - FILE_MWTR);
  373.     wputs(main_w, _("( Escape to exit, Space to tag )"));
  374.     dhili(subm);
  375.     /* this really needs to go in dhili !!!*/
  376.     wlocate(main_w, 0, cur + FILE_MWTR - top);
  377.     if(flushit) {
  378. dirflush = 1;
  379. wredraw(dsub, 1);
  380.     }
  382.     return(0);
  383. }
  386. /*
  387.  * Goto a new directory
  388.  */
  389. static void
  390. goto_filedir(new_dir, absolut)
  391. char *new_dir;
  392. int absolut;
  393. {
  394.     if(strcmp(new_dir, "..") == 0) {
  395. if(strcmp(work_dir, "/")) {
  396.     char *sp = strrchr(work_dir, '/');
  397.     *sp = (char) 0;
  398.     if(strlen(work_dir) == 0)
  399. strcpy(work_dir, "/");
  400. }
  401. else {
  402.     file_tell(_("Can't back up!"));
  403.     return;
  404. }
  405.     }
  406.     else if(!absolut) {
  407. int new_len = strlen(work_dir) + 1; /* + '/' */
  408. if((new_len += strlen(new_dir) + 1) > min_len) {
  409.     min_len = new_len;
  410.     work_dir = set_work_dir(work_dir, min_len);
  411. }
  412. if(strcmp(work_dir, "/") != 0)
  413.     strcat(work_dir, "/");
  414. strcat(work_dir, new_dir);
  415.     }
  416.     else {
  417. int new_len = 1;
  418. if(*new_dir != '/')
  419.     new_len += strlen(homedir) + 1;
  420. new_len += strlen(new_dir);
  421. if(min_len < new_len)
  422.     min_len = new_len;
  424. work_dir = set_work_dir(work_dir, min_len);
  426. if(*new_dir == '/')
  427.     strncpy(work_dir, new_dir, min_len);
  428. else
  429.     snprintf(work_dir, min_len, "%s/%s", homedir, new_dir);
  430.     }
  431.     new_filedir(dirdat, 1);
  432. }
  435. /*
  436.  * Initialize the file directory.
  437.  */
  438. static int
  439. init_filedir()
  440. {
  441.     int x1, x2;
  442.     int retstat = -1;
  444.     dirflush = 0;
  445.     x1 = (COLS / 2) - 37;
  446.     x2 = (COLS / 2) + 37;
  447.     dsub = wopen(x1 - 1, LINES - 3, x2 + 1, LINES - 3, BNONE, 
  448. stdattr, mfcolor, mbcolor, 0, 0, 1);
  449.     main_w = wopen(x1, 2, x2, LINES - 6, BSINGLE, stdattr, mfcolor,
  450. mbcolor, 0, 0, 1);
  452.     if(ret_buf != NULL ||
  453.       (retstat = ((ret_buf = malloc(BUFSIZ)) == NULL)? -1 : 0) == 0) {
  454. retstat = new_filedir((GETSDIR_ENTRY *) NULL, 0);
  455. dirflush = 1;
  456. wredraw(dsub, 1);
  457.     }
  458.     return(retstat);
  459. }
  462. static int
  463. tag_untag(pat, tag)
  464. char *pat;
  465. int tag;
  466. {
  467.     GETSDIR_ENTRY *my_d = dirdat;
  468.     int indxr, cntr;
  470.     for(indxr = nrents, cntr = 0; indxr; --indxr, ++my_d)
  471. if(S_ISREG(my_d->mode) && wildmat(my_d->fname, pat)) {
  472.     if(tag) {
  473. my_d->cflags |= FL_TAG;
  474. ++cntr;
  475.     }
  476.     else if(my_d->cflags & FL_TAG) {
  477. my_d->cflags &= ~FL_TAG;
  478. ++cntr;
  479.     }
  480. }
  482.     return(cntr);
  483. }
  486. /*
  487.  * concatenate tagged files into a buffer
  488.  */
  489. static char *
  490. concat_list(d)
  491. GETSDIR_ENTRY *d;
  492. {
  493.     GETSDIR_ENTRY *my_d;
  494.     int indxr, len;
  496.     my_d = d;
  497.     for(indxr = nrents, len = 0; indxr; --indxr, ++my_d)
  498. if(my_d->cflags & FL_TAG)
  499.     len += strlen(my_d->fname) + 1;
  501.     if(len) {
  502. if(len > BUFSIZ) {
  503.   if((ret_buf = realloc(ret_buf, len)) == NULL) {
  504.       file_tell(_("Too many files tagged - buffer would overflow"));
  505.       return(NULL);
  506.   }
  507. }
  508.     
  509. *ret_buf = (char) 0;
  510. my_d = d;
  511. for(indxr = nrents; indxr; --indxr, ++my_d)
  512.     if(my_d->cflags & FL_TAG) {
  513. /* this could be *much* more efficient */
  514. strcat(ret_buf, my_d->fname);
  515. strcat(ret_buf, " ");
  516.     }
  518. ret_buf[strlen(ret_buf) - 1] = (char) 0;
  519. return(ret_buf);
  520.     }
  522.     return(NULL);
  523. }
  526. /*
  527.  * Draw the file directory.
  528.  *
  529.  *      howmany - How many files can be selected
  530.  *       0 = none (for directory selection only, as in "rz")
  531.  *       1 = one  (for single-file up-/down-loads, as in "rx")
  532.  *      -1 = any number (for multiple files, as in "sz")
  533.  *
  534.  *    downloading - Is this for download selection?
  535.  *       0 = no
  536.  *       1 = yes - when single file selected, see if it exists
  537.  */
  538. char *
  539. filedir(howmany, downloading)
  540. int howmany;
  541. int downloading;
  542. {
  543.     time_t click_time = (time_t) 0;
  545.     how_many = howmany;
  546.     down_loading = downloading;
  547.     init_filedir();
  549. again:
  550.     wlocate(main_w, 0, cur + FILE_MWTR - top);
  551.     if(first) {
  552. wredraw(main_w, 1);
  553. first = 0;
  554.     }
  555.     while(!quit) {
  556. d = getno(cur, dirdat);
  557. /*
  558. if(S_ISDIR(d->mode))
  559.     prone(main_w, top, top, d, longest, 0);
  560. */
  561. switch(c = wxgetch()) {
  562.     case K_UP:
  563.     case 'k':
  564. /*
  565. if(S_ISDIR(d->mode))
  566.     prone(main_w, top, top, d, longest, 1);
  567. */
  568. cur -= (cur > 0);
  569. break;
  570.     case K_DN:
  571.     case 'j':
  572. /*
  573. if(S_ISDIR(d->mode))
  574.     prone(main_w, top, top, d, longest, 1);
  575. */
  576. cur += (cur < nrents - 1);
  577. break;
  578.     case K_LT:
  579.     case 'h':
  580. subm--;
  581. if(subm < 0)
  582.     subm = SUBM_OKAY;
  583. break;
  584.     case K_RT:
  585.     case 'l':
  586. subm = (subm + 1) % 6;
  587. break;
  588.     case K_PGUP:
  589.     case '02': /* Control-B */
  590. pgud = 1;
  591. quit = 1;
  592. break;
  593.     case K_PGDN:
  594.     case '06': /* Control-F */
  595. pgud = 2;
  596. quit = 1;
  597. break;
  598.     case 'f':    /* Find. */
  599. subm = 1;
  600. quit = 1;
  601. break;
  602.     case ' ':    /* Tag if not directory */
  603. if(S_ISDIR(d->mode)) {
  604.     time_t this_time = time((time_t *) NULL);
  605.     if(this_time - click_time < 2) {
  606. GETSDIR_ENTRY *d2 = getno(cur, dirdat);
  607. goto_filedir(d2->fname, 0);
  608. click_time = (time_t) 0;
  609.     }
  610.     else
  611. click_time = this_time;
  612. }
  613. else {
  614.     if(how_many) {
  615. if((d->cflags ^= FL_TAG) & FL_TAG) {
  616.     if(tag_cnt && how_many == 1) {
  617. d->cflags &= ~FL_TAG;
  618. file_tell(_("Can select only one!"));
  619. break;
  620.     }
  621.     ++tag_cnt;
  622. }
  623. else
  624.     --tag_cnt;
  625. wlocate(main_w, 0, cur + FILE_MWTR - top);
  626. prone(main_w, top, top, d, longest, d->cflags & FL_TAG);
  627. wputc(main_w, 'n');
  628. cur += (cur < nrents - 1);
  629.     }
  630. }
  631. break;
  633.     case 'G':
  634.     case 'g':
  635. subm = 0;
  636. goto real_programmers_use_gotos;
  637. break;
  638.     case 'P':
  639.     case 'p':
  640. subm = 1;
  641. goto real_programmers_use_gotos;
  642. break;
  643.     case 'S':
  644.     case 's':
  645. subm = 2;
  646. goto real_programmers_use_gotos;
  647. break;
  648.     case 'T':
  649.     case 't':
  650. subm = 3;
  651. goto real_programmers_use_gotos;
  652. break;
  653.     case 'U':
  654.     case 'u':
  655. subm = 4;
  656. goto real_programmers_use_gotos;
  657. break;
  658.     case 'O':
  659.     case 'o':
  660. subm = SUBM_OKAY;
  661. real_programmers_use_gotos:
  662. c = 'n';
  663. quit = 1;
  664. break;
  666.     case '33':
  667.     case 'r':
  668.     case 'n':
  669. quit = 1;
  670. break;
  672.     default:
  673. break;
  674. }
  676. if(c != ' ')
  677.     click_time = (time_t) 0;
  679. if(cur < top) {
  680.     top--;
  681.     prdir(main_w, top, top, dirdat, longest);
  682. }
  683. if(cur - top > main_w->ys - (2 + FILE_MWTR)) {
  684.     top++;
  685.     prdir(main_w, top, top, dirdat, longest);
  686. }
  687. /*
  688. if(cur != ocur)
  689.     wlocate(main_w, 0, cur + FILE_MWTR - top);
  690.  */
  692. ocur = cur;
  693. dhili(subm);
  694. /* this really needs to go in dhili !!!*/
  695. wlocate(main_w, 0, cur + FILE_MWTR - top);
  696.     }
  698.     quit = 0;
  699.     /* ESC means quit */
  700.     if(c == '33') {
  701. wclose(main_w, 1);
  702. wclose(dsub, 1);
  703. free(dirdat);
  704. return(NULL);
  705.     }
  706.     /* Page up or down ? */
  707.     if(pgud == 1) { /* Page up */
  708. ocur = top;
  709. top -= main_w->ys - (1 + FILE_MWTR);
  710. if(top < 0)
  711.     top = 0;
  712. cur = top;
  713. pgud = 0;
  714. if(ocur != top)
  715.     prdir(main_w, top, cur, dirdat, longest);
  716. ocur = cur;
  717. goto again;
  718.     }
  719.     if(pgud == 2) { /* Page down */
  720. ocur = top;
  721. if(top < nrents - main_w->ys + (1 + FILE_MWTR)) {
  722.     top += main_w->ys - (1 + FILE_MWTR);
  723.     if(top > nrents - main_w->ys + (1 + FILE_MWTR)) {
  724. top = nrents - main_w->ys + (1 + FILE_MWTR);
  725.     }
  726.     cur = top;
  727. } else
  728.     cur = nrents - 1;
  729. pgud = 0;
  730. if(ocur != top)
  731.     prdir(main_w, top, cur, dirdat, longest);
  732. ocur = cur;
  733. goto again;
  734.     }
  736.     if(c =='r' || c == 'n') {
  737. switch(subm) {
  738.     case 0:
  739. /* Goto directory */
  740. {
  741.     char buf[128];
  742.     char *s;
  743.     strncpy(buf, down_loading? P_DOWNDIR : P_UPDIR,
  744. sizeof(buf) -1);
  745.     s = input(_("Goto directory:"), buf);
  746. /*     if(s == CNULL || *s == (char) 0) */
  747.     if(s == CNULL)
  748. break;
  749.     goto_filedir(buf, 1);
  750. }
  751. break;
  752.     case 1:
  753. /* Previous directory */
  754. goto_filedir(prev_dir, 1);
  755. break;
  756.     case 2:
  757. /* File (wildcard) spec */
  758. {
  759.     char *s = input(_("Filename pattern:"), wc_mem);
  760.     if(s == CNULL || *s == (char) 0)
  761. break;
  762.     strcpy(wc_str, wc_mem);
  763.     new_filedir(dirdat, 1);
  764.     wc_str[0] = (char) 0;
  765. }
  766. break;
  767.     case 3:
  768. /* Tag */
  769. if(how_many == 1)
  770.     file_tell(_("Can select only one!"));
  771. else if(how_many == -1) {
  772.     char tag_buf[128];
  773.     char *s;
  774.     strncpy(tag_buf, wc_mem, 128);
  775.     
  776.     s = input(_("Tag pattern:"), tag_buf);
  777.     if(s != CNULL && *s != (char) 0) {
  778. int newly_tagged;
  779. if((newly_tagged = tag_untag(tag_buf, 1)) == 0) {
  780.     file_tell(_("No file(s) tagged"));
  781.     goto tag_end;
  782. }
  783. tag_cnt += newly_tagged;
  784. prdir(main_w, top, top, dirdat, longest);  
  785.     }
  786. }
  787. tag_end:
  788. break;
  789.     case 4:
  790. /* Untag */
  791. {
  792.     char tag_buf[128];
  793.     char *s;
  794.     int untagged;
  795.     strncpy(tag_buf, wc_mem, 128);
  796.     
  797.     s = input(_("Untag pattern:"), tag_buf);
  798.     if(s == CNULL || *s == (char) 0)
  799. goto untag_end;
  800.     if((untagged = tag_untag(tag_buf, 0)) == 0) {
  801. file_tell(_("No file(s) untagged"));
  802. goto untag_end;
  803.     }
  804.     tag_cnt -= untagged;
  805.     prdir(main_w, top, top, dirdat, longest);  
  806. }
  807. untag_end:
  808. break;
  809.     case 5:
  810. {
  811.   /* Done */
  812.   char *ret_ptr = NULL; /* failsafe: assume failure */
  814.   if(how_many != 0 && !tag_cnt) {
  816.     while(1) {
  817.       s = input(_("No file selected - enter filename:"),
  818. ret_buf);
  819.       if(s != CNULL && *s != (char) 0) {
  820. int f_exist = access(ret_buf, F_OK);
  821. if(down_loading) {
  822.   if(f_exist != -1) {
  823.     /* ask 'em if they're *sure* */
  824.     char buf[BUFSIZ];
  826.     snprintf(buf, sizeof(buf), 
  827.     _("File: "%s" exists!. Over-write?"),
  828.     ret_buf);
  829.     if(ask(buf, d_yesno) == 0) {
  830.       ret_ptr = ret_buf;
  831.       break;
  832.     }
  833.   }
  834.   else {
  835.     ret_ptr = ret_buf;
  836.     break;
  837.   }
  838. }
  839. else {
  840.   if(f_exist == -1)
  841.     file_tell(_("no such file!"));
  842.   else {
  843.     ret_ptr = ret_buf;
  844.     break;
  845.   }
  846. }
  847.       }
  848.       else {
  849. /* maybe want to ask: "abort?", here */
  850. goto again;
  851.       }
  852.     }
  853.   }
  854.   else {
  855.     /* put 'em in a buffer for return */
  856.     if(how_many == 0) {
  857.       /* current working directory */
  858.       ret_ptr = work_dir;
  859.     }
  860.     else {
  861.       ret_ptr = concat_list(dirdat);
  862.     }
  863.   }
  865.   wclose(main_w, 1);
  866.   wclose(dsub, 1);
  867.   free(dirdat);
  868.   return(ret_ptr);
  869. }
  870. break;
  871.     default:
  872. /* should "beep", I guess (? shouldn't get here) */
  873. file_tell("BEEP!");
  874. break;
  875. } /* switch */
  876.     }
  878.     goto again;
  879. }