;
;        ____     ___        ___     ___ ___ ___ ___ ____      ___ ___ ___
;         /  /__//_         /__ /  //_ //__ /  //_    /  / / //_ //__//_  
;        /  /  //__        ___//__//__/___//__//     /  /_/_//  //  \/__  
;
;-----------------------------------------------------------------------------
;   - FOR ABO'S CONTACT US AT:   BP:28 1170 WATERMAEL-BOITSFORT 1 BELGIUM!!...
;
;-----------------------------------------------------------------------------
;                           - DON'T SEND ANY DISKS -
;
;-----------------------------------------------------------------------------
;
;
;
;                       THE LEGENDARY >> SUBSOFTWARE << IN 87/88/89/90/91!!...
;                       ------------------------------------------------------
;
;
/*--------------------------------------------------------------*/
/*   Palette permettant de changer les couleurs du Workbench    */
/*                                                              */
/*   Exemple de programmation des gadgets sous intuition        */
/*         - Gadgets booléen                                    */
/*         - Gadgets proportionnels                             */
/*         - Gestion des couleurs                               */
/*                                    P. AMIABLE 1991           */
/*--------------------------------------------------------------*/

/*--------------------------------------------------------------*/
/*   Quelques includes utiles......                             */
/*--------------------------------------------------------------*/
#include <exec/types.h>
#include <intuition/intuition.h>
#include <stdio.h>

/*--------------------------------------------------------------*/
/*   Les defines maintenants.....                               */
/*--------------------------------------------------------------*/
#define INTUITION_REV 0L /* Version d'Intuition (la dernière)   */
#define GFX_REV       0L /* Version de Graphics (la dernière)   */
#define CSIZE         4  /* Nombre de couleurs à traiter        */

/* Pré-déclaration pour les gadgets */
void traite_reset(), traite_cancel();
void traite_rouge(), traite_vert(), traite_bleu();
void restorecol();

/* -------------------------------------------------------------*/
/*     Définition des variables externes                        */
/* -------------------------------------------------------------*/
SHORT cadre1[] = {
        0,0,
        61,0,
        61,12,
        0,12,
        0,0
};

struct Border bordure1 = {
        -1,-1,          /* position*/
        3,0,JAM1,       /* couleurs et mode de tracé */
        5,              /* nombre de vecteurs */
        cadre1,         /* tableau des vecteurs */
        NULL            /* bordure suivante dans la liste */
};

struct IntuiText texte1 = {
        3,0,JAM2,  /* couleurs et mode de tracé */
        10,2,      /* position */
        NULL,      /* fonte (NULL pour la police par défaut) */
        "RESET",   /* texte */
        NULL       /* structure IntuiText suivante dans la liste */
};

struct Gadget reset = {
        NULL,        /* adresse du gadget suivant  */
        124,69,      /* position */
        60,11,       /* taille de la boite de sélection */
        NULL,        /* Flags associés au gadget */
        RELVERIFY+GADGIMMEDIATE, /* Flags d'activation */
        BOOLGADGET,  /* type du gadget */
        (APTR)&bordure1, /* bordure ou image associée au gadget */
        NULL,        /* image alternée en cas de sélection */
        &texte1,     /* première structure IntuiText associée */
        NULL,        /* mot long d'exclusion mutuelle */
        NULL,        /* structure SpecialInfo */
        NULL,        /* identificateur du gadget */
        (APTR)traite_reset /* données utlisateur */
};

SHORT cadre2[] = {
        0,0,
        61,0,
        61,12,
        0,12,
        0,0
};
struct Border bordure2 = {
        -1,-1,        
        3,0,JAM1,
        5,        
        cadre2,        
        NULL        
};

struct IntuiText texte2 = {
        3,0,JAM2,
        6,2,        
        NULL,        
        "CANCEL",
        NULL        
};

struct Gadget cancel = {
        &reset,        
        125,85,        
        60,11,        
        NULL,        
        RELVERIFY+GADGIMMEDIATE,
        BOOLGADGET,        
        (APTR)&bordure2,
        NULL,        
        &texte2,
        NULL,        
        NULL,        
        NULL,        
        (APTR)traite_cancel        
};

struct PropInfo bleuinfo = {
        AUTOKNOB+FREEVERT, /* flags liés à la structure PropInfo */
        -1,0,              /* valeurs du potentiomètre */
        -1,0x1000,         /* incrément */
};

struct Image Image1 = {
        0,12,          /* position */
        12,4,          /* largeur et hauteur de l'image */
        0,             /* nombre de bitplanes */
        NULL,          /* structure ImageData */
        0x0000,0x0000, /* PlanePick et PlaneOnOff */
        NULL           /* structure Image suivante */
};

struct IntuiText texte3 = {
        3,0,JAM2,        
        7,-8,        
        NULL,        
        "B",        
        NULL        
};

struct Gadget bleu = {
        &cancel,
        90,20,        
        20,64,        
        NULL,        
        RELVERIFY|GADGIMMEDIATE,        
        PROPGADGET,        
        (APTR)&Image1,        
        NULL,
        &texte3,
        NULL,        
        (APTR)&bleuinfo,        
        NULL,
        (APTR)traite_bleu        
};

