/* CreateGUI.c */

#include <OSIncludes.h>
#pragma header

#include <clib/alib_protos.h>
#include <libraries/mui.h>
#include <pragma/muimaster_lib.h>

#define CATCOMP_NUMBERS
#include "catalogs/PrefsAttack.h"
#include "PWPrefs.h"
#include "Version.h"
#include "PrefsAttackIO.h"

#include <stdio.h>
#include <string.h>


#define SAVEIMAGE_NAME   "images/gadsave.brush"
#define USEIMAGE_NAME    "images/gaduse.brush"
#define TESTIMAGE_NAME   "images/gadtest.brush"
#define CANCELIMAGE_NAME "images/gadcancel.brush"
#define NEWIMAGE_NAME    "images/gadnew.brush"
#define DELIMAGE_NAME    "images/gaddel.brush"

STRPTR GruppenStrings[MAX_GRUPPEN+1];

static WORD GruppenID;
static WORD SeitenID;
static WORD ObjektID;
static WORD MaxPageImageHeight;

static Object *SaveGadget,*TestGadget,
				  *UseGadget,*CancelGadget;

static Object  *dummy,*dummy2,*dummy3;


static struct MyImage SaveImage,UseImage,
				  TestImage,CancelImage,
				  NewImage,DelImage,LogoImage;

static BOOL ImageSuccess;
static BOOL AnyPageImage;

static struct Hook HelpHook,LVStringHook,
						 LVActivateHook,LVNewHook,
						 LVDoubleClickHook,MainMenuHook,
						 ListConstructHook,
						 ListDestructHook;

static char *OldHelpText;
static char *HelpText;

static void MyHelpHook(struct Hook *hook, Object *obj,Object **mausobj)
{
	struct Objekt *o=0;
	
	if (!(*mausobj)) return;
	
	HelpText=EmptyHelpString;
	if (get(*mausobj,MUIA_UserData,&o)) 
	{
		if (o) HelpText=o->ob_HelpText;
	}

	if (HelpText!=OldHelpText) DoMethod(HelpObject,MUIM_Set,MUIA_Floattext_Text,HelpText);
	OldHelpText=HelpText;
}
 
static void MyLVStringHook(struct Hook *hook, Object *o,struct Objekt **obj)
{
	LONG active;
	char *s,*entry;

	get((*obj)->ob_MUIGetObject,MUIA_List_Active,&active);

	if (active==MUIV_List_Active_Off)
	{
		get(o,MUIA_String_Contents,&s);
		DoMethod((*obj)->ob_MUIGetObject,MUIM_List_InsertSingle,s,MUIV_List_Insert_Bottom);
		get((*obj)->ob_MUIGetObject,MUIA_List_Entries,&active);
		DoMethod((*obj)->ob_MUIGetObject,MUIM_List_Jump,active-1);
		DoMethod(MainWin,MUIM_Set,MUIA_Window_ActiveObject,o);
		DoMethod(o,MUIM_Set,MUIA_String_Contents,"");
	} else {
		get(o,MUIA_String_Contents,&s);	
		DoMethod((*obj)->ob_MUIGetObject,MUIM_List_GetEntry,active,&entry);
		if (entry)
		{
			strcpy(entry,s);
			DoMethod((*obj)->ob_MUIGetObject,MUIM_List_Redraw,MUIV_List_Redraw_Active);
			DoMethod(MainWin,MUIM_Set,MUIA_Window_ActiveObject,(*obj)->ob_MUISpecialObject);
		}
	}
}
 
static void MyLVActivateHook(struct Hook *hook, Object *o,Object **str)
{
	LONG active;
	char *s;

	get(o,MUIA_List_Active,&active);
	
	if (active==MUIV_List_Active_Off)
	{
		DoMethod(str[0],MUIM_Set,MUIA_String_Contents,"");
	} else {
		DoMethod(o,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&s);
		DoMethod(str[0],MUIM_Set,MUIA_String_Contents,s);
		get (MainWin,MUIA_Window_ActiveObject,&active);		
		if (active != (LONG) str[1])
		{
			DoMethod(MainWin,MUIM_Set,MUIA_Window_ActiveObject,str[1]);
		}
	}
}
 
static void MyLVNewHook(struct Hook *hook, Object *o,struct Objekt **obj)
{
	DoMethod((*obj)->ob_MUIGetObject,MUIM_Set,MUIA_List_Active,MUIV_List_Active_Off);
	DoMethod(MainWin,MUIM_Set,MUIA_Window_ActiveObject,o);
}

static void MyLVDoubleClickHook(struct Hook *hook, Object *o,Object **str)
{
	DoMethod(MainWin,MUIM_Set,MUIA_Window_ActiveObject,str[0]);
}

char *MyListConstructHook(struct Hook *hook, APTR pool, char *str)
{
	char *neu;
	
	if ((neu=AllocPooled(pool,257)))
	{
		strcpy(neu,str)
	}
	
	return neu;
}

