/*
**  latinum.dito 2.0
**  (C) Dirk Holtwick, 1996
*/

/// HEADER
#define LOC(a)    GetDITO_latinumString(m_ ## a)
#define OPENCAT   OpenDITO_latinumCatalog(NULL,NULL)
#define CLOSECAT  CloseDITO_latinumCatalog()

#define IPIC0 "\033I[6:38]"
#define IPIC1 "\033I[6:34]"
#define IPIC2 "\033I[6:39]"

struct DITO_InputData {
	Object
		*obj,                      // First pointer has to be the pointer
											// to the whole created object
		*remark,                   // String
		*genitiv,                  // String
		*genus,                    // String
		*adj0,                     // String
		*adj1,                     // String
		*adj2,                     // String
		*verb0,                    // String
		*verb1,                    // String
		*verb2;                    // String
};

struct DITO_OutputData {
	Object
		*obj,                      // First Pointer points to created object

		*kind,                     // Text
		*info,                     // Floattext
		*grammar,                  // Group
		*weight,                   // Text
		*text1,                    // Text
		*text2;                    // Text
};
///

/// DITO_GetExtInfo
char  *Types[5];

SAVEDS ASM struct DITO_ExtInfo *DITO_GetExtInfo(void)
{
	static struct DITO_ExtInfo info;

	Types[0] = LOC(part0);
	Types[1] = LOC(part1);
	Types[2] = LOC(part2);
	Types[3] = LOC(part3);

	info.Language    = LOC(language);
	info.Author      = AUTHOR;
	info.Version     = VERSIONSTR;
	info.Date        = __DATE__;
	info.Description = LOC(description);

	info.NumTypes    = 4;
	info.Types       = Types;

	return(&info);
}
///

