
// 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/>.

#include "Frontiere_initiale.h"

#include <iomanip>
#include "CharUtil.h"
#include <limits>

    // CONSTRUCTEURS :
// par defaut
Frontiere_initiale::Frontiere_initiale () :
   OrdreVisu("..............................frontieres initiales"
             ,"visualisation des frontieres initiales","fri")
   ,filaire(true),surface(true),numero(false)
   ,Rcoull(.425),Gcoull(0.0),Bcoull(.425)
   ,Rcoulf(1.0),Gcoulf(0.0),Bcoulf(1.0)
   ,Rcouln(1.0),Gcouln(1.0),Bcouln(0.0)
   ,taille_numero(0.2)
     {}; 
     
     // constructeur de copie 
Frontiere_initiale::Frontiere_initiale (const Frontiere_initiale& ord) :
    OrdreVisu(ord),filaire(ord.filaire) 
   ,surface(ord.surface),numero(ord.numero)
   ,Rcoull(ord.Rcoull),Gcoull(ord.Gcoull),Bcoull(ord.Bcoull)
   ,Rcoulf(ord.Rcoulf),Gcoulf(ord.Gcoulf),Bcoulf(ord.Bcoulf)
   ,Rcouln(ord.Rcouln),Gcouln(ord.Gcouln),Bcouln(ord.Bcouln)
   ,taille_numero(ord.taille_numero)
      {};
               
    // DESTRUCTEUR :
Frontiere_initiale::~Frontiere_initiale () 
     {};  
    
    // METHODES PUBLIQUES :
// execution de l'ordre
// 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
void Frontiere_initiale::ExeOrdre(ParaGlob * ,const Tableau <int>& ,LesMaillages * ,bool ,LesReferences*
                      ,LesLoisDeComp* ,DiversStockage*,Charge*,LesCondLim*
//                      ,LesContacts*,Resultats*,ostream & sort,EnumTypeIncre type_incre,int incre
                      ,LesContacts*,Resultats*,UtilLecture & entreePrinc,OrdreVisu::EnumTypeIncre ,int incre
//                      ,bool animation)
                      ,bool ,const map < string, const double * , std::less <string> >&
                      ,const List_io < TypeQuelconque >& listeVecGlob)
 {ostream &sort = entreePrinc.Sort_princ_vrml();
  // visualisation du maillage pointé si actif
  if ((actif)&&(incre==0))
  { cout << "\n *** ordre actuellement non defini *** "
         << "\n Frontiere_initiale::ExeOrdre( .... " << endl;
   }                          
 };

