
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL  : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.

/************************************************************************
 *     DATE:        23/01/97                                            *
 *                                                                $     *
 *     AUTEUR:      G RIO   (mailto:gerardrio56@free.fr)                *
 *                                                                $     *
 *     PROJET:      Herezh++                                            *
 *                                                                $     *
 ************************************************************************
 *     BUT:  Maillon de base d'un ordre de visualisation interactive.   *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/
#ifndef ORDREVISU_T
#define ORDREVISU_T

#include <iostream>
#include "string"

#include "ParaGlob.h"
#include "LesMaillages.h"
#include "LesReferences.h"
#include "LesLoisDeComp.h"
#include "DiversStockage.h"
#include "Charge.h"
#include "LesCondLim.h"
#include "LesContacts.h"
#include "Resultats.h"

/// @addtogroup Les_sorties_generiques
///  @{
///


class OrdreVisu  
{
  public :
     enum EnumTypeIncre {INCRE_0=0,PREMIER_INCRE,INCRE_COURANT,DERNIER_INCRE};
     // Retourne le nom d'un type d'increment a partir de son identificateur de
     // type enumere id_TypeIncre correspondant
     string Nom_TypeIncre (const OrdreVisu::EnumTypeIncre id_TypeIncre);
     // Retourne l'identificateur de type enumere associe au nom du type d'increment
     EnumTypeIncre Id_nom_TypeIncre (const string nom_TypeIncre);
     
     class Deuxentiers {public: int mail;int incr;}; // un conteneur de travail
     
    // CONSTRUCTEURS :
     // par defaut
     OrdreVisu () ; 
     // permettant la définition de l'affichage
     // l'ordre doit être en minuscule
     OrdreVisu(const string& comment_som, const string& explication, const string& ordre);
     
     // constructeur de copie 
     OrdreVisu (const OrdreVisu& ord);
               
    // DESTRUCTEUR :
    virtual  ~OrdreVisu () ;  
    
    // METHODES PUBLIQUES :
    // affichage de l'ordre
    void Affiche_ordre();
    // affichage de l'explication détaillée
    void Explication_detaillee();
    
    // initialisation : permet d'initialiser les différents paramètres de l'ordre
    // lors d'un premier passage des différents incréments
    // en virtuelle, a priori est défini si nécessaire dans les classes dérivées
    // incre : numéro d'incrément qui en cours
    virtual void Initialisation(ParaGlob * ,LesMaillages *,LesReferences*
                      ,LesLoisDeComp* ,DiversStockage*,Charge*,LesCondLim*,LesContacts*
                      ,Resultats*,EnumTypeIncre type_incre,int incre
                      ,const map < string, const double * , std::less <string> >& listeVarGlob
                      ,const List_io < TypeQuelconque >& listeVecGlob
                      ,bool fil_calcul) ;
    
    // execution de l'ordre
    // en virtuelle, a priori est défini dans les classes dérivées
    // tab_mail : donne les numéros de maillage concerné
    // incre : numéro d'incrément qui en cours
    // type_incre : indique si c'est le premier le dernier ou l'incrément courant a visualiser ou pas
    // animation : indique si l'on est en animation ou pas
    // unseul_incre : indique si oui ou non il y a un seul increment à visualiser
    virtual void ExeOrdre(ParaGlob * ,const Tableau <int>& tab_mail ,LesMaillages *,bool unseul_incre, LesReferences*
                      ,LesLoisDeComp* ,DiversStockage*,Charge*,LesCondLim*,LesContacts*
                      ,Resultats*,UtilLecture & entreePrinc,OrdreVisu::EnumTypeIncre type_incre,int incre
                      ,bool animation,const map < string, const double * , std::less <string> >& listeVarGlob
                      ,const List_io < TypeQuelconque >& listeVecGlob);
    // retour vrai  si l'ordre proposée est celui de l'instance
    bool OrdreVrai(const string& ord);
    // choix de l'ordre, cet méthode peut entraîner la demande d'informations
    // supplémentaires si nécessaire. qui sont ensuite gérer par la classe elle même
    virtual void ChoixOrdre(); 
    // renseigne si l'ordre est activé ou pas
    bool Actif()  const {return actif;}; 
    // inactive l'ordre
    void Inactive_ordre() {actif = false;}; 
    
    // lecture des paramètres de l'ordre dans un flux
    virtual void Lecture_parametres_OrdreVisu(UtilLecture & entreePrinc);
    // écriture des paramètres de l'ordre dans un flux
    virtual void Ecriture_parametres_OrdreVisu(UtilLecture & entreePrinc);
    
    
  protected :  
    // VARIABLES PROTEGEES :
    string commentaire_sommaire;
    string explication_detail;
    string ordre; // doit être en minuscule
    bool actif; // ordre actif ou pas
    
   
    // *** les déclarations suivantes pourraient être modifiée en créant une liaison entre 
    // *** animation et déformation, de la même manière qu'avec les isovaleurs !!!
    // *** dans le cas de l'animation : définition des listes de positions et de nom si rattachant
    static list <string> list_nom_coordinate;
    static list < list <Coordonnee> >  list_coordinate;
    static string nom_base_couleur; // utilisé dans déformée

    
    // METHODES PROTEGEES :
    // ordonne une liste, supprime les doublons et finalement l'affiche à l'écran
    void Propre_liste(list<int>& lis);
    // mise a zéro des lists de coordonnées
    void Mise_zero_coordo();
    // -- les deux méthodes suivantes sont utilisées par les ordres dérivées
    // lecture des paramètres de l'ordre général dans un flux
    void Lect_para_OrdreVisu_general(UtilLecture & entreePrinc);
    // écriture des paramètres de l'ordre dans un flux
    void Ecrit_para_OrdreVisu_general(UtilLecture & entreePrinc);
	 // changement des strings (cas d'un changement de langue par exemple)
	 void changeLibelle(const string& comment_som, const string& explication, const string& ord)
	   {commentaire_sommaire=comment_som;explication_detail=explication;ordre = ord;};
      

 };
 /// @}  // end of group

#endif  