/// DITO_CreateInput
SAVEDS ASM struct DITO_InputData *DITO_CreateInput(REG(a0) Object *app)
{
	struct   DITO_InputData *data;
	static char *strtab[5], *gentab[5];

	strtab[0] = LOC(part0);
	strtab[1] = LOC(part1);
	strtab[2] = LOC(part2);
	strtab[3] = LOC(part3);
	strtab[4] = 0;

	gentab[0] = LOC(gen0);
	gentab[1] = LOC(gen1);
	gentab[2] = LOC(gen2);
	gentab[3] = "Commune"; //LOC(gen3);
	gentab[4] = 0;

	if(data = AllocVec(sizeof(struct DITO_InputData),0)){

		data->obj = RegisterObject,

			MUIA_CycleChain, 1,
			MUIA_ShortHelp, "AMIGA + t",
			MUIA_Register_Titles, strtab,
			MUIA_Frame, MUIV_Frame_Group,

			// Übriges
			// *******
			Child, VGroup,
				Child, LLabel(LOC(remark)),
				Child, data->remark = StringObject,
					MUIA_CycleChain, 1,
					MUIA_Frame, MUIV_Frame_String,
					MUIA_String_Format, MUIV_String_Format_Center,
					MUIA_String_AdvanceOnCR, TRUE,
					End,
				End,

			// Substantiv
			// **********
			Child, HGroup,
				Child, VGroup,
					Child, LLabel(LOC(genitiv)),
					Child, data->genitiv = StringObject,
						MUIA_CycleChain, 1,
						MUIA_Frame, MUIV_Frame_String,
						MUIA_String_Format, MUIV_String_Format_Center,
						MUIA_String_AdvanceOnCR, TRUE,
						End,
					End,
				Child, data->genus = RadioObject,
					MUIA_CycleChain, 1,
					NoFrame,
					MUIA_ControlChar, 'g',
					MUIA_ShortHelp, "AMIGA + g",
					MUIA_Radio_Entries, gentab,
					End,
				End,

			// Adjektiv
			// ********
			Child, ColGroup(3),
				Child, LLabel(LOC(adj0)),
				Child, LLabel(LOC(adj1)),
				Child, LLabel(LOC(adj2)),
				Child, data->adj0 = StringObject,
					MUIA_CycleChain, 1,
					MUIA_Frame, MUIV_Frame_String,
					MUIA_String_Format, MUIV_String_Format_Center,
					MUIA_String_AdvanceOnCR, TRUE,
					End,
				Child, data->adj1 = StringObject,
					MUIA_CycleChain, 1,
					MUIA_Frame, MUIV_Frame_String,
					MUIA_String_Format, MUIV_String_Format_Center,
					MUIA_String_AdvanceOnCR, TRUE,
					End,
				Child, data->adj2 = StringObject,
					MUIA_CycleChain, 1,
					MUIA_Frame, MUIV_Frame_String,
					MUIA_String_Format, MUIV_String_Format_Center,
					MUIA_String_AdvanceOnCR, TRUE,
					End,
				End,

			// Verb
			// ****
			Child, ColGroup(3),
				Child, LLabel(LOC(verb0)),
				Child, LLabel(LOC(verb1)),
				Child, LLabel(LOC(verb2)),
				Child, data->verb0 = StringObject,
					MUIA_CycleChain, 1,
					MUIA_Frame, MUIV_Frame_String,
					MUIA_String_Format, MUIV_String_Format_Center,
					MUIA_String_AdvanceOnCR, TRUE,
					End,
				Child, data->verb1 = StringObject,
					MUIA_CycleChain, 1,
					MUIA_Frame, MUIV_Frame_String,
					MUIA_String_Format, MUIV_String_Format_Center,
					MUIA_String_AdvanceOnCR, TRUE,
					End,
				Child, data->verb2 = StringObject,
					MUIA_CycleChain, 1,
					MUIA_Frame, MUIV_Frame_String,
					MUIA_String_Format, MUIV_String_Format_Center,
					MUIA_String_AdvanceOnCR, TRUE,
					End,
				End,
			End;

		  return(data);
	}

	return(0);
}
///
/// DITO_DisposeInput
SAVEDS ASM void DITO_DisposeInput(REG(a0) struct DITO_InputData *data)
{
	if(data) FreeVec(data);
}
///
/// DITO_ClearInput
SAVEDS ASM void DITO_ClearInput(REG(a0) struct DITO_InputData *data)
{
	set(data->remark,  MUIA_String_Contents, "");
	set(data->genitiv, MUIA_String_Contents, "");
	set(data->adj0,    MUIA_String_Contents, "");
	set(data->adj1,    MUIA_String_Contents, "");
	set(data->adj2,    MUIA_String_Contents, "");
	set(data->verb0,   MUIA_String_Contents, "");
	set(data->verb1,   MUIA_String_Contents, "");
	set(data->verb2,   MUIA_String_Contents, "");
	set(data->genus,   MUIA_Radio_Active, 0);
}
///
/// DITO_WriteInput
SAVEDS ASM void DITO_WriteInput(REG(a0) struct DITO_InputData *data, REG(a1) struct DITO_Entry *entry)
{
	set (data->obj, MUIA_Group_ActivePage, DITO_GetVal (entry, DITO_Val_Type));

	DITO_ClearInput (data);

	switch(DITO_GetVal (entry, DITO_Val_Type)){

		// Default
		case 0:
			set(data->remark, MUIA_String_Contents, DITO_GetStr(entry,0));
			break;

		// Noun
		case 1:
			set(data->genitiv, MUIA_String_Contents, DITO_GetStr(entry,0));
			set(data->genus,   MUIA_Radio_Active,    DITO_GetVal(entry,0));
			break;

		// Adjective
		case 2:
			set(data->adj0, MUIA_String_Contents, DITO_GetStr(entry,0));
			set(data->adj1, MUIA_String_Contents, DITO_GetStr(entry,1));
			set(data->adj2, MUIA_String_Contents, DITO_GetStr(entry,2));
			break;

		// Verb
		case 3:
			set(data->verb0, MUIA_String_Contents, DITO_GetStr(entry,0));
			set(data->verb1, MUIA_String_Contents, DITO_GetStr(entry,1));
			set(data->verb2, MUIA_String_Contents, DITO_GetStr(entry,2));
			break;
	}
}
///
/// DITO_ReadInput
SAVEDS ASM BOOL DITO_ReadInput(REG(a0) struct DITO_InputData *data, REG(a1) struct DITO_EntryInfo *vi, REG(a2) struct DITO_Entry *entry)
{
	BOOL  changed = FALSE;

	get (data->obj, MUIA_Group_ActivePage, &vi->type);

	switch(vi->type){

		// Default
		case 0:
			vi->snum=1;
			get (data->remark, MUIA_String_Contents, &vi->gr[0]);
			if(entry) changed = strcmp(DITO_GetStr(entry,0), vi->gr[0]);
			break;

		// Noun
		case 1:
			vi->snum=1;
			get (data->genitiv, MUIA_String_Contents, &vi->gr[0]);
			get (data->genus,   MUIA_Radio_Active, &vi->val[0]);
			if(entry){
				changed =
					strcmp(DITO_GetStr(entry,0), vi->gr[0])
				|| (DITO_GetVal(entry, 0) != vi->val[0]);
			}
			break;

		// Adjective
		case 2:
			vi->snum=3;
			get (data->adj0, MUIA_String_Contents, &vi->gr[0]);
			get (data->adj1, MUIA_String_Contents, &vi->gr[1]);
			get (data->adj2, MUIA_String_Contents, &vi->gr[2]);
			if(entry){
				changed =
					strcmp(DITO_GetStr(entry,2), vi->gr[2])
				|| strcmp(DITO_GetStr(entry,1), vi->gr[1])
				|| strcmp(DITO_GetStr(entry,0), vi->gr[0]);
			}
			break;

		// Verb
		case 3:
			vi->snum=3;
			get (data->verb0, MUIA_String_Contents, &vi->gr[0]);
			get (data->verb1, MUIA_String_Contents, &vi->gr[1]);
			get (data->verb2, MUIA_String_Contents, &vi->gr[2]);
			if(entry){
				changed =
					strcmp(DITO_GetStr(entry,2), vi->gr[2])
				|| strcmp(DITO_GetStr(entry,1), vi->gr[1])
				|| strcmp(DITO_GetStr(entry,0), vi->gr[0]);
			}
			break;
	}
	return(changed);
}
///
/// DITO_ActivateFirstInput
SAVEDS ASM Object *DITO_ActivateFirstInput(REG(a0) struct DITO_InputData *data)
{
	LONG  p;

	get (data->obj, MUIA_Group_ActivePage, &p);
	switch(p){
		case 0:  return(data->remark);
		case 1:  return(data->genitiv);
		case 2:  return(data->adj0);
		case 3:  return(data->verb0);
	}
}
///
/// DITO_FontsInput
SAVEDS ASM void DITO_FontsInput(REG(a0) struct DITO_InputData *data, REG(d0) APTR word, REG(d1) APTR trans, REG(d2) APTR phon)
{
	set(data->remark,       MUIA_Font, word);
	set(data->genitiv,      MUIA_Font, word);
	set(data->verb0,        MUIA_Font, word);
	set(data->verb1,        MUIA_Font, word);
	set(data->verb2,        MUIA_Font, word);
	set(data->adj0,         MUIA_Font, word);
	set(data->adj1,         MUIA_Font, word);
	set(data->adj2,         MUIA_Font, word);
}
///
/// DITO_UpdateInput
SAVEDS ASM void DITO_UpdateInput(REG(a0) struct DITO_InputData *data)
{
}
///

