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

#include "cdseditprefs.h"

extern struct IntuiMessage *GetMsg();
extern struct Window	    *OpenWindow();

static char* PrefsFile = "cdsedit.prefs";
static struct IntuiMessage *Msg;

#define PREFSTITLE (UBYTE*)"         Cul-de-sac Preferences 1.0  ((C) 1991 HBA)"

#define CGW		32

#define FCOL 1
#define BCOL 0

#define F1COL	1
#define	B1COL	0
#define	F2COL	3
#define	B2COL	0

#define GFCOL 1
#define GBCOL 0

#define WFCOL 1
#define WBCOL 3

#define COLGW  16
#define NUMCOL 8

static char  *ColText = "  ";

static SHORT  ColPairs[] = { 0,0,COLGW+1,0,COLGW+1,9,0,9,0,0 };

static struct Border    ColBorder = {-1,-1,FCOL,BCOL,JAM2,5,ColPairs,0L};

static struct IntuiText ColStr[NUMCOL];

static struct Gadget    ColGadget[NUMCOL];

#define YESGADGET 	1 + NUMCOL
#define YGW		32

static SHORT  Yes1Pairs[] = { 0,0,YGW+1,0,YGW+1,9};
static SHORT  Yes2Pairs[] = { 0,0,0,9,YGW+1,9 };

static struct Border    Yes1Border = {-1,-1,F2COL,B2COL,JAM2,3,Yes1Pairs,0L};
static struct Border    Yes2Border = {-1,-1,F1COL,B1COL,JAM2,3,Yes2Pairs,&Yes1Border};

static struct IntuiText YesStr = { FCOL,BCOL,JAM2,0,0,0L,
                                   (UBYTE*)" OK ",0L};

static struct Gadget    YesGadget = { &ColGadget[0],10,190,
                                       YGW,8,GADGHCOMP,
                                   GADGIMMEDIATE|RELVERIFY,BOOLGADGET,
                                   (APTR)&Yes2Border,0L,
                                   &YesStr,0L,0L,YESGADGET,0L};

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

#define NOGADGET 	2 + NUMCOL
#define NGW		72

static SHORT  No1Pairs[] = { 0,0,NGW+1,0,NGW+1,9 };
static SHORT  No2Pairs[] = { 0,0,0,9,NGW+1,9};

static struct Border    No1Border = {-1,-1,F2COL,B2COL,JAM2,3,No1Pairs,0L};
static struct Border    No2Border = {-1,-1,F1COL,B1COL,JAM2,3,No2Pairs,&No1Border};

static struct IntuiText NoStr = { FCOL,BCOL,JAM2,0,0,0L,(UBYTE*)" Abbruch ",0L};

static struct Gadget    NoGadget = { &YesGadget,480-NGW-10,190,NGW,8,GADGHCOMP,
                                   GADGIMMEDIATE|RELVERIFY,BOOLGADGET,
                                   (APTR)&No2Border,0L,
                                   &NoStr,0L,0L,NOGADGET,0L};

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

#define RESETGADGET 	NOGADGET+1
#define RGW		112

static SHORT  Reset1Pairs[] = { 0,0,RGW+1,0,RGW+1,9};
static SHORT  Reset2Pairs[] = { 0,0,0,9,RGW+1,9};

static struct Border    Reset1Border = {-1,-1,F2COL,B2COL,JAM2,3,Reset1Pairs,0L};
static struct Border    Reset2Border = {-1,-1,F1COL,B1COL,JAM2,3,Reset2Pairs,&Reset1Border};

static struct IntuiText ResetStr = { FCOL,BCOL,JAM2,0,0,0L,
                                     (UBYTE*)" Zurücksetzen ",0L};

static struct Gadget    ResetGadget = { &NoGadget,140,190,RGW,8,GADGHCOMP,
                                   GADGIMMEDIATE|RELVERIFY,BOOLGADGET,
                                   (APTR)&Reset2Border,0L,
                                   &ResetStr,0L,0L,RESETGADGET,0L};


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

