/*
 * Eti.c :
 * -------
 * Auteur        : Xavier Mertens
 * Version   $VER: 1.02
 * Création      : 17 Mar 1993 - 18:39
 * Modification  : 10 Apr 1993 - 14:03
 * Langage       : SAS/C V6.00
 * Compatibilité : 2.x - 3.0
 * Description   : Programme d'impression d'étiquettes pour disk 3"½ 
 * Remarque(s)   : - Mettre la pile à environ 10Ko!!!
 *                 - Gestion de l'interface par Precognition 1.0
 * Historique    : 1.00 - Création.
 *								 1.01 - Ajout de la fenêtre de configuration.
 *                 1.02 - Correction de quelques bugs.
 *                        Ajout de l'info 'FS' sur l'étiquette.
 *                        Modification des routines do_FenetreNom() et Motor().
 */

#include <exec/types.h>
#include <exec/execbase.h>
#include <exec/memory.h>
#include <devices/trackdisk.h>
#include <precognition/precognition.h>
#include <intuition/intuitionbase.h>
#include <graphics/gfxbase.h>
#include <graphics/gfx.h>
#include <workbench/workbench.h>
#include <stdio.h>
#include <string.h>

#include "Eti_help.h"	/* Messages d'erreur,d'aide,... */

#include <clib/exec_protos_bis.h>  /* Version modifiée pour Precognition */
#include <clib/dos_protos.h>
#include <clib/intuition_protos.h>
#include <clib/graphics_protos.h>
#include <clib/wb_protos.h>

int CXBRK(void) { return(0); }    /* Aucune interruption ne sera tolérée! */
int chkabort(void) { return(0); }

/* ---- Defines --------------------------------------------------------- */

#define VERSTAG       "$VER: Eti 1.02 © XM 10.04.93 "
#define WARN          5
#define OK            0
#define ICONIFIED     10
#define OS_VERSION    37
#define TITRE_FENETRE "Eti v1.02 © Xavier Mertens - 10.04.93"
#define TITRE_AIDE    "Eti v1.02 © Xavier Mertens - 10.04.93          [Aide en ligne activée]"
#define PRINT(x)      { if(Output()) Write(Output(),x,strlen(x)); else DisplayBeep(NULL); }
#define NUM_LINES     15
#define OUTPUT        "PRT:"  /* Parallel.device!!! */
#define CODES_PRT			"\033[4w" /* Config par défaut */
#define NLQ						"\033[2\042z"
#define RESET					"\033\143"
#define US						"\033(B"
#define AUTRE					"PC0:"
#define PREFS					"ENV:Eti.prefs"
#define PREFS_BIS			"ENVARC:Eti.prefs"
#define ID_OFS        (0x444F5300L)  /* Définition des différentes FS */
#define ID_FFS        (0x444F5301L)
#define ID_OFSINT     (0x444F5302L)
#define ID_FFSINT     (0x444F5303L)
#define ID_DCFSOFS    (0x444F5304L)
#define ID_DCFSFFS    (0x444F5305L)
#define ID_BAD        (0x42414400L)
#define ID_NDOS       (0x4E444F53L)
#define ID_KICK       (0x4B49434BL)
#define TRACK_SIZE    ((LONG)(NUMSECS * TD_SECTOR))

/* ---- Structures ------------------------------------------------------ */

struct IntuitionBase *IntuitionBase;
struct GfxBase       *GfxBase;
struct WorkbenchBase *WorkbenchBase;
struct Window        *W;
struct EasyStruct    HelpRequester = {  /* Requester de l'aide en ligne */
                       sizeof(struct EasyStruct),
                       0,
                       (UBYTE *)"Aide en ligne...",
                       (UBYTE *)"%s",
                       (UBYTE *)"Continue|Stoppe"
                     },
                     WarningRequester = { /* Requester d'avertissement */
                       sizeof(struct EasyStruct),
                       0,
                       (UBYTE *)"Requête d'Eti...",
                       (UBYTE *)"%s",
                       (UBYTE *)"Oui|Non"
                     },
                     ErrorRequester = {  /* Requester de message d'erreur */
                       sizeof(struct EasyStruct),
                       0,
                       (UBYTE *)"Gestion d'erreur...",
                       (UBYTE *)"%s",
                       (UBYTE *)"Désolé!"
                     },
                     AboutRequester = {  /* Requester de bienvenue */
                       sizeof(struct EasyStruct),
                       0,
                       (UBYTE *)"A Propos...",
                       (UBYTE *)"%s",
                       (UBYTE *)"Merci"
                     };
struct AppMenuItem   *IconifyMenu;
struct AppMessage    *AppMsg;
struct MsgPort       *Port;
struct IntuiMessage  *MessageMenu;
struct IOExtTD       *DiskReq;
struct MsgPort       *DiskPort;


/* ---- Prototypes des fonctions ---------------------------------------- */

extern void __exit(int);
extern int atoi(const char *);
void DeletePort(struct MsgPort *ioReq);

struct IORequest *CreateExtIO( struct MsgPort *port, long ioSize );
struct MsgPort *CreatePort( STRPTR name, long pri );
void DeleteExtIO( struct IORequest *ioReq );
void DeletePort( struct MsgPort *ioReq );

int do_Fenetre(void);
int ReadTrack(VOID);
char *DiskName(char *name);
char *Today(void);
long FreeSpace(char *Unite);
BOOL do_FenetreNom(char str[]);
BOOL do_FenetrePrefs(void);
BOOL LirePrefs(void);
BOOL EcrirePrefs(void);
VOID Motor(int mode);

/* ---- Déclarations des variables -------------------------------------- */

