/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        A F F I C H A G E   D ' U N E   S E Q U E N C E   D ' I M A G E S  :                                                       */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Definition :                                                                                                               */
/*                                                                                                                                   */
/*                    Cette commande affiche une sequence                                                                            */
/*                  d'images Argument.                                                                                               */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xci/sequence$K' :                                                                                              */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 1987??????????).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        I N T E R F A C E   ' listG '  :                                                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        :Debut_listG:                                                                                                              */
/*        :Fin_listG:                                                                                                                */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D I R E C T I V E S   S P E C I F I Q U E S   D E   C O M P I L A T I O N  :                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        F I C H I E R S   D ' I N C L U D E S  :                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  INCLUDES_BASE

#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_SPIX
#    include   image_drive_dpx5c_FONCTION_EXT
#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SPIX
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SPIX

#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW
#    include   image_image_IMAGESF_EXT
                                        /* Introduit le 20070712101423...                                                            */
#    include   image_image_QUAD_IMAGE_EXT
                                        /* ATTENTION, avant le 20021230112537, les includes 'image_image_TRI_IMAGE_EXT' et           */
                                        /* 'image_image_QUAD_IMAGE_EXT' n'etaient faits que pour                                     */
                                        /* '__VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL'.                                             */
                                        /* Mais avec les modifications faites dans 'v $xiidX/fonct$vv$FON 20021230102551' il a       */
                                        /* fallu les rendre systematiques...                                                         */

#    include   image_drive_XWind_FONCTION_EXT

#    ifdef     __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
#         include   image_drive_SiliG_FONCTION_1_EXT
#    Aifdef    __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
#    Eifdef    __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL

#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S  :                                                                                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  xci/display.01.I"

                                        /* ATTENTION, on ne peut utiliser 'Iload_image_avec_redimensionnement_eventuel(...)' ici     */
                                        /* de facon simple, car, en effet, l'ouverture de la fenetre a lieu avant le chargement      */
                                        /* individuel des images. La dimension ne peut donc plus etre changee par la suite...        */
                                        /*                                                                                           */
                                        /* Enfin, 'Iload_image_avec_redimensionnement_eventuel(...)' est actuellement inutilisable   */
                                        /* pour des raisons detaillees dans 'v $xiii/files$FON'.                                     */

#define   EDITER_LES_MESSAGES_D_ERREUR                                                                                                  \
                    EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS                                                                           \
                                        /* Indique si les messages d'erreur des fichiers doivent etre emis ('VRAI') ou pas ('FAUX'), */ \
                                        /* ce qui peut etre tres utile lorsque l'on considere que les images non existantes ne sont  */ \
                                        /* pas encore produites et qu'il faut donc les attendre...                                   */

#define   EDITER_LE_NOM_DES_IMAGES                                                                                                      \
                    FAUX                                                                                                                \
                                        /* Indique si le nom de chacune des images affichees doit etre indique ('VRAI') ou pas       */ \
                                        /* ('FAUX'), l'edition ayant lieu comme pour un message d'erreur (afin de ne pas perturber   */ \
                                        /* le "pipe" des images...).                                                                 */
#define   EDITER_SEULEMENT_LE_NUMERO_DES_IMAGES                                                                                         \
                    FAUX                                                                                                                \
                                        /* Indique si 'IL_FAUT(editer_le_nom_des_images)' si le nom entier doit etre edite ('FAUX')  */ \
                                        /* ou seulement le numero ('VRAI').                                                          */

#include  xci/sequence.01.I"

#define   TEMPORISATION_INTER_TRAMES                                                                                                    \
                    ZERO                                                                                                                \
                                        /* Temporisation inter_trames ; une valeur nulle fait qu'il n'y a pas d'attente, et une      */ \
                                        /* valeur negative provoque l'attente sur la souris (ATTENTION, cette convention n'est pas   */ \
                                        /* celle de '$xci/display$K', car en effet, dans le cas de '$xci/sequence$K', en general on  */ \
                                        /* ne veut pas attendre apres chaque image, ce qui correspond reellement a une attente       */ \
                                        /* nulle ; cette convention ne peut donc etre utilisee...).                                  */
#define   NOMBRE_DE_REPETITIONS                                                                                                         \
                    UN                                                                                                                  \
                                        /* Nombre implicite de repetitions de l'animation...                                         */

#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_SPIX
#    define    TEMPORISATION_INTER_ANIMATIONS                                                                                           \
                         QUAD(SEIZE)                                                                                                    \
                                        /* Temporisation inter_animations ; une valeur nulle fait qu'il n'y a pas d'attente...       */
#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SPIX
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SPIX

#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW
#    define    RECUPERER_UNE_IMAGE_EN_VRAIES_COULEURS                                                                                   \
                         VRAI                                                                                                           \
                                        /* Faut-il recuperer une image en vraies couleurs ('VRAI)' c'est-a-dire dont les trois       */ \
                                        /* composantes ont la meme racine, ou bien trois images "independantes" ('FAUX'). La         */ \
                                        /* valeur par defaut est choisie pour assurer la compatibilite anterieure. Ceci etant        */ \
                                        /* lie evidemment a 'EST_FAUX(IXopen_____mettre_X_Window_en_mode_fausses_couleurs)' et       */ \
                                        /* a ete introduit le 20021231172005.                                                        */

#    define    CHANGER_LA_DIMENSION_DE_LA_FENETRE                                                                                       \
                         FAUX
#    define    X_DIMENSION_DE_LA_FENETRE                                                                                                \
                         FU
#    define    Y_DIMENSION_DE_LA_FENETRE                                                                                                \
                         FU
                                        /* Faut-il redimensionner la fenetre de facon, par exemple, a ce qu'elle soit plus grande    */
                                        /* que l'image ('VRAI)' ou pas ('FAUX'). Ceci a ete introduit le 20030401180401.             */

#    ifdef     ALLOCATION_DES_COULEURS_VERSION_02
#         define    TRANSLATER_LE_NOIR                                                                                                  \
                              TRANSLATER_LE_NOIR_PAR_DEFAUT_DE_IXdisplay                                                                \
                                        /* Indique si le niveau 'NOIR' est translatable dans 'ACCES_LA_PALETTE_ET_TRANSLATION(...)'  */ \
                                        /* ou pas (introduit le 20070712110252).                                                     */
#         define    INCREMENT_DES_NIVEAUX                                                                                               \
                              INCREMENT_DES_NIVEAUX_PAR_DEFAUT_DE_IXdisplay                                                             \
                                        /* Increment destine a decaler circulairement la palette (introduit le 20070712110252).      */
#    Aifdef    ALLOCATION_DES_COULEURS_VERSION_02
#    Eifdef    ALLOCATION_DES_COULEURS_VERSION_02

#    define    ATTENDRE_LES_IMAGES_INEXISTANTES                                                                                         \
                         VRAI                                                                                                           \
                                        /* Indique si les images inexistantes constituent une erreur ('FAUX'), ou bien si cela est   */ \
                                        /* normal ('VRAI'), ce qui signifie qu'elles n'ont pas encore ete calculee...                */