static void MyListDestructHook(struct Hook *hook,APTR pool, char *entry)
{
	FreePooled(pool,entry,257);
}

static void InitGui(void)
{
	struct Gruppe *gruppe;
	STRPTR *gs;
	
	gruppe=(struct Gruppe *)GruppenListe.lh_Head;
	gs=(STRPTR *)&GruppenStrings[0];
	
	while (gruppe->gr_Node.ln_Succ)
	{
		*gs++ = (STRPTR)gruppe;
		gruppe=(struct Gruppe *)gruppe->gr_Node.ln_Succ;
	}
	*gs=0;
	
}

static Object *MakeBodychunkObject(struct MyImage *mim)
{
	return BodychunkObject,
		MUIA_FixWidth,mim->im_BitMapHeader->bmh_Width,
		MUIA_FixHeight,mim->im_BitMapHeader->bmh_Height,
		MUIA_Bodychunk_Body,mim->im_Body,
		MUIA_Bodychunk_Compression,mim->im_BitMapHeader->bmh_Compression ? 1 : 0,
		MUIA_Bodychunk_Depth,mim->im_BitMapHeader->bmh_Depth,
		MUIA_Bodychunk_Masking,mim->im_BitMapHeader->bmh_Masking,
		MUIA_Bitmap_Width,mim->im_BitMapHeader->bmh_Width,
		MUIA_Bitmap_Height,mim->im_BitMapHeader->bmh_Height,
		MUIA_Bitmap_Transparent,TRUE,
		MUIA_Bitmap_UseFriend,TRUE,
		MUIA_Bitmap_SourceColors,mim->im_CRegs,
		End;
}

static void FreeMyImage(struct MyImage *im)
{
	if (im->im_Speicher) FreeVec(im->im_Speicher);
	if (im->im_CRegs) FreeVec(im->im_CRegs);
}

static void FreeImages(void)
{
	struct Gruppe *gr;
	WORD i;
	
	FreeMyImage(&SaveImage);
	FreeMyImage(&UseImage);
	FreeMyImage(&TestImage);
	FreeMyImage(&CancelImage);
	FreeMyImage(&NewImage);
	FreeMyImage(&DelImage);
	FreeMyImage(&LogoImage);
	
	gr=(struct Gruppe *)GruppenListe.lh_Head;
	
	for (i=0;i<Anz_Gruppen;i++)
	{
		FreeMyImage(&gr->gr_Image);
		gr=(struct Gruppe *)gr->gr_Node.ln_Succ;
	}

}

static void LoadImage(struct MyImage *im,char *name)
{

#define RGB32(x) ( (ULONG)x + ((ULONG)x<<8L) + ((ULONG)x<<16L) + ((ULONG)x<<24L) )

	ULONG *lp;
	UBYTE *bp;
	BPTR MyHandle=0;
	LONG l;
	
	if (!ImageSuccess) return;
	
	ImageSuccess=FALSE;

	if ((MyHandle=Open(name,MODE_OLDFILE)))
	{
		Seek(MyHandle,0,OFFSET_END);
		im->im_FileLen=Seek(MyHandle,0,OFFSET_BEGINNING);

		if ((im->im_Speicher=AllocVec(im->im_FileLen,MEMF_PUBLIC)))
		{
			if (Read(MyHandle,im->im_Speicher,im->im_FileLen)==im->im_FileLen)
			{
				im->im_BitMapHeader=(struct BitMapHeader *)FindChunk(MAKE_ID('B','M','H','D'),im->im_Speicher,im->im_FileLen);
				im->im_Body=FindChunk(MAKE_ID('B','O','D','Y'),im->im_Speicher,im->im_FileLen);
				im->im_Cmap=FindChunk(MAKE_ID('C','M','A','P'),im->im_Speicher,im->im_FileLen);
				
				if (im->im_BitMapHeader && im->im_Body && im->im_Cmap)
				{
					if ((im->im_CRegs=AllocVec((1L << im->im_BitMapHeader->bmh_Depth)*3*sizeof(ULONG),MEMF_PUBLIC)))
					{
						
						lp=im->im_CRegs;
						bp=im->im_Cmap;
						for (l=0;l<(1L << im->im_BitMapHeader->bmh_Depth);l++)
						{
							*lp++=RGB32(*bp);bp++;
							*lp++=RGB32(*bp);bp++;
							*lp++=RGB32(*bp);bp++;
						}
						
						ImageSuccess=TRUE;
						im->im_OK=TRUE;

					} // if ((im->im_CRegs=AllocVec((1L << im
					
				} // if (im->im_BitmapHeader && im->im_Body && ...

			} // if Read == filelen

		}	// if ((im->im_Speicher=AllocVec

		Close(MyHandle);
	} // if (MyHandle=Open

	if (!ImageSuccess) FreeMyImage(im);
}

