home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / DataScope 2.0.3 / DataScope2l / DSSource / vdevice.c < prev   
Encoding:
Text File  |  1994-05-04  |  5.6 KB  |  183 lines  |  [TEXT/MPS ]
  1. ce()       set the color palette for the 8-bit vdevice.
  2. */
  3. GDHandle v_savegd;        /* the saved gdevice */
  4. CGrafPtr v_saveport;    /* the saved port from SetPort */
  5.  
  6. /*************************************************************************/
  7. /* InitVDevice
  8. *  allocate an off-screen pixmap and off-screen gdevice which can be drawn
  9. *  in without the palette manager affecting the colors.  If we use MakeITable
  10. *  ourselves and don't install the gdevice into the gdevice list or make it
  11. *  active, then the palette manager ignores it, but QuickDraw works on it.
  12. *
  13. *  set vdev->bounds to the size you need before calling.
  14. *  allocate vdev->bp enough space to hold one byte per pixel of a rectangle that
  15. *  size.
  16. *
  17. *  returns 0 if ok,
  18. *  returns -1 or other negative on other errors.
  19. */
  20. InitVDevice(vdev)
  21.     VDevicePtr vdev;
  22. {
  23.     GDHandle thegd;
  24.     PixMapHandle pm;
  25.     Rect tr;
  26.     CTabHandle ct;
  27.     int width;
  28.  
  29.     GetPort((GrafPtr *)&v_saveport);
  30.     v_savegd = GetGDevice();            /* get old values */
  31.     
  32.     tr = vdev->bounds;                    /* get size of device to create */
  33.     if (tr.right - tr.left < 1 ||
  34.         tr.bottom - tr.top < 1)
  35.         return(-1);                        /* check for simple mistake */
  36.         
  37.     width = tr.right - tr.left;
  38.     
  39.     if (!vdev->bp)
  40.         return(-2);                        /* another simple mistake */
  41. /*
  42. *  Allocate the off-screen PixMap for drawing a duplicate copy.  The off-screen
  43. *  gdevice, CPort and PixMap form a virtual drawing space with its own color map.
  44. *  For this program, we have chosen to make this virtual space an 8-bit drawing
  45. *  device.  When drawing, use SetVDevice and UnsetVDevice to turn on and off.
  46. * 
  47. */
  48.     thegd = vdev->vgd = NewGDevice( 0, -1 );
  49.     
  50.     pm = (PixMapHandle) NewHandle(sizeof(PixMap));
  51.  
  52.     if (width & 1)    {                    /* must be even */
  53.         --tr.right;
  54.         --width;
  55.     }
  56.     (*pm)->baseAddr = vdev->bp;            /* get memory to use */
  57.     (*pm)->rowBytes = width | 0x8000;    /* setting high flag bit */
  58.     (*pm)->bounds = tr;
  59.     (*pm)->pixelSize = 8;                /* source is 8-bits */
  60.     (*pm)->pixelType = 0;                /* chunky */
  61.     (*pm)->cmpCount = 1;                /* chunky */
  62.     (*pm)->cmpSize = 8;                    /* chunky */
  63.     (*pm)->hRes = 72;
  64.     (*pm)->vRes = 72;                    /* resolution = 72dpi */
  65.     (*pm)->planeBytes = 0;                /* chunky */
  66.     (*pm)->pmVersion = 0;                /* chunky */
  67.     (*pm)->packSize = 0;                /* chunky */
  68.     (*pm)->packType = 0;                /* chunky */
  69.     ct = (*pm)->pmTable = (CTabHandle)NewHandle(sizeof(ColorTable));
  70.     (*ct)->ctSeed = GetCTSeed();
  71.     (*ct)->ctFlags = 0x8000;
  72.     (*ct)->ctSize = 1;                    /* 1-length color table (empty) */
  73.     
  74.     (*thegd)->gdResPref = 3;            /* inverse table size preferred */
  75.     (*thegd)->gdType = 0;                /* type = CLUT type */
  76.     (*thegd)->gdRect = tr;                /* device size boundary */
  77.  
  78.     (*thegd)->gdPMap = pm;                /* copy pixmap handle */
  79.     
  80.     SetDeviceAttribute(thegd,noDriver,true);
  81.     SetDeviceAttribute(thegd,gdDevType,true);    /* set to color, not monochrome */
  82.     
  83.     SetGDevice(thegd);
  84.                         /* CPort inherits from the gdevice, including pixmap */
  85.     OpenCPort(&vdev->vport);            /* initialize the port struct */
  86.     SetPort((GrafPtr)&vdev->vport);
  87.     ClipRect(&tr);                        /* set clip region */
  88.  
  89. /*
  90. *  Erase the image region in the virtual device. 
  91. */
  92.     PaintRect(&tr);
  93.  
  94. /*
  95. *  Restore the environment.
  96. */
  97.     SetGDevice(v_savegd);
  98.     SetPort((GrafPtr) v_saveport);
  99.     
  100.     return(0);
  101. }
  102.  
  103. /*******************************************************************************/
  104. /* SetVDevice
  105. *  Set the gdevice and port to our off-screen space.
  106. *  Save the old values for unset.
  107. */
  108. SetVDevice(vdev)
  109.     VDevicePtr vdev;
  110. {
  111.  
  112.     GetPort((GrafPtr *)&v_saveport);
  113.     v_savegd = GetGDevice();
  114.     if (!vdev->vgd)
  115.         return(-1);
  116.     SetGDevice(vdev->vgd);
  117.     SetPort((GrafPtr) &vdev->vport);
  118.     
  119.     return(0);
  120. }
  121.  
  122. /*******************************************************************************/
  123. /* UnsetVDevice
  124. *  Set the vdevice back to the saved values.
  125. */
  126. UnsetVDevice()
  127. {
  128.     SetGDevice(v_savegd);
  129.     SetPort((GrafPtr) v_saveport);
  130. }
  131.  
  132. /*******************************************************************************/
  133. /* TrashVDevice
  134. *  Get rid of the devices that we created with InitVDevice.
  135. *
  136. *  Remember to free up the vdev->bp after the gdevice is gone.
  137. */
  138. TrashVDevice(vdev)
  139.     VDevicePtr vdev;
  140. {
  141.     
  142.     (*(*vdev->vgd)->gdPMap)->baseAddr = NULL;    /* drop old value, bp has a copy */
  143.     
  144.     /* dispose of the color table. CloseCPort seems not to want to do that. */
  145.     
  146.     DisposHandle ((Handle) (**(**vdev->vgd).gdPMap).pmTable);
  147.     
  148.     CloseCPort(&vdev->vport);        /* lose the cport, disposes the pixmap */
  149.     (*vdev->vgd)->gdPMap = NULL;    /* destroy second copy of the pixmaphandle */
  150.     DisposGDevice (vdev->vgd);        /* disposes current gdevice and pixmap */
  151.     DisposPtr ((Ptr) vdev->bp);
  152.  
  153. }
  154.  
  155. /*******************************************************************************/
  156. /*  ColorVDevice
  157. *   input:  vdev and 
  158. *        palette handle.
  159. *   
  160. *   Use palette2ctab to install the color table into the off-screen gdevice and
  161. *   make the inverse color table for it.  Also install the palette into the current
  162. *   window.
  163. */
  164. ColorVDevice(vdev,pal)
  165.     VDevicePtr vdev;
  166.     PaletteHandle pal;
  167. {
  168.     CTabHandle ct;
  169.  
  170.     ct = (*vdev->vport.portPixMap)->pmTable;
  171.     if (!ct)
  172.         return;
  173.  
  174.     Palette2CTab( pal, ct );
  175.  
  176.     (*ct)->ctSeed = GetCTSeed();                    /* give it a unique seed */
  177.     (*ct)->ctFlags = 0  /* 0x8000 */;
  178.     
  179.     MakeITable( ct, (*vdev->vgd)->gdITable, 3 );    /* 3-bit inverse table  */
  180.  
  181. }
  182.  
  183.