home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 200-299 / ff214.lzh / MandelVroom / src / gadgets.c < prev    next >
C/C++ Source or Header  |  1989-05-30  |  13KB  |  543 lines
  1. /*
  2.  * MandelVroom 2.0
  3.  *
  4.  * (c) Copyright 1987,1989  Kevin L. Clague, San Jose, CA
  5.  *
  6.  * All rights reserved.
  7.  *
  8.  * Permission is hereby granted to distribute this program's source
  9.  * executable, and documentation for non-comercial purposes, so long as the
  10.  * copyright notices are not removed from the sources, executable or
  11.  * documentation.  This program may not be distributed for a profit without
  12.  * the express written consent of the author Kevin L. Clague.
  13.  *
  14.  * This program is not in the public domain.
  15.  *
  16.  * Fred Fish is expressly granted permission to distribute this program's
  17.  * source and executable as part of the "Fred Fish freely redistributable
  18.  * Amiga software library."
  19.  *
  20.  * Permission is expressly granted for this program and it's source to be
  21.  * distributed as part of the Amicus Amiga software disks, and the
  22.  * First Amiga User Group's Hot Mix disks.
  23.  *
  24.  * contents:  this file contains tools to allocate and free gadgets and
  25.  * gadget imagery for MandelVroom.
  26.  */
  27.  
  28. #include "mandp.h"
  29.  
  30. #define TOP 1
  31. #define BOT 2
  32.  
  33. /*************************************************************************
  34.  *
  35.  * Allocate and ititialize gadget tools
  36.  *
  37.  ************************************************************************/
  38.  
  39. /*
  40.  * Make a generic boolean gadget
  41.  */
  42. struct Gadget *MakeBool(x,y,xd,yd,c,id, flags)
  43.   SHORT  x,y,xd,yd;
  44.   UBYTE  c;
  45.   USHORT id;
  46.   USHORT flags;
  47. {
  48.   register struct Gadget *NewGadget;
  49.   register struct Image  *NewImage,*ShadowImage;
  50.  
  51.   NewGadget = (struct Gadget *)
  52.     safeAllocMem( (ULONG) sizeof(struct Gadget), (LONG) MEMF_CLEAR );
  53.  
  54.   if (NewGadget == NULL) return( NewGadget );
  55.  
  56.   if ( flags & GADGIMAGE ) {
  57.  
  58.     NewImage = (struct Image *)
  59.       safeAllocMem( (ULONG) sizeof(struct Image), (LONG) MEMF_CLEAR );
  60.  
  61.     if ( NewImage == NULL ) {
  62.       FreeMem( (char *) NewGadget, (LONG) sizeof(struct Gadget));
  63.       return( NULL );
  64.     }
  65.  
  66.     ShadowImage = (struct Image *)
  67.       safeAllocMem( (ULONG) sizeof(struct Image), (LONG) MEMF_CLEAR );
  68.  
  69.     if ( ShadowImage == NULL ) {
  70.       FreeImage( NewImage );
  71.       FreeMem( (char *) NewGadget, (LONG) sizeof(struct Gadget));
  72.       return( NULL );
  73.     }
  74.  
  75.     NewImage->Width = xd;
  76.     NewImage->Height = yd;
  77.     NewImage->PlaneOnOff = c;
  78.  
  79.     ShadowImage->LeftEdge = 1 + XScale;
  80.     ShadowImage->TopEdge = 1 + YScale;
  81.     ShadowImage->Width = xd;
  82.     ShadowImage->Height = yd;
  83.     ShadowImage->PlaneOnOff = SHADOWPEN;
  84.     ShadowImage->NextImage = NewImage;
  85.  
  86.     NewGadget->GadgetRender = (APTR) ShadowImage;
  87.  
  88.   } else {
  89.  
  90.     NewGadget->GadgetRender = (APTR)
  91.                               ShadowBorder( BEVELEDUP, 1, 1, xd-1, yd-1 );
  92.   }
  93.  
  94.   NewGadget->LeftEdge = x;
  95.   NewGadget->TopEdge  = y;
  96.   NewGadget->Width    = xd;
  97.   NewGadget->Height   = yd;
  98.   NewGadget->Flags    = GADGHCOMP | flags;
  99.   NewGadget->Activation = GADGIMMEDIATE;
  100.   NewGadget->GadgetType = BOOLGADGET;
  101.   NewGadget->GadgetID = id;
  102.  
  103.   return(NewGadget);
  104. } /* MakeBool */
  105.  
  106. /*
  107.  * Make a generic potentiometer gadget
  108.  */
  109. struct Gadget *MakePot(x, y, xd, yd, id, cnt)
  110.   SHORT  x,y,xd,yd;
  111.   USHORT id;
  112.   USHORT cnt;
  113. {
  114.   register struct Gadget   *NewGadget;
  115.   register struct Image    *NewImage;
  116.   register struct PropInfo *NewInfo;
  117.  
  118.   NewGadget = (struct Gadget *)
  119.     safeAllocMem( (ULONG) sizeof(struct Gadget), MEMF_CLEAR );
  120.  
  121.   if (NewGadget == NULL) goto nogadget;
  122.  
  123.   NewImage = (struct Image *)
  124.     safeAllocMem( (ULONG) sizeof(struct Image), MEMF_CLEAR );
  125.  
  126.   if (NewImage == NULL) goto noimage;
  127.  
  128.   NewInfo = (struct PropInfo *)
  129.     safeAllocMem( (ULONG) sizeof(struct PropInfo), MEMF_CLEAR );
  130.  
  131.   if (NewInfo == NULL) goto noinfo;
  132.  
  133.   NewGadget->LeftEdge = x;
  134.   NewGadget->TopEdge  = y;
  135.   NewGadget->Width    = xd;
  136.   NewGadget->Height   = yd;
  137.   NewGadget->Flags    = GADGHIMAGE | GADGIMAGE;
  138.   NewGadget->Activation   = RELVERIFY;
  139.   NewGadget->GadgetType   = PROPGADGET;
  140.   NewGadget->GadgetRender = (APTR) NewImage;
  141.   NewGadget->SpecialInfo  = (APTR) NewInfo;
  142.   NewGadget->GadgetID     = id;
  143.  
  144.   NewImage->PlaneOnOff = SHADOWPEN;
  145.   NewImage->Width  = 4 << XScale;
  146.   NewImage->Height = 3 << YScale;
  147.  
  148.   NewInfo->Flags = PROPBORDERLESS | FREEVERT;
  149.   NewInfo->VertBody = 1;
  150.  
  151.   return(NewGadget);
  152.  
  153. noinfo:
  154.   FreeMem( (char *) NewImage,  (LONG) sizeof(struct Image));
  155.  
  156. noimage:
  157.   FreeMem( (char *) NewGadget, (LONG) sizeof(struct Gadget));
  158.  
  159. nogadget:
  160.   return( NULL );
  161. } /* MakePot */
  162.  
  163. /*
  164.  * Make a generic string gadget
  165.  */
  166. struct Gadget *MakeString( x, y, length, id, String )
  167.   SHORT  x,y,length;
  168.   USHORT id;
  169.   char *String;
  170. {
  171.   register struct Gadget     *NewGadget;
  172.   register struct StringInfo *NewString;
  173.   register struct Border     *Border;
  174.  
  175.   register char *NewBuffer;
  176.  
  177.   NewGadget = (struct Gadget *)
  178.     safeAllocMem( (ULONG) sizeof(struct Gadget), (LONG) MEMF_CLEAR );
  179.  
  180.   if ( NewGadget == NULL ) goto nogadget;
  181.  
  182.   NewString = (struct StringInfo *)
  183.     safeAllocMem( (ULONG) sizeof(struct StringInfo), (LONG) MEMF_CLEAR );
  184.  
  185.   if (NewString == NULL) goto nostring;
  186.  
  187.   NewBuffer = (char *) safeAllocMem( (ULONG) length + 1, (LONG) MEMF_CLEAR );
  188.  
  189.   if (NewBuffer == NULL) goto nobuffer;
  190.  
  191.   Border = ShadowBorder( BEVELEDDOWN, -1, -1, length * 8 + 1, 9 );
  192.  
  193.   NewGadget->LeftEdge = x;
  194.   NewGadget->TopEdge  = y;
  195.   NewGadget->Width    = length * 8;
  196.   NewGadget->Height   = 8;
  197.   NewGadget->Flags    = GADGHCOMP;
  198.   NewGadget->Activation = STRINGRIGHT;
  199.   NewGadget->GadgetType = STRGADGET;
  200.   NewGadget->GadgetID = id;
  201.   NewGadget->GadgetRender = (APTR) Border;
  202.   NewGadget->SpecialInfo  = (APTR) NewString;
  203.  
  204.   NewString->MaxChars = length + 1;
  205.   NewString->BufferPos = 0;
  206.   NewString->DispPos = 0;
  207.   NewString->Buffer = (UBYTE *) NewBuffer;
  208.  
  209.   strcpy( NewBuffer, String );
  210.  
  211.   return(NewGadget);
  212.  
  213. nobuffer:
  214.  
  215.   FreeMem( (char *) NewString, (long) sizeof( struct StringInfo ) );
  216.  
  217. nostring:
  218.  
  219.   FreeMem( (char *) NewGadget, (long) sizeof( struct Gadget ) );
  220.  
  221. nogadget:
  222.  
  223.   return( NULL );
  224.  
  225. } /* MakeString */
  226.  
  227. /*
  228.  * Free a string of gadgets
  229.  */
  230. FreeGadgets(FirstGadget)
  231.   struct Gadget *FirstGadget;
  232. {
  233.   register struct Gadget *NextGadget;
  234.   register struct StringInfo *String;
  235.   register struct Border *Render;
  236.  
  237.   while (FirstGadget) {
  238.  
  239.     Render = (struct Border *) FirstGadget->GadgetRender;
  240.  
  241.     if ( Render ) {
  242.       if (FirstGadget->Flags & GADGIMAGE) {
  243.  
  244.         FreeImage( (struct Inage *) Render );
  245.       } else {
  246.  
  247.         FreeBorder( Render );
  248.       }
  249.     }
  250.  
  251.     Render = (struct Border *) FirstGadget->SelectRender;
  252.  
  253.     if ( Render ) {
  254.       if (FirstGadget->Flags & GADGIMAGE) {
  255.  
  256.         FreeImage( (struct Inage *) Render );
  257.       } else {
  258.  
  259.         FreeBorder( Render );
  260.       }
  261.     }
  262.  
  263.     if (FirstGadget->SpecialInfo) {
  264.  
  265.       switch( FirstGadget->GadgetType ) {
  266.  
  267.         case PROPGADGET:
  268.              FreeMem( (char *) FirstGadget->SpecialInfo,
  269.                       (LONG) sizeof(struct PropInfo));
  270.              break;
  271.  
  272.         case STRGADGET:
  273.              String = (struct StringInfo *) FirstGadget->SpecialInfo;
  274.              FreeMem( (char *) String->Buffer, (LONG) String->MaxChars );
  275.              FreeMem( (char *) String, (LONG) sizeof(struct StringInfo));
  276.  
  277.              break;
  278.       }
  279.     }
  280.  
  281.     FreeIntui( FirstGadget->GadgetText );
  282.  
  283.     NextGadget = FirstGadget->NextGadget;
  284.  
  285.     FreeMem( (char *) FirstGadget, (LONG) sizeof(struct Gadget));
  286.  
  287.     FirstGadget = NextGadget;
  288.   }
  289. } /* FreeGadgets */
  290.  
  291. FreeImage( Image )
  292.   struct Image *Image;
  293. {
  294.   register struct Image *image, *next;
  295.  
  296.   next = Image;
  297.  
  298.   while ( image = next ) {
  299.  
  300.     next = image->NextImage;
  301.  
  302.     FreeMem( (char *) image, (LONG) sizeof(struct Image));
  303.   }
  304. }
  305.  
  306. struct Border *
  307. MakeShadow( pen, numverts )
  308.   LONG pen;
  309.   int numverts;
  310. {
  311.   register struct Border *NewBorder;
  312.   register SHORT *NewCounts;
  313.  
  314.   NewBorder = (struct Border *)
  315.     safeAllocMem( (ULONG) sizeof(struct Border), (LONG) MEMF_CLEAR );
  316.  
  317.   if (NewBorder == NULL) return( NULL );
  318.  
  319.   NewCounts = (SHORT *)
  320.     safeAllocMem( (ULONG) sizeof(SHORT) * 2 * numverts, (LONG) MEMF_CLEAR );
  321.  
  322.   if (NewCounts == NULL) {
  323.     FreeMem( (char *) NewBorder, (LONG) sizeof(struct Border) );
  324.     return( NULL );
  325.   }
  326.  
  327.   NewBorder->FrontPen = pen;
  328.   NewBorder->DrawMode = JAM1;
  329.   NewBorder->XY       = NewCounts;
  330.   NewBorder->Count    = numverts;
  331.  
  332.   return( NewBorder );
  333. }
  334.  
  335. /*
  336.  * Make an Border structure
  337.  */
  338. static struct Border *
  339. MakeCornerShadow( Type, left, top, Width, Height, pen )
  340.  
  341.            LONG Type;
  342.   register LONG left,  top;
  343.            LONG Width, Height;
  344.            LONG pen;
  345. {
  346.   register struct Border *NewBorder;
  347.   register SHORT *NewCounts;
  348.  
  349.   register LONG right = left + Width;
  350.   register LONG bot   = top + Height;
  351.            LONG cornerx;
  352.            LONG cornery;
  353.            LONG direction;
  354.  
  355. #define NUMVERTS 6
  356.  
  357.   NewBorder = MakeShadow( pen, NUMVERTS );
  358.  
  359.   if (NewBorder == NULL) return( NewBorder );
  360.  
  361.   if ( Type == TOP ) {
  362.     cornerx = left;  cornery = top; direction = -1;
  363.   } else {
  364.     cornerx = right; cornery = bot; direction =  1;
  365.   }
  366.  
  367.   NewCounts = NewBorder->XY;
  368.  
  369.   *NewCounts++ = left;    *NewCounts++ = bot;
  370.   *NewCounts++ = cornerx; *NewCounts++ = cornery;
  371.   *NewCounts++ = right;   *NewCounts++ = top;
  372.  
  373.   left--; top--; bot++; right++;
  374.   cornerx += direction; cornery += direction;
  375.  
  376.   *NewCounts++ = right;   *NewCounts++ = top;
  377.   *NewCounts++ = cornerx; *NewCounts++ = cornery;
  378.   *NewCounts++ = left;    *NewCounts++ = bot;
  379.  
  380.   return( NewBorder );
  381. } /* MakeCornerShadow */
  382.  
  383. struct Border *
  384. ShadowBorder( Type, left, top, xdim, ydim )
  385.   int Type;
  386.   int left, top;
  387.   int xdim, ydim;
  388. {
  389.   register struct Border *Border1, *Border2;
  390.   register int            Pen1,     Pen2;
  391.  
  392.   if (Type == BEVELEDUP) {
  393.     Pen1 = HIGHLIGHTPEN; Pen2 = SHADOWPEN;
  394.   } else {
  395.     Pen2 = HIGHLIGHTPEN; Pen1 = SHADOWPEN;
  396.   }
  397.  
  398.   Border1 = MakeCornerShadow( (long) TOP,  (long) left, (long) top,
  399.                               (long) xdim, (long) ydim, (long) Pen1 );
  400.  
  401.   if ( Border1 ) {
  402.  
  403.     Border2 = MakeCornerShadow( (long) BOT,  (long) left, (long) top,
  404.                                 (long) xdim, (long) ydim, (long) Pen2 );
  405.     Border1->NextBorder = Border2;
  406.   }
  407.  
  408.   return( Border1 );
  409. }
  410.  
  411. FreeBorder( Border )
  412.   struct Border *Border;
  413. {
  414.   register struct Border *border, *next;
  415.  
  416.   next = Border;
  417.  
  418.   while ( border = next ) {
  419.  
  420.     next = border->NextBorder;
  421.  
  422.     FreeMem( (char *) border->XY, (LONG) sizeof(SHORT) * border->Count * 2);
  423.     FreeMem( (char *) border,     (LONG) sizeof(struct Border));
  424.   }
  425. }
  426.  
  427.  
  428.  
  429. /*
  430.  * Make an IntuiText structure
  431.  */
  432. struct IntuiText *MakeIntui(str, x, y, frontpen, backpen, drawmode )
  433.   char *str;
  434.   LONG  x, y;
  435.   LONG  frontpen, backpen;
  436.   LONG  drawmode;
  437. {
  438.   register struct IntuiText *NewIntui;
  439.   register char  *NewString;
  440.  
  441.   NewIntui = (struct IntuiText *)
  442.     safeAllocMem( (ULONG) sizeof(struct IntuiText), (LONG) MEMF_CLEAR );
  443.  
  444.   if ( NewIntui == NULL ) return( NULL );
  445.  
  446.   NewString = (char *)
  447.     safeAllocMem( (ULONG) strlen( str ) + 1, (LONG) MEMF_CLEAR );
  448.  
  449.   if ( NewString == NULL ) {
  450.     FreeMem( (char *) NewIntui, (long) sizeof(struct IntuiText) );
  451.     return( NULL );
  452.   }
  453.  
  454.   NewIntui->FrontPen = frontpen;
  455.   NewIntui->BackPen  = backpen;
  456.   NewIntui->DrawMode = drawmode;
  457.   NewIntui->LeftEdge = x;
  458.   NewIntui->TopEdge  = y;
  459.   NewIntui->IText = (UBYTE *) NewString;
  460.  
  461.   strcpy( NewString, str );
  462.  
  463.   return(NewIntui);
  464. } /* MakeIntui */
  465.  
  466. struct IntuiText *
  467. ShadowIntui( str, x, y )
  468.   char *str;
  469.   LONG x,y;
  470. {
  471.   register struct IntuiText *Intui1, *Intui2, *Intui3;
  472.  
  473.   Intui1 = MakeIntui( str,  x,     y,     NORMALPEN, NORMALPEN, JAM2 );
  474.   Intui2 = MakeIntui( str,  x + 1, y + 1, SHADOWPEN, NORMALPEN, JAM2 );
  475.   Intui3 = MakeIntui( str,  x,     y,     MEDIUMPEN, (long) 0,  JAM1 );
  476.  
  477.   Intui1->NextText = Intui2;
  478.   Intui2->NextText = Intui3;
  479.  
  480.   return( Intui1 );
  481. }
  482.  
  483. FreeIntui( Intui )
  484.   struct IntuiText *Intui;
  485. {
  486.   register struct IntuiText *intui, *next;
  487.  
  488.   next = Intui;
  489.  
  490.   while ( intui = next ) {
  491.  
  492.     next = intui->NextText;
  493.  
  494.     FreeMem( (char *) intui->IText, (long) strlen((char *)intui->IText) + 1);
  495.     FreeMem( (char *) intui, (LONG) sizeof(struct IntuiText));
  496.   }
  497. }
  498.  
  499. #if 0
  500. struct Border *
  501. MakeWindowBorder( NewWindow )
  502.   register struct NewWindow *NewWindow;
  503. {
  504.   register struct Border *Border1,*Border2;
  505.   register SHORT  *Verts;
  506.   register SHORT  Bottom, Right;
  507.  
  508.   Border1 = MakeShadow( HIGHLIGHTPEN, 2 );
  509.  
  510.   if (Border1 == NULL)
  511.     return NULL;
  512.  
  513.   Border2 = MakeShadow( SHADOWPEN, 3 );
  514.  
  515.   if (Border2 == NULL) {
  516.     FreeBorder( Border1 );
  517.     return NULL;
  518.   }
  519.  
  520.   Bottom = NewWindow->Height - 1;
  521.   Right  = NewWindow->Width  - 1;
  522.  
  523.   Verts = Border1->XY;
  524.  
  525.   /* Vertex.X        Vertext.Y */
  526.  
  527.   *Verts++ = 0;     *Verts++ = TOPMARG;
  528.   *Verts++ = 0;     *Verts++ = Bottom;
  529.  
  530.   Verts = Border2->XY;
  531.  
  532.   /* Vertex.X        Vertext.Y */
  533.  
  534.   *Verts++ = 0;     *Verts++ = Bottom;
  535.   *Verts++ = Right; *Verts++ = Bottom;
  536.   *Verts++ = Right; *Verts++ = TOPMARG - 1;
  537.  
  538.   Border1->NextBorder = Border2;
  539.  
  540.   return( Border1 );
  541. }
  542. #endif
  543.