/*

 The Color Commodity
 ===================

 Color manipulation and A2024 palette mapping

*/


#include "ColorPatch_GUI.h"

#define VALUE 256/100


/* Version */

UBYTE Version[]="$VER: ColorPatch 0.6b "__AMIGADATE__;

/* Prototypes */

int OpenGUI(void);
void CloseGUI(void);
void MainHandler(void);
void SaveConfig(void);
void __stdargs Error(UBYTE *Msg,...);
void UpdateColors(void);
extern long InstallPatch(void);
extern long RemovePatch(void);
long __saveds RedSlide(struct Gadget *Gadget, WORD Pos);
long __saveds GreenSlide(struct Gadget *Gadget, WORD Pos);
long __saveds BlueSlide(struct Gadget *Gadget, WORD Pos);
long __saveds ColorSlide(struct Gadget *Gadget, WORD Pos);
long __saveds ContrSlide(struct Gadget *Gadget, WORD Pos);
long __saveds BrightSlide(struct Gadget *Gadget, WORD Pos);
BOOL MatchBoolean(UBYTE *String);


/* Statics */

struct DosLibrary		*DOSBase;
struct Library			*IconBase;
struct Library			*CxBase;
struct IntuitionBase	*IntuitionBase;
struct GfxBase			*GfxBase;
struct Library			*GadToolsBase;
struct Library			*UtilityBase;
struct Library			*DiskfontBase;

struct MsgPort *mp;
CxObj *broker=NULL;
CxObj *popupfilter;
CxObj *activatefilter;

struct WBStartup *WBenchMsg;
UBYTE ProgName[100];
UBYTE IconName[128]="PROGDIR:";
struct DiskObject *DiskObject;
BOOL GUI=FALSE;
BOOL PopUpActive=TRUE;


/* Flags und Variablen im Assembler-Teil */

extern __far BOOL PatchActive;
extern __far BOOL UpdateAll;
extern __far BOOL CorA2024Active;
extern __far BOOL EmuA2024Active;
extern __far UWORD RedVal;
extern __far UWORD GreenVal;
extern __far UWORD BlueVal;
extern __far UWORD ColorVal;
extern __far UWORD ContrVal;
extern __far UWORD BrightVal;


/* Default-Werte */

WORD WindowLeft=-1;
WORD WindowTop =-1;
UWORD RedSlider=100;
UWORD GreenSlider=100;
UWORD BlueSlider=100;
UWORD ColorSlider=100;
UWORD ContrSlider=100;
UWORD BrightSlider=100;


/* Argument Array */

struct	ArgArray
{
	ULONG *aa_Priority;
	UBYTE *aa_PopKey;
	UBYTE *aa_PopUp;
};

UBYTE *Template = "CX_PRIORITY/N/K,CX_POPKEY/K,CX_POPUP/K";

UBYTE PopUpHotKey[100]="lalt a";
UBYTE ActivationHotKey[100]="ralt a";

UBYTE PatchError[]={
"Sorry, unable to remove patch!\n"
"graphics.library has been\n"
"patched by some other program.\n"
"Quit that program first and\n"
"then try again.\n"
"NOTE WELL: This would not have\n"
"happened if you had installed\n"
"the program 'SetMan' by Nicola\n"
"Salmoria. It is included in the\n"
"ColorPatch distribution archive.\n"
};


/*** Init Code ****/