/// DITO_CreateOutput
SAVEDS ASM struct DITO_OutputData *DITO_CreateOutput(REG(a0) Object *app)
{
	struct   DITO_OutputData *data;
	static   char *strtab[5];

	strtab[0] = LOC(part0);
	strtab[1] = LOC(part1);
	strtab[2] = LOC(part2);
	strtab[3] = LOC(part3);
	strtab[4] = 0;

	if(data = AllocVec(sizeof(struct DITO_OutputData),0)){

		data->obj = VGroup,
			Child, VGroup,
				MUIA_Frame, MUIV_Frame_Group,
				Child, HGroup,
					MUIA_Background, MUII_TextBack,
					MUIA_Frame, MUIV_Frame_Text,
					Child, data->kind = TextObject,
						MUIA_Text_PreParse, "\033c\033b",
						MUIA_Weight, 5000,
//                  MUIA_Text_SetMin, TRUE,
						End,
					Child, data->weight = TextObject,
						MUIA_Text_Contents, IPIC0,
						MUIA_Text_SetMin, TRUE,
						End,
					End,
				Child, data->info = ListviewObject,
					MUIA_Frame, MUIV_Frame_Text,
					MUIA_Background, MUII_TextBack,
					MUIA_Listview_Input, FALSE,
//             MUIA_Listview_ScrollerPos, MUIV_Listview_ScrollerPos_None,
					MUIA_Listview_List, FloattextObject,
						MUIA_Background, MUII_TextBack,
//                  MUIA_Font, trans,
						MUIA_List_Format, "p=\033c",
						End,
					End,
				End,
/*         Child, data->grammar = VGroup,
				MUIA_FrameTitle, LOC(grammar),
				MUIA_Frame, MUIV_Frame_Group,
				MUIA_Group_PageMode, TRUE,
				MUIA_VertDisappear, 1,

				// Rest
				Child, TextObject,
					MUIA_Text_Contents, "\033cKeine Angaben",
					End,

				// Noun
				Child, data->text1 = TextObject,
					MUIA_Font, word,
					MUIA_ShortHelp, "Singular\nPlural",
					MUIA_Frame, MUIV_Frame_Text,
					MUIA_Background, MUII_TextBack,
					MUIA_Text_Contents, "\033c\n",
					End,

				// Verb
				Child, data->text2 = TextObject,
					MUIA_Font, word,
					MUIA_ShortHelp, "Infinitiv\nPräteritum\nPartizip Perfekt",
					MUIA_Frame, MUIV_Frame_Text,
					MUIA_Background, MUII_TextBack,
					MUIA_Text_Contents, "\033c\n\n",
					End,
				End,
*/
			End;

		return(data);
	}

	return(0);
}
///
/// DITO_DisposeOutput
SAVEDS ASM void DITO_DisposeOutput(REG(a0) struct DITO_OutputData *data)
{
	if(data) FreeVec(data);
}
///
/// DITO_WriteOutput
extern SAVEDS ASM char *DITO_GrammarString (REG(a0) APTR entry, REG(a1) char *str);

