#include "dtmf.h"

#define Potar ((struct PropInfo )propgad->pinfo).VertPot
#define rastPort    FileWindow->RPort
#define INTERLIGNE  5


struct coordonnee
{
	long    LastRecord;
	long    NextRecord;
	char    nom[STRGADGCAR];
	char    prenom[STRGADGCAR];
	char    adresse1[STRGADGCAR];
	char    adresse2[STRGADGCAR];
	char    codepost[STRGADGCOD];
	char    ville[STRGADGCAR];
	char    pays[STRGADGCAR];
	char    telephone1[STRGADGTEL];
	char    telephone2[STRGADGTEL];
	char    fax[STRGADGTEL];
	char    note1[STRGADGCAR];
	char    note2[STRGADGCAR];
}
abonne;

struct EasyStruct confirm = {
								sizeof(struct EasyStruct),
								0,
								NULL,
								"voulez-vous réellement détruire cette fiche ?",
								"Oui|Non"
								};
char   *fiche[12] =
{"Nom        ",
 "Prénom     ",
 "Adresse    ",
 "           ",
 "Code Post. ",
 "Ville      ",
 "Pays       ",
 "Téléphone  ",
 "           ",
 "Fax        ",
 "Note       ",
 "           "
};

int     champ[10] =
{
	POSNOM,
	POSPRENOM,
	POSADDRESS1,
	POSADDRESS2,
	POSCODE,
	POSVILLE,
	POSPAYS,
	POSTEL1,
	POSTEL2,
	POSFAX
};

char    Chaine[MAXNUM + 1];

struct Gadget *lastString;

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
};

struct PropGadget *propgad;
struct Gadget N1,
        N2,
        N3,
        New,
        Find,
        Save,
        Append,
        RemoveG;
struct Border ShineNewBord,
        ShineFindBord,
        ShineSaveBord,
        ShineAppendBord,
        ShineRemoveGBord;
struct Border ShadowNewBord,
        ShadowFindBord,
        ShadowSaveBord,
        ShadowAppendBord,
        ShadowRemoveGBord;
struct IntuiText NewText,
        NewText2,
        FindText,
        FindText2,
        SaveText,
        SaveText2,
        TextsR;
struct IntuiText AppendText,
        AppendText2,
        RemoveGText,
        RemoveGText2;
struct Image ImGadgetProp;
struct Window *FileWindow;
struct MenuItem ItemsR;
struct Menu MenusR;
struct TextExtent fontExtent;

char   *IStringsR = "Pack      ";

short   ShineNewCadre[6],
        ShineFindCadre[6],
        ShineSaveCadre[6],
        ShineAppendCadre[6],
        ShineRemoveGCadre[6];
short   ShadowNewCadre[6],
        ShadowFindCadre[6],
        ShadowSaveCadre[6],
        ShadowAppendCadre[6],
        ShadowRemoveGCadre[6];
USHORT  heightWinFont,
        widthWinFont,
        heightScreenFont,
        widthScreenFont;

long    FilePos,
        First,
        PropPos,
        fix_display = 0,
        oldPos,
        i,
        NbreFiches,
        NumFiche,
        NextRecord = STRGADGORD,
        LastRecord,
        ThisRecord = STRGADGORD,
        EndFile;

UWORD   iconRepCoords[4] =
{250, 0, 150, 14};

void    InstallRepertoire(void);
int     Recherche(void);
void    Enregistre(void);
void    Ajoute(void);
void    Deplace(int);
void    Alphabet(long);
void    Aff_Fiche(void);
void    Detruit(void);
void    LenFile(void);
void    Init(void);
void    Repertoire(void);
void    HandleFileWindow(ULONG, UWORD, APTR);
void    CloseFileWindow(void);
void    Pack(void);
struct PropGadget *add_prop(struct Window *);
void    upperString(char *, char *);

/****************************************************************/
/*
 * Mise en place de la fiche abonné
 */
/*
 */
/*
 * Paramètres: NULL
 */
/*
 * Retour: NULL
 */
