home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / ABUSESRC.ZIP / AbuseSrc / macabuse / src / text_gui.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-20  |  11.1 KB  |  495 lines
  1. #include "lisp.hpp"
  2. #include "system.h"
  3. #include "lisp_gc.hpp"
  4. #include "dprint.hpp"
  5. #include <ctype.h>
  6.  
  7. #include <unistd.h>
  8. #include <stdio.h>
  9. #include <string.h>
  10. #include <stdlib.h>
  11.  
  12. #if defined( __MAC__ )
  13. extern char *macify_name(char *s);
  14. #elif defined( __WATCOMC__ )
  15. #include <sys\types.h>
  16. #include <direct.h>
  17. #define make_dir(dir) mkdir(dir)
  18. #else
  19. #include <sys/stat.h>
  20. #define make_dir(dir) mkdir(dir,S_IRWXU | S_IRWXG | S_IRWXO)
  21.  
  22. void modify_install_path(char *path) { ; }
  23. #endif
  24.  
  25.  
  26. #ifdef __WATCOMC__
  27. void modify_install_path(char *path)
  28. {
  29.   char ret[100],*r,*i_path=path;
  30.   int dc=0;
  31.   r=ret;
  32.  
  33.   if (path[1]==':')   // if "c:\blahblah "  skip the c:
  34.   {
  35.     r[0]=path[0];
  36.     r[1]=path[1];
  37.     r+=2;
  38.     path+=2;
  39.   }
  40.  
  41.   while (*path)       // eliminate double slashes and reduce more than 8 char dirs
  42.   {
  43.     
  44.     if (*path=='\\' || *path=='/')
  45.     {
  46.       dc=0;
  47.       *r=*path;
  48.       r++;
  49.       path++;
  50.       while (*path=='\\' || *path=='/') path++;
  51.     } else if (dc<8)
  52.     {
  53.       dc++;
  54.       *r=*path;
  55.       r++;
  56.       path++;
  57.     } else path++;
  58.   }
  59.  
  60.  
  61.   *r=0;
  62.   strcpy(i_path,ret);
  63. }
  64.  
  65. #include <dos.h>
  66. #endif
  67.  
  68. int change_dir(char *path)
  69. {
  70. #ifdef __WATCOMC__
  71.   unsigned cur_drive;
  72.   _dos_getdrive(&cur_drive);
  73.   if (path[1]==':')
  74.   {
  75.     unsigned total;
  76.     _dos_setdrive(toupper(path[0])-'A'+1,&total);
  77.  
  78.  
  79.     unsigned new_drive;
  80.     _dos_getdrive(&new_drive);
  81.  
  82.     if (new_drive!=toupper(path[0])-'A'+1)
  83.     {
  84.       return 0;
  85.     }
  86.  
  87.     path+=2;
  88.   }
  89.   
  90.   int er=chdir(path);
  91.   if (er)
  92.   {
  93.     unsigned total;
  94.     _dos_setdrive(cur_drive,&total);
  95.   }
  96.   return !er;
  97. #else
  98.   int ret;    // weird, used to include =chdir(path)
  99. #ifdef __MAC__
  100.   ret=chdir(macify_name(path));
  101. #else
  102.   ret=chdir(path);
  103. #endif
  104.   return ret==0;
  105. #endif  
  106. }
  107.  
  108. long K_avail(char *path);
  109.  
  110. #ifdef __WATCOMC__
  111. #include "i86.h"
  112. #include <conio.h>
  113. #include <bios.h>
  114.  
  115. long K_avail(char *path)
  116. {
  117.   unsigned drive=0;
  118.   if (path[1]==':') drive=toupper(path[0])-'A'+1;
  119.   else _dos_getdrive(&drive);
  120.  
  121.   struct diskfree_t f;
  122.   _dos_getdiskfree(drive,&f);
  123.   
  124.   return (long)((long)f.sectors_per_cluster*(long)f.bytes_per_sector/1024)*(long)f.avail_clusters;
  125. }
  126.  
  127. void set_cursor(int x, int y) {
  128.   union  REGS in,out;
  129.   memset(&in,0,sizeof(in));
  130.   in.w.ax=0x0200; in.w.bx=0; in.w.dx=(y<<8)|x;
  131.   int386(0x10,&in,&in);
  132. }
  133.  
  134. void put_char(int x, int y, int val, int color) { *((unsigned short *)(0xb8000+y*2*80+x*2))=(val)|(color<<8); }
  135. unsigned short get_char(int x, int y, int val) { return *((unsigned short *)(0xb8000+y*2*80+x*2)); }
  136. void put_string(int x,int y,char *s, int c) { while (*s) put_char(x++,y,*(s++),c); }
  137. void bar(int x1, int y1, int x2, int y2, int v, int c)
  138. { int x,y; 
  139.   for (x=x1;x<=x2;x++)
  140.     for (y=y1;y<=y2;y++)
  141.       put_char(x,y,v,c);
  142. }
  143.  
  144. void cls() { bar(0,0,79,25,' ',0x07); set_cursor(0,0); }
  145.  
  146. void box(int x1, int y1, int x2, int y2, int c)
  147. { 
  148.   unsigned char bc[]={  218,191,217,192,196,179 };
  149.   put_char(x1,y1,bc[0],c);
  150.   put_char(x2,y1,bc[1],c);
  151.   put_char(x2,y2,bc[2],c);
  152.   put_char(x1,y2,bc[3],c);
  153.   int x; for (x=x1+1;x<x2;x++) { put_char(x,y1,bc[4],c);  put_char(x,y2,bc[4],c); }
  154.   int y; for (y=y1+1;y<y2;y++) { put_char(x1,y,bc[5],c);  put_char(x2,y,bc[5],c); }
  155. }
  156.  
  157. void put_title(char *t)
  158. {
  159.   int x1=0,y1=0,x2=79,y2=25;
  160.   bar(x1,y1,x2,y1,' ',0x4f);
  161.   put_string((x1+x2)/2-strlen(t)/2,y1,t,0x4f);
  162. }
  163.  
  164.  
  165.  
  166.  
  167. int nice_copy(char *title, char *source, char *dest)
  168. {
  169.   int x1=0,y1=0,x2=79,y2=25;
  170.   bar(x1,y1+1,x2,y2,176,0x01);
  171.   put_title(title);
  172.  
  173.   box(x1,(y1+y2)/2-1,x2,(y1+y2)/2+3,0x17);
  174.   bar(x1+1,(y1+y2)/2,x2-1,(y1+y2)/2+2,' ',0x17);
  175.   
  176.   char msg[100];
  177.   sprintf(msg,"Copying %s -> %s",source,dest);
  178.   put_string(x1+1,(y1+y2)/2,msg,0x17);
  179.   bar(x1+1,(y1+y2)/2+2,x2-1,(y1+y2)/2+2,176,0x17);
  180.  
  181.   char *buffer=(char *)jmalloc(0xf000,"read buf");
  182.   if (!buffer) return 0;
  183.   FILE *out=fopen(dest,"wb");
  184.   if (!out) { jfree(buffer) ; return 0; }
  185.   FILE *in=fopen(source,"rb");
  186.   if (!in) { jfree(buffer); fclose(out); unlink(dest); return 0; }
  187.  
  188.   fseek(in,0,SEEK_END);
  189.   long size=ftell(in);
  190.   fseek(in,0,SEEK_SET);
  191.   int osize=size;
  192.   while (size)
  193.   {
  194.     long tr=fread(buffer,1,0xf000,in);
  195.     bar(x1+1,(y1+y2)/2+2,x1+1+(x2-x1)*(osize-size-tr)/osize,(y1+y2)/2+2,178,0x17);
  196.  
  197.     if (fwrite(buffer,1,tr,out)!=tr)
  198.     {
  199.       fclose(out);
  200.       fclose(in);
  201.       unlink(dest);
  202.       jfree(buffer);
  203.       return 0;
  204.     }
  205.     size-=tr;
  206.     
  207.   }
  208.   fclose(in);
  209.   fclose(out);
  210.   jfree(buffer);
  211.   cls();
  212.   return 1;
  213. }
  214.  
  215. void *nice_input(char *t, char *p, char *d)
  216. {  
  217.  
  218.   int x1=0,y1=0,x2=79,y2=25;
  219.   bar(x1,y1+1,x2,y2,176,0x01);
  220.   put_title(t);
  221.  
  222.   box(x1,(y1+y2)/2-1,x2,(y1+y2)/2+1,0x17);
  223.   bar(x1+1,(y1+y2)/2,x2-1,(y1+y2)/2,' ',0x17);
  224.  
  225.   put_string(x1+1,(y1+y2)/2,p,0x17);
  226.   bar       (x1+1+strlen(p)+1,(y1+y2)/2,x2-1,(y1+y2)/2,' ',0x0f);
  227.   put_string(x1+1+strlen(p)+1,(y1+y2)/2,d,0x70);
  228.   set_cursor(x1+1+strlen(p)+1,(y1+y2)/2);
  229.   while (!_bios_keybrd(_KEYBRD_READY));
  230.   if (_bios_keybrd(_KEYBRD_READY)==7181)
  231.   {
  232.     getch();
  233.     cls();
  234.     char ln[100];
  235.     strcpy(ln,d);                  // d might get collect in next new
  236.     return new_lisp_string(ln);
  237.   }
  238.   else
  239.   {
  240.     bar       (x1+1+strlen(p)+1,(y1+y2)/2,x2-1,(y1+y2)/2,' ',0x0f);
  241.     int key;
  242.     char ln[100];
  243.     ln[0]=0;
  244.     do
  245.     {
  246.       key=getch();
  247.       if (key==8 && ln[0]) 
  248.       {
  249.     ln[strlen(ln)-1]=0;
  250.     bar(x1+1+strlen(p)+1,(y1+y2)/2,x2-1,(y1+y2)/2,' ',0x0f);
  251.     put_string(x1+1+strlen(p)+1,(y1+y2)/2,ln,0x0f);
  252.       }
  253.       else if (isprint(key))
  254.       {
  255.     ln[strlen(ln)+1]=0;
  256.     ln[strlen(ln)]=key;
  257.  
  258.     put_string(x1+1+strlen(p)+1,(y1+y2)/2,ln,0x0f);
  259.       }      
  260.       set_cursor(x1+1+strlen(p)+1+strlen(ln),(y1+y2)/2);
  261.     } while (key!=13 && key!=27);
  262.  
  263.     cls();
  264.     if (key==27) return NULL;
  265.     return new_lisp_string(ln);          
  266.   }
  267. }
  268.  
  269. void *nice_menu(void *main_title, void *menu_title, void *list)
  270. {
  271.   int x1=0,y1=0,x2=79,y2=25;
  272.  
  273.   p_ref r1(main_title),r2(menu_title),r3(list);
  274.   main_title=eval(main_title);
  275.   menu_title=eval(menu_title);
  276.   char *t=lstring_value(main_title);
  277.   put_title(t);
  278.  
  279.   bar(x1,y1+1,x2,y2,176,0x01);
  280.  
  281.   void *l=eval(list);
  282.   p_ref r4(l);
  283.   int menu_height=list_length(l),menu_length=0;
  284.   void *m;
  285.   for (m=l;m;m=CDR(m))
  286.   { long l=strlen(lstring_value(CAR(m)));
  287.     if (l>menu_length) menu_length=l;
  288.   }
  289.  
  290.   char *mt=lstring_value(menu_title);
  291.   if (strlen(mt)>menu_length) menu_length=strlen(mt);
  292.  
  293.   int mx=(x2+x1)/2-menu_length/2-1,my=(y2+y1)/2-menu_height/2-2;
  294.   box(mx,my,mx+menu_length+2,my+menu_height+3,0x17);
  295.   bar(mx+1,my+1,mx+menu_length+1,my+menu_height+2,' ',0x17);
  296.   put_string(mx+1+menu_length/2-strlen(mt)/2,my,mt,0x1f);       // draw menu title
  297.   set_cursor(0,25);
  298.  
  299.   int cur_sel=0;
  300.   int key;
  301.   do
  302.   {
  303.     int y=0;
  304.     for (m=l;m;m=CDR(m),y++)
  305.     {
  306.       char *s=lstring_value(CAR(m));
  307.       if (y==cur_sel)
  308.       {
  309.     bar(mx+1,my+2+y,mx+1+menu_length,my+2+y,' ',0x0f);
  310.     put_string(mx+1+menu_length/2-strlen(s)/2,my+2+y,s,0x0f);
  311.       }
  312.       else
  313.       {
  314.     bar(mx+1,my+2+y,mx+1+menu_length,my+2+y,' ',0x1f);
  315.     put_string(mx+1+menu_length/2-strlen(s)/2,my+2+y,s,0x1f);
  316.       }
  317.     }
  318.  
  319.     key=_bios_keybrd(_KEYBRD_READ);
  320.  
  321.     if (key==18432) 
  322.     { cur_sel--; if (cur_sel==-1) cur_sel=menu_height-1; }
  323.     if (key==20480)
  324.     { cur_sel++; if (cur_sel==menu_height) cur_sel=0; }
  325.  
  326.   } while (key!=283 && key!=7181);
  327.   cls();
  328.   if (key==283) 
  329.     return new_lisp_number(-1);
  330.  
  331.   return new_lisp_number(cur_sel);
  332. }
  333.  
  334. void center_tbox(void *list, int c)
  335. {
  336.   int x1=0,y1=0,x2=79,y2=25;
  337.   int h;
  338.  
  339.   if (item_type(list)==L_CONS_CELL)
  340.     h=list_length(list);
  341.   else h=1;
  342.  
  343.   int y=(y1+y2)/2-h/2+1;
  344.   box(x1,(y1+y2)/2-h/2,x2,(y1+y2)/2-h/2+h+1,c);
  345.   bar(x1+1,y,x2-1,(y1+y2)/2-h/2+h+1-1,' ',c);
  346.  
  347.   if (item_type(list)==L_CONS_CELL)
  348.   {
  349.     while (list)
  350.     {
  351.       char *s=lstring_value(CAR(list));
  352.       put_string((x1+x2)/2-strlen(s)/2,y++,s,c);
  353.       list=CDR(list);
  354.     }
  355.   } else 
  356.   {
  357.     char *s=lstring_value(list);
  358.     put_string((x1+x2)/2-strlen(s)/2,y++,s,c);
  359.   }
  360. }
  361.  
  362. void *show_yes_no(void *t, void *msg, void *y, void *n)
  363. {
  364.   p_ref r1(t),r2(msg),r3(y),r4(n);
  365.   y=eval(y);
  366.   n=eval(n);
  367.   put_title(lstring_value(eval(t)));
  368.  
  369.   int x1=0,y1=0,x2=79,y2=25;
  370.   bar(x1,y1+1,x2,y2,176,0x01);  
  371.   center_tbox(eval(msg),0x1f);
  372.   int key;
  373.   char *yes=lstring_value(y);
  374.   char *no=lstring_value(n);
  375.   set_cursor(0,25);
  376.   do
  377.   {
  378.     key=getch();
  379.     set_cursor(0,0);
  380.   } while (toupper(key)!=toupper(yes[0]) && toupper(key)!=toupper(no[0]));
  381.   cls();
  382.   if (toupper(key)==toupper(yes[0]))
  383.     return true_symbol;
  384.   else return NULL;
  385. }
  386.  
  387. #else
  388.  
  389. int nice_copy(char *title, char *source, char *dest) { return 0; }
  390.  
  391. long K_avail(char *path)
  392. {
  393. #if 0 // ugh
  394.   char cmd[100];
  395.   sprintf(cmd,"du %s",path);
  396.   FILE *fp=popen(cmd,"rb");
  397.   if (!fp)
  398.   {
  399.     pclose(fp);
  400.     return 20000;
  401.   }
  402.   else
  403.   {
  404.     fgets(cmd,100,fp);
  405.     if (feof(fp))
  406.     {
  407.       pclose(fp);
  408.       return 20000;
  409.     }
  410.     fgets(cmd,100,fp);
  411.     char *s=cmd+strlen(cmd)-1;
  412.     while (*s==' ' || *s=='\t') s--;
  413.     while (*s!=' ' && *s!='\t') s--;  // skip last field
  414.  
  415.     while (*s==' ' || *s=='\t') s--;
  416.     while (*s!=' ' && *s!='\t') s--;  // skip last field
  417.  
  418.     while (*s==' ' || *s=='\t') s--;
  419.     while (*s!=' ' && *s!='\t') s--; s++;  // skip last field
  420.  
  421.     long a;
  422.     sscanf(s,"%d",&a);
  423.     
  424.     pclose(fp);
  425.     return a;
  426.   }
  427. #endif
  428.     return 0;
  429. }
  430.  
  431. void *show_yes_no(void *t, void *msg, void *y, void *n)
  432. {
  433.   p_ref r1(t),r2(msg),r3(y),r4(n);
  434.   t=eval(t); msg=eval(msg); y=eval(y); n=eval(n);
  435.   int c;
  436.   char *yes=lstring_value(y);
  437.   char *no=lstring_value(n);
  438.   do
  439.   {
  440.     dprintf("\n\n\n\n\n%s\n\n",lstring_value(t));
  441.     void *v=msg;
  442.     if (item_type(v)==L_CONS_CELL)
  443.       while (v) { dprintf("** %s\n",lstring_value(CAR(v))); v=CDR(v); }
  444.     else dprintf("** %s\n",lstring_value(v));
  445.     char msg[100];
  446.     fgets(msg,100,stdin);
  447.     c=msg[0];
  448.   } while (toupper(c)!=toupper(yes[0]) && toupper(c)!=toupper(no[0]));
  449.   if (toupper(c)==toupper(yes[0]))
  450.     return true_symbol;
  451.   else return NULL;
  452. }
  453.  
  454. void *nice_menu(void *main_title, void *menu_title, void *list)
  455. {
  456.   p_ref r1(main_title),r2(menu_title),r3(list);
  457.   main_title=eval(main_title);  menu_title=eval(menu_title);  list=eval(list);
  458.   char msg[100];
  459.   int i=0,d;
  460.   do
  461.   {
  462.     dprintf("\n\n\n\n\n%s\n\n%s\n-----------------------------------\n",
  463.        lstring_value(main_title),lstring_value(menu_title));
  464.  
  465.     void *v=list;
  466.     for (;v;v=CDR(v),i++)
  467.     {
  468.       dprintf("%d) %s\n",i+1,lstring_value(CAR(v)));
  469.     }
  470.     dprintf("> ");
  471.     fgets(msg,100,stdin);
  472.     sscanf(msg,"%d",&d);
  473.   } while (d-1>=i && d<=0);
  474.   return new_lisp_number(d-1);
  475. }
  476.  
  477. void *nice_input(char *t, char *p, char *d)
  478. {
  479.   int x; for (x=0;x<(40-strlen(t)/2);x++) dprintf(" ");
  480.   dprintf(" %s\n",t);
  481.   for (x=0;x<78;x++) dprintf("-"); dprintf("\n");
  482.   dprintf("%s (ENTER=%s) > ",p,d);
  483.   char ln[100];
  484.   fgets(ln,100,stdin); ln[strlen(ln)-1]=0;
  485.   if (ln[0]==0)
  486.   {
  487.     strcpy(ln,d);                  // d might get collect in next new
  488.     return new_lisp_string(ln);
  489.   }
  490.   else
  491.     return new_lisp_string(ln);    
  492. }
  493.  
  494. #endif
  495.