/*
**  italiano.dito
**  (C) Dirk Holtwick, 1996
*/

/// HEADER
#include "data.h"

#define DITO_DoUpdate 1

#define IRRSTR(d,a) Child, data->d[a] = StringObject,\
		MUIA_CycleChain, 1,\
		MUIA_String_Format, MUIV_String_Format_Center,\
		End

#define IRRONE(d,a) VGroup,\
	Child, CLabel("1. Person Singular"),\
	Child, data->d[a] = StringObject,\
		MUIA_CycleChain, 1,\
		MUIA_String_Format, MUIV_String_Format_Center,\
		MUIA_Frame, MUIV_Frame_String,\
		End,\
	End

#define IRRGR(d,a) VGroup,\
	MUIA_Frame, MUIV_Frame_String,\
	MUIA_InnerBottom, 0,\
	MUIA_InnerLeft, 0,\
	MUIA_InnerRight, 0,\
	MUIA_InnerTop, 0,\
	MUIA_Group_VertSpacing, 0,\
	IRRSTR(d,a+0),\
	IRRSTR(d,a+1),\
	IRRSTR(d,a+2),\
	IRRSTR(d,a+3),\
	IRRSTR(d,a+4),\
	IRRSTR(d,a+5),\
	End

#define IDX_PP 0
#define IDX_GERUND 1
#define IDX_PRESENTE 2
#define IDX_IMPERFETTO 8
#define IDX_REMOTO 14
#define IDX_FUTURO 20
#define IDX_CONDIZIONALE 26
#define IDX_IMPERATIVO 32
#define IDX_CPRESENTE 37
#define IDX_CIMPERFETTO 43
#define IDX 49

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

#ifndef MAKE_ID
#define MAKE_ID(a,b,c,d) ((ULONG) (a)<<24 | (ULONG) (b)<<16 | (ULONG) (c)<<8 | (ULONG) (d))
#endif

extern SAVEDS ASM char *DITO_GrammarString (REG(a0) APTR entry, REG(a1) char *str);

char  *Types[5];

///

/// struct DITO_InputData
struct DITO_InputData
{
	Object
		*obj,                      // First pointer has to be the pointer
											// to the whole created object
		*remark,                   // String
		*rremark,                  // String
		*article,                  // Cycle
		*isplural,                 // Checkmark
		*plural,                   // String
		*genus,                    // Radio
		*disable,                  // Group
		*adj,                      // Checkmark
		*essere,                   // Radio
		*irr,                      // Checkmark
		*btirr,                    // Button
		*isc,                      // Checkmark

		*win,                      // Window
		*cycle,                    // Cycle
		*pgroup,                   // Group
		*str[IDX],                 // String
		*bt,                       // Button

		*app;                      // Application
};
///
/// struct DITO_OutputData
struct DITO_OutputData
{
	Object
		*obj,
		*kind,                     // Text
		*info,                     // Floattext
		*text,                     // Text
		*noun,                     // Text
		*grammar,                  // Group
		*weight,                   // Text
		*diathese,                 // Cycle
		*modus,                    // Cycle
		*tempus;                   // Cycle
};
///

/// Private Grammar Functions
#define VAL(a,b)     DITO_GetVal (a,b)
#define GR(a,b)      DITO_GetStr(a,b)
#define LATEIN(a)    DITO_GetStr(a,DITO_Str_Word)
#define slastcmp(c)  (!strcmp((char *)SearchString+SearchStrLen-strlen(c),c))
#define suffcmp(a,b) (!strcmp( (char *)a+strlen(a)-strlen(b),b))
#define cutstr(a,b)  a[strlen(a)-strlen(b)]=0;
#define LISTER(c)    strcat(ListerBuffer,c)
#define isstr(s)     *((char *)s)

char  ListerBuffer[1000];

// Verb info structure
struct VerbInfo {
	char  konj,
			avere,
			inf[80],
			pres[80],
			pp[80];
};

