home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung 2 / Power-Programmierung CD 2 (Tewi)(1994).iso / c / library / dos / grafik / cgazv5n3 / paldemo.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-03-01  |  10.4 KB  |  390 lines
  1. /********* Listing 2 *************** PALDEMO.C *******
  2.  *                                                   *
  3.  * Palette Demonstration Program for EGA/VGA colors. *
  4.  * Tested on: Turbo 2.0+, MS 5.0+, Zortech C/C++ 2.0+*
  5.  * by:  Marv Luse, Autumn Hill Software, Inc.        *
  6.  * (c) 1991 Use freely but acknowledge authorship.   *
  7.  *****************************************************/
  8.  
  9. #include "stdlib.h"
  10. #include "stdio.h"
  11. #include "conio.h"
  12. #include "dos.h"
  13. #include "palette.h"
  14.  
  15. #define  OFF  0
  16. #define  ON   1
  17.  
  18. #define INDEX_COL   26
  19. #define COLOR_COL   33
  20. #define R_COL       41
  21. #define G_COL       46
  22. #define B_COL       51
  23.  
  24. #define HDR_ROW      4
  25. #define CLR_ROW      6
  26.  
  27. char *hdr = "Index  Color  Red  Grn  Blu";
  28. char *blk = "\xDB\xDB\xDB\xDB\xDB";
  29. char *msg = 
  30.  "\x19 INDEX \x18     \x1B RGB \x1A     - VALUE +";
  31.  
  32. int   iclr   = 0; /* color index in range 0-15 */
  33. int   irgb   = 0; /* which primary - 0=r, 1=g, 2=b */
  34. int   icol[] = { R_COL, G_COL, B_COL };
  35.  
  36. /*--------------------------------------------------*/
  37. /* Function to read byte from specified address...  */
  38. /*--------------------------------------------------*/
  39. int get_byte( unsigned short seg, unsigned short ofs )
  40. {
  41.     unsigned char far *p;
  42.  
  43.     p = (unsigned char far *) 
  44.         ( (((unsigned long) seg)<<16) | ofs );
  45.     return( (int) *p );
  46. }
  47.  
  48. /*--------------------------------------------------*/
  49. /* Function to write byte to specified address...   */
  50. /*--------------------------------------------------*/
  51. void put_byte( int byte_val, unsigned short seg, 
  52.                               unsigned short ofs )
  53. {
  54.     unsigned char far *p;
  55.  
  56.     p = (unsigned char far *) 
  57.                ( (((unsigned long) seg)<<16) | ofs );
  58.     *p = (unsigned char) byte_val;
  59. }
  60.  
  61. /*--------------------------------------------------*/
  62. /* Function to display char at given row and column */
  63. /*--------------------------------------------------*/
  64. void display_ch( int ch, int row, int col, int atr )
  65. {
  66.     unsigned short seg, ofs;
  67.  
  68.     /* address into video mem */
  69.     seg = 0xB800;
  70.     ofs = (row - 1)*160 + (col - 1)*2;
  71.  
  72.     /* displayed character */
  73.     put_byte( ch, seg, ofs );
  74.  
  75.     /* displayed attribute */
  76.     put_byte( atr, seg, ofs+1 );
  77. }
  78.  
  79. /*--------------------------------------------------*/
  80. /* Display a string at given row and column...      */
  81. /*--------------------------------------------------*/
  82. void display_str(char *str, int row, int col, int atr)
  83. {
  84.     while( *str )
  85.         display_ch( *str++, row, col++, atr );
  86. }
  87.  
  88. /*--------------------------------------------------*/
  89. /*  Turns hardware cursor on or off...              */
  90. /*--------------------------------------------------*/
  91. void set_cursor ( int state )
  92. {
  93.     union REGS reg;
  94.  
  95.     if( state ) /* show cursor */
  96.         reg.x.cx = 0x0607;
  97.     else        /* hide cursor */
  98.         reg.x.cx = 0x2000;
  99.     reg.x.ax = 0x0100;
  100.     int86 (0x10, ®, ®);
  101. }
  102.  
  103. /*--------------------------------------------------*/
  104. /*  Clear the screen...                             */
  105. /*--------------------------------------------------*/
  106. void clear_screen( void )
  107. {
  108.     int i, j;
  109.  
  110.     for( i=1; i<=25; i++ )
  111.         for( j=1; j<=80; j++ )
  112.             display_ch( ' ', i, j, 7 );
  113. }
  114.  
  115. /*--------------------------------------------------*/
  116. /*  Get RGB values for passed index...              */
  117. /*--------------------------------------------------*/
  118. void get_rgb( int i, unsigned char rgb[] )
  119. {
  120.     int r;
  121.  
  122.     if( is_ega_color() )
  123.     {
  124.         r = get_ega_pal_register( i );
  125.         rgb[0] = (unsigned char) ((r & 0x04) >> 1) |
  126.                  ((r & 0x20) >> 5);
  127.         rgb[1] = (unsigned char)  (r & 0x02)       |
  128.                  ((r & 0x10) >> 4);
  129.         rgb[2] = (unsigned char) ((r & 0x01) << 1) |
  130.                  ((r & 0x08) >> 3);
  131.     }
  132.     else
  133.     {
  134.         r = get_vga_pal_register( i );
  135.         get_vga_dac_register( r, rgb );
  136.     }
  137. }
  138.  
  139. /*--------------------------------------------------*/
  140. /*  Set RGB values for passed index...              */
  141. /*--------------------------------------------------*/
  142. void set_rgb( int i, unsigned char rgb[] )
  143. {
  144.     int r;
  145.  
  146.     if( is_ega_color() )
  147.     {
  148.         r  = 0;
  149.         r |= ((rgb[0] & 0x02) << 1) | 
  150.              ((rgb[0] & 0x01) << 5);
  151.         r |= (rgb[1] & 0x02)        | 
  152.              ((rgb[1] & 0x01) << 4);
  153.         r |= ((rgb[2] & 0x02) >> 1) | 
  154.              ((rgb[2] & 0x01) << 3);
  155.         set_ega_pal_register( i, r );
  156.     }
  157.     else
  158.     {
  159.         r = get_vga_pal_register( i );
  160.         set_vga_dac_register( r, rgb );
  161.     }
  162. }
  163.  
  164. /*--------------------------------------------------*/
  165. /*  Draw the palette demo display...                */
  166. /*--------------------------------------------------*/
  167. void draw_display( void )
  168. {
  169.     char          line[40];
  170.     unsigned char rgb[3];
  171.     int           i;
  172.  
  173.     if( is_ega_color() )
  174.         display_str( " EGA Color Palette Demo ", 
  175.                        2, 27, 0x0F );
  176.     else
  177.         display_str( " VGA Color Palette Demo ", 
  178.                        2, 27, 0x0F );
  179.  
  180.     display_str( hdr, HDR_ROW, INDEX_COL, 0x0F );
  181.  
  182.     for( i=0; i<16; i++ )
  183.     {
  184.         /* get rgb values for color index i */
  185.         get_rgb( i, rgb );
  186.  
  187.         /* format display line */
  188.         sprintf( line, 
  189.             "  %2d           %02d   %02d   %02d",
  190.             i, rgb[0], rgb[1], rgb[2] );
  191.         display_str(line,i+CLR_ROW, INDEX_COL, 0x0F);
  192.         display_str(blk, i+CLR_ROW, COLOR_COL, i);
  193.     }
  194.  
  195.     display_str( msg, 24, 22, 0x0F );
  196. }
  197.  
  198. /*--------------------------------------------------*/
  199. /*  Mark or Unmark an index (row)...                */
  200. /*--------------------------------------------------*/
  201. void mark_index( int row, int mark )
  202. {
  203.     int ch;
  204.  
  205.     ch = mark ? 0x10 : 0x20;
  206.     display_ch( ch, CLR_ROW+row, INDEX_COL, 0x0F );
  207. }
  208.  
  209. /*--------------------------------------------------*/
  210. /*  Mark or Unmark an RGB column...                 */
  211. /*--------------------------------------------------*/
  212. void mark_rgb( int col, int mark )
  213. {
  214.     int ch;
  215.  
  216.     ch = mark ? 0x1F : 0x20;
  217.     display_ch( ch, HDR_ROW+1, icol[col], 0x0F );
  218. }
  219.  
  220. /*--------------------------------------------------*/
  221. /*  Change r, g, or b of index by specified amount  */
  222. /*--------------------------------------------------*/
  223. void change_rgb( int index, int pri, int delta )
  224. {
  225.     unsigned char rgb[3];
  226.     char          val[8];
  227.     int           p, pmax;
  228.  
  229.     /* get rgb values for color index */
  230.     get_rgb( index, rgb );
  231.     pmax = is_ega_color() ? 3 : 63;
  232.  
  233.     /* modify specified primary */
  234.     p = rgb[pri];
  235.     p += delta;
  236.     if( p < 0 ) p = 0;
  237.     if( p > pmax ) p = pmax;
  238.     rgb[pri] = (unsigned char) p;
  239.  
  240.     /* set new primary rgb */
  241.     set_rgb( index, rgb );
  242.  
  243.     /* update display */
  244.     sprintf( val, "%02d", p );
  245.     display_str(val,index+CLR_ROW,icol[pri],0x0F);
  246. }
  247.  
  248. /*--------------------------------------------------*/
  249. /*  Do the demo...                                  */
  250. /*--------------------------------------------------*/
  251. void do_demo( void )
  252. {
  253.     int done, ch;
  254.  
  255.     mark_index( iclr, 1 );
  256.     mark_rgb( irgb, 1 );
  257.  
  258.     done = 0;
  259.     while( ! done )
  260.     {
  261.         ch = getch();
  262.  
  263.         switch( ch )
  264.         {
  265.             case 13 : /* enter */
  266.             case 27 : /* escape */
  267.                 done = 1;
  268.                 break;
  269.  
  270.             case 72 : /* up arrow */
  271.                 mark_index( iclr, 0 );
  272.                 iclr--;
  273.                 if( iclr < 0 ) iclr = 15;
  274.                 mark_index( iclr, 1 );
  275.                 break;
  276.  
  277.             case 80 : /* dn arrow */
  278.                 mark_index( iclr, 0 );
  279.                 iclr++;
  280.                 if( iclr > 15 ) iclr = 0;
  281.                 mark_index( iclr, 1 );
  282.                 break;
  283.  
  284.             case 75 : /* left arrow */
  285.                 mark_rgb( irgb, 0 );
  286.                 irgb--;
  287.                 if( irgb < 0 ) irgb = 2;
  288.                 mark_rgb( irgb, 1 );
  289.                 break;
  290.  
  291.             case 77 : /* right arrow */
  292.                 mark_rgb( irgb, 0 );
  293.                 irgb++;
  294.                 if( irgb > 2 ) irgb = 0;
  295.                 mark_rgb( irgb, 1 );
  296.                 break;
  297.  
  298.             case 43 : /* plus */
  299.                 change_rgb( iclr, irgb, 1 );
  300.                 break;
  301.  
  302.             case 45 : /* minus */
  303.                 change_rgb( iclr, irgb, -1 );
  304.                 break;
  305.         }
  306.     }
  307. }
  308.  
  309. /*--------------------------------------------------*/
  310. /*  Save our palette to disk...                     */
  311. /*--------------------------------------------------*/
  312. void save_palette( void )
  313. {
  314.     int            i;
  315.     unsigned char  rgb[3];
  316.     FILE          *fpal;
  317.  
  318.     fpal = fopen( "PALDEMO.PAL", "wt" );
  319.     for( i=0; i<16; i++ )
  320.     {
  321.         get_rgb( i, rgb );
  322.         fprintf( fpal, "%d %d %d  ", 
  323.                  rgb[0], rgb[1], rgb[2] );
  324.     }
  325.     fclose( fpal );
  326. }
  327.  
  328. /*--------------------------------------------------*/
  329. /*  Get our palette from disk...                    */
  330.  
  331. void read_palette( void )
  332. {
  333.     int            i, r, g, b;
  334.     unsigned char  rgb[3];
  335.     FILE          *fpal;
  336.  
  337.     fpal = fopen( "PALDEMO.PAL", "rt" );
  338.     if( fpal == NULL ) return;
  339.     for( i=0; i<16; i++ )
  340.     {
  341.         fscanf( fpal, "%d %d %d", &r, &g, &b );
  342.         rgb[0] = (unsigned char) r;
  343.         rgb[1] = (unsigned char) g;
  344.         rgb[2] = (unsigned char) b;
  345.         set_rgb( i, rgb );
  346.     }
  347.     fclose( fpal );
  348. }
  349.  
  350. /*--------------------------------------------------*/
  351. /*  Palette demo program...                         */
  352. /*--------------------------------------------------*/
  353. void main( void )
  354. {
  355.     int i, r;
  356.  
  357.     if((is_ega_color()==0) && (is_vga_color() == 0))
  358.     {
  359.         puts(
  360.         "\nThis pgm requires EGA or VGA display!" );
  361.         exit( 0 );
  362.     }
  363.  
  364.     set_cursor( OFF );
  365.     clear_screen();
  366.  
  367.     /* on EGA, we must establish our own PSA area */
  368.     if( is_ega_color() )
  369.     {
  370.         init_save_area( 1 );
  371.         /* fill in save area */
  372.         for( i=0; i<16; i++ )
  373.         {
  374.             r = get_ega_pal_register( i );
  375.             set_ega_pal_register( i, r );
  376.         }
  377.     }
  378.  
  379.     read_palette();
  380.     draw_display();
  381.     do_demo();
  382.     save_palette();
  383.  
  384.     /* on EGA, restore default PSA area */
  385.     if( is_ega_color() )
  386.         restore_save_area( 1 );
  387.  
  388.     clear_screen();
  389.     set_cursor( ON );
  390. }