/****************************************************************/
void
InstallRepertoire(void)
{
	UWORD   winWidth,
	        winHeight;
	UWORD   heightString;
	struct Gadget *tel1,
	       *tel2,
	       *tel3;

	abonne.nom[0] = '\0';
	abonne.prenom[0] = '\0';
	abonne.adresse1[0] = '\0';
	abonne.adresse2[0] = '\0';
	abonne.codepost[0] = '\0';
	abonne.ville[0] = '\0';
	abonne.pays[0] = '\0';
	abonne.telephone1[0] = '\0';
	abonne.telephone2[0] = '\0';
	abonne.fax[0] = '\0';
	abonne.note1[0] = '\0';
	abonne.note2[0] = '\0';

	if ((FileWindow = (struct Window *) OpenWindowTags(NULL,
							   WA_Left, winRepLeft,
							   WA_Top, winRepTop,
							   WA_Width, 1,
							   WA_Height, 1,
							   WA_MinWidth, 10,
							   WA_MaxWidth, 10,
							   WA_MinHeight, 10,
							   WA_MaxHeight, 10,
							   WA_Title, "Répertoire",
							   WA_CloseGadget, TRUE,
							   WA_DragBar, TRUE,
							   WA_DepthGadget, TRUE,
//							   WA_SizeGadget, TRUE,
							   WA_Zoom, iconRepCoords,
							   WA_ReportMouse, TRUE,
							   WA_Activate, TRUE,
							   WA_SmartRefresh, TRUE,
							   WA_PubScreen, pubScreen,
							   TAG_END
	     )) == NULL)
		cleanUp("\nOuverture fenêtre impossible", 6);

	FileWindow->BorderRight = 18;

	heightWinFont = FileWindow->RPort->Font->tf_YSize + 2;
	widthWinFont = FileWindow->RPort->Font->tf_XSize;

	heightScreenFont = pubScreen->RastPort.Font->tf_YSize + 2;
	widthScreenFont = pubScreen->RastPort.Font->tf_XSize;

	heightString = heightScreenFont;

	FirstStringGadget = InitStrGadget(FileWindow, fiche[0], abonne.nom, STRGADGCAR, (offy + 5), (12 * pubScreen->RastPort.Font->tf_XSize + 12));

	InitStrGadget(FileWindow, fiche[1], abonne.prenom, STRGADGCAR, ((offy + 5) + (1 * (heightString + INTERLIGNE))), (12 * pubScreen->RastPort.Font->tf_XSize + 12));

	InitStrGadget(FileWindow, fiche[2], abonne.adresse1, STRGADGCAR, ((offy + 5) + (2 * (heightString + INTERLIGNE))), (12 * pubScreen->RastPort.Font->tf_XSize + 12));

	InitStrGadget(FileWindow, fiche[3], abonne.adresse2, STRGADGCAR, ((offy + 5) + (3 * (heightString + INTERLIGNE))), (12 * pubScreen->RastPort.Font->tf_XSize + 12));

	InitStrGadget(FileWindow, fiche[4], abonne.codepost, STRGADGCOD, ((offy + 5) + (4 * (heightString + INTERLIGNE))), (12 * pubScreen->RastPort.Font->tf_XSize + 12));

	InitStrGadget(FileWindow, fiche[5], abonne.ville, STRGADGCAR, ((offy + 5) + (5 * (heightString + INTERLIGNE))), (12 * pubScreen->RastPort.Font->tf_XSize + 12));

	InitStrGadget(FileWindow, fiche[6], abonne.pays, STRGADGCAR, ((offy + 5) + (6 * (heightString + INTERLIGNE))), (12 * pubScreen->RastPort.Font->tf_XSize + 12));

	tel1 = InitStrGadget(FileWindow, fiche[7], abonne.telephone1, STRGADGTEL, ((offy + 5) + (7 * (heightString + INTERLIGNE))), (12 * pubScreen->RastPort.Font->tf_XSize + 12));

	tel2 = InitStrGadget(FileWindow, fiche[8], abonne.telephone2, STRGADGTEL, ((offy + 5) + (8 * (heightString + INTERLIGNE))), (12 * pubScreen->RastPort.Font->tf_XSize + 12));

	tel3 = InitStrGadget(FileWindow, fiche[9], abonne.fax, STRGADGTEL, ((offy + 5) + (9 * (heightString + INTERLIGNE))), (12 * pubScreen->RastPort.Font->tf_XSize + 12));

	InitStrGadget(FileWindow, fiche[10], abonne.note1, STRGADGCAR, ((offy + 5) + (10 * (heightString + INTERLIGNE))), (12 * pubScreen->RastPort.Font->tf_XSize + 12));

	lastString = InitStrGadget(FileWindow, fiche[11], abonne.note2, STRGADGCAR, ((offy + 5) + (11 * (heightString + INTERLIGNE))), (12 * pubScreen->RastPort.Font->tf_XSize + 12));

	NewText.FrontPen = PubDrawInfo->dri_Pens[TEXTPEN];
	NewText.BackPen = PubDrawInfo->dri_Pens[BACKGROUNDPEN];
	NewText.DrawMode = JAM1;
	NewText.LeftEdge = 2;
	NewText.TopEdge = 2;
	NewText.ITextFont = (struct TextAttr *) NULL;
	NewText.IText = (UBYTE *) "NOUVELLE";
	NewText.NextText = (struct IntuiText *) NULL;

	FindText.FrontPen = PubDrawInfo->dri_Pens[TEXTPEN];
	FindText.BackPen = PubDrawInfo->dri_Pens[BACKGROUNDPEN];
	FindText.DrawMode = JAM1;
	FindText.LeftEdge = 2;
	FindText.TopEdge = 2;
	FindText.ITextFont = (struct TextAttr *) NULL;
	FindText.IText = (UBYTE *) "CHERCHE";
	FindText.NextText = (struct IntuiText *) NULL;

	SaveText.FrontPen = PubDrawInfo->dri_Pens[TEXTPEN];
	SaveText.BackPen = PubDrawInfo->dri_Pens[BACKGROUNDPEN];
	SaveText.DrawMode = JAM1;
	SaveText.LeftEdge = 2;
	SaveText.TopEdge = 2;
	SaveText.ITextFont = (struct TextAttr *) NULL;
	SaveText.IText = (UBYTE *) "REMPLACER";
	SaveText.NextText = (struct IntuiText *) NULL;

	AppendText.FrontPen = PubDrawInfo->dri_Pens[TEXTPEN];
	AppendText.BackPen = PubDrawInfo->dri_Pens[BACKGROUNDPEN];
	AppendText.DrawMode = JAM1;
	AppendText.LeftEdge = 2;
	AppendText.TopEdge = 2;
	AppendText.ITextFont = (struct TextAttr *) NULL;
	AppendText.IText = (UBYTE *) "AJOUTER";
	AppendText.NextText = (struct IntuiText *) NULL;

	RemoveGText.FrontPen = PubDrawInfo->dri_Pens[TEXTPEN];
	RemoveGText.BackPen = PubDrawInfo->dri_Pens[BACKGROUNDPEN];
	RemoveGText.DrawMode = JAM1;
	RemoveGText.LeftEdge = 2;
	RemoveGText.TopEdge = 2;
	RemoveGText.ITextFont = (struct TextAttr *) NULL;
	RemoveGText.IText = (UBYTE *) "DETRUIRE";
	RemoveGText.NextText = (struct IntuiText *) NULL;

	ShineNewCadre[0] = TextLength(&(pubScreen->RastPort), NewText.IText, strlen(NewText.IText)) + 4;
	ShineNewCadre[1] = 0;
	ShineNewCadre[2] = 0;
	ShineNewCadre[3] = 0;
	ShineNewCadre[4] = 0;
	ShineNewCadre[5] = pubScreen->RastPort.Font->tf_YSize + 2;

	ShadowNewCadre[0] = 0;
	ShadowNewCadre[1] = ShineNewCadre[5];
	ShadowNewCadre[2] = ShineNewCadre[0];
	ShadowNewCadre[3] = ShineNewCadre[5];
	ShadowNewCadre[4] = ShineNewCadre[0];
	ShadowNewCadre[5] = 0;

	ShineNewBord.LeftEdge = 0;
	ShineNewBord.TopEdge = 0;
	ShineNewBord.FrontPen = PubDrawInfo->dri_Pens[SHINEPEN];
	ShineNewBord.BackPen = 0;
	ShineNewBord.DrawMode = JAM1;
	ShineNewBord.Count = 3;
	ShineNewBord.XY = ShineNewCadre;
	ShineNewBord.NextBorder = &ShadowNewBord;

	ShadowNewBord.LeftEdge = 0;
	ShadowNewBord.TopEdge = 0;
	ShadowNewBord.FrontPen = PubDrawInfo->dri_Pens[SHADOWPEN];
	ShadowNewBord.BackPen = 0;
	ShadowNewBord.DrawMode = JAM1;
	ShadowNewBord.Count = 3;
	ShadowNewBord.XY = ShadowNewCadre;
	ShadowNewBord.NextBorder = NULL;

	ShineFindCadre[0] = TextLength(&(pubScreen->RastPort), FindText.IText, strlen(FindText.IText)) + 4;
	ShineFindCadre[1] = 0;
	ShineFindCadre[2] = 0;
	ShineFindCadre[3] = 0;
	ShineFindCadre[4] = 0;
	ShineFindCadre[5] = ShineNewCadre[5];

	ShadowFindCadre[0] = 0;
	ShadowFindCadre[1] = ShineFindCadre[5];
	ShadowFindCadre[2] = ShineFindCadre[0];
	ShadowFindCadre[3] = ShineFindCadre[5];
	ShadowFindCadre[4] = ShineFindCadre[0];
	ShadowFindCadre[5] = 0;

	ShineFindBord.LeftEdge = 0;
	ShineFindBord.TopEdge = 0;
	ShineFindBord.FrontPen = PubDrawInfo->dri_Pens[SHINEPEN];
	ShineFindBord.BackPen = 0;
	ShineFindBord.DrawMode = JAM1;
	ShineFindBord.Count = 3;
	ShineFindBord.XY = ShineFindCadre;
	ShineFindBord.NextBorder = &ShadowFindBord;

	ShadowFindBord.LeftEdge = 0;
	ShadowFindBord.TopEdge = 0;
	ShadowFindBord.FrontPen = PubDrawInfo->dri_Pens[SHADOWPEN];
	ShadowFindBord.BackPen = 0;
	ShadowFindBord.DrawMode = JAM1;
	ShadowFindBord.Count = 3;
	ShadowFindBord.XY = ShadowFindCadre;
	ShadowFindBord.NextBorder = NULL;

	ShineSaveCadre[0] = TextLength(&(pubScreen->RastPort), SaveText.IText, strlen(SaveText.IText)) + 4;
	ShineSaveCadre[1] = 0;
	ShineSaveCadre[2] = 0;
	ShineSaveCadre[3] = 0;
	ShineSaveCadre[4] = 0;
	ShineSaveCadre[5] = ShineNewCadre[5];

	ShadowSaveCadre[0] = 0;
	ShadowSaveCadre[1] = ShineSaveCadre[5];
	ShadowSaveCadre[2] = ShineSaveCadre[0];
	ShadowSaveCadre[3] = ShineSaveCadre[5];
	ShadowSaveCadre[4] = ShineSaveCadre[0];
	ShadowSaveCadre[5] = 0;

	ShineSaveBord.LeftEdge = 0;
	ShineSaveBord.TopEdge = 0;
	ShineSaveBord.FrontPen = PubDrawInfo->dri_Pens[SHINEPEN];
	ShineSaveBord.BackPen = 0;
	ShineSaveBord.DrawMode = JAM1;
	ShineSaveBord.Count = 3;
	ShineSaveBord.XY = ShineSaveCadre;
	ShineSaveBord.NextBorder = &ShadowSaveBord;

	ShadowSaveBord.LeftEdge = 0;
	ShadowSaveBord.TopEdge = 0;
	ShadowSaveBord.FrontPen = PubDrawInfo->dri_Pens[SHADOWPEN];
	ShadowSaveBord.BackPen = 0;
	ShadowSaveBord.DrawMode = JAM1;
	ShadowSaveBord.Count = 3;
	ShadowSaveBord.XY = ShadowSaveCadre;
	ShadowSaveBord.NextBorder = NULL;

	ShineAppendCadre[0] = TextLength(&(pubScreen->RastPort), AppendText.IText, strlen(AppendText.IText)) + 4;
	ShineAppendCadre[1] = 0;
	ShineAppendCadre[2] = 0;
	ShineAppendCadre[3] = 0;
	ShineAppendCadre[4] = 0;
	ShineAppendCadre[5] = ShineNewCadre[5];

	ShadowAppendCadre[0] = 0;
	ShadowAppendCadre[1] = ShineAppendCadre[5];
	ShadowAppendCadre[2] = ShineAppendCadre[0];
	ShadowAppendCadre[3] = ShineAppendCadre[5];
	ShadowAppendCadre[4] = ShineAppendCadre[0];
	ShadowAppendCadre[5] = 0;

	ShineAppendBord.LeftEdge = 0;
	ShineAppendBord.TopEdge = 0;
	ShineAppendBord.FrontPen = PubDrawInfo->dri_Pens[SHINEPEN];
	ShineAppendBord.BackPen = 0;
	ShineAppendBord.DrawMode = JAM1;
	ShineAppendBord.Count = 3;
	ShineAppendBord.XY = ShineAppendCadre;
	ShineAppendBord.NextBorder = &ShadowAppendBord;

	ShadowAppendBord.LeftEdge = 0;
	ShadowAppendBord.TopEdge = 0;
	ShadowAppendBord.FrontPen = PubDrawInfo->dri_Pens[SHADOWPEN];
	ShadowAppendBord.BackPen = 0;
	ShadowAppendBord.DrawMode = JAM1;
	ShadowAppendBord.Count = 3;
	ShadowAppendBord.XY = ShadowAppendCadre;
	ShadowAppendBord.NextBorder = NULL;

	ShineRemoveGCadre[0] = TextLength(&(pubScreen->RastPort), RemoveGText.IText, strlen(RemoveGText.IText)) + 4;
	ShineRemoveGCadre[1] = 0;
	ShineRemoveGCadre[2] = 0;
	ShineRemoveGCadre[3] = 0;
	ShineRemoveGCadre[4] = 0;
	ShineRemoveGCadre[5] = ShineNewCadre[5];

	ShadowRemoveGCadre[0] = 0;
	ShadowRemoveGCadre[1] = ShineRemoveGCadre[5];
	ShadowRemoveGCadre[2] = ShineRemoveGCadre[0];
	ShadowRemoveGCadre[3] = ShineRemoveGCadre[5];
	ShadowRemoveGCadre[4] = ShineRemoveGCadre[0];
	ShadowRemoveGCadre[5] = 0;

	ShineRemoveGBord.LeftEdge = 0;
	ShineRemoveGBord.TopEdge = 0;
	ShineRemoveGBord.FrontPen = PubDrawInfo->dri_Pens[SHINEPEN];
	ShineRemoveGBord.BackPen = 0;
	ShineRemoveGBord.DrawMode = JAM1;
	ShineRemoveGBord.Count = 3;
	ShineRemoveGBord.XY = ShineRemoveGCadre;
	ShineRemoveGBord.NextBorder = &ShadowRemoveGBord;

	ShadowRemoveGBord.LeftEdge = 0;
	ShadowRemoveGBord.TopEdge = 0;
	ShadowRemoveGBord.FrontPen = PubDrawInfo->dri_Pens[SHADOWPEN];
	ShadowRemoveGBord.BackPen = 0;
	ShadowRemoveGBord.DrawMode = JAM1;
	ShadowRemoveGBord.Count = 3;
	ShadowRemoveGBord.XY = ShadowRemoveGCadre;
	ShadowRemoveGBord.NextBorder = NULL;

	N1.NextGadget = (struct Gadget *) &N2;
	N1.LeftEdge = lastString->LeftEdge + lastString->Width + 5;
	N1.TopEdge = tel1->TopEdge;
	N1.Width = 20;
	N1.Height = 11;
	N1.Flags = GFLG_GADGHCOMP | GFLG_GADGIMAGE;
	N1.Activation = GACT_IMMEDIATE | GACT_RELVERIFY;
	N1.GadgetType = GTYP_BOOLGADGET;
	N1.GadgetRender = (APTR) & ImageTel;
	N1.SelectRender = (APTR) NULL;
	N1.GadgetText = (struct IntuiText *) NULL;
	N1.MutualExclude = (ULONG) NULL;
	N1.SpecialInfo = (APTR) NULL;
	N1.GadgetID = 0;
	N1.UserData = (APTR) NULL;

	N2.NextGadget = (struct Gadget *) &N3;
	N2.LeftEdge = lastString->LeftEdge + lastString->Width + 5;
	N2.TopEdge = tel2->TopEdge;
	N2.Width = 20;
	N2.Height = 11;
	N2.Flags = GFLG_GADGHCOMP | GFLG_GADGIMAGE;
	N2.Activation = GACT_IMMEDIATE | GACT_RELVERIFY;
	N2.GadgetType = GTYP_BOOLGADGET;
	N2.GadgetRender = (APTR) & ImageTel;
	N2.SelectRender = (APTR) NULL;
	N2.GadgetText = (struct IntuiText *) NULL;
	N2.MutualExclude = (ULONG) NULL;
	N2.SpecialInfo = (APTR) NULL;
	N2.GadgetID = 0;
	N2.UserData = (APTR) NULL;

	N3.NextGadget = (struct Gadget *) &New;
	N3.LeftEdge = lastString->LeftEdge + lastString->Width + 5;
	N3.TopEdge = tel3->TopEdge;
	N3.Width = 20;
	N3.Height = 11;
	N3.Flags = GFLG_GADGHCOMP | GFLG_GADGIMAGE;
	N3.Activation = GACT_IMMEDIATE | GACT_RELVERIFY;
	N3.GadgetType = GTYP_BOOLGADGET;
	N3.GadgetRender = (APTR) & ImageTel;
	N3.SelectRender = (APTR) NULL;
	N3.GadgetText = (struct IntuiText *) NULL;
	N3.MutualExclude = (ULONG) NULL;
	N3.SpecialInfo = (APTR) NULL;
	N3.GadgetID = 0;
	N3.UserData = (APTR) NULL;

	New.NextGadget = (struct Gadget *) &Find;
	New.LeftEdge = 10;
	New.TopEdge = lastString->TopEdge + lastString->Height + 10;
	New.Width = ShineNewCadre[0];
	New.Height = ShineNewCadre[5];
	New.Flags = GFLG_GADGHCOMP;
	New.Activation = GACT_IMMEDIATE | GACT_RELVERIFY;
	New.GadgetType = GTYP_BOOLGADGET;
	New.GadgetRender = (APTR) & ShineNewBord;
	New.SelectRender = (APTR) NULL;
	New.GadgetText = (struct IntuiText *) &NewText;
	New.MutualExclude = (ULONG) NULL;
	New.SpecialInfo = (APTR) NULL;
	New.GadgetID = 0;
	New.UserData = (APTR) NULL;

	Find.NextGadget = (struct Gadget *) &Save;
	Find.LeftEdge = New.LeftEdge + New.Width + 5;
	Find.TopEdge = lastString->TopEdge + lastString->Height + 10;
	Find.Width = ShineFindCadre[0];
	Find.Height = ShineNewCadre[5];
	Find.Flags = GFLG_GADGHCOMP;
	Find.Activation = GACT_IMMEDIATE | GACT_RELVERIFY;
	Find.GadgetType = GTYP_BOOLGADGET;
	Find.GadgetRender = (APTR) & ShineFindBord;
	Find.SelectRender = (APTR) NULL;
	Find.GadgetText = (struct IntuiText *) &FindText;
	Find.MutualExclude = (ULONG) NULL;
	Find.SpecialInfo = (APTR) NULL;
	Find.GadgetID = 0;
	Find.UserData = (APTR) NULL;

	Save.NextGadget = (struct Gadget *) &Append;
	Save.LeftEdge = Find.LeftEdge + Find.Width + 5;
	Save.TopEdge = lastString->TopEdge + lastString->Height + 10;
	Save.Width = ShineSaveCadre[0];
	Save.Height = ShineNewCadre[5];
	Save.Flags = GFLG_GADGHCOMP;
	Save.Activation = GACT_IMMEDIATE | GACT_RELVERIFY;
	Save.GadgetType = GTYP_BOOLGADGET;
	Save.GadgetRender = (APTR) & ShineSaveBord;
	Save.SelectRender = (APTR) NULL;
	Save.GadgetText = (struct IntuiText *) &SaveText;
	Save.MutualExclude = (ULONG) NULL;
	Save.SpecialInfo = (APTR) NULL;
	Save.GadgetID = 0;
	Save.UserData = (APTR) NULL;

	Append.NextGadget = (struct Gadget *) &RemoveG;
	Append.LeftEdge = Save.LeftEdge + Save.Width + 5;
	Append.TopEdge = lastString->TopEdge + lastString->Height + 10;
	Append.Width = ShineAppendCadre[0];
	Append.Height = ShineNewCadre[5];
	Append.Flags = GFLG_GADGHCOMP;
	Append.Activation = GACT_IMMEDIATE | GACT_RELVERIFY;
	Append.GadgetType = GTYP_BOOLGADGET;
	Append.GadgetRender = (APTR) & ShineAppendBord;
	Append.SelectRender = (APTR) NULL;
	Append.GadgetText = (struct IntuiText *) &AppendText;
	Append.MutualExclude = (ULONG) NULL;
	Append.SpecialInfo = (APTR) NULL;
	Append.GadgetID = 0;
	Append.UserData = (APTR) NULL;

	RemoveG.NextGadget = (struct Gadget *) NULL;
	RemoveG.LeftEdge = Append.LeftEdge + Append.Width + 5;
	RemoveG.TopEdge = lastString->TopEdge + lastString->Height + 10;
	RemoveG.Width = ShineRemoveGCadre[0];
	RemoveG.Height = ShineNewCadre[5];
	RemoveG.Flags = GFLG_GADGHCOMP;
	RemoveG.Activation = GACT_IMMEDIATE | GACT_RELVERIFY;
	RemoveG.GadgetType = GTYP_BOOLGADGET;
	RemoveG.GadgetRender = (APTR) & ShineRemoveGBord;
	RemoveG.SelectRender = (APTR) NULL;
	RemoveG.GadgetText = (struct IntuiText *) &RemoveGText;
	RemoveG.MutualExclude = (ULONG) NULL;
	RemoveG.SpecialInfo = (APTR) NULL;
	RemoveG.GadgetID = 0;
	RemoveG.UserData = (APTR) NULL;

	AddGList(FileWindow, &N1, -1, 20, NULL);

	propgad = add_prop(FileWindow);

	winWidth = ((RemoveG.LeftEdge + RemoveG.Width + 5) > (N1.LeftEdge + N1.Width + 5)) ?
		(RemoveG.LeftEdge + RemoveG.Width + 5) : (N1.LeftEdge + N1.Width + 5);

	iconRepCoords[3] = (UWORD) pubScreen->BarHeight;

	winHeight = New.TopEdge + New.Height + 5;

	SizeWindow(FileWindow, winWidth + 15, winHeight);
	WindowLimits(FileWindow, winWidth + 15 - 1, winHeight - 1, winWidth + 15 + 1, winHeight + 1);

	RefreshGadgets(FileWindow->FirstGadget, FileWindow, NULL);

	Init();
}