// Compose some infos about a verb
BOOL MakeVerbInfo (struct VerbInfo *vinfo, struct DITO_Entry *act){
	long  i;
	char  *s;

	s=LATEIN(act);
	i=0;
	while(*s && (*s!=' ')) vinfo->inf[i++]=*s++;
	vinfo->inf[i]=0;

	vinfo->pres[0]=0;
	vinfo->pp[0]=0;

	vinfo->avere=(VAL(act,0)==0);
	vinfo->konj=-1;

	if(suffcmp(vinfo->inf, "si")){                     // reflexiv?
		strcpy(&vinfo->inf[strlen(vinfo->inf)-2], "e"); // "si" weg und "e" dran
		vinfo->avere=0;                                 // immmer mit essere
	}

	for(i=0;i<ANZKONJS;i++){
		if(suffcmp(vinfo->inf, KonjSuffixe[i])){
			strcpy(vinfo->pres,  vinfo->inf);
			cutstr(vinfo->pres,  KonjSuffixe[i]);
			strcpy(vinfo->pp,    vinfo->pres);
			strcat(vinfo->pp,    PPErg[i]);
			vinfo->konj=i;
			if((i==2) && VAL(act,1)) vinfo->konj=3;      // isc-Stammerweiterung
			i=ANZKONJS+2;
		}
	}

	if(VAL(act,2) && isstr(GR(act,IDX_PP))) {
		sprintf(vinfo->pp,"\0338%s",GR(act,IDX_PP));
		vinfo->pp[strlen(vinfo->pp)-1]=0;
	}
	return(TRUE);
}

// Create requested verb form
char *MakeForm(char *str, struct VerbInfo *vinfo, char c1, char c2, char c3, char i, struct DITO_Entry *act){
	// c1 - diathese
	// c2 - modus
	// c3 - tempus
	// i  - person

	int   idx;
	char  h[80];

	if((c3==5) && (i==0)){     // 1. pers. sing. imperativ
		str[0]=0;
		return(str);
	}
	if(act){

		// INdikativ Aktiv
		if(VAL(act,2) && (c1==0) && (c2==0)){
			switch(c3){
				case 0: idx=IDX_PRESENTE; break;
				case 1: idx=IDX_IMPERFETTO; break;
				case 2: idx=IDX_REMOTO; break;
				case 3: idx=IDX_FUTURO; break;
				case 4: idx=IDX_CONDIZIONALE; break;
				case 5: idx=IDX_IMPERATIVO-1; break;
				default: idx=0;
			}

			if(idx && isstr(GR(act,idx+i))){
				sprintf(str,"\0338%s",GR(act,idx+i));
				return(str);
			}else if(idx){
				strcpy(h,GR(act,idx));
				if(isstr(h)){
					switch(c3){

						// Passato remoto
						case 2:
							cutstr(h,"i");
							if(i==2){ sprintf(str,"\0338%se",h); return(str); }
							if(i==5){ sprintf(str,"\0338%sero",h); return(str); }
							break;

						// Futur
						case 3:
							cutstr(h,"ō");
							sprintf(str, "\0338%s%s", h, FutIrr[i]);
							return(str);
							break;

						// Konditional
						case 4:
							cutstr(h,"ei");
							sprintf(str, "\0338%s%s", h, CondIrr[i]);
							return(str);
							break;
					}
				}
			}

		// Konjunktiv Aktiv
		}else if(VAL(act,2) && (c1==0) && (c2==1)){

			switch(c3){
				case 0: idx=IDX_CPRESENTE; break;
				case 1: idx=IDX_CIMPERFETTO; break;
				default: idx=0;
			}

			if(idx && isstr(GR(act,idx+i))){
				sprintf(str,"\0338%s",GR(act,idx+i));
				return(str);
			}else if(idx){
				strcpy(h,GR(act,idx));
				if(isstr(h)){
					switch(c3){

						// Präsens
						case 0:
							if((i==3) || (i==4)) cutstr(h,"i");
							sprintf(str, "\0338%s%s", h, CPresIrr[i]);
							return(str);
							break;

						// Perfekt
						case 1:
							cutstr(h,"ssi");
							sprintf(str, "\0338%s%s", h, CPerfIrr[i]);
							return(str);
							break;
					}
				}
			}

		}
	}
	str[0]=0;
	if(c2==0){
		if(c3<=5)
			sprintf(str,"%s%s",vinfo->pres,ktab[vinfo->konj][c3][i]);
		else{
			if(vinfo->avere) sprintf(str,"%s %so",avere[c3-6][i],vinfo->pp);
			else if (i<3) sprintf(str,"%s %so/a",essere[c3-6][i],vinfo->pp);
			else sprintf(str,"%s %si/e",essere[c3-6][i],vinfo->pp);
		}
	}else{
		switch(c3){
			case 0:
			case 1:
				sprintf(str,"%s%s",vinfo->pres,ktab[vinfo->konj][c3+6][i]);
				break;
			case 6:
			case 7:
				if(vinfo->avere) sprintf(str,"%s %so",avere[c3-1][i],vinfo->pp);
				else if (i<3) sprintf(str,"%s %so/a",essere[c3-1][i],vinfo->pp);
				else sprintf(str,"%s %si/e",essere[c3-1][i],vinfo->pp);
				break;
			default:
				strcpy(str,"-");
				break;
		}
	}
	return(str);
}


