home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 420.lha / TransparentExample / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-10-05  |  8.5 KB  |  395 lines
  1. #define    DEMO    1
  2.  
  3. #if DEMO
  4. /* main.c
  5.  * example of transparent images
  6.  * Written by David N. Junod
  7.  *
  8.  * Compiled with SAS/C version 5.10.
  9.  * LC -L -cfist -ms -v -y main
  10.  *
  11.  */
  12.  
  13. #include <exec/types.h>
  14. #include <exec/memory.h>
  15. #include <exec/libraries.h>
  16. #include <intuition/intuition.h>
  17. #include <graphics/gfx.h>
  18. #include <workbench/workbench.h>
  19. #include <clib/exec_protos.h>
  20. #include <clib/intuition_protos.h>
  21. #include <clib/graphics_protos.h>
  22. #include <clib/icon_protos.h>
  23. #include <string.h>
  24. #include <stdio.h>
  25.  
  26. /* main.c */
  27. int main (int argc, char **argv);
  28. BOOL OpenLibraries (VOID);
  29. VOID CloseLibraries (VOID);
  30.  
  31. /* transparent images prototypes */
  32. VOID DrawTransImage (struct RastPort * rp, struct Image * im, WORD x, WORD y);
  33.  
  34. struct Library *IntuitionBase, *GfxBase, *IconBase;
  35.  
  36. /* NewWindow Structures */
  37. struct NewWindow NewWindow1 =
  38. {
  39.     0, 1, 640, 199, -1, -1,
  40.     CLOSEWINDOW | MOUSEBUTTONS,
  41.     WINDOWSIZING | WINDOWDRAG | WINDOWDEPTH | WINDOWCLOSE
  42.     | SIZEBRIGHT | ACTIVATE | NOCAREREFRESH | RMBTRAP,
  43.     NULL, NULL,
  44.     "Click Left MB for Transparent, Right MB for Normal",
  45.     NULL, NULL, 150, 50, 65535, 65535, WBENCHSCREEN,
  46. };
  47.  
  48. main (int argc, char **argv)
  49. {
  50.  
  51.     if (OpenLibraries ())
  52.     {
  53.     STRPTR name = "SYS:Prefs";
  54.     struct DiskObject *dob;
  55.  
  56.     /* Get a name if one was passed */
  57.     if (argc >= 2)
  58.         name = argv[1];
  59.  
  60.     /* Get an image to work with */
  61.     if (dob = GetDiskObject (name))
  62.     {
  63.         struct Image *image;
  64.         struct Window *win;
  65.  
  66.         image = (struct Image *) dob->do_Gadget.GadgetRender;
  67.  
  68.         /* Open the window */
  69.         if (win = OpenWindow (&NewWindow1))
  70.         {
  71.         struct RastPort *rp = win->RPort;
  72.         BOOL going = TRUE;
  73.  
  74.         while (going)
  75.         {
  76.             struct IntuiMessage *msg;
  77.  
  78.             /* Wait for something to happen */
  79.             Wait (1L << win->UserPort->mp_SigBit);
  80.  
  81.             /* Process all outstanding messages */
  82.             while (msg = (struct IntuiMessage *) GetMsg (win->UserPort))
  83.             {
  84.             switch (msg->Class)
  85.             {
  86.                 case CLOSEWINDOW:
  87.                 going = FALSE;
  88.                 break;
  89.  
  90.                 case MOUSEBUTTONS:
  91.                 if (msg->Code == SELECTDOWN)
  92.                 {
  93.                     DrawTransImage (rp, image,
  94.                             msg->MouseX, msg->MouseY);
  95.                 }
  96.                 /* This is not a recommended thing. Just done
  97.                  * to illustrate a point (rectangular draw).
  98.                  */
  99.                 else if (msg->Code == MENUDOWN)
  100.                 {
  101.                     DrawImage (rp, image,
  102.                             msg->MouseX, msg->MouseY);
  103.                 }
  104.                 break;
  105.  
  106.                 default:
  107.                 break;
  108.             }
  109.  
  110.             /* Reply to the message now that we're done with it */
  111.             ReplyMsg ((struct Message *) msg);
  112.             }
  113.         }
  114.  
  115.         /* Done with the window, close it */
  116.         CloseWindow (win);
  117.         }
  118.  
  119.         /* Done with the icon, close it */
  120.         FreeDiskObject (dob);
  121.     }
  122.     else
  123.     {
  124.         printf ("Couldn't open %s\n", name);
  125.     }
  126.  
  127.     CloseLibraries ();
  128.     }
  129. }
  130.  
  131. BOOL
  132. OpenLibraries (VOID)
  133. {
  134.  
  135.     if (IntuitionBase = OpenLibrary ("intuition.library", 31))
  136.     {
  137.     if (GfxBase = OpenLibrary ("graphics.library", 31))
  138.     {
  139.         if (IconBase = OpenLibrary ("icon.library", 31))
  140.         {
  141.         return (TRUE);
  142.         }
  143.         CloseLibrary (GfxBase);
  144.     }
  145.     CloseLibrary (IntuitionBase);
  146.     }
  147.     return (FALSE);
  148. }
  149.  
  150. VOID
  151. CloseLibraries (VOID)
  152. {
  153.  
  154.     if (IconBase)
  155.     CloseLibrary (IconBase);
  156.     if (IntuitionBase)
  157.     CloseLibrary (IntuitionBase);
  158.     if (GfxBase)
  159.     CloseLibrary (GfxBase);
  160. }
  161.  
  162. #endif
  163. /*------------------------------------------------------------------------*/
  164. /* transparent.c
  165.  * functions to implement transparent brushes and images
  166.  * Written by David N. Junod
  167.  *
  168.  */
  169. #include <exec/types.h>
  170. #include <exec/memory.h>
  171. #include <intuition/intuition.h>
  172. #include <graphics/gfx.h>
  173. #include <graphics/gfxbase.h>
  174. #include <graphics/gfxmacros.h>
  175. #include <graphics/sprite.h>
  176. #include <graphics/gels.h>
  177. #include <graphics/clip.h>
  178.  
  179. /* Structure for transparent images */
  180. struct TransImage
  181. {
  182.     struct Image *ti_IM;    /* The plain image */
  183.     struct BitMap *ti_sBM;    /* Shadow bitmap */
  184.     struct RastPort *ti_sRP;    /* Shadow rastport */
  185.     struct BitMap ti_BM;    /* Image bitmap */
  186.     struct RastPort ti_RP;    /* Image rastport */
  187. };
  188.  
  189. struct TransImage *AllocTransImage (struct Image * im);
  190. VOID FreeTransImage (struct TransImage * ti);
  191. VOID drawtransimage (struct RastPort * rp, struct TransImage * ti, WORD x, WORD y);
  192. VOID DrawTransImage (struct RastPort * rp, struct Image * im, WORD x, WORD y);
  193.  
  194. VOID FreeShadowBM (struct BitMap *);
  195. VOID FreeShadowRP (struct RastPort *);
  196. struct BitMap *AllocShadowBM (UWORD, UWORD, UWORD);
  197. struct RastPort *AllocShadowRP (struct BitMap *);
  198. VOID ClipBlitTrans (struct RastPort *, WORD, WORD, struct RastPort *, WORD, WORD, WORD, WORD, struct RastPort *, BOOL);
  199.  
  200. struct TransImage *
  201. AllocTransImage (struct Image * im)
  202. {
  203.     if (im)
  204.     {
  205.     LONG msize = sizeof (struct TransImage);
  206.     struct TransImage *ti;
  207.  
  208.     if (ti = (struct TransImage *) AllocMem (msize, MEMF_CLEAR))
  209.     {
  210.         LONG image_data = (LONG) im->ImageData;
  211.         UWORD depth = im->Depth;
  212.         UWORD width = im->Width;
  213.         UWORD height = im->Height;
  214.         WORD planes = RASSIZE (width, height);
  215.         WORD i;
  216.  
  217.         /* Remember the image */
  218.         ti->ti_IM = im;
  219.  
  220.         /* Initialize the Image bitmap */
  221.         InitBitMap (&ti->ti_BM, depth, width, height);
  222.  
  223.         /* Map the image data to planes */
  224.         for (i = 0L; i < depth; ++i)
  225.         ti->ti_BM.Planes[i] = (PLANEPTR) (image_data + i * planes);
  226.  
  227.         /* Initialize the Image rastport */
  228.         InitRastPort (&ti->ti_RP);
  229.         ti->ti_RP.BitMap = &ti->ti_BM;
  230.  
  231.         if (ti->ti_sBM = AllocShadowBM (depth, width, height))
  232.         {
  233.         if (ti->ti_sRP = AllocShadowRP (ti->ti_sBM))
  234.         {
  235.             return (ti);
  236.         }
  237.         FreeShadowBM (ti->ti_sBM);
  238.         }
  239.         FreeMem ((APTR) ti, msize);
  240.     }
  241.     }
  242.  
  243.     return (NULL);
  244. }
  245.  
  246. VOID
  247. FreeTransImage (struct TransImage * ti)
  248. {
  249.  
  250.     if (ti)
  251.     {
  252.     LONG msize = sizeof (struct TransImage);
  253.  
  254.     /* Free the shadow RastPort */
  255.     FreeShadowRP (ti->ti_sRP);
  256.  
  257.     /* Free the shadow BitMap */
  258.     FreeShadowBM (ti->ti_sBM);
  259.  
  260.     /* Free the temporary buffer */
  261.     FreeMem ((APTR) ti, msize);
  262.     }
  263. }
  264.  
  265. VOID
  266. drawtransimage (struct RastPort * rp, struct TransImage * ti, WORD x, WORD y)
  267. {
  268.  
  269.     ClipBlitTrans (
  270.               &(ti->ti_RP),    /* Source RastPort */
  271.               0, 0,        /* Source LeftEdge, TopEdge */
  272.               rp,        /* Destination RastPort */
  273.               x, y,        /* Destination LeftEdge, TopEdge */
  274.               ti->ti_IM->Width,    /* Width of Image */
  275.               ti->ti_IM->Height,/* Height of Image */
  276.               ti->ti_sRP,    /* Shadow RastPort */
  277.               TRUE);        /* Make a new shadow */
  278. }
  279.  
  280. /* If your going to be doing a lot with the image, then allocate it in
  281.  * your own app, use the lowercase drawtransimage() as many times as you
  282.  * want, and then free it.
  283.  */
  284. VOID
  285. DrawTransImage (struct RastPort * rp, struct Image * im, WORD x, WORD y)
  286. {
  287.     struct TransImage *ti;
  288.  
  289.     if (ti = AllocTransImage (im))
  290.     {
  291.     drawtransimage (rp, ti, x, y);
  292.  
  293.     FreeTransImage (ti);
  294.     }
  295. }
  296.  
  297. VOID
  298. FreeShadowBM (struct BitMap *sbm)
  299. {
  300.  
  301.     if (sbm)
  302.     {
  303.     LONG msize;
  304.  
  305.     msize = RASSIZE (8 * (sbm->BytesPerRow), sbm->Rows);
  306.  
  307.     if (sbm->Planes[0])
  308.     {
  309.         FreeMem ((APTR)sbm->Planes[0], msize);
  310.     }
  311.  
  312.     FreeMem ((APTR)sbm, sizeof (struct BitMap));
  313.     }
  314. }
  315.  
  316. VOID
  317. FreeShadowRP (struct RastPort *srp)
  318. {
  319.  
  320.     if (srp)
  321.     {
  322.     FreeMem (srp, sizeof (struct RastPort));
  323.     }
  324. }
  325.  
  326. struct BitMap *
  327. AllocShadowBM (UWORD depth, UWORD width, UWORD height)
  328. {
  329.     LONG msize = sizeof (struct BitMap);
  330.     struct BitMap *bm;
  331.     WORD i;
  332.  
  333.     /* Allocate a bitmap */
  334.     if (bm = (struct BitMap *) AllocMem (msize, MEMF_CHIP))
  335.     {
  336.     LONG rsize = RASSIZE (width, height);
  337.  
  338.     /* Initialize the bitmap */
  339.     InitBitMap (bm, depth, width, height);
  340.  
  341.     /* Allocate one plane */
  342.     if (bm->Planes[0] = (PLANEPTR) AllocMem (rsize, MEMF_CHIP | MEMF_CLEAR))
  343.     {
  344.         /* All planes point to the first plane */
  345.         for (i = 1; i < depth; i++)
  346.         bm->Planes[i] = bm->Planes[0];
  347.  
  348.         return (bm);
  349.     }
  350.  
  351.     FreeMem ((APTR) bm, msize);
  352.     }
  353.  
  354.     return (NULL);
  355. }
  356.  
  357. struct RastPort *
  358. AllocShadowRP (struct BitMap *bm)
  359. {
  360.     LONG msize = sizeof (struct RastPort);
  361.     struct RastPort *rp;
  362.  
  363.     /* Allocate a RastPort */
  364.     if (rp = (struct RastPort *) AllocMem (msize, MEMF_CHIP))
  365.     {
  366.     /* Initialize the new RastPort */
  367.     InitRastPort (rp);
  368.  
  369.     /* Point the RastPort's BitMap... */
  370.     rp->BitMap = bm;
  371.     }
  372.  
  373.     return (rp);
  374. }
  375.  
  376. VOID
  377. ClipBlitTrans (
  378.     struct RastPort *rp,    /* source RastPort */
  379.     WORD sx, WORD sy,        /* source top-left edge */
  380.     struct RastPort *drp,    /* destination RastPort */
  381.     WORD dx, WORD dy,        /* destination top-left edge */
  382.     WORD width, WORD height,    /* width & height of image to blit */
  383.     struct RastPort *Srp,    /* shadow RastPort */
  384.     BOOL makeShadow)        /* create new shadow? */
  385. {
  386.  
  387.     if (makeShadow)
  388.     {
  389.     ClipBlit (rp, sx, sy, Srp, 0, 0, width, height, 0xe0);
  390.     }
  391.  
  392.     ClipBlit (Srp, 0, 0, drp, dx, dy, width, height, 0x20);
  393.     ClipBlit (rp, sx, sy, drp, dx, dy, width, height, 0xe0);
  394. }
  395.