void
Init(void)
{
	LenFile();

	if (EndFile)
	{
		Seek(fileRepertoire, 0L, OFFSET_BEGINNING);
		Read(fileRepertoire, (char *) &ThisRecord, 4);
		Seek(fileRepertoire, ThisRecord + POSLAST, OFFSET_BEGINNING);
		Read(fileRepertoire, (char *) &LastRecord, 4);
		Read(fileRepertoire, (char *) &NextRecord, 4);
	}
	NumFiche = 0;
	Seek(fileRepertoire, 0L, OFFSET_BEGINNING);
	Read(fileRepertoire, (char *) &ThisRecord, 4);
	PropPos = 0;
}

/****************************************************************/
/*
 * met en place le menu Repertoire
 */
/*
 */
/*
 * Paramètres: NULL
 */
/*
 * Retour: NULL
 */
/****************************************************************/

VOID
CreeMenuR()
{

	TextsR.FrontPen = 6;
	TextsR.BackPen = 0;
	TextsR.DrawMode = JAM1;
	TextsR.LeftEdge = 1;
	TextsR.TopEdge = 1;
	TextsR.ITextFont = (struct TextAttr *) NULL;
	TextsR.IText = (UBYTE *) IStringsR;
	TextsR.NextText = (struct IntuiText *) NULL;

	ItemsR.NextItem = (struct IntuiText *) NULL;
	ItemsR.LeftEdge = 0;
	ItemsR.TopEdge = 0;
	ItemsR.Width = TextLength(rastPort, TextsR.IText, strlen(TextsR.IText));
	ItemsR.Height = rastPort->Font->tf_YSize + 2;
	ItemsR.Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP;
	ItemsR.ItemFill = (APTR) & TextsR;
	ItemsR.SelectFill = (APTR) NULL;
	ItemsR.Command = (BYTE) 0;
	ItemsR.SubItem = (struct MenuItem *) NULL;
	ItemsR.NextSelect = (USHORT) NULL;

	MenusR.NextMenu = (struct Menu *) NULL;
	MenusR.LeftEdge = 10;
	MenusR.TopEdge = 0;
	MenusR.Width = TextLength(rastPort, "REPERTOIRE", strlen("REPERTOIRE "));
	MenusR.Height = rastPort->Font->tf_YSize;
	MenusR.Flags = MENUENABLED;
	MenusR.MenuName = "REPERTOIRE";
	MenusR.FirstItem = &ItemsR;

}

