/****************************************************************************/
/****************************************************************************/
/**                                                                        **/
/** GENERIC2D.PKG                                                          **/
/**                                                                        **/
/** routines génériques sur la Lib2d                                       **/
/**                                                                        **/
/** Auteur : Loïc Berthelot, 			  juin 2000                      **/
/** Chanduroi                        modification 03/2004                  **/
/** version 0.95.1                                                         **/
/**    simplification de la lib (suppresion des frames dans les obj...)    **/
/**                                                                        **/
/** version 0.93                                                           **/
/**    intégration la librairie d'encapsulation GRAPHICDRESSING            **/
/**    ==> remplacement des _CRcomp... par GRAPHICDRESSING_CR....          **/
/**                                                                        **/
/** version 0.92                                                           **/
/**    ajout des GLIB2D_ToolTip                                            **/
/**                                                                        **/
/** version0.91.1                                                          **/
/**    chg des flags G2D par défault pour les GCR_Text                     **/
/**                                                                        **/
/** version 0.91                                                           **/
/**   ajout de gLib2d_setChannel                                           **/
/**   ajout de gLib2d_setCont                                              **/
/**                                                                        **/
/** version 0.9                                                            **/
/**   ajout de gCR_Tree                                                    **/
/**   refonte totale du système d'initialisation et de gestion             **/
/**                                                                        **/
/** version 0.41                                                           **/
/**    ajout de gCR_Combo                                                  **/
/**    ajout de la gestion des CompCheck                                   **/
/**                                                                        **/
/** version 0.4 (versioning perso)                                         **/
/**    refonte totale de la lib                                            **/
/**    utilisation des Bmps pour les frames (à la place des containers)    **/
/**    création des fonctions pour les frames                              **/
/**    refonte du système d'initialisation                                 **/
/**                                                                        **/
/*  version 0.36 (versioning perso)                                        **/
/**   ajout de gCR_loadBar                                                 **/
/**   modifs du commentaire de setBmpFilesName                             **/
/**                                                                        **/
/** version 0.35                                                           **/
/**   ajout de gLib2d_SETtext                                              **/
/**   transfo de gLib2d_setFont [S I] en [Chn S I]                         **/
/**   transfo de gLib2d_setdftFont [] en [Chn]                             **/
/**   transfo de gLib2d_dftIni : ajout de Chn en premier arg               **/
/**                                                                        **/
/** version 0.34 (versioning perso)                                        **/
/**   ajout de la variable globale gLib2d_dftObjFont                       **/
/**   ajout de la fonction gLib2d_close                                    **/
/**   ajout de la particule gLib2d à toutes les entités (sauf les gCR_..)  **/
/**   ajout de la colour gLib2d_green                                      **/
/**                                                                        **/
/** version 0.33                                                           **/
/**   ajout de gCR_Border                                                  **/
/**   ajout de gCR_3DBorder                                                **/
/**                                                                        **/
/** version 0.32                                                           **/
/**   ajout de gCR_3DBordered_Label                                        **/
/**                                                                        **/
/** version 0.31                                                           **/
/**   ajout de gCR_Bordered_Label                                          **/
/**                                                                        **/
/****************************************************************************/
/****************************************************************************/











/****************************************************************************************/
/**                                                                                    **/
/** STRUCTURE DU CODE                                                                  **/
/**                                                                                    **/
/****************************************************************************************/

  typeof colors = GLIB2D_Colors

  fun gLib2d_iniColors [] I
  fun gLib2d_Ini(ch) =
  fun gLib2d_setChannel (ch) =
  fun gLib2d_setCont (objCont) =

  fun gLib2d_iniText (tupleColor, tupleFont) =
  fun gLib2d_setTextColor (color) =
  fun gLib2d_setBttTextColor (color) =
  fun gLib2d_setSelectColor (color) =
  fun gLib2d_setTransCoeff (coeff) =
  fun gLib2d_setFont (fontName, fontSize) =

  fun gLib2d_iniFrame (bkgcolor, border2Dcolor, border3Dcolors) =
  fun gLib2d_setBkgColor (color) =
  fun gLib2d_set2DBorderColor (color) =
  fun gLib2d_set3DBorderColors (colors) =

  fun gLib2d_iniList (fln, tuple) =

  fun gLib2d_iniButton (filename) =

  fun gLib2d_iniCombo (checkFilename, slideFilename, slideTuple) =
  fun gLib2d_setComboCheck (filename) =
  fun gLib2d_setComboSlide (filename, tuple) =

  fun gLib2d_iniLoading (fln, tuple) =

  fun gLib2d_iniTree (filename, slideVfilename, slideVoffsets, slideHfilename, slideHoffsets) =

  fun gLib2d_defaultIni (ch) =

  fun gLib2d_Close() =



  fun _gLDu_AlphaBmp (fln) =
  fun _gLDu_AlphaTextRollOverBmp (fln, text) =

  fun _gCRu_ClassicFrame (w, h) =
  fun _gCRu_ClassicBorderedFrame (w, h) =

  fun _gCRu_addBorder (frame, x, y, w, h) =
  fun _gCRu_add3DBorder (frame, x, y, w, h) =
  fun _gCRu_addFrameBorder (frame) =
  fun _gCRu_add3DFrameBorder (frame) =

  fun _gLib2du_getFrameCoord (x, y, flag) =

  fun gCR_Frame(x, y, w, h, flag, fln) =
  fun gCR_BorderedFrame (x, y, w, h, flag, fln) =
  fun gCR_3DBorderedFrame (x, y, w, h, flag, fln) =
  fun _gLib2du_getFrameCallback (flag) =
  fun gDS_Frame (frame) =

  fun gCR_WinCont (win, x, y, w, h, pFlag, fln) =
  fun gDS_Cont (cont) =

  fun gCR_Text (x, y, w, h, t, frameFlag, fln) =
  fun gCR_Label (x, y, w, h, t, pFlag, fln) =
  fun gCR_Line (x, y, w, h, t, pFlag, fln) =
  fun gLib2d_setText (objText, text) =
  fun gDS_Text (objText) =

  fun gCR_List (x, y, w, h, pFlag, fln) =
  fun gDS_List (objList) =
  fun gGET_List (objList) =

  fun gCR_Button (x, y, t) =
  fun gDS_Button (objBtt) =

  fun gCR_Loading (x, y) =
  fun gLib2d_IncrLoading(objLoad) =
  fun gLib2d_ResetLoading (objLoad) =
  fun gDS_Loading (objLoad) =

  fun gCR_Combo (x, y, w, h, pFlag, fln) =
  fun gDS_Combo (objCombo) =
  fun gGET_Combo (objCombo)=

  fun gCR_Tree (x, y, w, h, pFlag, fln) =
  fun gDS_Tree (objTree) =
  fun gGET_Tree (objTree) =


  fun gCR_ToolTip

  fun _gLib2du_PaintContainer (c) =
  fun gLib2d_Paint () =

/****************************************************************************/
/**                                                                        **/
/** CONSTANTES POUR LES FLAGS DE BORDURE DES FRAMES                        **/
/**                                                                        **/
/****************************************************************************/


/* flag pour préciser frame sans bordure */
var G2D_NOBORDER = 1;;

/* flag pour préciser frame avec bordure */
var G2D_BORDER = 2;;

/* flag pour préciser frame sans bordure 3D */
var G2D_3DBORDER = 4;;

/* flag pour préciser bordure interieure à la frame */
/* var G2D_BORDER_IN = 8;;                          */

/* flag pour préciser bordure extèrieure à la frame */
/* var G2D_BORDER_OUT = 16;;
*/

var G2D_BTT_MINI = 8;;

var G2D_BTT_MIDDLE = 16;;

var G2D_BTT_MAXI = 32;;

/* flag pour préciser frame avec Bkg */
var G2D_BACKGROUND = 64;;

/* flag pour préciser frame sans Bkg */
var G2D_NOBACKGROUND = 128;;

/* flag pour placer une frame par rapport à un container */
/* typiquement, pour les frames de container principaux  */
var G2D_BYCONTAINER = 256;;

/* flag pour placer frame par rapport à une autre frame  */
/* typiquement, pour les Comptext avec frame             */
var G2D_BYOTHER = 512;;



/****************************************************************************************/
/**                                                                                    **/
/** INITIALISATION                C O U L E U R S                                      **/
/**                                                                                    **/
/****************************************************************************************/