// Compare a list of strings
int CmpList(char *s, const char **list){
	int   i=0;

	while(list[i]){
		if(!strnicmp(s,list[i],strlen(list[i]))) return(TRUE);
		i++;
	}
	return(FALSE);
}

// Substantiv
void MakeNoun(char *str, struct DITO_Entry *entry, int n){
	static char *s, *f, *articles[2][2][3];
	static int k, g, h;

	// sing, genus, kind

	articles[0][0][0] = "il ";
	articles[0][0][1] = "lo ";
	articles[0][0][2] = "l'";
	articles[0][1][0] = "la ";
	articles[0][1][1] = "la ";
	articles[0][1][2] = "l'";

	// plural, genus, kind

	articles[1][0][0] = "i ";
	articles[1][0][1] = "gli ";
	articles[1][0][2] = "gli ";
	articles[1][1][0] = "le ";
	articles[1][1][1] = "le ";
	articles[1][1][2] = "le ";

	s = DITO_GetStr(entry, DITO_Str_Word);
	if(CmpList(s,aarticles)) k=2;
	else if(CmpList(s,zarticles)) k=1;
	else k=0;

	if((g=DITO_GetVal(entry,0))>1) g=0;

	if(n==0){
		strcpy(str,articles[n][g][k]);
		strcat(str,s);
	}else{
		if (h=DITO_GetVal(entry,1)){
			strcpy(str,"\0338");
			strcat(str,artikel[h]);
			strcat(str,DITO_GetStr(entry,0));
		}else{
			strcpy(str,articles[n][g][k]);
			strcat(str,s);

			f=&str[strlen(str)-1];

			switch(*f){
				case 'o': *f='i'; break;
				case 'a': *f='e'; break;
				case 'e': *f='i'; break;
			}
		}
	}
}
///

/// DITO_GetExtInfo
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);
	Types[4] = LOC(part4);

	info.Language    = LOC(language);
	info.Author      = AUTHOR;
	info.Version     = VERSIONSTR;
	info.Date        = __DATE__;
	info.Description = LOC(description);
	info.NumTypes    = 5;
	info.Types       = Types;
	return(&info);
}
///

/*
MUIA_DITOin_Entry

MUIM_DITOin_ActivateFirst
MUIM_DITOin_EntryInfo
MUIM_DITOin_Fonts
*/