LONG __saveds main(void)
{
	ULONG ReturnCode=RETURN_FAIL;
	struct Process *MyProc;
	struct RDArgs *RDArgs=NULL;
	struct ArgArray	AA = { 0,0,0 };
	UBYTE *String;
	
	struct NewBroker nb;
	UBYTE CXPriority=0;
	
	BYTE OldPri=FindTask(NULL)->tc_Node.ln_Pri;
	
	if ((MyProc=(struct Process *)FindTask(NULL))->pr_CLI==NULL)
	{
		WaitPort(&MyProc->pr_MsgPort);
		WBenchMsg=(struct WBStartup*)GetMsg(&MyProc->pr_MsgPort);
	}
	
	if (!(DOSBase=(struct DosLibrary *)OpenLibrary("dos.library",33L)))
	{
		Alert(AT_Recovery|AG_OpenLib|AO_DOSLib);
		return(RETURN_FAIL);
	}
	
	if (DOSBase->dl_lib.lib_Version<39L)
	{
		(void)Write(Output(),"This program requires OS 3.0 or newer.\n",40L);
		goto Abbruch;
	}
	
	if(!(IconBase=OpenLibrary("icon.library",39)))
	{
		Error("No icon.library!");
		goto Abbruch;
	}
	if(!(CxBase=OpenLibrary("commodities.library",39)))
	{
		Error("No commodities.library!");
		goto Abbruch;
	}
	if(!(DiskfontBase=OpenLibrary("diskfont.library",39)))
	{
		Error("No diskfont.library!");
		goto Abbruch;
	}
	if (!(GfxBase=(struct GfxBase*)OpenLibrary("graphics.library",39)))
	{
		Error("No graphics.library!");
		goto Abbruch;
	}
	if (!(UtilityBase=OpenLibrary("utility.library",39)))
	{
		Error("No utility.library!");
		goto Abbruch;
	}
	if (!(IntuitionBase=(struct IntuitionBase*)OpenLibrary("intuition.library",39)))
	{
		Error("No intuition.library!");
		goto Abbruch;
	}
	if (!(GadToolsBase=OpenLibrary("gadtools.library",39)))
	{
		Error("No gadtools.library!");
		goto Abbruch;
	}
	
	if (WBenchMsg)
	{
		CurrentDir(WBenchMsg->sm_ArgList->wa_Lock);
		if (!(DiskObject=GetDiskObjectNew(WBenchMsg->sm_ArgList->wa_Name)))
		{
			Error("Can't get disk object.");
			goto Abbruch;
		}
	}
	else
	{
		GetProgramName(ProgName,sizeof(ProgName));
		strcat(IconName,FilePart(ProgName));
		
		if (!(DiskObject=GetDiskObjectNew(IconName)))
		{
			Error("Can't get disk object.");
			goto Abbruch;
		}
	}
	if (String=FindToolType(DiskObject->do_ToolTypes,"CX_PRIORITY"))
	{
		CXPriority=atol(String);
	}
	if (String=FindToolType(DiskObject->do_ToolTypes,"CX_POPKEY"))
	{
		strcpy(PopUpHotKey,String);
	}
	if (String=FindToolType(DiskObject->do_ToolTypes,"CX_POPUP"))
	{
		PopUpActive=MatchBoolean(String);
	}
	if (String=FindToolType(DiskObject->do_ToolTypes,"WINDOW_X"))
	{
		WindowLeft=atol(String);
	}
	if (String=FindToolType(DiskObject->do_ToolTypes,"WINDOW_Y"))
	{
		WindowTop=atol(String);
	}
	if (String=FindToolType(DiskObject->do_ToolTypes,"TOOLPRI"))
	{
		FindTask(NULL)->tc_Node.ln_Pri=atol(String);
	}
	if (String=FindToolType(DiskObject->do_ToolTypes,"HOTKEY"))
	{
		strcpy(ActivationHotKey,String);
	}
	if (String=FindToolType(DiskObject->do_ToolTypes,"ACTIVE"))
	{
		PatchActive=MatchBoolean(String);
	}
	if (String=FindToolType(DiskObject->do_ToolTypes,"CA2024"))
	{
		CorA2024Active=MatchBoolean(String);
	}
	if (String=FindToolType(DiskObject->do_ToolTypes,"EA2024"))
	{
		EmuA2024Active=MatchBoolean(String);
	}
	if (String=FindToolType(DiskObject->do_ToolTypes,"RED"))
	{
		RedSlider=atol(String);
	}
	if (String=FindToolType(DiskObject->do_ToolTypes,"GREEN"))
	{
		GreenSlider=atol(String);
	}
	if (String=FindToolType(DiskObject->do_ToolTypes,"BLUE"))
	{
		BlueSlider=atol(String);
	}
	if (String=FindToolType(DiskObject->do_ToolTypes,"COLOR"))
	{
		ColorSlider=atol(String);
	}
	if (String=FindToolType(DiskObject->do_ToolTypes,"CONTR"))
	{
		ContrSlider=atol(String);
	}
	if (String=FindToolType(DiskObject->do_ToolTypes,"BRIGHT"))
	{
		BrightSlider=atol(String);
	}
	
	if (!WBenchMsg)
	{
		if (!(RDArgs=ReadArgs(Template,(LONG *)&AA,0)))
		{
			PrintFault(IoErr(),ProgName);
			goto Abbruch;
		}
		if (AA.aa_PopKey)   strcpy(PopUpHotKey,AA.aa_PopKey);
		if (AA.aa_PopUp)    PopUpActive=MatchBoolean(AA.aa_PopUp);
		if (AA.aa_Priority) CXPriority = *AA.aa_Priority;
	}
	
	if(!(mp=CreateMsgPort()))
	{
		Error("Out of Memory!");
		goto Abbruch;
	}
	
	popupfilter=CxFilter(PopUpHotKey);
	AttachCxObj(popupfilter,CxSender(mp,CXCMD_APPEAR));
	AttachCxObj(popupfilter,CxTranslate(0));
	
	activatefilter=CxFilter(ActivationHotKey);
	AttachCxObj(activatefilter,CxSender(mp,CXCMD_ENABLE));
	AttachCxObj(activatefilter,CxTranslate(0));
	
	nb.nb_Version=NB_VERSION;
	nb.nb_Name="ColorPatch";
	nb.nb_Title="ColorPatch ©1994 by Christian Buchner";
	nb.nb_Descr="Color manipulation and A2024 mapping.";
	nb.nb_Unique=NBU_UNIQUE|NBU_NOTIFY;
	nb.nb_Pri=CXPriority;
	nb.nb_Flags=COF_SHOW_HIDE;
	nb.nb_Port=mp;
	nb.nb_ReservedChannel=0;
	
	if(!(broker=CxBroker(&nb,0))) goto Abbruch;
	
	AttachCxObj(broker,popupfilter);
	AttachCxObj(broker,activatefilter);
	
	ActivateCxObj(broker,TRUE);
	
	RedVal=RedSlider*VALUE;
	GreenVal=GreenSlider*VALUE;
	BlueVal=BlueSlider*VALUE;
	ColorVal=ColorSlider*VALUE;
	ContrVal=ContrSlider*VALUE;
	BrightVal=BrightSlider*VALUE;
	
	if (!InstallPatch())
	{
		if (PatchActive) UpdateColors();
		
		if (PopUpActive) OpenGUI();
		
		for(;;)
		{
			MainHandler();
			if (RemovePatch())
			{
				Error(PatchError);
				PatchActive=FALSE;
				if (GUI) OpenGUI();
				UpdateColors();
			}
			else break;
		}
		UpdateColors();
	}
	CloseGUI();
	ReturnCode=RETURN_OK;
	
	
Abbruch:
	
	if(broker) DeleteCxObjAll(broker);
	if(mp) DeleteMsgPort(mp);
	
	
	if (DiskObject) FreeDiskObject(DiskObject);
	if (RDArgs) FreeArgs(RDArgs);
	
	if (IconBase)		CloseLibrary(IconBase);
	if (CxBase)			CloseLibrary(CxBase);
	if (DiskfontBase)	CloseLibrary(DiskfontBase);
	if (IntuitionBase)	CloseLibrary((struct Library*)IntuitionBase);
	if (GfxBase)		CloseLibrary((struct Library*)GfxBase);
	if (GadToolsBase)	CloseLibrary(GadToolsBase);
	if (UtilityBase)	CloseLibrary(UtilityBase);
	if (DOSBase)		CloseLibrary(&DOSBase->dl_lib);
	
	if (MyProc->pr_CLI==NULL)
	{
		Forbid();
		ReplyMsg((struct Message*)WBenchMsg);
		return(RETURN_OK);
	}
	
	FindTask(NULL)->tc_Node.ln_Pri=OldPri;
	return(ReturnCode);
}