/* couleurs */
struct GLIB2D_Colors =
[
	black_GLIB2D            : I,
	blue_GLIB2D             : I,
        mallow_GLIB2D           : I,
	green_GLIB2D            : I,
	greenHospital_GLIB2D    : I,
	red_GLIB2D              : I,
	gray50_GLIB2D           : I,
	gray60_GLIB2D           : I,
	gray25_GLIB2D           : I,
	white_GLIB2D            : I,
	gold_GLIB2D	        : I,
	yellowSweet_GLIB2D      : I,
	darkRedEmaginer_GLIB2D  : I,
	lightRedEmaginer_GLIB2D : I



] mkGLIB2D_Colors;;


typeof colors = GLIB2D_Colors;;


/* création des couleurs           */
fun gLib2d_iniColors() =
    if (colors == nil)
    then set colors = mkGLIB2D_Colors [nil nil nil nil nil nil nil nil nil nil nil nil nil nil]
    else nil;
    set colors.black_GLIB2D = make_rgb 0 0 0;
    set colors.blue_GLIB2D = make_rgb 0 0 255;
    set colors.mallow_GLIB2D = make_rgb 205 193 255;
    set colors.red_GLIB2D = make_rgb 255 0 0;
    set colors.white_GLIB2D = make_rgb 255 255 255;
    set colors.gray50_GLIB2D = make_rgb 128 128 128;
    set colors.gray60_GLIB2D = make_rgb 163 163 163;
    set colors.gray25_GLIB2D = make_rgb 192 192 192;
    set colors.green_GLIB2D = make_rgb 0 170 0;
    set colors.greenHospital_GLIB2D = make_rgb 205 233 221;
    set colors.gold_GLIB2D = make_rgb 255 192 0;
    set colors.yellowSweet_GLIB2D = make_rgb 250 250 200;

/*+MB*/
/*
    set colors.darkRedEmaginer_GLIB2D = make_rgb 179 33 42;
*/
    set colors.darkRedEmaginer_GLIB2D = make_rgb 255 120 0;
/*-MB*/

    set colors.lightRedEmaginer_GLIB2D = make_rgb 213 16 28;
    1;;



/****************************************************************************************/
/**                                                                                    **/
/** INITIALISATION                G L I B 2 D                                          **/
/**                                                                                    **/
/****************************************************************************************/



struct GLIB2D_Cont =
[
	cont_contGLIB2D : ObjContainer
] mkGLIB2D_Cont;;



proto gDS_Cont = fun [GLIB2D_Cont] I;;


struct GLIB2D_Ini =
[
	ini_GLIB2D        : I,
	iniText_GLIB2D    : I,
	iniFrame_GLIB2D   : I,
	iniList_GLIB2D    : I,
	iniToolTip_GLIB2D : I,
	iniButton_GLIB2D  : I,
	iniCombo_GLIB2D   : I,
	iniLoading_GLIB2D : I,
	iniTree_GLIB2D    : I,

  iniClientx_GLIB2D : I,
  iniClienty_GLIB2D : I,
  iniClientw_GLIB2D : I,
  iniClienth_GLIB2D : I,

	cont_GLIB2D  : GLIB2D_Cont,
	ch_GLIB2D    : Chn

] mkGLIB2D_Ini;;


typeof ini = GLIB2D_Ini;;



/***************************************/
/*                                     */
/* gLib2d_Ini [Chn] I                  */
/*                                     */
/* initialise la lib2d avec un canal   */
/*                                     */
/***************************************/
fun gLib2d_Ini(ch) =
  gLib2d_iniColors;
  if (ini == nil)
  then set ini = mkGLIB2D_Ini [0 0 0 0 0 0 0 0 0 0 0 0 0 nil nil]
  else nil;
  set ini.ini_GLIB2D = 1;
  set ini.ch_GLIB2D = ch;

  1;;



/* change le canal courant */
fun gLib2d_setChannel (ch) =
  if (!ini.ini_GLIB2D)
  then nil
  else
  (
    set ini.ch_GLIB2D =ch;
    1;
   );;


/* change le container courant */
fun gLib2d_setCont (objCont) =
  if (!ini.ini_GLIB2D)
  then nil
  else
  (
    set ini.cont_GLIB2D = objCont;
    1;
  );;



/****************************************************************************************/
/**                                                                                    **/
/** INITIALISATION                T E X T E S                                          **/
/**                                                                                    **/
/****************************************************************************************/


struct GLIB2D_IniText =
[
  /* couleur de texte                      */
  textColor_txtGLIB2D : I,

  /* couleur de texte de bouton            */
  bttColor_txtGLIB2D : I,

  /* couleur de sélection de texte         */
  selectColor_txtGLIB2D : I,

  /* coefficient de transparence pour une   */
  /* sélection de texte                     */
  selectTransCoeff_txtGLIB2D : I,

  /* objet police de caractères par défault */
  objFont_txtGLIB2D : ObjFont,

  /* nom de la police par défault            */
  policeFont_txtGLIB2D : S,

  /* taille de la police par défault         */
  sizeFont_txtGLIB2D : I

] mkGLIB2D_IniText;;


typeof iniText = GLIB2D_IniText;;







/********************************************************/
/*                                                      */
/* gLib2d_iniText [[I I I I] [S I]] I                   */
/*                                                      */
/* instancie les valeurs de couleurs de texte           */
/*                                                      */
/* params :                                             */
/*   I    couleur de texte                              */
/*   I    couleur de texte pour boutons                 */
/*   I    couleur de sélection de texte                 */
/*   I    coefficient de transparence pour la sélection */
/*   S    nom de la police de caractère                 */
/*   I    taille de la police de caractère              */
/*                                                      */
/********************************************************/
fun gLib2d_iniText (tupleColor, tupleFont) =
  if (!ini.ini_GLIB2D)
  then 0
  else
  (
      let tupleColor -> [textcolor btttextcolor selectcolor transcoeff]
      in let tupleFont -> [policefont sizefont]
      in
      (
        set ini.iniText_GLIB2D = 1;
        if (iniText == nil)
        then set iniText = mkGLIB2D_IniText [nil nil nil nil nil nil nil]
	else nil;
        set iniText.textColor_txtGLIB2D     = textcolor;
        set iniText.bttColor_txtGLIB2D     = btttextcolor;
        set iniText.selectColor_txtGLIB2D  = selectcolor;
        set iniText.selectTransCoeff_txtGLIB2D   = transcoeff;
	set iniText.policeFont_txtGLIB2D = policefont;
	set iniText.sizeFont_txtGLIB2D = sizefont;
	set iniText.objFont_txtGLIB2D = _CRfont ini.ch_GLIB2D iniText.sizeFont_txtGLIB2D 0 0 iniText.policeFont_txtGLIB2D;
      );
      1;
  );;



fun gLib2d_setTextColor (color) =
  if (!ini.iniText_GLIB2D)
  then 0
  else
  (
    set iniText.textColor_txtGLIB2D = color;
    1;
  );;


fun gLib2d_setBttTextColor (color) =
  if (!ini.iniText_GLIB2D)
  then 0
  else
  (
    set iniText.bttColor_txtGLIB2D = color;
    1;
  );;


fun gLib2d_setSelectColor (color) =
  if (!ini.iniText_GLIB2D)
  then 0
  else
  (
    set iniText.selectColor_txtGLIB2D = color;
    1;
  );;


fun gLib2d_setTransCoeff (coeff) =
  if (!ini.iniText_GLIB2D)
  then 0
  else
  (
    set iniText.selectTransCoeff_txtGLIB2D = coeff;
    1;
  );;



fun gLib2d_setFont (fontName, fontSize) =
  if (!ini.iniText_GLIB2D)
  then 0
  else
  (
    set iniText.policeFont_txtGLIB2D = fontName;
    set  iniText.sizeFont_txtGLIB2D = fontSize;
    if (iniText.objFont_txtGLIB2D != nil)
    then _DSfont iniText.objFont_txtGLIB2D
    else nil;
    set iniText.objFont_txtGLIB2D = _CRfont ini.ch_GLIB2D iniText.sizeFont_txtGLIB2D 0 0 iniText.policeFont_txtGLIB2D;
    1;
  );;


fun gLib2d_setObjFont (objfont) =
  if (!ini.iniText_GLIB2D)
  then 0
  else
  (
    set iniText.policeFont_txtGLIB2D = nil;
    set iniText.sizeFont_txtGLIB2D = nil;
    set iniText.objFont_txtGLIB2D = objfont;
    1;
  );;