static char *UPREVSTAG = VERSTAG;

char *CycleGadget6_options[] = {
  "DF0:",
  "DF1:",
  "DF2:",
  "DF3:",
  "Autre",
  NULL
};

char *TypeFS[] = {
  "OFS",
  "FFS", 
  "OFS-INT",
  "FFS-INT",
  "DCFS-OFS",
  "DCFS-FFS",
  "???",
  NULL
};

char *Etiquette[15] = {
/* >-------------------------------------------< */
  "Eti v1.02 (C) XM (10.04.93)    Ecriture : OUI ", /*  0 */
  "                                          NON ", /*  1 */
  ".........................                     ", /*  2 */
  "                                              ", /*  3 */
  "Nom          : .........................      ", /*  4 */
  "Date         : .........................      ", /*  5 */
  "Espace Libre : .... Ko         FS : ........  ", /*  6 */
  "--------------------------------------------- ", /*  7 */
  " ...........................................  ", /*  8 */
  " ...........................................  ", /*  9 */
  " ...........................................  ", /* 10 */
  " ...........................................  ", /* 11 */
  " ...........................................  ", /* 12 */
  " ...........................................  ", /* 13 */
  "--------------------------------------------- "  /* 14 */
};

int i,j, /* Variables passe-partout */
		marge = 3,
		saut  = 3,
    lecteur,type;

UBYTE *Buffer;
unsigned int *point;

char str[30],
		 autre[5]  = AUTRE,
		 codes[50] = CODES_PRT,
		 sautdepage[10],
		 margegauche[10];
		

BOOL aide,
     date  = TRUE,
     libre = TRUE,
     nlq   = FALSE,
     lauto = TRUE;

FILE *Sortie;

/* ==== MAIN ============================================================ */

__stdargs __main(char *argv){

  int rc;

  if(!(IntuitionBase=(struct IntuitionBase *)OpenLibrary("intuition.library",OS_VERSION)) ||
     !(GfxBase=(struct GfxBase *)OpenLibrary("graphics.library",OS_VERSION)) ||
     !(WorkbenchBase=(struct WorkbenchBase *)OpenLibrary("workbench.library",OS_VERSION))){
    if(IntuitionBase)  CloseLibrary((struct Library *)IntuitionBase);
    if(GfxBase)        CloseLibrary((struct Library *)GfxBase);
    if(WorkbenchBase)  CloseLibrary((struct Library *)WorkbenchBase);
      PRINT("Erreur : Ouverture des bibliothèques.\n");
    __exit(WARN);
  }
  for(;;){
    rc = do_Fenetre();
    switch(rc){
      case WARN:
        PRINT("Erreur : Ouverture de la fenêtre.\n");
      case OK:
        CloseLibrary((struct Library *)IntuitionBase);
        CloseLibrary((struct Library *)GfxBase);
        CloseLibrary((struct Library *)WorkbenchBase);
        __exit(OK);
        break;
      case ICONIFIED:
        if(!(Port = CreateMsgPort())){
          PRINT("Erreur : Création du port.\n");
          break;
        }
        else
          if(!(IconifyMenu = AddAppMenuItem(0,0,"Réactiver Eti...",Port,NULL))){
            PRINT("Erreur : Impossible d'ajouter l'AppMenu.\n");
            DeletePort(Port);
            break;
          }
          else{
            Wait(1<<Port->mp_SigBit);        /* Dodo... */
            RemoveAppMenuItem(IconifyMenu);
            DeletePort(Port);
            break;
          }
        break;
      default:
        break;
    }
  }
  CloseLibrary((struct Library *)IntuitionBase);
  CloseLibrary((struct Library *)GfxBase);
  CloseLibrary((struct Library *)WorkbenchBase);
  __exit(OK);
}

/* ---- Fonctions do_Fenetre() --------------------------------------------- */

