home *** CD-ROM | disk | FTP | other *** search
/ Amiga Developer CD 1.2 / amidev_cd_12.iso / devcon / sanfrancisco_1989 / sf-devcon89.1 / graphics / example_code.c next >
Encoding:
C/C++ Source or Header  |  1992-08-27  |  11.7 KB  |  485 lines
  1.  
  2. /******************************************************************************
  3. *                                                                             *
  4. *   example_code -- specifying the new V1.4 ViewPort Modes to graphics.       *
  5. *                                                                             *
  6. *   Requires V1.4 KickStart and the new ECS chip set to display new modes.    *
  7. *                                                                             *
  8. ******************************************************************************/
  9.  
  10.  
  11. /*  this file consists of example code for the program ViewPortDemo, 
  12.     included with this release; detailed comments  and includes can 
  13.     be found in the companion file "tutorial", available on disk  */
  14.  
  15.  
  16. #include <exec/types.h>
  17. #include <graphics/displayinfo.h>
  18.  
  19. #define V1_POINT_4      36
  20.  
  21. struct GfxBase  *GfxBase = NULL;
  22.  
  23. extern iterate_modes( );
  24. extern mode_info( );
  25.  
  26. main()
  27. {
  28.     int error = FALSE;
  29.  
  30.     if( GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",V1_POINT_4) )
  31.     {
  32.         iterate_modes();         /* display every available mode */
  33.         CloseLibrary( GfxBase ); /* clean up and exit */
  34.     }
  35.     else
  36.     {
  37.         error = TRUE;
  38.     }
  39.  
  40.     exit(error);
  41. }
  42.  
  43.  
  44.  
  45. struct DisplayInfo   queryinfo;
  46. struct MonitorInfo   querymntr;
  47. struct DimensionInfo querydims;
  48.  
  49. iterate_modes()
  50. {
  51.     /* start with speical begin/end-of-list ID */
  52.  
  53.     ULONG       ID = INVALID_ID; 
  54.  
  55.     /* get next ID until there are no more */
  56.  
  57.     while((ID = NextDisplayInfo( ID )) != INVALID_ID)
  58.     {
  59.         /* query each ID returned by next() for mode information */
  60.  
  61.         if( mode_info( ID ) ) 
  62.         {
  63.             /* use the information to open a view/viewport in that mode */
  64.  
  65.             open_mode( ID );
  66.         }
  67.     }
  68. }
  69.  
  70.  
  71. mode_info( ID )
  72. ULONG ID;
  73. {
  74.     int    info = FALSE;
  75.     int    mntr = FALSE;
  76.     int    dims = FALSE;
  77.     int    success = FALSE;
  78.  
  79.     if( info=GetDisplayInfoData(NULL,&queryinfo,sizeof(queryinfo),DTAG_DISP,ID))
  80.     {
  81.         mntr=GetDisplayInfoData(NULL,&querymntr,sizeof(querymntr),DTAG_MNTR,ID);
  82.         dims=GetDisplayInfoData(NULL,&querydims,sizeof(querydims),DTAG_DIMS,ID);
  83.  
  84.         if(!(queryinfo.NotAvailable)) success= TRUE; 
  85.     }
  86.  
  87.     return( (info && mntr && dims)? success : FALSE );
  88. }
  89.  
  90.  
  91.  
  92. #include <exec/memory.h>
  93. #include <graphics/gfxbase.h>
  94. #include <graphics/gfx.h>
  95. #include <graphics/rastport.h>
  96. #include <graphics/view.h>
  97. #include <libraries/dos.h>
  98.  
  99. /* forward references */
  100.  
  101. extern                 create_display( ); /* draw a recognizable testpattern */
  102. extern struct RastPort *create_rp    ( ); /* allocate and init a rastport    */
  103. extern struct RasInfo  *create_ri    ( ); /* allocate and init a rasinfo     */
  104. extern struct BitMap   *create_bm    ( ); /* allocate and init a bitmap      */
  105. extern struct ViewPort *create_vp    ( ); /* allocate and init a viewport    */
  106. extern struct View     *create_view  ( ); /* allocate and init a view        */
  107.  
  108. extern                  dispose_ri   ( ); /* deallocate a rasinfo            */
  109. extern                  dispose_bm   ( ); /* deallocate a bitmap             */
  110. extern                  dispose_vp   ( ); /* deallocate a viewport           */
  111. extern                  dispose_view ( ); /* deallocate a view               */
  112.  
  113.  
  114.  
  115. open_mode( ID )
  116. ULONG ID;
  117. {
  118.     struct MonitorSpec *mspc, *OpenMonitor();
  119.     struct View        *view;
  120.     struct ViewPort    *vp;
  121.     struct RasInfo     *ri;
  122.     struct RasPort     *rp;
  123.  
  124.     if( ( mspc = OpenMonitor( NULL, ID ) ) 
  125.     &&  ( view = create_view( mspc ) )     
  126.     &&  ( vp   = create_vp( view, ID ) ) ) 
  127.     {
  128.         view->ViewPort = vp; 
  129.  
  130.         if( ri = create_ri( vp ) )
  131.         {
  132.             vp->RasInfo = ri;
  133.  
  134.             if( rp = create_rp( ri ) )
  135.             {
  136.                 struct View *restore_view = GfxBase->ActiView;
  137.  
  138.                 create_display( vp, rp );
  139.  
  140.                 MakeVPort( view, vp );
  141.                 MrgCop( view );
  142.                 LoadView( view );          
  143.  
  144.                 Wait(SIGBREAKF_CTRL_C);    
  145.                 
  146.                 LoadView( restore_view );  
  147.  
  148.                 dispose_rp( rp );
  149.             }   
  150.             if( ri ) dispose_ri( ri );
  151.         }   
  152.         if( vp )dispose_vp( vp );          
  153.         if( view )  dispose_view( view );  
  154.         CloseMonitor( mspc );              
  155.     } 
  156. }
  157.  
  158.  
  159. #include <graphics/monitor.h>
  160. #include <graphics/videocontrol.h>
  161.  
  162. struct TagItem vc[] =
  163. {
  164.     { VTAG_ATTACH_CM_SET, NULL },       
  165.     { VTAG_VIEWPORTEXTRA_SET, NULL },   
  166.     { VTAG_NORMAL_DISP_SET, NULL },     
  167.     { VTAG_END_CM, NULL }               
  168. };
  169.  
  170. struct ViewPort *create_vp( view, ID )
  171. struct View *view;
  172. ULONG ID;
  173. {
  174.     struct ViewPort  *vp       = NULL;
  175.     struct ViewPortExtra *vpx  = NULL;  /* new for V1.4 */
  176.  
  177.     if( vp = (struct ViewPort *) AllocMem(sizeof(*vp),MEMF_PUBLIC|MEMF_CLEAR) )
  178.     {
  179.         struct Rectangle *oscan    = &querydims.Nominal;
  180.         ULONG  WIDTH   = oscan->MaxX - oscan->MinX + 1 ;
  181.         ULONG  HEIGHT  = oscan->MaxY - oscan->MinY + 1 ;
  182.  
  183.         InitVPort( vp );
  184.  
  185.         vp->Modes    = (ID & 0xFFFF); 
  186.  
  187.         vp->DxOffset = 0;       vp->DyOffset = 0; 
  188.         vp->DWidth   = WIDTH;   vp->DHeight  = HEIGHT;
  189.  
  190.         if( vpx = (struct ViewPortExtra *) GfxNew( VIEWPORT_EXTRA_TYPE ) )
  191.         {
  192.             vpx->DisplayClip.MinX = oscan->MinX;
  193.             vpx->DisplayClip.MinY = oscan->MinY;
  194.             vpx->DisplayClip.MaxX = oscan->MaxX;
  195.             vpx->DisplayClip.MaxY = oscan->MaxY;
  196.         }
  197.  
  198.         vc[0].ti_Data = (ULONG) vp;
  199.         vc[1].ti_Data = (ULONG) vpx; 
  200.         vc[2].ti_Data = (ULONG) FindDisplayInfo( ID );
  201.  
  202.         VideoControl( GetColorMap(32), vc );
  203.  
  204.         view->Modes |= ((DIPF_IS_LACE & queryinfo.PropertyFlags)? LACE: 0);
  205.     }
  206.  
  207.     return( vp ); 
  208. }
  209.  
  210.  
  211. struct TagItem end_vc[] =
  212. {
  213.     { VTAG_VIEWPORTEXTRA_GET, NULL }, 
  214.     { VTAG_END_CM, NULL }             
  215. };
  216.  
  217. dispose_vp( vp)
  218. struct ViewPort *vp;
  219. {
  220.     struct ViewPortExtra *vpx;
  221.     int error = FALSE;
  222.  
  223.     if( vp )
  224.     {
  225.         error = VideoControl( vp->ColorMap, end_vc ); 
  226.  
  227.         if(!error)
  228.         {
  229.             if(vpx = (struct ViewPortExtra *)end_vc[0].ti_Data)
  230.             {
  231.                 GfxFree( vpx );         
  232.             }
  233.         }
  234.  
  235.         if ( vp->ColorMap )
  236.         {
  237.             FreeColorMap( vp->ColorMap );
  238.         }
  239.  
  240.         FreeVPortCopLists( vp );
  241.         FreeMem( vp, sizeof(*vp) );
  242.     }
  243. }
  244.  
  245.  
  246. struct View *create_view( mspc )
  247. struct MonitorSpec *mspc;
  248. {
  249.     struct View *view;
  250.     struct ViewExtra *vx;
  251.  
  252.  
  253.     if( view = (struct View *)AllocMem(sizeof(*view),MEMF_PUBLIC|MEMF_CLEAR) )
  254.     {
  255.         InitView( view );
  256.  
  257.         if( vx = (struct ViewExtra *)GfxNew( VIEW_EXTRA_TYPE ) )
  258.         {
  259.             vx->Monitor = mspc;
  260.             GfxAssociate( view, vx );
  261.             view->Modes |= EXTEND_VSTRUCT;
  262.         }
  263.  
  264.         view->DxOffset = querymntr.ViewPosition.x ;
  265.         view->DyOffset = querymntr.ViewPosition.y ;
  266.     }
  267.     return( view );
  268. }
  269.  
  270. dispose_view( view)
  271. struct View *view;
  272. {
  273.     if( view )
  274.     {
  275.         if (view->Modes & EXTEND_VSTRUCT)
  276.         {
  277.             struct ViewExtra *vx;     
  278.  
  279.             if( vx = (struct ViewExtra *) GfxLookUp( view ) )
  280.             {
  281.                 GfxFree( vx );
  282.             }
  283.         }
  284.         if ( view->LOFCprList ) FreeCprList ( view->LOFCprList );
  285.         if ( view->SHFCprList ) FreeCprList ( view->SHFCprList );
  286.  
  287.         FreeMem( view, sizeof(*view) );
  288.     }
  289. }
  290.  
  291. create_display( vp, rp )
  292. struct ViewPort *vp;
  293. struct RastPort *rp;
  294. {
  295.     int i,j,k;
  296.     char text[1];
  297.     WORD x_center = vp->DWidth  >> 1; 
  298.     WORD y_center = vp->DHeight >> 1; 
  299.     WORD width  =   vp->DWidth  >> 2; 
  300.     WORD height =  
  301.     (( ( LONG )( width * queryinfo.Resolution.x ) ) / queryinfo.Resolution.y );
  302.  
  303.     if(vp && rp)
  304.     {
  305.         SetAPen(  rp,  -1 );
  306.         SetDrMd(  rp,  JAM1 );
  307.  
  308.         /* "circle" in the center, 1/4 width of the screen  */
  309.         DrawEllipse( rp, x_center, y_center, width, height );
  310.  
  311.         /* outline the edge of the display with a rectangle */
  312.         Move( rp, 0,            0 ); 
  313.         Draw( rp, 0,            vp->DHeight-1);
  314.         Draw( rp, vp->DWidth-1, vp->DHeight-1);
  315.         Draw( rp, vp->DWidth-1, 0);
  316.         Draw( rp, 0,            0);
  317.  
  318.         /* indicate diagonals */
  319.         Move( rp, 0,            0 );
  320.         Draw( rp, vp->DWidth-1, vp->DHeight-1);
  321.         Move( rp, 0,            vp->DHeight-1);
  322.         Draw( rp, vp->DWidth-1, 0);
  323.  
  324.         /* dimension counters along the top and left edges  */
  325.         for(i=0; i < vp->DWidth; i+=(1<<4))
  326.         {
  327.             Move( rp, i, 0 ); Draw( rp, i, vp->DHeight-1);
  328.             if(!i) for(k=0; k+12 < vp->DHeight; k+=(1<<4))
  329.             {
  330.                 *text = '0'+((k>>4)%10);
  331.                 Move( rp, i+4, k+12 ); Text( rp, text, 1);
  332.             }
  333.         }
  334.         for(j=0; j < vp->DHeight; j+=(1<<4))
  335.         {
  336.             Move( rp, 0, j ); Draw( rp, vp->DWidth-1, j);
  337.             if(!j) for(k=0; k < vp->DWidth; k+=(1<<4))
  338.             {
  339.                 *text = '0'+((k>>4)%10);
  340.                 Move( rp, k+4, j+12 ); Text( rp, text, 1);
  341.             }
  342.         }
  343.     }
  344. }
  345.  
  346. struct RasInfo  *create_ri( vp )
  347. struct ViewPort *vp;
  348. {
  349.     struct RasInfo *ri  = NULL;
  350.     struct BitMap  *bm  = NULL;
  351.     struct RasInfo *ri2 = NULL;
  352.     struct BitMap  *bm2 = NULL;
  353.     int    depth        = querydims.MaxDepth;
  354.     int    depth2       = depth / 2;
  355.     int    error        = FALSE;
  356.  
  357.     if( queryinfo.PropertyFlags & DIPF_IS_DUALPF )
  358.     {
  359.         if( depth2 )
  360.         {
  361.             depth -= depth2;
  362.  
  363.             if( bm2 = create_bm( vp, depth2 ) )
  364.             {
  365.                 if( ri2 =  
  366.                 (struct RasInfo *)AllocMem(sizeof(*ri2),MEMF_PUBLIC|MEMF_CLEAR))
  367.                 {
  368.                     ri2->BitMap = bm2;
  369.                 }
  370.                 else error = TRUE;
  371.             }
  372.             else error = TRUE;
  373.         }
  374.     }
  375.  
  376.     if( !error )
  377.     {
  378.         if( bm = create_bm( vp, depth ) )
  379.         {
  380.             if(ri = 
  381.               (struct RasInfo *)AllocMem(sizeof(*ri),MEMF_PUBLIC|MEMF_CLEAR) )
  382.             {
  383.                 ri->BitMap = bm;
  384.                 ri->Next   = ri2;
  385.             }
  386.             else error = TRUE;
  387.         }
  388.         else error = TRUE;
  389.     }
  390.  
  391.     if( error )
  392.     {
  393.             if( bm  ) dispose_bm( bm  );
  394.             if( ri2 ) dispose_ri( ri2 );
  395.             if( bm2 ) dispose_bm( bm2 );
  396.     }
  397.  
  398.     return( ri );
  399. }
  400.  
  401.  
  402. struct RastPort *create_rp( ri )
  403. struct RasInfo  *ri;
  404. {
  405.     struct RastPort *rp = NULL;
  406.     struct BitMap   *bm = ri->BitMap;
  407.  
  408.     if( bm 
  409.     &&( rp = (struct RastPort *)AllocMem(sizeof(*rp),MEMF_PUBLIC|MEMF_CLEAR) ) )
  410.     {
  411.         InitRastPort( rp );
  412.         rp->BitMap = bm;
  413.     }
  414.     return( rp );
  415. }
  416.  
  417. dispose_rp( rp )
  418. struct RastPort *rp;
  419. {
  420.     if( rp )
  421.     {
  422.         FreeMem( rp, sizeof(*rp));
  423.     }
  424. }
  425.  
  426. dispose_ri( ri )
  427. struct RasInfo *ri;
  428. {
  429.     if( ri->Next ) dispose_ri( ri->Next ); /* recurse for dual playfield */
  430.  
  431.     if( ri )
  432.     {
  433.         dispose_bm( ri->BitMap );
  434.         FreeMem( ri, sizeof(*ri) );
  435.     }
  436. }
  437.  
  438.  
  439.  
  440. struct BitMap *create_bm( vp, depth )
  441. struct ViewPort *vp;
  442. int    depth;
  443. {
  444.     struct BitMap  *bm = NULL;
  445.     int i;
  446.  
  447.     if( vp && depth )
  448.     {
  449.         if( bm = (struct BitMap *) AllocMem(sizeof(*bm),MEMF_PUBLIC|MEMF_CLEAR))
  450.         {
  451.             InitBitMap(bm, depth, vp->DWidth, vp->DHeight );
  452.  
  453.             for (i = 0; i < bm->Depth; i++)
  454.             {
  455.                 if( bm->Planes[i] = (PLANEPTR) /* allocate chip memory planes */
  456.                 AllocMem( RASSIZE(vp->DWidth,vp->DHeight),MEMF_CHIP|MEMF_CLEAR))
  457.                 {
  458.                     continue;
  459.                 }
  460.                 else bm->Depth = i; dispose_bm( bm ); return( NULL );
  461.             }
  462.         }
  463.     }
  464.  
  465.     return( bm ); 
  466. }
  467.  
  468. dispose_bm( bm )
  469. struct BitMap *bm;
  470. {
  471.     if( bm )
  472.     {
  473.         int i;
  474.  
  475.         for(i=0; i < bm->Depth; i++)
  476.         {
  477.             if(bm->Planes[i]) FreeMem( bm->Planes[i], bm->BytesPerRow*bm->Rows);
  478.         }
  479.         FreeMem( bm, sizeof(*bm));
  480.     }
  481. }
  482.  
  483.  
  484.  
  485.