/****************************************************************/
/*
 * Recherche d'un abonné dans le fichier
 */
/*
 */
/*
 * Paramètres: le gadget sélectionne,
 */
/*
 * le deplacement à effectuer
 */
/*
 * Retour:
 */
/****************************************************************/
int
Recherche(void)
{
	int     Gagne = 0;
	long	NFiche = 0, PPos = 0,
	ThisRec, NextRec;

	struct coordonnee fiche,
	        cherche;

	Seek(fileRepertoire, 0L, OFFSET_BEGINNING);
	Read(fileRepertoire, (char *) &ThisRec, 4);

	upperString(abonne.nom, cherche.nom);
	upperString(abonne.prenom, cherche.prenom);
	upperString(abonne.adresse1, cherche.adresse1);
	upperString(abonne.adresse2, cherche.adresse2);
	strcpy(cherche.codepost, abonne.codepost);
	upperString(abonne.ville, cherche.ville);
	upperString(abonne.pays, cherche.pays);

	do
	{
		FilePos = Seek(fileRepertoire, ThisRec + POSNEXT, OFFSET_BEGINNING);

		Read(fileRepertoire, (char *) &NextRec, 4);

		Read(fileRepertoire, fiche.nom, STRGADGCAR);
		Read(fileRepertoire, fiche.prenom, STRGADGCAR);
		Read(fileRepertoire, fiche.adresse1, STRGADGCAR);
		Read(fileRepertoire, fiche.adresse2, STRGADGCAR);
		Read(fileRepertoire, fiche.codepost, STRGADGCOD);
		Read(fileRepertoire, fiche.ville, STRGADGCAR);
		Read(fileRepertoire, fiche.pays, STRGADGCAR);

		upperString(fiche.nom, fiche.nom);
		upperString(fiche.prenom, fiche.prenom);
		upperString(fiche.adresse1, fiche.adresse1);
		upperString(fiche.adresse2, fiche.adresse2);
		upperString(fiche.ville, fiche.ville);
		upperString(fiche.ville, fiche.ville);

		if ((FilePos != EOF) && \
		    ((strncmp(cherche.nom, fiche.nom, strlen(cherche.nom)) != 0) || (strlen(cherche.nom) == 0)) && \
		    ((strncmp(cherche.prenom, fiche.prenom, strlen(cherche.prenom)) != 0) || (strlen(cherche.prenom) == 0)) && \
		    ((strncmp(cherche.adresse1, fiche.adresse1, strlen(cherche.adresse1)) != 0) || (strlen(cherche.adresse1) == 0)) && \
		    ((strncmp(cherche.adresse2, fiche.adresse2, strlen(cherche.adresse2)) != 0) || (strlen(cherche.adresse2) == 0)) && \
		    ((strncmp(cherche.codepost, fiche.codepost, strlen(cherche.codepost)) != 0) || (strlen(cherche.codepost) == 0)) && \
		    ((strncmp(cherche.ville, fiche.ville, strlen(cherche.ville)) != 0) || (strlen(cherche.ville) == 0)) && \
		    ((strncmp(cherche.pays, fiche.pays, strlen(cherche.pays)) != 0) || (strlen(cherche.pays) == 0)))
		{
			NFiche++;
			ThisRec = NextRec;
		}

		else if (FilePos != EOF)
			Gagne = 1;

	}
	while ((FilePos != EOF) && !Gagne);

	ThisRec = NextRec;
	NumFiche = NFiche;

	if (Gagne && (FilePos != EOF))
	{
		if (FileWindow)
		{
			Seek(fileRepertoire, ThisRec, OFFSET_BEGINNING);
			Read(fileRepertoire, (char *) &ThisRecord, 4);
			Read(fileRepertoire, (char *) &LastRecord, 4);
			Read(fileRepertoire, (char *) &NextRecord, 4);
			Aff_Fiche();
        }
		else
		{
		Read(fileRepertoire, fiche.telephone1, STRGADGTEL);
		Read(fileRepertoire, fiche.telephone2, STRGADGTEL);
		Read(fileRepertoire, fiche.fax, STRGADGTEL);
		Read(fileRepertoire, fiche.note1, STRGADGCAR);
		Read(fileRepertoire, fiche.note2, STRGADGCAR);

			CopyMem(&fiche, &abonne, sizeof(struct coordonnee));
        }
	}
	else
	{
		abonne.nom[0] = '\0';
		abonne.prenom[0] = '\0';
		abonne.adresse1[0] = '\0';
		abonne.adresse2[0] = '\0';
		abonne.codepost[0] = '\0';
		abonne.ville[0] = '\0';
		abonne.pays[0] = '\0';
		abonne.telephone1[0] = '\0';
		abonne.telephone2[0] = '\0';
		abonne.fax[0] = '\0';
		abonne.note1[0] = '\0';
		abonne.note2[0] = '\0';

		if (FileWindow)
			RefreshGList(FirstStringGadget, FileWindow, NULL, 12);
	}
	return (Gagne);
}