int do_Fenetre(){
  int rc;
  pcgWindow     Fenetre;
  pcg_3DPens    pens;
  BOOL          done;
  IntuiMessage *message, event;
  OutlineBox    OutlineBox1;
  OutlineBox    OutlineBox2;
  OutlineBox    OutlineBox5;
  OutlineBox    OutlineBox7;
  ListEditor    ListEditor0;
  CycleGadget   CycleGadget6;
  BoolGadget    BoolGadget8;
  BoolGadget    BoolGadget12;
  BoolGadget    BoolGadget13;
  BoolGadget    BoolGadget14;
	BoolGadget		BoolGadget3;

  pens = StandardPens();

  pcgWindow_Init(&Fenetre,0,11,633,186,100,50,65535,65535,TITRE_FENETRE,
                 REFRESHWINDOW|CLOSEWINDOW,
                  WINDOWDRAG|WINDOWDEPTH|WINDOWCLOSE|SIMPLE_REFRESH|ACTIVATE,
                 NULL );

  OutlineBox_Init(&OutlineBox1,16,19,427,114,pens," Texte ");
  AddWindowObject(&Fenetre,(GraphicObject*)&OutlineBox1 );

  OutlineBox_Init(&OutlineBox2,455,19,158,56,pens,"  Prefs  ");
  AddWindowObject(&Fenetre,(GraphicObject*)&OutlineBox2);

  OutlineBox_Init(&OutlineBox5,455,82,158,51,pens," Lecteurs ");
  AddWindowObject(&Fenetre,(GraphicObject*)&OutlineBox5);

  OutlineBox_Init(&OutlineBox7,16,142,598,34,pens," Actions ");
  AddWindowObject(&Fenetre,(GraphicObject*)&OutlineBox7);

  ListEditor_Init(&ListEditor0,33,28,390,96,pens,"",43);
  AddWindowObject(&Fenetre,(GraphicObject*) &ListEditor0);

  CycleGadget_Init( &CycleGadget6,486,99,96,pens,"",CycleGadget6_options);
  AddWindowObject(&Fenetre,(GraphicObject*)&CycleGadget6);

  BoolGadget_Init(&BoolGadget8,31,152,125,14,pens,"  Impression");
  AddWindowObject(&Fenetre,(GraphicObject*)&BoolGadget8);

  BoolGadget_Init(&BoolGadget12,179,152,125,14,pens,"     Reset");
  AddWindowObject(&Fenetre,(GraphicObject*)&BoolGadget12);

  BoolGadget_Init(&BoolGadget13,326,152,125,14,pens,"     Aide");
  AddWindowObject(&Fenetre,(GraphicObject*)&BoolGadget13);

  BoolGadget_Init(&BoolGadget14,472,152,125,14,pens,"   Iconifier");
  AddWindowObject(&Fenetre,(GraphicObject*)&BoolGadget14);

  BoolGadget_Init(&BoolGadget3,485,40,96,14,pens,"  Modifier");
  AddWindowObject(&Fenetre,(GraphicObject*)&BoolGadget3);

  if(pcgOpenWindow(&Fenetre)){
    Refresh((Interactor *)&Fenetre);
    W = iWindow(&Fenetre);
    EasyRequest(NULL,&AboutRequester,NULL,A_PROPOS); /* Petit message */
		LirePrefs();

    done = FALSE;
    while(!done){
      message = WaitForMsg(Fenetre.Window->UserPort);
      event   = *message;
      ReplyMsg((struct Message *)message);

      switch (event.Class){

        case CLOSEWINDOW:
          done = TRUE;
          rc = OK;
          break;

        case REFRESHWINDOW:
          BeginRefresh( iWindow( &Fenetre ) );
          Refresh((Interactor *)&Fenetre);
          EndRefresh( iWindow( &Fenetre ), TRUE );
          break;

        default:

          /* Texte editor */

          if(Respond( (Interactor*) &ListEditor0, &event) & CHANGED_STATE){
            if(aide)
              if(!EasyRequest(NULL,&HelpRequester,NULL,TEXTE_AIDE))
                break;
            if(StringList_of(&ListEditor0.slist)->nEntries > 6){
              EasyRequest(NULL,&ErrorRequester,NULL,MAX_ERREUR);
              break;
            }
          }

          /* Lecteur ? */

          if(Respond( (Interactor*) &CycleGadget6, &event) & CHANGED_STATE)
            if(aide)
              if(!EasyRequest(NULL,&HelpRequester,NULL,LECTEUR_AIDE))
                break;
          
          /* Impression ? */

          if(Respond( (Interactor*) &BoolGadget8, &event) & CHANGED_STATE){
            if(aide)
              if(!EasyRequest(NULL,&HelpRequester,NULL,IMPRIME_AIDE))
                break;
            if(StringList_of(&ListEditor0.slist)->nEntries == 0)
              if(!EasyRequest(NULL,&WarningRequester,NULL,TEXT_WARNING)){
                ActivateNext((Interactor*)&ListEditor0);
                break;
              }

						/* Calcul du saut de page */

						strcpy(sautdepage,"");
						for(i=0;i<saut;i++)
							strcat(sautdepage,"\n");

						/* Calcul de la marge */

						strcpy(margegauche,"");
						for(i=0;i<marge;i++)
							strcat(margegauche," ");

            /* Détermination du type de FS */

            if(!(DiskPort = (struct MsgPort *)CreatePort(NULL,NULL)) ||
               !(DiskReq = (struct IOExtTD *)CreateExtIO(DiskPort,sizeof(struct IOExtTD))) ||
               OpenDevice(TD_NAME,lecteur,(struct IORequest *)DiskReq,NULL) ||
               !(Buffer = AllocMem(TRACK_SIZE,MEMF_CHIP|MEMF_PUBLIC))){
              EasyRequest(NULL,&ErrorRequester,NULL,FS_ERREUR);
              break;
            }
            Motor(1);
            type = ReadTrack();
            Motor(0);
            FreeMem(Buffer,TRACK_SIZE);
            DeleteExtIO((struct IORequest *)DiskReq);
            DeletePort(DiskPort);

            /* Lecture du nom de la disquette */
            
            if(!strcmp(DiskName(CycleGadget6_options[Value((Valuator *)&CycleGadget6)]),"-1")){
              EasyRequest(NULL,&ErrorRequester,NULL,DRIVE_ERREUR);
              break;
            }
            strcpy(str,DiskName(CycleGadget6_options[Value((Valuator *)&CycleGadget6)]));

            if(lauto){
              sprintf(Etiquette[2],"%-45s",DiskName(CycleGadget6_options[Value((Valuator *)&CycleGadget6)]));
              sprintf(Etiquette[4],"Nom          : %s",str);
            }
            else
              if(!do_FenetreNom(str)){
                break;
              }
              else{
                sprintf(Etiquette[2],"%-45s",str);
                sprintf(Etiquette[4],"Nom          : %s",str);
              }

            /* Configuration imprimante */

            if(!(Sortie=fopen(OUTPUT,"w"))){
              EasyRequest(NULL,&ErrorRequester,NULL,PRT_ERREUR);
              break;
            }

						fprintf(Sortie,"%s",RESET);
						fprintf(Sortie,"%s",US);
						if(strlen(codes) > 0)
							fprintf(Sortie,"\033%s",codes);

  					strcpy(Etiquette[7],"---------------------------------------------");
  					strcpy(Etiquette[14],"---------------------------------------------");

            if(nlq)
              fprintf(Sortie,"%s",NLQ);

            for(i=0;i<StringList_of(&ListEditor0.slist)->nEntries;i++)
              sprintf(Etiquette[8+i]," %-43s ",&StringList_of(&ListEditor0.slist)->Entries[i][0]);

            if(i<=5)
              for(j=i;j<6;j++)
                strcpy(Etiquette[8+j],"                                             ");


            for(i=0;i<NUM_LINES;i++){
              switch(i){
                case 5:
                  if(date){
                    strcpy(str,Today());
                    sprintf(Etiquette[5],"Date         : %s",str);
                  }
                  else
                    strcpy(Etiquette[5],"Date         : -");
                  break;
                case 6:
                  if(libre)
                    if(lauto)
                      sprintf(Etiquette[6],"Espace Libre : %4d Ko         FS : %s",(FreeSpace(CycleGadget6_options[Value((Valuator *)&CycleGadget6)])*512)/1024,TypeFS[type]);
                    else
                      sprintf(Etiquette[6],"Espace Libre : -    Ko         FS : %s",TypeFS[type]);
                  else
                    sprintf(Etiquette[6],"Espace Libre : -    Ko         FS : %s",TypeFS[type]);
                  break;
                default:
                  break;  
              }
              fprintf(Sortie,"%s%s\n",margegauche,Etiquette[i]);
            }
            fprintf(Sortie,"%s",RESET);
            fprintf(Sortie,"%s",sautdepage);  /* Fin de l'étiquette */
            fclose(Sortie);
          }

          /* Reset ? */

          if(Respond( (Interactor*) &BoolGadget12, &event) & CHANGED_STATE){
            if(aide)
              if(!EasyRequest(NULL,&HelpRequester,NULL,RESET_AIDE))
                break;
            date = libre = nlq = lauto = TRUE;
            SetValue((Valuator *)&CycleGadget6,0);
            Refresh((Interactor *)&CycleGadget6);
            DeleteAllStrings(&ListEditor0.slist);
            Refresh((Interactor *)&ListEditor0.slist);
						LirePrefs();
            break;
          }

          /* Aide ? */

          if(Respond( (Interactor*) &BoolGadget13, &event) & CHANGED_STATE){
            switch(aide){
              case TRUE:
                aide=FALSE;
                SetWindowTitles(iWindow(&Fenetre),TITRE_FENETRE,(UBYTE *)-1);
                break;
              case FALSE:
                if(EasyRequest(NULL,&HelpRequester,NULL,INSTRUCTIONS_AIDE)){
                  aide=TRUE;
                  SetWindowTitles(iWindow(&Fenetre),TITRE_AIDE,(UBYTE *)-1);
                }
                break;
            }
          }

          /* Iconfier ? */

           if(Respond( (Interactor*) &BoolGadget14, &event) & CHANGED_STATE){
            if(aide)
              if(!EasyRequest(NULL,&HelpRequester,NULL,ICON_AIDE))
                break;
            rc = ICONIFIED;
            aide = FALSE;
            done = TRUE;
            break;
          }

					/* Modifier préférences */

          if(Respond( (Interactor*) &BoolGadget3, &event) & CHANGED_STATE){
            if(aide)
              if(!EasyRequest(NULL,&HelpRequester,NULL,MODIFIER_AIDE))
                break;
						do_FenetrePrefs();
						break;
					}
      }

    }

    pcgCloseWindow( &Fenetre );
   
  }
  else
    rc = WARN; /* Erreur d'ouverture fenêtre */

  CleanUp( (Object*) &Fenetre );
  CleanUp( (Object*) &OutlineBox1 );
  CleanUp( (Object*) &OutlineBox2 );
  CleanUp( (Object*) &OutlineBox5 );
  CleanUp( (Object*) &OutlineBox7 );
  CleanUp( (Object*) &ListEditor0 );
  CleanUp( (Object*) &CycleGadget6 );
  CleanUp( (Object*) &BoolGadget8 );
  CleanUp( (Object*) &BoolGadget12 );
  CleanUp( (Object*) &BoolGadget13 );
  CleanUp( (Object*) &BoolGadget14 );
	CleanUp( (Object*) &BoolGadget3 );
  return(rc);
}