#    define    TEMPORISATION_INTER_ANIMATIONS                                                                                           \
                         ZERO                                                                                                           \
                                        /* Attente implicite avant d'effacer l'image : une valeur nulle correspond a un arret        */ \
                                        /* interactif de l'affichage par appui sur l'une quelconque des trois touches de la          */ \
                                        /* souris, lorsque celle-ci est dans la fenetre de display...                                */

#    define    IL_FAUT_RENORMALISER                                                                                                     \
                         FAUX                                                                                                           \
                                        /* Il ne faut pas renormaliser les images standard par defaut...                             */

#    include   xci/acces.01.I"
                                        /* Introduit le 20070712092453...                                                            */
#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        M A C R O S   U T I L E S  :                                                                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  xci/display.02.I"
#include  xci/signature.11.I"

#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW
#    include   xci/acces.02.I"
                                        /* Introduit le 20070712092453...                                                            */

#    define    CHARGEMENT_DE_L_IMAGE_COURANTE                                                                                           \
                         Bblock                                                                                                         \
                         BSaveModifyVariable(Logical                                                                                    \
                                            ,Iload_image_____initialiser_en_cas_d_erreur_fichier                                        \
                                            ,FAUX                                                                                       \
                                             );                                                                                         \
                                        /* Introduit le 20101118101240 afin que le reaffichage de l'image precedente se passe bien   */ \
                                        /* lorsque l'image courante est inexistante ; ainsi on bloque la reinitialisation et donc    */ \
                                        /* en cas d'erreur d'acces a l'image courante, l'image precedente est conservee...           */ \
                                                                                                                                        \
                         Test(EST_VRAI(IXopen_____mettre_X_Window_en_mode_fausses_couleurs))                                            \
                                        /* Possibilite introduite le 20021231100222.                                                 */ \
                              Bblock                                                                                                    \
                              Test(PAS_D_ERREUR(CODE_ERROR(gIload_image(les_images_sont_standards,ImageA,IFmageA,nom_image))))          \
                                   Bblock                                                                                               \
                                   Test(EST_VRAI(les_images_sont_standards))                                                            \
                                        Bblock                                                                                          \
                                        Test(EST_VRAI(les_images_standards_sont_a_renormaliser))                                        \
                                             Bblock                                                                                     \
                                             CALS(Irenormalisation(ImageA,ImageA));                                                     \
                                             Eblock                                                                                     \
                                        ATes                                                                                            \
                                             Bblock                                                                                     \
                                             Eblock                                                                                     \
                                        ETes                                                                                            \
                                        Eblock                                                                                          \
                                   ATes                                                                                                 \
                                        Bblock                                                                                          \
                                        Test(EST_VRAI(il_faut_calculer_les_extrema_des_images_non_standards))                           \
                                             Bblock                                                                                     \
                                             Test(IL_FAUT(conserver_le_zero))                                                           \
                                                  Bblock                                                                                \
                                                  CALS(Ifloat_std_avec_le_vrai_zero_et_renormalisation(ImageA,IFmageA));                \
                                        /* Renormalisation obligatoire lorsque l'image Argument est deja 'Float' en conservant le    */ \
                                        /* zero.                                                                                     */ \
                                                  Eblock                                                                                \
                                             ATes                                                                                       \
                                                  Bblock                                                                                \
                                                  CALS(Ifloat_std_avec_renormalisation(ImageA,IFmageA));                                \
                                        /* Renormalisation obligatoire lorsque l'image Argument est deja 'Float' en deplacant le     */ \
                                        /* zero.                                                                                     */ \
                                                  Eblock                                                                                \
                                             ETes                                                                                       \
                                             Eblock                                                                                     \
                                        ATes                                                                                            \
                                             Bblock                                                                                     \
                                             Test(IL_FAUT(tronquer_les_niveaux))                                                        \
                                                  Bblock                                                                                \
                                                  CALS(Ifloat_std_avec_troncation(ImageA,IFmageA,FLOT__NOIR,FLOT__BLANC));              \
                                        /* Renormalisation avec forcage des extrema...                                               */ \
                                                  Eblock                                                                                \
                                             ATes                                                                                       \
                                                  Bblock                                                                                \
                                                  CALS(Ifloat_std(ImageA,IFmageA,minimum_force,maximum_force));                         \
                                        /* Renormalisation avec forcage des extrema...                                               */ \
                                                  Eblock                                                                                \
                                             ETes                                                                                       \
                                             Eblock                                                                                     \
                                        ETes                                                                                            \
                                                                                                                                        \
                                        REMONTEE_DU_NIVEAU_DE_NOIR(ImageA,ImageA,niveau_de_NOIR_remonte);                               \
                                        /* Remontee eventuelle du niveau de NOIR...                                                  */ \
                                        Eblock                                                                                          \
                                   ETes                                                                                                 \
                                   Eblock                                                                                               \
                              ATes                                                                                                      \
                                   Bblock                                                                                               \
                                   Eblock                                                                                               \
                              ETes                                                                                                      \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(Image_ROUGE                                                      \
                                                                      ,gNOM_D_UNE_COMPOSANTE(nom_image,nom_imageAR,c_ROUGE)             \
                                                                       )                                                                \
                                                           )                                                                            \
                                                )                                                                                       \
                                   )                                                                                                    \
                                   Bblock                                                                                               \
                                   Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(Image_VERTE                                                 \
                                                                           ,gNOM_D_UNE_COMPOSANTE(nom_image,nom_imageAV,c_VERTE)        \
                                                                            )                                                           \
                                                                )                                                                       \
                                                     )                                                                                  \
                                        )                                                                                               \
                                        Bblock                                                                                          \
                                        Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(Image_BLEUE                                            \
                                                                                ,gNOM_D_UNE_COMPOSANTE(nom_image,nom_imageAB,c_BLEUE)   \
                                                                                 )                                                      \
                                                                     )                                                                  \
                                                          )                                                                             \
                                             )                                                                                          \
                                             Bblock                                                                                     \
                                             CALS(Iluminance(ImageA,Image_ROUGE,Image_VERTE,Image_BLEUE));                              \
                                        /* Au cas ou il serait ensuite impossible de visualiser en vraies couleurs (c'est le cas     */ \
                                        /* si le serveur -par exemple celui de '$LACT14'- ne connait pas 'TrueColor'...). Ainsi      */ \
                                        /* l'image visualisee en 'PseudoColor' sera representative de l'image 'TrueColor'...         */ \
                                             Eblock                                                                                     \
                                        ATes                                                                                            \
                                             Bblock                                                                                     \
                                             Eblock                                                                                     \
                                        ETes                                                                                            \
                                        Eblock                                                                                          \
                                   ATes                                                                                                 \
                                        Bblock                                                                                          \
                                        Eblock                                                                                          \
                                   ETes                                                                                                 \
                                   Eblock                                                                                               \
                              ATes                                                                                                      \
                                   Bblock                                                                                               \
                                   Eblock                                                                                               \
                              ETes                                                                                                      \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                                                                                                                                        \
                         ESaveModifyVariable(Logical                                                                                    \
                                            ,Iload_image_____initialiser_en_cas_d_erreur_fichier                                        \
                                             );                                                                                         \
                         Eblock                                                                                                         \
                                        /* Chargement de l'image courante...                                                         */