/* MatchBoolean */

BOOL MatchBoolean(UBYTE *String)
{
	if (MatchToolValue(String,"YES") || MatchToolValue(String,"TRUE"))
		return(TRUE);
	if (MatchToolValue(String,"NO") || MatchToolValue(String,"FALSE"))
		return(FALSE);
	return(FALSE);
}


/* Main Scheduling Routine */

void MainHandler(void)
{
	CxMsg *msg;
	long sigmask;
	ULONG type;
	long id;
	BOOL Running=TRUE;
	
	while(Running)
	{
		sigmask=(1<<mp->mp_SigBit) | SIGBREAKF_CTRL_C;
		
		if (ColorPatchWnd) sigmask |= (1<<ColorPatchWnd->UserPort->mp_SigBit);
		
		sigmask=Wait(sigmask);
		
		if (sigmask & SIGBREAKF_CTRL_C)
		{
			Running=FALSE;
		}
		else
		{
			id=0;
			if (sigmask & (1<<mp->mp_SigBit))
			{
				if (msg=(CxMsg*)GetMsg(mp))
				{
					id=CxMsgID(msg);
					type=CxMsgType(msg);
					ReplyMsg((struct Message*)msg);
				}
			}
			if (ColorPatchWnd)
			{
				if (sigmask & (1<<ColorPatchWnd->UserPort->mp_SigBit))
				{
					id=HandleColorPatchIDCMP();
					type=CXM_COMMAND;
				}
			}
			switch(id)
			{
				case CXCMD_DISABLE:
					PatchActive=FALSE;
					if (GUI) OpenGUI();
					UpdateColors();
					break;
				case CXCMD_ENABLE:
					if (type==CXM_IEVENT)
						PatchActive^=TRUE;
					else
						PatchActive=TRUE;
					if (GUI) OpenGUI();
					UpdateColors();
					break;
				case CXCMD_UNIQUE:
					/* fallthrough */
				case CXCMD_APPEAR:
					if (type==CXM_IEVENT)
					{
						if (GUI)
							if (ColorPatchWnd->Flags & WFLG_WINDOWACTIVE)
								CloseGUI();
							else
							{
								ActivateWindow(ColorPatchWnd);
								ScreenToFront(ColorPatchWnd->WScreen);
							}
						else
							OpenGUI();
					}
					else
					{
						OpenGUI();
					}
					break;
				case CXCMD_DISAPPEAR:
					CloseGUI();
					break;
				case CXCMD_KILL:
					Running=FALSE;
					break;
			}
		}
	}
}