BOOL do_FenetreNom(char str[]){
  pcgWindow     FenetreII;
  pcg_3DPens    pens;
  BOOL          done,rc;
  IntuiMessage *message, event;
  StringGadget  StringGadget0;
  BoolGadget    BoolGadget1;
  BoolGadget    BoolGadget2;

  pens = StandardPens();

  pcgWindow_Init( &FenetreII,
    W->LeftEdge+160,
    W->TopEdge+66,
    313,53,
    100,50,65535,65535,"Nom de la disquette...",
    REFRESHWINDOW|CLOSEWINDOW,
    SIMPLE_REFRESH | ACTIVATE,
    NULL);

  StringGadget_Init( &StringGadget0,63, 16, 239,25,pens, "Nom : " );
	SetStringValue((Valuator *)&StringGadget0,(LONG)str);
  AddWindowObject( &FenetreII, (GraphicObject*) &StringGadget0 );

  BoolGadget_Init( &BoolGadget1,11, 32, 96, 14,pens, "    Ok" );
  AddWindowObject( &FenetreII, (GraphicObject*) &BoolGadget1 );

  BoolGadget_Init( &BoolGadget2,206, 32, 96, 14,pens, "  Cancel" );
  AddWindowObject( &FenetreII, (GraphicObject*) &BoolGadget2 );

  if(pcgOpenWindow(&FenetreII)){
    Refresh((Interactor *)&FenetreII);

    ActivateNext( (Interactor*) &StringGadget0 );

    done = FALSE;
    while (!done){
      message = WaitForMsg(FenetreII.Window->UserPort);
      event   = *message; /* Make a local copy of the message */
      ReplyMsg((struct Message *)message);

      switch (event.Class){
        case REFRESHWINDOW:
          BeginRefresh( iWindow( &FenetreII ) );
          Refresh((Interactor *)&FenetreII);
          EndRefresh( iWindow( &FenetreII ), TRUE );
          break;

        default:

          /* Gadget Nom : */

          if(Respond( (Interactor*) &StringGadget0, &event ) & (CHANGED_STATE | DEACTIVATED)){
            strcpy(str,StringValue( (Valuator*) &StringGadget0));
            rc = TRUE;
            done = TRUE;
          }

          /* Gadget OK */

          if(Respond( (Interactor*) &BoolGadget1, &event) & CHANGED_STATE){
            strcpy(str,StringValue( (Valuator*) &StringGadget0));
            rc = TRUE;
            done = TRUE;
          }

          if(Respond( (Interactor*) &BoolGadget2, &event) & CHANGED_STATE){
            rc = FALSE;
            done = TRUE;
          }

      }

    }

      pcgCloseWindow( &FenetreII );
  }

  else
     rc = FALSE;

  CleanUp( (Object*) &FenetreII );
  CleanUp( (Object*) &StringGadget0 );
  CleanUp( (Object*) &BoolGadget1 );
  CleanUp( (Object*) &BoolGadget2 );
  return(rc);
}