/****************************************************************/
/*
 * Modification d'un abonné dans le fichier
 */
/*
 */
/*
 * Paramètres: NULL
 */
/*
 * Retour: NULL
 */
/****************************************************************/
void
Enregistre(void)
{
	struct Gadget *GadgetSel;
	int     i;

	Seek(fileRepertoire, ThisRecord + POSNOM, OFFSET_BEGINNING);

	GadgetSel = FirstStringGadget;

	for (i = 0; (i < MAXLINE); i++)
	{
		Write(fileRepertoire, (char *) ((struct StringInfo *) GadgetSel->SpecialInfo)->Buffer, (long) ((struct StringInfo *) GadgetSel->SpecialInfo)->MaxChars);
		GadgetSel = GadgetSel->NextGadget;
	}
}

/****************************************************************/
/*
 * Ajoute un abonné dans le fichier
 */
/*
 */
/*
 * Paramètres: NULL                                        
 */
/*
 * Retour: NULL
 */
/****************************************************************/
void
Ajoute(void)
{
	struct Gadget *GadgetSel;
	char    chaineLue[STRGADGCAR],
	        chaine1[STRGADGCAR],
	        chaine2[STRGADGCAR];
	int     fin = 0,
	        result = 1,
	        i = 0;
	ULONG   LastFiche = 0,
	        ThisFiche = 0;

	NumFiche = 0;
	LastRecord = 0;
	NextRecord = STRGADGORD;
	Seek(fileRepertoire, 0L, OFFSET_BEGINNING);
	Read(fileRepertoire, (char *) &ThisRecord, 4);

	do
	{
		FilePos = Seek(fileRepertoire, ThisRecord + POSNEXT, OFFSET_BEGINNING);
		if (FilePos != EOF)
		{
			Read(fileRepertoire, (char *) &NextRecord, 4);
			Seek(fileRepertoire, ThisRecord + champ[i], OFFSET_BEGINNING);
			switch (i)
			    {
			    case 0:				     // On compare le nom

				    Read(fileRepertoire, chaineLue, STRGADGCAR);
				    upperString(abonne.nom, chaine1);
				    break;
			    case 1:				     // On compare le prénom

				    Read(fileRepertoire, chaineLue, STRGADGCAR);
				    upperString(abonne.prenom, chaine1);
				    break;
			    case 2:				     // On compare l'adresse 1

				    Read(fileRepertoire, chaineLue, STRGADGCAR);
				    upperString(abonne.adresse1, chaine1);
				    break;
			    case 3:				     // On compare l'adresse 2

				    Read(fileRepertoire, chaineLue, STRGADGCAR);
				    upperString(abonne.adresse2, chaine1);
				    break;
			    case 4:				     // On compare le code postal

				    Read(fileRepertoire, chaineLue, STRGADGCOD);
				    upperString(abonne.codepost, chaine1);
				    break;
			    case 5:				     // On compare la ville

				    Read(fileRepertoire, chaineLue, STRGADGCAR);
				    upperString(abonne.ville, chaine1);
				    break;
			    case 6:				     // On compare le pays

				    Read(fileRepertoire, chaineLue, STRGADGCAR);
				    upperString(abonne.pays, chaine1);
				    break;
			    case 7:				     // On compare le numéro de téléphone 1

				    Read(fileRepertoire, chaineLue, STRGADGTEL);
				    upperString(abonne.telephone1, chaine1);
				    break;
			    case 8:				     // On compare le numéro de téléphone 2

				    Read(fileRepertoire, chaineLue, STRGADGTEL);
				    upperString(abonne.telephone2, chaine1);
				    break;
			    case 9:				     // On compare le numéro de fax

				    Read(fileRepertoire, chaineLue, STRGADGTEL);
				    upperString(abonne.fax, chaine1);
				    break;
			    default:
				    break;
			    }

			upperString(chaineLue, chaine2);
			result = strcmp(chaine1, chaine2);

			if (result < 0)
			{
			    // la nouvelle fiche (struct abonne) prend
			    // la place de la presente.
				if (LastRecord)
					Seek(fileRepertoire, LastRecord + POSNEXT, OFFSET_BEGINNING);	// il faut donc informer la fiche qui nous

				else
					Seek(fileRepertoire, LastRecord + POSLAST, OFFSET_BEGINNING);	// a envoye ici qu'elle doit delivrer une autre adresse.

				Write(fileRepertoire, (char *) &EndFile, 4);	// En l'occurrence la fin du fichier puisque c'est là
			    // que sont ajoutee les nouvelles fiches.

				Seek(fileRepertoire, ThisRecord + POSLAST, OFFSET_BEGINNING);	// On doit informer la fiche qui suivra celle qu'on ajoute

				Write(fileRepertoire, (char *) &EndFile, 4);	// de l'adresse qui la precede. qui est evidemment la fin
			    // l'adresse de la fin du fichier.

				Seek(fileRepertoire, 0L, OFFSET_END);	// On ecrit donc en fin de fichier qui nous envoie ici et
			    // ou doit on aller pour trouver le prochain abonne.

				Write(fileRepertoire, (char *) &LastRecord, 4);
				Write(fileRepertoire, (char *) &ThisRecord, 4);

				Seek(fileRepertoire, ThisRecord + POSNEXT, OFFSET_BEGINNING);	// On va aussi informer la dernière fiche de l'alphabet

				Read(fileRepertoire, (char *) &LastFiche, 4);	// que le fichier a grandit.

				ThisFiche = ThisRecord;
				while (LastFiche < EndFile)	     // On recherche donc la dernière fiche.

				{
					ThisFiche = LastFiche;
					Seek(fileRepertoire, LastFiche + POSNEXT, OFFSET_BEGINNING);
					Read(fileRepertoire, (char *) &LastFiche, 4);
				}
				Seek(fileRepertoire, ThisFiche + POSNEXT, OFFSET_BEGINNING);	// On se positionne sur le champ NextRecord de la derniere fiche.

				EndFile += NEXTRECORD;
				Write(fileRepertoire, (char *) &EndFile, 4);	// et on ecrit la nouvelle taille du fichier.

				NextRecord = ThisRecord;
				ThisRecord = EndFile;		     // On maintient à jour ces variables pour les gadgets de parcours

				GadgetSel = FirstStringGadget;	     // on écrit maintenant la fiche

				Seek(fileRepertoire, 0L, OFFSET_END);

				Write(fileRepertoire, abonne.nom, STRGADGCAR);
				Write(fileRepertoire, abonne.prenom, STRGADGCAR);
				Write(fileRepertoire, abonne.adresse1, STRGADGCAR);
				Write(fileRepertoire, abonne.adresse2, STRGADGCAR);
				Write(fileRepertoire, abonne.codepost, STRGADGCOD);
				Write(fileRepertoire, abonne.ville, STRGADGCAR);
				Write(fileRepertoire, abonne.pays, STRGADGCAR);
				Write(fileRepertoire, abonne.telephone1, STRGADGTEL);
				Write(fileRepertoire, abonne.telephone2, STRGADGTEL);
				Write(fileRepertoire, abonne.fax, STRGADGTEL);
				Write(fileRepertoire, abonne.note1, STRGADGCAR);
				Write(fileRepertoire, abonne.note2, STRGADGCAR);

/*
 * for (i = 0; (i < MAXLINE); i++)
 * {
 * Write(fileRepertoire, ((struct StringInfo *) GadgetSel->SpecialInfo)->Buffer, ((struct StringInfo *) GadgetSel->SpecialInfo)->MaxChars);
 * GadgetSel = GadgetSel->NextGadget;
 * }
 */
				Flush(fileRepertoire);
				LenFile();

				break;
			}

			if (result == 0)

			{
				i++;				     /*
								      * Les champs précédents sont identiques, on compare le suivant 
								      */
			}

			if (result > 0)
			{
				LastRecord = ThisRecord;
				ThisRecord = NextRecord;
				NumFiche++;
			}
		}
		else
			break;

	}
	while ((FilePos != EOF) && (i < 11));

}