#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW

#define   EDITION_FACULTATIVE_DU_NOM_DE_CHAQUE_IMAGE                                                                                    \
                    Bblock                                                                                                              \
                    Test(IL_FAUT(editer_le_nom_des_images))                                                                             \
                         Bblock                                                                                                         \
                         Test(IFEQ(numero_d_image,premiere_image))                                                                      \
                              Bblock                                                                                                    \
                              CALS(Fsauts_de_lignes(UN));                                                                               \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                                                                                                                                        \
                         Test(IL_FAUT(editer_seulement_le_numero_des_images))                                                           \
                              Bblock                                                                                                    \
                              CAL3(Prme1("%s\n",chain_numero_modulo(numero_d_image,nombre_de_chiffres)));                               \
                                        /* Le 20221212115343, 'chain_numero_modulo(...)' a remplace 'chain_numero(...)'...           */ \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              CAL3(Prme1("%s\n",nom_image));                                                                            \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Edition, lorsque cela est demande, du nom de l'image courante...                          */

#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW

#         if   (         (defined(BUG_SYSTEME_SG_X_WINDOW_BACKINGSTORE_1))                                                              \
                )
#              define    ATTENTE_DE_LA_FIN_DE_VISUALISATION                                                                             \
                                   Bblock                                                                                               \
                                   Test(IZLT(temporisation_inter_trames))                                                               \
                                        Bblock                                                                                          \
                                                                                                                                        \
                                        /* ATTENTION, pendant un temps j'ai essaye la sequence suivante ci-apres :                   */ \
                                        /*                                                                                           */ \
                                        /*                  DEFV(processus,Pre_affichage);                                        \  */ \
                                        /*                                      /* descripteur du processus destine au               */ \
                                        /*                                      /* re-affichage de l'image...                        */ \
                                        /*                  PARALLELE(BLOC(Loop                                                   \  */ \
                                        /*                                      Bblock                                            \  */ \
                                        /*                                      CALS(IXattente_de_l_evenement_Expose());          \  */ \
                                        /*                                      CALS(IXdisplay(ImageG));                          \  */ \
                                        /*                                      /* apres chaque remise au premier plan de            */ \
                                        /*                                      /* l'image courante, elle est raffichee...           */ \
                                        /*                                      Eblock                                            \  */ \
                                        /*                                 ELoo                                                   \  */ \
                                        /*                                 )                                                      \  */ \
                                        /*                           ,Pre_affichage                                               \  */ \
                                        /*                            );                                                          \  */ \
                                        /*                                      /* envoi en parallele d'un processus destine         */ \
                                        /*                                      /* a re-afficher l'image lorsqu'elle est             */ \
                                        /*                                      /* remise au premier plan...                         */ \
                                        /*                                                                                           */ \
                                        /* Mais malheureusement, d'une part cela ne marche pas systematiquement, et d'autre part,    */ \
                                        /* lors de l'arret normal du '$xci/display$X' "pere", le "fils", lui, reste actif...         */ \
                                                                                                                                        \
                                        CALS(IXattente_de_l_evenement_ButtonPress());                                                   \
                                        /* Et on attend de nouveau un petit peu, jusqu'a ce que l'on appuie sur l'un des trois       */ \
                                        /* boutons de la souris...                                                                   */ \
                                        Eblock                                                                                          \
                                   ATes                                                                                                 \
                                        Bblock                                                                                          \
                                        DODO(temporisation_inter_trames);                                                               \
                                        /* Et on attend de nouveau un petit peu, pour un temps pre-determine...                      */ \
                                        Eblock                                                                                          \
                                   ETes                                                                                                 \
                                   Eblock                                                                                               \
                                        /* Attente de la fin de visualisation...                                                     */
#         Aif  (         (defined(BUG_SYSTEME_SG_X_WINDOW_BACKINGSTORE_1))                                                              \
                )
#              define    ATTENTE_DE_LA_FIN_DE_VISUALISATION                                                                             \
                                   Bblock                                                                                               \
                                   Test(IZLT(temporisation_inter_trames))                                                               \
                                        Bblock                                                                                          \
                                        CALS(IXattente_de_l_evenement_ButtonPress());                                                   \
                                        /* Et on attend de nouveau un petit peu, jusqu'a ce que l'on appuie sur l'un des trois       */ \
                                        /* boutons de la souris...                                                                   */ \
                                        Eblock                                                                                          \
                                   ATes                                                                                                 \
                                        Bblock                                                                                          \
                                        DODO(temporisation_inter_trames);                                                               \
                                        /* Et on attend de nouveau un petit peu, pour un temps pre-determine...                      */ \
                                        Eblock                                                                                          \
                                   ETes                                                                                                 \
                                   Eblock                                                                                               \
                                        /* Attente de la fin de visualisation...                                                     */
#         Eif  (         (defined(BUG_SYSTEME_SG_X_WINDOW_BACKINGSTORE_1))                                                              \
                )

#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        A F F I C H A G E   D ' U N E   S E Q U E N C E   D ' I M A G E S  :                                                       */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
     DEFV(CHAR,INIC(POINTERc(nom_imageA),NOM_PIPE));
                                        /* Nom de la sequence a visualiser.                                                          */
     DEFV(CHAR,INIC(POINTERc(nom_postfixe),NOM_UNDEF_VIDE));
                                        /* Nom d'un eventuel postfixe a placer derriere <nom_imageA><numero> (par exemple '$ROUGE'). */
     DEFV(Int,INIT(premiere_image,PREMIERE_IMAGE));
                                        /* Numero de la premiere image,                                                              */
     DEFV(Int,INIT(derniere_image,DERNIERE_IMAGE));
                                        /* Numero de la derniere image.                                                              */
     DEFV(Int,INIT(pas_des_images,PAS_DES_IMAGES));
                                        /* Pas de passage d'un numero d'image a une autre.                                           */
     DEFV(Int,INIT(nombre_de_chiffres,NOMBRE_DE_CHIFFRES));
                                        /* Nombre de chiffres codant le numero des images de la serie...                             */
     DEFV(Int,INIT(numero_d_image,UNDEF));
                                        /* Numero de l'image courante.                                                               */
     DEFV(CHAR,INIT(POINTERc(nom_image),NOM_UNDEF));
                                        /* Nom courant des images.                                                                   */
     DEFV(Logical,INIT(editer_le_nom_des_images,EDITER_LE_NOM_DES_IMAGES));
                                        /* Indique si le nom de chacune des images affichees doit etre indique ('VRAI') ou pas       */
                                        /* ('FAUX'), l'edition ayant lieu comme pour un message d'erreur (afin de ne pas perturber   */
                                        /* le "pipe" des images...                                                                   */
     DEFV(Logical,INIT(editer_seulement_le_numero_des_images,EDITER_SEULEMENT_LE_NUMERO_DES_IMAGES));
                                        /* Indique si 'IL_FAUT(editer_le_nom_des_images)' si le nom entier doit etre edite ('FAUX')  */
                                        /* ou seulement le numero ('VRAI').                                                          */

     DEFV(CHAR,INIC(POINTERc(nom_paletteA),NOM_PIPE));
                                        /* Nom de la palette a utiliser.                                                             */

     DEFV(Int,INIT(temporisation_inter_trames,TEMPORISATION_INTER_TRAMES));
                                        /* Temporisation inter_trames ; une valeur nulle fait qu'il n'y a pas d'attente, et une      */
                                        /* valeur negative provoque l'attente sur la souris (ATTENTION, cette convention n'est pas   */
                                        /* celle de '$xci/display$K', car en effet, dans le cas de '$xci/sequence$K', en general on  */
                                        /* ne veut pas attendre apres chaque image, ce qui correspond reellement a une attente       */
                                        /* nulle ; cette convention ne peut donc etre utilisee...). C'est la raison pour laquelle    */
                                        /* 'temporisation_inter_trames' est de type 'Int' et non pas 'Positive'...                   */
     DEFV(Int,INIT(temporisation_inter_animations,TEMPORISATION_INTER_ANIMATIONS));
                                        /* Temporisation inter_animations ; une valeur nulle fait qu'il n'y a pas d'attente...       */
                                        /*                                                                                           */
                                        /* ATTENTION, jusqu'au 19970507160714, cet 'Int' avait le type 'Positive'.                   */
     DEFV(Positive,INIT(nombre_de_repetitions,NOMBRE_DE_REPETITIONS));
                                        /* Nombre implicite de repetitions de l'animation...                                         */

     DEFV(deltaF_2D,dimension_de_la_fenetre);
                                        /* Dimension de la fenetre de visualisation.                                                 */

