/* DoPrefs.c */

#include <OSIncludes.h>
#pragma header

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

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

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

/*==================================================================*/

static char DrawerName[257];

static char FileName[257];

static BOOL GetFile(STRPTR title,BOOL mode)
{
	struct FileRequester *req;
	struct Window *win;
	
	LONG res;
	char *fp;
	BOOL rc=FALSE;
	
	get(MainWin,MUIA_Window_Window,&win);
	
	if (win)
	{
		req=MUI_AllocAslRequest(ASL_FileRequest,0);
		if (req)
		{
			strcpy(DrawerName,FileName);
			fp=FilePart(DrawerName);
			*fp=0;
			sprintf(s,"PrefsAttack: %s",title);
			res=MUI_AslRequestTags(req,
				ASLFR_TitleText,s,
				ASLFR_InitialDrawer,DrawerName,
				ASLFR_InitialFile,FilePart(FileName),
				ASLFR_DoPatterns,TRUE,
				ASLFR_Window,win,
				ASLFR_DoSaveMode,mode,
				TAG_DONE);
				
			if (res)
			{
				strcpy(FileName,req->fr_Drawer);
				AddPart(FileName,req->fr_File,256);
				rc=TRUE;
			}
	
			MUI_FreeAslRequest(req);
		}
	}
	return rc;
}

static void LoadPrefs(STRPTR fname)
{
	struct pioLoad piL;
	struct pioScan piSC;
	struct Objekt *obj;
	struct ObjektItem *item;

	LONG rc;
	WORD inr;

	piL.MethodID=PIOM_LOAD;
	piL.Filename=fname;
	
	if ((*PIORoutine)((Msg)&piL)==PIOR_FAIL) return;

	set(mainapp,MUIA_Application_Sleep,TRUE);

	ResetObjekte();

	piSC.MethodID=PIOM_SCAN;
	do {
		rc=(*PIORoutine)((Msg)&piSC);
		if ((piSC.ScanType!=SCANTYP_NOTHING) && 
		    (piSC.ScanType!=SCANTYP_UNKNOWN))
		{
			if ((obj=FindKeyWord(piSC.KeyWord)))
			{
				switch (obj->ob_Typ)
				{
					case OBJ_BOOL:
						set(obj->ob_MUIGetObject,MUIA_Selected,piSC.Long_Value);
						break;
						
					case OBJ_INTEGER:
						sprintf(s,"%ld",piSC.Long_Value);
						set(obj->ob_MUIGetObject,MUIA_String_Contents,s);
						break;

					case OBJ_SLIDER:
						set(obj->ob_MUIGetObject,MUIA_Slider_Level,piSC.Long_Value);
						break;
						
					case OBJ_STRING:
						set(obj->ob_MUIGetObject,MUIA_String_Contents,piSC.String_Value);
						break;
					
					case OBJ_FILE:
						set(obj->ob_MUIGetObject,MUIA_String_Contents,piSC.String_Value);
						break;

					case OBJ_FONT:
						set(obj->ob_MUIGetObject,MUIA_String_Contents,piSC.String_Value);
						break;
						
					case OBJ_CYCLE:
						if((item=FindItem(obj,piSC.String_Value,&inr)))
						{
							set(obj->ob_MUIGetObject,MUIA_Cycle_Active,inr);
						}
						break;
						
					case OBJ_LISTVIEW:
						DoMethod(obj->ob_MUIGetObject,MUIM_List_InsertSingle,piSC.String_Value,MUIV_List_Insert_Bottom);
						break;
				}
			}
		}
	} while (rc != PIOR_ENDSCAN);
	set(mainapp,MUIA_Application_Sleep,FALSE);

}

static void SavePrefs(STRPTR fname,ULONG method)
{
	struct pioSave piS;
	struct pioScan piSC;
	struct Gruppe *gr;
	struct Seite *se;
	struct Objekt *obj;
	struct ObjektItem *item;

	char *sp;
	LONG l;
	WORD i;

	piS.MethodID=method;
	piS.Filename=fname;
	
	if ((*PIORoutine)((Msg)&piS)==PIOR_FAIL) return;

	piSC.MethodID=PIOM_SCAN;


	gr=(struct Gruppe *)GruppenListe.lh_Head;
	
	set(mainapp,MUIA_Application_Sleep,TRUE);

	while (gr->gr_Node.ln_Succ)
	{
		piSC.ScanType=SCANTYP_GROUP;
		piSC.String_Value=gr->gr_Name;
		
		(*PIORoutine)((Msg)&piSC);
		
		se=(struct Seite *)gr->gr_SeitenListe.lh_Head;
		while (se->se_Node.ln_Succ)
		{
			piSC.ScanType=SCANTYP_PAGE;
			piSC.String_Value=se->se_Name;
		
			(*PIORoutine)((Msg)&piSC);

			obj=(struct Objekt *)se->se_ObjektListe.lh_Head;
			while (obj->ob_Node.ln_Succ)
			{
				piSC.KeyWord=obj->ob_KeyWord;
				switch(obj->ob_Typ)
				{
					case OBJ_BOOL:
						piSC.ScanType=SCANTYP_LONG;
						get(obj->ob_MUIGetObject,MUIA_Selected,&piSC.Long_Value);
						break;
						
					case OBJ_INTEGER:
						piSC.ScanType=SCANTYP_LONG;
						get(obj->ob_MUIGetObject,MUIA_String_Contents,&sp);
						piSC.Long_Value=strtol(sp,0,0);
						break;
						
					case OBJ_SLIDER:
						piSC.ScanType=SCANTYP_LONG;
						get(obj->ob_MUIGetObject,MUIA_Slider_Level,&piSC.Long_Value);
						break;
						
					case OBJ_STRING:
					case OBJ_FILE:
					case OBJ_FONT:
						piSC.ScanType=SCANTYP_STRING;
						get(obj->ob_MUIGetObject,MUIA_String_Contents,&piSC.String_Value);
						break;
						
					case OBJ_CYCLE:
						piSC.ScanType=SCANTYP_STRING;
						get(obj->ob_MUIGetObject,MUIA_Cycle_Active,&l);
						item=(struct ObjektItem *)obj->ob_ItemListe.lh_Head;
						for (i=0;i<l;i++)
						{
							item=(struct ObjektItem *)item->obi_Node.ln_Succ;
						}
						piSC.String_Value=item->obi_KeyWord;
						break;
						
					case OBJ_LISTVIEW:
						get(obj->ob_MUIGetObject,MUIA_List_Entries,&l);
						for (i=0;i<l;i++)
						{
							piSC.ScanType=SCANTYP_STRING;
							DoMethod(obj->ob_MUIGetObject,MUIM_List_GetEntry,i,&piSC.String_Value);
							(*PIORoutine)((Msg)&piSC);
						}
						break;

				}
				
				if (obj->ob_Typ!=OBJ_LISTVIEW)
				{
					(*PIORoutine)((Msg)&piSC);
				}

				obj=(struct Objekt *)obj->ob_Node.ln_Succ;
			} /* Objekte */
			se=(struct Seite *)se->se_Node.ln_Succ;
		} /* Seiten */
		gr=(struct Gruppe *)gr->gr_Node.ln_Succ;
	}	/* Gruppen */
	piSC.ScanType=SCANTYP_ENDSCAN;
	(*PIORoutine)((Msg)&piSC);

	set(mainapp,MUIA_Application_Sleep,FALSE);
	
}

