home *** CD-ROM | disk | FTP | other *** search
/ The Devil's Doorknob BBS Capture (1996-2003) / devilsdoorknobbbscapture1996-2003.iso / W / WWIVSOR.ZIP / BBSOVL3.C < prev    next >
C/C++ Source or Header  |  1995-04-25  |  50KB  |  2,398 lines
  1. /*****************************************************************************
  2.  
  3.                 WWIV Version 4
  4.                     Copyright (C) 1988-1995 by Wayne Bell
  5.  
  6. Distribution of the source code for WWIV, in any form, modified or unmodified,
  7. without PRIOR, WRITTEN APPROVAL by the author, is expressly prohibited.
  8. Distribution of compiled versions of WWIV is limited to copies compiled BY
  9. THE AUTHOR.  Distribution of any copies of WWIV not compiled by the author
  10. is expressly prohibited.
  11.  
  12.  
  13. *****************************************************************************/
  14.  
  15.  
  16.  
  17. #include "vars.h"
  18.  
  19. #pragma hdrstop
  20.  
  21. #include "vardec1.h"
  22.  
  23. #include <stdarg.h>
  24. #include <stdlib.h>
  25. #include <string.h>
  26. #include <errno.h>
  27. #include <ctype.h>
  28. #include <conio.h>
  29.  
  30.  
  31. int numlock=NOTNUMBERS;
  32.  
  33.  
  34.  
  35. unsigned char pd_getkey(void)
  36. {
  37.   unsigned short x;
  38.  
  39.   g_flags |= g_flag_allow_extended;
  40.   x = getkey();
  41.   g_flags &= ~g_flag_allow_extended;
  42.  
  43.   return x;
  44. }
  45.  
  46.  
  47.  
  48. unsigned get_kb_event(void)
  49. {
  50.   time_t time1, time2;
  51.   unsigned key;
  52.  
  53.   ctrlbrk(new_control_break); // Disable control break
  54.   
  55.   tleft(1);
  56.   time(&time1);
  57.   
  58.  
  59.   
  60.   do{
  61.     time(&time2);
  62.     if(difftime(time2,time1) > 180 ) // greater than 3 minutes
  63.     {
  64.       hangup=1;
  65.       return 0;
  66.     }
  67.     if(hangup)
  68.       return 0;
  69.  
  70.     if(comhit() || kbhitb())
  71.     {
  72.       if(!incom || kbhitb())   // Check for local keys
  73.       {
  74.         key=getch();      // getch();
  75.  
  76.         if(key==127)
  77.           return(COMMAND_DELETE);
  78.         if(key==22)
  79.           return(COMMAND_INSERT);
  80.  
  81.  
  82.         if(key==13 || key==12)
  83.         {
  84.           return(EXECUTE);
  85.         }
  86.         
  87.  
  88.         if(!key)
  89.         {
  90.           if(kbhit())
  91.           {
  92.             key=getch();      // getch();
  93.             return(key+256);
  94.           }
  95.         }
  96.         else 
  97.         {
  98.           if(numlock==NOTNUMBERS)
  99.           {
  100.             switch(key)
  101.             {
  102.               case '8':
  103.                 return(COMMAND_UP);
  104.               case '4':
  105.                 return(COMMAND_LEFT);
  106.               case '2':
  107.                 return(COMMAND_DOWN);
  108.               case '6':
  109.                 return(COMMAND_RIGHT);
  110.               case '0':
  111.                 return(COMMAND_INSERT);
  112.               case '.':
  113.                 return(COMMAND_DELETE);
  114.               case '9':
  115.                 return(COMMAND_PAGEUP);
  116.               case '3':
  117.                 return(COMMAND_PAGEDN);
  118.               case '7':
  119.                 return(COMMAND_HOME);
  120.               case '1':
  121.                 return(COMMAND_END);
  122.             }
  123.           } 
  124.           switch(key)
  125.           {
  126.             case TAB:
  127.               return(TAB); 
  128.             case ESC:
  129.               return(GET_OUT);
  130.             default:
  131.             {
  132.               return(key);
  133.             }
  134.           }
  135.         }
  136.       }
  137.       else if(comhit())
  138.       {
  139.         key=pd_getkey();
  140.  
  141.         if(key==127)
  142.           return(COMMAND_DELETE);
  143.         if(key==22)
  144.           return(COMMAND_INSERT);
  145.  
  146.  
  147.  
  148.         if(key==13 || key==12)
  149.         {
  150.           return(EXECUTE);
  151.         }
  152.         
  153.         else if(key==ESC)
  154.         {
  155.           time_t time1;
  156.           time_t time2;
  157.  
  158.           time(&time1);
  159.           time(&time2);
  160.  
  161.           do
  162.           {
  163.             time(&time2);
  164.  
  165.             if(comhit())
  166.             {
  167.               key=pd_getkey();
  168.               if(key==OB||key==O)
  169.               {
  170.                 key=pd_getkey();
  171.  
  172.                 // Check for a second set of brackets
  173.                 if(key==OB||key==O)
  174.                   key=pd_getkey();
  175.  
  176.                 switch(key)
  177.                 {
  178.                   case A_UP:
  179.                     return(COMMAND_UP);
  180.                   case A_LEFT:
  181.                     return(COMMAND_LEFT);
  182.                   case A_DOWN:
  183.                     return(COMMAND_DOWN);
  184.                   case A_RIGHT:
  185.                     return(COMMAND_RIGHT);
  186.                   case A_INSERT:
  187.                    return(COMMAND_INSERT);
  188.                   case A_DELETE:
  189.                    return(COMMAND_DELETE);
  190.                   case A_HOME:
  191.                     return(COMMAND_HOME);
  192.                   case A_END:
  193.                     return(COMMAND_END);
  194.  
  195.                   default:
  196.                    return(key);
  197.                 }
  198.               }
  199.               else
  200.                 return(GET_OUT);
  201.             }
  202.           } while(difftime(time2,time1) < 1 && !hangup);
  203.  
  204.           if(difftime(time2,time1) >= 1)  // if no keys followed ESC
  205.             return(GET_OUT);
  206.         }
  207.         else
  208.         {
  209.  
  210.           if(!key)
  211.           {
  212.             if(kbhitb())
  213.             {
  214.               key=getch();           // getch();
  215.               return(key+256);
  216.             }
  217.           }
  218.  
  219.  
  220.           if(numlock==NOTNUMBERS)
  221.           {
  222.             switch(key)
  223.             {
  224.               case '8':
  225.                 return(COMMAND_UP);
  226.               case '4':
  227.                 return(COMMAND_LEFT);
  228.               case '2':
  229.                 return(COMMAND_DOWN);
  230.               case '6':
  231.                 return(COMMAND_RIGHT);
  232.               case '0':
  233.                 return(COMMAND_INSERT);
  234.               case '.':
  235.                 return(COMMAND_DELETE);
  236.               case '9':
  237.                 return(COMMAND_PAGEUP);
  238.               case '3':
  239.                 return(COMMAND_PAGEDN);
  240.               case '7':
  241.                 return(COMMAND_HOME);
  242.               case '1':
  243.                 return(COMMAND_END);
  244.             }
  245.           }  
  246.           switch(key)
  247.           {
  248.             default:
  249.               return(key);
  250.           }
  251.         }
  252.       }
  253.       time(&time1);  // reset timer
  254.     }
  255.     else
  256.       giveup_timeslice();
  257.     
  258.   }while(!hangup);
  259.   return 0; // must have hung up
  260. }
  261.  
  262.  
  263.  
  264. // Like onek but does not put cursor down a line
  265. // One key, no carriage return
  266. char onek_ncr(char *s)
  267. {
  268.   char ch;
  269.  
  270.   while (!strchr(s, ch = upcase(getkey())) && !hangup)
  271.     ;
  272.   if (hangup)
  273.     ch = s[0];
  274.   outchr(ch);
  275.   return (ch);
  276. }
  277.  
  278.  
  279. int do_sysop_command(unsigned command)
  280. {
  281.   unsigned x;
  282.   int needredraw=0;
  283.  
  284.   switch(command)
  285.   {
  286.     // Commands that cause screen to need to be redrawn go here
  287.     case COMMAND_F1:
  288.     case COMMAND_CF1:
  289.     case COMMAND_CF9:
  290.     case COMMAND_F10:
  291.     case COMMAND_CF10:
  292.       needredraw=1;
  293.       x=command-256;
  294.       break;
  295.  
  296.     // Commands that don't change the screen around
  297.     case COMMAND_SF1:
  298.     case COMMAND_F2:
  299.     case COMMAND_SF2:
  300.     case COMMAND_CF2:
  301.     case COMMAND_F3:
  302.     case COMMAND_SF3:
  303.     case COMMAND_CF3:
  304.     case COMMAND_F4:
  305.     case COMMAND_SF4:
  306.     case COMMAND_CF4:
  307.     case COMMAND_F5:
  308.     case COMMAND_SF5:
  309.     case COMMAND_CF5:
  310.     case COMMAND_F6:
  311.     case COMMAND_SF6:
  312.     case COMMAND_CF6:
  313.     case COMMAND_F7:
  314.     case COMMAND_SF7:
  315.     case COMMAND_CF7:
  316.     case COMMAND_F8:
  317.     case COMMAND_SF8:
  318.     case COMMAND_CF8:
  319.     case COMMAND_F9:
  320.     case COMMAND_SF9:
  321.     case COMMAND_SF10:
  322.       needredraw=0;
  323.       x=command-256;
  324.       break;
  325.       
  326.     default:
  327.       x=0;
  328.       break;
  329.   }
  330.       
  331.   if(x)
  332.   {
  333.     if(needredraw)
  334.       CLS();
  335.  
  336.     skey(x);
  337.  
  338.     if(needredraw)
  339.       CLS();
  340.   }
  341.   
  342.   return(needredraw);
  343. }
  344.  
  345.  
  346.  
  347.  
  348. // All the different functions that output strings to the screen and com
  349. // buffer, all of these need to be modifed to get the following color in
  350. // These don't count functions like npr and prt, since they end up calling
  351. // outstr to do the string printing... wonder if Wayne thinks he needs any
  352. // more functions to print string... hmmm.... <grin>
  353. // outstr  OutString (COM.C)
  354. // pla     Print Line with Abort (BBSUTL.C)
  355. // plal    Print Line with Abort and Limit how much can be printed hmm npr... (BBSUTL.C)
  356. // osan    OutString with Abort and Next (MSGBASE.C)
  357. // plan    Print Line with Abort and Next (MSGBASE.C)
  358.  
  359. // Oh, colors are...
  360. // |00 - |15 regular dos foreground colors
  361. // |16 - |23 OR |b0- |b7 for regular dos background colors
  362. // There MUST be two numbers following the pipe, ie |01 NOT |1
  363. void colorize_text(char *buffer)
  364. {
  365.   int pos=0, fmt_pos=0;
  366.   int attrib, col;
  367.   char num[3];
  368.   char *formated;
  369.   char color[50];
  370.   unsigned long x;
  371.  
  372.  
  373.   x=strlen(buffer);
  374.   x=(x)+100;
  375.  
  376.   formated=(char *)malloca(x);
  377.   if(!formated)
  378.   {
  379.     return;
  380.   }
  381.   formated[0]=0;
  382.  
  383.  
  384.   while(buffer[fmt_pos] && pos < x)
  385.   {
  386.     if(buffer[fmt_pos]=='|')
  387.     {
  388.       if(isdigit(buffer[fmt_pos+1]) || buffer[fmt_pos+1]==' ')
  389.       {
  390.         if(isdigit(buffer[fmt_pos+2]) || (buffer[fmt_pos+2]==' ' && buffer[fmt_pos+1]!=' '))
  391.         {
  392.  
  393.           if(buffer[fmt_pos+1]!='b' && buffer[fmt_pos+1]!='B')
  394.           {
  395.             strncpy(num, buffer+fmt_pos+1, 2);
  396.             num[2]=0;
  397.             col=atoi(num);
  398.  
  399.             if(col<16)
  400.             {
  401.               attrib=col;
  402.               buildfor(attrib, color);
  403.             }
  404.             else // For background colors 16-23)
  405.             {
  406.               col-=16;
  407.               attrib=col;
  408.               buildback(attrib, color);
  409.             }
  410.  
  411.             fmt_pos+=3;
  412.             strcat(formated, color);
  413.             pos+=strlen(color);
  414.           }
  415.           else if(buffer[fmt_pos+1]=='b' || buffer[fmt_pos+1]=='B')
  416.           {
  417.             strncpy(num, buffer+fmt_pos+2, 1);
  418.             num[1]=0;
  419.  
  420.             col=(atoi(num));
  421.             attrib=col;
  422.             buildback(attrib, color);
  423.  
  424.             fmt_pos+=3;
  425.             strcat(formated, color);
  426.             pos+=strlen(color);
  427.           }
  428.           else
  429.           {
  430.             formated[pos]=buffer[fmt_pos];
  431.             formated[pos+1]=0;
  432.             ++pos;
  433.             ++fmt_pos;
  434.           }
  435.         }
  436.         else
  437.         {
  438.           formated[pos]=buffer[fmt_pos];
  439.           formated[pos+1]=0;
  440.           ++pos;
  441.           ++fmt_pos;
  442.         }
  443.       }
  444.       else
  445.       {
  446.         formated[pos]=buffer[fmt_pos];
  447.         formated[pos+1]=0;
  448.         ++pos;
  449.         ++fmt_pos;
  450.       }
  451.     }
  452.     else
  453.     {
  454.       formated[pos]=buffer[fmt_pos];
  455.       formated[pos+1]=0;
  456.       ++pos;
  457.       ++fmt_pos;
  458.     }
  459.   }
  460.   formated[pos]=0;
  461.   strcpy(buffer, formated);
  462.   bbsfree(formated);
  463. }
  464.  
  465. // Calls the above colorize_text to print out '|colors'
  466. // This call and npr_color are only meant for formats that when expanded
  467. // Will be less than 512 characters, this is fine for most cases, but not
  468. // something like an extended description
  469. void sprintf_color(char *buffer, char *fmt, ...)
  470. {
  471.   va_list ap;
  472.  
  473.   va_start(ap, fmt);
  474.   vsprintf(buffer, fmt, ap);
  475.   va_end(ap);
  476.  
  477.   colorize_text(buffer);
  478. }
  479.  
  480.  
  481.  
  482. int replacefile(char *src, char *dst, int stats)
  483. {
  484.   if(exist(dst))
  485.     unlink(dst);
  486.  
  487.   return(copyfile(src, dst, stats));
  488. }
  489.  
  490.  
  491. int copyfile(char *input, char *output, int stats)
  492. {
  493.   int f1, f2, i;
  494.   char *b;
  495.   struct ftime ft;
  496.   statusbarrec sb;
  497.   long fl;
  498.  
  499.  
  500.   if(stats) stats=0;
  501.   if(stats) outstr(get_string(1484));
  502.  
  503.   if ((strcmp(input, output) != 0) && (exist(input)) && (!exist(output)))
  504.   {
  505.     if ((b = malloca(16400)) == NULL)
  506.       return 0;
  507.     f1 = sh_open1(input, O_RDONLY | O_BINARY);
  508.     if(!f1)
  509.       { bbsfree(b); return 0; }
  510.  
  511.     getftime(f1, &ft);
  512.  
  513.  
  514.     if(stats)
  515.     {
  516.       fl=filelength(f1);
  517.       sb.width=20;            sb.amount_per_square=1;
  518.       sb.square_list[0]='▓';  sb.empty_space='-';
  519.       sb.side_char1='[';      sb.side_char2=']';
  520.       sb.surround_color=RED;  sb.box_color=YELLOW+(BLACK<<4);
  521.       sb.total_items=fl;      sb.current_item=0;
  522.  
  523.       statusbar(&sb);
  524.     }
  525.  
  526.  
  527.  
  528.     f2 = sh_open(output, O_RDWR | O_BINARY | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
  529.     if(!f2)
  530.       { bbsfree(b); sh_close(f1); return 0; }
  531.  
  532.     i = read(f1, (void *) b, 16384);
  533.  
  534.  
  535.     if(stats)
  536.       { sb.current_item+=i; statusbar(&sb); }
  537.  
  538.     while (i > 0)
  539.     {
  540.       giveup_timeslice();
  541.       write(f2, (void *) b, i);
  542.       i = read(f1, (void *) b, 16384);
  543.  
  544.       if(stats && i)
  545.        { sb.current_item+=i; statusbar(&sb); }
  546.     }
  547.     f1=sh_close(f1);
  548.     setftime(f2, &ft);
  549.     f2=sh_close(f2);
  550.     bbsfree(b);
  551.  
  552.     if(stats)
  553.       { nl(); ansic(0); }
  554.   }
  555. #ifdef LAZY_WRITES
  556.   wait1(LAZY_WRITES);
  557. #endif
  558.  
  559.   return 1;
  560. }
  561.  
  562.  
  563.  
  564.  
  565. // Just like copyfile, except if the files are on the same drive, it will
  566. // rename them (which is very fast) instead of copying them, also, after
  567. // a copy, it will remove the source file (since it was 'moved')
  568. int movefile(char *src, char *dst, int stats)
  569. {
  570.   char source[201], dest[201];
  571.   int x;
  572.  
  573.   strcpy(source, src);
  574.   strcpy(dest, dst);
  575.   strupr(source);
  576.   strupr(dest);
  577.   if ((strcmp(source,dest)!=0) && (exist(source))) {
  578.     int which_way=0;
  579.     if ((source[1]!=':') && (dest[1]!=':'))
  580.       which_way=1;
  581.     if ((source[1]==':') && (dest[1]==':') && (source[0]==dest[0]))
  582.       which_way=1;
  583.  
  584.     if (which_way) {
  585.       rename(source, dest);
  586.       return 2;
  587.     }
  588.   }
  589.  
  590.   x = copyfile(src, dst, stats);
  591.   unlink(src);
  592.  
  593.   return x;
  594. }
  595.  
  596.  
  597.  
  598. int check_arc(char *filename)
  599. {
  600.   char header[10];
  601.   char *ext;
  602.   int file;
  603.  
  604.  
  605.   file=sh_open1(filename, O_RDONLY);
  606.  
  607.   if(file<0)
  608.     return(COMPRESSION_UNKNOWN);
  609.  
  610.   sh_lseek(file, 0, SEEK_SET);
  611.   sh_read(file, (void *)&header, 10);
  612.  
  613.   sh_close(file);
  614.  
  615.   switch(header[0])
  616.   {
  617.     case 0x60:
  618.       if((unsigned char)header[1]==(unsigned char)0xEA)
  619.         return(COMPRESSION_ARJ);
  620.       break;
  621.  
  622.     case 0x1a:
  623.       return(COMPRESSION_PAK);
  624.  
  625.     case 'P':
  626.       if(header[1]=='K')
  627.         return(COMPRESSION_ZIP);
  628.       break;
  629.  
  630.     case 'Z':
  631.       if(header[1]== 'O' && header[2] == 'O')
  632.         return(COMPRESSION_ZOO);
  633.       break;
  634.   }
  635.  
  636.   if (header[0]!='P') {
  637.     header[9]=0;
  638.     if(strstr(header, "-lh"))
  639.       return(COMPRESSION_LHA);
  640.  
  641.     // Guess on type, using extension to guess
  642.     ext=strstr(filename, ".");
  643.  
  644.     if(ext)
  645.     {
  646.       ++ext;
  647.  
  648.       if(stricmp(ext, "ZIP")==0)
  649.         return(COMPRESSION_ZIP);
  650.  
  651.       if(stricmp(ext, "LHA")==0)
  652.         return(COMPRESSION_LHA);
  653.  
  654.       if(stricmp(ext, "LZH")==0)
  655.         return(COMPRESSION_LHA);
  656.  
  657.       if(stricmp(ext, "ZOO")==0)
  658.         return(COMPRESSION_ZOO);
  659.  
  660.       if(stricmp(ext, "ARC")==0)
  661.         return(COMPRESSION_PAK);
  662.  
  663.       if(stricmp(ext, "PAK")==0)
  664.         return(COMPRESSION_PAK);
  665.  
  666.       if(stricmp(ext, "ARJ")==0)
  667.         return(COMPRESSION_ARJ);
  668.  
  669.       return(COMPRESSION_UNKNOWN);
  670.     }
  671.   }
  672.   return(COMPRESSION_UNKNOWN);
  673. }
  674.  
  675.  
  676.  
  677. // Returns which archive as a number in your archive config
  678. // Returns the first archiver you have listed if unknown
  679. // One thing to note, if an 'arc' is found, it uses pak, and returns that
  680. // The reason being, PAK does all ARC does, plus a little more, I belive
  681. // PAK has its own special modes, but still look like an ARC, thus, an ARC
  682. // Will puke if it sees this
  683. int match_archiver(char *filename)
  684. {
  685.   int x=0;
  686.   char type[4];
  687.  
  688.   x=check_arc(filename);
  689.  
  690.   if(x==COMPRESSION_UNKNOWN)
  691.     return 0;
  692.  
  693.  
  694.   switch(x)
  695.   {
  696.     case COMPRESSION_ZIP:
  697.       strcpy(type, "ZIP");
  698.       break;
  699.  
  700.     case COMPRESSION_LHA:
  701.       strcpy(type, "LHA");
  702.       break;
  703.  
  704.     case COMPRESSION_ARJ:
  705.       strcpy(type, "ARJ");
  706.       break;
  707.  
  708.     case COMPRESSION_PAK:
  709.       strcpy(type, "PAK");
  710.       break;
  711.  
  712.     case COMPRESSION_ZOO:
  713.       strcpy(type, "ZOO");
  714.       break;
  715.   }
  716.  
  717.   x=0;
  718.  
  719.   while(x<4)
  720.   {
  721.     if(stricmp(type, syscfg.arcs[x].extension)==0)
  722.       return x;
  723.  
  724.     ++x;
  725.   }
  726.  
  727.   return 0;
  728. }
  729.  
  730. long file_daten(char *filename)
  731. {
  732.   int fn;
  733.  
  734.   struct ftime file;
  735.   struct time  dtime;
  736.   struct date  ddate;
  737.  
  738.  
  739.   fn = sh_open1(filename, O_RDONLY);
  740.   if (fn != -1)
  741.   {
  742.     getftime(fn, &file);
  743.     fn=sh_close(fn);
  744.  
  745.     dtime.ti_hund = 0;
  746.     dtime.ti_min = file.ft_min;
  747.     dtime.ti_hour = file.ft_hour;
  748.     dtime.ti_sec = file.ft_tsec * 2;
  749.     ddate.da_year = file.ft_year + 1980;
  750.     ddate.da_day = file.ft_day;
  751.     ddate.da_mon = file.ft_month;
  752.  
  753.     return(dostounix(&ddate, &dtime));
  754.   }
  755.   return 0;
  756. }
  757.  
  758. // Waits amount of secs, or until a key is hit
  759. void wait_sec_or_hit(double seconds)
  760. {
  761.   time_t time1;
  762.   time_t time2;
  763.  
  764.   time(&time1);
  765.   time(&time2);
  766.  
  767.   if( seconds == 1 )
  768.     ++seconds;
  769.  
  770.   while(difftime(time2,time1) < seconds && !hangup && !comhit() && !kbhitb()) {
  771.     giveup_timeslice();
  772.     checkhangup();
  773.     time(&time2);
  774.   }
  775. }
  776.  
  777.  
  778.  
  779.  
  780.  
  781. varimenurec * addvarimenu(varimenurec *current, varimenurec *newitem)
  782. {
  783.   varimenurec *temp;
  784.   int cur, amount;
  785.  
  786.   if(current==NULL)
  787.   {
  788.     current=(varimenurec *) malloc(sizeof(varimenurec));
  789.     memmove((void *)current, (void *)newitem, sizeof(varimenurec));
  790.  
  791.     current->next=NULL;
  792.     current->amount=1;
  793.  
  794.     return(current);
  795.   }
  796.  
  797.  
  798.   amount=current->amount;
  799.   cur=0;
  800.   temp=current;
  801.  
  802.   while(cur<amount-1)
  803.   {
  804.     temp=temp->next;
  805.     ++cur;
  806.   }
  807.  
  808.   temp->next=(varimenurec *) malloc(sizeof(varimenurec));
  809.   temp=temp->next;
  810.  
  811.   memmove((void *)temp, (void *)newitem, sizeof(varimenurec));
  812.   temp->next=NULL;
  813.  
  814.   ++current->amount;
  815.   return(current);
  816. }
  817.  
  818. void varimenuforward(varimenurec *menu, varimenuinfo *info)
  819. {
  820.   varimenurec *temp;
  821.   int done=0, cur=0, amount=menu->amount;
  822.  
  823.   info->last=info->pos;
  824.  
  825.   while(!done && !hangup)
  826.   {
  827.     if(info->pos)
  828.     {
  829.       --info->pos;
  830.       temp=getvarimenurec(menu, info->pos);
  831.       if(temp->active)
  832.       {
  833.         done=1;
  834.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  835.       }
  836.     }
  837.     else
  838.     {
  839.       info->pos=amount-1;
  840.  
  841.       temp=getvarimenurec(menu, info->pos);
  842.       if(temp->active)
  843.       {
  844.         done=1;
  845.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  846.       }
  847.     }
  848.  
  849.     ++cur;
  850.  
  851.     if(cur==amount)
  852.       done=1;
  853.   }
  854. }
  855.  
  856. void varimenubackward(varimenurec *menu, varimenuinfo *info)
  857. {
  858.   varimenurec *temp;
  859.   int done=0, cur=0, amount=menu->amount;
  860.  
  861.   info->last=info->pos;
  862.  
  863.   while(!done && !hangup)
  864.   {
  865.     if(info->pos<amount-1)
  866.     {
  867.       ++info->pos;
  868.  
  869.       temp=getvarimenurec(menu, info->pos);
  870.       if(temp->active)
  871.       {
  872.         done=1;
  873.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  874.       }
  875.     }
  876.     else
  877.     {
  878.       info->pos=0;
  879.  
  880.       temp=getvarimenurec(menu, info->pos);
  881.       if(temp->active)
  882.       {
  883.         done=1;
  884.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  885.       }
  886.     }
  887.     ++cur;
  888.  
  889.     if(cur==amount)
  890.       done=1;
  891.   }
  892. }
  893.  
  894. void varimenuleft(varimenurec *menu, varimenuinfo *info)
  895. {
  896.   varimenurec *temp;
  897.   int done=0, cur=0, amount=menu->amount;
  898.   int looky=0;
  899.  
  900.   info->last=info->pos;
  901.  
  902.   temp=getvarimenurec(menu, info->pos);
  903.   looky=temp->ypos;
  904.  
  905.  
  906.   while(!done && !hangup)
  907.   {
  908.     int thisy=0;
  909.  
  910.     if(info->pos)
  911.     {
  912.       --info->pos;
  913.       temp=getvarimenurec(menu, info->pos);
  914.  
  915.       thisy=temp->ypos;
  916.  
  917.       if(thisy==looky && temp->active)
  918.       {
  919.         done=1;
  920.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  921.       }
  922.     }
  923.     else
  924.     {
  925.       if(looky)
  926.         --looky;
  927.       else
  928.         looky=60;
  929.  
  930.       info->pos=amount-1;
  931.  
  932.       temp=getvarimenurec(menu, info->pos);
  933.       thisy=temp->ypos;
  934.  
  935.       if(thisy==looky && temp->active)
  936.       {
  937.         done=1;
  938.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  939.       }
  940.     }
  941.  
  942.     ++cur;
  943.  
  944. //    if(cur==amount)
  945. //      done=1;
  946.   }
  947.   
  948. }
  949.  
  950. void varimenuup(varimenurec *menu, varimenuinfo *info)
  951. {
  952.   varimenurec *temp;
  953.   int done=0, cur=0, amount=menu->amount;
  954.   int lookx=0;
  955.  
  956.   info->last=info->pos;
  957.  
  958.   temp=getvarimenurec(menu, info->pos);
  959.   lookx=temp->xpos;
  960.  
  961.  
  962.   while(!done && !hangup)
  963.   {
  964.     int thisx=0;
  965.  
  966.     if(info->pos)
  967.     {
  968.       --info->pos;
  969.       temp=getvarimenurec(menu, info->pos);
  970.       thisx=temp->xpos;
  971.  
  972.       if(thisx==lookx && temp->active)
  973.       {
  974.         done=1;
  975.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  976.       }
  977.     }
  978.     else
  979.     {
  980.       if(lookx)
  981.         --lookx;
  982.       else
  983.         lookx=80;
  984.  
  985.  
  986.  
  987.       info->pos=amount-1;
  988.  
  989.       temp=getvarimenurec(menu, info->pos);
  990.       thisx=temp->xpos;
  991.  
  992.       if(thisx==lookx && temp->active)
  993.       {
  994.         done=1;
  995.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  996.       }
  997.     }
  998.  
  999.     ++cur;
  1000.  
  1001. //    if(cur==amount)
  1002. //      done=1;
  1003.   }
  1004.   
  1005. }
  1006.  
  1007. void varimenuright(varimenurec *menu, varimenuinfo *info)
  1008. {
  1009.   varimenurec *temp;
  1010.   int done=0, cur=0, amount=menu->amount;
  1011.   int looky;
  1012.  
  1013.   info->last=info->pos;
  1014.  
  1015.   temp=getvarimenurec(menu, info->pos);
  1016.   looky=temp->ypos;
  1017.  
  1018.  
  1019.   while(!done && !hangup)
  1020.   {
  1021.     int thisy;
  1022.  
  1023.     if(info->pos<amount-1)
  1024.     {
  1025.       ++info->pos;
  1026.  
  1027.       temp=getvarimenurec(menu, info->pos);
  1028.       thisy=temp->ypos;
  1029.  
  1030.       if(thisy==looky && temp->active)
  1031.       {
  1032.         done=1;
  1033.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  1034.       }
  1035.     }
  1036.     else
  1037.     {
  1038.       if(looky<=60)
  1039.         ++looky;
  1040.       else
  1041.         looky=0;
  1042.  
  1043.  
  1044.       info->pos=0;
  1045.  
  1046.       temp=getvarimenurec(menu, info->pos);
  1047.       thisy=temp->ypos;
  1048.  
  1049.       if(thisy==looky && temp->active)
  1050.       {
  1051.         done=1;
  1052.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  1053.       }
  1054.     }
  1055.     ++cur;
  1056.  
  1057. //    if(cur==amount)
  1058. //      done=1;
  1059.   }
  1060. }
  1061.  
  1062. void varimenudown(varimenurec *menu, varimenuinfo *info)
  1063. {
  1064.   varimenurec *temp;
  1065.   int done=0, cur=0, amount=menu->amount;
  1066.   int lookx;
  1067.  
  1068.   info->last=info->pos;
  1069.  
  1070.   temp=getvarimenurec(menu, info->pos);
  1071.   lookx=temp->xpos;
  1072.  
  1073.  
  1074.   while(!done && !hangup)
  1075.   {
  1076.     int thisx;
  1077.  
  1078.     if(info->pos<amount-1)
  1079.     {
  1080.       ++info->pos;
  1081.  
  1082.       temp=getvarimenurec(menu, info->pos);
  1083.       thisx=temp->xpos;
  1084.  
  1085.       if(thisx==lookx && temp->active)
  1086.       {
  1087.         done=1;
  1088.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  1089.       }
  1090.     }
  1091.     else
  1092.     {
  1093.       if(lookx<120)
  1094.         ++lookx;
  1095.       else
  1096.         lookx=0;
  1097.  
  1098.  
  1099.  
  1100.       info->pos=0;
  1101.  
  1102.       temp=getvarimenurec(menu, info->pos);
  1103.       thisx=temp->xpos;
  1104.  
  1105.       if(thisx==lookx && temp->active)
  1106.       {
  1107.         done=1;
  1108.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  1109.       }
  1110.     }
  1111.     ++cur;
  1112.  
  1113. //    if(cur==amount)
  1114. //      done=1;
  1115.   }
  1116. }
  1117.  
  1118.  
  1119. void varimenu(varimenurec *menu, varimenuinfo *info)
  1120. {
  1121.   varimenurec *temp;
  1122.  
  1123.  
  1124.   if(info->redraw!=COMMON_NONE)
  1125.     redrawvarimenu(info->redraw, menu, info);
  1126.  
  1127.   info->redraw=COMMON_NONE;
  1128.  
  1129.   while(!hangup)
  1130.   {
  1131.     temp=getvarimenurec(menu, info->pos);
  1132.     switch(temp->type)
  1133.     {
  1134.       case SHOW_TEXT_TYPE:
  1135.         showtext(&temp->types->st, info);
  1136.         break;
  1137.  
  1138.       case INPUT_EDIT_TYPE:
  1139.         input_edit(&temp->types->ie, info);
  1140.         break;
  1141.  
  1142.       case RADIO_BUTTON_TYPE:
  1143.         radio_button(&temp->types->rb, info);
  1144.         break;
  1145.  
  1146.       case CHECK_BOX_TYPE:
  1147.         check_box(&temp->types->cb, info);
  1148.         break;
  1149.  
  1150.  
  1151.       default:
  1152.         break;
  1153.     }
  1154.  
  1155.     if(varimenu_findhotkey(menu, info) > -1000)
  1156.     {
  1157.       redrawvarimenu(COMMON_PARTIAL, menu, info);
  1158.  
  1159.       temp=getvarimenurec(menu, info->pos);
  1160.       info->returnvalue=temp->returnvalue;
  1161.  
  1162.       return;
  1163.     }
  1164.  
  1165.     switch(info->event)
  1166.     {
  1167.       case COMMAND_STAB:
  1168.         varimenuforward(menu, info);
  1169.         break;
  1170.  
  1171.       case COMMAND_UP:
  1172.         varimenuup(menu, info);
  1173.         break;
  1174.  
  1175.       case COMMAND_LEFT:
  1176.         varimenuleft(menu, info);
  1177.         break;
  1178.  
  1179.       case COMMAND_DOWN:
  1180.         varimenudown(menu, info);
  1181.         break;
  1182.  
  1183.       case COMMAND_RIGHT:
  1184.         varimenuright(menu, info);
  1185.         break;
  1186.  
  1187.       case TAB:
  1188.         varimenubackward(menu, info);
  1189.         break;
  1190.  
  1191.       default:
  1192.  
  1193.         temp=getvarimenurec(menu, info->pos);
  1194.         info->returnvalue=temp->returnvalue;
  1195.         return;
  1196.     }
  1197.   }
  1198. }
  1199.  
  1200. varimenurec * getvarimenurec(varimenurec *menu, int which)
  1201. {
  1202.   varimenurec *temp;
  1203.   int pos=0;
  1204.   int amount=menu->amount;
  1205.  
  1206.   if(which>=amount)
  1207.   {
  1208.     return NULL;
  1209.   }
  1210.  
  1211.   temp=menu;
  1212.   if(which==0)
  1213.     return(temp);
  1214.  
  1215.  
  1216.  
  1217.   while(pos<which)
  1218.   {
  1219.     temp=temp->next;
  1220.     if(pos==which)
  1221.       return(temp);
  1222.  
  1223.     ++pos;
  1224.   }
  1225.  
  1226.   return(temp);
  1227. }
  1228.  
  1229.  
  1230.  
  1231.  
  1232. void redrawvarimenu(int redraw, varimenurec *menu, varimenuinfo *info)
  1233. {
  1234.   varimenurec *temp;
  1235.   int cur, savecolor=curatr;
  1236.   int mode;
  1237.  
  1238.  
  1239.  
  1240.   if(redraw==COMMON_FULL)
  1241.   {
  1242.     cur=0;
  1243.     temp=menu;
  1244.  
  1245.     setc(info->mi_normal);
  1246.  
  1247.  
  1248.     while((cur<menu->amount) && !hangup)
  1249.     {
  1250.       if(cur)
  1251.         temp=temp->next;
  1252.       else
  1253.         temp=menu;
  1254.  
  1255.       mode = temp->active==FALSE ? COMMON_INACTIVE : cur==info->pos ? COMMON_CURRENT : COMMON_ITEM;
  1256.  
  1257.  
  1258.       switch(temp->type)
  1259.       {
  1260.         case SHOW_TEXT_TYPE:
  1261.           redrawshowtext(COMMON_FULL, &temp->types->st, info, mode);
  1262.           break;
  1263.  
  1264.         case INPUT_EDIT_TYPE:
  1265.           redrawinputedit(COMMON_FULL, &temp->types->ie, info, mode);
  1266.           break;
  1267.  
  1268.         case RADIO_BUTTON_TYPE:
  1269.           redrawradiobutton(COMMON_FULL, &temp->types->rb, info, mode);
  1270.           break;
  1271.  
  1272.         case CHECK_BOX_TYPE:
  1273.           redrawcheckbox(COMMON_FULL, &temp->types->cb, info, mode);
  1274.           break;
  1275.  
  1276.         default:
  1277.           break;
  1278.       }
  1279.  
  1280.       ++cur;
  1281.     }
  1282.   }
  1283.   else if(redraw==COMMON_PARTIAL)
  1284.   {
  1285.     if(info->pos!=info->last)
  1286.     {
  1287.       temp=getvarimenurec(menu, info->pos);
  1288.  
  1289.       mode = temp->active==FALSE ? COMMON_INACTIVE : COMMON_CURRENT;
  1290.  
  1291.       switch(temp->type)
  1292.       {
  1293.         case SHOW_TEXT_TYPE:
  1294.           redrawshowtext(COMMON_NONE, &temp->types->st, info, mode);
  1295.           break;
  1296.  
  1297.         case INPUT_EDIT_TYPE:
  1298.           redrawinputedit(COMMON_NONE, &temp->types->ie, info, mode);
  1299.           break;
  1300.  
  1301.         case RADIO_BUTTON_TYPE:
  1302.           redrawradiobutton(COMMON_NONE, &temp->types->rb, info, mode);
  1303.           break;
  1304.  
  1305.         case CHECK_BOX_TYPE:
  1306.           redrawcheckbox(COMMON_NONE, &temp->types->cb, info, mode);
  1307.           break;
  1308.  
  1309.  
  1310.         default:
  1311.           break;
  1312.       }
  1313.  
  1314.  
  1315.  
  1316.       temp=getvarimenurec(menu, info->last);
  1317.  
  1318.       mode = temp->active==FALSE ? COMMON_INACTIVE : COMMON_ITEM;
  1319.  
  1320.       switch(temp->type)
  1321.       {
  1322.         case SHOW_TEXT_TYPE:
  1323.           redrawshowtext(COMMON_FULL, &temp->types->st, info, mode);
  1324.           break;
  1325.  
  1326.         case INPUT_EDIT_TYPE:
  1327.           redrawinputedit(COMMON_FULL, &temp->types->ie, info, mode);
  1328.           break;
  1329.  
  1330.         case RADIO_BUTTON_TYPE:
  1331.           redrawradiobutton(COMMON_FULL, &temp->types->rb, info, mode);
  1332.           break;
  1333.  
  1334.         case CHECK_BOX_TYPE:
  1335.           redrawcheckbox(COMMON_FULL, &temp->types->cb, info, mode);
  1336.           break;
  1337.  
  1338.  
  1339.         default:
  1340.           break;
  1341.       }
  1342.     }
  1343.  
  1344.   }
  1345.   else if(redraw==COMMON_NONE)
  1346.   {
  1347.     return;
  1348.   }
  1349.   else
  1350.   {
  1351.     return;
  1352.   }
  1353.  
  1354.   GOTO_XY(info->xpos, info->ypos);
  1355.   setc(savecolor);
  1356. }
  1357.  
  1358.  
  1359. void killvarimenu(varimenurec *menu)
  1360. {
  1361.   varimenurec *m[100];
  1362.   int cur=1, amount=menu->amount;
  1363.  
  1364.   m[0]=menu;
  1365.  
  1366.   while(cur < amount)
  1367.   {
  1368.     m[cur]=m[cur-1]->next;
  1369.     ++cur;
  1370.   }
  1371.  
  1372.   cur=0;
  1373.   while((cur < amount) && !hangup)
  1374.   {
  1375.     if(m[cur]->type==INPUT_EDIT_TYPE)
  1376.       kill_inputrec(&m[cur]->types->ie);
  1377.     else if(m[cur]->type==SHOW_TEXT_TYPE)
  1378.       kill_showtextrec(&m[cur]->types->st);
  1379.     else if(m[cur]->type==RADIO_BUTTON_TYPE)
  1380.       kill_radiobutton(&m[cur]->types->rb);
  1381.     else if(m[cur]->type==CHECK_BOX_TYPE)
  1382.       kill_checkbox(&m[cur]->types->cb);
  1383.  
  1384.  
  1385.  
  1386.     bbsfree(m[cur]);
  1387.     ++cur;
  1388.   }
  1389. }
  1390.  
  1391. void kill_inputrec(inputeditrec *input)
  1392. {
  1393.   bbsfree(input->text);
  1394.   bbsfree(input->show);
  1395. }
  1396.  
  1397. void kill_showtextrec(showtextrec *text)
  1398. {
  1399.   bbsfree(text->text);
  1400.   bbsfree(text->show);
  1401. }
  1402.  
  1403. void kill_radiobutton(radiobuttonrec *radio)
  1404. {
  1405.   if(radio!=radio)
  1406.     radio=radio;
  1407. }
  1408.  
  1409. void kill_checkbox(checkboxrec *check)
  1410. {
  1411.   if(check!=check)
  1412.     check=check;
  1413. }
  1414.  
  1415.  
  1416.  
  1417.  
  1418.  
  1419.  
  1420. int varimenu_findhotkey(varimenurec *menu, varimenuinfo *info)
  1421. {
  1422.   varimenurec *m;
  1423.   int cur=0, amount=menu->amount;
  1424.  
  1425.   unsigned e, h;
  1426.  
  1427.  
  1428.   m=menu;
  1429.  
  1430.   e=info->event;
  1431.   h=m->hotkey;
  1432.  
  1433.   if(!h || !e)
  1434.     return -1001;
  1435.  
  1436.   if(e>='A' && e <='Z')
  1437.     e=tolower(e);
  1438.   if(h>='A' && h <='Z')
  1439.     h=tolower(h);
  1440.  
  1441.   if(e==h && e)
  1442.   {
  1443.     if(menu->type==SHOW_TEXT_TYPE)
  1444.       info->event=EXECUTE;
  1445.     info->last=info->pos;
  1446.     info->pos=cur;
  1447.  
  1448.     return 1;
  1449.   }
  1450.  
  1451.   ++cur;  // we checked pos 0, inc up to pos 1
  1452.   while((cur < amount) && !hangup)
  1453.   {
  1454.     m=m->next;
  1455.  
  1456.     h=m->hotkey;
  1457.     if(h>='A' && h <='Z')
  1458.       h=tolower(h);
  1459.  
  1460.  
  1461.     if(e==h && e)
  1462.     {
  1463.       if(menu->type==SHOW_TEXT_TYPE)
  1464.         info->event=EXECUTE;
  1465.       info->last=info->pos;
  1466.       info->pos=cur;
  1467.  
  1468.       return 1;
  1469.     }
  1470.  
  1471.     ++cur;
  1472.  
  1473.   }
  1474.   return -1001;
  1475. }
  1476.  
  1477.  
  1478. void fillvarimenurec(varimenurec *menu, void *rec, int type, unsigned hotkey, int returnvalue, int active)
  1479. {
  1480.   memset(menu, 0, sizeof(varimenurec));
  1481.  
  1482.   (void *)menu->types=rec;
  1483.  
  1484.   menu->type=type;
  1485.  
  1486.   menu->hotkey=hotkey;
  1487.   menu->returnvalue=returnvalue;
  1488.  
  1489.   menu->active=active;
  1490.  
  1491.   switch(menu->type)
  1492.   {
  1493.     case SHOW_TEXT_TYPE:
  1494.       menu->xpos=menu->types->st.xpos;
  1495.       menu->ypos=menu->types->st.ypos;
  1496.       break;
  1497.  
  1498.     case INPUT_EDIT_TYPE:
  1499.       menu->xpos=menu->types->ie.xpos;
  1500.       menu->ypos=menu->types->ie.ypos;
  1501.       break;
  1502.  
  1503.     case RADIO_BUTTON_TYPE:
  1504.       menu->xpos=menu->types->rb.xpos;
  1505.       menu->ypos=menu->types->rb.ypos;
  1506.       break;
  1507.  
  1508.     case CHECK_BOX_TYPE:
  1509.       menu->xpos=menu->types->cb.xpos;
  1510.       menu->ypos=menu->types->cb.ypos;
  1511.       break;
  1512.   }
  1513. }
  1514.  
  1515.  
  1516.  
  1517. void build_inputrec(inputeditrec *input, int maxlen, int xpos, int ypos, int width, int insert, int char_case)
  1518. {
  1519.   memset(input, 0, sizeof(inputeditrec));
  1520.  
  1521.   input->pos=0;
  1522.   input->curlen=0;
  1523.   input->maxlen=maxlen;
  1524.   input->first=0;
  1525.   input->xpos=xpos;
  1526.   input->ypos=ypos;
  1527.   input->amount_to_show=width;
  1528.   input->curxpos=xpos;
  1529.   input->curypos=ypos;
  1530.   input->insert=insert;
  1531.   input->curmode=-1;
  1532.   input->text=(char *)malloc(maxlen+1);
  1533.   memset(input->text, 0, maxlen+1);
  1534.   input->show=(char *)malloc(width+5);
  1535.   memset(input->show, 0, width);
  1536.   input->char_case=char_case;
  1537. }
  1538.  
  1539. void build_radiobuttonrec(radiobuttonrec *radio, int xpos, int ypos, int amount, int pos, int rc, int fc)
  1540. {
  1541.   memset(radio, 0, sizeof(radiobuttonrec));
  1542.   radio->xpos=xpos;
  1543.   radio->ypos=ypos;
  1544.   radio->amount=amount;
  1545.   radio->pos=pos;
  1546.  
  1547.   if(pos >= amount)
  1548.     pos=amount-1;
  1549.  
  1550.   radio->radio_char=rc;
  1551.   radio->fill_char=fc;
  1552. }
  1553.  
  1554. void build_checkboxrec(checkboxrec *check, int xpos, int ypos, int amount, int pos, unsigned bi, int rc, int fc)
  1555. {
  1556.   memset(check, 0, sizeof(checkboxrec));
  1557.   check->xpos=xpos;
  1558.   check->ypos=ypos;
  1559.   check->amount=amount;
  1560.   check->bi.n.ni=bi;
  1561.  
  1562.   check->pos=pos;
  1563.   if(pos >= amount)
  1564.     pos=amount-1;
  1565.  
  1566.  
  1567.   check->check_char=rc;
  1568.   check->fill_char=fc;
  1569. }
  1570.  
  1571. void radio_button(radiobuttonrec *radio, varimenuinfo *info)
  1572. {
  1573.   if(info->redraw!=COMMON_NONE)
  1574.     redrawradiobutton(info->redraw, radio, info, COMMON_CURRENT);
  1575.  
  1576.   while(!hangup)
  1577.   {
  1578.     info->event=get_kb_event();
  1579.  
  1580.     switch(info->event)
  1581.     {
  1582.       case COMMAND_UP:
  1583.         radio->last=radio->pos;
  1584.         if(radio->pos)
  1585.         {
  1586.           --radio->pos;
  1587.           redrawradiobutton(COMMON_PARTIAL, radio, info, COMMON_CURRENT);
  1588.         }
  1589.         else
  1590.         {
  1591.           radio->pos=radio->amount-1;
  1592.           redrawradiobutton(COMMON_PARTIAL, radio, info, COMMON_CURRENT);
  1593.         }
  1594.         info->event=0;
  1595.         return;
  1596.         
  1597.       case COMMAND_DOWN:
  1598.         radio->last=radio->pos;
  1599.         if(radio->pos<radio->amount-1)
  1600.         {
  1601.           ++radio->pos;
  1602.           redrawradiobutton(COMMON_PARTIAL, radio, info, COMMON_CURRENT);
  1603.         }
  1604.         else
  1605.         {
  1606.           radio->pos=0;
  1607.           redrawradiobutton(COMMON_PARTIAL, radio, info, COMMON_CURRENT);
  1608.         }
  1609.         info->event=0;
  1610.         return;
  1611.  
  1612.       default:
  1613.         return;
  1614.     }
  1615.   }
  1616. }
  1617.  
  1618. void check_box(checkboxrec *check, varimenuinfo *info)
  1619. {
  1620.   if(info->redraw!=COMMON_NONE)
  1621.     redrawcheckbox(info->redraw, check, info, COMMON_CURRENT);
  1622.  
  1623.   while(!hangup)
  1624.   {
  1625.     info->event=get_kb_event();
  1626.  
  1627.     switch(info->event)
  1628.     {
  1629.       case COMMAND_UP:
  1630.         if(check->pos)
  1631.         {
  1632.           --check->pos;
  1633.           redrawcheckbox(COMMON_NONE, check, info, COMMON_CURRENT);
  1634.         }
  1635.         else
  1636.         {
  1637.           check->pos=check->amount-1;
  1638.           redrawcheckbox(COMMON_NONE, check, info, COMMON_CURRENT);
  1639.         }
  1640.         info->event=0;
  1641.         return;
  1642.         
  1643.       case COMMAND_DOWN:
  1644.         if(check->pos<check->amount-1)
  1645.         {
  1646.           ++check->pos;
  1647.           redrawcheckbox(COMMON_NONE, check, info, COMMON_CURRENT);
  1648.         }
  1649.         else
  1650.         {
  1651.           check->pos=0;
  1652.           redrawcheckbox(COMMON_NONE, check, info, COMMON_CURRENT);
  1653.         }
  1654.         info->event=0;
  1655.         return;
  1656.  
  1657.       case ' ':
  1658.         if(BitTst(check->bi.n.ni, check->pos))
  1659.           check->bi.n.ni=BitClr(check->bi.n.ni, check->pos);
  1660.         else
  1661.           check->bi.n.ni=BitSet(check->bi.n.ni, check->pos);
  1662.  
  1663.         redrawcheckbox(COMMON_PARTIAL, check, info, COMMON_CURRENT);
  1664.         info->event=0;
  1665.         return;
  1666.  
  1667.       default:
  1668.         return;
  1669.  
  1670.     }
  1671.   }
  1672. }
  1673.  
  1674.  
  1675.  
  1676. void input_edit(inputeditrec *input, varimenuinfo *info)
  1677. {
  1678.   if(info->redraw!=COMMON_NONE)
  1679.     redrawinputedit(info->redraw, input, info, COMMON_CURRENT);
  1680.  
  1681.   while(!hangup)
  1682.   {
  1683.     info->event=get_kb_event();
  1684.     input->bs=FALSE;
  1685.  
  1686.     switch(info->event)
  1687.     {
  1688.       case COMMAND_LEFT:
  1689.         if(input->pos)
  1690.         {
  1691.           --input->pos;
  1692.           redrawinputedit(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  1693.         }
  1694.         info->event=0;
  1695.         return;
  1696.         
  1697.       case COMMAND_RIGHT:
  1698.         if(input->pos<input->curlen)
  1699.         {
  1700.           ++input->pos;
  1701.           redrawinputedit(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  1702.         }
  1703.         info->event=0;
  1704.         return;
  1705.  
  1706.       case COMMAND_HOME:
  1707.         if(input->pos!=0)
  1708.         {
  1709.           input->pos=0;
  1710.           redrawinputedit(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  1711.         }
  1712.         info->event=0;
  1713.         return;
  1714.  
  1715.       case COMMAND_END:
  1716.         if(input->pos!=input->maxlen)
  1717.         {
  1718.           input->pos=input->curlen;
  1719.           redrawinputedit(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  1720.         }
  1721.         info->event=0;
  1722.         return;
  1723.  
  1724.       case COMMAND_INSERT:
  1725.         input->insert=!input->insert;
  1726.         info->event=0;
  1727.         return;
  1728.  
  1729.       case BACKSPACE:
  1730.         if(input->pos)
  1731.         {
  1732.           --input->pos;
  1733.           delete_inputedit(input, info);
  1734.           redrawinputedit(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  1735.         }
  1736.         info->event=0;
  1737.         return;
  1738.  
  1739.       case COMMAND_DELETE:
  1740.         delete_inputedit(input, info);
  1741.         redrawinputedit(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  1742.         info->event=0;
  1743.         return;
  1744.  
  1745.       case COMMAND_STAB:
  1746.       case TAB:
  1747.         return;
  1748.  
  1749.       default:
  1750.  
  1751.         if(ok_char_inputedit(input, info))
  1752.         {
  1753.           if(IE_UPPER & input->char_case)
  1754.             info->event=toupper(info->event);
  1755.           else if(IE_PROPPER & input->char_case)
  1756.           {
  1757.             if(input->pos && isspace(input->text[input->pos-1]))
  1758.               info->event=toupper(info->event);
  1759.           }
  1760.  
  1761.           add_char_inputedit(input, info);
  1762.           redrawinputedit(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  1763.  
  1764.           info->event=0;
  1765.           return;
  1766.         }
  1767.         else
  1768.           return;
  1769.     }
  1770.   }
  1771. }
  1772.  
  1773. int ok_char_inputedit(inputeditrec *input, varimenuinfo *info)
  1774. {
  1775.   unsigned event;
  1776.  
  1777.   event=info->event;
  1778.  
  1779.   if(event >= ' ' && event < 255)
  1780.     return 1;
  1781.  
  1782.   // Cut off warning until I expand this function
  1783.   if(input!=input)
  1784.     input=input;
  1785.  
  1786.   return 0;
  1787. }
  1788.  
  1789. void add_char_inputedit(inputeditrec *input, varimenuinfo *info)
  1790. {
  1791.   if(input->insert)
  1792.   {
  1793.     if(input->curlen<input->maxlen)
  1794.     {
  1795.       memmove(input->text+input->pos+1, input->text+input->pos, input->curlen-input->pos+1);
  1796.       input->text[input->pos]=(char)info->event;
  1797.       ++input->pos;
  1798.       ++input->curlen;
  1799.     }
  1800.   }
  1801.   else
  1802.   {
  1803.     if(input->pos<input->maxlen)
  1804.     {
  1805.       input->text[input->pos]=(char)info->event;
  1806.  
  1807.       if(input->pos==input->curlen)
  1808.         ++input->curlen;
  1809.  
  1810.       ++input->pos;
  1811.     }
  1812.   }
  1813. }
  1814.  
  1815.  
  1816. void redrawinputedit(int type, inputeditrec *input, varimenuinfo *info, int mode)
  1817. {
  1818.   int savecolor=curatr;
  1819.  
  1820.   if(input->pos < input->first)
  1821.   {
  1822.     input->first=input->pos - (input->amount_to_show/2);
  1823.     if(input->first<0)
  1824.       input->first=0;
  1825.  
  1826.     type=COMMON_FULL;
  1827.   }
  1828.   else if(input->pos - input->first > input->amount_to_show)
  1829.   {
  1830.     input->first=input->pos - (input->amount_to_show/2);
  1831.     if(input->first > input->maxlen)
  1832.       input->first=input->maxlen;
  1833.     type=COMMON_FULL;
  1834.   }
  1835.   else if(input->curmode!=mode)
  1836.     type=COMMON_FULL;
  1837.  
  1838.   input->curmode=mode;
  1839.  
  1840.   input->curxpos=input->xpos+(input->pos-input->first);
  1841.   input->curypos=input->ypos;
  1842.  
  1843.   if(type==COMMON_FULL)
  1844.   {
  1845.     strncpy(input->show, input->text+input->first, input->amount_to_show);
  1846.     input->show[input->amount_to_show]=0;
  1847.  
  1848.     pad_string(input->show, input->amount_to_show);
  1849.     GOTO_XY(input->xpos, input->ypos);
  1850.     setc(mode==COMMON_INACTIVE ? info->inactive_color : mode ==COMMON_ITEM ? info->mi_normal : info->ci_normal);
  1851.  
  1852.     if(IE_PASSWORD & input->char_case)
  1853.       echo=0;
  1854.     else
  1855.       echo=1;
  1856.     outstr(input->show);
  1857.   }
  1858.   else if(type==COMMON_PARTIAL)
  1859.   {
  1860.     int where = input->first+(input->pos-input->first);
  1861.     int a=input->amount_to_show-(input->pos-input->first)+1;
  1862.  
  1863.     if(input->pos!=input->first)
  1864.     {
  1865.       strncpy(input->show, input->text+where-1, a+1);
  1866.       input->show[a]=0;
  1867.       input->show[input->amount_to_show]=0 ;
  1868.  
  1869.       if(input->bs && strlen(input->show) != input->amount_to_show)
  1870.         strcat(input->show, " ");
  1871.  
  1872.       GOTO_XY(input->xpos + input->pos - input->first - 1, input->ypos);
  1873.     }
  1874.     else
  1875.     {
  1876.       strncpy(input->show, input->text+where, a);
  1877.       input->show[a]=0;
  1878.       input->show[input->amount_to_show]=0;
  1879.  
  1880.       if(input->bs && strlen(input->show) != input->amount_to_show)
  1881.         strcat(input->show, " ");
  1882.  
  1883.       GOTO_XY(input->xpos + input->pos - input->first, input->ypos);
  1884.     }
  1885.     setc(mode==COMMON_INACTIVE ? info->inactive_color : mode ==COMMON_ITEM ? info->mi_normal : info->ci_normal);
  1886.  
  1887.     if(IE_PASSWORD & input->char_case)
  1888.       echo=0;
  1889.     else
  1890.       echo=1;
  1891.     outstr(input->show);
  1892.   }
  1893.   else if(type==COMMON_NONE)
  1894.   {
  1895.   }
  1896.   else
  1897.   {
  1898.   }
  1899.  
  1900.  
  1901.   if(mode==COMMON_CURRENT)
  1902.   {
  1903.  
  1904.     info->xpos=input->xpos + input->pos - input->first;
  1905.     info->ypos=input->ypos;
  1906.     GOTO_XY(info->xpos, info->ypos);
  1907.   }
  1908.  
  1909.   input->bs=FALSE;
  1910.   setc(savecolor);
  1911. }
  1912.  
  1913.  
  1914. void delete_inputedit(inputeditrec *input, varimenuinfo *info)
  1915. {
  1916.   if((input->pos>0 && input->pos==input->curlen) || !input->curlen)
  1917.   {
  1918.     info->redraw=COMMON_NONE;
  1919.     return;
  1920.   }
  1921.  
  1922.   memmove(input->text+input->pos, input->text+input->pos+1, input->curlen-input->pos);
  1923.  
  1924.   --input->curlen;
  1925.   input->bs=TRUE;
  1926.   info->redraw=COMMON_PARTIAL;
  1927. }
  1928.  
  1929.  
  1930. void redrawradiobutton(int redraw, radiobuttonrec *radio, varimenuinfo *info, int mode)
  1931. {
  1932.   int savecolor=curatr;
  1933.   int color;
  1934.   int x=0;
  1935.  
  1936.   if(redraw==COMMON_FULL)
  1937.   {
  1938.  
  1939.     while((x<radio->amount) && !hangup)
  1940.     {
  1941.       color = (mode == COMMON_INACTIVE ? info->inactive_color : x == radio->pos ? info->mi_normal : info->ci_normal);
  1942.       setc(color);
  1943.  
  1944.       GOTO_XY(radio->xpos, radio->ypos+x);
  1945.       if(x==radio->pos)
  1946.         outchr(radio->radio_char);
  1947.       else
  1948.         outchr(radio->fill_char);
  1949.  
  1950.       ++x;
  1951.     }
  1952.   }
  1953.   else if(redraw!=COMMON_NONE)
  1954.   {
  1955.     if(radio->pos!=radio->last)
  1956.     {
  1957.       while((x<radio->amount) && !hangup)
  1958.       {
  1959.         if(x==radio->pos || x==radio->last)
  1960.         {
  1961.           color = (mode == COMMON_INACTIVE ? info->inactive_color : x == radio->pos ? info->mi_normal : info->ci_normal);
  1962.           setc(color);
  1963.  
  1964.           GOTO_XY(radio->xpos, radio->ypos+x);
  1965.           if(x==radio->pos)
  1966.             outchr(radio->radio_char);
  1967.           else
  1968.             outchr(radio->fill_char);
  1969.         }
  1970.         ++x;
  1971.       }
  1972.     }
  1973.   }
  1974.  
  1975.  
  1976.   if(mode==COMMON_CURRENT)
  1977.   {
  1978.     info->xpos=radio->xpos;
  1979.     info->ypos=radio->ypos+radio->pos;
  1980.     GOTO_XY(info->xpos, info->ypos);
  1981.   }
  1982.  
  1983.   setc(savecolor);
  1984. }
  1985.  
  1986. void redrawcheckbox(int redraw, checkboxrec *check, varimenuinfo *info, int mode)
  1987. {
  1988.   int savecolor=curatr;
  1989.   int color;
  1990.   int x=0;
  1991.  
  1992.   if(redraw==COMMON_FULL)
  1993.   {
  1994.  
  1995.     while((x<check->amount) && !hangup)
  1996.     {
  1997.       color = (mode == COMMON_INACTIVE ? info->inactive_color : x == check->pos ? info->mi_normal : info->ci_normal);
  1998.       setc(color);
  1999.  
  2000.       GOTO_XY(check->xpos, check->ypos+x);
  2001.       if(BitTst(check->bi.n.ni, x))
  2002.         outchr(check->check_char);
  2003.       else
  2004.         outchr(check->fill_char);
  2005.  
  2006.       ++x;
  2007.     }
  2008.   }
  2009.   else if(redraw!=COMMON_NONE)
  2010.   {
  2011.     while((x<check->amount) && !hangup)
  2012.     {
  2013.       if(x==check->pos)
  2014.       {
  2015.         color = (mode == COMMON_INACTIVE ? info->inactive_color : x == check->pos ? info->mi_normal : info->ci_normal);
  2016.         setc(color);
  2017.  
  2018.         GOTO_XY(check->xpos, check->ypos+x);
  2019.         if(BitTst(check->bi.n.ni, x))
  2020.           outchr(check->check_char);
  2021.         else
  2022.           outchr(check->fill_char);
  2023.       }
  2024.       ++x;
  2025.     }
  2026.   }
  2027.  
  2028.  
  2029.   if(mode==COMMON_CURRENT)
  2030.   {
  2031.     info->xpos=check->xpos;
  2032.     info->ypos=check->ypos+check->pos;
  2033.     GOTO_XY(info->xpos, info->ypos);
  2034.   }
  2035.  
  2036.   setc(savecolor);
  2037. }
  2038.  
  2039.  
  2040.  
  2041. void redrawshowtext(int redraw, showtextrec *text, varimenuinfo *info, int mode)
  2042. {
  2043.   int savecolor=curatr;
  2044.   int color;
  2045.  
  2046.   strncpy(text->show, text->text, text->amount_to_show);
  2047.   text->show[text->amount_to_show]=0;
  2048.  
  2049.   justify_string(text->show, text->amount_to_show, text->bg, text->justify);
  2050.  
  2051.   color = (mode == COMMON_INACTIVE ? info->inactive_color : mode == COMMON_ITEM ? info->mi_normal : info->ci_normal);
  2052.   if(color!=text->cur_color)
  2053.     redraw=COMMON_FULL;
  2054.   text->cur_color=color;
  2055.  
  2056.   if(redraw!=COMMON_NONE)
  2057.   {
  2058.     setc(color);
  2059.  
  2060.     GOTO_XY(text->xpos, text->ypos);
  2061.     outstr(text->show);
  2062.   }
  2063.  
  2064.   if(mode==COMMON_CURRENT)
  2065.   {
  2066.     info->xpos=text->xpos;
  2067.     info->ypos=text->ypos;
  2068.     GOTO_XY(info->xpos, info->ypos);
  2069.   }
  2070.  
  2071.   setc(savecolor);
  2072. }
  2073.  
  2074. void showtext(showtextrec *text, varimenuinfo *info)
  2075. {
  2076.  
  2077.   if(info->redraw!=COMMON_NONE)
  2078.     redrawshowtext(info->redraw, text, info, COMMON_CURRENT);
  2079.  
  2080.   info->event=get_kb_event();
  2081.   return;
  2082. }
  2083.  
  2084. void build_showtextrec(showtextrec *text, int xpos, int ypos, int width, char *t, int justify, int bg)
  2085. {
  2086.   memset(text, 0, sizeof(showtextrec));
  2087.  
  2088.   text->xpos=xpos;
  2089.   text->ypos=ypos;
  2090.   text->amount_to_show=width;
  2091.   text->curxpos=xpos;
  2092.   text->curypos=ypos;
  2093.  
  2094.   text->justify=justify;
  2095.   text->bg=bg;
  2096.  
  2097.   text->text=(char *)malloc(width+1);
  2098.   strncpy(text->text, t, width);
  2099.   text->text[width]=0;
  2100.  
  2101.   text->show=(char *)malloc(width+1);
  2102. }
  2103. void build_inputpicrec(inputpicrec *input, int xpos, int ypos, int width, int insert, char *picture)
  2104. {
  2105.   memset(input, 0, sizeof(inputpicrec));
  2106.  
  2107.   input->pos=0;
  2108.   input->curlen=0;
  2109.   input->first=0;
  2110.   input->xpos=xpos;
  2111.   input->ypos=ypos;
  2112.   input->amount_to_show=width;
  2113.   input->curxpos=xpos;
  2114.   input->curypos=ypos;
  2115.   input->insert=insert;
  2116.   input->curmode=-1;
  2117.   input->show=(char *)malloc(width+5);
  2118.   memset(input->show, 0, width);
  2119. //  input->picture=get_picture(picture, input->maxlen);
  2120.   if(picture!=picture)
  2121.     picture=picture;
  2122.   input->text=(char *)malloc(input->maxlen+1);
  2123.   memset(input->text, ' ', input->maxlen+1);
  2124.  
  2125. }
  2126.  
  2127. void kill_inputpic(inputpicrec *input)
  2128. {
  2129.   bbsfree(input->text);
  2130.   bbsfree(input->show);
  2131.  
  2132.   if(input->picture)
  2133.     bbsfree(input->picture);
  2134. }
  2135.  
  2136. void input_picture(inputpicrec *input, varimenuinfo *info)
  2137. {
  2138.   if(info->redraw!=COMMON_NONE)
  2139.     redrawinputpic(info->redraw, input, info, COMMON_CURRENT);
  2140.  
  2141.   while(!hangup)
  2142.   {
  2143.     info->event=get_kb_event();
  2144.     input->bs=FALSE;
  2145.  
  2146.     switch(info->event)
  2147.     {
  2148.       case COMMAND_LEFT:
  2149.         if(input->pos)
  2150.         {
  2151.           --input->pos;
  2152.           redrawinputpic(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  2153.         }
  2154.         info->event=0;
  2155.         return;
  2156.         
  2157.       case COMMAND_RIGHT:
  2158.         if(input->pos<input->curlen)
  2159.         {
  2160.           ++input->pos;
  2161.           redrawinputpic(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  2162.         }
  2163.         info->event=0;
  2164.         return;
  2165.  
  2166.       case COMMAND_HOME:
  2167.         if(input->pos!=0)
  2168.         {
  2169.           input->pos=0;
  2170.           redrawinputpic(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  2171.         }
  2172.         info->event=0;
  2173.         return;
  2174.  
  2175.       case COMMAND_END:
  2176.         if(input->pos!=input->maxlen)
  2177.         {
  2178.           input->pos=input->curlen;
  2179.           redrawinputpic(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  2180.         }
  2181.         info->event=0;
  2182.         return;
  2183.  
  2184.       case BACKSPACE:
  2185.         if(input->pos)
  2186.         {
  2187.           --input->pos;
  2188.           input->text[input->pos]=' ';
  2189.           redrawinputpic(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  2190.         }
  2191.         info->event=0;
  2192.         return;
  2193.  
  2194.       case COMMAND_DELETE:
  2195.         input->text[input->pos]=' ';
  2196.         redrawinputpic(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  2197.         info->event=0;
  2198.         return;
  2199.  
  2200.       case COMMAND_STAB:
  2201.       case TAB:
  2202.         return;
  2203.  
  2204.       default:
  2205.  
  2206.         if(ok_char_inputpic(input, info))
  2207.         {
  2208.           input->text[input->pos]=info->event;
  2209.           ++info->pos;
  2210.           redrawinputpic(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  2211.  
  2212.           info->event=0;
  2213.           return;
  2214.         }
  2215.         else
  2216.           return;
  2217.     }
  2218.   }
  2219. }
  2220.  
  2221. int ok_char_inputpic(inputpicrec *input, varimenuinfo *info)
  2222. {
  2223.   unsigned event;
  2224.  
  2225.   event=info->event;
  2226.  
  2227.   if(event >= ' ' && event < 255)
  2228.     return 1;
  2229.  
  2230.   // Cut off warning until I expand this function
  2231.   if(input!=input)
  2232.     input=input;
  2233.  
  2234.   return 0;
  2235. }
  2236.  
  2237.  
  2238. char ** read_picture(char *picture)
  2239. {
  2240.   int amount;
  2241.   int pos=0;
  2242.   int x, done=0;
  2243.   int next=0;
  2244.  
  2245.  
  2246.   while(!done && !hangup)
  2247.   {
  2248.  
  2249.     x=picture[pos];
  2250.  
  2251.     if(!x)
  2252.       break;
  2253.  
  2254.     switch(x)
  2255.     {
  2256.       case '!': // Execlude
  2257.         next=1;
  2258.         ++pos;
  2259.         break;
  2260.  
  2261.       case '[': // Start range
  2262.         while(x!=']' && x)
  2263.         {
  2264.           ++pos;
  2265.           x=picture[pos];
  2266.         }
  2267.         next=0;
  2268.         break;
  2269.  
  2270.       case '@': // Predefined type
  2271.         next=1;
  2272.         ++pos;
  2273.         break;
  2274.  
  2275.       case '~': // Force next char
  2276.         ++pos;
  2277.         if(picture[pos])
  2278.           ++pos;
  2279.  
  2280.         next=0;
  2281.         break;
  2282.  
  2283.       default:
  2284.         next=0;
  2285.         ++pos;
  2286.         break;
  2287.     }
  2288.  
  2289.     if(next)
  2290.       ++amount;
  2291.  
  2292.   }
  2293.  
  2294.   return NULL;
  2295. }
  2296.  
  2297.  
  2298.  
  2299.  
  2300. void redrawinputpic(int type, inputpicrec *input, varimenuinfo *info, int mode)
  2301. {
  2302.   int savecolor=curatr;
  2303.  
  2304.   if(input->pos < input->first)
  2305.   {
  2306.     input->first=input->pos - (input->amount_to_show/2);
  2307.     if(input->first<0)
  2308.       input->first=0;
  2309.  
  2310.     type=COMMON_FULL;
  2311.   }
  2312.   else if(input->pos - input->first > input->amount_to_show)
  2313.   {
  2314.     input->first=input->pos - (input->amount_to_show/2);
  2315.     if(input->first > input->maxlen)
  2316.       input->first=input->maxlen;
  2317.     type=COMMON_FULL;
  2318.   }
  2319.   else if(input->curmode!=mode)
  2320.     type=COMMON_FULL;
  2321.  
  2322.   input->curmode=mode;
  2323.  
  2324.   input->curxpos=input->xpos+(input->pos-input->first);
  2325.   input->curypos=input->ypos;
  2326.  
  2327.   if(type==COMMON_FULL)
  2328.   {
  2329.     strncpy(input->show, input->text+input->first, input->amount_to_show);
  2330.     input->show[input->amount_to_show]=0;
  2331.  
  2332.     pad_string(input->show, input->amount_to_show);
  2333.     GOTO_XY(input->xpos, input->ypos);
  2334.     setc(mode==COMMON_INACTIVE ? info->inactive_color : mode ==COMMON_ITEM ? info->mi_normal : info->ci_normal);
  2335.  
  2336.     if(IE_PASSWORD & input->char_case)
  2337.       echo=0;
  2338.     else
  2339.       echo=1;
  2340.     outstr(input->show);
  2341.   }
  2342.   else if(type==COMMON_PARTIAL)
  2343.   {
  2344.     int where = input->first+(input->pos-input->first);
  2345.     int a=input->amount_to_show-(input->pos-input->first)+1;
  2346.  
  2347.     if(input->pos!=input->first)
  2348.     {
  2349.       strncpy(input->show, input->text+where-1, a+1);
  2350.       input->show[a]=0;
  2351.       input->show[input->amount_to_show]=0 ;
  2352.  
  2353.       if(input->bs && strlen(input->show) != input->amount_to_show)
  2354.         strcat(input->show, " ");
  2355.  
  2356.       GOTO_XY(input->xpos + input->pos - input->first - 1, input->ypos);
  2357.     }
  2358.     else
  2359.     {
  2360.       strncpy(input->show, input->text+where, a);
  2361.       input->show[a]=0;
  2362.       input->show[input->amount_to_show]=0;
  2363.  
  2364.       if(input->bs && strlen(input->show) != input->amount_to_show)
  2365.         strcat(input->show, " ");
  2366.  
  2367.       GOTO_XY(input->xpos + input->pos - input->first, input->ypos);
  2368.     }
  2369.     setc(mode==COMMON_INACTIVE ? info->inactive_color : mode ==COMMON_ITEM ? info->mi_normal : info->ci_normal);
  2370.  
  2371.     if(IE_PASSWORD & input->char_case)
  2372.       echo=0;
  2373.     else
  2374.       echo=1;
  2375.     outstr(input->show);
  2376.   }
  2377.   else if(type==COMMON_NONE)
  2378.   {
  2379.   }
  2380.   else
  2381.   {
  2382.   }
  2383.  
  2384.  
  2385.   if(mode==COMMON_CURRENT)
  2386.   {
  2387.  
  2388.     info->xpos=input->xpos + input->pos - input->first;
  2389.     info->ypos=input->ypos;
  2390.     GOTO_XY(info->xpos, info->ypos);
  2391.   }
  2392.  
  2393.   input->bs=FALSE;
  2394.   setc(savecolor);
  2395. }
  2396.  
  2397.  
  2398.