#include "dtmf.h"

extern struct Window *FileWindow;
extern struct Screen *pubScreen;
extern struct TextAttr Topaz;
extern char *Undo[50];

struct Gadget *FirstStringGadget;

struct PropGadget
{
	struct Gadget scroller;
	struct Gadget up;
	struct Gadget down;
#ifdef NOTYET
	struct Gadget iconify;
#endif
	struct PropInfo pinfo;
	struct Image simage;
	struct Image *upimage;
	struct Image *downimage;
#ifdef NOTYET
	struct Image *iconifyimage;
#endif
};

const struct PropGadget gadgetdefaults =
{
	{			/*
				 * PropGadget 
				 */
		NULL,
		-13, 0, 10, 0,
		GFLG_RELRIGHT | GFLG_RELHEIGHT,
		GACT_RIGHTBORDER | GACT_RELVERIFY | GACT_IMMEDIATE | GACT_FOLLOWMOUSE,
		GTYP_PROPGADGET,
		NULL, NULL, NULL, NULL, NULL,
		0, NULL
	},
	{			/*
				 * Up-Image 
				 */
		NULL,
		-17, -31, 18, 11,
		GFLG_RELRIGHT | GFLG_RELBOTTOM | GFLG_GADGHIMAGE | GFLG_GADGIMAGE,
		GACT_RIGHTBORDER | GACT_RELVERIFY | GACT_IMMEDIATE,
		GTYP_BOOLGADGET,
		NULL, NULL, NULL, NULL, NULL,
		1, NULL
	},
	{			/*
				 * Down-Gadget 
				 */
		NULL,
		-17, -20, 18, 11,
		GFLG_RELRIGHT | GFLG_RELBOTTOM | GFLG_GADGHIMAGE | GFLG_GADGIMAGE,
		GACT_RIGHTBORDER | GACT_RELVERIFY | GACT_IMMEDIATE,
		GTYP_BOOLGADGET,
		NULL, NULL, NULL, NULL, NULL,
		2, NULL
	},
#ifdef NOTYET
	{			/*
				 * Zoom-Gadget 
				 */
		NULL,
		0, 0, 0, 0,
		GFLG_RELRIGHT | GFLG_GADGHIMAGE | GFLG_GADGIMAGE,
		GACT_TOPBORDER | GACT_RELVERIFY,
		GTYP_BOOLGADGET,
		NULL, NULL, NULL, NULL, NULL,
		3, NULL
	},
#endif
	{			/*
				 * PropInfo 
				 */
		AUTOKNOB | FREEVERT | PROPNEWLOOK | PROPBORDERLESS,
		MAXPOT, MAXPOT,
		MAXBODY, MAXBODY,
	},
};

/****************************************************************/
/*
 * Création des gadgets de saisie                  
 */
/*
 */
/*
 * Paramètres: nom, buffer et coordonnées du gadget        
 */
/*
 * Retour: pointeur sur le gadget créé                     
 */