struct PropInfo vertinfo = {
        AUTOKNOB+FREEVERT,        
        -1,0,        
        -1,0x1000,
};

struct Image Image2 = {
        0,7,        
        12,4,        
        0,        
        NULL,        
        0x0000,0x0000,        
        NULL        
};

struct IntuiText texte4 = {
        3,0,JAM2,
        6,-8,        
        NULL,        
        "V",        
        NULL        
};

struct Gadget vert = {
        &bleu,        
        57,20,        
        20,64,        
        NULL,        
        RELVERIFY|GADGIMMEDIATE,
        PROPGADGET,        
        (APTR)&Image2,
        NULL,        
        &texte4,
        NULL,        
        (APTR)&vertinfo,        
        NULL,        
        (APTR)traite_vert        
};

struct PropInfo rougeinfo = {
        AUTOKNOB+FREEVERT,
        -1,0,        
        -1,0x1000,
};

struct Image Image3 = {
        0,7,        
        12,4,        
        0,        
        NULL,        
        0x0000,0x0000,
        NULL        
};

struct IntuiText texte5 = {
        3,0,JAM2,        
        7,-8,        
        NULL,        
        "R",        
        NULL        
};

struct Gadget rouge = {
        &vert,        
        25,20,        
        20,64,        
        NULL,        
        RELVERIFY|GADGIMMEDIATE,        
        PROPGADGET,        
        (APTR)&Image3,        
        NULL,        
        &texte5,        
        NULL,        
        (APTR)&rougeinfo,
        NULL,        
        (APTR)traite_rouge
};

struct IntuiText texte8 = {
        3,0,JAM2,        
        94,86,        
        NULL,        
        "00",        
        NULL        
};

struct IntuiText texte7 = {
        3,0,JAM2,
        60,86,        
        NULL,        
        "00",        
        &texte8        
};

struct IntuiText texte6 = {
        3,0,JAM2,
        28,86,        
        NULL,        
        "00",        
        &texte7        
};


struct NewWindow nouvfenetre = {
        100,50,          /* position */ 
        200,100,         /* largeur et hauteur */
        0,1,             /* couleurs */
        MOUSEBUTTONS+GADGETDOWN+GADGETUP+
           CLOSEWINDOW+MOUSEMOVE,  /* flags IDCMP */
        WINDOWDRAG+WINDOWDEPTH+WINDOWCLOSE+
           ACTIVATE+NOCAREREFRESH, /* flags */
        &rouge,          /* premier gadget */
        NULL,            /* CHECKMARK personnelle */
        "Palette V 1.0", /* titre de la fenêtre */
        NULL,            /* pointeur sur un custom screen */
        NULL,            /* bitmap personnelle */
        200,100,         /* largeur et hauteur mini  */
        -1,-1,           /* largeur et hauteur maxi */
        WBENCHSCREEN     /* type d'écran associé */
};

 
char *bouton_gauche = (char *) 0xbfe001;
USHORT sauvecol[CSIZE];     /* table de sauvegarde des couleurs */
struct IntuitionBase *IntuitionBase;
struct GfxBase  *GfxBase;
struct  Window  *fenetre = NULL;
struct  RastPort *rastport = NULL;
struct ViewPort *viewport;
int courant = 0; 
UWORD ROUGE,VERT,BLEU; /* composante de chaque couleur */

/* --------------------------------------------------------------*/
/*         Programme principal                                   */
/* --------------------------------------------------------------*/
void _main()
{
struct IntuiMessage *message;
long GetMsg();
ULONG classemessage;
void init(), ouvrefenetre(), referme();
int fin=0, xmouse, ymouse;

  init();
  ouvrefenetre();
    while(!fin)
      {
       Wait(1L << fenetre->UserPort->mp_SigBit);
       while(message=(struct IntuiMessage *)GetMsg(fenetre->UserPort))
         {
          classemessage = message->Class; /* on recupere la classe */
          switch(classemessage) {

            case GADGETDOWN:
            /* On appelle la fonction liée au gadget activé */
             (*((void(*)())((struct Gadget *)message->IAddress)->UserData))();
              break;

            case CLOSEWINDOW: /* on a fermé la fenêtre */
              fin = 1;
              break;

            case MOUSEBUTTONS: /* bouton de la souris */
              xmouse = message->MouseX;
              ymouse = message->MouseY;
              if((xmouse > 120 && xmouse < 151) && (ymouse > 20 && ymouse < 36))
                courant = 0;
              if((xmouse > 150 && xmouse < 183) && (ymouse > 20 && ymouse < 36))
                courant = 1;
              if((xmouse > 120 && xmouse < 151) && (ymouse > 35 && ymouse < 53))
                courant = 2;
              if((xmouse > 150 && xmouse < 183) && (ymouse > 35 && ymouse < 53))
                courant = 3;
                
              restorecol();

              break;

            default: break;
          }
          ReplyMsg((struct Message *)message); /* libere le message */
        }
     }
   referme(); /* au revoir */
}