/****************************************************************/
/*
 * Parcours du fichier
 */
/*
 */
/*
 * Paramètres: le deplacement a effectuer
 */
/*
 */
/*
 * Retour:
 */
/****************************************************************/
void
Deplace(int Deplacement)
{

	if ((Deplacement == -1) && (LastRecord != 0))
	{
		NumFiche--;
		ThisRecord = LastRecord;
	}

	if ((Deplacement == 1) && (NextRecord != EndFile))
	{
		NumFiche++;
		ThisRecord = NextRecord;
	}

	Seek(fileRepertoire, ThisRecord + POSLAST, OFFSET_BEGINNING);
	Read(fileRepertoire, (char *) &LastRecord, 4);
	Read(fileRepertoire, (char *) &NextRecord, 4);

	Flush(fileRepertoire);
	Aff_Fiche();
}

/****************************************************************/
/*
 * mise a jour du gadget proportionnel                     
 */
/*
 */
/*
 * Paramètres: NULL
 */
/*
 * Retour: NULL                                            
 */
/****************************************************************/
void
Alphabet(long NewPos)
{
	char    lettre,
	        Nextlettre;
	char    c;

	lettre = abonne.nom[0];
	do
	{
		if (NewPos == oldPos)
			return ();

		if ((NewPos < oldPos) && (LastRecord != 0))
		{
			ThisRecord = LastRecord;
			NumFiche--;
		}

		if ((NewPos > oldPos) && (NextRecord != EndFile))
		{
			ThisRecord = NextRecord;
			NumFiche++;
		}

		Seek(fileRepertoire, ThisRecord + POSLAST, OFFSET_BEGINNING);
		Read(fileRepertoire, (char *) &LastRecord, 4);
		Read(fileRepertoire, (char *) &NextRecord, 4);
		Read(fileRepertoire, (char *) &c, 1);
	}
	while (((Nextlettre = (char) toupper((int) c)) == lettre) && (LastRecord != 0) && (NextRecord != EndFile));

	oldPos = Potar;

	Aff_Fiche();
}