BOOL do_FenetrePrefs(){
  pcgWindow     FenetrePrefs;
  pcg_3DPens    pens;
  BOOL          done,
								rc;
  IntuiMessage *message, event;
  OutlineBox    OutlineBox0;
  OutlineBox    OutlineBox4;
  OutlineBox    OutlineBox6;
  IntegerGadget IntegerGadget1;
  IntegerGadget IntegerGadget2;
  StringGadget  StringGadget3;
  StringGadget  StringGadget5;
  CheckBox      CheckBox7;
  CheckBox      CheckBox8;
  CheckBox      CheckBox9;
  CheckBox      CheckBox10;
  BoolGadget    BoolGadget11;
  BoolGadget    BoolGadget12;
  BoolGadget    BoolGadget13;

	/* On stocke ici les valeurs à renvoyer par le gadget 'Annuler' */

	int oldmarge,oldsaut;
	BOOL olddate,oldlauto,oldlibre,oldnlq;
	char oldautre[5],oldcodes[50];

  pens = StandardPens();

  pcgWindow_Init(&FenetrePrefs,0,11,384,209,100,50,65535,65535,
    "Edition des préférences",REFRESHWINDOW,
    WINDOWDRAG | WINDOWDEPTH | SIMPLE_REFRESH | ACTIVATE,
    NULL);

  OutlineBox_Init(&OutlineBox0,16,20,350,67,pens," Imprimante ");
  AddWindowObject(&FenetrePrefs,(GraphicObject*)&OutlineBox0);

  OutlineBox_Init(&OutlineBox4,16,92,351,31,pens," Autre Lecteur " );
  AddWindowObject(&FenetrePrefs,(GraphicObject*) &OutlineBox4);

  OutlineBox_Init( &OutlineBox6,16,129,352,50,pens," Options " );
  AddWindowObject( &FenetrePrefs,(GraphicObject*) &OutlineBox6 );

  IntegerGadget_Init(&IntegerGadget1,230,47,48,2,pens,"Marge de gauche : " );
  SetValue((Valuator*)&IntegerGadget1,marge);
  AddWindowObject(&FenetrePrefs,(GraphicObject*) &IntegerGadget1 );

  IntegerGadget_Init( &IntegerGadget2,230,65,48,2,pens,"Saut de page : " );
  SetValue( (Valuator*) &IntegerGadget2,saut);
  AddWindowObject(&FenetrePrefs,(GraphicObject*) &IntegerGadget2 );

  StringGadget_Init( &StringGadget3,230,29,112,50,pens,"Code de configuration : " );
	SetStringValue((Valuator *)&StringGadget3,(LONG)codes);
  AddWindowObject( &FenetrePrefs,(GraphicObject*) &StringGadget3 );

  StringGadget_Init( &StringGadget5,152,102,112,10,pens,"Nom : " );
	SetStringValue((Valuator *)&StringGadget5,(LONG)autre);
  AddWindowObject( &FenetrePrefs,(GraphicObject*) &StringGadget5 );

	if(date)
	  CheckBox_Init( &CheckBox7,33,139,pens,"Date",TRUE );
	else
	  CheckBox_Init( &CheckBox7,33,139,pens,"Date",FALSE);
  AddWindowObject( &FenetrePrefs,(GraphicObject*) &CheckBox7 );

	if(libre)
	  CheckBox_Init( &CheckBox8,33,157,pens, "Espace libre",TRUE );
	else
	  CheckBox_Init( &CheckBox8,33,157,pens, "Espace libre",FALSE);
  AddWindowObject( &FenetrePrefs, (GraphicObject*) &CheckBox8 );

	if(nlq)
	  CheckBox_Init( &CheckBox9,213, 139,pens, "Impression NLQ",TRUE );
	else
	  CheckBox_Init( &CheckBox9,213, 139,pens, "Impression NLQ",FALSE );
  AddWindowObject( &FenetrePrefs, (GraphicObject*) &CheckBox9 );

	if(lauto)
	  CheckBox_Init( &CheckBox10,214, 157,pens, "Lecture auto.",TRUE );
	else
	  CheckBox_Init( &CheckBox10,214, 157,pens, "Lecture auto.",FALSE);
  AddWindowObject( &FenetrePrefs, (GraphicObject*) &CheckBox10 );

  BoolGadget_Init( &BoolGadget11,16, 184, 96, 14,pens, " Utiliser" );
  AddWindowObject( &FenetrePrefs, (GraphicObject*) &BoolGadget11 );

  BoolGadget_Init( &BoolGadget12,273, 184, 96, 14,pens, " Ignorer" );
  AddWindowObject( &FenetrePrefs, (GraphicObject*) &BoolGadget12 );

  BoolGadget_Init( &BoolGadget13,143, 184, 96, 14,pens, "  Sauver" );
  AddWindowObject( &FenetrePrefs, (GraphicObject*) &BoolGadget13 );

	/* On sauvegarde les valeurs actuelles */

	oldmarge 	= marge;
	oldsaut		= saut;
	oldnlq		= nlq;
	olddate		=	date;
	oldlibre =	libre;
	oldlauto	=	lauto;
	strcpy(oldcodes,codes);
	strcpy(oldautre,autre);

  if(pcgOpenWindow(&FenetrePrefs)){
    Refresh((Interactor *)&FenetrePrefs);

    done = FALSE;
    while (!done){

      message = WaitForMsg(FenetrePrefs.Window->UserPort);
      event   = *message; /* Make a local copy of the message */
      ReplyMsg((struct Message *)message);

      switch(event.Class){

        case REFRESHWINDOW:
          BeginRefresh( iWindow( &FenetrePrefs ) );
          Refresh((Interactor *)&FenetrePrefs);
          EndRefresh( iWindow( &FenetrePrefs ), TRUE );
          break;

        default:

					/* Marge de gauche */

          if(Respond( (Interactor*) &IntegerGadget1, &event) & (CHANGED_STATE | DEACTIVATED)){
            if(aide)
              if(!EasyRequest(NULL,&HelpRequester,NULL,MARGE_AIDE))
                break;
            marge = (int)Value((Valuator*)&IntegerGadget1);
						if(marge < 0){
							DisplayBeep(NULL);
	            ActivateNext((Interactor*)&IntegerGadget1);
	          }
            ActivateNext( (Interactor*) &IntegerGadget2 );
          }

					/* Saut de page */

          if(Respond( (Interactor*) &IntegerGadget2, &event) & (CHANGED_STATE | DEACTIVATED)){
            if(aide)
              if(!EasyRequest(NULL,&HelpRequester,NULL,SAUT_AIDE))
                break;
            saut = (int)Value((Valuator*)&IntegerGadget2);
						if(saut < 0){
							DisplayBeep(NULL);
	            ActivateNext((Interactor*)&IntegerGadget2);
	          }
            ActivateNext( (Interactor*) &StringGadget5 );
          }

					/* Code de configuration */

          if(Respond( (Interactor*) &StringGadget3, &event ) & (CHANGED_STATE | DEACTIVATED)){
            if(aide)
              if(!EasyRequest(NULL,&HelpRequester,NULL,CODE_AIDE))
                break;
            strcpy(codes,StringValue((Valuator*)&StringGadget3));
            ActivateNext( (Interactor*) &IntegerGadget1 );
          }

					/* Autre nom */

          if(Respond( (Interactor*) &StringGadget5, &event ) & (CHANGED_STATE | DEACTIVATED)){
            if(aide)
              if(!EasyRequest(NULL,&HelpRequester,NULL,NOM_AIDE))
                break;
            strcpy(autre,StringValue((Valuator*)&StringGadget5));
            ActivateNext( (Interactor*) &StringGadget3 );
          }

					/* Date */

          if(Respond( (Interactor*) &CheckBox7, &event) & CHANGED_STATE){
            if(aide)
              if(!EasyRequest(NULL,&HelpRequester,NULL,DATE_AIDE))
                break;
            if(Value( (Valuator*) &CheckBox7))
              date = TRUE;
            else
              date = FALSE;
          }

					/* Espace libre */

          if(Respond( (Interactor*) &CheckBox8, &event) & CHANGED_STATE){
            if(aide)
              if(!EasyRequest(NULL,&HelpRequester,NULL,ESPACE_AIDE))
                break;
            if(Value( (Valuator*) &CheckBox8))
              libre = TRUE;
            else
              libre = FALSE;
					}

					/* Impression NLQ */

          if(Respond( (Interactor*) &CheckBox9, &event) & CHANGED_STATE){
            if(aide)
              if(!EasyRequest(NULL,&HelpRequester,NULL,NLQ_AIDE))
                break;
            if(Value( (Valuator*) &CheckBox9))
              nlq = TRUE;
            else
              nlq = FALSE;
          }

					/* Lecture automatique */

          if(Respond( (Interactor*) &CheckBox10, &event) & CHANGED_STATE){
            if(aide)
              if(!EasyRequest(NULL,&HelpRequester,NULL,LECTURE_AIDE))
                break;
            if(Value( (Valuator*) &CheckBox10))
              lauto = TRUE;
            else
              lauto = FALSE;
          }

					/* Utiliser */

          if(Respond( (Interactor*) &BoolGadget11, &event) & CHANGED_STATE){
            if(aide)
              if(!EasyRequest(NULL,&HelpRequester,NULL,UTILISER_AIDE))
                break;
	          done = rc = TRUE;
	          break;
          }

					/*  Ignorer */

          if(Respond( (Interactor*) &BoolGadget12, &event) & CHANGED_STATE){
            if(aide)
              if(!EasyRequest(NULL,&HelpRequester,NULL,IGNORER_AIDE))
                break;
						marge 	= oldmarge;
						saut		= oldsaut;
						nlq			= oldnlq;
						date		=	olddate;
						libre 	=	oldlibre;
						lauto		=	oldlauto;
						strcpy(codes,oldcodes);
						strcpy(autre,oldautre);
            done = rc = TRUE;
          }

 					/* Sauver */

          if(Respond( (Interactor*) &BoolGadget13, &event) & CHANGED_STATE){
            if(aide)
              if(!EasyRequest(NULL,&HelpRequester,NULL,SAUVER_AIDE))
                break;
            EcrirePrefs();
	          done = rc = TRUE;
	          break;
          }

      }

    }

    pcgCloseWindow( &FenetrePrefs );
  }
  else{ 
    ; /*** YOUR ERROR HANDLING HERE ***/
  }

  CleanUp( (Object*) &FenetrePrefs );
  CleanUp( (Object*) &OutlineBox0 );
  CleanUp( (Object*) &OutlineBox4 );
  CleanUp( (Object*) &OutlineBox6 );
  CleanUp( (Object*) &IntegerGadget1 );
  CleanUp( (Object*) &IntegerGadget2 );
  CleanUp( (Object*) &StringGadget3 );
  CleanUp( (Object*) &StringGadget5 );
  CleanUp( (Object*) &CheckBox7 );
  CleanUp( (Object*) &CheckBox8 );
  CleanUp( (Object*) &CheckBox9 );
  CleanUp( (Object*) &CheckBox10 );
  CleanUp( (Object*) &BoolGadget11 );
  CleanUp( (Object*) &BoolGadget12 );
  CleanUp( (Object*) &BoolGadget13 );
	return(rc);
}

