home *** CD-ROM | disk | FTP | other *** search
/ High Voltage Shareware / high1.zip / high1 / DIR21 / DOUGM.ZIP / DM168SRC.ZIP / DRAW.C < prev    next >
Text File  |  1992-07-26  |  16KB  |  597 lines
  1. /***************************************************************************/
  2. void Hide_Cursor( void )  
  3.  
  4. { 
  5.     _asm mov cx, 1000h
  6.     _asm mov ah, 01h
  7.     _asm mov al, video_mode
  8.     _asm int 10h
  9. }
  10.  
  11. /***************************************************************************/
  12. void Show_Cursor( void )  
  13.  
  14. {
  15.     _asm mov ch, cursor_top
  16.     _asm mov cl, cursor_bottom
  17.     _asm mov ah, 01h
  18.     _asm mov al, video_mode
  19.     _asm int 10h
  20. }
  21.  
  22. /***************************************************************************/
  23. void _fastcall Put_Cursor(col,row)
  24.  
  25. byte col,row;
  26.  
  27. {
  28.     _asm mov ah,02       
  29.     _asm sub bh,bh
  30.     _asm mov dh,row       
  31.     _asm mov dl,col       
  32.     _asm int 10h
  33. }
  34.  
  35. /***************************************************************************/
  36. void Hide_Mouse( void )  
  37.  
  38. { 
  39.     _asm mov ax,2
  40.     _asm int 33h
  41. }
  42.  
  43. /***************************************************************************/
  44. void Show_Mouse( void )  
  45.  
  46. {
  47.     _asm mov ax,1
  48.     _asm int 33h
  49. }
  50.  
  51. /***************************************************************************/
  52. void _fastcall Draw(x,y,thing,color)
  53.  
  54. register byte x,y,color;
  55. register char thing;
  56.  
  57. {
  58.     *(video_start+x+max_screen_x*y) = (int) ( (byte) thing| (int) (color <<8) );
  59. }
  60.  
  61. /***************************************************************************/
  62. byte _fastcall Read_Color(x,y)
  63.  
  64. byte x,y;
  65.  
  66. {
  67.     return( *(video_start+x+max_screen_x*y) >> 8);
  68. }
  69.  
  70. /***************************************************************************/
  71. void _fastcall Put_Color(x,y,color)
  72.  
  73. byte x,y,color;
  74.  
  75. {
  76.     *(video_start+x+max_screen_x*y) = (*(video_start+x+max_screen_x*y) & 255) | (color << 8);
  77. }
  78.  
  79. /***************************************************************************/
  80. void _fastcall Fill_Screen(thing,color)
  81.  
  82. char thing;
  83. byte color;
  84.  
  85. {
  86.     register int x, fill_value;
  87.  
  88.     fill_value = ( (byte) thing | color << 8);
  89.  
  90.     for ( x = max_screen_x * (max_screen_y+1); x>=0 ;x--)
  91.         *(video_start+x) = fill_value;
  92. }
  93.  
  94. /***************************************************************************/
  95. void Draw_Backdrop(void)
  96.  
  97. {
  98.     FILE *Backdrop;
  99.     char buffer[MAX_LINE];
  100.  
  101.     Fill_Screen(backdrop_char,backdrop_color);
  102.  
  103.     if (backdrop_file[0] != '\0'){
  104.         if ( ( Backdrop = fopen(backdrop_file, "r" ) ) != NULL ){
  105.             while ( fgets( buffer, MAX_LINE, Backdrop) != NULL )
  106.                 fprintf(stderr,"%s",buffer);
  107.               fclose(Backdrop);
  108.         }
  109.     }
  110. }
  111.  
  112. /***************************************************************************/
  113. void Draw_Header()
  114.  
  115. {
  116.     byte x;
  117.     byte back   = palette[header_palette][ BACK ] << 4;
  118.     byte text   = palette[header_palette][ TEXT ] | back;
  119.     byte border = palette[header_palette][ HIGHLIGHT ] | back;
  120.  
  121.     if ( header_message == NULL )
  122.         header_message = VERSION_STRING;
  123.  
  124.         /* draw top */
  125.     x=0;
  126.     Draw(x, 0, '┌', border);
  127.     for (x++; x < (byte)(max_screen_x-1); x++)
  128.         Draw(x, 0, '─', border);
  129.     Draw(x, 0,'┐', border);
  130.  
  131.         /* draw filling */
  132.     x=0;
  133.     Draw( x++ , 1, '│', border);
  134.     Draw( x++ , 1, ' ', text);
  135.     while (header_message[x-2] != '\0'){
  136.         Draw(x,1,header_message[x-2],text);
  137.         x++;
  138.     }
  139.     while (x< (byte)(max_screen_x-1) )    
  140.         Draw(x++, 1, ' ', text);
  141.     Draw(x, 1, '│', border);
  142.  
  143.         /* draw bottom */
  144.     x = 0;
  145.     Draw(x, 2, '└', border);
  146.     for(x++; x < (byte)(max_screen_x-1); x++)
  147.         Draw(x, 2, '─', border);
  148.     Draw(x, 2, '┘', border);
  149.  
  150.     Update_Time();
  151. }
  152.  
  153. /***************************************************************************/
  154. void Draw_Footer()
  155.  
  156. {
  157.     register byte x,i,ch;
  158.  
  159.     x=0;
  160.     for ( i=1; i < 11 ; i++){
  161.         if (special_item[i] != NULL){
  162.             Draw (x++,max_screen_y,' ',footer_color);    
  163.             Draw (x++,max_screen_y,'F',footer_color);    
  164.             if ( i == 10 ){
  165.                 Draw (x++,max_screen_y,'1',footer_color);    
  166.                 Draw (x++,max_screen_y,'0',footer_color);    
  167.             }
  168.             else
  169.                 Draw (x++,max_screen_y,(byte)(i+48),footer_color);    
  170.             Draw (x++,max_screen_y,'=',footer_color);    
  171.             Draw (x++,max_screen_y,' ',footer_color);    
  172.             ch =0;
  173.             while ( special_item[i]->title[ch] != '\0' )
  174.                 Draw (x++,max_screen_y,special_item[i]->title[ch++],footer_color);
  175.             Draw (x++,max_screen_y,' ',footer_color);
  176.             special_item[i]->item_number = x;
  177.         }
  178.     }
  179.     if (x > 0){
  180.         while (x < max_screen_x)
  181.             Draw (x++,max_screen_y,' ',footer_color);
  182.     }
  183. }
  184.  
  185. /***************************************************************************/
  186. void Screen_Saver()
  187.  
  188. {
  189.     char i;
  190.  
  191.     current_minute = 61;
  192.     shadow =  NO;    /* turn shadow drawing off */
  193.  
  194.              /* wait until movement resets the timer */
  195.         while (timer == 0){  
  196.         Update_Time();
  197.         Update_Mouse();
  198.         if (kbhit()){
  199.             Get_Key_Input();
  200.         }
  201.         clock_place++;  
  202.             /* increment clock_place -  this is used to simulate a
  203.                a random placement of the screen saver message 
  204.               by moding this number with the number of possible 
  205.               places to put it out.  This is done in update_time() */
  206.     }        
  207.  
  208.     Hide_Mouse();         /* just to be safe */
  209.  
  210.     i=win_index;        /* remember how many windows were open */
  211.                         /* draw back boxes will foul this number */
  212.   
  213.     Draw_Backdrop();    /* lay screen foundation */
  214.     Draw_Header();
  215.     Draw_Footer();
  216.     Draw_Back_Boxes();
  217.  
  218.     win_index = 1;      /* begin at the window #1 */
  219.     Last_Window_Globals();    /* go back to window 0 */
  220.  
  221.                         /* if more windows were open, display them */
  222.     if (do_return){
  223.         while( win_index < i ){  
  224.             Display_Menu( current_item );
  225.             win_index +=2;           /* two steps forward -- */
  226.             Last_Window_Globals();     /* one step back -- what a kludge */
  227.         }
  228.     }
  229.         /* turn shadow drawing back on */
  230.     shadow=draw_shadow;
  231.  
  232.     current_minute = 61;
  233.     event.action = NO_ACTION;
  234.  
  235.         /* current window will be redrawn automaticly upon return */ 
  236. }
  237.  
  238. /***************************************************************************/
  239. int *Store_Screen()
  240.  
  241. {
  242.     int *storage_addr;
  243.     register int *storage_pointer;
  244.     register byte x,y;
  245.  
  246.     if ( (storage_addr = (int *) malloc( (width+1) * (height+1) *2 )) == NULL){
  247.         Critical_Error(MEMORY);
  248.     }
  249.  
  250.     storage_pointer = storage_addr;
  251.  
  252.     for (y = top; y <= bottom; y++){
  253.         for (x = left; x <= right; x++){
  254.             *storage_pointer = *(video_start+x+max_screen_x*y);
  255.             storage_pointer++;
  256.         }
  257.     }
  258.  
  259.     return(storage_addr);
  260. }
  261.  
  262. /***************************************************************************/
  263. void Restore_Screen(storage_addr)
  264.  
  265. int *storage_addr;
  266.  
  267. {
  268.     register byte x,y;
  269.     register int *storage_pointer;
  270.  
  271.     storage_pointer = storage_addr;
  272.  
  273.     for (y = top; y <= bottom; y++){
  274.         for (x = left; x <= right; x++){
  275.             *(video_start + (max_screen_x*y) +x) = *storage_pointer;
  276.             storage_pointer++;
  277.         }
  278.     }
  279.     free (storage_addr);
  280.     return;
  281. }
  282.  
  283. /***************************************************************************/
  284. void Display_Menu(hi_item)
  285.  
  286. Item *hi_item;
  287.  
  288. {
  289.     byte text,border,title,back;
  290.  
  291.     register byte x,y,i;
  292.     char *str,quick_number;
  293.     Item *item;
  294.  
  295.     back  = palette[current_menu->palette][ BACK ] << 4;
  296.     text  = palette[current_menu->palette][ TEXT ] | back;
  297.     title = palette[current_menu->palette][ TITLE ] | back;
  298.  
  299.     if (hi_item == NULL){    /* draw_active menu */
  300.         if (shadow) Display_Shadow();
  301.         border = palette[current_menu->palette][ HIGHLIGHT ] | back;
  302.         last_x = 0;   /* force mouse reset */
  303.     }
  304.     else{                    /* draw inactive menu */
  305.         if (shadow) Remove_Shadow();
  306.         border = palette[current_menu->palette][ BORDER ] | back;
  307.     }
  308.  
  309.         /* draw top line */
  310.     x = left;
  311.     y = top;
  312.  
  313.     Draw(x, y,'╔', border);
  314.     for (x++; x < right; x++)
  315.         Draw(x, y,'═', border);
  316.     Draw(x, y, '╗', border);
  317.  
  318.         /* draw title centered*/
  319.     x = left;
  320.     y++;
  321.     Draw(x, y, '║', border);
  322.     for (i = (width-current_menu->title_length)/2; i!=0; i--)
  323.         Draw(++x, y,' ', title);
  324.     for (str = (char *) current_menu->title; *str != '\0'; str++)
  325.         Draw(++x, y, *str, title);
  326.     while ( x < right )
  327.         Draw(++x, y,' ', title);
  328.     Draw(x, y,'║', border);
  329.  
  330.         /* draw title bar */
  331.     x = left;
  332.     y++;
  333.     Draw(x, y,'╠', border);
  334.     for (x++; x < right; x++)
  335.         Draw(x, y,'═', border);
  336.     Draw(x, y,'╣', border);
  337.  
  338.         /* draw body */
  339.     
  340.     item = current_menu->first_item;
  341.     while (item != NULL){
  342.         y++;
  343.         x = left;
  344.         if ( item->first_line != NULL ){
  345.             if (item == hi_item)
  346.                 text = palette[current_menu->palette][ HIGHLIGHT ] | back;
  347.             Draw(x, y, '║', border);
  348.             Draw(++x, y, ' ', text);
  349.             if (quick_select){
  350.                                         /* make it an asc number */
  351.                 quick_number = 48 + item->item_number; 
  352.                 if (quick_number > 57)
  353.                                         /* make it an asc letter */
  354.                     quick_number += 7;  
  355.                 Draw(++x, y, quick_number, text);
  356.                 Draw(++x, y, ')', text);
  357.                 Draw(++x, y, ' ', text);
  358.             }                
  359.             for( str = (char *) item->title; *str != '\0'; str++)
  360.                 Draw(++x, y, *str, text);
  361.             while( x < right )
  362.                 Draw(++x, y, ' ', text);
  363.             Draw(x, y, '║', border);
  364.             if (item == hi_item) 
  365.                 text = palette[current_menu->palette][ TEXT ] | back;
  366.         }
  367.         else{                            /* draw sub-titles centered*/
  368.             x = left;
  369.             Draw(x, y, '╟', border);
  370.             for (i= (width - item->title_length)/2; i!=0; i--)
  371.                 Draw(++x, y, '─', border);
  372.             for (str = (char *) item->title; *str != '\0'; str++)
  373.                 Draw(++x, y, *str, border);
  374.             while (x < right )
  375.                 Draw(++x, y, '─', border);
  376.             Draw(x, y, '╢', border);
  377.         }
  378.         item = item->next_item;
  379.     }
  380.         /* draw bottom */
  381.     x = left;
  382.     y++;
  383.     Draw(x, y, '╚', border);
  384.     for(x++; x < right; x++)
  385.         Draw(x, y, '═', border);
  386.     Draw(x, y, '╝', border);
  387. }
  388.  
  389. /***************************************************************************/
  390. void Select(new_item)
  391.  
  392. /* unselect current_item and then select new_item */
  393.  
  394. Item *new_item;
  395.  
  396. {
  397.     register byte x,y;
  398.     byte back,text,select;
  399.  
  400.     back   = palette[current_menu->palette][ BACK ] << 4;
  401.     text   = palette[current_menu->palette][ TEXT ] | back;
  402.     back   = palette[current_menu->palette][ S_BACK ] << 4;
  403.     select = palette[current_menu->palette][ SELECT ] | back;
  404.  
  405.     y = top + current_item->item_number + 2;
  406.     x = left + 1;
  407.     while (x < right)
  408.         Put_Color(x++, y, text);
  409.  
  410.     current_item = new_item;
  411.  
  412.     y = top + current_item->item_number + 2;
  413.     x = left + 1;
  414.     while ( x < right)
  415.         Put_Color(x++, y, select);
  416.  
  417.     Win[win_index].item = current_item;
  418. }
  419.  
  420. /***************************************************************************/
  421. void Display_Text_Box(lines,x1,y1,pal)
  422.  
  423. char *lines[];
  424. byte x1,y1,pal;
  425.  
  426. {
  427.     byte text,border,back,x2,y2;
  428.     register byte x,y,i;
  429.     char *str;
  430.     int *storage;
  431.  
  432.     win_index++;
  433.  
  434.         /* determine hight and width */
  435.     width=height=0;
  436.     while(lines[height]!=NULL){
  437.         if (width < strlen(lines[height]))        
  438.             width = strlen(lines[height]);
  439.         height++;
  440.     }
  441.     height++;
  442.     width+=3;
  443.  
  444.     if (x1 == CENTER)
  445.         x1 = (max_screen_x-width)/2;
  446.     if (y1 == CENTER)
  447.         y1 = (max_screen_y-height)/2;
  448.  
  449.     x2 = x1+width;
  450.     y2 = y1+height;
  451.  
  452.     if ( x2 >= (byte)(max_screen_x) ){
  453.         x2 = max_screen_x-1;
  454.         x1 = x2 - width;
  455.     }
  456.  
  457.     if (y2 >= (byte)(max_screen_y) ){
  458.         y2 = max_screen_y-1;
  459.         y1 = y2 - height;
  460.     }
  461.  
  462.     if ( x1 >= x2 || y1 >= y2 ){
  463.         Last_Window_Globals();
  464.         Error_Box("Unable to display text box.","The box is too large.");
  465.         return;
  466.     }
  467.  
  468.     left = Win[win_index].left = x1;  
  469.     right = Win[win_index].right = x2;  
  470.     top = Win[win_index].top = y1;  
  471.     bottom = Win[win_index].bottom = y2;  
  472.     Win[win_index].width = width;
  473.     Win[win_index].height = height;
  474.     Win[win_index].storage = Store_Screen();  
  475.  
  476.     back   = palette[pal][ BACK ] << 4;
  477.     text   = palette[pal][ TEXT ] | back;
  478.     border = palette[pal][ HIGHLIGHT ] | back;
  479.  
  480.         /* draw top */
  481.     Draw(x = x1, y1, '┌', border);
  482.     for (x++; x < x2; x++)
  483.         Draw(x, y1, '─', border);
  484.     Draw(x, y1,'┐', border);
  485.  
  486.         /* draw filling */
  487.     for (y=y1+1;y<y2;y++){
  488.         x = x1;
  489.         Draw(x, y, '│', border);
  490.         str = lines[y-y1-1];
  491.         for( i=( x2-x1-strlen(str)-1 )/2 ;i != 0; i--)
  492.             Draw(++x, y, ' ', text);
  493.  
  494.         while (*str != '\0'){
  495.             Draw(++x, y, *str, text);
  496.             str++;
  497.         }
  498.         while( x < x2 )
  499.             Draw(++x, y, ' ', text);
  500.         Draw(x, y,'│', border);
  501.     }
  502.  
  503.         /* draw bottom */
  504.     Draw(x = x1, y2, '└', border);
  505.     for(x++; x < x2; x++)
  506.         Draw(x, y2, '─', border);
  507.     Draw(x, y2, '┘', border);
  508.  
  509.     if (shadow) Display_Shadow();
  510.     last_x = 0;   /* force mouse reset */
  511. }
  512.  
  513. /***************************************************************************/
  514. void Display_Shadow( )
  515.  
  516. {
  517.     register byte x, y;
  518.  
  519.     if (selected_fn) Unselect_Fn();
  520.  
  521.     right++;
  522.     bottom++;
  523.     for ( x = width+1; x ; x--){
  524.         *(shad_buf+x) = Read_Color( (byte)(left+x), bottom );
  525.         Put_Color( (byte)(left+x), bottom, shadow_color);    
  526.     }
  527.     for (y = height; y ; y--){
  528.         *(shad_buf+max_screen_x+y) = Read_Color(right, (byte)(top+y));
  529.         Put_Color( right, (byte)(top+y), shadow_color);
  530.     }
  531.     right--;
  532.     bottom--;
  533. }
  534.  
  535. /***************************************************************************/
  536. void Remove_Shadow()
  537.  
  538. {
  539.     register byte x, y;
  540.  
  541.     right++;
  542.     bottom++;
  543.     for ( x = width+1; x ; x-- )
  544.         Put_Color( (byte)(left+x), bottom, *(shad_buf+x) );
  545.     for ( y = height; y ; y--)
  546.         Put_Color( right,(byte)(top+y), *(shad_buf+max_screen_x+y) );    
  547.     right--;
  548.     bottom--;
  549. }
  550.  
  551. /***************************************************************************/
  552. void Clean_Up()
  553.  
  554. {
  555.     Fill_Screen(' ',7);
  556.     Put_Cursor(0,0);
  557.     Show_Cursor();
  558.     Hide_Mouse();
  559. }
  560.  
  561. /***************************************************************************/
  562. void Draw_Back_Boxes()
  563.  
  564. {
  565.     char *line[25],*place;
  566.     char temp[MAX_LINE], *checker;
  567.     byte i;
  568.  
  569.     current_text_block = first_text_block;
  570.  
  571.     while( current_text_block != NULL ){
  572.         current_text = current_text_block->first_line;
  573.         i=0;
  574.         while ( current_text != NULL && *(place=current_text->text_line) == '"'){
  575.             if (i <25){
  576.                 place++;
  577.                 Transcribe_String(place,temp);
  578.                 checker=temp;
  579.                 while (*checker != '\0'){
  580.                     if (*checker == '"')
  581.                         *checker = '\0';
  582.                     checker++;
  583.                 }
  584.                 line[i] = strdup(temp);
  585.                 i++;
  586.            }
  587.            current_text = current_text->next_line;
  588.         }
  589.         line[i] = NULL;
  590.  
  591.         Display_Text_Box(line,current_text_block->x1,current_text_block->y1,current_text_block->pal);
  592.         for (i=0;line[i] != NULL;i++)
  593.             free(line[i]);
  594.         current_text_block = current_text_block->next_block;
  595.     }
  596. }
  597.