/* Open Graphical User Interface */

#define TagPatch(ID,Tag,Value) case (ID): if (*Ptr==(Tag)) *(Ptr+1)=(ULONG)(Value); break

int OpenGUI(void)
{
	if (!GUI)
	{
		if (!SetupScreen())
		{
			ULONG GadID,*Ptr;
			
			if (WindowLeft != -1) ColorPatchLeft=WindowLeft;
			if (WindowTop  != -1) ColorPatchTop =WindowTop;
			
			for (GadID=0,Ptr=ColorPatchGTags;GadID<ColorPatch_CNT;GadID++,Ptr++)
			{
				for(;*Ptr!=TAG_END;Ptr+=2)
				{
					switch(GadID)
					{
						TagPatch(GD_PopUpHotKey,GTST_String,PopUpHotKey);
						TagPatch(GD_PopUpCheck,GTCB_Checked,PopUpActive);
						TagPatch(GD_ActivationHotKey,GTST_String,ActivationHotKey);
						TagPatch(GD_ActivationCheck,GTCB_Checked,PatchActive);
						TagPatch(GD_RedSlider,GTSL_Level,RedSlider);
						TagPatch(GD_GreenSlider,GTSL_Level,GreenSlider);
						TagPatch(GD_BlueSlider,GTSL_Level,BlueSlider);
						TagPatch(GD_ColorSlider,GTSL_Level,ColorSlider);
						TagPatch(GD_ContrSlider,GTSL_Level,ContrSlider);
						TagPatch(GD_BrightSlider,GTSL_Level,BrightSlider);
						TagPatch(GD_CorrectA2024Check,GTCB_Checked,CorA2024Active);
						TagPatch(GD_EmulateA2024Check,GTCB_Checked,EmuA2024Active);
					}
				}
			}
			
			if (!OpenColorPatchWindow())
			{
				ScreenToFront(ColorPatchWnd->WScreen);
				GUI=TRUE;
			}
		}
	}
	if (GUI)
	{
		GT_SetGadgetAttrs(ColorPatchGadgets[GD_PopUpHotKey],ColorPatchWnd,0,GTST_String,PopUpHotKey,TAG_END);
		GT_SetGadgetAttrs(ColorPatchGadgets[GD_PopUpCheck],ColorPatchWnd,0,GTCB_Checked,PopUpActive,TAG_END);
		
		GT_SetGadgetAttrs(ColorPatchGadgets[GD_ActivationHotKey],ColorPatchWnd,0,GTST_String,ActivationHotKey,TAG_END);
		GT_SetGadgetAttrs(ColorPatchGadgets[GD_ActivationCheck],ColorPatchWnd,0,GTCB_Checked,PatchActive,TAG_END);
		
		GT_SetGadgetAttrs(ColorPatchGadgets[GD_RedSlider],ColorPatchWnd,0,GTSL_Level,RedSlider,GTSL_DispFunc,&RedSlide,TAG_END);
		GT_SetGadgetAttrs(ColorPatchGadgets[GD_GreenSlider],ColorPatchWnd,0,GTSL_Level,GreenSlider,GTSL_DispFunc,&GreenSlide,TAG_END);
		GT_SetGadgetAttrs(ColorPatchGadgets[GD_BlueSlider],ColorPatchWnd,0,GTSL_Level,BlueSlider,GTSL_DispFunc,&BlueSlide,TAG_END);
		GT_SetGadgetAttrs(ColorPatchGadgets[GD_ColorSlider],ColorPatchWnd,0,GTSL_Level,ColorSlider,GTSL_DispFunc,&ColorSlide,TAG_END);
		GT_SetGadgetAttrs(ColorPatchGadgets[GD_ContrSlider],ColorPatchWnd,0,GTSL_Level,ContrSlider,GTSL_DispFunc,&ContrSlide,TAG_END);
		GT_SetGadgetAttrs(ColorPatchGadgets[GD_BrightSlider],ColorPatchWnd,0,GTSL_Level,BrightSlider,GTSL_DispFunc,&BrightSlide,TAG_END);
		
		GT_SetGadgetAttrs(ColorPatchGadgets[GD_CorrectA2024Check],ColorPatchWnd,0,GTCB_Checked,CorA2024Active,TAG_END);
		GT_SetGadgetAttrs(ColorPatchGadgets[GD_EmulateA2024Check],ColorPatchWnd,0,GTCB_Checked,EmuA2024Active,TAG_END);
	}
	else
	{
		CloseGUI();
		Error("Failed to open GUI!");
		return(-1);
	}
	return(0);
}