static void LoadImages(void)
{
	struct Gruppe *gr;
	WORD i;

	if (NoImages)
	{
		ImageSuccess=FALSE;
	} else {
		ImageSuccess=TRUE;
		LoadImage(&SaveImage,SAVEIMAGE_NAME);
		LoadImage(&UseImage,USEIMAGE_NAME);
		LoadImage(&TestImage,TESTIMAGE_NAME);
		LoadImage(&CancelImage,CANCELIMAGE_NAME);
		LoadImage(&NewImage,NEWIMAGE_NAME);
		LoadImage(&DelImage,DELIMAGE_NAME);
	}
	
	if (!NoGroupImages)
	{
		gr=(struct Gruppe *)GruppenListe.lh_Head;
		
		MaxPageImageHeight=0;
	
		for (i=0;i<Anz_Gruppen;i++)
		{
			ImageSuccess=TRUE;
			if (gr->gr_ImageName)
			{
				LoadImage(&gr->gr_Image,gr->gr_ImageName);
				
				if (gr->gr_Image.im_OK)
				{
					gr->gr_Image.im_Image=MakeBodychunkObject(&gr->gr_Image);
					AnyPageImage=TRUE;
	
					if (gr->gr_Image.im_BitMapHeader->bmh_Height > MaxPageImageHeight)
					{
						MaxPageImageHeight=gr->gr_Image.im_BitMapHeader->bmh_Height;
					}
				}
				
			}
			gr=(struct Gruppe *)gr->gr_Node.ln_Succ;
		}

	} // if (!NoGroupImages)
}

void EndGUI(void)
{
	FreeImages();
}

static Object *MyImageButton (struct MyImage *mim,char *text,char *key)
{
	if (mim->im_OK)
	{
		return HGroup,
					ButtonFrame,
					MUIA_Background,MUII_ButtonBack,
					MUIA_InputMode,MUIV_InputMode_RelVerify,
					MUIA_ControlChar,*key,
					MUIA_Group_HorizSpacing,0,
					MUIA_Group_SameHeight,TRUE,
					Child,HSpace(2),
					Child,VGroup,
						MUIA_Group_VertSpacing,0,
						Child,RectangleObject,End,
						Child,mim->im_Image=MakeBodychunkObject(mim),
						Child,RectangleObject,End,
						End,
					Child,HSpace(2),
					Child,RectangleObject,End,
					Child,VGroup,
						MUIA_Group_VertSpacing,0,
						Child,RectangleObject,End,
						Child,TextObject, 
							MUIA_Text_Contents,text,
							MUIA_Text_SetMax,TRUE,
							MUIA_Text_HiChar,*key,
							End,
						Child,RectangleObject,End,
						End,
					Child,RectangleObject,End,
					Child,HSpace(2),
					End;
		
	} else {
		return KeyButton(text,*key);
	}
}

static void SetUserData(Objekt *obj)
{
	if (!obj->ob_MUIObject) return;

	if (BubbleHelp && obj->ob_HelpText)
	{
		BreakString(obj->ob_HelpText);
		DoMethod(obj->ob_MUIObject,MUIM_SetUData,0,MUIA_ShortHelp,obj->ob_HelpText);
	}

	DoMethod(obj->ob_MUIObject,MUIM_SetUData,0,MUIA_UserData,obj);
	
	set(obj->ob_MUIObject,MUIA_HelpLine,obj->ob_HelpLine);
	if (obj->ob_HelpNode)
	{
		set(obj->ob_MUIObject,MUIA_HelpNode,obj->ob_HelpNode);
	}
	
			
}