#define REDGADGET RESETGADGET + 1

static struct PropInfo RedInfo = { AUTOKNOB|FREEVERT,0,0,0,0x1000,
                                     0,0,0,0x1000,0,0};

static struct IntuiText RedTxt = {FCOL,BCOL,JAM2,6,-12,0L,
                                    (UBYTE*)"R",0L};
 
static struct Image RedImg;

static struct Gadget RedGadget = {
    &ResetGadget,20,75,20,100,
    GADGHCOMP, 
    GADGIMMEDIATE|RELVERIFY,
    PROPGADGET,(APTR)&RedImg, 0L,&RedTxt,0L,
    (APTR)&RedInfo, REDGADGET, 0L
};

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

#define GREENGADGET REDGADGET +1 

static struct PropInfo GreenInfo = { AUTOKNOB|FREEVERT,0,0,0,0x1000,
                                     0,0,0,0x1000,0,0};

static struct IntuiText GreenTxt = {FCOL,BCOL,JAM2,6,-12,0L,
                                    (UBYTE*)"G",0L};
 
static struct Image GreenImg;

static struct Gadget GreenGadget = {
    &RedGadget,50,75,20,100,
    GADGHCOMP, 
    GADGIMMEDIATE|RELVERIFY,
    PROPGADGET,(APTR)&GreenImg, 0L,&GreenTxt,0L,
    (APTR)&GreenInfo, GREENGADGET, 0L
};

/* -------------------------------------------------------------- */
#define BLUEGADGET GREENGADGET + 1

static struct PropInfo BlueInfo = { AUTOKNOB|FREEVERT,0,0,0,0x1000,
                                     0,0,0,0x1000,0,0};

static struct IntuiText BlueTxt = {FCOL,BCOL,JAM2,6,-12,0L,
                                    (UBYTE*)"B",0L};
 
static struct Image BlueImg;

static struct Gadget BlueGadget = {
    &GreenGadget,80,75,20,100,
    GADGHCOMP, 
    GADGIMMEDIATE|RELVERIFY,
    PROPGADGET,(APTR)&BlueImg, 0L,&BlueTxt,0L,
    (APTR)&BlueInfo, BLUEGADGET, 0L
};

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

static UBYTE UNDO_BUFFER[PATHLEN+1];

#define INPUTGADGET   BLUEGADGET + 1

#define NUMGADFCOL    1
#define NUMGADBCOL    0

static struct IntuiText InputGadgetText = {NUMGADFCOL,NUMGADBCOL,
                                    JAM2,-120,0,0L,(UBYTE*)"Pfad Laden",0L};

static UBYTE  InputGadgetString[PATHLEN+1] = "";

static struct StringInfo InputGadgetSInfo =
                   {InputGadgetString,UNDO_BUFFER,0,PATHLEN,0,0,0,0,0,0,0L,0L,0L};
                   

static SHORT InputGadget1Pairs[] = { 0,0,PATHLEN * 8+1,0,PATHLEN * 8+1,9};
static SHORT InputGadget2Pairs[] = { 0,0,0,9,PATHLEN * 8+1,9};

static struct Border InputGadget1Border = { -1,-1,F1COL,B1COL,JAM2,
                                            3,InputGadget1Pairs,0L};
static struct Border InputGadget2Border = { -1,-1,F2COL,B2COL,JAM2,
                                            3,InputGadget2Pairs,&InputGadget1Border};

static struct Gadget InputGadget = {
     &BlueGadget,130,22,PATHLEN*8,8,GADGHCOMP, 
     RELVERIFY, STRGADGET,(APTR)&InputGadget2Border,0L,
     &InputGadgetText,0L,(APTR)&InputGadgetSInfo, INPUTGADGET,0L};

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

#define GAMESGADGET INPUTGADGET + 1

static struct IntuiText GamesGadgetText = {NUMGADFCOL,NUMGADBCOL,
                                    JAM2,-120,0,0L,(UBYTE*)"Pfad Sichern",0L};