// 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
void Frontiere_initiale::ChoixOrdre()
   {// demande de précision
    bool choix_valide = false;
    cout << "\n ----> préparation de la visualisation des frontieres initiales"
         << "\n  paramètre par défaut ? : affichage en filaire, couleur magenta,"
         << "\n                           et  affichage des facettes, couleur violet,"
         << " \n                          pas d'affichage de numéros. "
         << "   (rep 'o' ou 'f') pour accepter ces paramètres sinon autre ";
   string rep;
   cout << "\n reponse ? "; rep = lect_return_defaut(true,"o");
   if (rep != "o") 
    {// cas d'un choix autre que standart
     while (!choix_valide)
      {
       try 
        { 
          cout 
          << "\n (0) fin modif"
          << "\n (1) en fillaire?                       (2) affichage des facettes ?  "
          << "\n (3) affichage des numéros ?            (4) couleur pour le filaire "
          << "\n (5) couleur pour les facettes          (6) couleur pour les numeros";
          cout << "\n \n reponse ? ";
          rep = lect_return_defaut(false,"0");
          if (rep == "fin_prog") Sortie(1);
          // sinon
          int num = ChangeEntier(rep);
          if (num == 0) choix_valide=true;
          else if ((num >= 1)&&(num<=6)) 
           { choix_valide=false;
             switch (num)
              { case 1:  //"en filaire")
                { cout << "\n en fillaire (par defaut rep 'o') "
                       << "ou pas de filaire (rep autre) ? "; 
                  rep = lect_return_defaut(true,"o");
                  if (rep!= "o") filaire = false;
                  else           filaire = true;
                  break;}
                case 2:  // "affichage des facettes ?")
                { cout << "\n affichage des facettes (par defaut rep 'o') "
                       << "ou pas de facette (rep autre) ? ";
                  rep = lect_return_defaut(true,"o");
                  if (rep!= "o")  surface = false;
                  else            surface = true;
                  break;}
                case 3:  // "affichage des numéros ?")
                { cout << "\n affichage des numéros (non par defaut  rep 'o') "
                       << "ou on veut l'affichage des numéros (rep autre) ? "; 
                  rep = lect_return_defaut(true,"o");
                  if (rep!= "o")  numero = true;
                  else            numero = false;
                  break;}
                case 4:  // "couleur pour le filaire?")
                { cout << "\n couleur pour le filaire au standard RGB : par defaut mgenta (rep 'o') ";
                  rep = lect_return_defaut(true,"o");
                  if (rep != "o")
                   { cout << "\n couleur au standard RGB (trois réels entre 0 et 1) ?  ";
                     double Rco,Gco,Bco;
                     cin >> Rco >> Gco >> Bco;
                     std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
                     if ((Rco <= 1.)&& (Rco >= 0) && (Gco <= 1.)&& (Gco >= 0)
                          &&(Bco <= 1.)&& (Bco >= 0))
                       { Rcoull = Rco; Gcoull = Gco; Bcoull = Bco;
                        }
                     else
                       { cout << " \n *****choix non valide de couleur**** ";
                        }
                    }
                  else
                    { Rcoull = .425; Gcoull = 0.; Bcoull = .425;
                      }    
                  break;}
                case 5:  // "couleur pour les facettes")
                { cout << "\n couleur au standard RGB pour les facettes : par defaut violet (rep 'o') ";
                  rep = lect_return_defaut(false,"o");;
                  if (rep != "o")
                   { cout << "\n couleur au standard RGB (trois réels entre 0 et 1) ?  ";
                     double Rco,Gco,Bco;
                     cin >> Rco >> Gco >> Bco;
                     std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
                     if ((Rco <= 1.)&& (Rco >= 0) && (Gco <= 1.)&& (Gco >= 0)
                          &&(Bco <= 1.)&& (Bco >= 0))
                       { Rcoulf = Rco; Gcoulf = Gco; Bcoulf = Bco;
                        }
                     else
                       { cout << " \n *****choix non valide de couleur**** ";
                        }
                    }
                  else
                    { Rcoulf = 1; Gcoulf = 0; Bcoulf = 1;
                      }    
                  break;}
                case 6:  // "couleur pour les numerao")
                { cout << "\n couleur au standard RGB pour les numeraos : par defaut jaune (rep 'o') ";
                  rep = lect_return_defaut(false,"o"); 
                  if (rep != "o")
                   { cout << "\n couleur au standard RGB (trois réels entre 0 et 1) ?  ";
                     double Rco,Gco,Bco;
                     cin >> Rco >> Gco >> Bco;
                     std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
                     if ((Rco <= 1.)&& (Rco >= 0) && (Gco <= 1.)&& (Gco >= 0)
                          &&(Bco <= 1.)&& (Bco >= 0))
                       { Rcouln = Rco; Gcouln = Gco; Bcouln = Bco;
                        }
                     else
                       { cout << " \n *****choix non valide de couleur**** ";
                        }
                    }
                  else
                    { Rcouln = 1; Gcouln = 1; Bcouln = 0;
                      }    
                  break;}
              }
             } 
          else { cout << "\n Erreur on attendait un entier entre 0 et 6 !!, "
                      << "\n redonnez une bonne valeur"
                      << "\n ou taper fin_prog pour arreter le programme"; 
              choix_valide=false;
             }
         }    
       catch (ErrSortieFinale)
            // cas d'une direction voulue vers la sortie
            // on relance l'interuption pour le niveau supérieur
          { ErrSortieFinale toto;
            throw (toto);
          }
       catch (...)// erreur de lecture
       {  cout << "\n Erreur on attendait un des mots clés proposés !!, "
                      << "\n redonnez une bonne valeur"
                      << "\n ou taper fin_prog pour arreter le programme"; 
              choix_valide=false;
        }
       } //-- fin du while
      } //-- fin du if (rep != "o") du départ c'est-à-dire du cas non standart 
      // appel de la méthode de la classe mère
      OrdreVisu::ChoixOrdre();    
     };     
            
                            