SAVEDS ASM void DITO_WriteOutput(REG(a0) struct DITO_OutputData *data, REG(a1) struct DITO_Entry *entry)
{
	static char str[1000],gr[700];
//   static char form[500];
	static char *imptab[3];

	imptab[0] = IPIC0;
	imptab[1] = IPIC1;
	imptab[2] = IPIC2;

	set(data->weight, MUIA_Text_Contents, imptab[DITO_GetVal (entry, DITO_Val_Weight)]);

//   set(data->grammar, MUIA_Group_ActivePage, DITO_GetVal (entry, DITO_Val_Type));

	sprintf (str,"\n\033b%s\033n\n\n%s\n\n\033i%s",
		DITO_GrammarString (entry, gr),
		DITO_GetStr(entry, DITO_Str_Translation),
		DITO_GetStr(entry, DITO_Str_Note)
	);

	switch(DITO_GetVal (entry, DITO_Val_Type)){

		// Default
		case 0:
			set(data->kind, MUIA_Text_Contents, LOC(part0));
			break;

		// Noun
		case 1:
			set(data->kind, MUIA_Text_Contents, LOC(part1));
/*         if(DITO_GetStr(entry, 0)[0]){
				sprintf(form,"\033c%s\n\0338%s",DITO_GetStr(entry,DITO_Str_Word),DITO_GetStr(entry, 0));
			}else{
				sprintf(form,"\033c%s\n%ss",DITO_GetStr(entry,DITO_Str_Word),DITO_GetStr(entry, DITO_Str_Word));
			}
			set(data->text1, MUIA_Text_Contents, form);
*/         break;

		// Adjective
		case 2:
			set(data->kind, MUIA_Text_Contents, LOC(part2));
			break;

		// Verb
		case 3:
			set(data->kind, MUIA_Text_Contents, LOC(part3));
/*         strcpy(form,"\033c");
			strcat(form,DITO_GetStr(entry,DITO_Str_Word));
			if(DITO_GetStr(entry, 0)[0]){
				strcat(form,"\n\0338");
				strcat(form,DITO_GetStr(entry,0));
			}else{
				strcat(form,"\n\0330");
				strcat(form,DITO_GetStr(entry,DITO_Str_Word));
				strcat(form,"ed");
			}
			if(DITO_GetStr(entry, 1)[0]){
				strcat(form,"\n\0338");
				strcat(form,DITO_GetStr(entry,1));
			}else{
				strcat(form,"\n\0330");
				strcat(form,DITO_GetStr(entry,DITO_Str_Word));
				strcat(form,"ed");
			}
			set(data->text2, MUIA_Text_Contents, form);
*/         break;
	}

	set(data->info,   MUIA_Floattext_Text, str);
}
///
/// DITO_FontsOutput
SAVEDS ASM void DITO_FontsOutput (REG(a0) struct DITO_OutputData *data, REG(d0) APTR word, REG(d1) APTR trans, REG(d2) APTR phon){
}
///
/// DITO_UpdateOutput
SAVEDS ASM void DITO_UpdateOutput(REG(a0) struct DITO_OutputData *data, REG(a1) struct DITO_Entry *entry)
{
}
///
/// DITO_ParseInput
SAVEDS ASM Object *DITO_ParseInput (REG(a0) struct DITO_InputData *data, REG(a1) char *in, REG(a2) char *out){
	return(DITO_ActivateFirstInput(data));
}
///