/* -----------------------------------------------------------------------
 * char *DiskName(char *name)
 * Renvoie le nom du device spécifié.
 *
 * Entrée : char * (DHx: - DFx: - ...)
 * Sortie : char * (Le nom)
 *
 * v1.00 - 27 Mar 1993 - 18:12 - Création
 *
 * -----------------------------------------------------------------------
 */

char *DiskName(char *name){
  struct FileLock *lock;
  struct FileInfoBlock *FIBlock;
  if(lock=(struct FileLock *)Lock(name,ACCESS_READ)) {
    if(FIBlock = (struct FileInfoBlock *)AllocMem(sizeof(struct FileInfoBlock),MEMF_CLEAR))
      if(Examine((BPTR)lock,(struct FileInfoBlock *)FIBlock)){
        UnLock((BPTR)lock);
        return(FIBlock->fib_FileName);
      }
    UnLock((BPTR)lock);
  }
  return((char *)"-1"); 
}

/* -----------------------------------------------------------------------
 * char *Today()
 * Renvoie la date du jour s/forme d'une chaîne 'JJ-MMMMMMMM-AAAA'
 *
 * Entrée : -
 * Sortie : char * (Date du jour)
 *
 * v1.00 - 27 Mar 1993 - 18:12 - Création
 *
 * -----------------------------------------------------------------------
 */