static UBYTE  GamesGadgetString[PATHLEN+1] = "";

static struct StringInfo GamesGadgetSInfo =
                   {GamesGadgetString,UNDO_BUFFER,0,PATHLEN,0,0,0,0,0,0,0L,0L,0L};
                   

static struct Gadget GamesGadget = {
     &InputGadget,130,36,PATHLEN*8,8,GADGHCOMP, 
     RELVERIFY, STRGADGET,(APTR)&InputGadget2Border,0L,
     &GamesGadgetText,0L,(APTR)&GamesGadgetSInfo, GAMESGADGET,0L};

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

static UBYTE UNDO_BUFFER2[PATHLEN+1];

#define LVXTGADGET   GAMESGADGET + 1

static struct IntuiText lvxtGadgetText = 
       {NUMGADFCOL,NUMGADBCOL,JAM2,-120,0,0L,(UBYTE*)"Level Maske",0L};

static UBYTE  lvxtGadgetString[PATHLEN+1] = "";

static struct StringInfo lvxtGadgetSInfo =
                   {lvxtGadgetString,UNDO_BUFFER2,0,PATHLEN,0,0,0,0,0,0,0L,0L,0L};
                   
static struct Gadget lvxtGadget = {
     &GamesGadget,130,50,PATHLEN*8,8,GADGHCOMP, 
     RELVERIFY, STRGADGET,(APTR)&InputGadget2Border,0L,
     &lvxtGadgetText,0L,(APTR)&lvxtGadgetSInfo, LVXTGADGET,0L};

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

#define SOUNDGADGET 	LVXTGADGET + 1

#define BFCOL		1
#define BBCOL		0

#define KFCOL           6
#define KBCOL		0

static SHORT  SoundPairs[] = {-1,-1,8,-1,8,8,-1,8,-1,-1 };

static struct Border    SoundBorder = {0,0,BFCOL,BBCOL,JAM2,5,SoundPairs,0L};

static struct IntuiText SoundStr1 = 
       { KFCOL,KBCOL,JAM2,16,1,0L,(UBYTE*)" Sound ",0L};
static struct IntuiText SoundStr2 = 
      { FCOL,BCOL,JAM2,0,0,0L,(UBYTE*)" ",&SoundStr1};

static struct Gadget    SoundGadget = { &lvxtGadget,270,120,8,8,GADGHCOMP,
                                   GADGIMMEDIATE|RELVERIFY|TOGGLESELECT,
                                   BOOLGADGET,
                                   (APTR)&SoundBorder,0L,
                                   &SoundStr2,0L,0L,SOUNDGADGET,0L};

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

static struct NewWindow SetPrefsW = {80,30,480,220,WFCOL,WBCOL,
                                REFRESHWINDOW|GADGETUP|GADGETDOWN|
                                ACTIVEWINDOW,ACTIVATE,&SoundGadget,0L,
                                PREFSTITLE,0L,0L,0,0,0,0,CUSTOMSCREEN};


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

static struct CDSEditPrefs LocalPrefs;

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

static void CopyPrefs(p1,p2)

register struct CDSEditPrefs *p1,*p2;

{
 register int i;
 
 for (i = 0; i < NUMCOL; i++)
     {
      p2->red[i]   = p1->red[i];
      p2->green[i] = p1->green[i];
      p2->blue[i]  = p1->blue[i];
     }
 p2->sound = p1->sound;
 sprintf(p2->lvxt,"%s",p1->lvxt);
 sprintf(p2->path,"%s",p1->path);
 sprintf(p2->topath,"%s",p1->topath);
}


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


BOOL ReadPrefs(p)

struct CDSEditPrefs *p;

{
 FILE *f;
 
 if (!(f = fopen(PrefsFile,"r")))
    {
     ClearPrefs(p);
     return(FALSE);
    }
    
