home *** CD-ROM | disk | FTP | other *** search
/ Monster Media 1994 #1 / monster.zip / monster / PROG_C / GUILIB.ZIP / MENU.C < prev    next >
C/C++ Source or Header  |  1992-11-27  |  63KB  |  1,982 lines
  1. /*---------------------------------------------------------------------------*
  2. *  PLAIN DESIGN CORPORATION       COPYRIGHT (c)  1992                        *
  3. *----------------------------------------------------------------------------*
  4. *  PULL DOWN MENU SYSTEM for character based user interfaces                 *         
  5. *---------------------------------------------------------------------------*/
  6.  
  7. #include "stdio.h"
  8. #include "string.h"
  9. #include "conio.h"
  10. #include "stdlib.h"
  11. #include "bios.h"
  12. #include "ctype.h"
  13. #include "conio.h"
  14. #include "dos.h"
  15. #include "menu.h"
  16.  
  17. /*-------------------------------*/
  18. /* FOR MICROSOFT C COMPILER      */
  19. /*-------------------------------*/
  20. #ifdef MSC
  21. #define getvect(i) _dos_getvect(i)
  22. #define bioskey(i) _bios_keybrd(i)
  23. #endif
  24. /*-------------------------------*/
  25.  
  26. int  menu_descriptor=TEXT_FILE;   
  27.  
  28. FILE *fp;                         /* file pointer for the menu file        */
  29.  
  30. char menu_file[40]="MENUFILE";    /* menu descriptor file name             */
  31. int  menu_color=0x70;             /* menu color                            */
  32. int  menu_hotkey_color=0x74;      /* color of the hotkey                   */
  33. int  menu_sel_color=0x47;         /* selected menu item color              */
  34. int  menu_shadow=0x08;            /* shadow for expanded boxes             */
  35. int  menu_x=0;                    /* menu bar x locations                  */
  36. int  menu_y=0;                    /* menu bar y locations                  */
  37. int  menu_x_size=80;              /* size of the x axis of the bar         */
  38.  
  39.  
  40. char menu_title[MAX_TITLE][20];   /* menu title array                      */
  41. char title_hotkey[MAX_TITLE];     /* title hotkey array                    */
  42. char title_hotkey_loc[MAX_TITLE]; /* title hotkey location                 */
  43. long title_loc [MAX_TITLE];       /* each title location in menufile       */                                                   
  44. int  title_ident[MAX_TITLE];      /* title identifier number array         */                                   
  45. int  title_acc[MAX_TITLE];        /* title accelerator array               */
  46. int  title_x[MAX_TITLE];          /* title x location array                */
  47. int  title_num;                   /* number of titles in menufile          */
  48. int  title_ptr;                   /* title pointer variable                */
  49.  
  50. int  menu_acc_num;                /* number of menu accelerators           */
  51. int  menu_acc[MAX_ACC];           /* store the accelerator key code        */
  52. int  menu_ident[MAX_ACC];         /* return value for accelerated key code */
  53.  
  54. int  cur_ident;                   /* used to pass the current ident        */  
  55. int  key_return;                  /* key board status variable             */
  56. /*--------------------------------------------------------------------------*/
  57. union REGS iReg,oReg;          
  58. int   mousefound=NO;              /* mouse existance variable              */
  59. int   mousex;                     /* mouse cursor x location               */
  60. int   mousey;                     /* mouse cursor y location               */
  61. /*--------------------------------------------------------------------------*/
  62. int   txt_curs_x;                 /* text  cursor x location               */
  63. int   txt_curs_y;                 /* text  cursor y location               */
  64. int   curs_start_line=8;
  65. int   curs_end_line=8;
  66.  
  67. int   ms;                         /* mouse key status                      */
  68. int   mouse_display;              /* mouse cursor ON/OFF indicator         */
  69.  
  70. char  **menu;
  71. int   menu_lines;
  72. int   menu_line_ptr;
  73. /*--------------------------------------------------------------------------*/
  74. /*-------------------------------------*/
  75. /*          window  declerations       */
  76. /*-------------------------------------*/
  77. int           box_num;
  78. unsigned char *save_box [MAX_WINDOWS];
  79. unsigned char *gsave_box[MAX_WINDOWS];
  80. int           xwin      [MAX_WINDOWS];
  81. int           ywin      [MAX_WINDOWS];
  82. int           xwinsize  [MAX_WINDOWS];
  83. int           ywinsize  [MAX_WINDOWS];
  84. int           wincolor  [MAX_WINDOWS];
  85. int           winshadow [MAX_WINDOWS];
  86. int           winborder [MAX_WINDOWS];
  87. /*-------------------------------------*/
  88.  
  89.  
  90. int            initvar=1;   /* will indicate if initdisplay has been called */
  91. unsigned char  back_block;  /* block used by frect to fill a rectangle      */
  92.  
  93.  
  94.  
  95. /*--------------------------------------------------------------------------*/
  96. /*  int bar_menu(action);                                                    *
  97. *                                                                            *
  98. *    action : INIT         initialize the menu function by opening the menu  *
  99. *                          file and display menu titles on the screen.       *
  100. *             KEY_RETURN   returns keyboard input as it would be returned    *
  101. *                          by getkey function; return EOF if no key pressed  *
  102. *                          . If ALT key is pressed and released (ALONE), it  *
  103. *                            will turn the menu on; when appropriate menu is *
  104. *                            selected, it will return the menu identifier #. *
  105. *                          . If mouse left key is pressed on a menu title,   *
  106. *                            bar_menu will turn the menu on and return the   *
  107. *                            menu_identifier when an entry is selected.      *
  108. *                          . If an accelerator is detected, bar_menu will    *
  109. *                            return the identifier associated with the       *
  110. *                            accelerator without turning the menu on.        *
  111. /*--------------------------------------------------------------------------*/
  112. int  bar_menu(action)
  113. int  action;
  114. {
  115.    int  ch=0;
  116.    int  mouse_menu=NO;
  117.    int  acc_expand=OFF;
  118.    int  i;
  119.  
  120.    /*----------------------------------------------------*/
  121.    /* initilize the menu bar variables and read the menu */
  122.    /* file and display the unactivated menu              */
  123.    /*----------------------------------------------------*/
  124.    if(action==INIT)
  125.    { init_menu();
  126.      return(EOF);
  127.    }
  128.    /*--------------------------------------------------------------------*/
  129.    if(action==DISPLAY)
  130.    { display_menu();
  131.      return(EOF);
  132.    }
  133.    /*--------------------------------------------------------------------*/
  134.    /*                ACTIONS FOR   KEY_RETURN parameter                  */
  135.    /*--------------------------------------------------------------------*/
  136.  
  137.    /*-------------------------------------------*/
  138.    /* check if mouse is clicked on the menu bar */
  139.    /*-------------------------------------------*/
  140.    if(mouse_left_pressed()==YES)
  141.    { get_mouse_location();
  142.      if(mousey==menu_y)
  143.      { for(i=0;i<title_num;i++)
  144.        { if(mousex>=title_x[i] && mousex<=title_x[i]+strlen(menu_title[i])-1)
  145.          { mouse_menu=YES;
  146.            title_ptr=i;
  147.            break;
  148.          }
  149.        }
  150.      }
  151.    }
  152.    
  153.    /*-------------------------------------------*/
  154.    /*   check if the alt key is pressed         */
  155.    /*-------------------------------------------*/
  156.    if(mouse_menu==NO)
  157.    { if(alt_pressed()==NO)
  158.      { ch=getkey();
  159.        if(ch!=EOF)   /* check if an accelerator key has been pressed */
  160.        { for (i=0;i<menu_acc_num;i++)
  161.          { if(menu_acc[i]==ch)
  162.            { return(menu_ident[i]);
  163.            }
  164.          }
  165.          for (i=0;i<title_num;i++)
  166.          { if(title_acc[i]==ch)
  167.            { title_ptr=i;
  168.              acc_expand=ON;
  169.              break;
  170.            }
  171.          }
  172.        }
  173.        if(acc_expand==OFF)
  174.        { return(ch);  
  175.        }
  176.      }
  177.      /*----------------------*/
  178.      /* alt key is pressed   */
  179.      /*----------------------*/
  180.      else
  181.      { while(alt_pressed()==YES)
  182.        { ch=getkey();
  183.          
  184.          if(ch!=EOF)
  185.          { key_return=ON;
  186.            for (i=0;i<menu_acc_num;i++)
  187.            { if(menu_acc[i]==ch)
  188.              { return(menu_ident[i]);
  189.              }
  190.            }
  191.            for (i=0;i<title_num;i++)
  192.            { if(title_acc[i]==ch)
  193.              { title_ptr=i;
  194.                acc_expand=ON;
  195.                break;
  196.              }
  197.            }
  198.            if(acc_expand==OFF)
  199.            { return(ch);
  200.            }
  201.          }
  202.          if(acc_expand==ON)
  203.          { break;
  204.          }
  205.        }
  206.  
  207.  
  208.  
  209.  
  210.        if(key_return==ON && acc_expand==OFF)
  211.        { key_return=OFF;
  212.          return(EOF);
  213.        }
  214.  
  215.  
  216.  
  217.        if(acc_expand==OFF)
  218.        { title_ptr=0;
  219.        }
  220.        else
  221.        { title_ptr=i;
  222.        }
  223.      }
  224.    }
  225.  
  226.    /*--------------------------*/
  227.    /*   turn on the menu now   */
  228.    /*--------------------------*/
  229.    if(menu_descriptor==TEXT_FILE)
  230.    { fp=fopen(menu_file,"r");
  231.      if(fp==NULL)
  232.      { cls();
  233.        printf("\n cannot open file %s ",menu_file);
  234.        exit(-1);
  235.      }
  236.    }
  237.  
  238.    while(1)
  239.    { ch=expand(acc_expand);
  240.      if(acc_expand==ON)
  241.      { acc_expand=OFF;
  242.      }
  243.      switch(ch)
  244.      { case RIGHTKEY :
  245.         title_ptr++;
  246.         if(title_ptr==title_num)title_ptr=0;
  247.         continue;
  248.        case LEFTKEY  :
  249.         title_ptr--;
  250.         if(title_ptr<0)title_ptr=title_num-1;
  251.         continue;
  252.        case ESC      :
  253.         if(menu_descriptor==TEXT_FILE)
  254.         { fclose(fp);
  255.         }
  256.         return(EOF);
  257.        case ENTER    :
  258.         if(menu_descriptor==TEXT_FILE)
  259.         { fclose(fp);
  260.         }
  261.         return(cur_ident);
  262.      }
  263.    }
  264. }
  265. /*--------------------------------------------------------------------------*/
  266. /*                        initialize the menu system                        */
  267. /*--------------------------------------------------------------------------*/
  268. void init_menu(void)
  269. {
  270.   char buffer[100];
  271.   char dumy[40];
  272.   int  i;
  273.  
  274.   if(menu_descriptor==TEXT_FILE)
  275.   { fp=fopen(menu_file,"rb");
  276.     if(fp==NULL)
  277.     { cls();
  278.       printf("\n cannot open %s file \n press a key to exit to dos ",menu_file);
  279.       getch();
  280.       exit(-1);
  281.     }
  282.   }
  283.   frect(menu_x,menu_y,menu_x+menu_x_size-1,menu_y,menu_color,0);
  284.   title_num=0;
  285.   menu_acc_num=0;
  286.   while(next_line(buffer,sizeof(buffer))!=-1)
  287.   {       
  288.      if(strnicmp(buffer,"LINE",4)!=0 && strnicmp(buffer,"SUBMENU",7)!=0 &&
  289.         strnicmp(buffer,"END",3)!=0 && buffer[0]!='"')
  290.      { continue;
  291.      }
  292.  
  293.      if(buffer[1]!='%')
  294.      { if(menu_acc_num==MAX_ACC-1)
  295.        { continue;
  296.        }
  297.        if(strnicmp(buffer,"LINE",4)==0  ||
  298.            strnicmp(buffer,"SUBMENU",7)==0 ||
  299.             strnicmp(buffer,"END",3)==0        )
  300.        { continue;
  301.        }
  302.        menu_acc[menu_acc_num]=0;
  303.        seperate(buffer,dumy,&menu_ident[menu_acc_num],
  304.                             &menu_acc[menu_acc_num] ,ON  );
  305.        if( menu_acc[menu_acc_num]!=0)menu_acc_num++;
  306.        continue;  
  307.      }
  308.      title_hotkey[title_num]=seperate(buffer,menu_title[title_num],
  309.                          &title_ident[title_num],&title_acc[title_num],ON   );
  310.      if(title_hotkey[title_num]!=0)
  311.      { for(i=0;i<strlen(menu_title[title_num]);i++)
  312.        { if(menu_title[title_num][i]==title_hotkey[title_num])
  313.          { title_hotkey_loc[title_num]=i;
  314.            break;
  315.          }
  316.        }
  317.      }
  318.      title_loc[title_num]=get_pos();
  319.      title_x[title_num]=title_ptr;
  320.      pls(title_x[title_num],menu_y,menu_title[title_num]+1,menu_color);
  321.      place_title_hot(title_num);
  322.      title_ptr+=strlen(menu_title[title_num])+1;
  323.      title_num++;
  324.      if(title_num==MAX_TITLE)
  325.      { cls();
  326.        printf("\n too many menu titles ");
  327.        getch();
  328.        exit(-1);
  329.      }
  330.   }
  331.   if(menu_descriptor==TEXT_FILE)
  332.   { fclose(fp);
  333.   }
  334.  
  335. }
  336. /*--------------------------------------------------------------------------*/
  337. /*                        Display the menu bar                              */
  338. /*--------------------------------------------------------------------------*/
  339. void display_menu(void)
  340. {
  341.   int i;
  342.  
  343.   frect(menu_x,menu_y,menu_x+menu_x_size-1,menu_y,menu_color,0);
  344.   for(i=0;i<title_num;i++)
  345.   {  pls(title_x[i],menu_y,menu_title[i]+1,menu_color);
  346.      place_title_hot(i);
  347.   }
  348. }
  349. /*--------------------------------------------------------------------------*/
  350. /* seperate entry from identifier and accelerator, ad return the hotkey     */
  351. /*--------------------------------------------------------------------------*/
  352. unsigned char seperate(buffer,entry,ident,acc,hotkey_sep)
  353. char *buffer;
  354. char *entry;
  355. int  *ident;
  356. int  *acc;
  357. int  hotkey_sep;
  358. {
  359.  int i;
  360.  int j=0;
  361.  int s=0;
  362.  unsigned char hotkey=0;
  363.  
  364.  for(i=0;i<strlen(buffer);i++)
  365.  { if(buffer[i]=='"')
  366.    { s++;
  367.      continue;
  368.    }
  369.    if(s==1)
  370.    { if(buffer[i]=='^' )
  371.      { if(hotkey_sep==ON)
  372.        { i++;
  373.          hotkey=buffer[i];
  374.        }
  375.        else
  376.        { hotkey=buffer[i+1];
  377.        }
  378.      }
  379.      entry[j]=buffer[i];
  380.      j++;
  381.    }
  382.    if(s==2)
  383.    { entry[j]=0;
  384.      break;
  385.    }
  386.  }
  387.  
  388.  if  (s!=2)   
  389.  { cls();
  390.    printf("\n the following line in the menu descriptor file is illegal");
  391.    printf("\n var s=%d and ^%s^",s,buffer);
  392.    getch();
  393.    exit(-1);
  394.  }
  395.  sscanf(buffer+i+1,"%d %d",ident,acc);
  396.  return(hotkey);
  397. }
  398. /*--------------------------------------------------------------------------*/
  399. /* expand title # acc_expand                                                */
  400. /*--------------------------------------------------------------------------*/
  401. int expand(acc_expand)
  402. int acc_expand;
  403. { 
  404.   unsigned char entry[MAX_ENTRIES][50];
  405.   unsigned char hotkey[MAX_ENTRIES];
  406.   int hotkey_loc[MAX_ENTRIES];
  407.   unsigned char sep[42];
  408.   int  ident[MAX_ENTRIES];
  409.   int  acc  [MAX_ENTRIES];
  410.   long submenu_loc[MAX_ENTRIES];
  411.   int  entry_num=0;
  412.   int  entry_ptr=0;
  413.   char buffer[100];
  414.   int  box_x;
  415.   int  box_y;
  416.   int  box_width=0;
  417.   int  ch;
  418.   int  i;
  419.   int  mouse_left;
  420.   int  break_loop=OFF;
  421.   int  highlight;
  422.   /*---------------------------------*/
  423.   /* change color of the title first */
  424.   /*---------------------------------*/
  425.   pls(title_x[title_ptr],menu_y,menu_title[title_ptr]+1,menu_sel_color);
  426.   set_pos(&title_loc[title_ptr]);
  427.   while(next_line(buffer,sizeof(buffer))!=-1)
  428.   { 
  429.     if(strnicmp(buffer,"LINE",4)!=0 && strnicmp(buffer,"SUBMENU",7)!=0 &&
  430.        strnicmp(buffer,"END",3)!=0 && buffer[0]!='"')
  431.     { continue;
  432.     }
  433.     if(buffer[1]=='%')break;
  434.     submenu_loc[entry_num]=0L;
  435.     if(strnicmp(buffer,"LINE",4)==0)
  436.     { strcpy(entry[entry_num],"LINE");
  437.       entry_num++;
  438.       if(entry_num==MAX_ENTRIES)
  439.       { cls();
  440.         printf("\n too many entries for the title=%s",menu_title[title_ptr]);
  441.         getch();
  442.         exit(-1);
  443.       }
  444.       continue;
  445.     }
  446.     else if(strnicmp(buffer,"SUBMENU",7)==0)
  447.     { submenu_loc[entry_num-1]=get_pos();
  448.       i=1;
  449.       while(next_line(buffer,sizeof(buffer))!=-1)
  450.       { 
  451.         if(strnicmp(buffer,"LINE",4)!=0 && strnicmp(buffer,"SUBMENU",7)!=0 &&
  452.            strnicmp(buffer,"END",3)!=0 && buffer[0]!='"')
  453.         { continue;
  454.         }
  455.  
  456.         if(strnicmp(buffer,"SUBMENU",7)==0)
  457.         { i++;
  458.         }
  459.         if(strnicmp(buffer,"END",3)==0)
  460.         { i--;
  461.         }
  462.         if(i==0)break;
  463.       }
  464.       if(i!=0)
  465.       { cls();
  466.         printf("\n ERROR   SUBMENU without an END ");
  467.         getch();
  468.         exit(-1);
  469.       }
  470.       continue;
  471.     }
  472.     hotkey[entry_num]=seperate(buffer,entry[entry_num],&ident[entry_num],
  473.                                                        &acc[entry_num],ON )  ;
  474.     for(i=0;i<strlen(entry[entry_num]);i++)
  475.     { if(entry[entry_num][i]==hotkey[entry_num])
  476.       { hotkey_loc[entry_num]=i;
  477.         break;
  478.       }
  479.       else
  480.       { hotkey_loc[entry_num]=0;
  481.       }
  482.     }
  483.     if(hotkey[entry_num]>='a' && hotkey[entry_num]<='z')
  484.     { hotkey[entry_num]-=32;
  485.     }
  486.     if(strlen(entry[entry_num])>box_width)
  487.     { box_width=strlen(entry[entry_num]);
  488.     }
  489.     entry_num++;
  490.   }
  491.   /*-----------------------------------*/
  492.   /* show a box to expand the title on */
  493.   /*-----------------------------------*/
  494.   if(entry_num>0)
  495.   { box_x=title_x[title_ptr];
  496.     box_y=menu_y+1;
  497.   }
  498.   else
  499.   { if(acc_expand==ON)
  500.     { pls(title_x[title_ptr],menu_y,menu_title[title_ptr]+1,menu_sel_color);
  501.       cur_ident=title_ident[title_ptr];
  502.       return(ENTER);
  503.     }
  504.     box_x=-1;
  505.     box_y=-1;
  506.   }
  507.   strcpy(sep,"├");
  508.   for(i=0;i<box_width;i++)
  509.   { strcat(sep,"─");
  510.   }
  511.   strcat(sep,"┤");
  512.  
  513.  
  514.   if(entry_num>0)
  515.   { 
  516. /*-------------------------------------*/
  517. /* adjust box_x                        */
  518. /*-------------------------------------*/
  519.     if(box_x+box_width+3>79)
  520.     { box_x=79-box_width-3;
  521.       if(box_x+box_width+3>79)
  522.       { box_x=76-box_width;
  523.       }
  524.     }
  525.     messagebox(box_x,box_y,box_width+2,entry_num+2,menu_color,menu_shadow,1,YES);
  526.     for(i=0;i<entry_num;i++)
  527.     { if(stricmp(entry[i],"LINE")==0)
  528.       { pls(box_x,box_y+1+i,sep,menu_color);
  529.       }
  530.       else
  531.       { pls(box_x+1,box_y+1+i,entry[i],menu_color);
  532.         if(hotkey[i]!=0)
  533.         { writechar(box_x+1+hotkey_loc[i],box_y+1+i,entry[i][hotkey_loc[i]],
  534.                                                           menu_hotkey_color);
  535.         }
  536.         if(submenu_loc[i]!=0L)
  537.         { writechar(box_x+box_width,box_y+1+i,16,menu_color);
  538.         }
  539.       }
  540.     } 
  541.     chcolor(box_x+1,box_y+1+entry_ptr,box_width,1,menu_sel_color);
  542.     highlight=ON;
  543.   }
  544.   while(1)
  545.   { ch=getkey();
  546.     
  547.     if(ch!=EOF)
  548.     { for(i=0;i<title_num;i++)
  549.       { if(title_acc[i]==ch && title_ptr!=i)
  550.         { pls(title_x[title_ptr],menu_y,menu_title[title_ptr]+1,menu_color);
  551.           place_title_hot(title_ptr);
  552.           title_ptr=i;
  553.           break_loop=ON;
  554.           break;
  555.         }
  556.       }
  557.       for (i=0;i<menu_acc_num;i++)
  558.       { if(menu_acc[i]==ch)
  559.         { cur_ident=menu_ident[i];
  560.           ch=ENTER;
  561.           break_loop=ON;
  562.           break;
  563.         }
  564.       }
  565.     }
  566.     /*-------------------------------------*/
  567.     /* check if a hot key has been pressed */
  568.     /*-------------------------------------*/
  569.     if(ch>='a' && ch<='z')
  570.     { ch-=32;
  571.     }
  572.     for(i=0;i<entry_num;i++)
  573.     { if(ch==hotkey[i])
  574.       { cur_ident=ident[i];
  575.         chcolor(box_x+1,box_y+1+entry_ptr,box_width,1,menu_color);
  576.         if(hotkey[entry_ptr]!=0)
  577.         { writechar(box_x+1+hotkey_loc[entry_ptr],box_y+1+entry_ptr,
  578.                entry[entry_ptr][hotkey_loc[entry_ptr]],menu_hotkey_color);
  579.         }
  580.         entry_ptr=i;
  581.         chcolor(box_x+1,box_y+1+entry_ptr,box_width,1,menu_sel_color);
  582.         ch=ENTER;
  583.         break;
  584.       }
  585.     }
  586.     
  587.     mouse_left=mouse_state();
  588.     if(mouse_left==PRESSED)
  589.     { get_mouse_location();
  590.       if(mousex>=box_x+1 && mousex<=box_x+box_width &&
  591.          mousey>box_y && mousey<=box_y+entry_num )
  592.       { if(strnicmp(entry[mousey-box_y-1],"LINE",4)==0 && highlight==ON)
  593.         { chcolor(box_x+1,box_y+1+entry_ptr,box_width,1,menu_color);
  594.           if(hotkey[entry_ptr]!=0)
  595.           { writechar(box_x+1+hotkey_loc[entry_ptr],box_y+1+entry_ptr,
  596.                  entry[entry_ptr][hotkey_loc[entry_ptr]],menu_hotkey_color);
  597.           }
  598.           highlight=OFF;
  599.           continue;
  600.         }
  601.         if(entry_ptr != mousey-box_y-1 || highlight==OFF)
  602.         { if(strnicmp(entry[mousey-box_y-1],"LINE",4)==0)
  603.           { highlight=OFF;
  604.             continue;
  605.           }
  606.           chcolor(box_x+1,box_y+1+entry_ptr,box_width,1,menu_color);
  607.           if(hotkey[entry_ptr]!=0)
  608.           { writechar(box_x+1+hotkey_loc[entry_ptr],box_y+1+entry_ptr,
  609.                  entry[entry_ptr][hotkey_loc[entry_ptr]],menu_hotkey_color);
  610.           }
  611.           entry_ptr=mousey-box_y-1;
  612.           chcolor(box_x+1,box_y+1+entry_ptr,box_width,1,menu_sel_color);
  613.           highlight=ON;
  614.           continue;
  615.         }
  616.       }
  617.       else if(mousey==menu_y)     /* check for title change */
  618.       { for(i=0;i<title_num;i++)
  619.         { if(mousex>=title_x[i] && mousex<=title_x[i]+strlen(menu_title[i])-1
  620.                                 && title_ptr != i  )
  621.           { pls(title_x[title_ptr],menu_y,menu_title[title_ptr]+1,menu_color);
  622.             place_title_hot(title_ptr);
  623.             title_ptr=i;
  624.             break_loop=ON;
  625.             break;
  626.           }
  627.         }
  628.       }
  629.       else if(highlight==ON)
  630.       { chcolor(box_x+1,box_y+1+entry_ptr,box_width,1,menu_color);
  631.         if(hotkey[entry_ptr]!=0)
  632.         { writechar(box_x+1+hotkey_loc[entry_ptr],box_y+1+entry_ptr,
  633.                entry[entry_ptr][hotkey_loc[entry_ptr]],menu_hotkey_color);
  634.         }
  635.         highlight=OFF;
  636.       }
  637.     }
  638.     else if(mouse_left==PRESSEDRELEASED)
  639.     { if(mousex>=box_x+1 && mousex<=box_x+box_width &&
  640.          mousey>box_y && mousey<=box_y+entry_num)
  641.       { if(strnicmp(entry[mousey-box_y-1],"LINE",4)==0)
  642.         { ch=ESC;
  643.           break;
  644.         }
  645.         else
  646.         { cur_ident=ident[entry_ptr];
  647.           ch=ENTER;
  648.         }
  649.       }
  650.       else if(entry_num==0 && mousey==menu_y && mousex>=title_x[title_ptr]
  651.               && mousex<=title_x[title_ptr]+strlen(menu_title[title_ptr])-1 )
  652.       { ch=ENTER;
  653.         cur_ident=title_ident[title_ptr];
  654.       }
  655.       else if(entry_num>0 && mousey==menu_y && mousex>=title_x[title_ptr]
  656.               && mousex<=title_x[title_ptr]+strlen(menu_title[title_ptr])-1 )
  657.       { ms=RELEASED;
  658.         chcolor(box_x+1,box_y+1+entry_ptr,box_width,1,menu_sel_color);
  659.         continue;
  660.       }
  661.  
  662.       else
  663.       { ch=ESC;
  664.       }
  665.       ms=RELEASED;
  666.     }
  667.  
  668.  
  669.     if(ch==ENTER && entry_num>0 && submenu_loc[entry_ptr]!=0 )
  670.     { ch=submenu(submenu_loc[entry_ptr],box_x+box_width/2+1,box_y+entry_ptr+2);
  671.       if(ch==-2)
  672.       { get_mouse_location();
  673.         if(mousex>=box_x && mousex<=box_x+box_width+2 &&
  674.            mousey>=box_y+1 && mousey<=box_y+entry_num   )
  675.         { if(strnicmp(entry[mousey-box_y-1],"LINE",4)==0)
  676.           { ch=ESC;
  677.             break;
  678.           }
  679.           chcolor(box_x+1,box_y+1+entry_ptr,box_width,1,menu_color);
  680.           if(hotkey[entry_ptr]!=0)
  681.           { writechar(box_x+1+hotkey_loc[entry_ptr],box_y+1+entry_ptr,
  682.                  entry[entry_ptr][hotkey_loc[entry_ptr]],menu_hotkey_color);
  683.           }
  684.  
  685.           entry_ptr=mousey-box_y-1;
  686.           chcolor(box_x+1,box_y+1+entry_ptr,box_width,1,menu_sel_color);
  687.           continue;
  688.         }
  689.  
  690.         else if(mousey==menu_y)     /* check for title change */
  691.         { for(i=0;i<title_num;i++)
  692.           { if(mousex>=title_x[i] && mousex<=title_x[i]+strlen(menu_title[i])-1
  693.                                   && title_ptr != i  )
  694.             { pls(title_x[title_ptr],menu_y,menu_title[title_ptr]+1,menu_color);
  695.               place_title_hot(title_ptr);
  696.               title_ptr=i;
  697.               break_loop=ON;
  698.               break;
  699.             }
  700.           }
  701.           if(break_loop==OFF)
  702.           { ch=ESC;
  703.           }
  704.         }
  705.  
  706.         else
  707.         { ch=ESC;
  708.         }
  709.       }
  710.       
  711.       if(ch!=-1)
  712.       { break;
  713.       }
  714.     }
  715.     if(ch==RIGHTKEY || ch==LEFTKEY || ch==ESC || ch==ENTER)
  716.     { if(entry_num>0)
  717.       { cur_ident=ident[entry_ptr];
  718.       }
  719.       else
  720.       { cur_ident=title_ident[title_ptr];
  721.       }
  722.       break;
  723.     }
  724.  
  725.  
  726.     switch(ch)
  727.     { case DOWNKEY :
  728.        chcolor(box_x+1,box_y+1+entry_ptr,box_width,1,menu_color);
  729.        if(hotkey[entry_ptr]!=0)
  730.        { writechar(box_x+1+hotkey_loc[entry_ptr],box_y+1+entry_ptr,
  731.               entry[entry_ptr][hotkey_loc[entry_ptr]],menu_hotkey_color);
  732.        }
  733.        entry_ptr++;
  734.        if(entry_ptr==entry_num)entry_ptr=0;
  735.        if(stricmp(entry[entry_ptr],"LINE")==0)
  736.        { entry_ptr++;
  737.          if(entry_ptr==entry_num)entry_ptr=0;
  738.        }
  739.        chcolor(box_x+1,box_y+1+entry_ptr,box_width,1,menu_sel_color);
  740.        break;   
  741.       case UPKEY :
  742.        chcolor(box_x+1,box_y+1+entry_ptr,box_width,1,menu_color);
  743.        if(hotkey[entry_ptr]!=0)
  744.        { writechar(box_x+1+hotkey_loc[entry_ptr],box_y+1+entry_ptr,
  745.               entry[entry_ptr][hotkey_loc[entry_ptr]],menu_hotkey_color);
  746.        }
  747.        entry_ptr--;
  748.        if(entry_ptr<0)entry_ptr=entry_num-1;
  749.        if(stricmp(entry[entry_ptr],"LINE")==0)
  750.        { entry_ptr--;
  751.          if(entry_ptr<0)entry_ptr=entry_num-1;
  752.        }
  753.        chcolor(box_x+1,box_y+1+entry_ptr,box_width,1,menu_sel_color);
  754.        break;
  755.     }
  756.     if(break_loop==ON)break;
  757.   }
  758.  
  759.   /*-----------------------------------------*/
  760.   /* change the color of the menu title back */
  761.   /* remove the background box for entries   */
  762.   /*-----------------------------------------*/
  763.   pls(title_x[title_ptr],menu_y,menu_title[title_ptr]+1,menu_color);
  764.   place_title_hot(title_ptr);
  765.   if(entry_num>0)
  766.   { messagebox(box_x,box_y,box_width+2,entry_num+2,menu_color,menu_shadow,0,YES);
  767.   }
  768.   return(ch);
  769. }
  770. /*--------------------------------------------------------------------------*/
  771. /* Place the hotkey letter on the title using the hotkey color              */
  772. /*--------------------------------------------------------------------------*/
  773. void place_title_hot(tn)
  774. int tn;
  775. { 
  776.   if(title_hotkey[tn]!=0)
  777.   { writechar(title_x[tn]+title_hotkey_loc[tn]-1,
  778.                       menu_y,title_hotkey[tn],menu_hotkey_color);
  779.   }
  780.  
  781. }
  782. /*--------------------------------------------------------------------------*/
  783. /* display submenu associated with an entry                                 */
  784. /*--------------------------------------------------------------------------*/
  785. int submenu(location,xstart,ystart)
  786. long location;
  787. int  xstart;
  788. int  ystart;
  789. {
  790.   char     menu[20][40];
  791.   int      m_ident[20];
  792.   long     submenu_loc[20];
  793.   int      menu_num=0;
  794.   char     buffer[100];
  795.   int      box_width=0;
  796.   int      ch=0;
  797.   int      i;
  798.   int      sl;
  799.   int      def=0;
  800.  
  801.   memset(menu,0,(size_t)600);
  802.  
  803.   set_pos(&location);
  804.   
  805.   while(next_line(buffer,sizeof(buffer))!=-1)
  806.   { 
  807.     if(strnicmp(buffer,"LINE",4)!=0 && strnicmp(buffer,"SUBMENU",7)!=0 &&
  808.        strnicmp(buffer,"END",3)!=0 && buffer[0]!='"')
  809.     { continue;
  810.     }
  811.     if(strnicmp(buffer,"END",3)==0)
  812.     { break;
  813.     }
  814.     submenu_loc[menu_num]=0L;
  815.     if(strnicmp(buffer,"SUBMENU",7)==0)
  816.     { submenu_loc[menu_num-1]=get_pos();
  817.       
  818.       i=1;
  819.       while(next_line(buffer,sizeof(buffer))!=-1)
  820.       { 
  821.         if(strnicmp(buffer,"LINE",4)!=0 && strnicmp(buffer,"SUBMENU",7)!=0 &&
  822.            strnicmp(buffer,"END",3)!=0 && buffer[0]!='"')
  823.         { continue;
  824.         }
  825.         if(strnicmp(buffer,"SUBMENU",7)==0)
  826.         { i++;
  827.         }
  828.         if(strnicmp(buffer,"END",3)==0)
  829.         { i--;
  830.         }
  831.         if(i==0)break;
  832.       }
  833.       if(i!=0)
  834.       { cls();
  835.         printf("\n ERROR   SUBMENU without an END ");
  836.         getch();
  837.         exit(-1);
  838.       }
  839.       continue;
  840.     }
  841.     if(strnicmp(buffer,"LINE",4)==0)
  842.     { strcpy(menu[menu_num],"LINE");
  843.       menu_num++;
  844.       continue;
  845.     }
  846.     ch=seperate(buffer,menu[menu_num],&m_ident[menu_num],&i,OFF );
  847.     if(strlen(menu[menu_num])>box_width && ch==0)
  848.     { box_width=strlen(menu[menu_num]);
  849.     }
  850.     else if(strlen(menu[menu_num])-1>box_width && ch!=0)
  851.     { box_width=strlen(menu[menu_num])-1;
  852.     }
  853.     menu_num++;
  854.   }
  855.  
  856.   for(i=0;i<menu_num;i++)
  857.   { while(strlen(menu[i])<box_width)
  858.     { strcat(menu[i]," ");
  859.     }
  860.     if(submenu_loc[i]!=0)
  861.     { if(strchr(menu[i],'^')==NULL)
  862.       { menu[i][box_width-1]=16;
  863.       }
  864.       else
  865.       { menu[i][box_width]=16;
  866.       }
  867.     }
  868.   }
  869.   /*--------------------------------------------------*/
  870.   /* adjust xstart and ystart to stay on the screen   */
  871.   /*--------------------------------------------------*/
  872.   if (xstart+box_width+3>txt_scr_xsize-1)
  873.   { xstart-=box_width+3;
  874.   }
  875.   if (ystart+menu_num+1>txt_scr_ysize-1)
  876.   { ystart=txt_scr_ysize-3-menu_num;
  877.   }
  878.   /*--------------------------------------------------*/
  879.   messagebox(xstart,ystart,box_width+2,menu_num+2,menu_color,
  880.                                                            menu_shadow,1,YES);
  881.   while(1)
  882.   {
  883.     ch=menus(menu,menu_num,xstart+1,ystart+1,menu_color,menu_sel_color,def);
  884.     if(ch>=0 && ch<menu_num)
  885.     { def=ch;
  886.     }
  887.     if(submenu_loc[ch]!=0L && ch!=-1 && ch!=-2)
  888.     { ch=submenu(submenu_loc[ch],xstart+box_width/2+1,ystart+ch+2);
  889.       if(ch==ENTER)
  890.       { ch=ESC;
  891.         break;
  892.       }
  893.       if(ch==-1 )continue;
  894.       if(ch==-2)
  895.       { sl=0;
  896.         for(i=0;i<menu_num;i++)
  897.         { if(strlen(menu[i])>sl)
  898.           { sl=strlen(menu[i]);
  899.           }
  900.         }
  901.         get_mouse_location();
  902.         if(mousex>=xstart+1 && mousex<=xstart+sl+1 && 
  903.             mousey>=ystart+1 && mousey<=ystart+menu_num)
  904.         { def=mousey-ystart-1;
  905.           continue;
  906.         }
  907.       }
  908.     }
  909.     break;
  910.   }
  911.   messagebox(xstart,ystart,box_width+2,menu_num+2,menu_color,
  912.                                                            menu_shadow,0,YES);
  913.   if(ch==-1 || ch==-2)
  914.   { return(ch);
  915.   }
  916.   if(ch!=ESC)
  917.   { cur_ident=m_ident[ch];
  918.   }
  919.   return(ENTER);
  920.   
  921. }
  922. /*--------------------------------------------------------------------------*/
  923. /* return number of spaces in the begining of a line                        */
  924. /*--------------------------------------------------------------------------*/
  925. int remove_spaces(buffer)
  926. char *buffer;
  927. { int i=0;
  928.  
  929.   while (buffer[i]==' ')
  930.   { i++;
  931.   }
  932.   return(i);
  933. }
  934. /*--------------------------------------------------------------------------*/
  935. /*--------------------------------------------------------------------------*/
  936. /* menus function will create a vertical scrolling menu, when a menu is     */
  937. /* selected, it will return the menu number which was highlighted           */
  938. /* parameters :  menu     -> two dimentional array of the menu text         */
  939. /*                             menu[menu_number][field_length]              */
  940. /*               menu_num -> number of menus to be displayed                */
  941. /*               x        -> left coordinate of the left side of the menu   */
  942. /*               y        -> top  coordinate of the menu                    */
  943. /*               menu_col -> menu display color                             */
  944. /*               sel_col  -> highlighted menu color                         */
  945. /*               def_menu -> highlighted menu at default, if 0 first entry  */
  946. /*                           is highlighted.                                */
  947. /*--------------------------------------------------------------------------*/
  948.                                                                             
  949. int menus(menu,menu_num,x,y,menu_col,sel_col,def_menu)
  950.  
  951. char menu[20][40] ;                         /* menu array                */
  952. int  menu_num;                              /* number of menus           */
  953. int  x;                                     /* x coordinate of the menu  */
  954. int  y;                                     /* y coordinate of top left  */
  955. int  menu_col;                              /* color of the menu display */
  956. int  sel_col;                               /* selected menu color       */
  957. int  def_menu;                              /* default menu number       */
  958.                                             /* if -1 just display items  */
  959. {
  960.   int  i;
  961.   int  ch;
  962.   int  mp;                                   /* menu pointer              */
  963.   int  sl=0;
  964.   unsigned char sep[60];
  965.   int  highlight;
  966.   char *c;
  967.   unsigned char menu_hotkey[20];
  968.   int           hotkey_loc[20];
  969.   char          buffer[50];
  970.  
  971.   mp=def_menu;
  972.   ms=RELEASED;
  973.  
  974.   for(i=0;i<menu_num;i++)
  975.   { c=strchr(menu[i],'^');
  976.     if(c!=NULL)
  977.     { menu_hotkey[i]=c[1];
  978.       if(menu_hotkey[i]>='a' && menu_hotkey[i]<='z')
  979.       { menu_hotkey[i]-=32;
  980.       }
  981.       hotkey_loc[i]=c-menu[i];
  982.     }
  983.     else
  984.     { menu_hotkey[i]=0;
  985.       hotkey_loc[i]=-1;
  986.     }
  987.     if( (strlen(menu[i])>sl && menu_hotkey[i]==0) ||
  988.         (strlen(menu[i])-1 >sl && menu_hotkey[i]!=0 )  )
  989.     {  if(menu_hotkey[i]==0)
  990.        { sl=strlen(menu[i]);
  991.        }
  992.        else
  993.        { sl=strlen(menu[i])-1;
  994.        }
  995.     }
  996.   }
  997.  
  998.   strcpy(sep,(unsigned char *)"├");
  999.   for(i=0;i<sl;i++)
  1000.   { strcat(sep,(unsigned char *)"─");
  1001.   }
  1002.   strcat(sep,(unsigned char *)"┤");
  1003.  
  1004.  
  1005.   for(i=0;i<menu_num;i++)                   /* draw the menu with highlight */
  1006.   { if(strlen(menu[i])<sl)
  1007.     { while(strlen(menu[i])<sl)
  1008.       { strcat(menu[i]," ");
  1009.       }
  1010.     }
  1011.     if(strnicmp(menu[i],"LINE",4)==0)
  1012.     { pls(x-1,y+i,(unsigned char *)sep,menu_color);
  1013.       continue;
  1014.     }
  1015.     strcpy(buffer,menu[i]);
  1016.  
  1017.     if(menu_hotkey[i]!=0)
  1018.     { c=strchr(buffer,'^');
  1019.       strcpy(c,c+1);
  1020.     }
  1021.  
  1022.     if(i==def_menu)
  1023.     { pls(x,y+i,(unsigned char *)buffer,sel_col);
  1024.     }
  1025.     else 
  1026.     { pls(x,y+i,(unsigned char *)buffer,menu_col);
  1027.       if(menu_hotkey[i]!=0)
  1028.       { writechar(x+hotkey_loc[i],y+i,menu[i][hotkey_loc[i]+1],menu_hotkey_color);
  1029.       }
  1030.     }
  1031.   }
  1032.   if(def_menu==-1)return(-1);
  1033.   highlight=ON;
  1034.  
  1035.   while(1)
  1036.   { ch=getkey();
  1037.     
  1038.     if(ch>='a' && ch<='z')
  1039.     { ch-=32;
  1040.     }
  1041.     if(ch!=EOF)
  1042.     { for(i=0;i<menu_num;i++)
  1043.       { if(ch==menu_hotkey[i])
  1044.         { ch=ENTER;
  1045.           chcolor(x,y+mp,sl,1,menu_col);
  1046.           if(menu_hotkey[mp]!=0)
  1047.           { writechar(x+hotkey_loc[mp],y+mp,menu[mp][hotkey_loc[mp]+1],
  1048.                                                          menu_hotkey_color);
  1049.           }
  1050.           mp=i;
  1051.           chcolor(x,y+mp,sl,1,sel_col);
  1052.           break;
  1053.         }
  1054.       }
  1055.     }
  1056.  
  1057.     if(ch==EOF && mousefound==YES)     /* check mouse */
  1058.     { if(mouse_state()==PRESSED)
  1059.       { get_mouse_location();
  1060.  
  1061.         if(mousex>=x && mousex<x+strlen(menu[0]) &&
  1062.            mousey>=y && mousey<y+menu_num     )
  1063.         { if(strnicmp(menu[mousey-y],"LINE",4)==0)
  1064.           { if(highlight==ON)
  1065.             { chcolor(x,y+mp,sl,1,menu_col);
  1066.               if(menu_hotkey[mp]!=0)
  1067.               { writechar(x+hotkey_loc[mp],y+mp,menu[mp][hotkey_loc[mp]+1],
  1068.                                                           menu_hotkey_color);
  1069.               }
  1070.               highlight=OFF;
  1071.             }
  1072.           }
  1073.           else if(highlight==OFF)
  1074.           { mp=mousey-y;
  1075.             chcolor(x,mousey,sl,1,sel_col);
  1076.             highlight=ON;
  1077.           }
  1078.           else
  1079.           { if(mp+y>mousey)ch=UPKEY;
  1080.             else if(mp+y<mousey)ch=DOWNKEY;
  1081.             else ch=EOF;
  1082.           }
  1083.         }
  1084.         else
  1085.         { if(highlight==ON)
  1086.           { chcolor(x,y+mp,sl,1,menu_col);
  1087.             if(menu_hotkey[mp]!=0)
  1088.             { writechar(x+hotkey_loc[mp],y+mp,menu[mp][hotkey_loc[mp]+1],
  1089.                                                            menu_hotkey_color);
  1090.             }
  1091.             highlight=OFF;
  1092.           }
  1093.         }
  1094.       }
  1095.       else if(mouse_state()==PRESSEDRELEASED)
  1096.       { get_mouse_location();
  1097.         if(mousex>=x && mousex<x+strlen(menu[0]) &&
  1098.            mousey>=y && mousey<y+menu_num            )
  1099.         { ch=ENTER;
  1100.         }
  1101.         else ch=-2;
  1102.         ms=RELEASED;
  1103.       }
  1104.     }
  1105.  
  1106.     if(ch==UPKEY || ch==DOWNKEY)
  1107.     {  if(mousefound==YES)hide_mouse_cursor();
  1108.        chcolor(x,y+mp,sl,1,menu_col);
  1109.        if(menu_hotkey[mp]!=0)
  1110.        { writechar(x+hotkey_loc[mp],y+mp,menu[mp][hotkey_loc[mp]+1],
  1111.                                                            menu_hotkey_color);
  1112.        }
  1113.        if(ch==UPKEY)
  1114.        { mp--;
  1115.          if(strnicmp(menu[mp],"LINE",4)==0)mp--;
  1116.          if(mp<0)mp=menu_num-1;
  1117.        }
  1118.        if(ch==DOWNKEY)
  1119.        { mp++;
  1120.          if(strnicmp(menu[mp],"LINE",4)==0)mp++;
  1121.          if(mp==menu_num)mp=0;
  1122.        }
  1123.        chcolor(x,y+mp,sl,1,sel_col);
  1124.        if(mousefound==YES)show_mouse_cursor();
  1125.     }
  1126.     if(ch==ENTER)return(mp);
  1127.     if(ch==ESC)return(-1);
  1128.     if(ch==-2) return(-2);
  1129.   }
  1130. }
  1131.  
  1132. /*--------------------------------------------------------------------------*/
  1133. /* place a string on the screen at appropriate coordinates                  */
  1134. /*       parameters : xx1,yy1 -> coordinates                                */
  1135. /*                    c       -> character pointer                          */
  1136. /*                    cm      -> display color                              */ 
  1137. /*--------------------------------------------------------------------------*/
  1138.  
  1139. void pls (int xx1,int yy1,unsigned char c[],int cm)                         
  1140.  
  1141. { int i;
  1142.   int m;
  1143.  
  1144.  
  1145.   if(initvar==0)
  1146.   {  cls();
  1147.      printf("\a \n Display borad not initialized");
  1148.      getch();
  1149.      exit(-1);
  1150.   }
  1151.  
  1152.   m=mouse_display;
  1153.   if(mouse_display==YES) 
  1154.   { hide_mouse_cursor();
  1155.   }
  1156.   for (i = 0;i <strlen((char *)c) ;i++ )
  1157.   { writechar(xx1+i,yy1,c[i],cm);
  1158.   }
  1159.   if(m==YES)
  1160.   { show_mouse_cursor();
  1161.   }
  1162. }
  1163. /*--------------------------------------------------------------------------*/
  1164. /* display a text mode rectangle Parameters: xx1,yy1,xx2,yy2 -> coordinates */
  1165. /*                                           cm              -> color       */                                                                
  1166. /*--------------------------------------------------------------------------*/
  1167.  
  1168. void rect(int xx1,int yy1,int xx2,int yy2,int cm)
  1169. { 
  1170.   int x,y ;
  1171.   int m;
  1172.  
  1173.   m=mouse_display;
  1174.   if(mouse_display==YES) 
  1175.   { hide_mouse_cursor();
  1176.   }
  1177.  
  1178.  
  1179.   if (xx1<=xx2 && yy1<=yy2)
  1180.   { for (x = xx1; x < xx2; x++)
  1181.     { writechar(x,yy1,196,cm);
  1182.       writechar(x,yy2,196,cm);
  1183.     }
  1184.  
  1185.      for (y = yy1+1; y < yy2; y++) 
  1186.     { writechar(xx1,y,179,cm);
  1187.       writechar(xx2,y,179,cm);
  1188.     }                          
  1189.  
  1190.     writechar(xx1,yy1,218,cm);
  1191.     writechar(xx2,yy1,191,cm);
  1192.     writechar(xx1,yy2,192,cm);
  1193.     writechar(xx2,yy2,217,cm);
  1194.  
  1195.   } 
  1196.   if(m==YES)
  1197.   { show_mouse_cursor();
  1198.   }
  1199. }
  1200.  
  1201. /*--------------------------------------------------------------------------*/
  1202. /* display a text mode filled rectangle.                                    */
  1203. /*                               Parameters: xx1,yy1,xx2,yy2 -> coordinates */
  1204. /*                                           cm              -> color       */                                                                
  1205. /*--------------------------------------------------------------------------*/
  1206. void frect(int xx1,int yy1,int xx2,int yy2,int cm,int shadow)
  1207. {
  1208.  int x,y;
  1209.  int m;    
  1210.  
  1211.  if(initvar==0)
  1212.  {  cls();
  1213.     printf("\a \n Display borad not initialized");
  1214.     getch();
  1215.     exit(-1);
  1216.  }
  1217.  
  1218.  m=mouse_display;
  1219.  if(mouse_display==YES) 
  1220.  { hide_mouse_cursor();
  1221.  }
  1222.  
  1223.  for (y=yy1;y<yy2+1;y++)
  1224.  { for (x=xx1;x<xx2+1;x++)
  1225.    { writechar(x,y,back_block,cm);
  1226.    }    
  1227.  }        
  1228.  if(shadow!=0)
  1229.  { chcolor(xx1+2,yy2+1,xx2-xx1+1,1,shadow);
  1230.    chcolor(xx2+1,yy1+1,2,yy2-yy1,shadow);
  1231.  }
  1232.  if(m==YES)
  1233.  { show_mouse_cursor();
  1234.  }
  1235. }
  1236. /*--------------------------------------------------------------------------*/
  1237. /* return a key from the keyboard, if non return EOF                        */
  1238. /*--------------------------------------------------------------------------*/
  1239. int getkey(void)
  1240. {
  1241.  int key, lo, hi;
  1242.  if(!kbhit())return(EOF);
  1243.  key = bioskey(0);
  1244.  lo = key & 0X00FF;
  1245.  hi = (key & 0XFF00) >> 8;
  1246.  if(lo==0)return(hi+256);
  1247.  return(lo);
  1248.  
  1249. /*  return((lo == 0) ? hi + 256 : lo);  */
  1250. }
  1251. /*--------------------------------------------------------------------------*/
  1252. /* display a filled rectangle, while preserving the background.  The        */
  1253. /* background is saved in an allocated memory.  If malloc failes, this      */
  1254. /* routine will exit to dos.  
  1255. /* and remove the box.                                                      */
  1256. /*                      Parameters : x,y       -> coordinates of top left.  */
  1257. /*                                   xsize     -> size in x direction.      */
  1258. /*                                   ysize     -> size in y direction.      */
  1259. /*                                   backcolor -> color of the box.         */
  1260. /*                                   forcolor  -> border line color.        */
  1261. /*                                   sw        -> display or remove switch  */
  1262. /*                                                  sw=1 : draw the box     */
  1263. /*                                                  sw=0 : remove the last  */
  1264. /*                                                         draw box         */
  1265. /*                                   border    -> draw border on the box    */
  1266. /*--------------------------------------------------------------------------*/
  1267.  
  1268. int messagebox(x,y,xsize,ysize,color,shadow,sw,border)
  1269. int x;
  1270. int y;
  1271. int xsize;
  1272. int ysize;
  1273. int color;
  1274. int shadow;
  1275. int sw;
  1276. int border;
  1277. { 
  1278.   int i,j;
  1279.   unsigned char *temp;
  1280.   unsigned char far *scr_temp;
  1281.   int save_xsize;
  1282.   int save_ysize;
  1283.   int m;
  1284.  
  1285.  
  1286.  
  1287.   if(sw==-1)
  1288.   { box_num=0;
  1289.     return(-1);
  1290.   }   
  1291.  
  1292.   if(initvar==0)
  1293.   {  cls();
  1294.      printf("\a \n Display borad not initialized");
  1295.      getch();
  1296.      exit(-1);
  1297.   }
  1298.  
  1299.  if(shadow==0)
  1300.  { save_ysize=ysize;
  1301.    save_xsize=xsize;
  1302.  }
  1303.  else
  1304.  { save_ysize=ysize+1;
  1305.    save_xsize=xsize+2;
  1306.  }
  1307.  
  1308.  switch(sw)
  1309.  {
  1310.    case ON :
  1311.     m=mouse_display;
  1312.     if(mouse_display==YES) 
  1313.     { hide_mouse_cursor();
  1314.     }
  1315.  
  1316.     if(box_num==MAX_ENTRIES)
  1317.     { cls();
  1318.       printf("\n box_num has reached the maximum allowed submenu levels");
  1319.       printf("\n to increase the levels change MAX_WINDOWS in def.h    ");
  1320.       getch();
  1321.       exit(-1);
  1322.     }
  1323.     if( (save_box[box_num]=malloc(save_ysize*save_xsize*2))==NULL)
  1324.     { cls();
  1325.       printf("\n not enough memory for message box # %d",box_num);
  1326.       getch();
  1327.       exit(-1);
  1328.     }
  1329.  
  1330.     temp=save_box[box_num];
  1331.  
  1332.     for(i=y;i<y+save_ysize;i++)
  1333.     { 
  1334.       for(j=x;j<x+save_xsize;j++)
  1335.       { 
  1336.         *temp++=readchar(j,i);
  1337.         *temp++=readcolor(j,i);
  1338.       }
  1339.     }
  1340.     /*------------------------------*/
  1341.     /* text background is saved now */
  1342.     /*------------------------------*/
  1343.  
  1344.     /*------------------------------*/
  1345.     /* save graphics background now */
  1346.     /*------------------------------*/
  1347.  
  1348.     if(font_width>1)
  1349.     { /*
  1350.       if( (gsave_box[box_num]=malloc(save_ysize*save_xsize*font_width*font_height))==NULL)
  1351.       { cls();
  1352.         printf("\n not enough memory for graphics message box # %d",box_num);
  1353.         printf("\n tryed to allocate %u bytes",save_ysize*save_xsize*font_width*font_height);
  1354.         getch();
  1355.         exit(-1);
  1356.       }
  1357.       temp=gsave_box[box_num];
  1358.       */
  1359.     }
  1360.  
  1361.  
  1362.  
  1363.  
  1364.     frect(x,y,x+xsize-1,y+ysize-1,  color,shadow);
  1365.  
  1366.     if(border==YES)
  1367.     { rect(x,y,x+xsize-1,y+ysize-1,color);
  1368.     }
  1369.  
  1370.     xwin[box_num]=x;
  1371.     ywin[box_num]=y;
  1372.  
  1373.     xwinsize[box_num]=xsize;
  1374.     ywinsize[box_num]=ysize;
  1375.     
  1376.     wincolor[box_num]=color;
  1377.     winshadow[box_num]=shadow;
  1378.     winborder[box_num]=border;
  1379.  
  1380.     box_num++;
  1381.     break;
  1382.  
  1383.    case OFF :
  1384.     m=mouse_display;
  1385.     if(mouse_display==YES) 
  1386.     { hide_mouse_cursor();
  1387.     }
  1388.     box_num--;
  1389.     temp=save_box[box_num];
  1390.     for(i=y;i<y+save_ysize;i++)
  1391.     {  
  1392.        for(j=x;j<x+save_xsize;j++)
  1393.        { 
  1394.          writechar(j,i,*temp,*(temp+1) );
  1395.          temp+=2;
  1396.        }
  1397.     }
  1398.     free(save_box[box_num]);
  1399.     break;
  1400.  } /* end of the switch statement */
  1401.  if(m==YES)
  1402.  { show_mouse_cursor();
  1403.  }
  1404.  return(box_num-1);
  1405. }
  1406. /*--------------------------------------------------------------------------*/
  1407. /* change color of a rectangle without changing the characters.             */
  1408. /*--------------------------------------------------------------------------*/
  1409. void chcolor(x,y,xsize,ysize,color)
  1410. int x;
  1411. int y;
  1412. int xsize;
  1413. int ysize;
  1414. int color;
  1415. { int i;
  1416.   int j;
  1417.   int m;
  1418.   unsigned char far *scr_temp;
  1419.  
  1420.   m=mouse_display;
  1421.   if(mouse_display==YES) 
  1422.   { hide_mouse_cursor();
  1423.   }
  1424.  
  1425.   for(j=y;j<y+ysize;j++)
  1426.   { 
  1427.     for(i=x;i<x+xsize;i++)
  1428.     { writechar(i,j,readchar(i,j),color);
  1429.     }
  1430.   }
  1431.   if(m==YES)
  1432.   { show_mouse_cursor();
  1433.   }
  1434. }
  1435. /*--------------------------------------------------------------------------*/
  1436. /* Initialize the mouse driver                                              */
  1437. /*--------------------------------------------------------------------------*/
  1438. void init_mouse(void)
  1439. {
  1440.  int int_handler;
  1441.  long vector;
  1442.  unsigned char first_byte;
  1443.  
  1444.  
  1445.  int_handler=(int)getvect(0x33);
  1446.  first_byte=*(unsigned char far *)int_handler;
  1447.  vector = (long) int_handler;
  1448.  
  1449.  
  1450.  if((vector==0) || (first_byte==0xcf))
  1451.  { mousefound=NO;
  1452.    ms=RELEASED;
  1453.    return; /* mouse driver not found */
  1454.  }
  1455.  /* reset the mouse */
  1456.  iReg.x.ax=0;
  1457.  int86(0x33,&iReg,&oReg);
  1458.  mousefound=YES;
  1459.  if(mouse_left_pressed()==YES)
  1460.  { ms=PRESSED;
  1461.  }
  1462.  else
  1463.  { ms=RELEASED;
  1464.  }
  1465.  
  1466.  
  1467. }    /* end of set mouse */
  1468. /*--------------------------------------------------------------------------*/
  1469. /* Display the mouse cursor                                                 */
  1470. /*--------------------------------------------------------------------------*/
  1471. void show_mouse_cursor(void)
  1472. {
  1473.    if(mousefound==NO)return;
  1474.    iReg.x.ax=1;
  1475.    int86(0x33,&iReg,&oReg);
  1476.    mouse_display=YES;
  1477. }
  1478. /*--------------------------------------------------------------------------*/
  1479. /* Hide the mouse cursor                                                    */
  1480. /*--------------------------------------------------------------------------*/
  1481. void hide_mouse_cursor(void)
  1482. {  
  1483.    if(mousefound==NO)return;
  1484.    iReg.x.ax=2;
  1485.    int86(0x33,&iReg,&oReg);
  1486.    mouse_display=NO;
  1487. }
  1488. /*--------------------------------------------------------------------------*/
  1489. /* find the mouse location and assign it to mousex, and mousey.             */
  1490. /*--------------------------------------------------------------------------*/
  1491. void get_mouse_location(void)
  1492. {
  1493.   if(mousefound==NO)return;
  1494.   iReg.x.ax=3;
  1495.   int86(0x33,&iReg,&oReg);
  1496.   mousex=oReg.x.cx/8;
  1497.   mousey=oReg.x.dx/8;
  1498. }
  1499. /*--------------------------------------------------------------------------*/
  1500. /* return the state of the left mouse key  (YES) pressed     (NO) released  */
  1501. /*--------------------------------------------------------------------------*/
  1502. int mouse_left_pressed(void)
  1503. {
  1504.   if(mousefound==NO)return(NO);
  1505.   iReg.x.ax=3;
  1506.   int86(0x33,&iReg,&oReg);
  1507.   if(oReg.x.bx==1) return(YES);
  1508.   return(NO);
  1509. }
  1510. /*--------------------------------------------------------------------------*/
  1511. /* return the mouse state, and keep track of if mouse left key has been     */
  1512. /* pressed and released.                                                    */
  1513. /*--------------------------------------------------------------------------*/
  1514. int mouse_state(void)
  1515. {
  1516.   int a;
  1517.   a=mouse_left_pressed();
  1518.   if(a==YES)
  1519.   { ms=PRESSED;
  1520.     return(ms);
  1521.   }
  1522.   if(ms==PRESSED && a==NO)
  1523.   { ms=PRESSEDRELEASED;
  1524.     return(ms);
  1525.   }
  1526.   return(ms);
  1527. }
  1528. /*--------------------------------------------------------------------------*/
  1529. /* control the text cursor                                                  */
  1530. /*                 action :                                                 */
  1531. /*                             ON : turn on the text cursor                 */
  1532. /*                            OFF : turn off the text cursor                */
  1533. /*                          BLOCK : change the text cursor to a block       */
  1534. /*                         SQUARE : change the text cursor to a square      */
  1535. /*                           LINE : change the text cursor to a line        */
  1536. /*                       POSITION : set the text cursor location to         */
  1537. /*                                  txt_curs_x,txt_curs_y.                  */ 
  1538. /*--------------------------------------------------------------------------*/
  1539. void txt_curs(action)
  1540. int action;
  1541. {
  1542.   union REGS reg;
  1543.  
  1544.   return;
  1545.  
  1546.   switch(action)
  1547.   {
  1548.     case ON  :
  1549.      reg.h.ah=1;
  1550.      reg.h.ch=curs_start_line;
  1551.      reg.h.cl=curs_end_line;
  1552.      break;
  1553.     case OFF :
  1554.      reg.h.ah=1;
  1555.      reg.h.ch=1;
  1556.      reg.h.cl=0;
  1557.      break;
  1558.     case BLOCK :
  1559.      reg.h.ah=1;
  1560.      curs_start_line=0;
  1561.      curs_end_line=8;
  1562.      reg.h.ch=curs_start_line;
  1563.      reg.h.cl=curs_end_line;
  1564.      break;
  1565.     case SQUARE :
  1566.      reg.h.ah=1;
  1567.      curs_start_line=4;
  1568.      curs_end_line=8;
  1569.      reg.h.ch=curs_start_line;
  1570.      reg.h.cl=curs_end_line;
  1571.      break;
  1572.     case LINE  :
  1573.      reg.h.ah=1;
  1574.      curs_start_line=8;
  1575.      curs_end_line=8;
  1576.      reg.h.ch=curs_start_line;
  1577.      reg.h.cl=curs_end_line;
  1578.      break;
  1579.     case POSITION :
  1580.      reg.h.ah=2;
  1581.      reg.h.dh=txt_curs_y;
  1582.      reg.h.dl=txt_curs_x;
  1583.      reg.h.bh=0;
  1584.      break;
  1585.     default :
  1586.      return;
  1587.  
  1588.   }
  1589.  
  1590.   int86(0x10,®,®); 
  1591.  
  1592. }
  1593. /*--------------------------------------------------------------------------*/
  1594. /* clear the screen to black                                                */
  1595. /*--------------------------------------------------------------------------*/
  1596. void cls(void)
  1597. {
  1598.   if(initvar==0)
  1599.   {  system("CLS");
  1600.      printf("\a \n Display borad not initialized");
  1601.      getch();
  1602.      exit(-1);
  1603.   }
  1604.  
  1605.   frect(0,0,txt_scr_xsize-1,txt_scr_ysize-1,0x07,0);
  1606. }
  1607. /*--------------------------------------------------------------------------*/
  1608. /* return the state of the ALT key                                          */
  1609. /*--------------------------------------------------------------------------*/
  1610. int alt_pressed(void)
  1611. {
  1612.   if( (bioskey(2) & 0x08)!=0 ) return(YES);
  1613.   return(NO);
  1614. }
  1615. /*--------------------------------------------------------------------------*/
  1616. /* change the color of the menu.  Call this function before bar_menu(INIT)  */
  1617. /*--------------------------------------------------------------------------*/
  1618. void bg_menu_color(int color)
  1619. {
  1620.   menu_color&=0x0F;
  1621.   menu_color|=color;
  1622. }
  1623. void fg_menu_color(int color)
  1624. {
  1625.   menu_color&=0xF0;
  1626.   menu_color|=color;
  1627. }
  1628. /*--------------------------------------------------------------------------*/
  1629. /* change the color of the menu hotkeys.                                    */
  1630. /* Call this function before bar_menu(INIT)                                 */
  1631. /*--------------------------------------------------------------------------*/
  1632. void bg_menu_hotkey_color(int color)
  1633. {
  1634.   menu_hotkey_color&=0x0F;
  1635.   menu_hotkey_color|=color;
  1636. }
  1637. void fg_menu_hotkey_color(int color)
  1638. {
  1639.   menu_hotkey_color&=0xF0;
  1640.   menu_hotkey_color|=color;
  1641. }
  1642.  
  1643. /*--------------------------------------------------------------------------*/
  1644. /* change the color of the highlighted menu.                                */
  1645. /* Call this function before bar_menu(INIT)                                 */
  1646. /*--------------------------------------------------------------------------*/
  1647. void bg_menu_sel_color(int color)
  1648. {
  1649.   menu_sel_color&=0x0F;
  1650.   menu_sel_color|=color;
  1651. }
  1652. void fg_menu_sel_color(int color)
  1653. {
  1654.   menu_sel_color&=0xF0;
  1655.   menu_sel_color|=color;
  1656. }
  1657. /*--------------------------------------------------------------------------*/
  1658. /* change the color of the rectangle shadow.                                */
  1659. /* Call this function before bar_menu(INIT)                                 */
  1660. /*--------------------------------------------------------------------------*/
  1661. void bg_menu_shadow(int color)
  1662. {
  1663.   menu_shadow&=0x0F;
  1664.   menu_shadow|=color;
  1665. }
  1666. void fg_menu_shadow(int color)
  1667. {
  1668.   menu_shadow&=0x0F;
  1669.   menu_shadow|=color;
  1670. }
  1671. /*--------------------------------------------------------------------------*/
  1672. /* change the menu bar's x location.                                        */
  1673. /* Call this function before bar_menu(INIT)                                 */
  1674. /*--------------------------------------------------------------------------*/
  1675. void ch_menu_x(int x)
  1676. {
  1677.   menu_x=x;
  1678. }
  1679. /*--------------------------------------------------------------------------*/
  1680. /* change the menu bar's y location.                                        */
  1681. /* Call this function before bar_menu(INIT)                                 */
  1682. /*--------------------------------------------------------------------------*/
  1683. void ch_menu_y(int y)
  1684. {
  1685.   menu_y=y;
  1686. }
  1687. /*--------------------------------------------------------------------------*/
  1688. /* change the menu bar's x size.   .                                        */
  1689. /* Call this function before bar_menu(INIT)                                 */
  1690. /*--------------------------------------------------------------------------*/
  1691. void ch_menu_xsize(int xsize)
  1692. {
  1693.   menu_x_size=xsize;
  1694. }
  1695. /*--------------------------------------------------------------------------*/
  1696. /* set the menu file descriptor name                                        */
  1697. /* Call this function before bar_menu(INIT)                                 */
  1698. /*--------------------------------------------------------------------------*/
  1699. void ch_menu_filename(char *f)
  1700. {
  1701.   strcpy(menu_file,f);
  1702. }
  1703. /*--------------------------------------------------------------------------*/
  1704. /* return the next line from the menu descriptor                            */
  1705. /*--------------------------------------------------------------------------*/
  1706. int next_line(char *buffer,int buf_size)
  1707. {
  1708.   switch(menu_descriptor)
  1709.   { case TEXT_FILE :
  1710.      if(fgets(buffer,buf_size,fp)!=NULL)
  1711.      { strcpy(buffer,buffer+remove_spaces(buffer));
  1712.        return(0);
  1713.      }
  1714.      return(-1);
  1715.     case VARIABLE  :
  1716.      if(menu_line_ptr==menu_lines)
  1717.      { return(-1);
  1718.      }
  1719.      strcpy(buffer,*menu);
  1720.      menu++;
  1721.      menu_line_ptr++;
  1722.      break;
  1723.   }
  1724.   return(0);
  1725. }
  1726. /*--------------------------------------------------------------------------*/
  1727. /* set the position in the menu descriptor                                  */
  1728. /*--------------------------------------------------------------------------*/
  1729. void set_pos(long *l )
  1730. {
  1731.   switch(menu_descriptor)
  1732.   { case TEXT_FILE :
  1733.      fsetpos(fp,l);
  1734.      break;
  1735.     case VARIABLE :
  1736.      menu+=(int)(*l-(long)menu_line_ptr);
  1737.      menu_line_ptr=(int)*l;
  1738.      break;
  1739.   }
  1740. }
  1741. /*--------------------------------------------------------------------------*/
  1742. /* return the position in the menu descriptor                               */
  1743. /*--------------------------------------------------------------------------*/
  1744. long get_pos( void)
  1745. {
  1746.   switch(menu_descriptor)
  1747.   { case TEXT_FILE :
  1748.      return(ftell(fp));
  1749.     case VARIABLE :
  1750.      return((long)menu_line_ptr);
  1751.   }
  1752.   return(-1);
  1753. }
  1754. /*--------------------------------------------------------------------------*/
  1755. /* set the menu descriptor to TEXT_FILE, or VARIABLE                        */
  1756. /* when setting to VARIABLE, mv will be pointer to the menu descriptor,     */
  1757. /* and l is the number of lines in the descriptor                           */
  1758. /* when setting to TEXT_FILE, set mv to NULL, and l to 0                    */
  1759. /*--------------------------------------------------------------------------*/
  1760. void set_menu_descriptor(int md, char **mv,int l)
  1761. {
  1762.   if(md==TEXT_FILE)   /* default is set for text file */
  1763.   { menu_descriptor=TEXT_FILE;
  1764.     return;
  1765.   }
  1766.   menu_descriptor=VARIABLE;
  1767.   menu=mv;
  1768.   menu_lines=l;
  1769.   menu_line_ptr=0;
  1770. }
  1771. /*--------------------------------------------------------------------------*/
  1772. /* change the character used by frect to filled rectangle.  This character  */
  1773. /* by default is 32.                                                        */
  1774. /*--------------------------------------------------------------------------*/
  1775. void frect_char(unsigned char c)
  1776. {
  1777.   back_block=c;
  1778. }
  1779. /*--------------------------------------------------------------------------*/
  1780. /*--------------------------------------------------------------------------*/
  1781. /* display a field with the structure of field : all parameters must be     */
  1782. /* passed, the field routine will return with return keys of ESC            */
  1783. /*                                                           UPKEY          */
  1784. /*                                                           DOWNKEY        */
  1785. /*                                                           ENTER          */
  1786. /*                                                           TAB            */
  1787. /*                                                           SHIFTTAB       */
  1788. /*    struct field                                                          */
  1789. /*      { int  x;                   field's X coordinate                    */
  1790. /*        int  y;                   field's Y coordinate                    */ 
  1791. /*        int  length;              field length                            */
  1792. /*        char title[20];           title of the field                      */
  1793. /*        char f[80];               field content                           */
  1794. /*        int  fcolor;              field color                             */
  1795. /*        int  tcolor;              title color                             */
  1796. /*        int  xstart;              default x location for the cursor       */
  1797. /*                                  as character #,  first char=0           */
  1798. /*      };                                                                  */
  1799. /*                                                                          */
  1800. /*                                                                          */
  1801. /*    When returned, the variable f[80] and xstart are updated with the     */
  1802. /*    new content of the field, and xstart is set to the location of the    */
  1803. /*    cursor with respect to the first character.                           */
  1804. /*                                                                          */
  1805. /*    When the function is called, the addres of the structure must be      */
  1806. /*    passed.                                                               */
  1807. /*--------------------------------------------------------------------------*/
  1808. int  displayfield(field,action)
  1809. struct field *field;
  1810. int    action;
  1811. {
  1812.   int i;
  1813.   int ch;
  1814.   int xcurs;
  1815.  
  1816.   txt_curs(ON);
  1817.   hide_mouse_cursor();
  1818.   for (i=0;i<field->length;i++) 
  1819.                          writechar(field->x+i,field->y,' ',field->fcolor);
  1820.   pls (field->x,field->y,(unsigned char *)field->f,field->fcolor);
  1821.   pls (field->x,field->y-1,(unsigned char *)field->title,field->tcolor);
  1822.   if(action==INIT)return EOF;
  1823.  
  1824.   show_mouse_cursor();
  1825.   xcurs=field->x+field->xstart;
  1826.   txt_curs_x=xcurs;
  1827.   txt_curs_y=field->y;
  1828.   txt_curs(POSITION);
  1829.  
  1830.   while(1)
  1831.   { ch=getkey();
  1832.  
  1833.     if(mouse_state()==PRESSED)
  1834.     { get_mouse_location();
  1835.       if(mousey==field->y && mousex>=field->x && mousex<=field->x+field->length)
  1836.       { xcurs=mousex;
  1837.  
  1838.         txt_curs_x=xcurs;
  1839.         txt_curs_y=field->y;
  1840.         txt_curs(POSITION);
  1841.       }
  1842.       else
  1843.       { field->xstart=xcurs-field->x;
  1844.         strncpy(field->f,"",sizeof((unsigned char *)field->f) );  /* set all to \0 */
  1845.         txt_curs(OFF);
  1846.         for(i=0;i<field->length;i++)
  1847.         { field->f[i]=readchar(i+field->x,field->y);
  1848.         }
  1849.         return(EOF);
  1850.       }
  1851.     }
  1852.  
  1853.     if( (ch>=',' && ch<='~') || ch==' ') /* a valid character was pressed */
  1854.     { 
  1855.       /*-------------------------------------------------*/
  1856.       /* check the last character in the field; if it is */
  1857.       /* a space, shift all characters in between, else  */
  1858.       /* write over what is there                        */
  1859.       /*-------------------------------------------------*/
  1860.       i=readchar(field->x+field->length-1,field->y);
  1861.       if(i==' ')       /* shift characters to the right */
  1862.       { txt_curs(OFF);
  1863.         for(i=field->x+field->length-1;i!=xcurs; i--)
  1864.         { writechar(i,field->y,readchar(i-1,field->y),field->fcolor);
  1865.         }
  1866.         txt_curs(ON);
  1867.       }
  1868.       writechar(xcurs,field->y,ch,field->fcolor);
  1869.       if(xcurs!=field->x+field->length-1)xcurs++;
  1870.       txt_curs_x=xcurs;
  1871.       txt_curs_y=field->y;
  1872.       txt_curs(POSITION);
  1873.       continue;
  1874.     }
  1875.  
  1876.     switch(ch)
  1877.     { 
  1878.       case RIGHTKEY :
  1879.        if(xcurs!=field->x+field->length-1)xcurs++;
  1880.        else
  1881.        { field->xstart=xcurs-field->x;
  1882.          strncpy(field->f,"",sizeof((unsigned char *)field->f) );  /* set all to \0 */
  1883.          for(i=0;i<field->length;i++)
  1884.          { field->f[i]=readchar(field->x,field->y);
  1885.          }
  1886.          txt_curs(OFF);
  1887.          return(ch);
  1888.        }
  1889.        break;
  1890.       case LEFTKEY  :
  1891.        if(xcurs!=field->x)xcurs--;
  1892.        else
  1893.        { field->xstart=xcurs-field->x;
  1894.          strncpy(field->f,"",sizeof((unsigned char *)field->f) );  /* set all to \0 */
  1895.          for(i=0;i<field->length;i++)
  1896.          { field->f[i]=readchar(i+field->x,field->y);
  1897.          }
  1898.          txt_curs(OFF);
  1899.          return(ch);
  1900.        }
  1901.        break;
  1902.       case ESC      :
  1903.       case UPKEY    :
  1904.       case DOWNKEY  :
  1905.       case ENTER    :
  1906.       case TAB      :
  1907.       case SHIFTTAB :
  1908.        /*-------------------------------*/
  1909.        /* assign the current variables  */
  1910.        /*-------------------------------*/
  1911.        field->xstart=xcurs-field->x;
  1912.        strncpy(field->f,"",sizeof((unsigned char *)field->f) );  /* set all to \0 */
  1913.        for(i=0;i<field->length;i++)
  1914.        { field->f[i]=readchar(i+field->x,field->y);
  1915.        }
  1916.        txt_curs(OFF);
  1917.        return(ch);
  1918.       case DELKEY   :
  1919.        if(xcurs==field->x+field->length-1)
  1920.        { writechar(xcurs,field->y,' ',field->fcolor);
  1921.          break;
  1922.        }
  1923.        xcurs++;
  1924.        ch=BS;
  1925.       case BS       :
  1926.        if(xcurs==field->x)continue;
  1927.        txt_curs(OFF);
  1928.        for(i=xcurs-1;i<field->x+field->length;i++)
  1929.        { writechar(i,field->y,readchar(i+1,field->y),field->fcolor);
  1930.        }
  1931.        writechar(field->x+field->length-1,field->y,' ',field->fcolor);
  1932.        xcurs--;
  1933.        txt_curs(ON);
  1934.     }
  1935.     txt_curs_x=xcurs;
  1936.     txt_curs_y=field->y;
  1937.     txt_curs(POSITION);
  1938.   }
  1939. }
  1940. /*--------------------------------------------------------------------------*/
  1941. /* read a string in to the string variable from the screen                  */
  1942. /* string coordinate starts at x,y  and the size of the string is size      */
  1943. /*--------------------------------------------------------------------------*/
  1944. void readstring(x,y,size,string)
  1945. int  x;
  1946. int  y;
  1947. int  size;
  1948. char *string;
  1949. {
  1950.   int i;
  1951.   char c;
  1952.  
  1953.   for(i=x;i<x+size;i++)
  1954.   { c=readchar(i,y);
  1955.     string[i-x]=c;
  1956.   }               
  1957.   string[size]=0;
  1958. }
  1959. /*--------------------------------------------------------------------------*/
  1960. int set_video_mode(int v)
  1961. {
  1962.   union REGS reg;          
  1963.  
  1964.   reg.x.ax=v;
  1965.   int86(0x10,®,®);
  1966.  
  1967.   return  v;        
  1968. }
  1969. /*--------------------------------------------------------------------------*/
  1970. int get_video_mode(void)
  1971. {
  1972.   union REGS reg;          
  1973.  
  1974.   reg.h.ah=15;
  1975.  
  1976.   int86(0x10,®,®);
  1977.   return reg.h.al;
  1978.  
  1979. }
  1980. /*--------------------------------------------------------------------------*/
  1981.  
  1982.