/****************************************************************/
struct Gadget *
InitStrGadget(struct Window *TheWindow, char *GadgName, UBYTE * GadgBuffer, int LenBuffer, int Top, int Left)
{
	short  *cadre1;
	USHORT  Width,
	        Height;

	struct IntuiText *NewGadgText,
	       *NewGadgText2,
	       *NewGadgText3,
	       *NewGadgText4;

	struct Gadget *NewGadget;

	struct StringInfo *String;

	struct Border *Bord;

	Top += 2;						     // Assez curieux !!??!!

	Left += 2;						     // Différence d'offset entre un gadget et un string-gadget

	NewGadgText = (struct IntuiText *) AllocMem(sizeof(struct IntuiText), MEMF_CHIP | MEMF_CLEAR);

	NewGadgText2 = (struct IntuiText *) AllocMem(sizeof(struct IntuiText), MEMF_CHIP | MEMF_CLEAR);

	NewGadgText3 = (struct IntuiText *) AllocMem(sizeof(struct IntuiText), MEMF_CHIP | MEMF_CLEAR);

	NewGadgText4 = (struct IntuiText *) AllocMem(sizeof(struct IntuiText), MEMF_CHIP | MEMF_CLEAR);

	SetAPen(TheWindow->RPort, 1);

	NewGadget = (struct Gadget *) AllocMem(sizeof(struct Gadget), MEMF_CHIP | MEMF_CLEAR);

	String = (struct StringInfo *) AllocMem(sizeof(struct StringInfo), MEMF_CHIP | MEMF_CLEAR);

	Bord = (struct Border *) AllocMem(sizeof(struct Border), MEMF_CHIP | MEMF_CLEAR);

	cadre1 = (short *) AllocMem(sizeof(short) * 4, MEMF_CHIP | MEMF_CLEAR);

	Width = LenBuffer * pubScreen->RastPort.Font->tf_XSize;
	Height = pubScreen->RastPort.Font->tf_YSize + 2;

	cadre1[0] = -2;
	cadre1[1] = Height;
	cadre1[2] = Width + 2;
	cadre1[3] = Height;

	Bord->LeftEdge = 0;
	Bord->TopEdge = 0;
	Bord->FrontPen = 3;
	Bord->BackPen = 0;
	Bord->DrawMode = JAM1;
	Bord->Count = 2;
	Bord->XY = cadre1;
	Bord->NextBorder = NULL;

	String->Buffer = (UBYTE *) GadgBuffer;
	String->UndoBuffer = (UBYTE *) Undo;
	String->BufferPos = 0;
	String->MaxChars = LenBuffer;
	String->DispPos = 0;
	String->UndoPos = 0;
	String->NumChars = 0;
	String->DispCount = 0;
	String->CLeft = 0;
	String->CTop = 0;
	String->Extension = NULL;
	String->LongInt = 0;
	String->AltKeyMap = NULL;

	NewGadgText4->FrontPen = 2;
	NewGadgText4->BackPen = 0;
	NewGadgText4->DrawMode = JAM1;
	NewGadgText4->LeftEdge = -5;
	NewGadgText4->TopEdge = 0;
	NewGadgText4->ITextFont = (struct TextAttr *) NULL;
	NewGadgText4->IText = (UBYTE *) ":";
	NewGadgText4->NextText = (struct IntuiText *) NULL;

	NewGadgText3->FrontPen = 1;
	NewGadgText3->BackPen = 0;
	NewGadgText3->DrawMode = JAM1;
	NewGadgText3->LeftEdge = -4;
	NewGadgText3->TopEdge = +1;
	NewGadgText3->ITextFont = (struct TextAttr *) NULL;
	NewGadgText3->IText = (UBYTE *) ":";
	NewGadgText3->NextText = (struct IntuiText *) NewGadgText4;

	NewGadgText2->FrontPen = 2;
	NewGadgText2->BackPen = 0;
	NewGadgText2->DrawMode = JAM1;
	NewGadgText2->LeftEdge = -(strlen(GadgName) * pubScreen->RastPort.Font->tf_XSize) - 12;
	NewGadgText2->TopEdge = 0;
	NewGadgText2->ITextFont = (struct TextAttr *) NULL;
	NewGadgText2->IText = (UBYTE *) GadgName;
	NewGadgText2->NextText = (struct IntuiText *) NewGadgText3;

	NewGadgText->FrontPen = 1;
	NewGadgText->BackPen = 0;
	NewGadgText->DrawMode = JAM1;
	NewGadgText->LeftEdge = -(strlen(GadgName) * pubScreen->RastPort.Font->tf_XSize) - 11;
	NewGadgText->TopEdge = +1;
	NewGadgText->ITextFont = (struct TextAttr *) NULL;
	NewGadgText->IText = (UBYTE *) GadgName;
	NewGadgText->NextText = (struct IntuiText *) NewGadgText2;

	NewGadget->NextGadget = NULL;
	NewGadget->LeftEdge = Left;
	NewGadget->TopEdge = Top;
	NewGadget->Width = Width;
	NewGadget->Height = Height;
	NewGadget->Flags = GFLG_GADGHCOMP | GFLG_TABCYCLE;
	NewGadget->Activation = GACT_IMMEDIATE | GACT_RELVERIFY;
	NewGadget->GadgetType = GTYP_STRGADGET;
	NewGadget->GadgetRender = (struct Border *) Bord;
	NewGadget->SelectRender = (APTR) NULL;
	NewGadget->GadgetText = (struct IntuiText *) NewGadgText;
	NewGadget->MutualExclude = 0;
	NewGadget->SpecialInfo = (struct IntuiText *) String;
	NewGadget->GadgetID = 0xFFFF;
	NewGadget->UserData = NULL;

	AddGadget(TheWindow, NewGadget, -1);

	return (NewGadget);
}