char *Today(){
  short JourParMois[12]={
   31,28,31,30,31,30,31,31,30,31,30,31
  };
  char *Mois[12]={
     (STRPTR)"Janvier",
     (STRPTR)"Février",
     (STRPTR)"Mars",
     (STRPTR)"Avril",
     (STRPTR)"Mai",
     (STRPTR)"Juin",
     (STRPTR)"Juillet",
     (STRPTR)"Août",
     (STRPTR)"Septembre",
     (STRPTR)"Octobre",
     (STRPTR)"Novembre",
     (STRPTR)"Décembre"
  };
  char Date[25];
  struct DateStamp Maintenant;
  SHORT i,k,m,a,t;
  DateStamp(&Maintenant);
  t = Maintenant.ds_Days;
  i = t%7;
  for(a=1978;;a++){
    k=(a%4==0)?366:365;
    if(t<k)
      break;
    else
      t-=k;
  }
  JourParMois[1] = k-337;
  for(m=0;t>JourParMois[m];m++)
    t-=JourParMois[m];
  sprintf(Date,"%d %s %d",t+1,Mois[m],a);
  return((char *)Date);
}

/* -----------------------------------------------------------------------
 * long FreeSpace(char *Unite)
 * Renvoie le nombre de blocs libre sur le périphérique spécifié.
 *
 * Entrée : char * (DFx: - DHx: - ...)
 * Sortie : long   (Nombre de blocs libres)
 *
 * v1.00 - 27 Mar 1993 - 18:12 - Création
 *
 * -----------------------------------------------------------------------
 */

long FreeSpace(char *Unite){
  struct InfoData *InfoData;
  BPTR lock;
  long Blocks;
  InfoData = AllocMem(sizeof(struct InfoData),MEMF_CLEAR);
  if(!(lock = Lock (Unite,ACCESS_READ)))
     return(-1);
  if(!Info(lock,InfoData)){
      FreeMem(InfoData,sizeof(struct InfoData));
    return (-1);
  }
  UnLock(lock);
  Blocks = (InfoData->id_NumBlocks) - (InfoData->id_NumBlocksUsed); 
   FreeMem(InfoData,sizeof(struct InfoData));
  return(Blocks);
}

/* -----------------------------------------------------------------------
 * BOOL LirePrefs()
 * Lit les préférences depuis ENV:Eti.prefs.
 *
 * Entrée : -
 * Sortie : TRUE/FALSE
 *
 * v1.00 - 27 Mar 1993 - 18:12 - Création
 *
 * -----------------------------------------------------------------------
 */

