/* Main-Header File inserted by GenCodeC */
/* Libraries */
#include <libraries/mui.h>
#include <libraries/gadtools.h> /* for BARLABEL in MenuItem */

/* Prototypes */
#include <clib/muimaster_protos.h>
#include <clib/exec_protos.h>
#include <clib/alib_protos.h>
#include <clib/dos_protos.h>


/*  Pragmas  */
#include <pragmas/muimaster_pragmas.h>
#include <pragmas/exec_pragmas.h>

/*  Ansi  */
#include <stdlib.h>
#include <stdio.h>
/* GenCodeC header end */

/* Include generated by GenCodeC */
#include "GenCodeCGUI.h"

#include <exec/memory.h>
#include <string.h>

#include "TextField.h"
#include "Tools.h"
#include "GenCodeC.h"
#include "MB.h"
#include "MB_pragmas.h"
#include "MB_protos.h"

/* defines for header file */
#define  HHEADER     1
#define  CHEADER     2
#define  MAINHEADER  3

#define  LOCALSAVE   1
#define  GLOBALSAVE  2

/* Global variables */
BOOL  TextFieldLocked = FALSE;

struct ObjTextField	*TF_H_Header;
struct ObjTextField	*TF_C_Header;
struct ObjTextField	*TF_Main_Header;

char 	*H_Header_Text;
char 	*C_Header_Text;
char 	*Main_Header_Text;

static const char vers[] = "\0$VER: GenCodeC 2.2ß  27.09.95";

/* Declarations for libraries (inserted by GenCodeC) */
struct Library * MUIMasterBase;

struct Library * DOSBase = NULL;
struct Library * MUIBBase = NULL;

/* Init() function */
void init( void )
{
	if (!(MUIMasterBase = OpenLibrary(MUIMASTER_NAME,MUIMASTER_VMIN)))
	{
		DisplayMsg("Can't Open MUIMaster Library\n");
		exit(20);
	}

	if (!(DOSBase  = OpenLibrary("dos.library", 0)))
	{
		DisplayMsg("Can't Open Dos Library\n");
		CloseLibrary(MUIMasterBase);
		exit(20);
	}

	if (!(MUIBBase = OpenLibrary("muibuilder.library", 0)))
	{
		DisplayMsg("Can't Open MUIBuilder Library\n");
		CloseLibrary(MUIMasterBase);
		CloseLibrary(DOSBase);
		exit(20);
	}
	
	/* exit if we can't init the Library */
	if (!MB_Open())
	{
		DisplayMsg("Unable to Get Temporary files !\n");
		MB_Close();
		CloseLibrary(MUIMasterBase);
		CloseLibrary(DOSBase);
		CloseLibrary(MUIBBase);
		exit(20);
	}
}
/* GenCodeC init() end */

void UnlockTextFieldTexts(struct ObjTextField *,char *,struct ObjTextField *,char *,struct ObjTextField *,char *);

/* End() function */
void end( void )
{
	MB_Close();    /* Free Memory and Close Temporary Files */

	if (TextFieldLocked)
	{
		UnlockTextFieldTexts(TF_H_Header,H_Header_Text,
							 TF_C_Header,C_Header_Text,
							 TF_Main_Header,Main_Header_Text);
	}

	ClearMemory();

	CloseLibrary(MUIBBase);
	CloseLibrary(DOSBase);
	CloseLibrary(MUIMasterBase);
	exit(20);
}
/* GenCodeC end() end */