/*********************************************************************/
/*
 * Fonction de destruction de tous les gadgets                  
 */
/*
 * créés par InitStrGadget()
 */
/*
 */
/*
 * Paramètres: fenêtre concernée et pointeur sur premier Gadget 
 */
/*
 * Retour: NULL                                                 
 */
/*********************************************************************/
VOID
DeleteStringGadgets(struct Window * TheWindow, struct Gadget * FirstStringGadget)
{
	struct Gadget *Gadget;
	struct IntuiText *text,
	       *textSuiv;

	while ((FirstStringGadget != NULL) && (FirstStringGadget->GadgetType & GTYP_STRGADGET)
	       && (FirstStringGadget->GadgetID == 0xFFFF))
	{
		Gadget = (struct Gadget *) FirstStringGadget->NextGadget;

		if (FirstStringGadget->GadgetRender)
		{
			if (((struct Border *) ((struct Border *) FirstStringGadget->GadgetRender))->XY)
				FreeMem(((struct Border *) ((struct Border *) FirstStringGadget->GadgetRender))->XY, sizeof(short) * ((struct Border *) FirstStringGadget->GadgetRender)->Count);

			FreeMem(FirstStringGadget->GadgetRender, sizeof(struct Border));
		}

		if (FirstStringGadget->SpecialInfo)
		{
			FreeMem(FirstStringGadget->SpecialInfo, sizeof(struct StringInfo));
		}

		if (FirstStringGadget->GadgetText)
		{
			text = FirstStringGadget->GadgetText;
			while (text != NULL)
			{
				textSuiv = text->NextText;
				FreeMem(text, sizeof(struct IntuiText));

				text = textSuiv;
			}
		}

		if (RemoveGadget(TheWindow, FirstStringGadget) == -1)
		{
			printf("Problème pour enlever gadget");
		}

		FreeMem(FirstStringGadget, sizeof(struct Gadget));

		FirstStringGadget = Gadget;
	}
}