#include  xci/display.03.I"

#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_SPIX
     DEFV(pointF_2D,coin_haut_gauche);
                                        /* Position du coin haut gauche de la fenetre.                                               */
#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SPIX
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SPIX

#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW
     DEFV(CHAR,INIC(POINTERc(nom_imageAR),NOM_PIPE));
                                        /* Nom de l'image ROUGE a utiliser,                                                          */
     DEFV(CHAR,INIC(POINTERc(nom_imageAV),NOM_PIPE));
                                        /* Nom de l'image VERTE a utiliser,                                                          */
     DEFV(CHAR,INIC(POINTERc(nom_imageAB),NOM_PIPE));
                                        /* Nom de l'image BLEUE a utiliser.                                                          */
     DEFV(Logical,INIT(recuperer_une_image_en_vraies_couleurs,RECUPERER_UNE_IMAGE_EN_VRAIES_COULEURS));
                                        /* Faut-il recuperer une image en vraies couleurs ('VRAI)' c'est-a-dire dont les trois       */
                                        /* composantes ont la meme racine, ou bien trois images "independantes" ('FAUX'). La         */
                                        /* valeur par defaut est choisie pour assurer la compatibilite anterieure. Ceci etant        */
                                        /* lie evidemment a 'EST_FAUX(IXopen_____mettre_X_Window_en_mode_fausses_couleurs)' et       */
                                        /* a ete introduit le 20021231172005.                                                        */
     DEFV(Logical,INIT(attendre_les_images_inexistantes,ATTENDRE_LES_IMAGES_INEXISTANTES));
                                        /* Indique si les images inexistantes constituent une erreur ('FAUX'), ou bien si cela est   */
                                        /* normal ('VRAI'), ce qui signifie qu'elles n'ont pas encore ete calculee...                */

#    ifdef     ALLOCATION_DES_COULEURS_VERSION_02
     DEFV(Logical,INIT(translater_le_NOIR,TRANSLATER_LE_NOIR));
                                        /* Indique si le niveau 'NOIR' est translatable dans 'ACCES_LA_PALETTE_ET_TRANSLATION(...)'  */
                                        /* ou pas (introduit le 20070712110252).                                                     */
     DEFV(Int,INIT(increment_des_niveaux,INCREMENT_DES_NIVEAUX));
                                        /* Increment destine a decaler circulairement la palette (introduit le 20070712110252).      */
#    Aifdef    ALLOCATION_DES_COULEURS_VERSION_02
#    Eifdef    ALLOCATION_DES_COULEURS_VERSION_02

     DEFV(Logical,INIT(changer_la_dimension_de_la_fenetre,CHANGER_LA_DIMENSION_DE_LA_FENETRE));
     DEFV(Float,INIT(X_dimension_de_la_fenetre,X_DIMENSION_DE_LA_FENETRE));
     DEFV(Float,INIT(Y_dimension_de_la_fenetre,Y_DIMENSION_DE_LA_FENETRE));
                                        /* Faut-il redimensionner la fenetre de facon, par exemple, a ce qu'elle soit plus grande    */
                                        /* que l'image ('VRAI)' ou pas ('FAUX'). Ceci a ete introduit le 20030401180401.             */

#    include   xci/acces.03.I"
                                        /* Introduit le 20070712092453...                                                            */
#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW

     /*..............................................................................................................................*/
     EGAL(files_____editer_les_messages_d_erreur_de_lecture_des_fichiers,EDITER_LES_MESSAGES_D_ERREUR);
                                        /* Initialisation de l'indicateur d'edition des messages d'erreur...                         */

#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_SPIX
     INITIALISATION_POINT_2D(coin_haut_gauche,_____cNORMALISE_OX5(X_COIN_HAUT_GAUCHE),_____cNORMALISE_OY5(Y_COIN_HAUT_GAUCHE));
                                        /* Definition de la position implicite de la fenetre.                                        */
     GET_ARGUMENTSi(nombre_d_arguments
                   ,BLOC(GET_ARGUMENT_C("imageA=""A=",nom_imageA);
                         GET_ARGUMENT_C("postfixe=",nom_postfixe);
                         GET_ARGUMENT_C("paletteA=""palette=""pA=""p=",nom_paletteA);
                         GET_ARGUMENT_I("premiere=",premiere_image);
                         GET_ARGUMENT_I("derniere=",derniere_image);
                         GET_ARGUMENT_I("pas=",pas_des_images);
                         GET_ARGUMENT_L("editer=""lister=",editer_le_nom_des_images);
                                        /* Le synonyme "lister=" a ete introduit le 20101205133859...                                */
                         GET_ARGUMENT_L("numero=",editer_seulement_le_numero_des_images);
                         GET_ARGUMENT_I("chiffres=",nombre_de_chiffres);
                         GET_ARGUMENT_I("repetition=""r=",nombre_de_repetitions);
                         GET_ARGUMENT_I("Duree=""D=",temporisation_inter_trames);
                         GET_ARGUMENT_I("duree=""d=",temporisation_inter_animations);
                         GET_ARGUMENT_F("xc=""x=""X=",ASD1(coin_haut_gauche,x));
                         GET_ARGUMENT_F("yc=""y=""Y=",ASD1(coin_haut_gauche,y));

                         GET_ARGUMENT_L("messages_erreur_fichiers=""mef="
                                       ,files_____editer_les_messages_d_erreur_de_lecture_des_fichiers
                                        );
                                        /* Ces arguments ont ete introduits le 20120302212805...                                     */
                         )
                    );
#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SPIX
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SPIX