/****************************************************************************************/
/**                                                                                    **/
/** INITIALISATION                F R A M E S                                          **/
/**                                                                                    **/
/****************************************************************************************/


struct GLIB2D_IniFrame =
[
  /* couleur de fond de container et frame */
  bkgColor_frameGLIB2D : I,

  /* couleurs                                               */
  /* couleur de tracé des bords 2D des containers et frames */
  border2DColor_frameGLIB2D : I,

  /* couleurs pour les bords 3D des frames et containers    */
  border3DColors_frameGLIB2D : [I I I I]

] mkGLIB2D_IniFrame;;


typeof iniFrame = GLIB2D_IniFrame;;




/********************************************************/
/*                                                      */
/* gLib2d_iniFrame [I I [I I I I]] I                    */
/*                                                      */
/* instancie les couleurs de frames                     */
/*                                                      */
/* params :                                             */
/*   I    couleur de background des frames              */
/*   I    couleur de bordure 2D                         */
/*   I I I I  couleurs de bordure 3D                    */
/*                                                      */
/********************************************************/
fun gLib2d_iniFrame (bkgcolor, border2Dcolor, border3Dcolors) =
  if (!ini.ini_GLIB2D)
  then 0
  else
  (
      set ini.iniFrame_GLIB2D = 1;
      if (iniFrame == nil)
      then set iniFrame = mkGLIB2D_IniFrame [nil nil nil]
      else nil;
      set iniFrame.bkgColor_frameGLIB2D = bkgcolor;
      set iniFrame.border2DColor_frameGLIB2D = border2Dcolor;
      set iniFrame.border3DColors_frameGLIB2D = border3Dcolors;
      1;
  );;



fun gLib2d_setBkgColor (color) =
  if (!ini.iniFrame_GLIB2D)
  then 0
  else
  (
    set iniFrame.bkgColor_frameGLIB2D = color;
    1;
  );;


fun gLib2d_set2DBorderColor (color) =
  if (!ini.iniFrame_GLIB2D)
  then 0
  else
  (
    set iniFrame.border2DColor_frameGLIB2D = color;
    1;
  );;


fun gLib2d_set3DBorderColors (colors) =
  if (!ini.iniFrame_GLIB2D)
  then 0
  else
  (
    set iniFrame.border3DColors_frameGLIB2D = colors;
    1;
  );;



/****************************************************************************************/
/**                                                                                    **/
/** INITIALISATION                T O O L T I P                                        **/
/**                                                                                    **/
/****************************************************************************************/



struct GLIB2D_IniToolTip =
[
  /* fichier pour les boutons roll-over    */
  fln_tltpGLIB2D : S,
  textColor_tltpGLIB2D : I,
  bkgColor_tltpGLIB2D : I
] mkGLIB2D_IniToolTip;;


typeof iniToolTip = GLIB2D_IniToolTip;;




fun gLib2d_iniToolTip (filename, txtcolor, bkgcolor) =
  if (!ini.ini_GLIB2D)
  then 0
  else
  (
      set ini.iniToolTip_GLIB2D = 1;
      if (iniToolTip == nil)
      then set iniToolTip = mkGLIB2D_IniToolTip [nil nil nil]
      else nil;
      set iniToolTip.fln_tltpGLIB2D = filename;
      set iniToolTip.textColor_tltpGLIB2D = txtcolor;
      set iniToolTip.bkgColor_tltpGLIB2D = bkgcolor;
      1;
  );;


fun gLib2d_setToolTipFln (fln) =
  if (!ini.iniToolTip_GLIB2D)
  then 0
  else
  (
    set iniToolTip.fln_tltpGLIB2D = fln;
    1;
  );;




fun gLib2d_setToolTipTextColor (txtcolor) =
  if (!ini.iniToolTip_GLIB2D)
  then 0
  else
  (
    set iniToolTip.textColor_tltpGLIB2D = txtcolor;
    1;
  );;



fun gLib2d_setToolTipBkgColor (bkgcolor) =
  if (!ini.iniToolTip_GLIB2D)
  then 0
  else
  (
    set iniToolTip.bkgColor_tltpGLIB2D = bkgcolor;
    1;
  );;



/****************************************************************************************/
/**                                                                                    **/
/** INITIALISATION                L O A D I N G                                        **/
/**                                                                                    **/
/****************************************************************************************/



struct GLIB2D_IniLoading =
[
  /* fichier pour les barres de chargement */
  bmpFln_ldgGLIB2D : S,

  /* offset minValue                       */
  minVal_ldgGLIB2D : I,

  /* offset maxValue                        */
  maxVal_ldgGLIB2D : I,

  /* offset step                            */
  step_ldgGLIB2D : I,

  /* position courrante de la barre de chargement */
  barVal_ldgGLIB2D : F,

  /* valeur d'incrémentation de la barre */
  incrBarVal_ldgGLIB2D : F,

  /* valeur courrante représentée par la barre de chargement */
  currentVal_ldgGLIB2D : F,

  /* valeur que la barre totale représente (valeur que l'on cherche à atteindre */
  representedVal_ldgGLIB2D : F,

  /* valeur d'incrémentation à ajouter à NextStepValue    */
  incrStepVal_ldgGLIB2D : F,

  /* valeur à atteindre pour incrémenter la BarValue      */
  nextStepVal_ldgGLIB2D : F

] mkGLIB2D_IniLoading;;


typeof iniLoading = GLIB2D_IniLoading;;






/********************************************************/
/*                                                      */
/* gLib2d_iniLoading [S [I I I F]] I                    */
/*                                                      */
/* initialise les valeurs propres aux loading barres    */
/*                                                      */
/* params :                                             */
/*    S      fichier png pour slide barre               */
/*    I      minvalue                                   */
/*    I      maxvalue                                   */
/*    I      step                                       */
/*    F      representedValue                           */
/*                                                      */
/********************************************************/
fun gLib2d_iniLoading (fln, tuple) =
  if (!ini.ini_GLIB2D)
  then nil
  else
  (
    set ini.iniLoading_GLIB2D = 1;
    if (iniLoading == nil)
    then set iniLoading = mkGLIB2D_IniLoading [nil nil nil nil nil nil nil nil nil nil]
    else nil;

    let tuple -> [value1 value2 value3 fValue4]
    in
    (
      set iniLoading.bmpFln_ldgGLIB2D = fln;
      set iniLoading.minVal_ldgGLIB2D = value1;
      set iniLoading.maxVal_ldgGLIB2D = value2;
      set iniLoading.step_ldgGLIB2D = value3;
      set iniLoading.representedVal_ldgGLIB2D = fValue4;
      set iniLoading.barVal_ldgGLIB2D = (itof iniLoading.minVal_ldgGLIB2D);
      set iniLoading.incrBarVal_ldgGLIB2D =  (itof iniLoading.maxVal_ldgGLIB2D) /. (itof (iniLoading.maxVal_ldgGLIB2D - iniLoading.minVal_ldgGLIB2D));
      set iniLoading.incrStepVal_ldgGLIB2D = iniLoading.representedVal_ldgGLIB2D /. (itof (iniLoading.maxVal_ldgGLIB2D - iniLoading.minVal_ldgGLIB2D));
      set iniLoading.nextStepVal_ldgGLIB2D = iniLoading.incrStepVal_ldgGLIB2D;
      set iniLoading.currentVal_ldgGLIB2D = (itof 0);
      if ((fln == nil) || ((_checkpack fln) == nil))
      then 0
      else 1;
    );
  );;



/****************************************************************************************/
/**                                                                                    **/
/** INITIALISATION                D E F A U L T                                        **/
/**                                                                                    **/
/****************************************************************************************/


/********************************************************/
/*                                                      */
/* gLib2d_defaultIni [Chn] I                            */
/*                                                      */
/* fixe les valeurs par défault de la librairie         */
/*                                                      */
/********************************************************/
fun gLib2d_defaultIni (ch) =

    gLib2d_Ini ch;
    (
       (gLib2d_iniText [colors.white_GLIB2D colors.red_GLIB2D colors.blue_GLIB2D 70]
                      ["Arial" 14])
    && (gLib2d_iniFrame colors.gray60_GLIB2D colors.gray50_GLIB2D
                       [colors.gray50_GLIB2D colors.black_GLIB2D colors.white_GLIB2D colors.gray25_GLIB2D])
    && (gLib2d_iniToolTip nil colors.black_GLIB2D colors.yellowSweet_GLIB2D)
    );;