/* Close Graphical User Interface */

void CloseGUI(void)
{
	CloseColorPatchWindow();
	CloseDownScreen();
	GUI=FALSE;
}



/* Update colors on all screens */

void UpdateColors(void)
{
	struct ViewPort *ViewPort;
	ULONG empty=0x0;
	Forbid();
	UpdateAll=TRUE;
	ViewPort=ViewAddress()->ViewPort;
	while(ViewPort)
	{
		LoadRGB32(ViewPort, &empty);
		ViewPort=ViewPort->Next;
	}
	UpdateAll=FALSE;
	Permit();
}



/* Error Request routine */

void __stdargs Error(UBYTE *Msg,...)
{
	va_list Arg;
	struct EasyStruct Req={sizeof(struct EasyStruct),0,"ColorPatch Error",0,"I see"};
	va_start(Arg,Msg);
	Req.es_TextFormat=Msg;
	EasyRequestArgs(ColorPatchWnd,&Req,0,Arg);
	va_end(Arg);
}



/* Lots of Event handling routines */


int ColorPatchAboutMenu(void)
{
	struct EasyStruct Req={sizeof(struct EasyStruct),0,
						"ColorPatch Commodity",
						"%s\n"
						"Written by Christian Buchner\n"
						"Copyright © 1994\n"
						"This is FreeWare\n\n"
						"For quality patches contact:\n"
						"Christian Buchner\n"
						"Ganghoferstraße 2\n"
						"82110 Germering\n"
						"Germany\n"
						"Tel.: +49-(0)89/844872","I see"};
	EasyRequest(ColorPatchWnd,&Req,0,&Version[6]);
	return(0);
}