/* Read a header file and load it in memory */
char *LoadHeaderFile(int HeaderFile)
{
	char  *TMPFile;
	char  *HF;
	int   size;
	char  *MBDir=NULL;
	char  *FileName;
	
	MB_Get(MUIB_FileName,&FileName,TAG_END);
	
	/* Get Current Directory Name */
	if (!(MBDir = GetCurrentDirectory()))
	{
		return NULL;
	}
	  
	size = strlen(MBDir)+1+9+1+strlen(FilePart(FileName))+12+1;
	if (!(TMPFile = AllocMemory(size)))
	{
		FreeMemory(MBDir);
		return NULL;
	}
	else
	{
		/* Try to read local header and if there's no local header, try to read global header */
	
		strcpy(TMPFile,MBDir);
		AddPart(TMPFile,"C_Headers",size);
		AddPart(TMPFile,FilePart(FileName),size);
		remove_extend(TMPFile);
		switch(HeaderFile)
		{
			case HHEADER:
				add_extend(TMPFile,".H-Header");
				break;
			
			case CHEADER:
				add_extend(TMPFile,".C-Header");
				break;
			
			case MAINHEADER:
				add_extend(TMPFile,".Main-Header");
				break;
		}
		if (!(HF = LoadFileInRAM(TMPFile,TRUE)))
		{
			FreeMemory(TMPFile);
			size = strlen(MBDir)+1+9+1+12+1;
			if (!(TMPFile = AllocMemory(size)))
			{
				FreeMemory(MBDir);
				return NULL;
			}
			else
			{
				strcpy(TMPFile,MBDir);
				AddPart(TMPFile,"C_Headers",size);
				switch(HeaderFile)
				{
					case HHEADER:
						AddPart(TMPFile,"H-Header",size);
						break;
					
					case CHEADER:
						AddPart(TMPFile,"C-Header",size);
						break;
					
					case MAINHEADER:
						AddPart(TMPFile,"Main-Header",size);
						break;
				}
				HF = LoadFileInRAM(TMPFile,FALSE);
				FreeMemory(MBDir);
				FreeMemory(TMPFile);
				return HF;
			}
		}
		else
		{
			FreeMemory(MBDir);
			FreeMemory(TMPFile);
			return HF;
		}
	}
}

/* Save a header file */
void SaveHeaderFile(int HeaderFile,char *HeaderText,int PrefsSave)
{
	char  *TMPFile;
	int   size;
	char  *MBDir = NULL;
	char  *FileName;
	BOOL  Prefs = (PrefsSave==LOCALSAVE);
	FILE  *file;
	
	MB_Get(MUIB_FileName,&FileName,TAG_END);
	
	/* Get Current Directory Name */
	if (!(MBDir = GetCurrentDirectory()))
	{
		return;
	}
	  
	size = strlen(MBDir)+1+9+((Prefs) ? (1+strlen(FilePart(FileName))):1)+12+1;
	if (!(TMPFile = AllocMemory(size)))
	{
		FreeMemory(MBDir);
		return;
	}
	else
	{
		strcpy(TMPFile,MBDir);
		AddPart(TMPFile,"C_Headers",size);
		if (Prefs)
		{
			AddPart(TMPFile,FilePart(FileName),size);
			remove_extend(TMPFile);
		}
		switch(HeaderFile)
		{
			case HHEADER:
				(Prefs) ? add_extend(TMPFile,".H-Header") : AddPart(TMPFile,"H-Header",size);
				break;
			
			case CHEADER:
				(Prefs) ? add_extend(TMPFile,".C-Header") : AddPart(TMPFile,"C-Header",size);
				break;
			
			case MAINHEADER:
				(Prefs) ? add_extend(TMPFile,".Main-Header") : AddPart(TMPFile,"Main-Header",size);
				break;
		}
		if (file = fopen(TMPFile,"w"))
		{
			FreeMemory(MBDir);
			FreeMemory(TMPFile);
			fwrite(HeaderText,1,strlen(HeaderText),file);
			fclose(file);
		}
	}
}

void CreateTextFieldObjects(struct ObjApp *App,
							struct ObjTextField **TF_H_Header,
							struct ObjTextField **TF_C_Header,
							struct ObjTextField **TF_Main_Header)
{
	char  *HeaderText;
	