/***************************************/
/*                                     */
/* gLib2d_Close [] I                   */
/*                                     */
/* ferme toutes les structures         */
/* d'initialisation et de config de la */
/* lib.                                */
/*                                     */
/***************************************/
fun gLib2d_Close() =
  if (ini == nil)
  then nil
  else
  (
    gDS_Cont ini.cont_GLIB2D;
    set ini.ch_GLIB2D = nil;
    set iniFrame = nil;
    set iniText = nil;
    set iniLoading = nil;
    set ini = nil;
    1;
  );;



/****************************************************************************************/
/**                                                                                    **/
/** BODY                U T I L S    B I T M A P                                       **/
/**                                                                                    **/
/****************************************************************************************/




/********************************************************/
/*                                                      */
/* _gLDu_AlphaBmp [S] [AlphaBmp I I]                    */
/*                                                      */
/* fonction utilitaire à usage interne                  */
/*                                                      */
/* charge une image Bmp à partir du nom de fichier      */
/* et renvoie un triplet contenant le pointeur vers     */
/* le Bmp, la largeur et la hauteur de l'image          */
/*                                                      */
/* params :                                             */
/*   S    nom du fichier image                          */
/*                                                      */
/********************************************************/
fun _gLDu_AlphaBmp (fln) =
  if (!ini.ini_GLIB2D)
  then nil
  else
  let _LDalphaBitmap ini.ch_GLIB2D _checkpack fln -> alphabmp
  in
    let _GETalphaBitmapSize alphabmp -> [width height]
    in
      [alphabmp width height];;









/*************************************************************/
/*                                                           */
/* _gLDu_AlphaTextRollOverBmp [S S] [AlphaBmp I I]           */
/*                                                           */
/* fonction utilitaire à usage interne                       */
/*                                                           */
/* charge une image Bmp à partir du nom de fichier,          */
/* colle un texte dessus,                                    */
/* et renvoie un triplet contenant le pointeur vers          */
/* le Bmp, la largeur et la hauteur de l'image               */
/*                                                           */
/* params :                                                  */
/*   S    nom du fichier image                               */
/*   S    texte à afficher sur le bouton                     */
/*                                                           */
/*************************************************************/
fun _gLDu_AlphaTextRollOverBmp (fln, text) =
  if (!ini.iniText_GLIB2D)
  then nil
  else
  (
    let _gLDu_AlphaBmp  fln -> [alphabmp width height]
    in
        let _GETalphaBitmaps alphabmp -> [bmp _]
        in
        (
          _DRAWtext bmp iniText.objFont_txtGLIB2D (width / 2) (height / 16) TD_CENTER iniText.bttColor_txtGLIB2D text;
	  _DRAWtext bmp iniText.objFont_txtGLIB2D (width / 2) (5*height/16) TD_CENTER iniText.bttColor_txtGLIB2D text;
     	  _DRAWtext bmp iniText.objFont_txtGLIB2D (width / 2) (9*height/16) TD_CENTER iniText.bttColor_txtGLIB2D text;
          [alphabmp width height];
       );
   );;

/****************************************************************************************/
/**                                                                                    **/
/** BODY                    U T I L S          F R A M E                               **/
/**                                                                                    **/
/****************************************************************************************/


/* type d'un objet GLIB2D Frame */
struct GLIB2D_Frame =
[
  /* image alphabitmap associée au compBitmap */
  alpha_frameGLIB2D  : AlphaBitmap,

  /* objet compBitmap associé au container */
  comp_frameGLIB2D   : CompBitmap,

  width_frameGLIB2D  : I,

  height_frameGLIB2D : I

] mkGLIB2D_Frame;;



/********************************************************/
/*                                                      */
/* _gCRu_ClassicFrame [I I] GLIB2D_Frame                */
/*                                                      */
/* fonction utilitaire aux création des frames          */
/*                                                      */
/* créé une frame bmp vide par défault                  */
/*                                                      */
/********************************************************/
fun _gCRu_ClassicFrame (w, h) =
  let _CRbitmap ini.ch_GLIB2D  w h -> bmp
  in
  (
    _DRAWrectangle bmp 0 0 w h DRAW_SOLID 1 iniFrame.bkgColor_frameGLIB2D DRAW_SOLID iniFrame.bkgColor_frameGLIB2D;
    let _CRalphaBitmap ini.ch_GLIB2D bmp nil nil nil -> alphaBmp
    in
    (
      _DSbitmap bmp;
      let _GETalphaBitmapSize alphaBmp -> [width height]
      in mkGLIB2D_Frame [alphaBmp nil width height];
     );
   );;





/**********************************************************/
/*                                                        */
/* _gCRu_ClassicBorderedFrame [I I] GLIB2D_Frame          */
/*                                                        */
/* fonction utilitaire aux création des frames            */
/*                                                        */
/* créé une frame bmp vide avec bordure par défault       */
/*                                                        */
/**********************************************************/
fun _gCRu_ClassicBorderedFrame (w, h) =
  let _CRbitmap ini.ch_GLIB2D w h -> bmp
  in
  (
     _DRAWrectangle bmp 0 0 w h DRAW_SOLID 1 iniFrame.border2DColor_frameGLIB2D DRAW_SOLID iniFrame.bkgColor_frameGLIB2D;
     let _CRalphaBitmap ini.ch_GLIB2D bmp nil nil nil -> alphaBmp
     in
     (
       _DSbitmap bmp;
       let _GETalphaBitmapSize alphaBmp -> [width height]
       in mkGLIB2D_Frame [alphaBmp nil width height];
     );
   );;


/********************************************************/
/*                                                      */
/* _gCRu_addBorder [GLIB2D_Frame I I I I] GLIB2D_Frame  */
/*                                                      */
/* fonction utilitaire aux création des frames          */
/*                                                      */
/* ajoute une bordure de niveau 1 à un frame Bmp.       */
/*                                                      */
/********************************************************/
fun _gCRu_addBorder (frame, x, y, w, h) =
  let _GETalphaBitmaps frame.alpha_frameGLIB2D -> [bmp _]
  in
  (
    _DRAWline bmp x       y      (x+w-1)  y      DRAW_SOLID 1 iniFrame.border2DColor_frameGLIB2D;
    _DRAWline bmp (x+w-1) y      (x+w-1) (y+h-1) DRAW_SOLID 1 iniFrame.border2DColor_frameGLIB2D;
    _DRAWline bmp x      (y+h-1) (x+w-1) (y+h-1) DRAW_SOLID 1 iniFrame.border2DColor_frameGLIB2D;
    _DRAWline bmp x       y       x      (y+h-1) DRAW_SOLID 1 iniFrame.border2DColor_frameGLIB2D;
  );
  frame;;


/********************************************************/
/*                                                      */
/* _gCRu_add3DBorder [GLIB2D_Frame I I I I] GLIB2D_Frame*/
/*                                                      */
/* fonction utilitaire aux création des frames          */
/*                                                      */
/* ajoute une bordure 3D à une frame Bmp                */
/*                                                      */
/********************************************************/
fun _gCRu_add3DBorder (frame, x, y, w, h) =
  let _GETalphaBitmaps frame.alpha_frameGLIB2D -> [bmp _]
  in
  (
    let iniFrame.border3DColors_frameGLIB2D -> [color1 color2 color3 color4]
    in
    (
      _DRAWline bmp x        y      (x+w-1)  y      DRAW_SOLID 1 color1;
      _DRAWline bmp x        y       x      (y+h-1) DRAW_SOLID 1 color1;
      _DRAWline bmp (x+1)   (y+1)   (x+w-1) (y+1)   DRAW_SOLID 1 color2;
      _DRAWline bmp (x+1)   (y+1)   (x+1)   (y+h-1) DRAW_SOLID 1 color2;
      _DRAWline bmp (x+w-1) (y+1)   (x+w-1) (y+h-1) DRAW_SOLID 1 color3;
      _DRAWline bmp (x+1)   (y+h-1) (x+w-1) (y+h-1) DRAW_SOLID 1 color3;
      _DRAWline bmp (x+w-2) (y+2)   (x+w-2) (y+h-2) DRAW_SOLID 1 color4;
      _DRAWline bmp (x+2)   (y+h-2) (x+w-2) (y+h-2) DRAW_SOLID 1 color4;
    );
  );
  frame;;