#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW
     INITIALISATION_POINT_2D(coin_bas_gauche,_____cNORMALISE_OX11(X_COIN_BAS_GAUCHE),_____cNORMALISE_OY11(Y_COIN_BAS_GAUCHE));
                                        /* Definition de la position implicite de la fenetre.                                        */
     EGAL(X11_____signaler_les_evenements_inattendus,SIGNALER_LES_EVENEMENTS_INATTENDUS);
                                        /* Initialisation du signalisateur d'evenement inattendu...                                  */

#    ifdef     ALLOCATION_DES_COULEURS_VERSION_01
     GET_ARGUMENTSi(nombre_d_arguments
                   ,BLOC(GET_ARGUMENT_C("serveur=",serveur_standard);
                         GET_ARGUMENT_L("ne_pas_verifier_le_serveur=""npvs="
                                       ,IXopen_____X_Window_accepter_le_serveur_sans_verification
                                        );
                         GET_ARGUMENT_N("verifier_le_serveur=""vs="
                                       ,IXopen_____X_Window_accepter_le_serveur_sans_verification
                                        );
                                        /* Arguments introduits le 20100109113313 pour acceder au serveur 'Xming' (Windows Vista).   */
                         GET_ARGUMENT_L("attendre=",attendre_les_images_inexistantes);
                         GET_ARGUMENT_L("attention=",editer_les_PRINT_ATTENTION_initiaux);
                         GET_ARGUMENT_L("signaler=",X11_____signaler_les_evenements_inattendus);
                         GET_ARGUMENT_L("trop_grandes=""trop_grande="
                                       ,X11_____tenter_l_ouverture_des_fenetres_trop_grandes_par_rapport_a_l_ecran
                                        );

                         GET_ARGUMENT_C("imageA=""A=",nom_imageA);
                         GET_ARGUMENT_L("standard=",les_images_sont_standards);
                                        /* Parametre introduit le 20070712092453.                                                    */
                         GET_ARGUMENT_C("Rouge=""ROUGE=""AR=",nom_imageAR);
                         GET_ARGUMENT_C("Verte=""VERTE=""AV=",nom_imageAV);
                         GET_ARGUMENT_C("Bleue=""BLEUE=""AB=",nom_imageAB);
                         GET_ARGUMENT_L("RVB=",recuperer_une_image_en_vraies_couleurs);
                         GET_ARGUMENT_L("fc=""fausses_couleurs=",IXopen_____mettre_X_Window_en_mode_fausses_couleurs);
                         GET_ARGUMENT_N("vraies_couleurs=""vc=",IXopen_____mettre_X_Window_en_mode_fausses_couleurs);
                         GET_ARGUMENT_C("postfixe=",nom_postfixe);
                         GET_ARGUMENT_C("paletteA=""palette=""pA=""p=",nom_paletteA);
                         GET_ARGUMENT_I("nombre=""couleurs=",nombre_de_couleurs_necessaires);
                         GET_ARGUMENT_I("premiere=",premiere_image);
                         GET_ARGUMENT_I("derniere=",derniere_image);
                         GET_ARGUMENT_I("pas=",pas_des_images);
                         GET_ARGUMENT_L("editer=",editer_le_nom_des_images);
                         GET_ARGUMENT_L("numero=",editer_seulement_le_numero_des_images);
                         GET_ARGUMENT_I("chiffres=",nombre_de_chiffres);

                         GET_ARGUMENT_L("zero=",conserver_le_zero);
                         GET_ARGUMENT_L("rn=""renormaliser=",les_images_standards_sont_a_renormaliser);
                         GET_ARGUMENT_P("rNOIR=",Ifloat_std_____niveau_NOIR);
                         GET_ARGUMENT_P("rBLANC=",Ifloat_std_____niveau_BLANC);
                         GET_ARGUMENT_L("extrema=",il_faut_calculer_les_extrema_des_images_non_standards);
                         GET_ARGUMENT_L("tronquer=",tronquer_les_niveaux);
                         GET_ARGUMENT_L("NOIR_unique=",Ifloat_std_____seul_le_niveau_minimal_donnera_du_NOIR);
                         GET_ARGUMENT_L("eviter_faux_NOIRs=""eviter=",Ifloat_std_avec_troncation_____eviter_les_faux_points_NOIRs);
                         GET_ARGUMENT_P("noir_remonte=""niveau=""n=""NOIR_remonte=",niveau_de_NOIR_remonte);
                                        /* Parametres introduits le 20070712092453.                                                  */

                         GET_ARGUMENT_L("message_attention_extrema=""mae="
                                       ,Ifloat_std_____editer_le_message_d_attention_relatif_aux_extrema
                                        );
                                        /* Introduit le 20140102175056...                                                            */

                         GET_ARGUMENT_F("minimum=""min=",minimum_force);
                         GET_ARGUMENT_F("maximum=""max=",maximum_force);
                         GET_ARGUMENT_F("epsilon=",Ifloat_std_____epsilon_de_seuillage_inferieur_par_rapport_au_niveau_minimal);
                                        /* Parametres introduits le 20070712092453.                                                  */

                         GET_ARGUMENT_I("repetition=""r=",nombre_de_repetitions);
                         GET_ARGUMENT_I("Duree=""D=",temporisation_inter_trames);
                         GET_ARGUMENT_I("duree=""d=",temporisation_inter_animations);
                         GET_ARGUMENT_L("Fdimension=""Fd=",changer_la_dimension_de_la_fenetre);
                         GET_ARGUMENT_F("FXdimension=""FX=",X_dimension_de_la_fenetre);
                         GET_ARGUMENT_F("FYdimension=""FY=",Y_dimension_de_la_fenetre);
                         GET_ARGUMENT_L("centrer=""Fcentrer=""Fc=",centrer_la_fenetre);
                                        /* Parametre introduit le 20060427162740...                                                  */
                         GET_ARGUMENT_F("xc=""x=""X=",ASD1(coin_bas_gauche,x));
                         GET_ARGUMENT_F("yc=""y=""Y=",ASD1(coin_bas_gauche,y));
                         GET_ARGUMENT_C("substitution=""s=",nom_substitution);

                         GET_ARGUMENT_L("messages_erreur_fichiers=""mef="
                                       ,files_____editer_les_messages_d_erreur_de_lecture_des_fichiers
                                        );
                                        /* Ces arguments ont ete introduits le 20120302212805...                                     */
                         )
                    );
#    Aifdef    ALLOCATION_DES_COULEURS_VERSION_01
#    Eifdef    ALLOCATION_DES_COULEURS_VERSION_01