	if (!(*TF_H_Header = CreateTextField()))
	{
		DisplayMsg("Can't Create Textfield object\n");
		DisposeApp(App);
		end();
	}
	DoMethod(App->GR_H_Header, OM_ADDMEMBER, (*TF_H_Header)->textfield);
	HeaderText = LoadHeaderFile(HHEADER);
	if (HeaderText)
	{
		set((*TF_H_Header)->text,TEXTFIELD_Text,HeaderText);
		FreeMemory(HeaderText);
	}
	
	if (!(*TF_C_Header = CreateTextField()))
	{
		DisplayMsg("Can't Create Textfield object\n");
		DisposeTextField(*TF_H_Header);
		DisposeApp(App);
		end();
	}
	DoMethod(App->GR_C_Header, OM_ADDMEMBER, (*TF_C_Header)->textfield);
	HeaderText = LoadHeaderFile(CHEADER);
	if (HeaderText)
	{
		set((*TF_C_Header)->text,TEXTFIELD_Text,HeaderText);
		FreeMemory(HeaderText);
	}
	
	if (!(*TF_Main_Header = CreateTextField()))
	{
		DisplayMsg("Can't Create Textfield object\n");
		DisposeTextField(*TF_H_Header);
		DisposeTextField(*TF_C_Header);
		DisposeApp(App);
		end();
	}
	DoMethod(App->GR_Main_Header, OM_ADDMEMBER, (*TF_Main_Header)->textfield);
	HeaderText = LoadHeaderFile(MAINHEADER);
	if (HeaderText)
	{
		set((*TF_Main_Header)->text,TEXTFIELD_Text,HeaderText);
		FreeMemory(HeaderText);
	}
}

void LockTextFieldTexts(struct ObjApp *App,
						struct ObjTextField *TF_H_Header,char **H_Header_Text,
						struct ObjTextField *TF_C_Header,char **C_Header_Text,
						struct ObjTextField *TF_Main_Header,char **Main_Header_Text)
{
	char  *text;
	ULONG    size;
	
	set(TF_H_Header->text,TEXTFIELD_ReadOnly,TRUE);
	set(TF_C_Header->text,TEXTFIELD_ReadOnly,TRUE);
	set(TF_Main_Header->text,TEXTFIELD_ReadOnly,TRUE);
	
	get(TF_H_Header->text,TEXTFIELD_Size,&size);
	get(TF_H_Header->text,TEXTFIELD_Text,&text);
	if (!(*H_Header_Text = AllocMemory(size+1)))
	{
		DisposeTextField(TF_H_Header);
		DisposeTextField(TF_C_Header);
		DisposeTextField(TF_Main_Header);
		DisposeApp(App);
		end();
	}
	strncpy(*H_Header_Text,text,size);
	(*H_Header_Text)[size]='\0';
	
	get(TF_C_Header->text,TEXTFIELD_Size,&size);
	get(TF_C_Header->text,TEXTFIELD_Text,&text);
	if (!(*C_Header_Text = AllocMemory(size+1)))
	{
		FreeMemory(*H_Header_Text);
		DisposeTextField(TF_H_Header);
		DisposeTextField(TF_C_Header);
		DisposeTextField(TF_Main_Header);
		DisposeApp(App);
		end();
	}
	strncpy(*C_Header_Text,text,size);
	(*C_Header_Text)[size]='\0';
	
	get(TF_Main_Header->text,TEXTFIELD_Size,&size);
	get(TF_Main_Header->text,TEXTFIELD_Text,&text);
	if (!(*Main_Header_Text = AllocMemory(size+1)))
	{
		FreeMemory(*H_Header_Text);
		FreeMemory(*C_Header_Text);
		DisposeTextField(TF_H_Header);
		DisposeTextField(TF_C_Header);
		DisposeTextField(TF_Main_Header);
		DisposeApp(App);
		end();
	}
	strncpy(*Main_Header_Text,text,size);
	(*Main_Header_Text)[size]='\0';

	TextFieldLocked = TRUE;
}