int ColorPatchCloseWindow(void)
{
	return(CXCMD_DISAPPEAR);
}

int ColorPatchChangeWindow(void)
{
	WindowLeft=ColorPatchWnd->LeftEdge;
	WindowTop =ColorPatchWnd->TopEdge;
	return(0);
}

int PopUpHotKeyClicked(void)
{
	UBYTE *String=GetString(ColorPatchGadgets[GD_PopUpHotKey]);
	if (strcmp(String,PopUpHotKey))
	{
		strcpy(PopUpHotKey,String);
		SetFilter(popupfilter,String);
	}
	return(0);
}

int PopUpCheckClicked(void)
{
	PopUpActive=ColorPatchMsg.Code;
	return(0);
}

int ActivationHotKeyClicked(void)
{
	UBYTE *String=GetString(ColorPatchGadgets[GD_ActivationHotKey]);
	if (strcmp(String,ActivationHotKey))
	{
		strcpy(ActivationHotKey,String);
		SetFilter(activatefilter,String);
	}
	return(0);
}

int ActivationCheckClicked(void)
{
	PatchActive=ColorPatchMsg.Code;
	UpdateColors();
	return(0);
}

int RedSliderClicked(void)
{
	RedSlider=ColorPatchMsg.Code;
	RedVal=RedSlider*VALUE;
	if (PatchActive) UpdateColors();
	return(0);
}

long __saveds RedSlide(struct Gadget *Gadget, WORD Pos)
{
	if (RedSlider!=Pos)
	{
		RedSlider=Pos;
		RedVal=RedSlider*VALUE;
		if (PatchActive) UpdateColors();
	}
	return(Pos);
}

int GreenSliderClicked(void)
{
	GreenSlider=ColorPatchMsg.Code;
	GreenVal=GreenSlider*VALUE;
	if (PatchActive) UpdateColors();
	return(0);
}

long __saveds GreenSlide(struct Gadget *Gadget, WORD Pos)
{
	if (GreenSlider!=Pos)
	{
		GreenSlider=Pos;
		GreenVal=GreenSlider*VALUE;
		if (PatchActive) UpdateColors();
	}
	return(Pos);
}

int BlueSliderClicked(void)
{
	BlueSlider=ColorPatchMsg.Code;
	BlueVal=BlueSlider*VALUE;
	if (PatchActive) UpdateColors();
	return(0);
}

long __saveds BlueSlide(struct Gadget *Gadget, WORD Pos)
{
	if (BlueSlider!=Pos)
	{
		BlueSlider=Pos;
		BlueVal=BlueSlider*VALUE;
		if (PatchActive) UpdateColors();
	}
	return(Pos);
}

int ColorSliderClicked(void)
{
	ColorSlider=ColorPatchMsg.Code;
	ColorVal=ColorSlider*VALUE;
	if (PatchActive) UpdateColors();
	return(0);
}