static Object *MakeObjekte(struct Seite *seite)
{
	struct Objekt *obj;
	char s[12];

	WORD id;
	
	ObjektID=0;
	obj=(struct Objekt *)seite->se_ObjektListe.lh_Head;
	
	while (obj->ob_Node.ln_Succ)
	{
		id=GruppenID+SeitenID+ObjektID;

		switch (obj->ob_Typ)
		{
			case OBJ_BOOL:
				obj->ob_MUIObject=HGroup,
//							MUIA_Group_SameWidth,TRUE,
							Child,HGroup,
								MUIA_Weight,seite->se_LabelWeight,
								Child,RectangleObject,End,
								Child,Label1(obj->ob_Name),
								End,
							Child,HGroup,
							 	MUIA_Weight,seite->se_GadgetWeight,
								Child,obj->ob_MUIGetObject=ImageObject,
									ImageButtonFrame,
									MUIA_InputMode, MUIV_InputMode_Toggle,
									MUIA_Image_Spec,MUII_CheckMark,
									MUIA_Image_FreeVert,TRUE,
									MUIA_Selected,obj->ob_LongValue,
									MUIA_Background,MUII_ButtonBack,
									MUIA_ShowSelState,FALSE,
									MUIA_CycleChain,TRUE,
									End,
								Child,RectangleObject,End,
								End,
							End;
				SetUserData(obj);
				break;

			case OBJ_INTEGER:
				sprintf(s,"%ld",obj->ob_LongValue);
				obj->ob_MUIObject=HGroup,
//							MUIA_Group_SameWidth,TRUE,
							Child,HGroup,
								MUIA_Weight,seite->se_LabelWeight,
								Child,RectangleObject,End,
								Child,Label2(obj->ob_Name),
								End,	
							Child,obj->ob_MUIGetObject=StringObject,
								MUIA_Weight,seite->se_GadgetWeight,
								StringFrame,
								MUIA_String_Accept,"-0123456789",
								MUIA_String_Integer,TRUE,
								MUIA_String_MaxLen,11,
								MUIA_String_Contents,s,
								MUIA_CycleChain,TRUE,
								End,
							End;
				SetUserData(obj);
				break;

			case OBJ_STRING:
				obj->ob_MUIObject=HGroup,
//							MUIA_Group_SameWidth,TRUE,
							Child,HGroup,
								MUIA_Weight,seite->se_LabelWeight,
								Child,RectangleObject,End,
								Child,Label2(obj->ob_Name),
								End,
							Child,obj->ob_MUIGetObject=StringObject,
								MUIA_Weight,seite->se_GadgetWeight,
								StringFrame,
								MUIA_String_Contents,obj->ob_StringValue,
								obj->ob_MaxStringLen>0 ? MUIA_String_MaxLen : TAG_IGNORE,obj->ob_MaxStringLen,
								MUIA_CycleChain,TRUE,
								End,
							End;
				SetUserData(obj);
				break;
							
			case OBJ_CYCLE:
				obj->ob_MUIObject=HGroup,
//							MUIA_Group_SameWidth,TRUE,
							Child,HGroup,
								MUIA_Weight,seite->se_LabelWeight,
								Child,RectangleObject,End,
								Child,Label1(obj->ob_Name),
								End,
							Child,obj->ob_MUIGetObject=CycleObject,
								MUIA_Weight,seite->se_GadgetWeight,
//								ButtonFrame,
								MUIA_Cycle_Entries,obj->ob_Tabelle,
								MUIA_Cycle_Active,obj->ob_LongValue,
								MUIA_CycleChain,TRUE,
								End,
							End;

				SetUserData(obj);
				break;

			case OBJ_SLIDER:
				obj->ob_MUIObject=HGroup,
							Child,HGroup,
								MUIA_Weight,seite->se_LabelWeight,
								Child,RectangleObject,End,
								Child,Label1(obj->ob_Name),
								End,
							Child,obj->ob_MUIGetObject=SliderObject,
								MUIA_Weight,seite->se_GadgetWeight,
								SliderFrame,
								MUIA_Slider_Horiz,TRUE,
								MUIA_Slider_Level,obj->ob_LongValue,
								MUIA_Slider_Min,obj->ob_Min,
								MUIA_Slider_Max,obj->ob_Max,
								MUIA_CycleChain,TRUE,
								End,
							End;
				SetUserData(obj);
				break;

			case OBJ_FILE:
				obj->ob_MUIObject=HGroup,
							Child,HGroup,
								MUIA_Weight,seite->se_LabelWeight,
								Child,RectangleObject,End,
								Child,Label1(obj->ob_Name),
								End,
							Child,PopaslObject,
								MUIA_Weight,seite->se_GadgetWeight,
								MUIA_Popstring_String,obj->ob_MUIGetObject=String(obj->ob_StringValue,256),
								MUIA_Popstring_Button,PopButton(MUII_PopFile),
								MUIA_CycleChain,TRUE,
								End,
							End;
				SetUserData(obj);
				break;			

			case OBJ_FONT:
				obj->ob_MUIObject=HGroup,
							Child,HGroup,
								MUIA_Weight,seite->se_LabelWeight,
								Child,RectangleObject,End,
								Child,Label1(obj->ob_Name),
								End,
							Child,PopaslObject,
								MUIA_Weight,seite->se_GadgetWeight,
								MUIA_Popasl_Type,ASL_FontRequest,
								MUIA_Popstring_String,obj->ob_MUIGetObject=String(obj->ob_StringValue,256),
								MUIA_Popstring_Button,PopButton(MUII_PopUp),
								MUIA_CycleChain,TRUE,
								End,
							End;
				SetUserData(obj);
				break;

			case OBJ_LISTVIEW:
				obj->ob_MUISpecialObject=ListviewObject,
					MUIA_CycleChain,TRUE,
					MUIA_Listview_DragType,MUIV_Listview_DragType_Immediate,
					MUIA_Listview_List,obj->ob_MUIGetObject=ListObject,
						InputListFrame,
						MUIA_List_ConstructHook,&ListConstructHook,
						MUIA_List_DestructHook,&ListDestructHook,
						MUIA_List_DragSortable,TRUE,
						End,
					End;

				obj->ob_MUIObject=VGroup,
							GroupFrameT(obj->ob_Name),
							Child,obj->ob_MUISpecialObject,
							Child,dummy=StringObject,
								StringFrame,
								MUIA_CycleChain,TRUE,
								MUIA_String_MaxLen,256,
								MUIA_String_Contents,"",
								MUIA_String_AttachedList,obj->ob_MUISpecialObject,
								End,
							Child,HGroup,
								MUIA_VertWeight,0,
								Child,dummy2=MyImageButton(&NewImage,MSG(GAD_NEW),MSG(GAD_NEW_KEY)),
								Child,dummy3=MyImageButton(&DelImage,MSG(GAD_DEL),MSG(GAD_DEL_KEY)),
								End,
							End;

				SetUserData(obj);
				if (obj->ob_MUIObject)
				{
					if (obj->ob_AnzItems)
					{
						DoMethod(obj->ob_MUIGetObject,MUIM_List_Insert,obj->ob_Tabelle,-1,MUIV_List_Insert_Bottom);
					}

					DoMethod(dummy,MUIM_Notify,MUIA_String_Acknowledge,MUIV_EveryTime,
								dummy,3,MUIM_CallHook,&LVStringHook,obj);

					DoMethod(obj->ob_MUIGetObject,MUIM_Notify,MUIA_List_Active,MUIV_EveryTime,
								obj->ob_MUIGetObject,4,MUIM_CallHook,&LVActivateHook,dummy,obj->ob_MUISpecialObject);

					
					DoMethod(dummy2,MUIM_Notify,MUIA_Pressed,FALSE,
								dummy,3,MUIM_CallHook,&LVNewHook,obj);

					DoMethod(dummy3,MUIM_Notify,MUIA_Pressed,FALSE,
								obj->ob_MUIGetObject,2,MUIM_List_Remove,MUIV_List_Remove_Active);

					DoMethod(obj->ob_MUISpecialObject,MUIM_Notify,MUIA_Listview_DoubleClick,TRUE,
								obj->ob_MUISpecialObject,3,MUIM_CallHook,&LVDoubleClickHook,dummy);
								
				}
								
				break;

		}

		obj=(struct Objekt *)obj->ob_Node.ln_Succ;
		ObjektID+=1;
	}
	
	InitTag(Tags);
	
	obj=(struct Objekt *)seite->se_ObjektListe.lh_Head;
	
	while (obj->ob_Node.ln_Succ)
	{
		AddTag(MUIA_Group_Child,(LONG)obj->ob_MUIObject);
		obj=(struct Objekt *)obj->ob_Node.ln_Succ;
	}
	TagDone();
	
	return HGroup,
				seite->se_HelpNode ? MUIA_HelpNode : TAG_IGNORE , seite->se_HelpNode,
				Child,RectangleObject,MUIA_Weight,1,End,
				Child,MUI_NewObjectA(MUIC_Group,Tags),
				Child,RectangleObject,MUIA_Weight,1,End,
				End;
}