/// DITO_CreateInput
SAVEDS ASM struct DITO_InputData *DITO_CreateInput (REG(a0) Object *app)
{
	struct DITO_InputData *data;
	static char *strtab[6], *genustab[4], *helptab[4], *irrtab[9];
	int i;

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

	genustab[0] = LOC(rasub0);
	genustab[1] = LOC(rasub1);
	genustab[2] = LOC(rasub2);
	genustab[3] = 0;

	helptab[0] = LOC(avere);
	helptab[1] = LOC(essere);
	helptab[2] = LOC(both);
	helptab[3] = 0;

	irrtab[0] = LOC(cypraes);
	irrtab[1] = LOC(cyimperf);
	irrtab[2] = LOC(cypassrem);
	irrtab[3] = LOC(cyfut1);
	irrtab[4] = LOC(cykond1);
	irrtab[5] = LOC(cyimp);
	irrtab[6] = LOC(cykonjprae);
	irrtab[7] = LOC(cykonjimperf);
	irrtab[8] = NULL;

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

		data->app = app;

		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, VGroup,
				Child, VSpace(0),
				Child, HGroup,
					Child, HSpace(0),
					Child, HGroup,
						MUIA_ShortHelp, "AMIGA + m",
						Child, data->isplural = KeyCheckMark(FALSE,'m'),
						Child, Label(LOC(plural)),
						End,
					Child, HSpace(0),
					Child, data->genus = RadioObject,
						NoFrame,
						MUIA_CycleChain, 1,
						MUIA_ControlChar, 'g',
						MUIA_ShortHelp, "AMIGA + g",
						MUIA_Radio_Entries, genustab,
						End,
					Child, HSpace(0),
					End,
				Child, VSpace(0),
				Child, data->disable = VGroup,
					Child, LLabel(LOC(irrplural)),
					Child, HGroup,
						Child, data->article = CycleObject,
							MUIA_CycleChain, 1,
							MUIA_ShortHelp, "AMIGA + a",
							MUIA_Cycle_Entries, artikel,
							MUIA_ControlChar, 'a',
							End,
						Child, data->plural = StringObject,
							MUIA_CycleChain, 1,
							MUIA_Weight, 1000,
							MUIA_Frame, MUIV_Frame_String,
							MUIA_String_AdvanceOnCR, TRUE,
							End,
						End,
					End,
				Child, VSpace(0),
				End,

			// Adjektiv
			// ********
			Child, HGroup,
				MUIA_ShortHelp, "AMIGA + v",
				Child, data->adj = KeyCheckMark(FALSE,'v'),
				Child, Label(LOC(invar)),
				End,


			// Verb
			// ****
			Child, HGroup,
				Child, HSpace(0),
				Child, data->essere = RadioObject,
					MUIA_CycleChain, 1,
					MUIA_ShortHelp, "AMIGA + p",
					MUIA_ControlChar, 'p',
					MUIA_Radio_Entries, helptab,
					End,
				Child, HSpace(0),
				Child, ColGroup(2),
					MUIA_ShortHelp, "AMIGA + r\nAMIGA + x",
					Child, data->irr = KeyCheckMark(FALSE,0), // r
					Child, data->btirr = SimpleButton(LOC(irr)),
					Child, data->isc = KeyCheckMark(FALSE,'x'),
					Child, LLabel(LOC(isc)),
					End,
				Child, HSpace(0),
				End,

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

			End;


		// Irregular Forms

		data->win = WindowObject,
			MUIA_Window_Title, LOC(irrverb),
			MUIA_Window_ID, MAKE_ID('I', 'R', 'R', 'V'),
			WindowContents, VGroup,
				Child, data->cycle = CycleObject,
					MUIA_CycleChain, 1,
					MUIA_Cycle_Entries, irrtab,
					MUIA_ShortHelp, "AMIGA + c",
					MUIA_ControlChar, 'c',
					End,
				Child, data->pgroup = GroupObject,
					MUIA_Group_PageMode, TRUE,
					Child, IRRGR(str,IDX_PRESENTE),
					Child, IRRGR(str,IDX_IMPERFETTO),
					Child, IRRGR(str,IDX_REMOTO),
					Child, IRRGR(str,IDX_FUTURO),
					Child, IRRGR(str,IDX_CONDIZIONALE),
					Child, VGroup,
						MUIA_Frame, MUIV_Frame_String,
						MUIA_InnerBottom, 0,
						MUIA_InnerLeft, 0,
						MUIA_InnerRight, 0,
						MUIA_InnerTop, 0,
						MUIA_Group_VertSpacing, 0,
						IRRSTR(str,IDX_IMPERATIVO),
						IRRSTR(str,IDX_IMPERATIVO+1),
						IRRSTR(str,IDX_IMPERATIVO+2),
						IRRSTR(str,IDX_IMPERATIVO+3),
						IRRSTR(str,IDX_IMPERATIVO+4),
						End,
					Child, IRRGR(str,IDX_CPRESENTE),
					Child, IRRGR(str,IDX_CIMPERFETTO),
					End,
				Child, ColGroup(2),
					Child, LLabel(LOC(pp)),
					Child, data->str[0] = StringObject,
						MUIA_CycleChain, 1,
						MUIA_ShortHelp, "AMIGA + SPACE",
						MUIA_ControlChar, ' ',
						MUIA_String_Format, MUIV_String_Format_Center,
						MUIA_Frame, MUIV_Frame_String,
						End,
					Child, LLabel(LOC(gerund)),
					Child, data->str[1] = StringObject,
						MUIA_CycleChain, 1,
						MUIA_String_Format, MUIV_String_Format_Center,
						MUIA_Frame, MUIV_Frame_String,
						End,
					End,
				Child, data->bt = SimpleButton("_OK"),
				End,
			End;

		DoMethod(app,OM_ADDMEMBER,data->win);

		DoMethod(data->win,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,
			data->win, 3, MUIM_Set, MUIA_Window_Open, FALSE);
		DoMethod(data->bt, MUIM_Notify, MUIA_Pressed, FALSE,
			data->win, 3, MUIM_Set, MUIA_Window_Open, FALSE);

		DoMethod(data->isplural, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
			data->disable, 3, MUIM_Set, MUIA_Disabled, MUIV_TriggerValue);

		DoMethod(data->btirr, MUIM_Notify, MUIA_Pressed, FALSE,
			data->win, 3, MUIM_Set, MUIA_Window_Open, TRUE);
		DoMethod(data->btirr, MUIM_Notify, MUIA_Pressed, FALSE,
			data->irr, 3, MUIM_Set, MUIA_Selected, TRUE);

		DoMethod(data->str[0], MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
			data->win, 3, MUIM_Set, MUIA_Window_ActiveObject, data->str[1]);
		DoMethod(data->str[1], MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
			data->win, 3, MUIM_Set, MUIA_Window_ActiveObject, data->bt);

		DoMethod(data->str[IDX_IMPERFETTO-1], MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
			data->cycle,3,MUIM_Set,MUIA_Cycle_Active,1);
		DoMethod(data->str[IDX_REMOTO-1], MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
			data->cycle,3,MUIM_Set,MUIA_Cycle_Active,2);
		DoMethod(data->str[IDX_FUTURO-1], MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
			data->cycle,3,MUIM_Set,MUIA_Cycle_Active,3);
		DoMethod(data->str[IDX_CONDIZIONALE-1], MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
			data->cycle,3,MUIM_Set,MUIA_Cycle_Active,4);
		DoMethod(data->str[IDX_IMPERATIVO-1], MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
			data->cycle,3,MUIM_Set,MUIA_Cycle_Active,5);
		DoMethod(data->str[IDX_CPRESENTE-1], MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
			data->cycle,3,MUIM_Set,MUIA_Cycle_Active,6);
		DoMethod(data->str[IDX_CIMPERFETTO-1], MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
			data->cycle,3,MUIM_Set,MUIA_Cycle_Active,7);
		DoMethod(data->str[IDX_CIMPERFETTO+5], MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
			data->win, 3, MUIM_Set, MUIA_Window_ActiveObject, data->str[0]);

		DoMethod(data->cycle, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime,
			data->pgroup,3,MUIM_Set,MUIA_Group_ActivePage,MUIV_TriggerValue);

		for(i=IDX_PRESENTE;i<(IDX-1);i++)
			DoMethod(data->str[i], MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
				data->win, 3, MUIM_Set, MUIA_Window_ActiveObject, data->str[i+1]);

		return(data);
	}

	return(0);
}
///
/// DITO_DisposeInput
SAVEDS ASM void DITO_DisposeInput (REG(a0) struct DITO_InputData *data)
{
	set(data->win, MUIA_Window_Open, FALSE);
	DoMethod(data->app,OM_REMMEMBER,data->win);
	if(data) FreeVec(data);
}
///
/// DITO_ClearInput
SAVEDS ASM void DITO_ClearInput (REG(a0) struct DITO_InputData *data)
{
	int i;

	set(data->remark,   MUIA_String_Contents, "");
	set(data->rremark,  MUIA_String_Contents, "");
	set(data->plural,   MUIA_String_Contents, "");
	set(data->genus,    MUIA_Radio_Active, 0);
	set(data->essere,   MUIA_Radio_Active, 0);
	set(data->adj,      MUIA_Selected, FALSE);
	set(data->irr,      MUIA_Selected, FALSE);
	set(data->isc,      MUIA_Selected, FALSE);
	set(data->isplural, MUIA_Selected, FALSE);
	set(data->cycle,    MUIA_Cycle_Active, 0);
	set(data->article,  MUIA_Cycle_Active, 0);
	for(i=0;i<IDX;i++)
		set(data->str[i], MUIA_String_Contents, "");
}
///
/// DITO_WriteInput
SAVEDS ASM void DITO_WriteInput (REG(a0) struct DITO_InputData *data, REG(a1) struct DITO_Entry *entry){
	int i;

	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->plural, MUIA_String_Contents, DITO_GetStr(entry,0));
			set (data->article, MUIA_Cycle_Active, DITO_GetVal(entry, 1));
			set (data->isplural, MUIA_Selected, DITO_GetVal(entry, 2));
			setmutex (data->genus, DITO_GetVal(entry,0));
			break;

		// Adjective
		case 2:
			set(data->adj, MUIA_Selected, DITO_GetVal(entry, 0));
			break;

		// Verb
		case 3:
			set(data->isc, MUIA_Selected, DITO_GetVal(entry, 1));
			set(data->irr, MUIA_Selected, DITO_GetVal(entry, 2));
			setmutex(data->essere, DITO_GetVal(entry, 0));
			if(DITO_GetVal(entry,2)){
				for(i=0;i<IDX;i++){
					set (data->str[i], MUIA_String_Contents, DITO_GetStr(entry,i));
				}
			}
			break;

		// Redewendung
		case 4:
			set(data->rremark, MUIA_String_Contents, DITO_GetStr(entry,0));
			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;
	int   i;

	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->genus, MUIA_Radio_Active, &vi->val[0]);
			get (data->isplural, MUIA_Selected, &vi->val[2]);
			if(!vi->val[2]){
				get (data->plural, MUIA_String_Contents, &vi->gr[0]);
				get (data->article, MUIA_Cycle_Active, &vi->val[1]);
			}
			if(entry) changed = strcmp(DITO_GetStr(entry,0), vi->gr[0])
				|| (DITO_GetVal(entry, 0) != vi->val[0])
				|| (DITO_GetVal(entry, 1) != vi->val[1])
				|| (DITO_GetVal(entry, 2) != vi->val[2]);
			break;

		// Adjective
		case 2:
			vi->snum=0;
			get (data->adj, MUIA_Selected, &vi->val[0]);
			if(entry) changed = (DITO_GetVal(entry, 0) != vi->val[0]);
			break;

		// Verb
		case 3:
			vi->snum=0;
			get (data->essere, MUIA_Radio_Active, &vi->val[0]);
			get (data->isc, MUIA_Selected, &vi->val[1]);
			get (data->irr, MUIA_Selected, &vi->val[2]);
			if(vi->val[2]){
				vi->snum = IDX;
				for(i=0;i<IDX;i++){
					get (data->str[i], MUIA_String_Contents, &vi->gr[i]);
				}
			}
			if(entry){
				changed = (DITO_GetVal(entry, 0) != vi->val[0])
				|| (DITO_GetVal(entry, 1) != vi->val[1])
				|| (DITO_GetVal(entry, 2) != vi->val[2]);
				if(vi->val[2]){
					for(i=0;i<IDX;i++){
						changed = changed || strcmp(DITO_GetStr(entry,i), vi->gr[i]);
					}
				}
			}
			break;

		// Default
		case 4:
			vi->snum=1;
			get (data->rremark, MUIA_String_Contents, &vi->gr[0]);
			if(entry) changed = 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->plural);