long __saveds ColorSlide(struct Gadget *Gadget, WORD Pos)
{
	if (ColorSlider!=Pos)
	{
		ColorSlider=Pos;
		ColorVal=ColorSlider*VALUE;
		if (PatchActive) UpdateColors();
	}
	return(Pos);
}

int ContrSliderClicked(void)
{
	ContrSlider=ColorPatchMsg.Code;
	ContrVal=ContrSlider*VALUE;
	if (PatchActive) UpdateColors();
	return(0);
}

long __saveds ContrSlide(struct Gadget *Gadget, WORD Pos)
{
	if (ContrSlider!=Pos)
	{
		ContrSlider=Pos;
		ContrVal=ContrSlider*VALUE;
		if (PatchActive) UpdateColors();
	}
	return(Pos);
}

int BrightSliderClicked(void)
{
	BrightSlider=ColorPatchMsg.Code;
	BrightVal=BrightSlider*VALUE;
	if (PatchActive) UpdateColors();
	return(0);
}

long __saveds BrightSlide(struct Gadget *Gadget, WORD Pos)
{
	if (BrightSlider!=Pos)
	{
		BrightSlider=Pos;
		BrightVal=BrightSlider*VALUE;
		if (PatchActive) UpdateColors();
	}
	return(Pos);
}

int CorrectA2024CheckClicked(void)
{
	CorA2024Active=ColorPatchMsg.Code;
	if (PatchActive) UpdateColors();
	return(0);
}

int EmulateA2024CheckClicked(void)
{
	EmuA2024Active=ColorPatchMsg.Code;
	if (PatchActive) UpdateColors();
	return(0);
}

int SaveButtonClicked(void)
{
	SaveConfig();
	return(CXCMD_DISAPPEAR);
}

int ColorPatchSaveMenu(void)
{
	SaveConfig();
	return(CXCMD_DISAPPEAR);
}

int HideButtonClicked(void)
{
	return(CXCMD_DISAPPEAR);
}

int ColorPatchHideMenu(void)
{
	return(CXCMD_DISAPPEAR);
}

int ColorPatchQuitMenu(void)
{
	return(CXCMD_KILL);
}

int QuitButtonClicked(void)
{
	return(CXCMD_KILL);
}

int ColorPatchVanillaKey(void)
{
	if (ColorPatchMsg.Qualifier&IEQUALIFIER_RCOMMAND)
	{
		if (ColorPatchMsg.Code=='p')
		{
			ActivateGadget(ColorPatchGadgets[GD_PopUpHotKey],ColorPatchWnd,0);
		}
		if (ColorPatchMsg.Code=='u')
		{
			PopUpActive ^= TRUE;
			if (GUI) OpenGUI();
		}
		
		if (ColorPatchMsg.Code=='k')
		{
			ActivateGadget(ColorPatchGadgets[GD_ActivationHotKey],ColorPatchWnd,0);
		}
		if (ColorPatchMsg.Code=='a')
		{
			PatchActive ^= TRUE;
			if (GUI) OpenGUI();
			UpdateColors();
		}
		
		if (ColorPatchMsg.Code=='c')
		{
			CorA2024Active ^= TRUE;
			if (GUI) OpenGUI();
			if (PatchActive) UpdateColors();
		}
		if (ColorPatchMsg.Code=='e')
		{
			EmuA2024Active ^= TRUE;
			if (GUI) OpenGUI();
			if (PatchActive) UpdateColors();
		}
	}
	return(0);
}


/* Save Configuration */