 fread((char*)p,sizeof(struct CDSEditPrefs),1,f);
 
 fclose(f);
 return(TRUE);
}

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

static void WritePrefs(p)

struct CDSEditPrefs *p;

{
 FILE *f;
 
 f = fopen(PrefsFile,"w");
 
 fwrite((char*)p,sizeof(struct CDSEditPrefs),1,f);
 
 fclose(f);
}

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

void SetCDSEditPrefs(p,v)

struct CDSEditPrefs *p;
struct ViewPort *v;

{
 register int i;
 
 for (i = 0; i < 8; i++)
     {
     SetRGB4(v,(LONG)i,(LONG)p->red[i],
                       (LONG)p->green[i],
                       (LONG)p->blue[i]);
     }
}

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

static ClearPrefs(p)

struct CDSEditPrefs *p;

{
 p->red[0]   = 0;
 p->green[0] = 0;
 p->blue[0]  = 0;

 p->red[1]   = 15;
 p->green[1] = 15;
 p->blue[1]  = 15;

 p->red[2]   = 0;
 p->green[2] = 0;
 p->blue[2]  = 14;
 
 p->red[3]   = 10;
 p->green[3] = 0;
 p->blue[3]  = 8;
 
 p->red[4]   = 6;
 p->green[4] = 3;
 p->blue[4]  = 3;

 p->red[5]   = 12;
 p->green[5] = 0;
 p->blue[5]  = 0;

 p->red[6]   = 0;
 p->green[6] = 12;
 p->blue[6]  = 0;

 p->red[7]   = 12;
 p->green[7] = 10;
 p->blue[7]  = 10;

 sprintf(p->path,"CDS:CDS_Levels");
 sprintf(p->topath,"CDS:Games");
 sprintf(p->lvxt,"Level_");
 p->sound        = TRUE;
}

/* ----------------------------------------------------------------- */
 
static void SetUpGadgets(p)

struct CDSEditPrefs *p;

{
  register int    i;
  
  for (i = 0; i < NUMCOL; i++)
      {
       ColGadget[i].LeftEdge = 150 + 25 * (i / 4);
       ColGadget[i].TopEdge  = 80  + 25 * (i % 4);
       ColGadget[i].Width    = COLGW;
       ColGadget[i].Height   = 8;
       if (i != (NUMCOL-1)) 
       	  ColGadget[i].NextGadget = &ColGadget[i+1];
       else
          ColGadget[i].NextGadget = 0L;
       ColGadget[i].Flags        = GADGHCOMP;
       ColGadget[i].Activation   = GADGIMMEDIATE|RELVERIFY;
       ColGadget[i].GadgetType   = BOOLGADGET;
       ColGadget[i].GadgetRender = (APTR)&ColBorder;
       ColGadget[i].SelectRender = 0L;
       ColGadget[i].GadgetText	 = &ColStr[i];
       ColGadget[i].SpecialInfo  = 0L;
       ColGadget[i].UserData	=  0L;
       ColGadget[i].GadgetID	=  i;
       
       ColStr[i].FrontPen	= (UBYTE)i;
       ColStr[i].BackPen	= (UBYTE)i;
       ColStr[i].DrawMode	= JAM2;
       ColStr[i].LeftEdge	= 0;
       ColStr[i].TopEdge	= 0;
       ColStr[i].ITextFont	= 0L;
       ColStr[i].IText		= (UBYTE*)ColText;
       ColStr[i].NextText	= 0L;
      }
 sprintf(InputGadgetString,"%s",p->path);       
 sprintf(GamesGadgetString,"%s",p->topath);       
 sprintf(lvxtGadgetString,"%s",p->lvxt);       
 if (p->sound)
    SoundGadget.Flags |= SELECTED;
 else
    SoundGadget.Flags &= (~SELECTED);
           
}

static SetColorGadgets(r,g,b)

int r,g,b;

