windiv.c
上传用户:tianjinjs
上传日期:2007-01-05
资源大小:309k
文件大小:9k
源码类别:

Modem编程

开发平台:

Unix_Linux

  1. /*
  2.  * windiv.c Some extra window routines for minicom, that
  3.  * I did not want to fold into window.c
  4.  *
  5.  * This file is part of the minicom communications package,
  6.  * Copyright 1991-1995 Miquel van Smoorenburg.
  7.  *
  8.  * This program is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU General Public License
  10.  * as published by the Free Software Foundation; either version
  11.  * 2 of the License, or (at your option) any later version.
  12.  *
  13.  * hgk+jl 02.98 File selection window (no longer used this way..)
  14.  */
  15. #include <dirent.h>
  16. #include <sys/stat.h>
  17. #include "port.h"
  18. #include "minicom.h"
  19. #include "intl.h"
  20. #ifndef max
  21.   #define max(a,b) ((a)>(b)?(a):(b))
  22. #endif
  23. #ifndef min
  24.   #define min(a,b) ((a)<(b)?(a):(b))
  25. #endif
  26. /*
  27.  * Popup a window and put a text in it.
  28.  */  
  29. /*VARARGS1*/
  30. WIN *mc_tell(s, a1, a2, a3, a4)
  31. char *s, *a1, *a2, *a3, *a4;
  32. {
  33.   WIN *w;
  34.   char buf[128];
  35.   if (stdwin == NIL_WIN) return(NULL);
  36.   snprintf(buf, sizeof(buf), s, a1, a2, a3, a4);
  37.   w = wopen((COLS / 2) - 2 - strlen(buf) / 2, 8,
  38.     (COLS / 2) + 2 + strlen(buf) / 2, 10,
  39.         BDOUBLE, stdattr, mfcolor, mbcolor, 0, 0, 1);
  40.   wcursor(w, CNONE);
  41.   wlocate(w, 2, 1);
  42.   wputs(w, buf);
  43.   wredraw(w, 1);
  44.   return(w);
  45. }
  46. /*
  47.  * Show an error message.
  48.  */
  49. /*VARARGS1*/
  50. void werror(s, a1, a2, a3, a4)
  51. char *s, *a1, *a2, *a3, *a4;
  52. {
  53.   WIN *tellwin;
  54.   
  55.   tellwin = mc_tell(s, a1, a2, a3, a4);
  56.   sleep(2);
  57.   wclose(tellwin, 1);
  58. }
  59. /*
  60.  * Vertical "wselect" function.
  61.  */
  62. int ask(what, s)
  63. char *what;
  64. char *s[];
  65. {
  66.   int num = 0;
  67.   int cur = 0, ocur = 0;
  68.   int f, c;
  69.   WIN *w;
  70.   int size, offs;
  71.   for(f = 0; s[f]; f++) num++;
  72.   size = 5 * num;
  73.   offs = 0;
  74.   if (strlen(what) > 2 * size + 4) {
  75. size = strlen(what) / 2 + 2;
  76. offs = size - 5*num;
  77.   }
  78.   w = wopen((COLS / 2) - size , 8, (COLS / 2) + 1 + size, 9,
  79. BSINGLE, stdattr, mfcolor, mbcolor, 0, 0, 1);
  80.   dirflush = 0;
  81.   wcursor(w, CNONE);
  82.   wlocate(w, 1 + size - (strlen(what) / 2), 0);
  83.   wputs(w, what);
  84.   for(f = 1; f < num; f++) {
  85.    wlocate(w, 2 + offs + 10*f, 1);
  86.    wputs(w, _(s[f]));
  87.   }
  88.   wredraw(w, 1);
  89.   while(1) {
  90.    wlocate(w, 2 + offs + 10*cur, 1);
  91. if (!useattr)
  92. wprintf(w, ">%s", _(s[cur]) + 1);
  93. else {
  94.    wsetattr(w, XA_REVERSE | stdattr);
  95.    wputs(w, _(s[cur]));
  96. }
  97.    ocur = cur;
  98.    wflush();
  99.    switch(c = wxgetch()) {
  100.    case ' ':
  101.    case 27:
  102.    case 3:
  103.    dirflush = 1;
  104.    wclose(w, 1);
  105.    return(-1);
  106.    case 'r':
  107.    case 'n':
  108.    dirflush = 1;
  109.    wclose(w, 1);
  110.    return(cur);
  111.    case K_LT:
  112.    case 'h':
  113.    cur--;
  114.    if (cur < 0) cur = num - 1;
  115.    break;
  116.    default:
  117.    cur = (cur + 1) % num;
  118.    break;
  119.    }
  120.    wlocate(w, 2 + offs + 10*ocur, 1);
  121.    wsetattr(w, stdattr);
  122. if (!useattr)
  123. wputs(w, " ");
  124. else
  125.    wputs(w, _(s[ocur]));
  126.   }
  127. }
  128. extern int editline();
  129. /*
  130.  * Popup a window and ask for input.
  131.  */
  132. char *input(s, buf)
  133. char *s;
  134. char *buf;
  135. {
  136.   WIN *w;
  137.   w = wopen((COLS / 2) - 20, 11, (COLS / 2) + 20, 12,
  138. BDOUBLE, stdattr, mfcolor, mbcolor, 1, 0, 1);
  139.   wputs(w, s);
  140.   wlocate(w, 0, 1);
  141.   wprintf(w, "> %-38.38s", buf);
  142.   wlocate(w, 2, 1);
  143.   if (wgets(w, buf, 38, 128) < 0) buf = CNULL;
  144.   wclose(w, 1);
  145.   return(buf);
  146. }
  147. #if 0  /* these functions have been replaced */
  148. /*--- File-Select-Extension by H.G.Keller, modified by jl ------------
  149.  *
  150.  * 
  151.  * a bit simpler as Smoorenburg's but considerably more convinient 
  152.  * than the previous case
  153.  *
  154.  */
  155. /* Compare two directory entries. */
  156. static int cmpdir(d1, d2)
  157. struct dirent *d1;
  158. struct dirent *d2;
  159. {
  160.   return(strcmp(d1->d_name, d2->d_name));
  161. }
  162. /* Sort the directory list. */
  163. static void sortdir( base, elements )
  164. void *base;
  165. size_t elements;
  166. {
  167.   qsort (base, elements, sizeof(struct dirent), cmpdir);
  168. }
  169. char *fselect(file_dir)
  170. char *file_dir;
  171. {
  172.   #define ESC 0x1B
  173.   #define CR 0xD
  174.   #define TRUE  (1==1)
  175.   #define FALSE (1==0)
  176.   char* SELECTION_TITLE = _("Select File(s) to Upload");
  177.   static char fname[2048];
  178.   static char buf[160];
  179.   WIN *w;
  180.   DIR *dir;
  181.   struct dirent *dirent;
  182.   struct dirent *dirlist;
  183.   int *selflag;
  184.   int nMaxFiles, nCnt;
  185.   int nNrOfRows, nMaxWidth;
  186.   int strow, nMaxRows, nOldAttr;
  187.   int   nRunFlag, hlight;
  188.   struct stat statBuf;
  189.   /*
  190.    * generate File-List
  191.    */
  192.   *fname = '';
  193.   if ((dir = opendir(file_dir)) == NULL) {
  194.     wbell();
  195.     return(fname); 
  196.   }
  197.   nMaxFiles = 0;
  198.   while(1){   /* count all the entries */
  199.     dirent = readdir (dir);
  200.     if (dirent)
  201.       nMaxFiles++;
  202.     else
  203.       break;
  204.   }
  205.   closedir(dir);
  206.   /*
  207.    * allocate memory for the list and fill the list
  208.    */
  209.   dirlist = (struct dirent *)malloc( sizeof(struct dirent) * (nMaxFiles+1) );
  210.   selflag = calloc(nMaxFiles+1, sizeof(int));
  211.   if( dirlist ){
  212.     dir = opendir (file_dir); /* check is not needed again */
  213.     nCnt = nMaxWidth = 0;
  214.     while( (dirent = readdir( dir )) ){
  215.       /* skip dir's, special-files, sockets ... */
  216.       if((strcmp(dirent->d_name, ".") == 0 ) 
  217.  || (strcmp( dirent->d_name, ".." ) == 0))
  218. continue;
  219.       stat(dirent->d_name, &statBuf);
  220.       if (!S_ISREG(statBuf.st_mode))
  221. continue;
  222.       /* get regular files */
  223.       dirlist[nCnt].d_ino    = dirent->d_ino;
  224.       dirlist[nCnt].d_off    = dirent->d_off;
  225.       dirlist[nCnt].d_reclen = dirent->d_reclen;
  226.       strcpy(dirlist[nCnt].d_name, dirent->d_name );
  227.       nMaxWidth = max(nMaxWidth, strlen(dirent->d_name));
  228.       nCnt++;
  229.     }
  230.     sortdir( dirlist, nMaxRows=nCnt ); 
  231.     nNrOfRows  = min( 18, nCnt );
  232.     nMaxWidth  = max(min( COLS-4, nMaxWidth ), strlen(SELECTION_TITLE)+5);
  233.     nMaxWidth /= 2; nMaxWidth++;
  234.     
  235.     w = wopen( (COLS / 2)-nMaxWidth,   12-nNrOfRows/2, 
  236.                (COLS / 2)+nMaxWidth-1, 12+nNrOfRows/2-((nNrOfRows+1)&0x1),
  237. BDOUBLE, stdattr, mfcolor, mbcolor, 1, 0, 1);
  238.     wcursor(w, CNONE);
  239.     wtitle( w, TMID, SELECTION_TITLE );
  240.     nRunFlag = TRUE;
  241.     hlight = strow = 0;
  242.     buf[0]='';
  243.     while( nRunFlag ){
  244.       wlocate(w, 1, 0);
  245.       for( nCnt=0; nCnt < nNrOfRows; nCnt++ ){
  246.         if( strlen(dirlist[nCnt+strow].d_name) ){
  247.           nOldAttr = w->attr;
  248.           if( nCnt == hlight )
  249.     w->attr = COLATTR(mfcolor, mbcolor);
  250.   else if(selflag[nCnt+strow])
  251.     w->attr = COLATTR(mbcolor, mfcolor);
  252.           strncpy(fname,dirlist[nCnt+strow].d_name,
  253.   2*nMaxWidth-1);
  254.           *(fname+2*nMaxWidth-1) = '';
  255.           wputs(w, fname );  wclreol(w);
  256.           wlocate(w, 1, 1+nCnt);
  257.           w->attr = nOldAttr;
  258.         }
  259.         wflush();
  260.       }
  261.       
  262.       switch( wxgetch() ){
  263.         case K_UP:  
  264.         case '+':
  265.         case 'k':
  266.         case 'K':
  267.           if( hlight )
  268.     hlight--;
  269.           else if( strow )
  270.     strow--;
  271.   break;
  272.         case '-':
  273.         case K_DN:
  274.         case 'j':
  275.         case 'J':
  276.           if( hlight < nNrOfRows-1 )
  277.     hlight++;
  278.           else if( nMaxRows - strow > nNrOfRows )
  279.     strow++;
  280.   break;
  281.         case ESC:   
  282.           nRunFlag=FALSE;
  283.   break;
  284.         case CR:    
  285.   nRunFlag = FALSE;
  286.         case ' ':  /* do this also with CR.. */
  287.   if(strlen(buf) + strlen(dirlist[strow+hlight].d_name) <
  288.      sizeof(buf) + 2 && selflag[strow+hlight]==0) {
  289.     strcat(buf, dirlist[strow+hlight].d_name);
  290.     strcat(buf," ");
  291.     selflag[strow+hlight] = 1;
  292.   }
  293.   if (hlight < nNrOfRows-1)
  294.     hlight++;
  295.   break;
  296.       }
  297.     }
  298.     free( dirlist );
  299.     wclose(w, 1);
  300.   }
  301.   else{
  302.     /*
  303.      * Memory-Allocation-Error
  304.      */
  305.   }
  306.   return( (char *)buf);
  307. }
  308. #endif
  309. #if 0
  310. /* Here I mean to work on a file selection window. */
  311. /* Maybe minicom 1.70 - MvS. */
  312. struct file {
  313.   char *name;
  314.   char isdir;
  315. };
  316. static struct filelist **list;
  317. static int nrlist;
  318. /* Compare two directory entries. */
  319. static int cmpdir(d1, d2)
  320. struct file *d1;
  321. struct file *d2;
  322. {
  323.   if (strcmp(d1->name, "..")) return(-1);
  324.   return(strcmp(d1->name, d2->name));
  325. }
  326. /* Sort the directory list. */
  327. static int sortdir()
  328. {
  329.   qsort(list, nrlist, sizeof(struct file *), cmpdir);
  330. }
  331. /* Create file list of directory. */
  332. static int makelist()
  333. {
  334.   DIR *dir;
  335.   struct dirent *d;
  336.   struct file **new;
  337.   int left = 0;
  338.   int f;
  339.   if ((dir = opendir(".")) == NULL) {
  340. wbell();
  341. return(-1);
  342.   }
  343.   /* Free the old list if nessecary. */
  344.   if (list) {
  345. for(f = 0; f < nrlist; f++) free(list[f]);
  346. free(list);
  347. list = NULL;
  348.   }
  349.   while(d = readdir(dir)) {
  350. /* Skip "." entry. */
  351. if (strcmp(d->d_name, ".") == 0) continue;
  352. /* Add this to our list. */
  353. if (left == 0) {
  354. /* Re-malloc. */
  355. if ((new = malloc(nrents + 10 * sizeof(void *))) == NULL) {
  356. closedir(dir);
  357. return(-1);
  358. }
  359. if (list) {
  360. memcpy(new, list, nrlist * sizeof(struct file **));
  361. free(list);
  362. }
  363. list = new;
  364. left = 10;
  365. }
  366. /* Stat this file. */
  367. #ifdef S_IFLNK
  368. (void) lstat(d->d_name, &st);
  369. #else
  370. (void) stat(d->d_name, &st);
  371. #endif
  372. list[nrlist]->isdir = S_ISDIR(st.st_mode);
  373. f = 0;
  374. if (S_ISDIR(st.st_mode)) f = '/';
  375. #ifdef S_ISLNK
  376. if (S_ISLNK(st.st_mode)) f = '@';
  377. #endif
  378. #ifdef S_ISFIFO
  379. if (S_ISFIFO(st.st_mode)) f = '|';
  380. #endif
  381. #ifdef S_ISSOCK
  382. if (S_ISSOCK(st.st_mode)) f = '=';
  383. #endif
  384. if (S_ISREG(st.st_mode) && (st.st_mode & 0x111)) f = '*';
  385. /* Fill in name. */
  386. if ((list[nrlist]->name = malloc(strlen(d->d_name + 2))) == NULL) {
  387. closedir(dir);
  388. return(-1);
  389. }
  390. sprintf(list[nrlist]->name, "%s%c", d->d_name, f);
  391. nrlist++;
  392. left--;
  393.   }
  394.   closedir(dir);
  395.   return(0);
  396. }
  397. /* Select a file. */
  398. char *wfilesel()
  399. {
  400.   WIN *w;
  401.   char cwd[64];
  402.   /* Open one window. */
  403.   w = wopen((COLS / 2) - 20, 5, (COLS / 2) + 20, 20,
  404. BDOUBLE, stdattr, mfcolor, mbcolor, 1, 0, 1);
  405.   getcwd(cwd, 64);
  406.   while(1) {
  407. makelist();
  408. sortdir();
  409. #endif /* DEVEL */