void SaveConfig(void)
{
	char **ToolTypeArray;
	char **OriginalArray=DiskObject->do_ToolTypes;
	char *TextBuf;
	
	if (ToolTypeArray=AllocVec(50*sizeof(APTR),MEMF_CLEAR))
	{
		if (TextBuf=AllocVec(1000,MEMF_CLEAR))
		{
			char **tta=ToolTypeArray;
			char **orig;
			char *buf=TextBuf;
			
			/* Alle "unbekannten" Tooltypes übernehmen */
			
			for (orig=OriginalArray;*orig;orig++)
			{
				if ( (!strnicmp(*orig,"CX_POPUP=",9)) ||
					 (!strnicmp(*orig,"CX_POPKEY=",10)) ||
					 (!strnicmp(*orig,"WINDOW_X=",9)) ||
					 (!strnicmp(*orig,"WINDOW_Y=",9)) ||
					 (!strnicmp(*orig,"HOTKEY=",7)) ||
					 (!strnicmp(*orig,"ACTIVE=",7)) ||
					 (!strnicmp(*orig,"CA2024=",7)) ||
					 (!strnicmp(*orig,"EA2024=",7)) ||
					 (!strnicmp(*orig,"RED=",4)) ||
					 (!strnicmp(*orig,"GREEN=",6)) ||
					 (!strnicmp(*orig,"BLUE=",5)) ||
					 (!strnicmp(*orig,"COLOR=",6)) ||
					 (!strnicmp(*orig,"CONTR=",6)) ||
					 (!strnicmp(*orig,"BRIGHT=",7)) ) continue;
				*tta++=*orig;
			}
			
			/* CX_POPUP Tooltype erzeugen */
			
			*tta++=buf;
			if (PopUpActive)
				buf+=sprintf(buf,"CX_POPUP=YES")+1;
			else
				buf+=sprintf(buf,"CX_POPUP=NO")+1;
			
			/* CX_POPKEY Tooltype erzeugen */
			
			*tta++=buf;
			buf+=sprintf(buf,"CX_POPKEY=%s",PopUpHotKey)+1;
			
			/* Fensterposition speichern */
			
			*tta++=buf; buf+=sprintf(buf,"WINDOW_X=%d",WindowLeft)+1;
			*tta++=buf; buf+=sprintf(buf,"WINDOW_Y=%d",WindowTop)+1;
			
			/* HOTKEY Tooltype erzeugen */
			
			*tta++=buf;
			buf+=sprintf(buf,"HOTKEY=%s",ActivationHotKey)+1;
			
			/* ACTIVE Tooltype erzeugen */
			
			*tta++=buf;
			if (PatchActive)
				buf+=sprintf(buf,"ACTIVE=YES")+1;
			else
				buf+=sprintf(buf,"ACTIVE=NO")+1;
			
			/* CA2024 Tooltype erzeugen */
			
			*tta++=buf;
			if (CorA2024Active)
				buf+=sprintf(buf,"CA2024=YES")+1;
			else
				buf+=sprintf(buf,"CA2024=NO")+1;
			
			/* EA2024 Tooltype erzeugen */
			
			*tta++=buf;
			if (EmuA2024Active)
				buf+=sprintf(buf,"EA2024=YES")+1;
			else
				buf+=sprintf(buf,"EA2024=NO")+1;
			
			/* Farbeinstellungen speichern */
			
			*tta++=buf; buf+=sprintf(buf,"RED=%d",RedSlider)+1;
			*tta++=buf; buf+=sprintf(buf,"GREEN=%d",GreenSlider)+1;
			*tta++=buf; buf+=sprintf(buf,"BLUE=%d",BlueSlider)+1;
			*tta++=buf; buf+=sprintf(buf,"COLOR=%d",ColorSlider)+1;
			*tta++=buf; buf+=sprintf(buf,"CONTR=%d",ContrSlider)+1;
			*tta++=buf; buf+=sprintf(buf,"BRIGHT=%d",BrightSlider)+1;
			
			/* Icon zurückschreiben */
			
			DiskObject->do_ToolTypes=ToolTypeArray;
			if (WBenchMsg)
			{
				PutDiskObject(WBenchMsg->sm_ArgList->wa_Name,DiskObject);
			}
			else
			{
				PutDiskObject(IconName,DiskObject);
			}
			DiskObject->do_ToolTypes=OriginalArray;
			
			FreeVec(TextBuf);
		}
		else
		{
			Error("Out of memory!");
		}
		FreeVec(ToolTypeArray);
	}
	else
	{
		Error("Out of memory!");
	}
}