static Object *MakeSeiten(struct Gruppe *gruppe)
{
	struct Seite *seite,*firstseite;
	Object *ob;

	SeitenID=0;

	seite=firstseite=(struct Seite *)gruppe->gr_SeitenListe.lh_Head;
	while (seite->se_Node.ln_Succ)
	{
		seite->se_MUIObject=MakeObjekte(seite);
		seite=(struct Seite *)seite->se_Node.ln_Succ;
		SeitenID+=50;
	}
	
	InitTag(Tags);
	AddTag(MUIA_Group_SameSize,TRUE);
	if (gruppe->gr_AnzSeiten>1)
	{
		AddTag(MUIA_Register_Titles,(LONG)gruppe->gr_Tabelle);
		AddTag(MUIA_CycleChain,TRUE);
		if (gruppe->gr_HelpNode)
		{
			AddTag(MUIA_HelpNode,(LONG)gruppe->gr_HelpNode);
		}
	}
	
	seite=(struct Seite *)gruppe->gr_SeitenListe.lh_Head;
	while (seite->se_Node.ln_Succ)
	{
		AddTag(MUIA_Group_Child,(LONG)seite->se_MUIObject);
		seite=(struct Seite *)seite->se_Node.ln_Succ;
	}
	TagDone();

	ob=MUI_NewObjectA(MUIC_Group,Tags);
	if (gruppe->gr_AnzSeiten==1)
	{
		if (!(firstseite->se_Name[0]))
		{
			return VGroup,
						MUIA_Frame, MUIV_Frame_Group,
						MUIA_Background, MUII_PageBack,
						gruppe->gr_HelpNode ? MUIA_HelpNode : TAG_IGNORE , gruppe->gr_HelpNode,
						Child,RectangleObject,End,
						Child,ob,
						Child,RectangleObject,End,
						End;
		} else {
			return VGroup,
						MUIA_Frame,MUIV_Frame_Group,
						MUIA_Background,MUII_PageBack,
						MUIA_FrameTitle,firstseite->se_Name,
						gruppe->gr_HelpNode ? MUIA_HelpNode : TAG_IGNORE , gruppe->gr_HelpNode,
						Child,RectangleObject,End,
						Child,ob,
						Child,RectangleObject,End,
						End;
		}
	} else {
		return MUI_NewObjectA(MUIC_Register,Tags);
	}
}