#    ifdef     ALLOCATION_DES_COULEURS_VERSION_02
     GET_ARGUMENTSi(nombre_d_arguments
                   ,BLOC(GET_ARGUMENT_C("serveur=",serveur_standard);
                         GET_ARGUMENT_L("ne_pas_verifier_le_serveur=""npvs="
                                       ,IXopen_____X_Window_accepter_le_serveur_sans_verification
                                        );
                         GET_ARGUMENT_N("verifier_le_serveur=""vs="
                                       ,IXopen_____X_Window_accepter_le_serveur_sans_verification
                                        );
                                        /* Arguments introduits le 20100109113313 pour acceder au serveur 'Xming' (Windows Vista).   */
                         GET_ARGUMENT_L("attendre=",attendre_les_images_inexistantes);
                         GET_ARGUMENT_L("attention=",editer_les_PRINT_ATTENTION_initiaux);
                         GET_ARGUMENT_L("signaler=",X11_____signaler_les_evenements_inattendus);
                         GET_ARGUMENT_L("trop_grandes=""trop_grande="
                                       ,X11_____tenter_l_ouverture_des_fenetres_trop_grandes_par_rapport_a_l_ecran
                                        );

                         GET_ARGUMENT_C("imageA=""A=",nom_imageA);
                         GET_ARGUMENT_L("standard=",les_images_sont_standards);
                                        /* Parametre introduit le 20070712092453.                                                    */
                         GET_ARGUMENT_C("Rouge=""ROUGE=""AR=",nom_imageAR);
                         GET_ARGUMENT_C("Verte=""VERTE=""AV=",nom_imageAV);
                         GET_ARGUMENT_C("Bleue=""BLEUE=""AB=",nom_imageAB);
                         GET_ARGUMENT_L("RVB=",recuperer_une_image_en_vraies_couleurs);
                         GET_ARGUMENT_L("fc=""fausses_couleurs=",IXopen_____mettre_X_Window_en_mode_fausses_couleurs);
                         GET_ARGUMENT_N("vraies_couleurs=""vc=",IXopen_____mettre_X_Window_en_mode_fausses_couleurs);
                         GET_ARGUMENT_C("postfixe=",nom_postfixe);
                         GET_ARGUMENT_C("paletteA=""palette=""pA=""p=",nom_paletteA);
                         GET_ARGUMENT_L("translater_le_NOIR=""noir=""NOIR=",translater_le_NOIR);
                         GET_ARGUMENT_I("increment=""i=",increment_des_niveaux);
                                        /* Parametres introduits le 20070712092453.                                                  */
                         GET_ARGUMENT_I("nombre=""couleurs=",nombre_de_couleurs_necessaires);
                         GET_ARGUMENT_I("premiere=",premiere_image);
                         GET_ARGUMENT_I("derniere=",derniere_image);
                         GET_ARGUMENT_I("pas=",pas_des_images);
                         GET_ARGUMENT_L("editer=",editer_le_nom_des_images);
                         GET_ARGUMENT_L("numero=",editer_seulement_le_numero_des_images);
                         GET_ARGUMENT_I("chiffres=",nombre_de_chiffres);

                         GET_ARGUMENT_L("zero=",conserver_le_zero);
                         GET_ARGUMENT_L("rn=""renormaliser=",les_images_standards_sont_a_renormaliser);
                         GET_ARGUMENT_P("rNOIR=",Ifloat_std_____niveau_NOIR);
                         GET_ARGUMENT_P("rBLANC=",Ifloat_std_____niveau_BLANC);
                         GET_ARGUMENT_L("extrema=",il_faut_calculer_les_extrema_des_images_non_standards);
                         GET_ARGUMENT_L("tronquer=",tronquer_les_niveaux);
                         GET_ARGUMENT_L("NOIR_unique=",Ifloat_std_____seul_le_niveau_minimal_donnera_du_NOIR);
                         GET_ARGUMENT_L("eviter_faux_NOIRs=""eviter=",Ifloat_std_avec_troncation_____eviter_les_faux_points_NOIRs);
                         GET_ARGUMENT_P("noir_remonte=""niveau=""n=""NOIR_remonte=",niveau_de_NOIR_remonte);
                                        /* Parametres introduits le 20070712092453.                                                  */

                         GET_ARGUMENT_L("message_attention_extrema=""mae="
                                       ,Ifloat_std_____editer_le_message_d_attention_relatif_aux_extrema
                                        );
                                        /* Introduit le 20140102175056...                                                            */

                         GET_ARGUMENT_F("minimum=""min=",minimum_force);
                         GET_ARGUMENT_F("maximum=""max=",maximum_force);
                         GET_ARGUMENT_F("epsilon=",Ifloat_std_____epsilon_de_seuillage_inferieur_par_rapport_au_niveau_minimal);
                                        /* Parametres introduits le 20070712092453.                                                  */

                         GET_ARGUMENT_I("repetition=""r=",nombre_de_repetitions);
                         GET_ARGUMENT_I("Duree=""D=",temporisation_inter_trames);
                         GET_ARGUMENT_I("duree=""d=",temporisation_inter_animations);
                         GET_ARGUMENT_L("Fdimension=""Fd=",changer_la_dimension_de_la_fenetre);
                         GET_ARGUMENT_F("FXdimension=""FX=",X_dimension_de_la_fenetre);
                         GET_ARGUMENT_F("FYdimension=""FY=",Y_dimension_de_la_fenetre);
                         GET_ARGUMENT_L("centrer=""Fcentrer=""Fc=",centrer_la_fenetre);
                                        /* Parametre introduit le 20060427162740...                                                  */
                         GET_ARGUMENT_F("xc=""x=""X=",ASD1(coin_bas_gauche,x));
                         GET_ARGUMENT_F("yc=""y=""Y=",ASD1(coin_bas_gauche,y));
                         GET_ARGUMENT_C("substitution=""s=",nom_substitution);

                         GET_ARGUMENT_L("messages_erreur_fichiers=""mef="
                                       ,files_____editer_les_messages_d_erreur_de_lecture_des_fichiers
                                        );
                                        /* Ces arguments ont ete introduits le 20120302212805...                                     */
                         )
                    );
#    Aifdef    ALLOCATION_DES_COULEURS_VERSION_02
#    Eifdef    ALLOCATION_DES_COULEURS_VERSION_02

#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW

#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_SPIX
     CHARGEMENT_DE_LA_PALETTE_DE_COULEURS;
                                        /* Chargement des trois listes de substitution constitutive d'une palette.                   */

     INITIALISATION_ACCROISSEMENT_2D(dimension_de_la_fenetre,_____lNORMALISE_OX5(dimX5),_____lNORMALISE_OY5(dimY5));
                                        /* Definition des dimensions de la fenetre.                                                  */

     CALS(IDopen(nom_imageA,ADRESSE(dimension_de_la_fenetre),ADRESSE(coin_haut_gauche)));

     Repe(nombre_de_repetitions)
          Bblock
          DoQu(numero_d_image,premiere_image,derniere_image,pas_des_images)
               Bblock
               EGAL(nom_image
                   ,COND(IFEQ_chaine(nom_postfixe,NOM_UNDEF_VIDE)
                        ,chain_Aconcaten2_sauf_nom_pipe(nom_imageA
                                                       ,chain_numero_modulo(numero_d_image,nombre_de_chiffres)
                                                        )
                        ,chain_Aconcaten3_sauf_nom_pipe(nom_imageA
                                                       ,chain_numero_modulo(numero_d_image,nombre_de_chiffres)
                                                       ,nom_postfixe
                                                        )
                         )
                    );
                                        /* Le 20221212115343, 'chain_numero_modulo(...)' a remplace 'chain_numero(...)'...           */

               Test(PAS_D_ERREUR(CODE_ERROR(Iload_image(ImageA,nom_image))))
                                        /* ATTENTION, on ne peut utiliser 'Iload_image_avec_redimensionnement_eventuel(...)' ici     */
                                        /* de facon simple, car, en effet, l'ouverture de la fenetre a lieu avant le chargement      */
                                        /* individuel des images. La dimension ne peut donc plus etre changee par la suite...        */
                                        /*                                                                                           */
                                        /* Enfin, 'Iload_image_avec_redimensionnement_eventuel(...)' est actuellement inutilisable   */
                                        /* pour des raisons detaillees dans 'v $xiii/files$FON'.                                     */
                    Bblock
                    CALS(IDdisplay(ImageA));
                                        /* Puis, lorsqu'elle est la, on l'affiche...                                                 */
                    EDITION_FACULTATIVE_DU_NOM_DE_CHAQUE_IMAGE;
                                        /* Edition, lorsque cela est demande, du nom de l'image courante lorsqu'elle existe...       */
                                        /* ATTENTION, on notera que 'EDITION_FACULTATIVE_DU_NOM_DE_CHAQUE_IMAGE' est situee apres    */
                                        /* l'appel a 'IDdisplay(...)' ce qui fait que le nom de l'image est edite apres, lorsque     */
                                        /* l'affichage est termine. Cela permet, par exemple, d'envoyer, via le reseau, des          */
                                        /* sequences d'images "en aveugle" et de simultanement les commenter par telephone...        */

                    DODO(temporisation_inter_trames);
                    Eblock
               ATes
                    Bblock
                    gTest__CODE_ERREUR__ERREUR07
                        (BLOC(Bblock
                              PRINT_ATTENTION("la fin de flot a ete rencontree lors du chargement d'une 'image'");
                              Eblock
                              )
                        ,BLOC(Bblock
                              Test(IL_FAUT(files_____editer_les_messages_d_erreur_de_lecture_des_fichiers))
                                   Bblock
                                   PRINT_ERREUR("le fichier demande n'existe pas ou n'est pas de type 'image'");
                                   Eblock
                              ATes
                                   Bblock
                                   Eblock
                              ETes
                              Eblock
                              )
                         );
                    Eblock
               ETes
               CALZ_FreCC(nom_image);
               Eblock
          EDoI
          DODO(temporisation_inter_animations);
          Eblock
     ERep

     CALS(IDclose());
#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SPIX
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_SPIX

#ifdef    __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW
     Test(IL_FAUT(changer_la_dimension_de_la_fenetre))
                                        /* Ce test a ete introduit le 20030401180401.                                                */
          Bblock
          INITIALISATION_ACCROISSEMENT_2D(dimension_de_la_fenetre
                                         ,X_dimension_de_la_fenetre
                                         ,Y_dimension_de_la_fenetre
                                          );
                                        /* Definition des dimensions arbitraire pour la fenetre.                                     */
          Eblock
     ATes
          Bblock
          INITIALISATION_ACCROISSEMENT_2D(dimension_de_la_fenetre
                                         ,_____lNORMALISE_OX11(dimX11)
                                         ,_____lNORMALISE_OY11(dimY11)
                                          );
                                        /* Definition des dimensions de la fenetre tel qu'une image y tienne juste...                */
          Eblock
     ETes

     Test(EST_VRAI(IXopen_____mettre_X_Window_en_mode_fausses_couleurs))
                                        /* Possibilite introduite le 20021231100222.                                                 */
          Bblock
          RECHERCHE_D_UNE_LISTE_DE_SUBSTITUTION(nom_substitution,substitution_courante,substitution_courante);
                                        /* Tentative de recherche de la substitution demandee...                                     */
          CHARGEMENT_DE_LA_PALETTE_DE_COULEURS;
                                        /* Chargement des trois listes de substitution constitutive d'une palette.                   */

          Test(IFEQ(substitution_courante,L_SUBSTITUTION_VARIABLE))
               Bblock
               CALS(Icompactage_d_une_palette(nombre_de_couleurs_necessaires));
                                        /* Pour la substitution 'VARIABLE', on procede a un compactage de la palette Argument.       */
               Eblock
          ATes
               Bblock
               Eblock
          ETes

          Test(IFNE(substitution_courante,L_SUBSTITUTION_NEUTRE))
               Bblock
               SUBSTITUTION(substitution_courante);
                                        /* Positionnement de la substitution courante quelqu'elle soit (mais non 'NEUTRE'...).       */
               SET_FILTRAGE(ACTIF);
                                        /* Et on active le filtrage...                                                               */
               Eblock
          ATes
               Bblock
               Eblock
          ETes
          Eblock
     ATes
          Bblock
          Eblock
     ETes

     CALS(IXinitialisation());
                                        /* Initialisation fondamentale introduite le 20160815122159...                               */
     CALS(IXopen(serveur_standard
                ,nom_imageA
                ,ADRESSE(dimension_de_la_fenetre)
                ,centrer_la_fenetre
                ,ADRESSE(coin_bas_gauche)
                ,editer_les_PRINT_ATTENTION_initiaux
                 )
          );

#    ifdef     ALLOCATION_DES_COULEURS_VERSION_02
     Test(EST_VRAI(IXopen_____X_Window_a_ete_mis_en_mode_fausses_couleurs))
          Bblock
          Test(IZNE(increment_des_niveaux))
               Bblock
               CALS(IXpalette(increment_des_niveaux,translater_le_NOIR));
                                        /* Renvoi de la palette translatee circulairement (introduit le 20070712110252)...           */
               Eblock
          ATes
               Bblock
               Eblock
          ETes
          Eblock
     ATes
          Bblock
          Eblock
     ETes