/***********************************************************/
/*                                                         */
/* _gCRu_addFrameBorder [GLIB2D_Frame] GLIB2D_Frame        */
/*                                                         */
/* fonction utilitaire aux création des frames             */
/*                                                         */
/* ajoute une bordure de niveau un autour d'une frame Bmp. */
/*                                                         */
/***********************************************************/
fun _gCRu_addFrameBorder (frame) =
    _gCRu_addBorder frame 0 0 frame.width_frameGLIB2D frame.height_frameGLIB2D;;






/********************************************************/
/*                                                      */
/* _gCRu_add3DFrameBorder [GLIB2D_Frame] GLIB2D_Frame   */
/*                                                      */
/* fonction utilitaire aux création des frames          */
/*                                                      */
/* ajoute une bordure 3D autour d'une frame Bmp         */
/*                                                      */
/********************************************************/
fun _gCRu_add3DFrameBorder (frame) =
    _gCRu_add3DBorder frame 0 0 frame.width_frameGLIB2D frame.height_frameGLIB2D;;



/*******************************************************************/
/*                                                                 */
/* _gLib2du_getFrameCoord [I I I] [I I]                            */
/*                                                                 */
/* fonction utilitaire                                             */
/*                                                                 */
/* fonction utilitaire pour déterminer les coordonnées de position */
/* de la frame, par rapport aux coordonnées du container et en     */
/* fonction du flag G2D_CBYCONTAINER ou G2D_BYOTHER                */
/*                                                                 */
/*******************************************************************/
fun _gLib2du_getFrameCoord (x, y, flag) =
  if ((flag & G2D_BYCONTAINER) != 0)
  then [0 0]
  else if ((flag & G2D_BYOTHER) != 0)
       then [x y]
       else [nil nil];;

/****************************************************************************************/
/**                                                                                    **/
/** BODY                    F R A M E                                                  **/
/**                                                                                    **/
/****************************************************************************************/

/*******************************************************************/
/*                                                                 */
/* gCR_Frame [I I I I I S] GLIB2D_Frame                            */
/*                                                                 */
/* renvoie un CompBmp décrivant une frame classique                */
/*                                                                 */
/*******************************************************************/
fun gCR_Frame(x, y, w, h, flag, fln) =
  if (!ini.iniFrame_GLIB2D)
  then nil
  else
  (
    let if (fln == nil)
        then _gCRu_ClassicFrame (min w ini.iniClientw_GLIB2D) (min h ini.iniClienth_GLIB2D)
        else let _gLDu_AlphaBmp fln -> [alphaBmp alphaW alphaH] in mkGLIB2D_Frame [alphaBmp nil alphaW alphaH]
    -> frame
    in
    let
       if (flag & G2D_BORDER)
       then _gCRu_addFrameBorder frame
       else if (flag & G2D_3DBORDER)
       then _gCRu_add3DFrameBorder frame
       else frame
    -> frame
    in
      let _gLib2du_getFrameCoord x y flag
      -> [xPos yPos]
      in
      let _CRcompBitmap ini.ch_GLIB2D ini.cont_GLIB2D.cont_contGLIB2D /*obj père*/ nil
        [ini.iniClientx_GLIB2D+xPos ini.iniClienty_GLIB2D+yPos]
        OBJ_ENABLE + OBJ_VISIBLE
        /*filtre flags*/OBJ_CONTAINER_MOVE
        frame.alpha_frameGLIB2D 0 0 w h
      -> compBmp
      in
      (
         set frame.comp_frameGLIB2D = compBmp;
         frame;
      );
  );;







/**************************************************************************/
/*                                                                        */
/* gCR_BorderedFrame [I I I I I S] GLIB2D_Frame                           */
/*                                                                        */
/* renvoie un CompBmp décrivant une frame                                 */
/* avec une bordure 2D                                                    */
/*                                                                        */
/**************************************************************************/
fun gCR_BorderedFrame (x, y, w, h, flag, fln) =
  if (!ini.iniFrame_GLIB2D)
  then nil
  else
  (
    let if (fln == nil)
        then _gCRu_ClassicFrame (min w ini.iniClientw_GLIB2D) (min h ini.iniClienth_GLIB2D)
        else let _gLDu_AlphaBmp fln -> [alphaBmp alphaW alphaH] in mkGLIB2D_Frame [alphaBmp nil alphaW alphaH]
    -> frame
    in
      let _gCRu_addFrameBorder frame -> borderedFrame
      in
        let _gLib2du_getFrameCoord x y flag
        -> [xPos yPos]
        in
        let _CRcompBitmap ini.ch_GLIB2D ini.cont_GLIB2D.cont_contGLIB2D /*obj père*/ nil
          [ini.iniClientx_GLIB2D+xPos ini.iniClienty_GLIB2D+yPos]
          OBJ_ENABLE + OBJ_VISIBLE
          /*filtre flags*/OBJ_CONTAINER_MOVE
          borderedFrame.alpha_frameGLIB2D 0 0 w h
         -> compBmp
         in
	 (
	   set borderedFrame.comp_frameGLIB2D = compBmp;
	   borderedFrame;
	 );
  );;





/*****************************************************************************/
/*                                                                           */
/* gCR_3DBorderedFrame [I I I I I S] GLIB2D_Frame                            */
/*                                                                           */
/* renvoie un CompBmp décrivant une frame                                    */
/* avec une bordure 3D                                                       */
/*                                                                           */
/*****************************************************************************/
fun gCR_3DBorderedFrame (x, y, w, h, flag, fln) =
  if (!ini.iniFrame_GLIB2D)
  then nil
  else
  (
    let if (fln == nil)
        then _gCRu_ClassicFrame (min w ini.iniClientw_GLIB2D) (min h ini.iniClienth_GLIB2D)
        else let _gLDu_AlphaBmp fln -> [alphaBmp alphaW alphaH] in mkGLIB2D_Frame [alphaBmp nil alphaW alphaH]
    -> frame
    in
    let _gCRu_add3DFrameBorder frame -> borderedFrame
    in
      let _gLib2du_getFrameCoord x y flag
      -> [xPos yPos]
      in
      let _CRcompBitmap ini.ch_GLIB2D ini.cont_GLIB2D.cont_contGLIB2D /*obj père*/ nil
        [ini.iniClientx_GLIB2D+xPos ini.iniClienty_GLIB2D+yPos]
        OBJ_ENABLE + OBJ_VISIBLE
        /*filtre flags*/OBJ_CONTAINER_MOVE
        borderedFrame.alpha_frameGLIB2D 0 0 w h
      -> compBmp
      in
      (
          set borderedFrame.comp_frameGLIB2D = compBmp;
	  borderedFrame;
      );
  );;


/*******************************************************************************************/
/*                                                                                         */
/* _gLib2du_getFrameCallback [I] fun [I] GLIB2D_Frame                                      */
/*                                                                                         */
/* fonction utilitaire pour la création des frames                                         */
/*                                                                                         */
/* renvoie la callback de création de frame associé au flag passé en paramètre             */
/*                                                                                         */
/*******************************************************************************************/
fun _gLib2du_getFrameCallback (flag) =
    if ((flag & G2D_BACKGROUND) != 0)
    then
        if ((flag & G2D_NOBORDER) != 0)
        then @gCR_Frame
        else if ((flag & G2D_BORDER) != 0)
             then @gCR_BorderedFrame
	     else if ((flag & G2D_3DBORDER) != 0)
	          then @gCR_3DBorderedFrame
	          else nil
    else nil;;






/********************************************************/
/*                                                      */
/* gDS_Frame [GLIB2D_Frame] I                           */
/*                                                      */
/* détruit une frame et son contenu.                    */
/*                                                      */
/********************************************************/
fun gDS_Frame (frame) =
  if (frame == nil)
  then nil
  else
  (
    _DSalphaBitmap frame.alpha_frameGLIB2D;
    _DScompBitmap frame.comp_frameGLIB2D;
    set frame = nil;
    1;
  );;

/****************************************************************************************/
/**                                                                                    **/
/** BODY                    C O N T A I N E R                                          **/
/**                                                                                    **/
/****************************************************************************************/