//      case 2:  return(data->verb0);
		case 4:  return(data->rremark);
	}
	return(0);
}
///
/// 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->rremark,      MUIA_Font, word);
	set(data->plural,       MUIA_Font, word); 
}
///
/// DITO_UpdateInput
SAVEDS ASM void DITO_UpdateInput (REG(a0) struct DITO_InputData *data){
}
///

/*
MUIA_DITOout_Entry

MUIM_DITOout_Distribute, strin, strout
MUIM_DITOout_Fonts, 1,2,3
*/

/// DITO_CreateOutput
SAVEDS ASM struct DITO_OutputData *DITO_CreateOutput (REG(a0) Object *app){
	struct   DITO_OutputData *data;
	static   char  *temptab[12], *diatab[3], *modtab[3];

	temptab[0] = LOC(cypraes);
	temptab[1] = LOC(cyimperf);
	temptab[2] = LOC(cypassrem);
	temptab[3] = LOC(cyfut1);
	temptab[4] = LOC(cykond1);
	temptab[5] = LOC(cyimp);
	temptab[6] = LOC(cyperf);
	temptab[7] = LOC(cypqp);
	temptab[8] = LOC(cytrarem);
	temptab[9] = LOC(cyfut2);
	temptab[10] = LOC(cykond2);
	temptab[11] = NULL;

	diatab[0] = LOC(cydia0);
	diatab[1] = LOC(cydia1);
	diatab[2] = NULL;

	modtab[0] = LOC(cyind);
	modtab[1] = LOC(cykonj);
	modtab[2] = NULL;

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

		data->obj = VGroup,
			Child, VGroup,
				MUIA_Frame, MUIV_Frame_Group,
				MUIA_VertDisappear, 1,
				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->noun = TextObject,
					MUIA_ShortHelp, "Singular\nPlural",
					MUIA_Frame, MUIV_Frame_Text,
					MUIA_Background, MUII_TextBack,
					MUIA_Text_Contents, "\033c\n",
					End,

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

				// Verb
				Child, VGroup,
					MUIA_ShortHelp,
						"1. Person Singualar\n"
						"2. Person Singualar\n"
						"3. Person Singualar\n"
						"1. Person Plural\n"
						"2. Person Plural\n"
						"3. Person Plural\n",
					Child, HGroup,
						MUIA_Group_SameSize, TRUE,
						Child, data->diathese = CycleObject,
							MUIA_Disabled, TRUE,
							MUIA_ShortHelp, "AMIGA + 1",
							MUIA_Cycle_Entries, diatab,
							MUIA_ControlChar, '1',
							End,
						Child, data->modus = CycleObject,
							MUIA_Cycle_Entries, modtab,
							MUIA_ShortHelp, "AMIGA + 2",
							MUIA_ControlChar, '2',
							End,
						End,
					Child, data->tempus = CycleObject,
						MUIA_Cycle_Entries, temptab,
						MUIA_ShortHelp, "AMIGA + 3",
						MUIA_ControlChar, '3',
						End,
					Child, data->text = TextObject,
						MUIA_Background, MUII_TextBack,
						MUIA_Frame, MUIV_Frame_Text,
						MUIA_Text_Contents, "\n\n\n\n\n",
						MUIA_Text_PreParse, "\033c",
						MUIA_Text_SetMin, TRUE,
						End,
					End,

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

				End,
			End;

		DoMethod(data->diathese, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime,
			app,2,MUIM_Application_ReturnID, DITO_DoUpdate);
		DoMethod(data->modus, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime,
			app,2,MUIM_Application_ReturnID, DITO_DoUpdate);
		DoMethod(data->tempus, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime,
			app,2,MUIM_Application_ReturnID, DITO_DoUpdate);

		return(data);
	}

	return(0);
}
///
/// DITO_DisposeOutput
SAVEDS ASM void DITO_DisposeOutput (REG(a0) struct DITO_OutputData *data){
	if(data) FreeVec(data);
}
///
/// DITO_WriteOutput
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 *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));
			break;

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

		// Verb
		case 3:
			set(data->kind, MUIA_Text_Contents, LOC(part3));
			break;

		// Default
		case 4:
			set(data->kind, MUIA_Text_Contents, LOC(part4));
			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){
	set(data->noun,       MUIA_Font, word);
	set(data->text,       MUIA_Font, word);
}
///
/// DITO_UpdateOutput

