/*
 * Jauge.c :
 * ---------
 * Auteur         : Xavier Mertens
 * Version        : 1 
 * Révision       : 03
 * Création       : 17 Dec 1992 - 10:04
 * Modification   : 24 Dec 1992 - 16:57
 * Langage        : SAS/C V6.00
 * Compatibilité  : 2.x - 3.0
 * Description    : Jauge pour la gestion de la mémoire CHIP & FAST avec  
 *                  alarme en cas de minimum dépassé.
 */

/* L'interface a été générée par Precognition version 1.00 par Lee Willis */

#include <exec/types.h>
#include <exec/execbase.h>
#include <exec/memory.h>
#include <Precognition/Precognition.h> /* Include fournies par le programme */
#include <intuition/intuitionbase.h>
#include <graphics/gfxbase.h>
#include <devices/timer.h>
#include <libraries/dosextens.h>
#include <libraries/dos.h>
#include <workbench/workbench.h>
#include <workbench/startup.h>

#include <proto/graphics.h>
#include <proto/intuition.h>
#include <proto/dos.h>
#include <proto/wb.h>

int CXBRK(void) { return(0); }
int chkabort(void) { return(0); }

#define OS_VERSION 37   /* Version minimum des bibliothèques. */
#define WARN       5    /* Code renvoyé au Shell en cas d'erreur */
#define WAIT_TIME  1    /* Delais d'attente pour le timer.device */
#define MINIMUM    100  /* Mémoire minimum */
#define LOWPRI     -10  /* Priorité minimum */
#define HIGHPRI    20   /* ........ maximum */

struct IntuitionBase *IntuitionBase;
struct GfxBase       *GfxBase;
struct MsgPort       *DevicePort;
struct IOStdReq      *DeviceMsg;

struct EasyStruct Requete = {
  sizeof (struct EasyStruct),
  0,
  "Informations...",
  "Jauge v1.03 écrit par Xavier Mertens (24.12.92)\n            Chip: %5ld Fast: %5ld\n                 Minimum: %5ld",
  "Ok"
};

extern struct ExecBase *SysBase;
extern struct WBStartup *WBenchMsg;

struct IntuitionBase  *IntuitionBase;
struct GfxBase        *GfxBase;
struct Task           *MyTask;
struct timerequest    Time_Req;
struct MsgPort        *Timer_Port = NULL;
struct Library        *IconBase;
struct WBArg          *Arg;
struct DiskObject     *DiskLock;

VOID do_JaugeWindow(VOID);
VOID CloseAll(int returncode);

static char *VERSION = " $VER:1.03(24.12.92)"; /* Pour la commande VERSION */

int i,
    PosX = 590,
    PosY = 131,
    Delais = WAIT_TIME,
    Minimum = MINIMUM;

__stdargs __main(char *argv){

  LONG OldDir;

  char **ToolArray;
  char *Value;

/* Fixation d'une priorité faible pour ne pas gêner le système */

  MyTask=SysBase->ThisTask; 
  SetTaskPri(MyTask,LOWPRI);

/* Lecture des tooltypes si chargé depuis le Workbench */

/* 
    4 tooltypes : DELAY   -> Délais entre chaque rafraichissement des jauges.
                  MINIMUM -> Mémoire minimum pour l'alerte.
                  X,Y     -> Coin supérieur gauche de la fenêtre.
*/

  if(!(((struct Process *)SysBase->ThisTask)->pr_CLI)){
    if(!(IconBase = (struct Library *)OpenLibrary("icon.library",OS_VERSION)))
      CloseAll(WARN);
    for(i=0,Arg=WBenchMsg->sm_ArgList;i<WBenchMsg->sm_NumArgs;i++,Arg++){
    OldDir=CurrentDir(Arg->wa_Lock);
      if(DiskLock=GetDiskObject(Arg->wa_Name)){
        ToolArray=DiskLock->do_ToolTypes;
        if(Value=FindToolType(ToolArray,"DELAY"))
          Delais=atoi(Value);
        if(Value=FindToolType(ToolArray,"MINIMUM"))
          Minimum=atoi(Value);
        if(Value=FindToolType(ToolArray,"X"))
          PosX=atoi(Value);
        if(Value=FindToolType(ToolArray,"Y"))
          PosY=atoi(Value);
        FreeDiskObject(DiskLock);
      }
      CurrentDir(OldDir);
    }
    CloseLibrary(IconBase);
  }

/* Vérification des valeurs données par l'utilisateur,on ne sait jamais!!! */

  if(Delais < WAIT_TIME)
    Delais=WAIT_TIME;
  if(Minimum < MINIMUM)
    Minimum = MINIMUM;
  if((PosX < 0 ) || (PosX > 590))
    PosX = 590;
  if((PosY < 0 ) || (PosY > 131))
    PosY = 131;

/* Ouverture de tout le nécessaire */

  if(!(IntuitionBase = (struct IntuitionBase *)
          OpenLibrary("intuition.library",OS_VERSION))      ||
    !(GfxBase = (struct GfxBase *)
          OpenLibrary("graphics.library",OS_VERSION))       ||
    !(Timer_Port = CreatePort("JaugeTimerPort", 0))         ||
     (OpenDevice(TIMERNAME,UNIT_VBLANK,(struct IORequest *)&Time_Req,0)))
    CloseAll(WARN);

/* Initialisation du timer */

  Time_Req.tr_node.io_Message.mn_ReplyPort = Timer_Port;
  Time_Req.tr_node.io_Command = TR_ADDREQUEST;
  Time_Req.tr_node.io_Flags = 0;
  Time_Req.tr_node.io_Error = 0;

/* Routine principale */

  do_JaugeWindow();

/* Au revoir... */

  CloseAll(NULL);
}

