home *** CD-ROM | disk | FTP | other *** search
/ Fish 'n' More 2 / fishmore-publicdomainlibraryvol.ii1991xetec.iso / fish / code_examples / cmanual_456 / acm3.lzh / LowLevelGraphics / Example4.c < prev    next >
C/C++ Source or Header  |  1991-01-12  |  9KB  |  281 lines
  1. /* Example 4                                                            */
  2. /* This example demonstrates how to open two different ViewPorts on the */
  3. /* same display. The first ViewPort is in low resolution and use 32     */
  4. /* colours, while the second ViewPort is in high resolution and only    */
  5. /* use 2 colours.                                                       */
  6.  
  7.  
  8. #include <intuition/intuition.h>
  9. #include <graphics/gfxbase.h>
  10.  
  11.  
  12. /* ViewPort 1 */
  13. #define WIDTH1   320 /* 320 pixels wide.                              */
  14. #define HEIGHT1  150 /* 150 lines high.                               */ 
  15. #define DEPTH1     5 /* 5 BitPlanes should be used, gives 32 colours. */
  16. #define COLOURS1  32 /* 2^5 = 32                                      */
  17.  
  18. /* ViewPort 2 */
  19. #define WIDTH2   640 /* 640 pixels wide.                             */
  20. #define HEIGHT2   45 /* 45 lines high.                               */
  21. #define DEPTH2     1 /* 1 BitPlanes should be used, gives 2 colours. */
  22. #define COLOURS2   2 /* 2^1 = 2                                      */
  23.  
  24.  
  25. struct IntuitionBase *IntuitionBase;
  26. struct GfxBase *GfxBase;
  27.  
  28.  
  29. struct View my_view;
  30. struct View *my_old_view;
  31.  
  32.  
  33. /* ViewPort 1 */
  34. struct ViewPort view_port1;
  35. struct RasInfo ras_info1;
  36. struct BitMap bit_map1;
  37. struct RastPort rast_port1;
  38. UWORD color_table1[] =
  39. {
  40.   0x000, 0xFFF, 0xDDD, 0xBBB, 0x999, 0x777, 0x555, 0x333,
  41.   0xF00, 0xD00, 0xB00, 0x900, 0x700, 0x500, 0x300, 0x100,
  42.   0x0F0, 0x0D0, 0x0B0, 0x090, 0x070, 0x050, 0x030, 0x010,
  43.   0x00F, 0x00D, 0x00B, 0x009, 0x007, 0x005, 0x003, 0x001
  44. };
  45.  
  46.  
  47. /* ViewPort 2 */
  48. struct ViewPort view_port2;
  49. struct RasInfo ras_info2;
  50. struct BitMap bit_map2;
  51. struct RastPort rast_port2;
  52. UWORD color_table2[] = { 0x000, 0xFFF };
  53.  
  54.  
  55. void clean_up();
  56. void main();
  57.  
  58.  
  59. void main()
  60. {
  61.   UWORD *pointer;
  62.   int loop;
  63.   
  64.  
  65.  
  66.   /* Open the Intuition library: */
  67.   IntuitionBase = (struct IntuitionBase *)
  68.     OpenLibrary( "intuition.library", 0 );
  69.   if( !IntuitionBase )
  70.     clean_up( "Could NOT open the Intuition library!" );
  71.  
  72.   /* Open the Graphics library: */
  73.   GfxBase = (struct GfxBase *)
  74.     OpenLibrary( "graphics.library", 0 );
  75.   if( !GfxBase )
  76.     clean_up( "Could NOT open the Graphics library!" );
  77.  
  78.  
  79.  
  80.   /* Save the current View, so we can restore it later: */
  81.   my_old_view = GfxBase->ActiView;
  82.  
  83.  
  84.  
  85.   /* 1. Prepare the View structure, and give it a pointer to */
  86.   /*    the first ViewPort:                                  */
  87.   InitView( &my_view );
  88.   my_view.ViewPort = &view_port1;
  89.  
  90.  
  91.  
  92.   /* 2. Prepare the ViewPort structures, and set some important values: */
  93.  
  94.   /* ViewPort 1 */
  95.   InitVPort( &view_port1 );
  96.   view_port1.DWidth = WIDTH1;      /* Set the width.                */
  97.   view_port1.DHeight = HEIGHT1;    /* Set the height.               */
  98.   view_port1.DxOffset = 0;         /* X position.                   */
  99.   view_port1.DyOffset = 0;         /* Y position.                   */
  100.   view_port1.RasInfo = &ras_info1; /* Give it a pointer to RasInfo. */
  101.   view_port1.Modes = NULL;         /* Low resolution.               */
  102.   view_port1.Next = &view_port2;   /* Pointer to next ViewPort.     */
  103.  
  104.   /* ViewPort 2 */
  105.   InitVPort( &view_port2 );
  106.   view_port2.DWidth = WIDTH2;      /* Set the width.                */
  107.   view_port2.DHeight = HEIGHT2;    /* Set the height.               */
  108.   view_port2.DxOffset = 0;         /* X position.                   */
  109.   view_port2.DyOffset = HEIGHT1+5; /* Y position (5 lines under).   */
  110.   view_port2.RasInfo = &ras_info2; /* Give it a pointer to RasInfo. */
  111.   view_port2.Modes = HIRES;        /* High resolution.              */
  112.   view_port2.Next = NULL;          /* Last ViewPort in the list.    */
  113.  
  114.  
  115.  
  116.   /* 3. Get a colour map, link it to the ViewPort, and prepare it: */
  117.  
  118.   /* ViewPort 1 */
  119.   view_port1.ColorMap = (struct ColorMap *) GetColorMap( COLOURS1 );
  120.   if( view_port1.ColorMap == NULL )
  121.     clean_up( "Could NOT get a ColorMap!" );
  122.   /* Get a pointer to the colour map: */
  123.   pointer = (UWORD *) view_port1.ColorMap->ColorTable;
  124.   /* Set the colours: */
  125.   for( loop = 0; loop < COLOURS1; loop++ )
  126.     *pointer++ = color_table1[ loop ];
  127.  
  128.   /* ViewPort 2 */
  129.   view_port2.ColorMap = (struct ColorMap *) GetColorMap( COLOURS2 );
  130.   if( view_port2.ColorMap == NULL )
  131.     clean_up( "Could NOT get a ColorMap!" );
  132.   /* Get a pointer to the colour map: */
  133.   pointer = (UWORD *) view_port2.ColorMap->ColorTable;
  134.   /* Set the colours: */
  135.   for( loop = 0; loop < COLOURS2; loop++ )
  136.     *pointer++ = color_table2[ loop ];
  137.  
  138.  
  139.  
  140.   /* 4. Prepare the BitMap: */
  141.  
  142.   /* ViewPort 1 */
  143.   InitBitMap( &bit_map1, DEPTH1, WIDTH1, HEIGHT1 );
  144.   /* Allocate memory for the Raster: */ 
  145.   for( loop = 0; loop < DEPTH1; loop++ )
  146.   {
  147.     bit_map1.Planes[ loop ] = (PLANEPTR) AllocRaster( WIDTH1, HEIGHT1 );
  148.     if( bit_map1.Planes[ loop ] == NULL )
  149.       clean_up( "Could NOT allocate enough memory for the raster!" );
  150.     /* Clear the display memory with help of the Blitter: */
  151.     BltClear( bit_map1.Planes[ loop ], RASSIZE( WIDTH1, HEIGHT1 ), 0 );
  152.   }
  153.  
  154.   /* ViewPort 2 */
  155.   InitBitMap( &bit_map2, DEPTH2, WIDTH2, HEIGHT2 );
  156.   /* Allocate memory for the Raster: */ 
  157.   for( loop = 0; loop < DEPTH2; loop++ )
  158.   {
  159.     bit_map2.Planes[ loop ] = (PLANEPTR) AllocRaster( WIDTH2, HEIGHT2 );
  160.     if( bit_map2.Planes[ loop ] == NULL )
  161.       clean_up( "Could NOT allocate enough memory for the raster!" );
  162.     /* Clear the display memory with help of the Blitter: */
  163.     BltClear( bit_map2.Planes[ loop ], RASSIZE( WIDTH2, HEIGHT2 ), 0 );
  164.   }
  165.  
  166.  
  167.  
  168.   /* 5. Prepare the RasInfo structure: */
  169.  
  170.   /* ViewPort 1 */
  171.   ras_info1.BitMap = &bit_map1; /* Pointer to the BitMap structure.  */
  172.   ras_info1.RxOffset = 0;       /* The top left corner of the Raster */
  173.   ras_info1.RyOffset = 0;       /* should be at the top left corner  */
  174.                                 /* of the display.                   */
  175.   ras_info1.Next = NULL;        /* Single playfield - only one       */
  176.                                 /* RasInfo structure is necessary.   */
  177.  
  178.   /* ViewPort 2 */
  179.   ras_info2.BitMap = &bit_map2; /* Pointer to the BitMap structure.  */
  180.   ras_info2.RxOffset = 0;       /* The top left corner of the Raster */
  181.   ras_info2.RyOffset = 0;       /* should be at the top left corner  */
  182.                                 /* of the display.                   */
  183.   ras_info2.Next = NULL;        /* Single playfield - only one       */
  184.                                 /* RasInfo structure is necessary.   */
  185.  
  186.  
  187.  
  188.   /* 6. Create the display: */
  189.   MakeVPort( &my_view, &view_port1 ); /* Prepare ViewPort 1 */
  190.   MakeVPort( &my_view, &view_port2 ); /* Prepare ViewPort 2 */
  191.   MrgCop( &my_view );
  192.  
  193.  
  194.  
  195.   /* 7. Prepare the RastPort, and give it a pointer to the BitMap. */
  196.  
  197.   /* ViewPort 1 */
  198.   InitRastPort( &rast_port1 );
  199.   rast_port1.BitMap = &bit_map1;
  200.  
  201.   /* ViewPort 2 */
  202.   InitRastPort( &rast_port2 );
  203.   rast_port2.BitMap = &bit_map2;
  204.  
  205.  
  206.  
  207.   /* 8. Show the new View: */
  208.   LoadView( &my_view );
  209.  
  210.  
  211.  
  212.   /* Set the draw mode to JAM1. FgPen's colour will be used. */
  213.   SetDrMd( &rast_port1, JAM1 );
  214.   SetDrMd( &rast_port2, JAM1 );
  215.  
  216.   /* Set FgPen's colour to 1 (white). */
  217.   SetAPen( &rast_port2, 1 );
  218.   /* Draw some pixels in the second ViewPort: */
  219.   for( loop = 0; loop < 500; loop++ )
  220.     WritePixel( &rast_port2, rand() % WIDTH2, rand() % HEIGHT2 );
  221.  
  222.   /* Print some text into the second ViewPort: */
  223.   Move( &rast_port2, 0, 10 );
  224.   Text( &rast_port2, "This text is written on a single high resolution BitMap. The ViewPort above use ", 80 );
  225.   Move( &rast_port2, 0, 20 );
  226.   Text( &rast_port2, "a 32-colour low resolution BitMap.                                              ", 80 );
  227.  
  228.   /* Draw 10000 pixels in seven different colours, randomly. */ 
  229.   for( loop = 0; loop < 10000; loop++ )
  230.   {
  231.     /* Set FgPen's colour (1-31, 0 used for the the background). */
  232.     SetAPen( &rast_port1, rand() % (COLOURS1-1) + 1 );
  233.     /* Write a pixel somewere on the display: */
  234.     WritePixel( &rast_port1, rand() % WIDTH1, rand() % HEIGHT1 );
  235.   }
  236.   
  237.  
  238.  
  239.   /* 9. Restore the old View: */
  240.   LoadView( my_old_view );
  241.  
  242.  
  243.   /* Free all allocated resources and leave. */
  244.   clean_up( "THE END" );
  245. }
  246.  
  247.  
  248. /* Returns all allocated resources: */
  249. void clean_up( message )
  250. STRPTR message;
  251. {
  252.   int loop;
  253.  
  254.   /* Free automatically allocated display structures: */
  255.   FreeVPortCopLists( &view_port1 );
  256.   FreeVPortCopLists( &view_port2 );
  257.   FreeCprList( my_view.LOFCprList );
  258.   
  259.   /* Deallocate the display memory, BitPlane for BitPlane: */
  260.   for( loop = 0; loop < DEPTH1; loop++ )
  261.     if( bit_map1.Planes[ loop ] )
  262.       FreeRaster( bit_map1.Planes[ loop ], WIDTH1, HEIGHT1 );
  263.   for( loop = 0; loop < DEPTH2; loop++ )
  264.     if( bit_map2.Planes[ loop ] )
  265.       FreeRaster( bit_map2.Planes[ loop ], WIDTH2, HEIGHT2 );
  266.  
  267.   /* Deallocate the ColorMap: */
  268.   if( view_port1.ColorMap ) FreeColorMap( view_port1.ColorMap );
  269.   if( view_port2.ColorMap ) FreeColorMap( view_port2.ColorMap );
  270.  
  271.   /* Close the Graphics library: */
  272.   if( GfxBase ) CloseLibrary( GfxBase );
  273.  
  274.   /* Close the Intuition library: */
  275.   if( IntuitionBase ) CloseLibrary( IntuitionBase );
  276.  
  277.   /* Print the message and leave: */
  278.   printf( "%s\n", message ); 
  279.   exit();
  280. }
  281.