/*
// Some settings in our grammar mask changed and so we have to update
// the output
*/

SAVEDS ASM void DITO_UpdateOutput (REG(a0) struct DITO_OutputData *data, REG(a1) struct DITO_Entry *entry){
	LONG tempus, diathese, modus;
	static char     str[300];
	int      i;
	struct   VerbInfo vinfo;

	switch(DITO_GetVal(entry,DITO_Val_Type)){

		// Noun
		case 1:
			strcpy(ListerBuffer,"\033c");
			MakeNoun(str, entry, 0);
			LISTER(str);
			str[0]=0;
			LISTER("\n");
			str[0]=0;
			MakeNoun(str, entry, 1);
			LISTER(str);
			set (data->noun, MUIA_Text_Contents, ListerBuffer);
			break;

		// Verb
		case 3:
			get(data->tempus,    MUIA_Cycle_Active, &tempus);
			get(data->diathese,  MUIA_Cycle_Active, &diathese);
			get(data->modus,     MUIA_Cycle_Active, &modus);

			ListerBuffer[0]=0;
			str[0]=0;

			MakeVerbInfo(&vinfo, entry);

			for(i=0;i<6;i++){
				MakeForm(str,&vinfo,diathese,modus,tempus,i,entry);
				LISTER(str);
				LISTER("\0330");
				if(i<5) LISTER("\n");
			}
			set (data->text,MUIA_Text_Contents,ListerBuffer);
			break;

	}
}
///
/// DITO_ParseInput
SAVEDS ASM Object *DITO_ParseInput (REG(a0) struct DITO_InputData *data, REG(a1) char *in, REG(a2) char *out){
/*
	strcpy (out,"hallo");
	set(data->remark, MUIA_String_Contents, "fuck");
*/
	return(DITO_ActivateFirstInput(data));
}
///

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

	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 (pl. %s)", DITO_GetStr(entry, DITO_Str_Word),gen[DITO_GetVal(entry, 0)],h);
			else sprintf(str,"%s %s", DITO_GetStr(entry, DITO_Str_Word),gen[DITO_GetVal(entry, 0)]);
			break;

		// Verb
		case 3:
			v = DITO_GetVal(entry, 2);
			if(v) sprintf(str,"%s (irr, aus. %s)", DITO_GetStr(entry, DITO_Str_Word),aus[DITO_GetVal(entry, 0)],h);
			else sprintf(str,"%s (aus. %s)", DITO_GetStr(entry, DITO_Str_Word),aus[DITO_GetVal(entry, 0)]);
			break;

		// Expression
		case 4:
			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 ...
		default:
			strcpy(str, DITO_GetStr(entry, DITO_Str_Word));
			break;
	}
	return(str);
}
///