/***********************************************************************/
/*                                                                     */
/* gCR_WinCont [ObjWin I I I I I S] GLIB2D_Cont                        */
/*                                                                     */
/* renvoie un container par défault associé à une                      */
/* fenêtre.                                                            */
/*                                                                     */
/* params :                                                            */
/*   ObjWin fenetre associée                                           */
/*   I      position sur x                                             */
/*   I      position sur y                                             */
/*   I      largeur                                                    */
/*   I      hauteur                                                    */
/*                                                                     */
/***********************************************************************/
fun gCR_WinCont (win, x, y, w, h) =
  if (!ini.ini_GLIB2D)
  then nil
  else
     let _CRcontainerFromObjWin ini.ch_GLIB2D win x y w h  /*flags*/CO_CHILDINSIDE + CO_NOBORDER /*+ CO_NOCLIPCHILDREN */ /*Couleur*/iniFrame.bkgColor_frameGLIB2D ""
    -> newCont
    in
    (
      let mkGLIB2D_Cont [newCont] -> glib2dCont in
      set ini.cont_GLIB2D = glib2dCont;
      set ini.iniClientx_GLIB2D = 0;
      set ini.iniClienty_GLIB2D = 0;
      set ini.iniClientw_GLIB2D = w;
      set ini.iniClienth_GLIB2D = h;
      ini.cont_GLIB2D;
  );;


/*+MB*/
fun gSET_Cont (newCont, cx, cy, cw, ch) =
  if (!ini.ini_GLIB2D)
  then nil
  else
  (
    let mkGLIB2D_Cont [newCont] -> glib2dCont in
    set ini.cont_GLIB2D = glib2dCont;
    set ini.iniClientx_GLIB2D = cx;
    set ini.iniClienty_GLIB2D = cy;
    set ini.iniClientw_GLIB2D = cw;
    set ini.iniClienth_GLIB2D = ch;
    ini.cont_GLIB2D;
  );;
/*-MB*/


/*********************************************/
/*                                           */
/* gDS_Cont [GLIB2D_Cont] I                  */
/*                                           */
/* détruit un container et sa frame.         */
/*                                           */
/*********************************************/
fun gDS_Cont (cont) =
  if (cont == nil)
  then nil
  else
  (
    _DScontainer cont.cont_contGLIB2D;
    set cont = nil;
    1;
  );;


/****************************************************************************************/
/**                                                                                    **/
/** BODY                    T E X T                                                    **/
/**                                                                                    **/
/****************************************************************************************/


struct GLIB2D_Text =
[
	text_txtGLIB2D : CompText

] mkGLIB2D_Text;;





/********************************************************************/
/*                                                                  */
/* gCR_Text [I I I I S] GLIB2D_Text                                 */
/*                                                                  */
/* renvoie une zone de texte éditable par défault                   */
/*                                                                  */
/* params :                                                         */
/*   I            position sur x                                    */
/*   I            position sur y                                    */
/*   I            largeur                                           */
/*   I            hauteur                                           */
/*   S            texte                                             */
/*                                                                  */
/********************************************************************/
fun gCR_Text (x, y, w, h, t) =
  if (!ini.iniText_GLIB2D)
  then nil
  else
  (
    /* création de l'obket CompText */
    let GRAPHICDRESSING_CRcompText
          ini.ch_GLIB2D ini.cont_GLIB2D.cont_contGLIB2D  /*obj père*/nil
          [ini.iniClientx_GLIB2D+x ini.iniClienty_GLIB2D+y]
          OBJ_ENABLE + OBJ_VISIBLE + CT_WORDWRAP + CT_MULTIEDITLINE
          /*filtrage flags*/OBJ_CONTAINER_MOVE
          w h t iniText.objFont_txtGLIB2D
          [ iniText.textColor_txtGLIB2D 0 0 0 ]
      	  [ iniText.selectColor_txtGLIB2D iniText.selectTransCoeff_txtGLIB2D ]
	  -> textTmp
    in
       /* on renvoit lçobjet GLIB2D_Text */
       mkGLIB2D_Text [textTmp];
  );;



/********************************************************/
/*                                                      */
/* gCR_Label [I I I I S] GLIB2D_Text                    */
/*                                                      */
/* renvoie une zone de texte NON éditable par défault   */
/*                                                      */
/* params :                                             */
/*   I            position sur x                        */
/*   I            position sur y                        */
/*   I            largeur                               */
/*   I            hauteur                               */
/*   S            texte                                 */
/*                                                      */
/********************************************************/
fun gCR_Label (x, y, w, h, t) =
  if (!ini.iniText_GLIB2D)
  then nil
  else
  (
    let
      /* création de l'objet CompText */
      GRAPHICDRESSING_CRcompText
        ini.ch_GLIB2D ini.cont_GLIB2D.cont_contGLIB2D  /*obj père*/nil
        [ini.iniClientx_GLIB2D+x ini.iniClienty_GLIB2D+y]
        OBJ_ENABLE + OBJ_VISIBLE + CT_WORDWRAP + CT_LABEL
        /*filtrage flags*/OBJ_CONTAINER_MOVE
        w h t iniText.objFont_txtGLIB2D
        [ iniText.textColor_txtGLIB2D 0 0 0 ]
        [ iniText.selectColor_txtGLIB2D iniText.selectTransCoeff_txtGLIB2D ]

    -> objtext
    in
        /* on renvoit l'objet GLIB2D_Text */
        mkGLIB2D_Text [objtext]
  );;

/********************************************************************/
/*                                                                  */
/* gCR_Line [I I I I S] GLIB2D_Text                                 */
/*                                                                  */
/* renvoie une zone de texte non éditable par défault               */
/*                                                                  */
/* params :                                                         */
/*   I            position sur x                                    */
/*   I            position sur y                                    */
/*   I            largeur                                           */
/*   I            hauteur                                           */
/*   S            texte                                             */
/*                                                                  */
/********************************************************************/
fun gCR_Line (x, y, w, h, t) =
  if (!ini.iniText_GLIB2D)
  then nil
  else
  (
    let
      GRAPHICDRESSING_CRcompText
        ini.ch_GLIB2D ini.cont_GLIB2D.cont_contGLIB2D  /*obj père*/nil
        [ini.iniClientx_GLIB2D+x ini.iniClienty_GLIB2D+y]
        OBJ_ENABLE + OBJ_VISIBLE + CT_EDITLINE
        /*filtrage flags*/OBJ_CONTAINER_MOVE
        w h t iniText.objFont_txtGLIB2D
        [ iniText.textColor_txtGLIB2D 0 0 0 ]
	      [ iniText.selectColor_txtGLIB2D iniText.selectTransCoeff_txtGLIB2D ]
	  -> textTmp
    in
       /* on renvoit l'objet GLIB2D_Text */
       mkGLIB2D_Text [textTmp];
  );;


/********************************************************/
/*                                                      */
/* gLib2d_setText [GLIB2D_Text S] I                     */
/*                                                      */
/* mis à jour du texte d'un objet texte                 */
/*                                                      */
/********************************************************/
fun gLib2d_setText (objText, text) =
  _SETcompText objText.text_txtGLIB2D text iniText.objFont_txtGLIB2D
    [iniText.textColor_txtGLIB2D 0 0 nil] CT_NOCHANGE;
  1;;




fun gLib2d_getText (objText) =
  _GETcompText objText.text_txtGLIB2D;;




/********************************************************/
/*                                                      */
/* gDS_Text [GLIB2D_Text] I                             */
/*                                                      */
/* permet de détruire une objet comptext et les objets  */
/* compBmp et alphaBmp associés...                      */
/*                                                      */
/********************************************************/
fun gDS_Text (objText) =
  if (objText == nil)
  then nil
  else
  (
    GRAPHICDRESSING_DScompText objText.text_txtGLIB2D;
    set objText = nil;
    1;
  );;



/****************************************************************************************/
/**                                                                                    **/
/** BODY                    L I S T                                                    **/
/**                                                                                    **/
/****************************************************************************************/


struct GLIB2D_List =
[
	list_lstGLIB2D : CompList

] mkGLIB2D_List;;




/********************************************************/
/*                                                      */
/* gCR_List [I I I I] GLIB2D_List                       */
/*                                                      */
/* renvoie une list box par défault                     */
/*                                                      */
/* params :                                             */
/*   I            position sur x                        */
/*   I            position sur y                        */
/*   I            largeur                               */
/*   I            hauteur                               */
/*                                                      */
/********************************************************/
fun gCR_List (x, y, w, h) =
  if (!ini.iniText_GLIB2D)
  then nil
  else
  (
    let
      GRAPHICDRESSING_CRcompList
        ini.ch_GLIB2D ini.cont_GLIB2D.cont_contGLIB2D /*obj père*/ nil
        [ini.iniClientx_GLIB2D+x ini.iniClienty_GLIB2D+y]
        OBJ_ENABLE + OBJ_VISIBLE + LST_HIGHLIGHT_CLICKED + LST_LEFT
        /* filtrage flags*/OBJ_CONTAINER_MOVE
        w h
        /*nbr d'items visibles à la fois*/ /*(h / gLib2d_dftSizeFont)*/8
        LST_VERTICAL iniText.objFont_txtGLIB2D 0
        [iniText.textColor_txtGLIB2D 0 0 0]
        [iniText.selectColor_txtGLIB2D iniText.selectTransCoeff_txtGLIB2D]
      -> listTmp
      in mkGLIB2D_List [listTmp];
    );;