static Object *MakeGruppen(void)
{
	struct Gruppe *gruppe;

	GruppenID=1000;

	gruppe=(struct Gruppe *)GruppenListe.lh_Head;
	while(gruppe->gr_Node.ln_Succ)
	{
		gruppe->gr_MUIObject=MakeSeiten(gruppe);
		gruppe=(struct Gruppe *)gruppe->gr_Node.ln_Succ;
		GruppenID+=1000;
	}

	InitTag(Tags);
	AddTag(MUIA_Group_PageMode,TRUE);
	AddTag(MUIA_VertWeight,0);
	AddTag(MUIA_Group_SameSize,TRUE);
	
	gruppe=(struct Gruppe *)GruppenListe.lh_Head;
	while(gruppe->gr_Node.ln_Succ)
	{
		AddTag(MUIA_Group_Child,(LONG)gruppe->gr_MUIObject);
		gruppe=(struct Gruppe *)gruppe->gr_Node.ln_Succ;
	}
	TagDone();
	
	GruppenObject=MUI_NewObjectA(MUIC_Group,Tags);
	return GruppenObject;
}

static Object *MakeLogoObject(void)
{
	Object *obj,*dummy;

	ImageSuccess=TRUE;
	if (LogoFile[0]) LoadImage(&LogoImage,LogoFile);

	if (!LogoImage.im_OK) return 0;
	
	obj=VGroup,
				MUIA_Weight,0,
				Child,RectangleObject,End,
				Child,dummy=BodychunkObject,
					MUIA_InputMode,MUIV_InputMode_RelVerify,
					ButtonFrame,
					MUIA_FixWidth,LogoImage.im_BitMapHeader->bmh_Width,
					MUIA_FixHeight,LogoImage.im_BitMapHeader->bmh_Height,
					MUIA_Bodychunk_Body,LogoImage.im_Body,
					MUIA_Bodychunk_Depth,LogoImage.im_BitMapHeader->bmh_Depth,
					MUIA_Bodychunk_Compression,LogoImage.im_BitMapHeader->bmh_Compression ? 1 : 0,
					MUIA_Bodychunk_Masking,LogoImage.im_BitMapHeader->bmh_Masking,
					MUIA_Bitmap_Width,LogoImage.im_BitMapHeader->bmh_Width,
					MUIA_Bitmap_Height,LogoImage.im_BitMapHeader->bmh_Height,
					MUIA_Bitmap_UseFriend,TRUE,
					MUIA_Bitmap_Transparent,TRUE,
					MUIA_Bitmap_SourceColors,LogoImage.im_CRegs,
					End,
				Child,RectangleObject,End,
				End;

	if (obj)
	{
		DoMethod(dummy,MUIM_Notify,MUIA_Pressed,FALSE,
					dummy,3,MUIM_CallHook,&MainMenuHook,MEN_ABOUTPIO);
	}
	return obj;
}

static Object *MakeHelpGruppe(void)
{
	Object *obj,*LogoObj;

	HelpObject=FloattextObject,
			TextFrame,
			MUIA_VertWeight,0,
			MUIA_Background,MUII_TextBack,
			MUIA_Floattext_Text,EmptyHelpString,
//			MUIA_FixHeightTxt,EmptyHelpString,
			End;
			
	LogoObj=MakeLogoObject();
	
	if (!LogoObj)
	{
		obj=HelpObject;
	} else {
		obj=HGroup,
			MUIA_VertWeight,0,
			Child,LogoObj,
			Child,HelpObject,
			End;
	}
	return obj;
}

static void InitHooks(void)
{
	HelpHook.h_Entry=HookEntry;
	HelpHook.h_SubEntry=(HOOKFUNC)MyHelpHook;

	LVStringHook.h_Entry=HookEntry;
	LVStringHook.h_SubEntry=(HOOKFUNC)MyLVStringHook;

	LVActivateHook.h_Entry=HookEntry;
	LVActivateHook.h_SubEntry=(HOOKFUNC)MyLVActivateHook;

	LVNewHook.h_Entry=HookEntry;
	LVNewHook.h_SubEntry=(HOOKFUNC)MyLVNewHook; 

	LVDoubleClickHook.h_Entry=HookEntry;
	LVDoubleClickHook.h_SubEntry=(HOOKFUNC)MyLVDoubleClickHook;

	MainMenuHook.h_Entry=HookEntry;
	MainMenuHook.h_SubEntry=(HOOKFUNC)MyMainMenuHook;

	ListConstructHook.h_Entry=HookEntry;
	ListConstructHook.h_SubEntry=(HOOKFUNC)MyListConstructHook;

	ListDestructHook.h_Entry=HookEntry;
	ListDestructHook.h_SubEntry=(HOOKFUNC)MyListDestructHook;
}