void UnlockTextFieldTexts(struct ObjTextField *TF_H_Header,char *H_Header_Text,
							struct ObjTextField *TF_C_Header,char *C_Header_Text,
							struct ObjTextField *TF_Main_Header,char *Main_Header_Text)
{
	set(TF_H_Header->text,TEXTFIELD_ReadOnly,FALSE);
	set(TF_C_Header->text,TEXTFIELD_ReadOnly,FALSE);
	set(TF_Main_Header->text,TEXTFIELD_ReadOnly,FALSE);
	
	FreeMemory(H_Header_Text);
	FreeMemory(C_Header_Text);
	FreeMemory(Main_Header_Text);

	TextFieldLocked = FALSE;
}

/* Main Function inserted by GenCodeC */
int main(int argc,char **argv)
{
	struct ObjApp		* App = NULL; /* Object */
	BOOL				running = TRUE;
	ULONG				signal;
	BOOL				Locale;

	/* Program initialisation : generated by GenCodeC */
	init();
	
	/* Create Object : generated by GenCodeC */
	if (!(App = CreateApp()))
	{
		DisplayMsg("Can't Create App\n");
		end();
	}
	
	CreateTextFieldObjects(App,&TF_H_Header,&TF_C_Header,&TF_Main_Header);

	MB_Get(MUIB_Locale,&Locale,TAG_DONE);
	if (!Locale)
		set(App->GR_Catalog,MUIA_ShowMe,FALSE);
	
	set(App->WI_C_Generation,
		MUIA_Window_Open, TRUE
		);
	
	while (running)
	{
		switch (DoMethod(App->App,MUIM_Application_Input,&signal))
		{
			case MUIV_Application_ReturnID_Quit:
			running = FALSE;
			break;
			
			/* Insert your code between the "case" statement and comment "end of case ..." */
			case ID_BT_SAVE_LOCAL:
			{
				LockTextFieldTexts(App,TF_H_Header,&H_Header_Text,
									   TF_C_Header,&C_Header_Text,
									   TF_Main_Header,&Main_Header_Text);
					
				SaveHeaderFile(HHEADER,H_Header_Text,LOCALSAVE);
				SaveHeaderFile(CHEADER,C_Header_Text,LOCALSAVE);
				SaveHeaderFile(MAINHEADER,Main_Header_Text,LOCALSAVE);
					
				UnlockTextFieldTexts(TF_H_Header,H_Header_Text,
									 TF_C_Header,C_Header_Text,
									 TF_Main_Header,Main_Header_Text);
			}
			break;
			/* end of case ID_BT_SAVE_LOCAL */

			case ID_BT_SAVE_GLOBAL:
			{
				LockTextFieldTexts(App,TF_H_Header,&H_Header_Text,
									   TF_C_Header,&C_Header_Text,
									   TF_Main_Header,&Main_Header_Text);
					
				SaveHeaderFile(HHEADER,H_Header_Text,GLOBALSAVE);
				SaveHeaderFile(CHEADER,C_Header_Text,GLOBALSAVE);
				SaveHeaderFile(MAINHEADER,Main_Header_Text,GLOBALSAVE);
					
				UnlockTextFieldTexts(TF_H_Header,H_Header_Text,
									 TF_C_Header,C_Header_Text,
									 TF_Main_Header,Main_Header_Text);
			}
			break;
			/* end of case ID_BT_SAVE_GLOBAL */

			case ID_BT_GENERATE:
			{	
				LockTextFieldTexts(App,TF_H_Header,&H_Header_Text,
									   TF_C_Header,&C_Header_Text,
									   TF_Main_Header,&Main_Header_Text);
					
				GenerateCode(App,H_Header_Text,C_Header_Text,Main_Header_Text);
					
				UnlockTextFieldTexts(TF_H_Header,H_Header_Text,
									 TF_C_Header,C_Header_Text,
									 TF_Main_Header,Main_Header_Text);
			}
			break;
			/* end of case ID_BT_GENERATE */

			/* End computing of IDCMP */
		}
		if (running && signal) Wait(signal);
	}
	DisposeApp(App);
	end();
}