home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 377b.lha / libraries / layers / layer.c < prev    next >
Encoding:
C/C++ Source or Header  |  1980-02-03  |  13.6 KB  |  517 lines
  1. /* Copyright (c) 1990 Commodore-Amiga, Inc.
  2.  *
  3.  * This example is provided in electronic form by Commodore-Amiga, Inc. for
  4.  * use with the 1.3 revisions of the Addison-Wesley Amiga reference manuals. 
  5.  * The 1.3 Addison-Wesley Amiga Reference Manual series contains additional
  6.  * information on the correct usage of the techniques and operating system
  7.  * functions presented in this example.  The source and executable code of
  8.  * this example may only be distributed in free electronic form, via bulletin
  9.  * board or as part of a fully non-commercial and freely redistributable
  10.  * diskette.  Both the source and executable code (including comments) must
  11.  * be included, without modification, in any copy.  This example may not be
  12.  * published in printed form or distributed with any commercial product.
  13.  * However, the programming techniques and support routines set forth in
  14.  * this example may be used in the development of original executable
  15.  * software products for Commodore Amiga computers.
  16.  * All other rights reserved.
  17.  * This example is provided "as-is" and is subject to change; no warranties
  18.  * are made.  All use is at your own risk.  No liability or responsibility
  19.  * is assumed.
  20.  */
  21.  
  22. #include <exec/types.h>
  23. #include <graphics/gfxbase.h>
  24. #include <graphics/layers.h>
  25. #include <proto/all.h>
  26. #include <stdlib.h>
  27. #include <string.h>
  28.  
  29. VOID clean_exit(LONG retc);
  30. VOID cleanUp(VOID);
  31. VOID myOrCols(struct Region *region);
  32. VOID pMessage(UBYTE *string);
  33. VOID myLabelRegion( struct Region *region, struct Layer *layer,
  34.                     LONG color, UBYTE *string);
  35. VOID myLabelAllRegions(LONG color);
  36. VOID myLabelLayer( struct Layer *layer, LONG color, UBYTE *string);
  37. VOID myResetRegions(VOID);
  38.  
  39. #define L_DELAY 100
  40. #define S_DELAY 50
  41.  
  42. #define DUMMY 0L
  43.  
  44. #define CLR_RED 1
  45. #define CLR_GRN 2
  46. #define CLR_BLU 3
  47.  
  48. #define SCREEN_D 2
  49. #define SCREEN_W 320
  50. #define SCREEN_H 200
  51.  
  52. /* the starting size of example layers, offsets are used for placement */
  53. #define W_H 50
  54. #define W_T 5
  55. #define W_B (W_T+W_H)-1
  56. #define W_W 80
  57. #define W_L (SCREEN_W/2) - (W_W/2)
  58. #define W_R (W_L+W_W)-1
  59.  
  60. /* size of the superbitmap */
  61. #define SUPER_H SCREEN_H
  62. #define SUPER_W SCREEN_W
  63.  
  64. /* starting size of the message layer */
  65. #define M_H 10
  66. #define M_T SCREEN_H-M_H
  67. #define M_B (M_T+M_H)-1
  68. #define M_W SCREEN_W
  69. #define M_L 0
  70. #define M_R (M_L+M_W)-1
  71.  
  72. /* This example shows how to use the layers.library.
  73. ** This code may be freely utilized to develop programs for the Amiga.
  74. */
  75. struct GfxBase *GfxBase;
  76. struct Library *LayersBase;
  77.  
  78. /* global for FreeMem() */
  79. struct View *oldview = NULL;    /* save old view so can go back to sys */
  80. struct View theView;
  81. struct ViewPort theViewPort;
  82. /* pointer to colormap struct, dynamic alloc */
  83. struct ColorMap *theColorMap = NULL;
  84. struct BitMap theBitMap, theSuperBitMap;
  85. struct Layer *theLayers[3] =  { NULL, NULL, NULL, };
  86. struct Layer *msgLayer = NULL;
  87. LONG theLayerFlags[3] = { LAYERSUPER, LAYERSMART, LAYERSIMPLE };
  88. struct Layer_Info *theLayerInfo = NULL;
  89.  
  90. USHORT colortable[] = { 0x000, 0xf00, 0x0f0, 0x00f };
  91. struct Region *ColRegion = NULL;
  92. struct Region *RowRegion = NULL;
  93. struct Region *theRegions[3] = { NULL, NULL, NULL };
  94.  
  95. VOID main(int argc, char **argv)
  96. {
  97. struct RasInfo theRasInfo;
  98. short iii,jjj;
  99. UWORD *colorpalette;
  100. struct Rectangle rect;  /* some rectangle structures */
  101.  
  102. if ((GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",0)) == NULL)
  103.     exit(RETURN_WARN);
  104.  
  105. if((LayersBase = OpenLibrary("layers.library",0)) == NULL)
  106.     clean_exit(RETURN_WARN);
  107.  
  108. /* example steals screen from Intuition,
  109. ** this is just an example.  In real life, open your own.
  110. */
  111. oldview = GfxBase->ActiView;    /* save current view, go back later */
  112.  
  113. /* get a LayerInfo structure */
  114. if((theLayerInfo = NewLayerInfo()) == NULL)
  115.     clean_exit(RETURN_WARN);
  116.  
  117. InitView(&theView);
  118. theView.ViewPort = &theViewPort;
  119. InitVPort(&theViewPort);
  120.  
  121. theViewPort.DWidth  = SCREEN_W;
  122. theViewPort.DHeight = SCREEN_H;
  123. theViewPort.RasInfo = &theRasInfo;
  124.  
  125. InitBitMap(&theBitMap,SCREEN_D,SCREEN_W,SCREEN_H);
  126.  
  127. theRasInfo.BitMap   = &theBitMap;
  128. theRasInfo.RxOffset = 0;
  129. theRasInfo.RyOffset = 0;
  130. theRasInfo.Next     = NULL;
  131.  
  132. theColorMap = GetColorMap(4);
  133.  
  134. colorpalette = (UWORD *)theColorMap->ColorTable;
  135. for(iii=0; iii<4; iii++)
  136.     *colorpalette++ = colortable[iii];
  137. theViewPort.ColorMap = theColorMap;    /* link it with the viewport */
  138.  
  139. for(iii=0; iii<SCREEN_D; iii++)
  140.     {
  141.     if((theBitMap.Planes[iii] =
  142.                 (PLANEPTR)AllocRaster(SCREEN_W,SCREEN_H)) == NULL)
  143.         clean_exit(RETURN_WARN);
  144.     BltClear(theBitMap.Planes[iii], RASSIZE(SCREEN_W, SCREEN_H), 1);
  145.     }
  146.  
  147. MakeVPort( &theView, &theViewPort ); /* construct copper (prelim) list */
  148. MrgCop( &theView );       /* merge copper lists in the view structure. */
  149. LoadView(&theView);
  150.  
  151. if ((msgLayer = CreateUpfrontLayer( theLayerInfo, &theBitMap,
  152.                      M_L, M_T, M_R, M_B, LAYERSMART, NULL)) == NULL)
  153.     clean_exit(RETURN_WARN);
  154. pMessage("Setting up Layers");
  155.  
  156. /* Layers stuff starts here ********************************************/
  157. InitBitMap(&theSuperBitMap,SCREEN_D,SUPER_W,SUPER_H);
  158. for(iii=0; iii<SCREEN_D; iii++)
  159.     {
  160.     if((theSuperBitMap.Planes[iii] =
  161.                       (PLANEPTR)AllocRaster(SUPER_W,SUPER_H)) == NULL)
  162.         clean_exit(RETURN_WARN);
  163.     BltClear(theSuperBitMap.Planes[iii], RASSIZE(SUPER_W, SUPER_H), 1);
  164.     }
  165.  
  166. for(iii=0; iii<3; iii++)
  167.     {
  168.     pMessage("Create BehindLayer");
  169.     if (iii == 0)
  170.         {
  171.         if((theLayers[iii] = CreateBehindLayer( theLayerInfo, &theBitMap,
  172.                     W_L+(iii*30), W_T+(iii*30), W_R+(iii*30), W_B+(iii*30),
  173.                     theLayerFlags[iii], &theSuperBitMap)) == NULL)
  174.             clean_exit(RETURN_WARN);
  175.         }
  176.     else
  177.         {
  178.         if((theLayers[iii] = CreateBehindLayer( theLayerInfo, &theBitMap,
  179.                     W_L+(iii*30), W_T+(iii*30), W_R+(iii*30), W_B+(iii*30),
  180.                     theLayerFlags[iii], NULL)) == NULL)
  181.             clean_exit(RETURN_WARN);
  182.         }
  183.  
  184.     pMessage("RectFill the RastPort");
  185.     SetAPen(theLayers[iii]->rp,iii+1);
  186.     SetDrMd(theLayers[iii]->rp,JAM1);
  187.     if (iii == 0) RectFill(theLayers[iii]->rp,0,0,SUPER_W-1,SUPER_H-1);
  188.     if (iii == 1) RectFill(theLayers[iii]->rp,0,0,W_W-1,W_H-1);
  189.     if (iii == 2) RectFill(theLayers[iii]->rp,0,0,W_W-1,W_H-1);
  190.     SetAPen(theLayers[iii]->rp,0);
  191.     Move(theLayers[iii]->rp,5,7);
  192.     }
  193.  
  194. pMessage("Label all Layers");
  195. Text(theLayers[0]->rp,"Super",5);
  196. Text(theLayers[1]->rp,"Smart",5);
  197. Text(theLayers[2]->rp,"Simple",6);
  198.  
  199. pMessage("MoveLayer 1 InFrontOf 0");
  200. if (!MoveLayerInFrontOf( theLayers[1], theLayers[0]))
  201.     clean_exit(RETURN_WARN);
  202.  
  203. pMessage("MoveLayer 2 InFrontOf 1");
  204. if (!MoveLayerInFrontOf( theLayers[2], theLayers[1]))
  205.     clean_exit(RETURN_WARN);
  206. myLabelLayer(theLayers[2], CLR_BLU, "Simple");
  207.  
  208. pMessage("Incrementally MoveLayers...");
  209. for(iii=0; iii<30; iii++)
  210.     {
  211.     if (!MoveLayer(DUMMY, theLayers[1], -1, 0))
  212.         clean_exit(RETURN_WARN);
  213.     if (!MoveLayer(DUMMY, theLayers[2], -2, 0))
  214.         clean_exit(RETURN_WARN);
  215.     myLabelLayer(theLayers[2], CLR_BLU, "Simple");
  216.     }
  217.  
  218. pMessage("make Layer 0 the UpfrontLayer");
  219. if (!UpfrontLayer(DUMMY, theLayers[0]))
  220.     clean_exit(RETURN_WARN);
  221.  
  222. pMessage("make Layer 2 the BehindLayer");
  223. if (!BehindLayer(DUMMY, theLayers[2]))
  224.     clean_exit(RETURN_WARN);
  225.  
  226. pMessage("Incrementally MoveLayers again...");
  227. for(iii=0; iii<30; iii++)
  228.     {
  229.     if (!MoveLayer(DUMMY, theLayers[1], 0, 1))
  230.         clean_exit(RETURN_WARN);
  231.     if (!MoveLayer(DUMMY, theLayers[2], 0, 2))
  232.         clean_exit(RETURN_WARN);
  233.     myLabelLayer(theLayers[2], CLR_BLU, "Simple");
  234.     }
  235.  
  236. pMessage("Big MoveLayer");
  237. for(iii=0; iii<3; iii++)
  238.     {
  239.     if (!MoveLayer(DUMMY, theLayers[iii], -theLayers[iii]->bounds.MinX, 0))
  240.         clean_exit(RETURN_WARN);
  241.     }
  242.  
  243. pMessage("Incrementally increase size");
  244. for(iii=0; iii<5; iii++)
  245.     {
  246.     for(jjj=0; jjj<3; jjj++)
  247.         {
  248.         if (!SizeLayer(DUMMY, theLayers[jjj], 1, 1))
  249.             clean_exit(RETURN_WARN);
  250.         }
  251.     myLabelLayer(theLayers[1], CLR_GRN, "Smart");
  252.     myLabelLayer(theLayers[2], CLR_BLU, "Simple");
  253.     }
  254.  
  255. pMessage("Big SizeLayer");
  256. for(iii=0; iii<3; iii++)
  257.     {
  258.     if (!SizeLayer(DUMMY,theLayers[iii],SCREEN_W-(theLayers[iii]->bounds.MaxX)-1,0))
  259.         clean_exit(RETURN_WARN);
  260.     }
  261. myLabelLayer(theLayers[1], CLR_GRN, "Smart");
  262. myLabelLayer(theLayers[2], CLR_BLU, "Simple");
  263.  
  264. pMessage("ScrollLayer down");
  265. for(iii=0; iii<30; iii++)
  266.     {
  267.     for(jjj=0; jjj<3; jjj++)
  268.         {
  269.         ScrollLayer(DUMMY, theLayers[jjj], 0, -1);
  270.         }
  271.     myLabelLayer(theLayers[1], CLR_GRN, "Smart");
  272.     myLabelLayer(theLayers[2], CLR_BLU, "Simple");
  273.     }
  274. pMessage("ScrollLayer up");
  275. for(iii=0; iii<30; iii++)
  276.     {
  277.     for(jjj=0; jjj<3; jjj++)
  278.         {
  279.         ScrollLayer(DUMMY, theLayers[jjj], 0, 1);
  280.         }
  281.     myLabelLayer(theLayers[1], CLR_GRN, "Smart");
  282.     myLabelLayer(theLayers[2], CLR_BLU, "Simple");
  283.     }
  284.  
  285. /* Regions stuff starts here *******************************************/
  286. pMessage("Create Regions");
  287. if ((RowRegion = NewRegion()) == NULL)
  288.     clean_exit(RETURN_WARN);
  289. if ((ColRegion = NewRegion()) == NULL)
  290.     clean_exit(RETURN_WARN);
  291. for(iii=0; iii<3; iii++)
  292.     if ((theRegions[iii] = NewRegion()) == NULL) /* for each layer */
  293.         clean_exit(RETURN_WARN);
  294.  
  295. pMessage("Build two tmp regions");
  296. myOrCols(ColRegion);    /* made into subroutine, used often */
  297. for (iii=1; iii<6; iii++)
  298.     {
  299.     rect.MinX = 50;
  300.     rect.MaxX = 315;
  301.     rect.MinY = (iii*10)-5;
  302.     rect.MaxY = (iii*10);
  303.     if (!OrRectRegion(RowRegion, &rect))
  304.         clean_exit(RETURN_WARN);
  305.     }
  306.  
  307. rect.MinX = 5;
  308. rect.MaxX = 315;
  309. rect.MinY = 25;
  310. rect.MaxY = 30;
  311.  
  312. myResetRegions();
  313. pMessage("OrRectRegion one row...");
  314. for (iii=0; iii<3; iii++)
  315.     if (!OrRectRegion(theRegions[iii], &rect))
  316.         clean_exit(RETURN_WARN);
  317.  
  318. pMessage("OrRectRegion result (blue)");
  319. myLabelAllRegions(CLR_BLU);
  320. Delay(L_DELAY);
  321.  
  322. myResetRegions();
  323. pMessage("XorRectRegion one row...");
  324. for (iii=0; iii<3; iii++)
  325.     if (!XorRectRegion(theRegions[iii], &rect))
  326.         clean_exit(RETURN_WARN);
  327.  
  328. pMessage("XorRectRegion result (blue)");
  329. myLabelAllRegions(CLR_BLU);
  330. Delay(L_DELAY);
  331.  
  332. myResetRegions();
  333. pMessage("AndRectRegion one row...");
  334. for (iii=0; iii<3; iii++)
  335.     AndRectRegion(theRegions[iii], &rect);
  336.  
  337. pMessage("AndRectRegion result (blue)");
  338. myLabelAllRegions(CLR_BLU);
  339. Delay(L_DELAY);
  340.  
  341. myResetRegions();
  342. pMessage("ClearRectRegion one row...");
  343. for (iii=0; iii<3; iii++)
  344.     if (!ClearRectRegion(theRegions[iii], &rect))
  345.         clean_exit(RETURN_WARN);
  346.  
  347. pMessage("ClearRectRegion result (blue)");
  348. myLabelAllRegions(CLR_BLU);
  349. Delay(L_DELAY);
  350.  
  351. myResetRegions();
  352. pMessage("OrRegionRegion Rows...");
  353. for (iii=0; iii<3; iii++)
  354.     if (!OrRegionRegion(RowRegion, theRegions[iii]))
  355.         clean_exit(RETURN_WARN);
  356.  
  357. pMessage("OrRegionRegion result (blue)");
  358. myLabelAllRegions(CLR_BLU);
  359. Delay(L_DELAY);
  360.  
  361. myResetRegions();
  362. pMessage("XorRegionRegion Rows...");
  363. for (iii=0; iii<3; iii++)
  364.     if (!XorRegionRegion(RowRegion, theRegions[iii]))
  365.         clean_exit(RETURN_WARN);
  366.  
  367. pMessage("XorRegionRegion result (blue)");
  368. myLabelAllRegions(CLR_BLU);
  369. Delay(L_DELAY);
  370.  
  371. myResetRegions();
  372. pMessage("AndRegionRegion Rows...");
  373. for (iii=0; iii<3; iii++)
  374.     if (!AndRegionRegion(RowRegion, theRegions[iii]))
  375.         clean_exit(RETURN_WARN);
  376.  
  377. pMessage("AndRegionRegion result (blue)");
  378. myLabelAllRegions(CLR_BLU);
  379. Delay(L_DELAY);
  380.  
  381. cleanUp();
  382. }    /* end of main() */
  383.  
  384. VOID clean_exit(LONG retc)
  385. {
  386. cleanUp();
  387. exit(retc);
  388. }
  389.  
  390. VOID cleanUp(VOID)
  391. {
  392. short iii;
  393.  
  394. if (oldview)
  395.     LoadView(oldview);              /* put back the old view  */
  396.  
  397. if (msgLayer != NULL)
  398.     if (!DeleteLayer(DUMMY, msgLayer))
  399.         exit(RETURN_FAIL);
  400.  
  401. if (ColRegion != NULL)
  402.     DisposeRegion(ColRegion);
  403. if (RowRegion != NULL)
  404.     DisposeRegion(RowRegion);
  405. for(iii=0; iii<3; iii++)
  406.     {
  407.     if (theRegions[iii] != NULL)
  408.         DisposeRegion(theRegions[iii]);
  409.     if (theLayers[iii] != NULL)
  410.         if (!DeleteLayer(DUMMY,theLayers[iii]))
  411.             exit(RETURN_FAIL);
  412.     }
  413.  
  414. /* !!! free superbitmap */
  415. for (iii=0; iii<SCREEN_D; iii++)
  416.     {    /* free the drawing area */
  417.     if (theSuperBitMap.Planes[iii] != NULL)
  418.         FreeRaster(theSuperBitMap.Planes[iii], SUPER_W, SUPER_H);
  419.     }
  420.  
  421. if (theLayerInfo != NULL)
  422.     DisposeLayerInfo(theLayerInfo);
  423. if (theColorMap != NULL)
  424.     FreeColorMap(theColorMap);       /* free the color map */
  425. for (iii=0; iii<SCREEN_D; iii++)
  426.     {    /* free the drawing area */
  427.     if (theBitMap.Planes[iii] != NULL)
  428.         FreeRaster(theBitMap.Planes[iii], SCREEN_W, SCREEN_H);
  429.     }
  430.  
  431. /* free dynamically created structures */
  432. FreeVPortCopLists(&theViewPort);
  433. FreeCprList(theView.LOFCprList);
  434.  
  435. if (LayersBase != NULL)
  436.     CloseLibrary(LayersBase);
  437. if (GfxBase != NULL)
  438.     CloseLibrary((struct Library *)GfxBase);
  439. }
  440.  
  441. VOID myOrCols(struct Region *region)
  442. {
  443. short iii;
  444. struct Rectangle rect;
  445. for (iii=5; iii<10; iii++)
  446.     {
  447.     rect.MinX = (iii*10);
  448.     rect.MaxX = (iii*10)+5;
  449.     rect.MinY = 5;
  450.     rect.MaxY = 50;
  451.     if (!OrRectRegion(region, &rect))
  452.         clean_exit(RETURN_WARN);
  453.     }
  454. }
  455.  
  456. VOID pMessage(UBYTE *string)
  457. {
  458. Delay(S_DELAY);
  459. myLabelLayer(msgLayer, CLR_GRN, string);
  460. }
  461.  
  462. VOID myLabelRegion( struct Region *region, struct Layer *layer,
  463.                     LONG color, UBYTE *string)
  464. {
  465. struct Region *old_region;
  466.  
  467. /* blow away the damage list. */
  468. if (BeginUpdate(layer))
  469.     EndUpdate(layer, TRUE);
  470.  
  471. /* install a user clip region.
  472. ** draw into the layer
  473. ** then put back the old clip region
  474. */
  475. old_region = InstallClipRegion(layer,region);
  476. myLabelLayer(layer, color, string);
  477. region = InstallClipRegion(layer,old_region);
  478. }
  479.  
  480. VOID myLabelAllRegions(LONG color)
  481. {
  482. myLabelRegion(theRegions[0], theLayers[0], color, "Super");
  483. myLabelRegion(theRegions[1], theLayers[1], color, "Smart");
  484. myLabelRegion(theRegions[2], theLayers[2], color, "Simple");
  485. }
  486.  
  487. VOID myLabelLayer( struct Layer *layer, LONG color, UBYTE *string)
  488. {
  489. SetAPen(layer->rp, color);
  490. SetDrMd(layer->rp,JAM1);
  491. RectFill(layer->rp, 0, 0, layer->bounds.MaxX - layer->bounds.MinX,
  492.          layer->bounds.MaxY - layer->bounds.MinY);
  493. SetAPen(layer->rp,0);
  494. Move(layer->rp,5,7);
  495. Text(layer->rp, string, strlen(string));
  496. }
  497.  
  498. VOID myResetRegions(VOID)
  499. {
  500. short iii;
  501.  
  502. pMessage("Clear all Regions");
  503. myLabelLayer(theLayers[0], CLR_RED, "Super");
  504. myLabelLayer(theLayers[1], CLR_RED, "Smart");
  505. myLabelLayer(theLayers[2], CLR_RED, "Simple");
  506. for (iii=0; iii<3; iii++)
  507.     ClearRegion(theRegions[iii]);
  508.  
  509. /* put the col region into each layer */
  510. pMessage("OrRegionRect Columns...");
  511. for (iii=0; iii<3; iii++)
  512.     myOrCols(theRegions[iii]);
  513.  
  514. pMessage("ORed in Column Rects - in green");
  515. myLabelAllRegions(CLR_GRN);
  516. }
  517.