/// DITO_GrammarString
SAVEDS ASM char *DITO_GrammarString (REG(a0) APTR entry, REG(a1) char *str){
	char  *h,*h2;
	int   v;
	static char *gen[4]={"m.","f.","n.","m.+f."};

	switch(DITO_GetVal(entry, DITO_Val_Type)){

		// Rest
		case 0:
			h = DITO_GetStr(entry, 0);
			if(*h) sprintf(str,"%s (%s)", DITO_GetStr(entry, DITO_Str_Word),h);
			else strcpy(str, DITO_GetStr(entry, DITO_Str_Word));
			break;

		// Noun
		case 1:
			h = DITO_GetStr(entry, 0);
			if(*h) sprintf(str,"%s, %s %s", DITO_GetStr(entry, DITO_Str_Word),h,gen[DITO_GetVal(entry, 0)]);
			else sprintf(str,"%s %s", DITO_GetStr(entry, DITO_Str_Word),gen[DITO_GetVal(entry, 0)]);
			break;

/*
		// Adjektive
		case 2:
			v = DITO_GetVal(entry, 0);
			if(v) sprintf(str,"%s (adj. inv.)", DITO_GetStr(entry, DITO_Str_Word));
			else sprintf(str,"%s (adj.)", DITO_GetStr(entry, DITO_Str_Word));
			break;

		// Verb
		case 4:
			v = DITO_GetVal(entry, 0);
			if(v) sprintf(str,"%s (irr. #%d)", DITO_GetStr(entry, DITO_Str_Word),v);
			else sprintf(str,"%s", DITO_GetStr(entry, DITO_Str_Word));
			break;

		// Expression
		case 5:
			h = DITO_GetStr(entry, 0);
			if(*h) sprintf(str, "\"%s\" (%s)", DITO_GetStr(entry, DITO_Str_Word),h);
			else sprintf(str, "\"%s\"", DITO_GetStr(entry, DITO_Str_Word));
			break;
*/
		// else ... Adverb
		default:
			strcpy(str, DITO_GetStr(entry, DITO_Str_Word));
			break;
	}
	return(str);
}
///