/****************************************************************/
/*
 * Affichage de la fiche choisie
 */
/*
 */
/*
 * Paramètres : NULL
 */
/*
 * Retour: NULL
 */
/****************************************************************/
void
Aff_Fiche(void)
{
	struct Gadget *GadgetSel;
	int     i;

	Seek(fileRepertoire, ThisRecord + POSLAST, OFFSET_BEGINNING);
	Read(fileRepertoire, (char *) &LastRecord, 4);
	FilePos = Read(fileRepertoire, (char *) &NextRecord, 4);

	RemoveGList(FileWindow, FirstStringGadget, 12);

	GadgetSel = FirstStringGadget;

	for (i = 0; (FilePos != EOF) && (i < MAXLINE); i++)
	{
		FilePos = Read(fileRepertoire, ((struct StringInfo *) GadgetSel->SpecialInfo)->Buffer, ((struct StringInfo *) GadgetSel->SpecialInfo)->MaxChars);
		GadgetSel = GadgetSel->NextGadget;
	}

	AddGList(FileWindow, FirstStringGadget, ~0, 12, NULL);
	RefreshGList(FirstStringGadget, FileWindow, NULL, 12);

}

/****************************************************************/
/*
 * Suppression de la fiche visualisée
 */
/*
 */
/*
 * Paramètres: NULL
 */
/*
 * Retour: NULL
 */
/****************************************************************/
void
Detruit(void)
{
// En fait, on ne modifie que le chainage du fichier. La fonction Pack
    // se chargera de ne conserver que ce qui est utile.

	Seek(fileRepertoire, ThisRecord + POSLAST, OFFSET_BEGINNING);	// on se repositionne sur le debut de la fiche.

	Read(fileRepertoire, (char *) &LastRecord, 4);		     // On relie la position de la precedente

	Read(fileRepertoire, (char *) &NextRecord, 4);		     // et la position de la suivante.

	Seek(fileRepertoire, NextRecord + POSLAST, OFFSET_BEGINNING);
	Write(fileRepertoire, (char *) &LastRecord, 4);		     // A la suivante, on indique la precedente. Vu ??

	Seek(fileRepertoire, (LastRecord == 0 ? 0L : LastRecord + POSNEXT), OFFSET_BEGINNING);
	Write(fileRepertoire, (char *) &NextRecord, 4);		     // Et a la precedente, on indique la suivante. Logique non ??

	LenFile();						     // Enfin, on ajuste le gadget proportionnel. Ah OK, D'ACCORD, OK, OK, OK, OK !!??!!

	ThisRecord = NextRecord;
	Aff_Fiche();
}

/****************************************************************/
/*
 * Lecture de la longueur du fichier
 */
/*
 */
/*
 * Paramètres: NULL
 */
/*
 * Retour: NULL
 */
/****************************************************************/
void
LenFile(void)
{
	long    NextRec = 0;

	NbreFiches = 0;

	EndFile = Seek(fileRepertoire, 0L, OFFSET_END);
	EndFile = Seek(fileRepertoire, 0L, OFFSET_END);		     // On lit la longueur du fichier pour connaitre l'adresse
    														// de fin de fichier. On le fait 2 fois parce qu'une
    														// fois ne suffit apparemment pas.

	Seek(fileRepertoire, 0L, OFFSET_BEGINNING);		     // Je cherche l'adresse de la première fiche.

	Read(fileRepertoire, (char *) &NextRec, 4);		     // Je la lit.

	FilePos = Seek(fileRepertoire, NextRec + POSNEXT, OFFSET_BEGINNING);	// Je m'y positionne.

	Read(fileRepertoire, (char *) &NextRec, 4);		     // Je lit l'adresse de la suivante.

	while (FilePos != EOF)
	{
		FilePos = Seek(fileRepertoire, NextRec + POSNEXT, OFFSET_BEGINNING);

		Read(fileRepertoire, (char *) &NextRec, 4);

		NbreFiches++;
	}
	NbreFiches--;

	PropPos = (NumFiche / ((NbreFiches * 1.0))) * MAXBODY;	     // NextRecord pointe sur la fiche actuellement à l'écran.
    // On détermine son numéro d'ordre et on calcul la valeur

	oldPos = PropPos;					     // a indiquer au gdaget proportionnel.

	if (FileWindow)
		NewModifyProp((struct Gadget *)propgad, FileWindow, NULL, ((struct PropInfo) propgad->pinfo).Flags, 0,
			      PropPos, (ULONG)0xFFFFL,
			      (ULONG) (MAXBODY / (NbreFiches + 1)), 1);

}

/****************************************************************/
/*
 * Demande d'informations pour recherche et enregistrement
 */
/*
 */
/*
 * Paramètres: NULL
 */
/*
 * Retour: NULL
 */
/****************************************************************/
void
Repertoire(void)
{
	if (!FileWindow)
	{
		InstallRepertoire();
		CreeMenuR();
		SetMenuStrip(FileWindow, &MenusR);

		ModifyIDCMP(FileWindow, IDCMP_CLOSEWINDOW | IDCMP_GADGETDOWN | IDCMP_GADGETUP | IDCMP_MOUSEMOVE | IDCMP_MENUPICK | IDCMP_ACTIVEWINDOW);
		FileWindowNotClosed = 1;
	}
}

void
HandleFileWindow(ULONG Class, UWORD Code, APTR Address)