static void InitMethods(void)
{

/* Listview Entries */

//	DoMethod(GruppenListObject,MUIM_List_Insert,GruppenStrings,-1,MUIV_List_Insert_Bottom);
	
/* Close-Gadget --> QUIT */

	DoMethod(MainWin,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,
		mainapp,2,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);

/* Cancel-Gadget --> QUIT */

	DoMethod(CancelGadget,MUIM_Notify,MUIA_Pressed,FALSE,
		mainapp,2,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);

/* List-View --> GROUP */

	DoMethod(GruppenListObject,MUIM_Notify,MUIA_List_Active,MUIV_EveryTime,GruppenObject,
				3,MUIM_Set,MUIA_Group_ActivePage,MUIV_TriggerValue);
				
/* Help --> Text */

	if (!BubbleHelp)
	{
		DoMethod(MainWin,MUIM_Notify,MUIA_Window_MouseObject,MUIV_EveryTime,
					MainWin,3,MUIM_CallHook,&HelpHook,MUIV_TriggerValue);
	}
				
/* Menu --> MenuHook */

	DoMethod(MainWin,MUIM_Notify,MUIA_Window_MenuAction,MUIV_EveryTime,
				MainWin,3,MUIM_CallHook,&MainMenuHook,MUIV_TriggerValue);

/* SaveGadget - Menu */

	DoMethod(SaveGadget,MUIM_Notify,MUIA_Pressed,FALSE,
				MainWin,3,MUIM_CallHook,&MainMenuHook,MEN_SAVEGAD);

/* UseGadget - Menuhook */

	DoMethod(UseGadget,MUIM_Notify,MUIA_Pressed,FALSE,
				MainWin,3,MUIM_CallHook,&MainMenuHook,MEN_USEGAD);
/* TestGadget - Menuhook */

	DoMethod(TestGadget,MUIM_Notify,MUIA_Pressed,FALSE,
				MainWin,3,MUIM_CallHook,&MainMenuHook,MEN_TESTGAD);

}
						
Object *MakeMainMenus(void)
{
	static char *scuts[]= {"1","2","3","4","5","6","7","8","9","0"};
	struct Gruppe *gr;
	char *sc;
	WORD i;
	
	InitTag(Tags);
	AddTag(MUIA_Menu_Title,(LONG)MSG(MENU_PAGE));
	
	gr=(struct Gruppe *)GruppenListe.lh_Head;
	for (i=1;i<=Anz_Gruppen;i++)
	{
		if (i<=10) sc=scuts[i-1]; else sc=0;
		AddTag(MUIA_Family_Child,(LONG)MUI_MakeObject(MUIO_Menuitem,gr->gr_Name,sc,0,MEN_SEITE_OFFSET+i-1));
		gr=(struct Gruppe *)gr->gr_Node.ln_Succ;
	}
	TagDone();
	
	return MenustripObject,
				MUIA_Family_Child,MenuObject,
					MUIA_Menu_Title,MSG(MENU_PROJECT),
					MUIA_Family_Child,MUI_MakeObject(MUIO_Menuitem,MSG(ITEM_PR_ABOUT),MSG(KITEM_PR_ABOUT),0,MEN_ABOUT),
					MUIA_Family_Child,MUI_MakeObject(MUIO_Menuitem,MSG(ITEM_PR_ABOUTMUI),MSG(KITEM_PR_ABOUTMUI),0,MEN_ABOUTMUI),
					MUIA_Family_Child,MUI_MakeObject(MUIO_Menuitem,MSG(ITEM_PR_ABOUTPIO),MSG(KITEM_PR_ABOUTPIO),0,MEN_ABOUTPIO),
					MUIA_Family_Child,MUI_MakeObject(MUIO_Menuitem,NM_BARLABEL,0,0,0),
					MUIA_Family_Child,MUI_MakeObject(MUIO_Menuitem,MSG(ITEM_PR_ICONIFY),MSG(KITEM_PR_ICONIFY),0,MEN_ICONIFY),
					MUIA_Family_Child,MUI_MakeObject(MUIO_Menuitem,NM_BARLABEL,0,0,0),
					MUIA_Family_Child,MUI_MakeObject(MUIO_Menuitem,MSG(ITEM_PR_QUIT),MSG(KITEM_PR_QUIT),0,MEN_QUIT),
					End,
				MUIA_Family_Child,MenuObject,
					MUIA_Menu_Title,MSG(MENU_SETTINGS),
					MUIA_Family_Child,MUI_MakeObject(MUIO_Menuitem,MSG(ITEM_SE_LOADDEF),MSG(KITEM_SE_LOADDEF),0,MEN_LOAD),
					MUIA_Family_Child,MUI_MakeObject(MUIO_Menuitem,MSG(ITEM_SE_LOAD),MSG(KITEM_SE_LOAD),0,MEN_LOADAS),
					MUIA_Family_Child,MUI_MakeObject(MUIO_Menuitem,NM_BARLABEL,0,0,0),
					MUIA_Family_Child,MUI_MakeObject(MUIO_Menuitem,MSG(ITEM_SE_SAVEDEF),MSG(KITEM_SE_SAVEDEF),0,MEN_SAVE),
					MUIA_Family_Child,MUI_MakeObject(MUIO_Menuitem,MSG(ITEM_SE_SAVE),MSG(KITEM_SE_SAVE),0,MEN_SAVEAS),
					MUIA_Family_Child,MUI_MakeObject(MUIO_Menuitem,NM_BARLABEL,0,0,0),
					MUIA_Family_Child,MUI_MakeObject(MUIO_Menuitem,MSG(ITEM_SE_MUI),MSG(KITEM_SE_MUI),0,MEN_MUI),
					End,
				MUIA_Family_Child,MUI_NewObjectA(MUIC_Menu,Tags),
				End;
}