/* détruit un objet GLIB2D_List */
fun gDS_List (objList) =
  if (objList == nil)
  then nil
  else
  (
    GRAPHICDRESSING_DScompList objList.list_lstGLIB2D;
    1;
  );;



/* renvoie l'objet compList */
fun gGET_List (objList) =
  if (objList == nil)
  then nil
  else objList.list_lstGLIB2D;;


/****************************************************************************************/
/**                                                                                    **/
/** BODY                T O O L T I P                                                  **/
/**                                                                                    **/
/****************************************************************************************/


struct GLIB2D_ToolTip =
[
	tooltip_tltpGLIB2D : EmToolTip,

	alpha_tltpGLIB2D : AlphaBitmap

] mkGLIB2D_ToolTip;;


/********************************************************************/
/*                                                                  */
/* gCR_ToolTip [ObjNode S] GLIB2D_ToolTip                           */
/*                                                                  */
/* créé un tooltip sur un objnode                                   */
/*                                                                  */
/* params :                                                         */
/*   ObjNode  objet père                                            */
/*   S        text du tooltip                                       */
/*   I        flags de création du tooltip                          */
/*   S        nom du fichier background s'il y a                    */
/*                                                                  */
/********************************************************************/
fun gCR_ToolTip (objnode, text) =
  if ((!ini.iniText_GLIB2D) || (!ini.iniToolTip_GLIB2D))
  then nil
  else
  (
    let
      if ((iniToolTip.fln_tltpGLIB2D == nil) || ((_checkpack iniToolTip.fln_tltpGLIB2D) == nil))
      then [nil 0 0]
      else _gLDu_AlphaBmp iniToolTip.fln_tltpGLIB2D
    -> [alphaBmp alphaW alphaH]
    in
    /* création de l'objet ToolTip */
    let _CR_TOOLTIP ini.ch_GLIB2D ini.cont_GLIB2D.cont_contGLIB2D  objnode
        iniText.objFont_txtGLIB2D
	[iniToolTip.textColor_tltpGLIB2D nil iniText.selectColor_txtGLIB2D iniText.selectTransCoeff_txtGLIB2D]
	iniToolTip.bkgColor_tltpGLIB2D alphaBmp [5 0 alphaW alphaH]
	text nil 1500
    -> tooltip
    in
      mkGLIB2D_ToolTip [tooltip alphaBmp];
   );;

fun gDS_ToolTip (objtltp) =
  if (objtltp == nil)
  then nil
  else
  (
    _DSalphaBitmap objtltp.alpha_tltpGLIB2D;
    set objtltp = nil;
    1;
  );;

/****************************************************************************************/
/**                                                                                    **/
/** BODY                    B U T T O N                                                **/
/**                                                                                    **/
/****************************************************************************************/


struct GLIB2D_Button =
[
   btt_bttGLIB2D : CompRollOver,

   alpha_bttGLIB2D : AlphaBitmap,

   tltp_bttGLIB2D : GLIB2D_ToolTip

] mkGLIB2D_Button;;


/********************************************************/
/*                                                      */
/* gCR_Button [I I I IS] GLIB2D_Button                  */
/*                                                      */
/* renvoie un bouton par défault                        */
/*                                                      */
/* params :                                             */
/*   I            position sur x                        */
/*   I            position sur y                        */
/*   I I          taille w et h                         */
/*   S            texte du bouton                       */
/*   S            texte du tooltip                      */
/*                                                      */
/********************************************************/
fun gCR_Button (x, y, w, h, flag, t, tt, alphaicone) =
  let ini.ch_GLIB2D -> ch in
  let ini.cont_GLIB2D.cont_contGLIB2D -> cont in
  let
     if (flag == nil)
     then GRAPHICDRESSING_CRcompRollOverWithText ch cont nil [ini.iniClientx_GLIB2D+x ini.iniClienty_GLIB2D+y]
          OBJ_ENABLE | OBJ_VISIBLE
          OBJ_CONTAINER_MOVE/*nil */
          w h Font t iniText.textColor_txtGLIB2D

     else if (flag & G2D_BTT_MINI)
     then GRAPHICDRESSING_CRcompRollOverMini ch cont nil [ini.iniClientx_GLIB2D+x ini.iniClienty_GLIB2D+y]
          OBJ_ENABLE | OBJ_VISIBLE
          OBJ_CONTAINER_MOVE/*nil */
          alphaicone

	else if (flag & G2D_BTT_MIDDLE)
	then GRAPHICDRESSING_CRcompRollOverMiddle ch cont nil [ini.iniClientx_GLIB2D+x ini.iniClienty_GLIB2D+y]
	     OBJ_ENABLE | OBJ_VISIBLE
	     OBJ_CONTAINER_MOVE/*nil */
	     alphaicone

	else if (flag & G2D_BTT_MAXI)
	then GRAPHICDRESSING_CRcompRollOverMaxi ch cont nil [ini.iniClientx_GLIB2D+x ini.iniClienty_GLIB2D+y]
	     OBJ_ENABLE | OBJ_VISIBLE
	     OBJ_CONTAINER_MOVE/*nil */
	     alphaicone
	else nil
  -> buttonTmp
  in
    let if (tt == nil)
        then nil
        else gCR_ToolTip (_CONVERTcompRollOverToObjNode buttonTmp) tt
    -> tooltipTmp
    in
       mkGLIB2D_Button [buttonTmp nil tooltipTmp];;






/* bouton défini manuellement avec un alpha choisi */
fun gCR_CustomButton (x, y, w, h, tt, alpha) =
    let _CRcompRollOver ini.ch_GLIB2D
                      ini.cont_GLIB2D.cont_contGLIB2D
                      nil
                      [ini.iniClientx_GLIB2D+x ini.iniClienty_GLIB2D+y]
                      (OBJ_VISIBLE|OBJ_ENABLE|ROL_MASK)
                      OBJ_CONTAINER_MOVE/*nil */
                      alpha
    -> buttonTmp
    in
      let if (tt == nil)
          then nil
          else gCR_ToolTip (_CONVERTcompRollOverToObjNode buttonTmp) tt
      -> tooltipTmp
      in
        mkGLIB2D_Button [buttonTmp alpha tooltipTmp];;



/* détruit un objet GLIB2D_Button */
fun gDS_Button (objBtt) =
  if (objBtt == nil)
  then nil
  else
  (
    _DSalphaBitmap objBtt.alpha_bttGLIB2D;
    gDS_ToolTip objBtt.tltp_bttGLIB2D;
    GRAPHICDRESSING_DScompRollOver objBtt.btt_bttGLIB2D;
    1;
  );;


 fun gDS_CustomButton (objBtt) =
   if (objBtt == nil)
   then nil
   else
   (
      gDS_ToolTip objBtt.tltp_bttGLIB2D;
      _DScompRollOver objBtt.btt_bttGLIB2D;
   );;

/****************************************************************************************/
/**                                                                                    **/
/** BODY                    L O A D I N G                                              **/
/**                                                                                    **/
/****************************************************************************************/



struct GLIB2D_Loading =
[
	slide_ldgGLIB2D : CompSlideBar,

	alpha_ldgGLIB2D : AlphaBitmap

] mkGLIB2D_Loading;;