/* Routine sans commentaire... */

VOID CloseAll(int returncode){
  AbortIO((struct IORequest *)&Time_Req . tr_node);
  if(Time_Req.tr_node.io_Message.mn_ReplyPort)
                    CloseDevice(&Time_Req);
  if(Timer_Port)    DeletePort(Timer_Port);
  if(IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
  if(GfxBase)       CloseLibrary((struct Library *)GfxBase);
  __exit(returncode);
}

/* Routine principale */

VOID do_JaugeWindow(){
  pcgWindow     JaugeWindow;
  pcg_3DPens    pens;
  BOOL          done;
  IntuiMessage *message, event;
  BoolGadget    InfoGadget;
  VSlider    ChipGadget;
  VSlider    FastGadget;

  UBYTE *registre = 0xBFE001; /* Adresse du registre de la LED */
  UBYTE valeur = *registre;

  pens = StandardPens();

  pcgWindow_Init( &JaugeWindow,
    PosX,PosY,50,125,0,0,0,0,"",REFRESHWINDOW | CLOSEWINDOW,
    WINDOWDRAG | WINDOWDEPTH | WINDOWCLOSE | SIMPLE_REFRESH | ACTIVATE,
    NULL);

  BoolGadget_Init( &InfoGadget,8,113,35,10,pens," ?" );
  AddWindowObject( &JaugeWindow, (GraphicObject*) &InfoGadget );

  VSlider_Init( &ChipGadget,7,13,15,90,pens,"C" );
  SetKnobSize( (Positioner*) &ChipGadget,MAXBODY/10 );
  SetValue( (Valuator*) &ChipGadget, 0 );
  AddWindowObject( &JaugeWindow, (GraphicObject*) &ChipGadget );

  VSlider_Init( &FastGadget,27,13,15,90,pens, "F" );
  SetKnobSize( (Positioner*) &FastGadget,MAXBODY/10 );
  SetValue( (Valuator*) &FastGadget,0 );
  AddWindowObject( &JaugeWindow, (GraphicObject*) &FastGadget );

  if(pcgOpenWindow(&JaugeWindow)){
    Refresh(&JaugeWindow);

    done = FALSE;
    while(!done){ /* Main event loop */

/* Calcul de la taille du curseur en fonction de la mémoire CHIP & FAST */

      SetKnobSize( (Positioner*) &ChipGadget,((MAXBODY*(float)(AvailMem(MEMF_CHIP)))/(float)AvailMem(MEMF_CHIP|MEMF_TOTAL)));
      SetValue( (Valuator*) &ChipGadget,MAXBODY );

/* Test s'il existe de la FAST (on ne sait jamais) ? */

      if(AvailMem(MEMF_FAST|MEMF_TOTAL) != 0)
        SetKnobSize( (Positioner*) &FastGadget,((MAXBODY*(float)(AvailMem(MEMF_FAST)))/(float)AvailMem(MEMF_FAST|MEMF_TOTAL)));
      else
        SetKnobSize( (Positioner*) &FastGadget,0);
      SetValue( (Valuator*) &FastGadget,MAXBODY );

/* Si la mémoire minimum est dépassée,alerte!!! c-à-d clignotement de la LED */

      if(Minimum > ((AvailMem(MEMF_CHIP)>>10)+(AvailMem(MEMF_FAST)>>10))){
          SetTaskPri(MyTask,HIGHPRI);
      for(i=0;i<5;i++){
          if(valeur & 2)
            *registre = valeur & 253;
          else
            *registre = valeur | 2;
          valeur = *registre;
          Delay(50);
        }
        SetTaskPri(MyTask,LOWPRI);
      }
      Time_Req.tr_time.tv_secs  = Delais;
      Time_Req.tr_time.tv_micro = 0;
      SendIO((struct IORequest *) &Time_Req.tr_node);

/* Attente d'un message : Timer ou Fenêtre ? */

      Wait(1<<JaugeWindow.Window->UserPort->mp_SigBit |
           1<<Timer_Port->mp_SigBit);

/* Si c'est de la fenêtre */

      while(message = (struct IntuiMessage *)GetMsg(JaugeWindow.Window->UserPort)){
        event   = *message;
        ReplyMsg((struct Message *)message);
        switch (event.Class){
          case CLOSEWINDOW:
            done = TRUE;
            break;
          case REFRESHWINDOW:
            BeginRefresh( iWindow( &JaugeWindow ) );
            Refresh((Interactor *)&JaugeWindow );
            EndRefresh( iWindow( &JaugeWindow ), TRUE );
            break;
          default:
            if(Respond( (Interactor*) &InfoGadget, &event) & CHANGED_STATE){
              EasyRequest(NULL,&Requete,NULL,AvailMem(MEMF_CHIP)>>10,AvailMem(MEMF_FAST)>>10,Minimum);
              break;
            }
        }
      }

/* Sinon du timer */

      GetMsg(Timer_Port);
    }
    pcgCloseWindow( &JaugeWindow );
  }
  else{
    CloseAll(WARN);
  }
  CleanUp( (Object* ) &JaugeWindow );
  CleanUp( (Object* ) &InfoGadget );
  CleanUp( (Object* ) &ChipGadget );
  CleanUp( (Object* ) &FastGadget );
}

/* Eof */