BOOL LirePrefs(){
	FILE *prefs;
	char data[50];
	if(!(prefs = fopen(PREFS,"r"))){
    EasyRequest(NULL,&ErrorRequester,NULL,NO_PREFS);
		return(FALSE);
	}
	fscanf(prefs,"%s\n",&data);
	if(strcmp(data,"ETIPREFS")){
		EasyRequest(NULL,&ErrorRequester,NULL,data /*BAD_FILE*/);
		fclose(prefs);
		return(FALSE);
	}
	fscanf(prefs,"%s\n",&codes);
	fscanf(prefs,"%s\n",&data);marge = atoi(data);
	fscanf(prefs,"%s\n",&data);saut = atoi(data);
	fscanf(prefs,"%s\n",&autre);
	fscanf(prefs,"%s\n",&data);
	if(strcmp(data,"TRUE"))
		date = FALSE;
	else
		date = TRUE;
	fscanf(prefs,"%s\n",&data);
	if(strcmp(data,"TRUE"))
		libre = FALSE;
	else
		libre = TRUE;
	fscanf(prefs,"%s\n",&data);
	if(strcmp(data,"TRUE"))
		nlq = FALSE;
	else
		nlq = TRUE;
	fscanf(prefs,"%s\n",&data);
	if(strcmp(data,"TRUE"))
		lauto = FALSE;
	else
		lauto = TRUE;
	fclose(prefs);
	return(TRUE);
}

/* -----------------------------------------------------------------------
 * BOOL EcrirePrefs()
 * Sauvegarde les préférences dans ENV:Eti.prefs puis dans ENVARC:
 * => Absolument améliorer cette #?! de routine!
 *
 * Entrée : -
 * Sortie : TRUE/FALSE
 *
 * v1.00 - 27 Mar 1993 - 18:12 - Création
 *
 * -----------------------------------------------------------------------
 */

BOOL EcrirePrefs(){
	int i;
	FILE *prefs;
  for(i=0;i<2;i++){
		switch(i){
			case 0:
				if(!(prefs = fopen(PREFS,"w"))){
			    EasyRequest(NULL,&ErrorRequester,NULL,NO_PREFS2);
					return(FALSE);
				}
				break;
			case 1:
				if(!(prefs = fopen(PREFS_BIS,"w"))){
			    EasyRequest(NULL,&ErrorRequester,NULL,NO_PREFS2);
					return(FALSE);
				}
				break;
		}
		fprintf(prefs,"%s\n","ETIPREFS");
		fprintf(prefs,"%s\n",codes);
		fprintf(prefs,"%d\n",marge);
		fprintf(prefs,"%d\n",saut);
		fprintf(prefs,"%s\n",autre);
	  if(date)
			fprintf(prefs,"%s\n","TRUE");
		else
			fprintf(prefs,"%s\n","FALSE");
	  if(libre)
			fprintf(prefs,"%s\n","TRUE");
		else
			fprintf(prefs,"%s\n","FALSE");
	  if(nlq)
			fprintf(prefs,"%s\n","TRUE");
		else
			fprintf(prefs,"%s\n","FALSE");
	  if(lauto)
			fprintf(prefs,"%s\n","TRUE");
		else
			fprintf(prefs,"%s\n","FALSE");
		fclose(prefs);
	}
	return(TRUE);
}

/* -----------------------------------------------------------------------
 * VOID Motor()
 * Mise en marche et arrêt du moteur du drive sélectionné
 *
 * Entrée : -
 * Sortie : -
 *
 * v1.00 - 08 Apr 1993 - 19:40 - Création
 * v1.01 - 09 Apr 1993 - 16:05 - Fusion MotorOn/MotorOff
 * -----------------------------------------------------------------------
 */

VOID Motor(int mode){
  DiskReq->iotd_Req.io_Length=mode;
  DiskReq->iotd_Req.io_Command=TD_MOTOR;
  DoIO((struct IORequest *)DiskReq);
}

/* -----------------------------------------------------------------------
 * int ReadTrack()
 * Lit le bootblock de la disquette et renvoie un code en fonction du
 * FileSystem détecté.
 *
 * Entrée : -
 * Sortie : 0 - OFS
 *          1 - FFS
 *          2 - OFS-INT
 *          3 - FFS-INT
 *          4 - DCFS-OFS
 *          5 - DCFS-FFS
 *          6 - Autre
 *
 * v1.00 - 08 Apr 1993 - 19:39 - Création
 *
 * -----------------------------------------------------------------------
 */

int ReadTrack(){
  DiskReq->iotd_Req.io_Length=1024;
  DiskReq->iotd_Req.io_Data=(APTR)Buffer;
  DiskReq->iotd_Req.io_Command=CMD_READ;
  DiskReq->iotd_Req.io_Offset=0;
  DoIO((struct IORequest *)DiskReq);
  if(DiskReq->iotd_Req.io_Error)
    return(6);
  point = (unsigned int *)Buffer;
  if(point[0]==ID_OFS) return(0);
  if(point[0]==ID_FFS) return(1);
  if(point[0]==ID_OFSINT) return(2);
  if(point[0]==ID_FFSINT) return(3);
  if(point[0]==ID_DCFSOFS) return(4);
  if(point[0]==ID_DCFSFFS) return(5);
  return(6);
}

/* ---- Eof -------------------------------------------------------------
               ___
              ////
			 ___   ////
       \\\\ ////
        \\XXX//   ONLY AMIGA MAKES IT POSSIBLE...

---------------------------------------------------------------------- */