Object *MakeGUI(void)
{
	Object *LVObject,*LogoObj=0;

	if (!(Tags=AllocVec(1000,MEMF_ANY)))
	{
		Ende(MSG(ERR_OUTOFMEMORY));
	}

	InitGui();
	InitHooks();
	InitMyListClass();
	LoadImages();

	SaveGadget=MyImageButton(&SaveImage,MSG(GAD_SAVE),MSG(GAD_SAVE_KEY));
	UseGadget=MyImageButton(&UseImage,MSG(GAD_USE),MSG(GAD_USE_KEY));
	TestGadget=MyImageButton(&TestImage,MSG(GAD_TEST),MSG(GAD_TEST_KEY));
	CancelGadget=MyImageButton(&CancelImage,MSG(GAD_CANCEL),MSG(GAD_CANCEL_KEY));

	GruppenListObject=NewObject(CL_MyList->mcc_Class,0,
		MUIA_List_Active,0,
		MUIA_List_AdjustWidth,TRUE,
		MUIA_List_SourceArray,GruppenStrings,
		AnyPageImage ? MUIA_List_MinLineHeight : TAG_IGNORE, MaxPageImageHeight+2,
		InputListFrame,
		End;
	
	MainMenu=MakeMainMenus();

	if (BubbleHelp) LogoObj=MakeLogoObject();

	mainapp=ApplicationObject,
		MUIA_Application_Title,ReqTitle,
		MUIA_Application_Version,"$VER: PrefsAttack " PROG_VERSION_S " ("__DATE2__")",
		MUIA_Application_Copyright,"(C) 1997 Georg Steger",
		MUIA_Application_Author,"Georg Steger",
		MUIA_Application_Description,"Multi purpose preferences program",
		MUIA_Application_Base,ReqTitle,
		GuideFile[0] ? MUIA_Application_HelpFile : TAG_IGNORE,GuideFile,
		SleepIcon ? MUIA_Application_DiskObject : TAG_IGNORE,SleepIcon,

		SubWindow,MainWin=WindowObject,
			MUIA_Window_Title,PrefsName,
			MUIA_Window_ID,MAKE_ID('P','R','A','T'),
			MUIA_Window_NeedsMouseObject,TRUE,
			MUIA_Window_Width,MUIV_Window_Width_MinMax(50),
			MUIA_Window_Height,MUIV_Window_Height_MinMax(50),
			MUIA_Window_AltWidth,MUIV_Window_AltWidth_Visible(90),
			MUIA_Window_AltHeight,MUIV_Window_AltHeight_Visible(80),
			MUIA_Window_Menustrip,MainMenu,
			WindowContents,VGroup,
				Child,HGroup,
					Child,VGroup,
						Child,LVObject=ListviewObject,
							MUIA_CycleChain,1,
							MUIA_Listview_List,GruppenListObject,
							End,
						LogoObj ? Child : TAG_IGNORE,LogoObj,
						End,
					Child,HGroup,
						MUIA_Background,MUII_WindowBack,
						Child,MakeGruppen(),
						End,
					End,
				BubbleHelp ? TAG_IGNORE : Child, BubbleHelp ? 0 : MakeHelpGruppe(),
				Child,HGroup,
					MUIA_Weight,0,
					MUIA_Group_SameWidth,TRUE,
					Child,SaveGadget,
					Child,UseGadget,
					Child,TestGadget,
					Child,CancelGadget,
					End,
				End,
			End,
		End;
		
	if (mainapp)
	{
		set(MainWin,MUIA_Window_ActiveObject,(LONG)LVObject);
		InitMethods();
	}
	FreeVec(Tags);Tags=0;

	return mainapp;
}