/* --------------------------------------------------------------*/
/*  Init() Ouvre la bibliothèque                                 */
/* --------------------------------------------------------------*/
 void init()
  {
   char *OpenLibrary();

   IntuitionBase = (struct IntuitionBase *)
     OpenLibrary("intuition.library",INTUITION_REV);
   if(!IntuitionBase)
      {
       exit(FALSE);
      }
   GfxBase = (struct GfxBase *)
    OpenLibrary("graphics.library",GFX_REV);
   if(!GfxBase)
      {
       referme(); 
       exit(FALSE);
      }
}
 

/* --------------------------------------------------------------*/
/*  ouvrefenetre() ouvre la fenetre et les gadgets               */
/* --------------------------------------------------------------*/

void ouvrefenetre()
{
void referme();
int i;
UWORD cadre[] = {
    120,20,
    183,20,
    183,53,
    120,53,
    120,20 };

   if(!(fenetre=(struct Window*)OpenWindow(&nouvfenetre)))
     {
      referme();
      exit(FALSE);
     }        
   rastport = fenetre->RPort; /* rastport nécessaire pour tracer */
   viewport = (struct ViewPort *)ViewPortAddress(fenetre);
    for(i=0 ; i<CSIZE ; i++)
        sauvecol[i] = GetRGB4(viewport->ColorMap,i);
    SetAPen(rastport,1);
    Move(rastport,120,20);
    PolyDraw(rastport,5,cadre);
    SetAPen(rastport,0);
    RectFill(rastport,121,21,151,36);
    SetAPen(rastport,1);
    RectFill(rastport,152,21,182,36);
    SetAPen(rastport,2);
    RectFill(rastport,121,37,151,52);
    SetAPen(rastport,3);
    RectFill(rastport,152,37,182,52);
    restorecol();
}

/* --------------------------------------------------------------*/
/*  Cette fonction referme la fenetre et les bibliothèques       */
/* --------------------------------------------------------------*/
void referme()
 {
  if(fenetre)       CloseWindow(fenetre);
  if(IntuitionBase) CloseLibrary(IntuitionBase);
  if(GfxBase) CloseLibrary(IntuitionBase);
 }
 

/* --------------------------------------------------------------*/
/*  fonction gérant le gadget RESET                              */
/* --------------------------------------------------------------*/
void  traite_reset() /* on remet la couleur sauvegardée associée */
{
    SetRGB4(viewport,courant,(sauvecol[courant]>> 8) & 0xF,
                             (sauvecol[courant]>> 4) & 0xF,
                             sauvecol[courant] & 0xF);
    restorecol();
}

/* --------------------------------------------------------------*/
/*  fonction gérant le gadget CANCEL                             */
/* --------------------------------------------------------------*/

void  traite_cancel() /* remet les couleurs sauvegardées au départ */
{
    LoadRGB4(viewport,sauvecol,4); 
    restorecol();
}

/* --------------------------------------------------------------*/
/*  fonction gérant le gadget BLEU                               */
/* --------------------------------------------------------------*/
void traite_bleu()
{
        while((*bouton_gauche & 0x40)-64) {
              BLEU  = bleuinfo.VertPot  >> 12;

              SetRGB4(viewport,courant,ROUGE,VERT,BLEU);

              sprintf(texte8.IText,"%2d",BLEU);
              PrintIText(rastport,&texte8,0,0);
        }
}

/* --------------------------------------------------------------*/
/*  fonction gérant le gadget VERT                               */
/* --------------------------------------------------------------*/
void  traite_vert()
{
        while((*bouton_gauche & 0x40)-64) {
              VERT  = vertinfo.VertPot  >> 12;

              SetRGB4(viewport,courant,ROUGE,VERT,BLEU);

              sprintf(texte7.IText,"%2d",VERT);
              PrintIText(rastport,&texte7,0,0);
        }
}

/* --------------------------------------------------------------*/
/*  fonction gérant le gadget ROUGE                              */
/* --------------------------------------------------------------*/
void  traite_rouge()
{
        while((*bouton_gauche & 0x40)-64) {
              ROUGE  = rougeinfo.VertPot  >> 12;

              SetRGB4(viewport,courant,ROUGE,VERT,BLEU);

              sprintf(texte6.IText,"%2d",ROUGE);
              PrintIText(rastport,&texte6,0,0);
        }
}

/* --------------------------------------------------------------*/
/*  fonction gérant le gadget ROUGE                              */
/* --------------------------------------------------------------*/
void restorecol()
{
    ROUGE = (GetRGB4(viewport->ColorMap,courant) >> 8) & 0xF ;
    VERT  = (GetRGB4(viewport->ColorMap,courant) >> 4) & 0xF ;
    BLEU  = GetRGB4(viewport->ColorMap,courant) & 0xF ;
 
    rougeinfo.VertPot = ROUGE << 12;
    vertinfo.VertPot = VERT << 12;
    bleuinfo.VertPot = BLEU << 12;
    RefreshGList(&rouge,fenetre,0,3);

    sprintf(texte6.IText,"%2d",ROUGE);
    sprintf(texte7.IText,"%2d",VERT);
    sprintf(texte8.IText,"%2d",BLEU);
    PrintIText(rastport,&texte6,0,0);
 }