{
 RedInfo.VertPot     = (USHORT)((4095L * (LONG)r) & 0xFFFF);
 GreenInfo.VertPot   = (USHORT)((4095L * (LONG)g) & 0xFFFF);
 BlueInfo.VertPot    = (USHORT)((4095L * (LONG)b) & 0xFFFF);
}
 

void EditCDSEditPrefs(S,p,v)

struct Screen   *S;
struct CDSEditPrefs *p;
struct ViewPort *v;
  
{ ULONG  Class;
  USHORT Code; 
  BOOL   Ende,TakeIt;
  int    GadID,pos,x,y,i,col;
  
  struct Gadget *igad;
  struct Window *W;


  Ende             = FALSE;
  SetPrefsW.Screen = S;  

  CopyPrefs(p,&LocalPrefs);  
  SetUpGadgets(&LocalPrefs);
  SetColorGadgets(LocalPrefs.red[0],
                  LocalPrefs.green[0],
                  LocalPrefs.blue[0]);
  col = 0;

  if (!(W = OpenWindow(&SetPrefsW)))
     return();

  RefreshGadgets(&SoundGadget,W,0L);

  while (!Ende)
  {
   Msg = GetMsg(W->UserPort);
   if (Msg != 0L)
            {
            Class = Msg->Class;
            Code  = Msg->Code;
            ReplyMsg(Msg);
            switch (Class) {
               case GADGETUP    :
                    igad  = (struct Gadget*)Msg->IAddress;
               	    GadID = igad->GadgetID;
               	    if (GadID < NUMCOL) 
               	       {
               	        col = GadID;
               	        SetColorGadgets(LocalPrefs.red[GadID],
               	                        LocalPrefs.green[GadID],
               	                        LocalPrefs.blue[GadID]);
                        RefreshGadgets(&SoundGadget,W,0L);
                        break;
                       }
               	        
               	    switch (GadID) {
               	           case RESETGADGET:
               	                ClearPrefs(&LocalPrefs);
               	                SetCDSEditPrefs(&LocalPrefs,v);
               	                SetUpGadgets(&LocalPrefs);
             	                SetColorGadgets(LocalPrefs.red[col],
               	                        LocalPrefs.green[col],
               	                        LocalPrefs.blue[col]);
                                RefreshGadgets(&SoundGadget,W,0L);
                                break;
               	                
               	           case YESGADGET:
               	                TakeIt = TRUE;
               	                Ende   = TRUE;
               	                break;
               	           
               	           case NOGADGET:
               	                TakeIt = FALSE;
               	           	Ende   = TRUE;
				break;
				
		           case REDGADGET:
		                LocalPrefs.red[col] = 
		                ((RedInfo.VertPot & 0xf000) >> 12);
  	                        SetCDSEditPrefs(&LocalPrefs,v);
				break;
				
		           case GREENGADGET:
		                LocalPrefs.green[col] = 
		                ((GreenInfo.VertPot & 0xf000) >> 12);
  	                        SetCDSEditPrefs(&LocalPrefs,v);
				break;
				
		           case BLUEGADGET:
		                LocalPrefs.blue[col] = 
		                ((BlueInfo.VertPot & 0xf000) >> 12);
  	                        SetCDSEditPrefs(&LocalPrefs,v);
				break;
		                               	           	
		 	   default:
		 	        break;
		           }
		    break;
		default:
		    break;
                    
               }
          }
   }
 CloseWindow(W);
 if (TakeIt)
    {
     sprintf(LocalPrefs.path,"%s",InputGadgetString);       
     sprintf(LocalPrefs.topath,"%s",GamesGadgetString);       
     sprintf(LocalPrefs.lvxt,"%s",lvxtGadgetString);        
     if ((SoundGadget.Flags & SELECTED) != 0)
        LocalPrefs.sound = TRUE;
     else
        LocalPrefs.sound = FALSE;

     CopyPrefs(&LocalPrefs,p);
     WritePrefs(p);
     SetCDSEditPrefs(p,v);
    }
 else
    SetCDSEditPrefs(p,v);
}