struct PropGadget *
add_prop(struct Window *win)
{
	struct PropGadget *pg;
	struct DrawInfo *mydrawinfo;
	struct Image *dummy;
	struct TagItem taglist[4] =
	{
		SYSIA_Which, NULL,
		SYSIA_DrawInfo, NULL,
	};
	USHORT  width,
	        size_height,
	        depth_width,
	        depth_height,
	        height;

/*
 * Get memory 
 */
	if (!(pg = AllocMem(sizeof(struct PropGadget), 0)))
		        return NULL;

/*
 * copy default flags/modes/etc. 
 */
	movmem(&gadgetdefaults, pg, sizeof(struct PropGadget));

/*
 * find out sizes 
 */
	mydrawinfo = (struct DrawInfo *) GetScreenDrawInfo(win->WScreen);

	taglist[0].ti_Data = DEPTHIMAGE;
	taglist[1].ti_Data = (ULONG) mydrawinfo;
	taglist[2].ti_Tag = IA_Height;				     /*
								      * the depth-gadget needs a height 
								      */
	taglist[2].ti_Data = win->BorderTop;
	taglist[3].ti_Tag = TAG_END;

/*
 * get size of depth-gadget 
 */
	if (!(dummy = (struct Image *) NewObjectA(NULL, "sysiclass", taglist)))
	{
		FreeMem(pg, sizeof(struct PropGadget));

		FreeScreenDrawInfo(win->WScreen, mydrawinfo);
		return (NULL);
	}

	depth_width = dummy->Width;
	depth_height = dummy->Height;

/*
 * we don't need the image anymore 
 */
	DisposeObject(dummy);

#ifdef NOTYET
/*
 * Get the ZOOMIMAGE here because we need the height 
 */
	taglist[0].ti_Data = ZOOMIMAGE;

	if (!(pg->iconifyimage = (struct Image *) NewObjectA(NULL, "sysiclass", taglist)))
	{
		FreeMem(pg, sizeof(struct PropGadget));

		FreeScreenDrawInfo(win->WScreen, mydrawinfo);
		DisposeObject(pg->upimage);
		DisposeObject(pg->downimage);
		return (NULL);
	}

	pg->iconify.GadgetRender = pg->iconify.SelectRender = (APTR) pg->iconifyimage;
#endif

	taglist[0].ti_Data = SIZEIMAGE;
	taglist[2].ti_Tag = TAG_END;

/*
 * get size of size-gadget 
 */
/* J'ai laissé ce bout de code, mais en réalité la fenêtre ne dispose pas de size-gadget
	et je n'ai pas voulu mettre en place un test */

	if (!(dummy = (struct Image *) NewObjectA(NULL, "sysiclass", taglist)))
	{
		FreeMem(pg, sizeof(struct PropGadget));

		FreeScreenDrawInfo(win->WScreen, mydrawinfo);
		return (NULL);
	}

	width = dummy->Width;					     /*
								      * width of up/down-gadgets 
								      */
	size_height = 1; //dummy->Height;
								     /*
								      * bottom offset
								      */

/*
 * we don't need the image anymore 
 */
	DisposeObject(dummy);

	taglist[0].ti_Data = UPIMAGE;

	if (!(pg->upimage = (struct Image *) NewObjectA(NULL, "sysiclass", taglist)))
	{
		FreeMem(pg, sizeof(struct PropGadget));

		FreeScreenDrawInfo(win->WScreen, mydrawinfo);
		return (NULL);
	}

	pg->up.GadgetRender = pg->up.SelectRender = (APTR) pg->upimage;

	height = pg->upimage->Height;

	taglist[0].ti_Data = DOWNIMAGE;

	if (!(pg->downimage = (struct Image *) NewObjectA(NULL, "sysiclass", taglist)))
	{
		FreeMem(pg, sizeof(struct PropGadget));

		FreeScreenDrawInfo(win->WScreen, mydrawinfo);
		DisposeObject(pg->upimage);
		return (NULL);
	}

	pg->down.GadgetRender = pg->down.SelectRender = (APTR) pg->downimage;

/*
 * Release drawinfo 
 */
	FreeScreenDrawInfo(win->WScreen, mydrawinfo);

/*
 * Now init all sizes/positions 
 */
	pg->scroller.TopEdge = depth_height + 1;
	pg->scroller.Height = -(depth_height + size_height + 2 * height + 2);
	pg->up.LeftEdge = pg->down.LeftEdge = -(width - 1);
	pg->scroller.LeftEdge = -(width - 4);
	pg->down.TopEdge = -(size_height + height - 1);
	pg->up.TopEdge = pg->down.TopEdge - height;
	pg->up.Width = pg->down.Width = width;
	pg->scroller.Width = width - 6;
	pg->up.Height = pg->down.Height = height;
#ifdef NOTYET
	pg->iconify.Width = pg->iconifyimage->Width;
	pg->iconify.Height = pg->iconifyimage->Height;
	pg->iconify.LeftEdge = -(depth_width + pg->iconify.Width);
#endif

/*
 * Other fields 
 */
	pg->scroller.GadgetRender = (APTR) & pg->simage;
	pg->scroller.SpecialInfo = (APTR) & pg->pinfo;

/*
 * Link gadgets 
 */
	pg->scroller.NextGadget = &pg->up;
	pg->up.NextGadget = &pg->down;

/*
 * and add them to the window 
 */
	AddGList(win, &pg->scroller, -1, -1, NULL);

/*
 * return field 
 */

	return (pg);
}								     /*
								      * add_prop 
								      */

void
free_prop(struct PropGadget *pg)
{
	if (pg)
	{
	    /*
	     * * Free elements 
	     */
		DisposeObject(pg->upimage);
		DisposeObject(pg->downimage);
#ifdef NOTYET
		DisposeObject(pg->iconifyimage);
#endif

	    /*
	     * * Free struct 
	     */
		FreeMem(pg, sizeof(struct PropGadget));
	}
}								     /*
								      * free_prop 
								      */