
/*-----------------------------------------------------------------------
                          Testbild

                         Rainer Stork
                        Krefelder Str.5
                         4044 Kaarst 2
                       Tel. 02101/511027

-----------------------------------------------------------------------*/

#include <exec/types.h>
#include <graphics/gfxmacros.h>
#include <intuition/intuition.h>

long *OpenLibrary();

struct IntuitionBase *IntuitionBase;
struct GfxBase *GfxBase;



/*----------------------------------------------------------------------
                   Bildschirm öffnen
----------------------------------------------------------------------*/
struct Screen *OeffneScreen(mode,bitPlanes)
SHORT mode,bitPlanes;
{
   struct NewScreen NewScreen;


   if (mode == 0)
   {
      NewScreen.ViewModes = 0;
      NewScreen.Width = 320;
      NewScreen.Height = 256;
   }
   else if (mode == 1)
   {
      NewScreen.ViewModes = LACE;
      NewScreen.Width = 320;
      NewScreen.Height = 512;
   }
   else if (mode == 2)
   {
      NewScreen.ViewModes = HIRES;
      NewScreen.Width = 640;
      NewScreen.Height = 256;
      if (bitPlanes == 5)
         bitPlanes = 4;
   }
   else if (mode == 3)
   {
      NewScreen.ViewModes = HIRES | LACE;
      NewScreen.Width = 640;
      NewScreen.Height = 512;
      if (bitPlanes == 5)
         bitPlanes = 4;
   }
   else
   {
      return(NULL);
   }


   NewScreen.LeftEdge     = 0;
   NewScreen.TopEdge      = 0;
   NewScreen.Depth        = bitPlanes;
   NewScreen.DetailPen    = 0;
   NewScreen.BlockPen     = 0;
   NewScreen.Type         = CUSTOMSCREEN;
   NewScreen.Font         = NULL;
   NewScreen.DefaultTitle = (UBYTE *)"Farbtest";
   NewScreen.Gadgets      = NULL;
   NewScreen.CustomBitMap = NULL;

   return((struct Screen *)(OpenScreen(&NewScreen)));
}

/*-------------------------------------------------------------------
   macht ein Fenster auf, das in Größe nicht verändert werden kann
-------------------------------------------------------------------*/

struct Window *Mache_Fenster(Schirm,left,top,breite,hoehe,idcmp,flags,titel,gad)
struct Screen *Schirm;        /* Zeiger auf Screen-Struktur   */
SHORT left,top,breite,hoehe;  /* Abmessungen + Lage des Fensters  */
ULONG idcmp,flags;            /* Flags des Fensters  */
STRPTR titel;                 /* Window-Titel */
struct Gadget *gad;           /* erstes User-Gadet im Window */
{
   struct NewWindow NW;

   NW.LeftEdge               = left;
   NW.TopEdge                = top;
   NW.Width                  = breite;
   NW.Height                 = hoehe;
   NW.DetailPen              = 0;
   NW.BlockPen               = 1;
   NW.IDCMPFlags             = idcmp;
   NW.Flags                  = flags;
   NW.FirstGadget            = gad;
   NW.CheckMark              = NULL;
   NW.Screen                 = Schirm;
   NW.BitMap                 = NULL;
   NW.MinWidth               = breite;
   NW.MaxWidth               = breite;
   NW.MinHeight              = hoehe;
   NW.MaxHeight              = hoehe;
   NW.Title                  = titel;
   NW.Type                   = CUSTOMSCREEN;

   return((struct Window *)OpenWindow(&NW));
}   /* Ende Mache_FIX_Fenster()  */