#    Aifdef    ALLOCATION_DES_COULEURS_VERSION_02
#    Eifdef    ALLOCATION_DES_COULEURS_VERSION_02

     Repe(nombre_de_repetitions)
          Bblock
          DoQu(numero_d_image,premiere_image,derniere_image,pas_des_images)
               Bblock
               EGAL(nom_image
                   ,COND(IFEQ_chaine(nom_postfixe,NOM_UNDEF_VIDE)
                        ,chain_Aconcaten2_sauf_nom_pipe(nom_imageA
                                                       ,chain_numero_modulo(numero_d_image,nombre_de_chiffres)
                                                        )
                        ,chain_Aconcaten3_sauf_nom_pipe(nom_imageA
                                                       ,chain_numero_modulo(numero_d_image,nombre_de_chiffres)
                                                       ,nom_postfixe
                                                        )
                         )
                    );
                                        /* Le 20221212115343, 'chain_numero_modulo(...)' a remplace 'chain_numero(...)'...           */

               Test(IL_FAUT(attendre_les_images_inexistantes))
                    Bblock
                    DEFV(Logical,INIT(iterer_le_chargement,VRAI));
                                        /* Pour faire un chargement reussi pour chaque image...                                      */

                    Tant(IL_FAUT(iterer_le_chargement))
                         Bblock
                         CHARGEMENT_DE_L_IMAGE_COURANTE;

                         Test(PAS_D_ERREUR(CODE_ERREUR))
                              Bblock
                              EGAL(iterer_le_chargement,FAUX);
                                        /* L'image courante existe...                                                                */
                              Eblock
                         ATes
                              Bblock
                              Test(IFGT(numero_d_image,premiere_image))
                                   Bblock
                                   CALS(IXdisplay_avec_reinitialisation_du_reaffichage(ImageA
                                                                                      ,Image_ROUGE,Image_VERTE,Image_BLEUE
                                                                                      ,increment_des_niveaux
                                                                                      ,translater_le_NOIR
                                                                                       )
                                        );
                                        /* Le 20101118100139 fut introduit le reaffichage a priori de l'image precedente afin de     */
                                        /* compenser l'absence de 'IXattente_de_l_evenement_ButtonPress(...)' qui fait qu'alors      */
                                        /* cette image peut ne pas etre raffraichie a cause du jeu du "basculement" des fenetres...  */
                                   Eblock
                              ATes
                                   Bblock
                                   Eblock
                              ETes

                              DODO(UN);
                                        /* Tant que l'image courante n'existe pas, on l'attend gentiment. Le 20101118100139          */
                                        /* l'attente a ete reduite de 'DEUX' a 'UN' afin de faciliter le reaffichage frequent        */
                                        /* de l'image precedente ci-dessus par IXdisplay_avec_reinitialisation_du_reaffichage(...)'. */
                              Eblock
                         ETes
                         Eblock
                    ETan

                    CALS(IXdisplay_avec_reinitialisation_du_reaffichage(ImageA
                                                                       ,Image_ROUGE,Image_VERTE,Image_BLEUE
                                                                       ,increment_des_niveaux
                                                                       ,translater_le_NOIR
                                                                        )
                         );
                                        /* Puis, lorsqu'elle est la, on l'affiche. L'affichage en vraies couleurs a ete introduit    */
                                        /* le 20030101172438.                                                                        */
                                        /*                                                                                           */
                                        /* Le 20101118083802, la fonction 'IXdisplay_avec_reinitialisation_du_reaffichage(...)'      */
                                        /* a remplacee 'IXdisplay(...)'.                                                             */

                    EDITION_FACULTATIVE_DU_NOM_DE_CHAQUE_IMAGE;
                                        /* Edition, lorsque cela est demande, du nom de l'image courante lorsqu'elle existe...       */
                                        /* ATTENTION, on notera que 'EDITION_FACULTATIVE_DU_NOM_DE_CHAQUE_IMAGE' est situee apres    */
                                        /* l'appel a 'IXdisplay(...)' ce qui fait que le nom de l'image est edite apres, lorsque     */
                                        /* l'affichage est termine. Cela permet, par exemple, d'envoyer, via le reseau, des          */
                                        /* sequences d'images "en aveugle" et de simultanement les commenter par telephone...        */

                    ATTENTE_DE_LA_FIN_DE_VISUALISATION;
                    Eblock
               ATes
                    Bblock
                    CHARGEMENT_DE_L_IMAGE_COURANTE;

                    Test(PAS_D_ERREUR(CODE_ERREUR))
                         Bblock
                         CALS(IXdisplay_avec_reinitialisation_du_reaffichage(ImageA
                                                                            ,Image_ROUGE,Image_VERTE,Image_BLEUE
                                                                            ,increment_des_niveaux
                                                                            ,translater_le_NOIR
                                                                             )
                              );
                                        /* Dans ce cas, l'image courante doit exister, sinon, c'est une erreur. L'affichage en       */
                                        /* vraies couleurs a ete introduit le 20030101172438.                                        */
                                        /*                                                                                           */
                                        /* Le 20101118083802, la fonction 'IXdisplay_avec_reinitialisation_du_reaffichage(...)'      */
                                        /* a remplacee 'IXdisplay(...)'.                                                             */

                         EDITION_FACULTATIVE_DU_NOM_DE_CHAQUE_IMAGE;
                                        /* Edition, lorsque cela est demande, du nom de l'image courante lorsqu'elle existe...       */
                                        /* ATTENTION, on notera que 'EDITION_FACULTATIVE_DU_NOM_DE_CHAQUE_IMAGE' est situee apres    */
                                        /* l'appel a 'IXdisplay(...)' ce qui fait que le nom de l'image est edite apres, lorsque     */
                                        /* l'affichage est termine. Cela permet, par exemple, d'envoyer, via le reseau, des          */
                                        /* sequences d'images "en aveugle" et de simultanement les commenter par telephone...        */

                         ATTENTE_DE_LA_FIN_DE_VISUALISATION;
                         Eblock
                    ATes
                         Bblock
                         gTest__CODE_ERREUR__ERREUR07
                             (BLOC(Bblock
                                   PRINT_ATTENTION("la fin de flot a ete rencontree lors du chargement d'une 'image'");
                                   Eblock
                                   )
                             ,BLOC(Bblock
                                   Test(IL_FAUT(files_____editer_les_messages_d_erreur_de_lecture_des_fichiers))
                                        Bblock
                                        PRINT_ERREUR("le fichier demande n'existe pas ou n'est pas de type 'image'");
                                        Eblock
                                   ATes
                                        Bblock
                                        Eblock
                                   ETes
                                   Eblock
                                   )
                              );
                         Eblock
                    ETes
                    Eblock
               ETes

               CALZ_FreCC(nom_image);
               Eblock
          EDoI

          Test(IFET(IZEQ(temporisation_inter_animations),IFEQ(compteur_des_repetitions_du_Repe,nombre_de_repetitions)))
               Bblock
               Test(IZLT(temporisation_inter_trames))
                    Bblock
                                        /* ATTENTION, sur la derniere image de la sequence, lorsque 'temporisation_inter_trames' est */
                                        /* negatif, il y a dans 'ATTENTE_DE_LA_FIN_DE_VISUALISATION' une premiere attente via la     */
                                        /* fonction 'IXattente_de_l_evenement_ButtonPress()' ; dans ces circonstances, il est donc   */
                                        /* inutile d'en faire une seconde ici...                                                     */
                    Eblock
               ATes
                    Bblock
                    CALS(IXattente_de_l_evenement_ButtonPress());
                                        /* Boutons de la souris, mais ATTENTION uniquement sur la derniere repetition de la          */
                                        /* sequence et lorsque cela a ete demande...                                                 */
                    Eblock
               ETes
               Eblock
          ATes
               Bblock
               DODO(temporisation_inter_animations);
                                        /* Et on attend de nouveau un petit peu, pour un temps pre-determine...                      */
               Eblock
          ETes
          Eblock
     ERep

     CALS(IXclose());

     Test(IFNE(substitution_courante,L_SUBSTITUTION_NEUTRE))
          Bblock
          SET_FILTRAGE(INACTIF);
          SUBSTITUTION(L_SUBSTITUTION_NEUTRE);
          Eblock
     ATes
          Bblock
          Eblock
     ETes
#Aifdef   __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW
#Eifdef   __VERSION__COMPILER_LE_GRAPHIQUE_X_WINDOW

     RETU_Commande;
     Eblock
ECommande



Copyright © Jean-François COLONNA, 2019-2024.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / École polytechnique, Institut Polytechnique de Paris, 2019-2024.