{
	switch (Class)
	    {
	    case ACTIVEWINDOW:
		    ActivateGadget(FirstStringGadget, FileWindow, NULL);
		    break;

	    case IDCMP_MENUPICK:
		    if (Code != MENUNULL)
			    switch (ITEMNUM(Code))
				{
				case 0:
					Pack();
					break;

				}
		    break;

	    case IDCMP_CLOSEWINDOW:
		    CloseFileWindow();
		    break;

	    case IDCMP_GADGETDOWN:
		    if (Address == (APTR) & N1)
		    {
				strcpy(Chaine, abonne.telephone1);
			    GT_SetGadgetAttrs(gadText, MyWindow, NULL,
					      GTTX_Text, Chaine,
					      TAG_END);
				Recompose(Chaine);
		    }

		    if (Address == (APTR) & N2)
		    {
				strcpy(Chaine, abonne.telephone2);
			    GT_SetGadgetAttrs(gadText, MyWindow, NULL,
					      GTTX_Text, Chaine,
					      TAG_END);
				Recompose(Chaine);
		    }

		    if (Address == (APTR) & N3)
		    {
				strcpy(Chaine, abonne.fax);
			    GT_SetGadgetAttrs(gadText, MyWindow, NULL,
					      GTTX_Text, Chaine,
					      TAG_END);
				Recompose(Chaine);
		    }

		    if (Address == (APTR) & propgad->up)
		    {
			    Deplace(-1);
		    }

		    if (Address == (APTR) & propgad->down)
		    {
			    Deplace(1);
		    }

		    if ((((struct Gadget *) Address) == &(propgad->scroller)) && (((struct PropInfo) propgad->pinfo).Flags & KNOBHIT))
			    fix_display = 1;

		    if (Address == (APTR) & New)
		    {
			    abonne.nom[0] = '\0';
			    abonne.prenom[0] = '\0';
			    abonne.adresse1[0] = '\0';
			    abonne.adresse2[0] = '\0';
			    abonne.codepost[0] = '\0';
			    abonne.ville[0] = '\0';
			    abonne.pays[0] = '\0';
			    abonne.telephone1[0] = '\0';
			    abonne.telephone2[0] = '\0';
			    abonne.fax[0] = '\0';
			    abonne.note1[0] = '\0';
			    abonne.note2[0] = '\0';
			    RefreshGList(FirstStringGadget, FileWindow, NULL, 12);
		    }

		    if (Address == (APTR) & Find)
		    {
			    Recherche();
		    }

		    if (Address == (APTR) & Save)
		    {
			    Enregistre();
		    }

		    if (Address == (APTR) & Append)
		    {
			    Ajoute();
		    }

		    if (Address == (APTR) & RemoveG)
		    {
				if (EasyRequest(NULL, &confirm, NULL, NULL))
				    Detruit();
		    }

		    break;

	    case IDCMP_GADGETUP:
		    if ((Address == (APTR) &(propgad->scroller)) && !fix_display)
		    {
			    Alphabet(Potar);
		    }
		    else
			    fix_display = 0;

		    PropPos = (NumFiche / ((NbreFiches * 1.0))) * MAXBODY;

		    oldPos = PropPos;

		    NewModifyProp((struct Gadget *)propgad, FileWindow, NULL, ((struct PropInfo) propgad->pinfo).Flags, 0,
				  PropPos, MAXBODY, (ULONG) (MAXBODY / (NbreFiches + 1)), 1);

		    if ((Address == (APTR) &New) || (Address == (APTR) &Find))
			    ActivateGadget(FirstStringGadget, FileWindow, NULL);

			if ((((struct Gadget *)Address)->GadgetType == GTYP_STRGADGET) && (Address != (APTR) lastString))
				ActivateGadget(((struct Gadget *)Address)->NextGadget, FileWindow, NULL);
            else
			    ActivateGadget(FirstStringGadget, FileWindow, NULL);

		    break;

	    default:
		    break;

	    }

	if (fix_display)
	{

		while (((long) ((Potar + 1) / ((struct PropInfo) propgad->pinfo).VPotRes + 0.5)) != NumFiche)
		{
			if (Potar < oldPos)
			{
				ThisRecord = LastRecord;
				Seek(fileRepertoire, ThisRecord + POSLAST, OFFSET_BEGINNING);
				Read(fileRepertoire, (char *) &LastRecord, 4);
				NumFiche--;
				oldPos -= ((struct PropInfo) propgad->pinfo).VPotRes;
				if (oldPos < 0)
					oldPos = 0;
			}

			else if (Potar > oldPos)
			{
				ThisRecord = NextRecord;
				Seek(fileRepertoire, ThisRecord + POSNEXT, OFFSET_BEGINNING);
				Read(fileRepertoire, (char *) &NextRecord, 4);
				NumFiche++;
				oldPos += ((struct PropInfo) propgad->pinfo).VPotRes;
				if (oldPos > 0xFFFF)
					oldPos = 0xFFFF;
			}
		}
		Aff_Fiche();

	}

}

/****************************************************************/
/*
 * Fonction permettant de supprimer toutes les fiches
 */
/*
 * qui ne sont plus chainees dans le fichier Repertoire.dat
 */
/*
 * Paramètres: NULL
 */
/*
 * Retour: NULL
 */
/****************************************************************/
void
Pack(void)
{
	long    NextRec = 4L,
	        NewNextRec = STRGADGORD + NEXTRECORD,
	        NewLastRec = 0L,
	        n = STRGADGORD,
	        Carlu = 0;
	int     TmpFile;
	struct coordonnee Fiche;

	if ((TmpFile = Open((UBYTE *) "TmpDtmf.dat", MODE_READWRITE)) == -1)
		cleanUp("Creation fichier temporaire impossible", 6);

	Write(TmpFile, (char *) &NextRec, 4);			     // Maintenant, la première fiche sera obligatoirement au début.

	Seek(fileRepertoire, 0L, OFFSET_BEGINNING);		     // Je cherche l'adresse de la première fiche.

	Read(fileRepertoire, (char *) &NextRec, 4);		     // Je la lit.

	FilePos = Seek(fileRepertoire, NextRec, OFFSET_BEGINNING);   // Je me positionne sur la première fiche.

	Read(fileRepertoire, (char *) &Fiche, sizeof(struct coordonnee));	// Je lit la fiche.

	NextRec = Fiche.NextRecord;
	Fiche.LastRecord = NewLastRec;				     // La première fiche est forcément adressee par le champ 0.

	Fiche.NextRecord = NewNextRec;				     // La deuxieme se trouvera tout de suite apres la premiere.

	Write(TmpFile, (char *) &Fiche, sizeof(struct coordonnee));	// Je l'ecrit dans le nouveau fichier.

	Seek(fileRepertoire, NextRec, OFFSET_BEGINNING);
	Carlu = Read(fileRepertoire, (char *) &Fiche, sizeof(struct coordonnee));

	while (Carlu != 0)					     // Etc....

	{
		NextRec = Fiche.NextRecord;
		NewLastRec = NewNextRec - NEXTRECORD;
		NewNextRec += NEXTRECORD;
		Fiche.LastRecord = NewLastRec;
		Fiche.NextRecord = NewNextRec;
		Write(TmpFile, (char *) &Fiche, sizeof(struct coordonnee));

		Seek(fileRepertoire, NextRec, OFFSET_BEGINNING);
		Carlu = Read(fileRepertoire, (char *) &Fiche, sizeof(struct coordonnee));
	}

	Close(TmpFile);
	Close(fileRepertoire);

// J'efface le fichier repertoire.dat
	System("delete >NIL: repertoire.dat", NULL);
// Je renome le fichier TmpDtmf.dat en repertoire.dat
	System("rename >NIL: TmpDtmf.dat repertoire.dat", NULL);

	if ((fileRepertoire = Open((UBYTE *) "repertoire.dat", MODE_READWRITE)) == -1)
		cleanUp("réouverture fichier de données impossible", 6);

	if (Read(fileRepertoire, " ", 1L) == 0)
	{
		Write(fileRepertoire, (char *) &n, 4);
		Flush(fileRepertoire);
	}

	NumFiche = 0;
	Seek(fileRepertoire, 0L, OFFSET_BEGINNING);
	LastRecord = 0;
	ThisRecord = NextRecord = STRGADGORD;
	LenFile();						     // Je remet tout en ordre

// Ouf... c'est terminé.

}

/****************************************************************/
/*
 * Fonction transformant une chaine en caractères minuscules   
 */
/*
 * en une chaine en caractères majuscules                      
 */
/*
 * Parametres: chaine source, chaine destination           
 */
/*
 * Retour: NULL                                            
 */
/****************************************************************/
void
upperString(char *str1, char *str2)
{
	int     i = 0;

	while (str1[i] != '\0')
	{
		str2[i] = (char) toupper((int) str1[i]);
		i++;
	}

	str2[i] = '\0';
}

void
CloseFileWindow()
{
	ModifyIDCMP(FileWindow, 0L);
	DeleteStringGadgets(FileWindow, FirstStringGadget);
	CloseWindow(FileWindow);
	FileWindow = NULL;
	free_prop(propgad);
	FileWindowNotClosed = 0;
}