/*************************************************************/
/*                                                           */
/* gCR_Loading [I I] GLIB2D_Loading                          */
/*                                                           */
/* créé une loading barre                                    */
/*                                                           */
/* renvoie 1 si ok                                           */
/* nil sinon (lib non initialisée ou container n'existe pas) */
/*                                                           */
/*************************************************************/
fun gCR_Loading (x, y) =
  /*if (!ini.iniLoading_GLIB2D)
  then nil
  else
  (*/
   /* création de l'alpha Bmp */
   let _gLDu_AlphaBmp iniLoading.bmpFln_ldgGLIB2D -> [aBmp aBmpW aBmpH]
   in
      let aBmpW -> w
      in let aBmpH / 3 -> h
      in
   /* création de la loading barre */
   let _CRcompSlideBar ini.ch_GLIB2D ini.cont_GLIB2D.cont_contGLIB2D /*obj pere*/nil
     [ini.iniClientx_GLIB2D+x ini.iniClienty_GLIB2D+y]
     OBJ_ENABLE + OBJ_VISIBLE + SLB_MASK + SLB_GAUGE
     OBJ_CONTAINER_MOVE /*nil */
     aBmp [iniLoading.minVal_ldgGLIB2D iniLoading.maxVal_ldgGLIB2D iniLoading.maxVal_ldgGLIB2D]
     SLB_HORIZONTAL 0 w 1
     -> slideTmp
     in mkGLIB2D_Loading [slideTmp aBmp]
  /*)*/;;







/*************************************************************/
/*                                                           */
/* gLib2d_IncrLoading [GLIB2d_Loading] I                     */
/*                                                           */
/* incrémente la slide bar                                   */
/*                                                           */
/*************************************************************/
fun gLib2d_IncrLoading(objLoad) =
    if (objLoad == nil)
    then nil
    else
    (
      set iniLoading.currentVal_ldgGLIB2D = iniLoading.currentVal_ldgGLIB2D +. (itof 1);
      if (iniLoading.currentVal_ldgGLIB2D <=. iniLoading.nextStepVal_ldgGLIB2D)
      then nil
      else
      (
        set iniLoading.barVal_ldgGLIB2D = iniLoading.barVal_ldgGLIB2D +. iniLoading.incrBarVal_ldgGLIB2D;
        set iniLoading.nextStepVal_ldgGLIB2D = iniLoading.nextStepVal_ldgGLIB2D +. iniLoading.incrStepVal_ldgGLIB2D;
        _SETcompSlideBarValue objLoad.slide_ldgGLIB2D (ftoi iniLoading.barVal_ldgGLIB2D);
      );
      1;
    );;






/*************************************************************/
/*                                                           */
/* gLib2d_ResetLoadBar [CompSlideBar] I                      */
/*                                                           */
/* réinitialise la slide bar                                 */
/*                                                           */
/*************************************************************/
fun gLib2d_ResetLoading (objLoad) =
  if (objLoad == nil)
  then nil
  else
  (
    gLib2d_iniLoading iniLoading.bmpFln_ldgGLIB2D
                      [iniLoading.minVal_ldgGLIB2D iniLoading.maxVal_ldgGLIB2D
  		       iniLoading.step_ldgGLIB2D iniLoading.representedVal_ldgGLIB2D];
    _SETcompSlideBarValue objLoad.slide_ldgGLIB2D (ftoi iniLoading.barVal_ldgGLIB2D);
    1;
  );;






/* détruit un objet GLIB2D_Loading */
fun gDS_Loading (objLoad) =
  if (objLoad == nil)
  then nil
  else
  (
    _DSalphaBitmap objLoad.alpha_ldgGLIB2D;
    _DScompSlideBar objLoad.slide_ldgGLIB2D;
    set objLoad = nil;
    1;
  );;

/****************************************************************************************/
/**                                                                                    **/
/** BODY                    C O M B O                                                  **/
/**                                                                                    **/
/****************************************************************************************/


struct GLIB2D_Combo =
[
	combo_comboGLIB2D : CompCombo,

        label_comboGLIB2D : GLIB2D_Text

] mkGLIB2D_Combo;;





/**********************************************************************/
/*                                                                    */
/* gCR_Combo [I I I I] GLIB2D_Combo                                   */
/*                                                                    */
/* créé une combo box avec des valeurs par défault                    */
/*                                                                    */
/**********************************************************************/
fun gCR_Combo (x, y, w, h) =
  if (!ini.iniText_GLIB2D)
  then nil
  else
  (
     /* frame du label (en-tête de la combo box) */
     let gCR_Text x y w 20 ""-> label
     in

     /* combo box */
     let GRAPHICDRESSING_CRcompCombo ini.ch_GLIB2D ini.cont_GLIB2D.cont_contGLIB2D /*obj père*/nil
       [ini.iniClientx_GLIB2D+x ini.iniClienty_GLIB2D+y]
       OBJ_ENABLE + OBJ_VISIBLE
       /*filtres*/OBJ_CONTAINER_CLICK|OBJ_CONTAINER_MOVE
       w h
       iniText.objFont_txtGLIB2D
       [iniText.textColor_txtGLIB2D nil 0 0]
       [iniText.selectColor_txtGLIB2D iniText.selectTransCoeff_txtGLIB2D]
       0
     -> combo
     in mkGLIB2D_Combo [combo label];
 );;





/* détruit un objet GLIB2D_Combo */
fun gDS_Combo (objCombo) =
  if (objCombo == nil)
  then nil
  else
  (
    gDS_Text objCombo.label_comboGLIB2D;
    GRAPHICDRESSING_DScompCombo objCombo.combo_comboGLIB2D;
    set objCombo = nil;
    1;
  );;


/* renvoie l'objet CompCombo */
fun gGET_Combo (objCombo)=
  if (objCombo == nil)
  then nil
  else objCombo.combo_comboGLIB2D;;


/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
/**                                                                                    **/
/** BODY                    T R E E                                                    **/
/**                                                                                    **/
/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/


struct GLIB2D_Tree =
[
	tree_treeGLIB2D : CompTree

] mkGLIB2D_Tree;;



/**********************************************************************/
/*                                                                    */
/* gCR_Tree [I I I I I] GLIB2D_Tree                                   */
/*                                                                    */
/* créé un arbre                                                      */
/*                                                                    */
/**********************************************************************/
 fun gCR_Tree (x, y, w, h, flag) =
  if (!ini.iniText_GLIB2D)
  then nil
  else
  (
     let OBJ_ENABLE+OBJ_VISIBLE -> basicFlags in
     let
        if (flag == nil)
	then basicFlags
	else basicFlags+flag
     -> flags
     in
     /* CompTree */
     let GRAPHICDRESSING_CRcompTree ini.ch_GLIB2D ini.cont_GLIB2D.cont_contGLIB2D /*obj père*/nil
       [ini.iniClientx_GLIB2D+x ini.iniClienty_GLIB2D+y]
       flags
       /*filtres*/OBJ_CONTAINER_MOVE
       /* taille */(w) (h)
       /* nbr d'items visibles */ (((h) / iniText.sizeFont_txtGLIB2D) - 10)
       /* direction (non utilisée à l'heure actuelle (juillet 2000)) */ 0
       iniText.objFont_txtGLIB2D
       /* taille réservée pour imgs */0
       /* décalage entre éléments */ 25
       [iniText.textColor_txtGLIB2D nil nil nil]
       [iniText.selectColor_txtGLIB2D iniText.selectTransCoeff_txtGLIB2D]

     -> tree

     in mkGLIB2D_Tree [tree];
 );;




/* détruit un objet GLIB2D_Tree */
fun gDS_Tree (objTree) =
  if (objTree == nil)
  then nil
  else
  (
    GRAPHICDRESSING_DScompTree objTree.tree_treeGLIB2D;
    set objTree = nil;
    1;
  );;


/* renvoie l'objet CompTree */
fun gGET_Tree (objTree) =
  if (objTree == nil)
  then nil
  else objTree.tree_treeGLIB2D;;



/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
/**                                                                                    **/
/** BODY                    P A I N T                                                  **/
/**                                                                                    **/
/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/


/*************************************************************/
/*                                                           */
/* _gLib2du_PaintContainer [GLIB2D_Cont] I                   */
/*                                                           */
/* fonction à usage interne                                  */
/* redessine un container                                    */
/*                                                           */
/* renvoie 1 si ok                                           */
/* nil sinon                                                 */
/*                                                           */
/*************************************************************/
fun _gLib2du_PaintContainer (c) =
  _PAINTcontainer c.cont_contGLIB2D;
  1;;







/*************************************************************/
/*                                                           */
/* gLib2d_Paint [] I                                         */
/*                                                           */
/* redessine le container et tous ses composants             */
/*                                                           */
/* renvoie 1 si ok                                           */
/*                                                           */
/*************************************************************/
fun gLib2d_Paint () =
  if (!ini.ini_GLIB2D)
  then nil
  else
  (
    _gLib2du_PaintContainer ini.cont_GLIB2D;
    1;
  );;