VOID main(argc,argv)
int argc;
char *argv[];
{
   LONG i;
   ULONG class;
   USHORT code;
   struct Gadget *gad;
   struct IntuiMessage *Nachricht;
   SHORT gadid,Planes,mode,colors;
   SHORT breite,hoehe;
   struct Screen *Schirm;
   struct Window *Fenster;

   if (argc == 3)
   {
      Planes = (SHORT)atol(argv[1]);
      mode = (SHORT)atol(argv[2]);

      if ((Planes > 5) || (Planes < 1))
      {
         printf("Falsche Zahl an Bitplanes !!\n");
         exit(20);
      }

      if ((mode > 3) || (mode < 0))
      {
         printf("Falscher Modus !!\n");
         exit(20);
      }
   }

   if ((argc == 1) || (argc == 0))
   {
      mode = 3;
      Planes = 4;
   }

   if ((argc == 2) && (argv[1][0] == '?'))
   {
      printf("USAGE  %s bitplanes mode\n",argv[0]);
      printf("bitplanes: 1 bis 5\n");
      printf("mode 0 : 320 x 256\n");
      printf("mode 1 : 320 x 512\n");
      printf("mode 2 : 640 x 256\n");
      printf("mode 3 : 640 x 512\n");
      exit(5);
   }

   if ((argc > 3) || ((argc == 2) && (argv[1][0] != '?')))
   {
      printf("Falsche Anzahl Parameter !!\n");
      exit(20);
   }



/*-----------------------------------------------------------------------
      Gfx-Library und Intuition-Library müssen geöffnet werden !!
-----------------------------------------------------------------------*/

   if ((GfxBase=(struct GfxBase *)OpenLibrary("graphics.library",0))==0)
      exit(FALSE);

   if ((IntuitionBase=(struct IntuitionBase *)OpenLibrary("intuition.library",0))==0)
   {
      CloseLibrary(GfxBase);
      exit(FALSE);
   }

   Schirm = OeffneScreen(mode,Planes);
   if (Schirm == NULL)
   {
      CloseLibrary(GfxBase);
      CloseLibrary(IntuitionBase);
      exit(FALSE);
   }

   Fenster = Mache_Fenster(Schirm,0,0,Schirm->Width,Schirm->Height,
                            VANILLAKEY,ACTIVATE+BORDERLESS,"",NULL);
   if (Fenster == NULL)
   {
      CloseScreen(Schirm);
      CloseLibrary(GfxBase);
      CloseLibrary(IntuitionBase);
      exit(FALSE);
   }

   for (i=0 ; i<10000 ; i++) ;  /* warten bis Window auf */

   DrawTestbild(mode,Fenster->RPort);

   for (;;)
   {
/*------------ schlafen bis Nachricht ankommt -------------*/
      Wait(1<<Fenster->UserPort->mp_SigBit);

      while ((Nachricht=(struct IntuiMessage *)GetMsg(Fenster->UserPort)) != 0)
      {
         ReplyMsg(Nachricht);
         class=Nachricht->Class;
         code =Nachricht->Code;
         gad=(struct Gadget *)Nachricht->IAddress;
         gadid=gad->GadgetID;

         if (class == VANILLAKEY)
         {
            if ((code == 'q') || (code == 'x'))  /* ende */
            {
               CloseWindow(Fenster);
               CloseScreen(Schirm);
               CloseLibrary(GfxBase);
               CloseLibrary(IntuitionBase);
               exit(TRUE);
            }
            if (code == 'f')  /* farbe */
            {
               Change_Color(Schirm);
               DrawTestbild(mode,Fenster->RPort);
            }
            if (code == 'r')  /* neu zeichnen */
               DrawTestbild(mode,Fenster->RPort);
         }
      }  /* Ende while */
   }  /* Ende forever */
}   /* Ende main */




DrawTestbild(Modus,rp)
SHORT Modus;
struct RastPort *rp;
{
   UWORD Patt1 = 0xaaaa;
   UWORD Patt2 = 0xffff;
   SHORT i,br,ho;
   SHORT xStep,yStep;

   if (Modus == 0)
   {
      br = 320;
      ho = 256;
   }
   if (Modus == 1)
   {
      br = 320;
      ho = 512;
   }
   if (Modus == 2)
   {
      br = 640;
      ho = 256;
   }
   if (Modus == 3)
   {
      br = 640;
      ho = 512;
   }

   SetAPen(rp,0);
   RectFill(rp,0,0,br-1,ho-1);

   xStep = br / 20;
   yStep = ho / 16;

/*--------- Farbflächen malen ----------*/
   SetDrMd(rp,JAM1);
   for(i=3 ; i<18 ; i++)
   {
      SetAPen(rp,i-2);
      RectFill(rp,i*xStep,2*yStep,(i+1)*xStep,5*yStep);
   }
   for(i=3 ; i<18 ; i++)
   {
      SetAPen(rp,i+14);
      RectFill(rp,i*xStep,5*yStep,(i+1)*xStep,8*yStep);
   }

   SetAfPt(rp,&Patt1,0);
   for(i=3 ; i<18 ; i++)
   {
      SetAPen(rp,i-2);
      RectFill(rp,i*xStep,8*yStep,(i+1)*xStep,11*yStep);
   }
   for(i=3 ; i<18 ; i++)
   {
      SetAPen(rp,i+14);
      RectFill(rp,i*xStep,11*yStep,(i+1)*xStep,14*yStep);
   }

/*----------- Raster malen ------------*/
   SetAfPt(rp,&Patt2,0);
   SetAPen(rp,1);
   for (i=1 ; i<br ; i+=xStep)
   {
      Move(rp,i-1,0);
      Draw(rp,i-1,ho-1);
   }
   Move(rp,br-1,0);
   Draw(rp,br-1,ho-1);

   for (i=1 ; i<ho ; i+=yStep)
   {
      Move(rp,0,i-1);
      Draw(rp,br-1,i-1);
   }
   Move(rp,0,ho-1);
   Draw(rp,br-1,ho-1);

/*------------ große Kreise malen ---------------*/
   SetAPen(rp,2);
   DrawEllipse(rp,br/2,ho/2,xStep*3,yStep*3);
   SetAPen(rp,3);
   DrawEllipse(rp,br/2,ho/2,xStep*4,yStep*4);
   SetAPen(rp,4);
   DrawEllipse(rp,br/2,ho/2,xStep*7,yStep*7);
   SetAPen(rp,5);
   DrawEllipse(rp,br/2,ho/2,xStep*8,yStep*8);

/*------------ kleine Eck-Kreise malen -----------*/
   SetAPen(rp,1);
   DrawEllipse(rp,xStep*2,yStep*2,xStep,yStep);
   DrawEllipse(rp,xStep*2,yStep*2,xStep*2,yStep*2);

   DrawEllipse(rp,xStep*18,yStep*2,xStep,yStep);
   DrawEllipse(rp,xStep*18,yStep*2,xStep*2,yStep*2);

   DrawEllipse(rp,xStep*2,yStep*14,xStep,yStep);
   DrawEllipse(rp,xStep*2,yStep*14,xStep*2,yStep*2);

   DrawEllipse(rp,xStep*18,yStep*14,xStep,yStep);
   DrawEllipse(rp,xStep*18,yStep*14,xStep*2,yStep*2);

}
