home *** CD-ROM | disk | FTP | other *** search
/ Hot Shareware 35 / hot35.iso / ficheros / LC / SIMPWN93.ZIP / SIMPWIN.ZIP / SIMPWN92.C < prev    next >
C/C++ Source or Header  |  1997-09-17  |  29KB  |  1,412 lines
  1.  
  2. /* simpwin9 Copyright 1995 - 1997 Bruce R. O'Banion */
  3.  
  4. # include <string.h>
  5. # include <stdio.h>
  6. # include <conio.h>
  7. # include <process.h>
  8. # include <dos.h>
  9. # include <io.h>
  10. # include <stdarg.h>
  11. # include <mem.h>
  12. # include <sys\stat.h>
  13. # include <bios.h>
  14. # include <alloc.h>
  15. # include <stdlib.h>
  16. # include <dir.h>
  17. # include <ctype.h>
  18.  
  19. # include "skdef92.h"
  20. # include "simpwn92.h"
  21.  
  22. typedef struct
  23. {
  24.     int old[14];
  25.     int new[14];
  26. } WINDOW_DATA;
  27. struct text_info initial_info;
  28. WINDOW_DATA window_data,temp_data,window_temp;
  29. char path_name[255],screen_path[255];
  30. char far *video_buff;
  31. char far *buff_2;
  32. char far *screen_buff;
  33. FILE *t_fp;
  34. unsigned long int popups,screens;
  35. int dev_error;
  36. int mou_installed = 0;
  37. struct ffblk dir_data;
  38.  
  39.  
  40. int handler(int errval,int ax,int bp,int si);
  41. int error_write(FILE *err_fp);
  42. int save_window_data(int file);
  43. int load_window_data(int file);
  44.  
  45. int simp_window(int l,int t,int r,int b,int boarder,int shad,int forground,int background,int shade_locate,int shade_fore,int shade_back,int boarder_char,int fill_char)
  46. {
  47.     int i,j,col_start,col_end,tl,tr,bl,br,rt,cs,at,end_for,start_for;
  48.  
  49.  
  50.     window_data.new[0] = l;
  51.     window_data.new[1] = t;
  52.     window_data.new[2] = r;
  53.     window_data.new[3] = b;
  54.     window_data.new[4] = boarder;
  55.     window_data.new[5] = shad;
  56.     window_data.new[6] = forground;
  57.     window_data.new[7] = background;
  58.     window_data.new[8] = shade_locate;
  59.     window_data.new[9] = shade_fore;
  60.     window_data.new[10] = shade_back;
  61.     window_data.new[11] = boarder_char;
  62.     window_data.new[12] = fill_char;
  63.     window(l,t,r,b);
  64.     textattr(forground + (background<<4));
  65.     col_start = ((l - 1) * 2);
  66.     col_end = (r * 2);
  67.     end_for = col_end;
  68.     start_for = col_start;
  69.     at = (forground + (background<<4));
  70.     tr = 0x00;
  71.     tl = 0x00;
  72.     bl = 0x00;
  73.     br = 0x00;
  74.     rt = 0x00;
  75.     cs = 0x00;
  76.     if(boarder == 1)
  77.     {
  78.         tl = 0xda;
  79.         tr = 0xbf;
  80.         bl = 0xc0;
  81.         br = 0xd9;
  82.         rt = 0xc4;
  83.         cs = 0xb3;
  84.     }
  85.     if(boarder == 2)
  86.     {
  87.         tl = 0xc9;
  88.         tr = 0xbb;
  89.         bl = 0xc8;
  90.         br = 0xbc;
  91.         rt = 0xcd;
  92.         cs = 0xba;
  93.     }
  94.     if(boarder == 3)
  95.     {
  96.         tl = 0xd6;
  97.         tr = 0xb7;
  98.         bl = 0xd3;
  99.         br = 0xbd;
  100.         rt = 0xc4;
  101.         cs = 0xba;
  102.     }
  103.     if(boarder == 4)
  104.     {
  105.         tl = 0xd5;
  106.         tr = 0xb8;
  107.         bl = 0xd4;
  108.         br = 0xbe;
  109.         rt = 0xcd;
  110.         cs = 0xb3;
  111.     }
  112.     if(boarder == 5)
  113.     {
  114.         tl = boarder_char;
  115.         tr = boarder_char;
  116.         bl = boarder_char;
  117.         br = boarder_char;
  118.         rt = boarder_char;
  119.         cs = boarder_char;
  120.     }
  121.     if((shade_locate < 1) & (shade_locate > 4))
  122.     {
  123.         shade_locate = 1;
  124.     }
  125.     pokeb(0xb800,col_start + ((t - 1) * 160),tl);
  126.     pokeb(0xb800,col_start + 1 + ((t - 1) * 160),at);
  127.     for(i = col_start + 2;i < col_end - 2;i = i + 2)
  128.     {
  129.         pokeb(0xb800,i + ((t - 1) * 160),rt);
  130.         pokeb(0xb800,i + 1 + ((t - 1) * 160),at);
  131.     }
  132.     pokeb(0xb800,col_end - 2 + ((t - 1) * 160),tr);
  133.     pokeb(0xb800,col_end - 1 + ((t - 1) * 160),at);
  134.     pokeb(0xb800,col_start + ((b - 1) * 160),bl);
  135.     pokeb(0xb800,col_start + ((b - 1) * 160) + 1,at);
  136.     for(i = col_start + 2 + ((b - 1) * 160);i < col_end - 2 + ((b - 1) * 160);i = i + 2)
  137.     {
  138.         pokeb(0xb800,i,rt);
  139.         pokeb(0xb800,i + 1,at);
  140.     }
  141.     pokeb(0xb800,col_end - 2 + ((b - 1) * 160),br);
  142.     pokeb(0xb800,col_end - 1 + ((b - 1) * 160),at);
  143.     for(i = t;i < b - 1;i++)
  144.     {
  145.         pokeb(0xb800,col_start + (i * 160),cs);
  146.         pokeb(0xb800,col_end - 2 + (i * 160),cs);
  147.         pokeb(0xb800,col_start + 1 + (i * 160),at);
  148.         pokeb(0xb800,col_end - 1 + (i * 160),at);
  149.     }
  150.     for(i = t;i < (b - 1);i++)
  151.     {
  152.         for(j = col_start + 2;j < col_end - 2;j = j + 2)
  153.         {
  154.             pokeb(0xb800,j + (i * 160),fill_char);
  155.             pokeb(0xb800,j + 1 + (i * 160),at);
  156.         }
  157.     }
  158.     if((shad > 0) & (shad < 3))
  159.     {
  160.         if((shade_locate == 1) | (shade_locate == 2))
  161.         {
  162.             if(shad == 2)
  163.             {
  164.                 end_for = col_end + 2;
  165.             }
  166.         }
  167.         else
  168.         {
  169.             if(shad == 2)
  170.             {
  171.                 start_for = col_start - 2;
  172.             }
  173.         }
  174.         if((shade_locate == 1) | (shade_locate == 3))
  175.         {
  176.             for(i = t;i < b + 1;i++)
  177.             {
  178.                 if(shade_locate == 1)
  179.                 {
  180.                     if(shad == 1)
  181.                     {
  182.                         pokeb(0xb800,col_start - 3 + (i * 160),shade_fore + (shade_back<<4));
  183.                     }
  184.                     pokeb(0xb800,col_start - 1 + (i * 160),shade_fore + (shade_back<<4));
  185.                 }
  186.                 else
  187.                 {
  188.                     if(shad == 1)
  189.                     {
  190.                         pokeb(0xb800,col_end + 3 + (i * 160),shade_fore + (shade_back<<4));
  191.                     }
  192.                     pokeb(0xb800,col_end + 1 + (i * 160),shade_fore + (shade_back<<4));
  193.                 }
  194.             }
  195.             for(i = start_for;i < end_for - 4;i = i + 2)
  196.             {
  197.                 if(shade_locate == 1)
  198.                 {
  199.                     pokeb(0xb800,i + 1 + (b * 160),shade_fore + (shade_back<<4));
  200.                 }
  201.                 else
  202.                 {
  203.                     pokeb(0xb800,i + 5 + (b * 160),shade_fore + (shade_back<<4));
  204.                 }
  205.             }
  206.         }
  207.         if((shade_locate == 2) | (shade_locate == 4))
  208.         {
  209.             for(i = t - 2;i < b - 1;i++)
  210.             {
  211.                 if(shade_locate == 2)
  212.                 {
  213.                     if(shad == 1)
  214.                     {
  215.                         pokeb(0xb800,col_start - 3 + (i * 160),shade_fore + (shade_back<<4));
  216.                     }
  217.                     pokeb(0xb800,col_start - 1 + (i * 160),shade_fore + (shade_back<<4));
  218.                 }
  219.                 else
  220.                 {
  221.                     if(shad == 1)
  222.                     {
  223.                         pokeb(0xb800,col_end + 3 + (i * 160),shade_fore + (shade_back<<4));
  224.                     }
  225.                     pokeb(0xb800,col_end + 1 + (i * 160),shade_fore + (shade_back<<4));
  226.                 }
  227.             }
  228.             for(i = start_for;i < end_for - 4;i = i + 2)
  229.             {
  230.                 if(shade_locate == 2)
  231.                 {
  232.                     pokeb(0xb800,i + 1 + ((t - 2) * 160),shade_fore + (shade_back<<4));
  233.                 }
  234.                 else
  235.                 {
  236.                     pokeb(0xb800,i + 5 + ((t - 2) * 160),shade_fore + (shade_back<<4));
  237.                 }
  238.             }
  239.         }
  240.     }
  241.     return(0);
  242. }
  243.  
  244. int popup_window(int number,int l,int t,int r,int b,int boarder,int shad,int forground,int background,int shade_locate,int shade_fore,int shade_back,int boarder_char,int fill_char)
  245. {
  246.     int i;
  247.  
  248.     for(i = 0;i < 14;i++)
  249.     {
  250.         window_data.old[i] = window_data.new[i];
  251.     }
  252.     window_data.new[0] = l;
  253.     window_data.new[1] = t;
  254.     window_data.new[2] = r;
  255.     window_data.new[3] = b;
  256.     window_data.new[4] = boarder;
  257.     window_data.new[5] = shad;
  258.     window_data.new[6] = forground;
  259.     window_data.new[7] = background;
  260.     window_data.new[8] = shade_locate;
  261.     window_data.new[9] = shade_fore;
  262.     window_data.new[10] = shade_back;
  263.     window_data.new[11] = boarder_char;
  264.     window_data.new[12] = fill_char;
  265.     window_data.new[13] = number;
  266.     save_window_data(number);
  267.     simp_window(l,t,r,b,boarder,shad,forground,background,shade_locate,shade_fore,shade_back,boarder_char,fill_char);
  268.     return(0);
  269. }
  270.  
  271.  
  272. int unpopup_window(int number)
  273. {
  274.     int i;
  275.  
  276.     if(load_window_data(number) != 0)
  277.     {
  278.         return(1);
  279.     }
  280.     for(i = 0;i < 14;i++)
  281.     {
  282.         window_data.new[i] = window_data.old[i];
  283.     }
  284.     textattr(window_data.new[6] + (window_data.new[7]<<4));
  285.     window((window_data.new[0]),(window_data.new[1]),(window_data.new[2]),(window_data.new[3]));
  286.     return(0);
  287. }
  288.  
  289. int init_window(int num_popup,int screen_num,char *drive)
  290. {
  291.     unsigned long int size_block = 4056,free_space,convert = 1.0,num_file;
  292.     struct dfree space;
  293.     int i,drive_num,handle;
  294.     FILE init_fp;
  295.     char cur_dir[80];
  296.     char *buff;
  297.  
  298.     if((buff = (char*)malloc(4096)) == NULL)
  299.     {
  300.         return(1);
  301.     }
  302.     memset(buff,0,4096);
  303.     harderr(handler);
  304.     video_buff = MK_FP(0xb800,0x0000);
  305.     screen_buff = MK_FP(0xb900,0x0000);
  306.     buff_2 = MK_FP(0xba00,0x0000);
  307.     t_fp = &init_fp;
  308.     popups = num_popup + 1;
  309.     screens = screen_num + 1;
  310.     num_file = popups + screens;
  311.  
  312.     switch(drive[0])
  313.     {
  314.         case 'a' :
  315.         case 'A' : drive_num = 1; break;
  316.         case 'b' :
  317.         case 'B' : drive_num = 2; break;
  318.         case 'c' :
  319.         case 'C' : drive_num = 3; break;
  320.         case 'd' :
  321.         case 'D' : drive_num = 4; break;
  322.         case 'e' :
  323.         case 'E' : drive_num = 5; break;
  324.         case 'f' :
  325.         case 'F' : drive_num = 6; break;
  326.         case 'g' :
  327.         case 'G' : drive_num = 7; break;
  328.         default : drive_num = getdisk() + 1; break;
  329.     }
  330.     getdfree(drive_num,&space);
  331.     free_space = convert * space.df_avail * space.df_bsec * space.df_sclus / size_block;
  332.     if(num_file > free_space)
  333.     {
  334.         free(buff);
  335.         return(1);
  336.     }
  337.     strupr(drive);
  338.     if((strcmp(drive,"G") <= 0) & (strcmp(drive,"A") >= 0) & (getdisk() + 1 != drive_num))
  339.     {
  340.         strcat(drive,":");
  341.         strcpy(path_name,drive);
  342.         strcpy(screen_path,drive);
  343.     }
  344.     else
  345.     {
  346.         getcwd(cur_dir,79);
  347.         i = strlen(cur_dir);
  348.         if(cur_dir[i - 1] == '\\')
  349.         {
  350.             cur_dir[i - 1] = '';
  351.         }
  352.         strcpy(path_name,cur_dir);
  353.         strcpy(screen_path,cur_dir);
  354.     }
  355.     strcat(path_name,"\\win.dat");
  356.     strcat(screen_path,"\\screen.dat");
  357.     handle = creat(path_name,S_IREAD|S_IWRITE);
  358.     close(handle);
  359.     if((t_fp = fopen(path_name,"r+b")) == NULL)
  360.     {
  361.         free(buff);
  362.         return(1);
  363.     }
  364.     for(i = 0;i <= num_popup;i++)
  365.     {
  366.         if(fwrite(buff,sizeof(char) * 4056,1,t_fp) != 1)
  367.         {
  368.             fclose(t_fp);
  369.             free(buff);
  370.             return(1);
  371.         }
  372.     }
  373.  
  374.     fclose(t_fp);
  375.     handle = creat(screen_path,S_IREAD|S_IWRITE);
  376.     close(handle);
  377.     if((t_fp = fopen(screen_path,"r+b")) == NULL)
  378.     {
  379.         free(buff);
  380.         return(1);
  381.     }
  382.     for(i = 0;i <= screen_num;i++)
  383.     {
  384.         if(fwrite(buff,sizeof(char) * 4056,1,t_fp) != 1)
  385.         {
  386.             fclose(t_fp);
  387.             free(buff);
  388.             return(1);
  389.         }
  390.     }
  391.     fclose(t_fp);
  392.     free(buff);
  393.     return(0);
  394. }
  395.  
  396. void uninit_window()
  397. {
  398.     remove(path_name);
  399.     remove(screen_path);
  400. }
  401.  
  402. int load_window_data(int file)
  403. {
  404.     unsigned long int block = 4056;
  405.     int i;
  406.  
  407.     if(read_file(video_buff,path_name,4056,block * file) != 0)
  408.     {
  409.         return(1);
  410.     }
  411.     for(i = 0;i < 14;i++)
  412.     {
  413.         window_data.new[i] = peek(0xb800,4001 + (i * 2));
  414.         window_data.old[i] = peek(0xb800,4027 + (i * 2));
  415.     }
  416.     return(0);
  417. }
  418.  
  419. int save_window_data(int file)
  420. {
  421.     unsigned long int block = 4056;
  422.     int i;
  423.  
  424.     for(i = 0;i < 14;i++)
  425.     {
  426.         poke(0xb800,4001 + (i * 2),window_data.new[i]);
  427.         poke(0xb800,4027 + (i * 2),window_data.old[i]);
  428.     }
  429.     if(write_file(video_buff,path_name,4056,block * file) != 0)
  430.     {
  431.         return(1);
  432.     }
  433.     return(0);
  434. }
  435.  
  436. int write_window(int x,int y,char *format,...)
  437. {
  438.     va_list ap;
  439.     char * buff;
  440.  
  441.     if((buff = (char*)malloc(81)) == NULL)
  442.     {
  443.         return(1);
  444.     }
  445.     memset(buff,0,81);
  446.     va_start(ap,format);
  447.     vsprintf(buff,format,ap);
  448.     va_end(ap);
  449.     gotoxy(x,y);
  450.     cprintf("%s",buff);
  451.     free(buff);
  452.     return(0);
  453. }
  454.  
  455. int clear_window(int fill_char)
  456. {
  457.     int i,j,addr;
  458.  
  459.     gettextinfo(&initial_info);
  460.     for(i = initial_info.wintop;i < initial_info.winbottom - 1;i++)
  461.     {
  462.         for(j = initial_info.winleft;j < initial_info.winright - 1;j++)
  463.         {
  464.             addr = (i * 160) + (j * 2);
  465.             pokeb(0xb800,addr,fill_char);
  466.             pokeb(0xb800,addr + 1,window_data.new[6] + (window_data.new[7]<<4));
  467.         }
  468.     }
  469.     return(0);
  470. }
  471.  
  472. int save_screen(int screen_num)
  473. {
  474.     unsigned long int block;
  475.  
  476.     if(screen_num == 0)
  477.     {
  478.         movedata(0xb800,0x0000,0xb900,0x0000,4000);
  479.         window_temp = window_data;
  480.     }
  481.     else
  482.     {
  483.         block = 4000 + sizeof(WINDOW_DATA);
  484.         if(write_file(video_buff,screen_path,4000,block * screen_num) != 0)
  485.         {
  486.             return(1);
  487.         }
  488.         if(write_file(&window_data,screen_path,sizeof(WINDOW_DATA),(block * screen_num) + 4000) != 0)
  489.         {
  490.             return(1);
  491.         }
  492.     }
  493.     return(0);
  494. }
  495.  
  496. int load_screen(int screen_num)
  497. {
  498.     unsigned long int block;
  499.  
  500.     if(screen_num == 0)
  501.     {
  502.         movedata(0xb900,0x0000,0xb800,0x0000,4000);
  503.         window_data = window_temp;
  504.         textattr(window_data.new[6] + (window_data.new[7]<<4));
  505.         window(window_data.new[0],window_data.new[1],window_data.new[2],window_data.new[3]);
  506.     }
  507.     else
  508.     {
  509.         block = 4000 + sizeof(WINDOW_DATA);
  510.         if(read_file(video_buff,screen_path,4000,block * screen_num) != 0)
  511.         {
  512.             return(1);
  513.         }
  514.         if(read_file(&window_data,screen_path,sizeof(WINDOW_DATA),(block * screen_num) + 4000) != 0)
  515.         {
  516.             return(1);
  517.         }
  518.         textattr(window_data.new[6] + (window_data.new[7]<<4));
  519.         window(window_data.new[0],window_data.new[1],window_data.new[2],window_data.new[3]);
  520.     }
  521.     return(0);
  522. }
  523. int get_string(char *enter_string,char *mask,char *format,int x,int y,int strip,int default_dis)
  524. {
  525.     int enter_data[81],i = 0,erase = 0,mask_on = 0,j,temp_data = 0,valid_key;
  526.     int size_data,temp_i,search,first_key,bios_pick;
  527.     char temp_string[81];
  528.     char temp_char[2];
  529.  
  530.     for(i = 0;i < strlen(format);i++)
  531.     {
  532.         switch(format[i])
  533.         {
  534.             case 'A' : break;
  535.             case '*' : break;
  536.             case 'U' : break;
  537.             case 'u' : break;
  538.             case 'L' : break;
  539.             case 'l' : break;
  540.             case 'F' : break;
  541.             case 'e' : break;
  542.             case '#' : break;
  543.             case '9' : break;
  544.             case 'h' : break;
  545.             case 'o' : break;
  546.             case 'Y' : break;
  547.             case 'T' : break;
  548.             case ' ' : break;
  549.         }
  550.     }
  551.     size_data = strlen(mask);
  552.     for(i = 0;i < 81;i++)
  553.     {
  554.         enter_data[i] = 0;
  555.     }
  556.     strcpy(temp_char,"");
  557.     strcpy(temp_string,"");
  558.     for(i = 0;i < size_data;i++)
  559.     {
  560.         if(format[i] == ' ')
  561.         {
  562.             mask_on = 1;
  563.         }
  564.     }
  565.     if((default_dis == 1) & (strlen(enter_string) <= size_data))
  566.     {
  567.         gotoxy(x,y);
  568.         cprintf("%s",enter_string);
  569.     }
  570.     else if(mask_on == 1)
  571.     {
  572.         gotoxy(x,y);
  573.         cprintf("%s",mask);
  574.     }
  575.     else
  576.     {
  577.         default_dis = 0;
  578.     }
  579.     first_key = 1;
  580.     for(i = 0;i < size_data + 1;i++)
  581.     {
  582.         if(i < 0)
  583.         {
  584.             gotoxy(x,y);
  585.             putch(0x00);
  586.             i = 0;
  587.         }
  588.         temp_i = i;
  589.         if(i < size_data)
  590.         {
  591.             search = 1;
  592.             while(format[i] == ' ')
  593.             {
  594.                 if(erase != 1)
  595.                 {
  596.                     i = i + 1;
  597.                     temp_i = temp_i + 1;
  598.                 }
  599.                 else if(i != 0)
  600.                 {
  601.                     if(search == 1)
  602.                     {
  603.                         i = i - 1;
  604.                         temp_i = temp_i - 1;
  605.                     }
  606.                     else
  607.                     {
  608.                         i = i + 1;
  609.                         temp_i = temp_i + 1;
  610.                     }
  611.                 }
  612.                 else
  613.                 {
  614.                     i = 1;
  615.                     temp_i = 1;
  616.                     search = 0;
  617.                 }
  618.                 if(i == size_data)
  619.                 {
  620.                     break;
  621.                 }
  622.             }
  623.             if(i == size_data)
  624.             {
  625.                 i = i - 1;
  626.                 search = 3;
  627.                 while(format[i] == ' ')
  628.                 {
  629.                     i = i - 1;
  630.                 }
  631.                 temp_i = i + 1;
  632.             }
  633.             if(erase == 1)
  634.             {
  635.                 gotoxy(x + i,y);
  636.                 enter_data[i] = 0x00;
  637.                 putch(0x00);
  638.             }
  639.         }
  640.         erase = 0;
  641.         if(i <= size_data)
  642.         {
  643.             if((first_key == 1) & (default_dis == 1))
  644.             {
  645.                 i = strlen(enter_string);
  646.                 temp_i = i;
  647.                 for(j = 0;j < i;j++)
  648.                 {
  649.                     memmove(&enter_data[j],&enter_string[j],1);
  650.                 }
  651.             }
  652.             if(i == size_data)
  653.             {
  654.                 i = i - 1;
  655.             }
  656.             gotoxy(x + i,y);
  657.             bios_pick = bioskey(0);
  658.             memmove(&temp_data,&bios_pick,1);
  659.             if((temp_data != 13) & (temp_data != 8) & (first_key == 1))
  660.             {
  661.                 i = 0;
  662.                 temp_i = i;
  663.                 for(j = i;j < size_data;j++)
  664.                 {
  665.                     gotoxy(x + j,y);
  666.                     putch(0x00);
  667.                     enter_data[j] = 0;
  668.                 }
  669.                 if(mask_on == 1)
  670.                 {
  671.                     gotoxy(x,y);
  672.                     cprintf("%s",mask);
  673.                 }
  674.             }
  675.             first_key = 0;
  676.             valid_key = 1;
  677.             switch(format[i])
  678.             {
  679.                 case 'A' :
  680.                 case 'u' :
  681.                 case 'l' : if((format[i] == 'u') & (temp_data > 96) & (temp_data < 123))
  682.                                 {
  683.                         temp_data = temp_data - 32;
  684.                                 }
  685.                                 if((format[i] == 'l') & (temp_data > 64) & (temp_data < 91))
  686.                                 {
  687.                         temp_data = temp_data + 32;
  688.                                 }
  689.                                 if(isalnum(temp_data) == 0)
  690.                                 {
  691.                         switch(temp_data)
  692.                         {
  693.                             case 27 : i = 100; break;
  694.                             case 32 : break;
  695.                             case 13 : i = 100; break;
  696.                             case 8 : erase = 1;
  697.                                     valid_key = 0; break;
  698.                             default : erase = 2;
  699.                                         valid_key = 0; break;
  700.                         }
  701.                                 }
  702.                                 break;
  703.                 case 'U' : if(isupper(temp_data) == 0)
  704.                                 {
  705.                         switch(temp_data)
  706.                         {
  707.                             case 27 : i = 100; break;
  708.                             case 13 : i = 100; break;
  709.                             case 8 : erase = 1;
  710.                                     valid_key = 0; break;
  711.                             default : erase = 2;
  712.                                         valid_key = 0; break;
  713.                         }
  714.                                 }
  715.                                 break;
  716.                 case 'L' : if(islower(temp_data) == 0)
  717.                                 {
  718.                         switch(temp_data)
  719.                         {
  720.                             case 27 : i = 100; break;
  721.                             case 13 : i = 100; break;
  722.                             case 8 : erase = 1;
  723.                                     valid_key = 0; break;
  724.                             default : erase = 2;
  725.                                         valid_key = 0; break;
  726.                         }
  727.                                 }
  728.                                 break;
  729.                 case 'e' : if(isdigit(temp_data) == 0)
  730.                                 {
  731.                         switch(temp_data)
  732.                         {
  733.                             case 43 : break;
  734.                             case 45 : break;
  735.                             case 46 : break;
  736.                             case 69 : break;
  737.                             case 101 : break;
  738.                             case 13 : i = 100; break;
  739.                             case 27 : i = 100; break;
  740.                             case 8 : erase = 1;
  741.                                     valid_key = 0; break;
  742.                             default : erase = 2;
  743.                                         valid_key = 0; break;
  744.                         }
  745.                                 }
  746.                                 break;
  747.                 case '9' : if(isdigit(temp_data) == 0)
  748.                                 {
  749.                         switch(temp_data)
  750.                         {
  751.                             case 13 : i = 100; break;
  752.                             case 27 : i = 100; break;
  753.                             case 8 : erase = 1;
  754.                                     valid_key = 0; break;
  755.                             default : erase = 2;
  756.                                         valid_key = 0; break;
  757.                         }
  758.                                 }
  759.                                 break;
  760.                 case 'F' : if(isdigit(temp_data) == 0)
  761.                                 {
  762.                         switch(temp_data)
  763.                         {
  764.                             case 45 : break;
  765.                             case 46 : break;
  766.                             case 13 : i = 100; break;
  767.                             case 27 : i = 100; break;
  768.                             case 8 : erase = 1;
  769.                                     valid_key = 0; break;
  770.                             default : erase = 2;
  771.                                         valid_key = 0; break;
  772.                         }
  773.                                 }
  774.                                 break;
  775.                 case '#' : if(isdigit(temp_data) == 0)
  776.                                 {
  777.                         switch(temp_data)
  778.                         {
  779.                             case 45 : break;
  780.                             case 13 : i = 100; break;
  781.                             case 27 : i = 100; break;
  782.                             case 8 : erase = 1;
  783.                                     valid_key = 0; break;
  784.                             default : erase = 2;
  785.                                         valid_key = 0; break;
  786.                         }
  787.                                 }
  788.                                 break;
  789.                 case 'o' : if((isdigit(temp_data)) & (temp_data != 56) &
  790.                         (temp_data != 57))
  791.                                 {
  792.                         switch(temp_data)
  793.                         {
  794.                             case 45 : break;
  795.                             case 13 : i = 100; break;
  796.                             case 27 : i = 100; break;
  797.                             case 8 : erase = 1;
  798.                                     valid_key = 0; break;
  799.                             default : erase = 2;
  800.                                         valid_key = 0; break;
  801.                         }
  802.                                 }
  803.                                 break;
  804.                 case 'h' : if(isxdigit(temp_data) == 0)
  805.                                 {
  806.                         switch(temp_data)
  807.                         {
  808.                             case 45 : break;
  809.                             case 13 : i = 100; break;
  810.                             case 27 : i = 100; break;
  811.                             case 8 : erase = 1;
  812.                                     valid_key = 0; break;
  813.                             default : erase = 2;
  814.                                         valid_key = 0; break;
  815.                         }
  816.                                 }
  817.                                 break;
  818.                 case 'Y' : switch(temp_data)
  819.                                 {
  820.                         case 89 : break;
  821.                         case 78 : break;
  822.                         case 121 : break;
  823.                         case 110 : break;
  824.                         case 13 : i = 100; break;
  825.                         case 27 : i = 100; break;
  826.                         case 8 : erase = 1;
  827.                                 valid_key = 0; break;
  828.                         default : erase = 2;
  829.                                     valid_key = 0; break;
  830.                                 }
  831.                                 break;
  832.                 case 'T' : switch(temp_data)
  833.                                 {
  834.                         case 70 : break;
  835.                         case 84 : break;
  836.                         case 102 : break;
  837.                         case 116 : break;
  838.                         case 13 : i = 100; break;
  839.                         case 27 : i = 100; break;
  840.                         case 8 : erase = 1;
  841.                                 valid_key = 0; break;
  842.                         default : erase = 2;
  843.                                     valid_key = 0; break;
  844.                                 }
  845.                                 break;
  846.                 case '*' : if((temp_data < 35) | (temp_data > 125))
  847.                                 {
  848.                         switch(temp_data)
  849.                         {
  850.                             case 32 : break;
  851.                             case 33 : break;
  852.                             case 13 : i = 100; break;
  853.                             case 27 : i = 100; break;
  854.                             case 8 : erase = 1;
  855.                                     valid_key = 0; break;
  856.                             default : erase = 2;
  857.                                         valid_key = 0; break;
  858.                         }
  859.                                 }
  860.                                 break;
  861.                 default : if(temp_data == 13)
  862.                             {
  863.                         i = 100;
  864.                             }
  865.                             else if(temp_data == 8)
  866.                             {
  867.                         erase = 1;
  868.                         valid_key = 0;
  869.                             }
  870.             }
  871.         }
  872.         if(i != 100)
  873.         {
  874.             i = temp_i;
  875.         }
  876.         else
  877.         {
  878.             if(search == 3)
  879.             {
  880.                 enter_data[size_data] = temp_data;
  881.             }
  882.             else
  883.             {
  884.                 enter_data[temp_i] = temp_data;
  885.             }
  886.             valid_key = 2;
  887.         }
  888.         if(valid_key == 1)
  889.         {
  890.             if((temp_i < size_data) & (search != 3))
  891.             {
  892.                 gotoxy(x + temp_i,y);
  893.                 putch(temp_data);
  894.                 enter_data[temp_i] = temp_data;
  895.             }
  896.             if((temp_i == size_data) | (search == 3))
  897.             {
  898.                 gotoxy(x + temp_i - 1,y);
  899.                 putch(temp_data);
  900.                 enter_data[temp_i - 1] = temp_data;
  901.                 i = i - 1;
  902.             }
  903.             valid_key = 0;
  904.         }
  905.         if(erase == 1)
  906.         {
  907.             if(mask_on == 0)
  908.             {
  909.                 gotoxy(x + i - 1,y);
  910.                 enter_data[i - 1] = 0x00;
  911.                 putch(0x00);
  912.                 gotoxy(x + i,y);
  913.                 enter_data[i] = 0x00;
  914.                 putch(0x00);
  915.             }
  916.             else
  917.             {
  918.                 gotoxy(x + i,y);
  919.                 enter_data[i] = 0x00;
  920.                 putch(0x00);
  921.             }
  922.             i = i - 2;
  923.         }
  924.         if(erase == 2)
  925.         {
  926.             i = i - 1;
  927.         }
  928.     }
  929.     if(enter_data[0] == 13)
  930.     {
  931.         gotoxy(x,y);
  932.         cprintf("%s",enter_string);
  933.         return(0);
  934.     }
  935.     i = 0;
  936.     while((enter_data[i] != 13) & (enter_data[i] != 27))
  937.     {
  938.         if(i < size_data)
  939.         {
  940.             if(strip == 1)
  941.             {
  942.                 if(format[i] == ' ')
  943.                 {
  944.                     i = i + 1;
  945.                 }
  946.             }
  947.             else
  948.             {
  949.                 if(format[i] == ' ')
  950.                 {
  951.                     temp_char[0] = mask[i];
  952.                     temp_char[1] = NULL;
  953.                     strcat(temp_string,temp_char);
  954.                     i = i + 1;
  955.                 }
  956.             }
  957.             if((format[i] != ' ') & (i < size_data))
  958.             {
  959.                 if((enter_data[i] > 31) & (enter_data[i] < 127))
  960.                 {
  961.                     temp_char[0] = enter_data[i];
  962.                     temp_char[1] = NULL;
  963.                     strcat(temp_string,temp_char);
  964.                 }
  965.                 i = i + 1;
  966.             }
  967.         }
  968.     }
  969.     if(enter_data[i] == 27)
  970.     {
  971.         return(1);
  972.     }
  973.     if(temp_string[0] != NULL)
  974.     {
  975.         strcpy(enter_string,temp_string);
  976.     }
  977.     return(0);
  978. }
  979.  
  980. void show_cursor(void)
  981. {
  982.     _CH = 0x06;
  983.     _CL = 0x07;
  984.     _AH = 0x01;
  985.     geninterrupt(0x10);
  986. }
  987.  
  988. void hide_cursor(void)
  989. {
  990.     _CH = 0x10;
  991.     _CL = 0x00;
  992.     _AH = 0x01;
  993.     geninterrupt(0x10);
  994. }
  995.  
  996. int read_text(char *file_name,int wrap)
  997. {
  998.     int i,done = 0,error_check,x = 3,y = 2,page = 1,eof,block = 2000,set = 0;
  999.     long int start_byte = 0L;
  1000.  
  1001.     gettextinfo(&initial_info);
  1002.     eof = 0;
  1003.     while(done == 0)
  1004.     {
  1005.         if(page != 0)
  1006.         {
  1007.             clear_window(0);
  1008.             for(i = 0;i < 2000;i++)
  1009.             {
  1010.                 pokeb(0xba00,i,0x00);
  1011.             }
  1012.             error_check = read_file(buff_2,file_name,2000,start_byte);
  1013.             switch(error_check)
  1014.             {
  1015.                 case 0 : eof = 0; break;
  1016.                 case -1 : eof = 1; break;
  1017.                 default : return(error_check);
  1018.             }
  1019.             if(page == 1)
  1020.             {
  1021.                 for(i = set;i < 2000;i++)
  1022.                 {
  1023.                     if(peekb(0xba00,i) == 0x09)
  1024.                     {
  1025.                         pokeb(0xba00,i,0x20);
  1026.                     }
  1027.                     if(wrap == 1)
  1028.                     {
  1029.                         if(peekb(0xba00,i) != '\r')
  1030.                         {
  1031.                             if(peekb(0xba00,i) == '')
  1032.                             {
  1033.                                 break;
  1034.                             }
  1035.                             else
  1036.                             {
  1037.                                 if(((x + initial_info.winleft) < (initial_info.winright)) &
  1038.                                     ((y + initial_info.wintop) < (initial_info.winbottom + 1)))
  1039.                                 {
  1040.                                     if(peekb(0xba00,i) == '\n')
  1041.                                     {
  1042.                                         x = 3;
  1043.                                         y++;
  1044.                                     }
  1045.                                     else
  1046.                                     {
  1047.                                         gotoxy(x,y);
  1048.                                         putch(peekb(0xba00,i));
  1049.                                         x++;
  1050.                                     }
  1051.                                 }
  1052.                                 else
  1053.                                 {
  1054.                                     if((x + initial_info.winleft) > (initial_info.winright - 1))
  1055.                                     {
  1056.                                         i--;
  1057.                                         x = 3;
  1058.                                         y++;
  1059.                                     }
  1060.                                     else
  1061.                                     {
  1062.                                         if((y + initial_info.wintop) > (initial_info.winbottom))
  1063.                                         {
  1064.                                             eof = 0;
  1065.                                             break;
  1066.                                         }
  1067.                                     }
  1068.                                 }
  1069.                             }
  1070.                         }
  1071.                     }
  1072.                     else
  1073.                     {
  1074.                         if(peekb(0xba00,i) != '\r')
  1075.                         {
  1076.                             if(peekb(0xba00,i) == '')
  1077.                             {
  1078.                                 break;
  1079.                             }
  1080.                             if(((x + initial_info.winleft) < (initial_info.winright)) &
  1081.                                 ((y + initial_info.wintop) < (initial_info.winbottom + 1)))
  1082.                             {
  1083.                                 if(peekb(0xba00,i) == '\n')
  1084.                                 {
  1085.                                     x = 3;
  1086.                                     y++;
  1087.                                 }
  1088.                                 else
  1089.                                 {
  1090.                                     gotoxy(x,y);
  1091.                                     putch(peekb(0xba00,i));
  1092.                                     x++;
  1093.                                 }
  1094.                             }
  1095.                             else
  1096.                             {
  1097.                                 if((x + initial_info.winleft) > (initial_info.winright - 1))
  1098.                                 {
  1099.                                     if(peekb(0xba00,i) == '\n')
  1100.                                     {
  1101.                                         x = 3;
  1102.                                         y++;
  1103.                                     }
  1104.                                 }
  1105.                                 else
  1106.                                 {
  1107.                                     if((y + initial_info.wintop) > (initial_info.winbottom))
  1108.                                     {
  1109.                                         eof = 0;
  1110.                                         break;
  1111.                                     }
  1112.                                 }
  1113.                             }
  1114.                         }
  1115.                     }
  1116.                 }
  1117.                 page = 0;
  1118.             }
  1119.             else
  1120.             {
  1121.                 if(wrap == 0)
  1122.                 {
  1123.                     block--;
  1124.                 }
  1125.                 for(i = block - 1;i > -1;i--)
  1126.                 {
  1127.                     if(peekb(0xba00,i) == 0x09)
  1128.                     {
  1129.                         pokeb(0xba00,i,0x20);
  1130.                     }
  1131.                     if(wrap == 1)
  1132.                     {
  1133.                         if(peekb(0xba00,i) != '\r')
  1134.                         {
  1135.                             if(((x - initial_info.winleft) > 1) &
  1136.                                 ((y - initial_info.wintop) > 0))
  1137.                             {
  1138.                                 if(peekb(0xba00,i) == '\n')
  1139.                                 {
  1140.                                     x = initial_info.winright - 2;
  1141.                                     y--;
  1142.                                 }
  1143.                                 else
  1144.                                 {
  1145.                                     x--;
  1146.                                 }
  1147.                             }
  1148.                             else
  1149.                             {
  1150.                                 if((x - initial_info.winleft) < 2)
  1151.                                 {
  1152.                                     x = initial_info.winright - 2;
  1153.                                     y--;
  1154.                                     i++;
  1155.                                 }
  1156.                                 else
  1157.                                 {
  1158.                                     if((y - initial_info.wintop) < 1)
  1159.                                     {
  1160.                                         break;
  1161.                                     }
  1162.                                 }
  1163.                             }
  1164.                         }
  1165.                     }
  1166.                     else
  1167.                     {
  1168.                         if(peekb(0xba00,i) != 'r')
  1169.                         {
  1170.                             if(((x - initial_info.winleft) > 1) &
  1171.                                 ((y - initial_info.wintop) > 0))
  1172.                             {
  1173.                                 if(peekb(0xba00,i) == '\n')
  1174.                                 {
  1175.                                     y--;
  1176.                                     x = initial_info.winright - 2;
  1177.                                 }
  1178.                                 else
  1179.                                 {
  1180.                                     x--;
  1181.                                 }
  1182.                             }
  1183.                             else
  1184.                             {
  1185.                                 if((peekb(0xba00,i) == '\n') & ((x - initial_info.winleft) < 2))
  1186.                                 {
  1187.                                     y--;
  1188.                                     x = initial_info.winright - 2;
  1189.                                 }
  1190.                                 else
  1191.                                 {
  1192.                                     if((y - initial_info.wintop) < 1)
  1193.                                     {
  1194.                                         break;
  1195.                                     }
  1196.                                 }
  1197.                             }
  1198.                         }
  1199.                     }
  1200.                 }
  1201.                 block = 2000;
  1202.                 start_byte = start_byte + i + 1;
  1203.                 page = 1;
  1204.                 if(wrap == 0)
  1205.                 {
  1206.                     set = 1;
  1207.                 }
  1208.                 else
  1209.                 {
  1210.                     set = 0;
  1211.                 }
  1212.                 x = 3;
  1213.                 y = 2;
  1214.             }
  1215.         }
  1216.         else
  1217.         {
  1218.             if(wrap < 2)
  1219.             {
  1220.                 switch(bioskey(0))
  1221.                 {
  1222.                     case PGDN : page = 1;
  1223.                                         x = 3;
  1224.                                         y = 2;
  1225.                                         if(eof == 0)
  1226.                                         {
  1227.                                             start_byte = start_byte + i;
  1228.  
  1229.                                         }
  1230.                                         eof = 0;
  1231.                                         block = 2000;
  1232.                                         set = 0;
  1233.                                         break;
  1234.                     case PGUP : if(start_byte < 2000L)
  1235.                                             {
  1236.                                                 if(start_byte == 0L)
  1237.                                                 {
  1238.                                                     block = 2000;
  1239.                                                     page = 1;
  1240.                                                     x = 3;
  1241.                                                     y = 2;
  1242.                                                 }
  1243.                                                 else
  1244.                                                 {
  1245.                                                     block = start_byte;
  1246.                                                     page = 2;
  1247.                                                     x = initial_info.winright - 2;
  1248.                                                     y = initial_info.winbottom - 1;
  1249.                                                 }
  1250.                                                 start_byte = 0L;
  1251.                                             }
  1252.                                             else
  1253.                                             {
  1254.                                                 start_byte = start_byte - 2000L;
  1255.                                                 block = 2000;
  1256.                                                 page = 2;
  1257.                                                 x = initial_info.winright - 2;
  1258.                                                 y = initial_info.winbottom - 1;
  1259.                                             }
  1260.                                             break;
  1261.                     case ESC : done = 1; break;
  1262.                     default : page = 0; break;
  1263.                 }
  1264.             }
  1265.             else
  1266.             {
  1267.                 if(wrap == 2)
  1268.                 {
  1269.                     bioskey(0);
  1270.                     done = 1;
  1271.                 }
  1272.                 else
  1273.                 {
  1274.                     done = 1;
  1275.                 }
  1276.             }
  1277.         }
  1278.     }
  1279.     return(0);
  1280. }
  1281.  
  1282.  
  1283.  
  1284. int read_file(void far *buff,char *file_name,unsigned int length,unsigned long int byte_start)
  1285. {
  1286.     FILE r_fp;
  1287.     char *file_buff;
  1288.     unsigned int seg;
  1289.     unsigned int off;
  1290.  
  1291.     if((file_buff = (char*)malloc(length)) == NULL)
  1292.     {
  1293.         return(1);
  1294.     }
  1295.     #ifdef __LARGE__
  1296.         seg = FP_SEG(file_buff);
  1297.         off = FP_OFF(file_buff);
  1298.     #else
  1299.         seg = _DS;
  1300.         asm mov cx,file_buff;
  1301.         off = _CX;
  1302.     #endif
  1303.     dev_error = 0;
  1304.     t_fp = &r_fp;
  1305.     if((t_fp = fopen(file_name,"r+b")) == NULL)
  1306.     {
  1307.         error_write(t_fp);
  1308.         free(file_buff);
  1309.         return(dev_error);
  1310.     }
  1311.     if(fseek(t_fp,byte_start,0) != 0)
  1312.     {
  1313.         error_write(t_fp);
  1314.         fclose(t_fp);
  1315.         free(file_buff);
  1316.         return(dev_error);
  1317.     }
  1318.     if(fread(file_buff,length,1,t_fp) != 1)
  1319.     {
  1320.         error_write(t_fp);
  1321.         fclose(t_fp);
  1322.         movedata(seg,off,FP_SEG(buff),FP_OFF(buff),length);
  1323.         free(file_buff);
  1324.         return(dev_error);
  1325.     }
  1326.     fclose(t_fp);
  1327.     movedata(seg,off,FP_SEG(buff),FP_OFF(buff),length);
  1328.     free(file_buff);
  1329.     return(0);
  1330. }
  1331.  
  1332. #pragma warn -par
  1333.  
  1334. int handler(int errval,int ax,int bp,int si)
  1335. {
  1336.     if(ax < 0)
  1337.     {
  1338.         dev_error = _DI & 0x00ff;
  1339.         bdosptr(0x09,"$",0);
  1340.         hardretn(2);
  1341.     }
  1342.     dev_error = errval;
  1343.     bdosptr(0x09,"$",0);
  1344.     hardretn(2);
  1345.     return(0);
  1346. }
  1347.  
  1348. int write_file(void far *buff,char *file_name,unsigned int length,unsigned long int byte_start)
  1349. {
  1350.     FILE w_fp;
  1351.     char *file_buff;
  1352.     unsigned int seg;
  1353.     unsigned int off;
  1354.  
  1355.     if((file_buff = (char*)malloc(length)) == NULL)
  1356.     {
  1357.         return(1);
  1358.     }
  1359.     #ifdef __LARGE__
  1360.         seg = FP_SEG(file_buff);
  1361.         off = FP_OFF(file_buff);
  1362.     #else
  1363.         seg = _DS;
  1364.         asm mov cx,file_buff;
  1365.         off = _CX;
  1366.     #endif;
  1367.     movedata(FP_SEG(buff),FP_OFF(buff),seg,off,length);
  1368.     dev_error = 0;
  1369.     t_fp = &w_fp;
  1370.     if((t_fp = fopen(file_name,"r+b")) == NULL)
  1371.     {
  1372.         error_write(t_fp);
  1373.         free(file_buff);
  1374.         return(dev_error);
  1375.     }
  1376.     if(fseek(t_fp,byte_start,0) != 0)
  1377.     {
  1378.         error_write(t_fp);
  1379.         fclose(t_fp);
  1380.         free(file_buff);
  1381.         return(dev_error);
  1382.     }
  1383.     if(fwrite(file_buff,length,1,t_fp) != 1)
  1384.     {
  1385.         error_write(t_fp);
  1386.         fclose(t_fp);
  1387.         free(file_buff);
  1388.         return(dev_error);
  1389.     }
  1390.     fclose(t_fp);
  1391.     free(file_buff);
  1392.     return(0);
  1393. }
  1394.  
  1395. int error_write(FILE *err_pt)
  1396. {
  1397.     if(dev_error == 0)
  1398.     {
  1399.         dev_error = _doserrno;
  1400.     }
  1401.     if(feof(err_pt) != 0)
  1402.     {
  1403.         dev_error = -1;
  1404.         return(1);
  1405.     }
  1406.     return(0);
  1407. }
  1408.  
  1409.  
  1410.  
  1411.  
  1412.