void MyMainMenuHook(struct Hook *hook, Object *o,ULONG *men)
{
	struct pioInfo pi;

	switch (*men)
	{
		case MEN_QUIT:
			DoMethod(mainapp,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);
			break;

		case MEN_ABOUT:
			MUI_Request(mainapp,MainWin,0,ReqTitle,MSG(MSG_REQ_OK),MSG(MSG_ABOUT),
			   "V" PROG_VERSION_S " ("__DATE2__")\n\33n(C) Copyright 1997 by Georg Steger.\nAll rights reserved!",
				FilePart(PrefsFile),
				FilePart(PIOFile),
				AvailMem(MEMF_CHIP),
				AvailMem(MEMF_FAST),
				AvailMem(MEMF_ANY));
			break;
			
		case MEN_ABOUTPIO:
			pi.MethodID=PIOM_INFO;
			pi.Information=0;
			(*PIORoutine)((Msg)&pi);
			
			if (pi.Information)
			{
				MUI_Request(mainapp,MainWin,0,FilePart(PIOFile),MSG(MSG_REQ_OK),pi.Information);
			}
			break;

		case MEN_ABOUTMUI:
			DoMethod(mainapp,MUIM_Application_AboutMUI,MainWin);
			break;

		case MEN_ICONIFY:
			DoMethod(mainapp,MUIM_Set,MUIA_Application_Iconified,TRUE);
			break;
			
		case MEN_LOAD:
			LoadPrefs(0);
			break;
			
		case MEN_LOADAS:
			if (GetFile(MSG(MSG_ASL_LOADTITLE),FALSE))
			{
				LoadPrefs(FileName);
			}
			break;

		case MEN_SAVE:
		case MEN_SAVEGAD:
			SavePrefs(0,PIOM_SAVE);
			if ((*men == MEN_SAVEGAD) && SaveAndQuit)
			{
				DoMethod(mainapp,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);
			}
			break;

		case MEN_SAVEAS:
			if (GetFile(MSG(MSG_ASL_SAVETITLE),TRUE))
			{
				SavePrefs(FileName,PIOM_SAVE);
			}
			break;
			
		case MEN_USEGAD:
			if (!Supports_Use)
			{
				MUI_Request(mainapp,MainWin,0,ReqTitle,MSG(MSG_REQ_OK),MSG(ERR_NOTSUPPORTED_USE));
			} else {
				SavePrefs(0,PIOM_USE);
			}
			break;

		case MEN_TESTGAD:
			if (!Supports_Test)
			{
				MUI_Request(mainapp,MainWin,0,ReqTitle,MSG(MSG_REQ_OK),MSG(ERR_NOTSUPPORTED_TEST));

			} else {
				SavePrefs(0,PIOM_TEST);
			}
			break;

		case MEN_MUI:
			DoMethod(mainapp,MUIM_Application_OpenConfigWindow,0);
			break;

		default:
			if (((*men)>=MEN_SEITE_OFFSET) && ((*men)<=(Anz_Gruppen+MEN_SEITE_OFFSET)))
			{
				DoMethod(GruppenListObject,MUIM_Set,MUIA_List_Active,(*men)-MEN_SEITE_OFFSET);
			}
	}
}

void DoPrefs(void)
{

//	BOOL	Done = FALSE;
	ULONG signals=0;
	
	if (!(mainapp=MakeGUI()))
	{
		Ende(MSG(ERR_NO_WINDOW));
	}

	LoadPrefs(0);

	set(MainWin,MUIA_Window_Open,TRUE);

	while (DoMethod(mainapp,MUIM_Application_NewInput,&signals)
			 !=MUIV_Application_ReturnID_Quit)
	{
		if (signals)
		{
			signals=Wait(signals|SIGBREAKF_CTRL_C);
			if (signals&SIGBREAKF_CTRL_C) break;
		}
	}

	MUI_DisposeObject(mainapp);
	
	EndGUI();
}