source: PSPA/Interface_Web/trunk/pspaWT/sources/userInterface/src/GWt_pspaApplication.cc @ 271

#include <stdio.h>
#include <string.h>
#include <vector>

#include "GWt_pspaApplication.h"
#include "GWt_ligneFaisceau.h"
#include "GWt_globalParameters.h"
// #include "GWt_dialog.h"
#include "GWt_draggableImage.h"
#include "particleBeam.h"
#include "bareParticle.h"
#include "nomDeLogiciel.h"
#include "mixedTools.h"
#include "nomdElements.h"
#include "environmentVariables.h"
#include "GWt_console.h"
#include "trivaluedBool.h"

#include <Wt/WLineEdit>
#include <Wt/WGridLayout>
#include <Wt/WVBoxLayout>
#include <Wt/WHBoxLayout>
#include <Wt/WImage>
#include <Wt/WMenu>
#include <Wt/WStackedWidget>
#include <Wt/WBreak>
#include <Wt/WDialog>
#include <Wt/WStandardItemModel>
#include <Wt/WFileUpload>
#include <Wt/WPainter>
#include <Wt/WPdfImage>
#include <Wt/WRasterImage>
#include <Wt/WScrollArea>

using namespace Wt::Chart;

/*
 * The env argument contains information about the new session, and
 * the initial request. It must be passed to the WApplication
 * constructor so it is typically also an argument for your custom
 * application constructor.
*/

PspaApplication::PspaApplication(const WEnvironment& env) : WApplication(env)
{

  workingDir_ = WApplication::docRoot()+ "/"+WORKINGAREA;
  nameOfCase_ = "pspa"; // default

  setTitle("portail PSPA");                               // application title 
  if (!wApp->environment().javaScript()) {
    new WText("<i>This examples requires that javascript support is enabled.</i>",root());
  }
  
  // include the styleSheet
  WContainerWidget *widroot = root();
  useStyleSheet ("htdocs/pspa.css");
  dtmanage_ = new dataManager();

  /*
   * The main layout is a 3x2 grid layout.
   */
  WGridLayout *layout = new WGridLayout();
//  layout->addWidget(createTitle("<a href='workingArea/parmin'> Menu (In future)</a>"), 0, 0, 1, 2);
//  layout->addWidget(createTitle("Menu (In future)"), 0, 0, 1, 2);

  WHBoxLayout *toolbarLayout = new WHBoxLayout();
    
  WPushButton* boutonSauve = new WPushButton();
  WPushButton* boutonRestaure = new WPushButton();
  WPushButton* boutonLoadNew = new WPushButton();
  WPushButton* boutongraphicalAnalysis = new WPushButton();

  boutonSauve->setStyleClass("saveButton");
  boutonRestaure->setStyleClass("restoreButton");
  boutonLoadNew->setStyleClass("loadNewButton");
  boutongraphicalAnalysis->setStyleClass("histoButton");

  boutonSauve->setToolTip ("sauvegarder la config");
  boutonRestaure->setToolTip (" restaurer la config");
  boutonLoadNew->setToolTip ("upload config");
  boutongraphicalAnalysis->setToolTip ("analyse graphique");

  boutonSauve->setMaximumSize(38,38);
  boutonSauve->setMinimumSize(38,38);
  boutonRestaure->setMaximumSize(38,38);
  boutonRestaure->setMinimumSize(38,38);
  boutonLoadNew->setMaximumSize(38,38);
  boutonLoadNew->setMinimumSize(38,38);
  boutongraphicalAnalysis->setMaximumSize(38,38);
  boutongraphicalAnalysis->setMinimumSize(38,38);
  
  boutonSauve->clicked().connect(this, &PspaApplication::sauver);
  boutonRestaure->clicked().connect(this, &PspaApplication::restaurer);
  // Upload when the button is clicked.
  // React to a succesfull upload.
  boutonLoadNew->clicked().connect(this, &PspaApplication::openFileSelector);

boutongraphicalAnalysis->clicked().connect(this, &PspaApplication::dialogOnGraphics);


  toolbarLayout->addWidget(boutonSauve , 0,Wt::AlignMiddle);
  toolbarLayout->addWidget(boutonRestaure , 0,Wt::AlignMiddle);
  toolbarLayout->addWidget(boutonLoadNew , 0,Wt::AlignMiddle);
  toolbarLayout->addWidget(boutongraphicalAnalysis , 0,Wt::AlignMiddle);
  toolbarLayout->addWidget(new WText("") , 1,Wt::AlignMiddle);

  WContainerWidget * layoutContainer = new WContainerWidget();
  layoutContainer->setLayout(toolbarLayout);
  layoutContainer->decorationStyle().setBackgroundImage ("/htdocs/fond_toolbar.png");
  layout->addWidget(layoutContainer, 1, 0, 1, 2);
  layout->addWidget(createPalette(), 2, 0, 4, 1);
  
  beamLine_ = createBeamLine();
  WScrollArea* scroll = new  WScrollArea();
  scroll->setWidget(beamLine_);
  layout->addWidget(scroll, 2, 1, 1, 1);
  

  // console_ = new WContainerWidget();
  // console_->decorationStyle().setBackgroundColor (WColor("lightgray"));
  // console_->setMaximumSize(600,200);
  // layout->addWidget(console_, 3, 1);
  // console_->setMinimumSize(300,100);
  // console_->setOverflow(WContainerWidget::OverflowAuto);  


  console_ = new GWt_console();
  console_->clear();
  console_->decorationStyle().setBackgroundColor (WColor("lightgray"));
  console_->setMaximumSize(600,200);
  console_->setMinimumSize(300,100);
  console_->setOverflow(WContainerWidget::OverflowAuto);  
  layout->addWidget(console_, 3, 2);





  //-----------
  // A supprimer et a mettre en fenetre
  globalParam_ = createGlobalParamWidget();
  //  leDessin_ = new WContainerWidget();
  //  leDessin_ = createDrawingWidget();
  graphicsDialog_ = new GWt_dialog("graphical analysis",createDrawingWidget(),false);
  graphicsDialog_->setMinimumSize(400,400);
  graphicsDialog_->setClosable(true);



  WWidget* executeWidget = createExecuteWidget();

  layout->addWidget( globalParam_, 3, 1);
  //  layout->addWidget( leDessin_, 3, 2);
  layout->addWidget( executeWidget , 4, 1);
  //-----------
  


  layout->setColumnResizable(1);
  layout->setRowResizable(2);
  /*
   * Let row 2 and column 1 take the excess space.
   */
  layout->setRowStretch(2, 1);
  layout->setColumnStretch(1, 1);
  
  widroot->setLayout(layout);  
}

WWidget* PspaApplication::createPalette()
{
  WContainerWidget* palette=new WContainerWidget();
  //  palette->setLayout(new WVBoxLayout());

  // nomdElements *e= new nomdElements();
  // int nElts= e->getNumberOfElements(); 
  // delete e;
  //  nomdElements bidon;

  // FIXME a reprendre avec un patern
  createDragImage("htdocs/beam.jpg","htdocs/beam.jpg","htdocs/beam.jpg",palette,"beam");
  new WBreak(palette);
  createDragImage("htdocs/rfgun.jpg","htdocs/rfgun.jpg","htdocs/rfgun.jpg",palette,"rfgun");
  new WBreak(palette);
  createDragImage("htdocs/drift.jpg","htdocs/drift.jpg","htdocs/drift.jpg",palette,"drift");
  new WBreak(palette);
  createDragImage("htdocs/cell.jpg","htdocs/cell.jpg","htdocs/cell.jpg",palette,"cell");
  new WBreak(palette);
  createDragImage("htdocs/bend.jpg","htdocs/bend.jpg","htdocs/bend.jpg",palette,"bend");
  new WBreak(palette);
  createDragImage("htdocs/soleno.jpg","htdocs/soleno.jpg","htdocs/soleno.jpg",palette,"soleno");
  new WBreak(palette);
  createDragImage("htdocs/fit.jpg","htdocs/fit.jpg","htdocs/fit.jpg",palette,"fit");
  new WBreak(palette);


  //  palette->setMinimumSize(100,300);
  return palette;
}

void PspaApplication::createDragImage(const char *url,const char *smallurl,const char *mimeType,WContainerWidget *p,WString name)
{
  GWt_draggableImage *result = new GWt_draggableImage(url,p);
  WImage *dragImage = new WImage(smallurl,p);

  /*
   * Set the image to be draggable, showing the other image (dragImage)
   * to be used as the widget that is visually dragged.
   */
  cout << "createDragImage" << dragImage<<endl;
  result->setDraggable(mimeType,dragImage,true);

}

WWidget* PspaApplication::createBeamLine()
{
  WContainerWidget* beamLine = new GWt_LigneFaisceau(this);
  beamLine->setMinimumSize(300,100);
  return beamLine;
}

WWidget* PspaApplication::createGlobalParamWidget()
{
  WContainerWidget* globalParam = new GWt_globalParameters(this);
  globalParam->setMaximumSize(600,150);
  globalParam->setMinimumSize(600,150);
  return globalParam;
}

WWidget* PspaApplication::createExecuteWidget()
{

  WContainerWidget* executeW = new WContainerWidget();
  executeW->setMaximumSize(600,150);
  executeW->setMinimumSize(600,150);

  // bouton execute
  exec_go_ = new WPushButton("execute!");
  //    exec_go_->setMinimumSize(300,300);
  exec_go_->setDisabled(true);
  exec_go_->clicked().connect(this, &PspaApplication::executer);

  // preparation du bouton add
  WPushButton* exec_add = new WPushButton("add");
  exec_add->clicked().connect(this, &PspaApplication::addSectionToExecuteW);
  
  // preparation du bouton delete
  WPushButton* exec_delete = new WPushButton("delete");
  exec_delete->clicked().connect(this, &PspaApplication::deleteSectionToExecuteW);

  // preparation du bouton push_ok 
  WPushButton* exec_ok = new WPushButton("check/ok");
  exec_ok->clicked().connect(this, &PspaApplication::checkSectionSelection);
  
  // le panel 
  WPanel *panelLogiciels = new WPanel(executeW);
  panelLogiciels->setTitle(" sections of beam Line for executing softwares ");

  contenuSections_ = new WContainerWidget();  
  contenuSections_->addWidget(exec_add);
  contenuSections_->addWidget(exec_delete);
  contenuSections_->addWidget(exec_ok);
  contenuSections_->addWidget(exec_go_);
  contenuSections_->addWidget(new WBreak());
  contenuSections_->addWidget(new WBreak());
  addSectionToExecuteW();
  
  panelLogiciels->setCentralWidget(contenuSections_);
  return executeW;
}

void PspaApplication::dialogOnGraphics()
{
  // GWt_dialog* graphicsDialog = new GWt_dialog("graphical analysis",createDrawingWidget(),false);
  // graphicsDialog->setMinimumSize(400,400);
  // graphicsDialog->setClosable(true);


    graphicsDialog_->show();

}

WContainerWidget* PspaApplication::createDrawingWidget()
{
  WContainerWidget* dessin = new WContainerWidget();




  choixEnveloppeDessin_ = new WComboBox();
  choixEnveloppeDessin_->addItem("x");
  //  choixEnveloppeDessin_->addItem("y");
  WPushButton* okEnv = new WPushButton("draw enveloppe");
 okEnv->clicked().connect(this, &PspaApplication::dessinerEnveloppe);


  dessin->addWidget(new WText(" enveloppe :  "));
  dessin->addWidget(choixEnveloppeDessin_);
  dessin->addWidget(okEnv);

  dessin->addWidget(new WBreak());

  choixElementDessin_ = new WComboBox();



  choixTypeDessinFaisceau_ = new WComboBox();
  choixTypeDessinFaisceau_->addItem("courant_snyder");
  choixTypeDessinFaisceau_->addItem("macroparticles");
  WPushButton* caroule = new WPushButton("dessiner");
 caroule->clicked().connect(this, &PspaApplication::dessiner);

  dessin->addWidget(new WText(" phase space after element :  "));
  dessin->addWidget(choixElementDessin_);
  dessin->addWidget(choixTypeDessinFaisceau_);
 dessin->addWidget(caroule);
  dessin->addWidget(new WBreak());




 /////////////////////////////////////////////////////////////////////
 dessin->addWidget(new WText(" histogramme :  "));
 WPushButton* okHisto = new WPushButton("histogramme");
 dessin->addWidget(okHisto);
 okHisto->clicked().connect(this,&PspaApplication::dessinerHistogramme);
 /////////////////////////////////////////////////////////////////////

  toto_ = new WContainerWidget();
  dessin->addWidget(toto_);
  return dessin;
}

void PspaApplication::addSectionToExecuteW()
{

  disableSectionExecute();

  string premierText, dernierText;
  if(selectedSections_.size() == 0)
    {
      premierText = dtmanage_->getLabelFromElementNumero(1);

      dernierText = dtmanage_->getLabelFromElementNumero(dtmanage_->beamLineSize());
    }
  else  
    {
      dernierText = selectedSections_.back()->fin->text().toUTF8();
      int dernierNumero = dtmanage_->getCollection()->getNumeroFromLabel(dernierText);
      dernierNumero++;
      if ( dernierNumero <= dtmanage_->beamLineSize() )
        {
          premierText = dtmanage_->getLabelFromElementNumero(dernierNumero);
        }
      else 
        {
          premierText = dtmanage_->getLabelFromElementNumero(dtmanage_->beamLineSize());
        }
      dernierText = premierText;
    }
  
  //  cout << "PspaApplication::addSectionToExecute() : " << premierText << " Ã   " << dernierText << endl;

  WContainerWidget* newSection = new WContainerWidget;

  selectedSections_.push_back(new GWt_sectionToExecute);
  selectedSections_.back()->debut = new WLineEdit();
  selectedSections_.back()->debut->setDisabled(true);
  selectedSections_.back()->debut->setText(premierText);
  selectedSections_.back()->fin = new WLineEdit();
  selectedSections_.back()->fin->changed().connect(this,&PspaApplication::disableSectionExecute);
  selectedSections_.back()->fin->setText(dernierText);
  selectedSections_.back()->selection = new WComboBox();
  selectedSections_.back()->ligneDeWidget = newSection;
  newSection->addWidget(new WText(" from : "));
  newSection->addWidget(selectedSections_.back()->debut);
  newSection->addWidget(new WText(" to : "));
  newSection->addWidget(selectedSections_.back()->fin);
  newSection->addWidget(selectedSections_.back()->selection);

  contenuSections_->addWidget(newSection);
  unsigned nb = nomDeLogiciel::getNumberOfSoftwares();
  unsigned k;
  for(k = 0; k < nb; k++) {
    selectedSections_.back()->selection->addItem(nomDeLogiciel(k).getString());
  }
}

void PspaApplication::disableSectionExecute()
{
  exec_go_->setDisabled(true);
}

void PspaApplication::checkSectionSelection()
{
  if ( selectedSections_.empty() ) return;

  // traitement de la premiere ligne
  // on impose le depart du calcul au premier element
  string premier = dtmanage_->getLabelFromElementNumero(1);
  (*selectedSections_.begin())->debut->setText(premier);

  string currentString =  (*selectedSections_.begin())->fin->text().toUTF8();
  int current = dtmanage_->getCollection()->getNumeroFromLabel( currentString);

  cout << " numero " << current << endl;
  // si la fin est mal definie on prend toute la config par defaut
  if ( current <= 0 || current > dtmanage_->beamLineSize() ) 
    {
      current = dtmanage_->beamLineSize();
      currentString =  dtmanage_->getLabelFromElementNumero(current);
      (*selectedSections_.begin())->fin->setText(currentString);
    }
  current++;
  currentString = dtmanage_->getLabelFromElementNumero(current);
    
  // traitement des suivantes (on avance d'un cran dans la liste)
  list<GWt_sectionToExecute*>::iterator itr, itr0;
  itr0 = selectedSections_.begin();
  itr0++;
  for (itr = itr0; itr != selectedSections_.end(); itr++)
    {
      // debut
      if ( current >= dtmanage_->beamLineSize() ) 
        {
          //      GWt_tools::addConsoleMessage(" bad section definition !  \n ");
          GWt_dialog warningDialog("PSPA : Vérification des sections", " bad section definition !", GWt_dialog::Error,true,true);
          warningDialog.exec();
          return;
        }

      (*itr)->debut->setText(currentString);
      // fin
      string finString =  (*itr)->fin->text().toUTF8();

      int numeroFin = dtmanage_->getCollection()->getNumeroFromLabel( finString);

      if ( numeroFin <= current || numeroFin > dtmanage_->beamLineSize())
        {
          //      GWt_tools::addConsoleMessage(" bad section definition !  \n ");
          GWt_dialog warningDialog("PSPA : Vérification des sections", " bad section definition !", GWt_dialog::Error, true,true);
          warningDialog.exec();
          return;
        }

      // preparation de la ligne suivante
      current = numeroFin +1;
      currentString = dtmanage_->getLabelFromElementNumero(current);
    }

  if (!areDataCoherent()) {
    GWt_dialog warningDialog("PSPA : Vérification des sections", " donnees incoherentes !", GWt_dialog::Error,true,true);
    warningDialog.exec();
  }
  else 
    {
      exec_go_->setDisabled(false);
    }
}

bool PspaApplication::areDataCoherent() 
{
  bool caMarche = true;
  dtmanage_->initializeExecution(workingDir_);
  
  list<GWt_sectionToExecute*>::iterator itr;
  for(itr = selectedSections_.begin(); itr != selectedSections_.end(); itr++)
    {
      string debString = (*itr)->debut->text().toUTF8();
      string finString = (*itr)->fin->text().toUTF8();


      int debut = dtmanage_->getCollection()->getNumeroFromLabel(debString);
      int fin = dtmanage_->getCollection()->getNumeroFromLabel(finString);
      nomDeLogiciel prog = nomDeLogiciel ( (*itr)->selection->currentIndex() );
      dtmanage_->addSectionToExecute(debut,fin,prog);
    }

  string diagnostic;
  trivaluedBool essai = dtmanage_->checkExecute(diagnostic);
  cout << " retour verif , essai = " << essai << endl;
  if ( essai == error ) {
    cout << " appli : erreur " << endl;
    caMarche = false;   
    GWt_dialog calculDialog("PSPA check execute : ERROR", diagnostic , GWt_dialog::Error,true,true);
    calculDialog.exec();
  } else if ( essai == warning )  {
    cout << " appli : warnig " << endl;
    caMarche = true;    
    GWt_dialog calculDialog("PSPA check execute : warning ", diagnostic , GWt_dialog::Warning, false,true);
    calculDialog.exec();
  }

  return caMarche;
}

void PspaApplication::deleteSectionToExecuteW()
{
  if ( selectedSections_.empty() ) return;
  disableSectionExecute();
  selectedSections_.back()->ligneDeWidget->clear();
  delete selectedSections_.back()->ligneDeWidget;
  selectedSections_.pop_back();
}

void PspaApplication::executer()
{
  console_->addConsoleMessage(string("on va peut etre y arriver"));
    
  
  static_cast<GWt_globalParameters*>(globalParam_)->updateGlobals();

  GWt_dialog calculDialog("Calcul en cours", "Veuillez patienter...", GWt_dialog::Wait, true,false);
  calculDialog.show();

  processEvents();      

  string resultat;
  if ( !dtmanage_->executeAll(workingDir_, resultat)) {
    GWt_dialog warningDialog("PSPA : Echec", " echec lors de l'exécution !", GWt_dialog::Error, true,true);
    warningDialog.exec();
  }
  //  cout << " PspaApplication : retour d'execution resultat =  " << resultat << endl; 
  console_->addConsoleMessage(resultat);
  //  cout << " PspaApplication : affichage console termine  " << endl; 

  exec_go_->setDisabled(true);

  calculDialog.hide();

  faireDessin();
}

void PspaApplication::sauver()
{
  cout << " on sauve " << endl;
  console_->addConsoleMessage("sauvegarde");

  dialogSave_ = new WDialog("save");
  new WText("name of case : ",dialogSave_->contents());
  saveNameEdit_ = new WLineEdit(nameOfCase_.c_str(), dialogSave_->contents());
  WPushButton *annule = new WPushButton("cancel",dialogSave_->contents());
  WPushButton *submit = new WPushButton("OK",dialogSave_->contents());
  annule->clicked().connect(dialogSave_, &Wt::WDialog::reject);
  submit->clicked().connect(dialogSave_, &Wt::WDialog::accept);
  dialogSave_->finished().connect(this, &PspaApplication::dialogSaveDone);  
  dialogSave_->show();
}

void PspaApplication::dialogSaveDone(WDialog::DialogCode code)
{

  if ( code != Wt::WDialog::Accepted ) { console_->addConsoleMessage(" pas de sauvegarde"); return;}
  else { console_->addConsoleMessage("sauvegarde sur repertoire : " + workingDir_);}
  nameOfCase_ = saveNameEdit_->text().toUTF8();
  cout << " PspaApplication::dialogSaveDone() nameOfCase_= " << nameOfCase_ << endl;
  delete dialogSave_;
  dialogSave_ = NULL;
  GWt_globalParameters* bibi = static_cast<GWt_globalParameters*>(globalParam_);
  bibi->updateGlobals();
  //  dtmanage_->saveConfiguration(nameOfCase_);
  dtmanage_->saveConfiguration(workingDir_ ,  nameOfCase_);
}



void PspaApplication::restaurer()
{
  console_->addConsoleMessage(string("on va recharger..."));
  dialogOpen_ = new WDialog("open");
  new WText("name of case : ",dialogOpen_->contents());
  openNameEdit_ = new WLineEdit(nameOfCase_.c_str(), dialogOpen_->contents());
  WPushButton *annule = new WPushButton("cancel",dialogOpen_->contents());
  WPushButton *submit = new WPushButton("OK",dialogOpen_->contents());
  annule->clicked().connect(dialogOpen_, &Wt::WDialog::reject);
  submit->clicked().connect(dialogOpen_, &Wt::WDialog::accept);
  dialogOpen_->finished().connect(this, &PspaApplication::dialogOpenDone);  
  dialogOpen_->show();
}

void PspaApplication::dialogOpenDone(WDialog::DialogCode code)
{

  if ( code != Wt::WDialog::Accepted ) { console_->addConsoleMessage(" pas de restauration"); return;}
  else { console_->addConsoleMessage("restauration depuis le repertoire " + workingDir_ );}

  nameOfCase_ = openNameEdit_->text().toUTF8();
  cout << " PspaApplication::dialogOpenDone() nameOfCase_= " << nameOfCase_ << endl;
  delete dialogOpen_;
  dialogSave_ = NULL;

  bool test = dtmanage_->restoreElements(workingDir_,  nameOfCase_);
  if ( !test ) {
        GWt_dialog restoreWarning(" element restoring", "failure in restoring elements !", GWt_dialog::Error, false,true);
           restoreWarning.exec();
  }

  GWt_globalParameters* bibi = static_cast<GWt_globalParameters*>(globalParam_);
  bibi->renew();

  GWt_LigneFaisceau* bobo = static_cast<GWt_LigneFaisceau*>(beamLine_);
  bobo->restoreElementCollection();

  console_->addConsoleMessage(string("...terminee"));
}


void PspaApplication::openFileSelector()
{

  WContainerWidget *result = new WContainerWidget();
  WVBoxLayout* myLayout = new WVBoxLayout();

  uploadFileSelectorWidget_ = new WFileUpload();

  uploadFileSelectorWidget_->setFileTextSize(40);
  
  myLayout->addWidget(new WText("Select the configuration file for pspa : "));
  myLayout->addWidget(uploadFileSelectorWidget_);

  result->setLayout (myLayout);

  // Upload automatically when the user entered a file.
  uploadFileSelectorWidget_->changed().connect(uploadFileSelectorWidget_, &WFileUpload::upload);
  
  // React to a succesfull upload.
  uploadFileSelectorWidget_->uploaded().connect(this, &PspaApplication::chargerConfig);
  
  // React to a fileupload problem.
  uploadFileSelectorWidget_->fileTooLarge().connect(this, &PspaApplication::fileTooLarge);
  
  
  GWt_dialog* fileSelectorDialog = new GWt_dialog("Load a file",result,false);
  
  fileSelectorDialog->exec();
}


void PspaApplication::chargerConfig()
{
  GWt_dialog*  message= new GWt_dialog("File successfully upload","The file has been correctly upload to" + uploadFileSelectorWidget_->spoolFileName(),GWt_dialog::Warning,false,true);

  string nomDuFichier = (uploadFileSelectorWidget_->clientFileName()).toUTF8();
  cout << " fichier client : " << nomDuFichier << endl;
  bool test = removeExtensionFromConfigName(nomDuFichier);
  cout << " fichier client sans extension : " << nomDuFichier << endl;

  if ( test )
    {
      nameOfCase_ = nomDuFichier;
      console_->addConsoleMessage(string("restauration..."));

      if ( !dtmanage_->restoreElements(workingDir_, uploadFileSelectorWidget_->spoolFileName()) ) {
        GWt_dialog restoreWarning(" element restoring", "failure in restoring elements !", GWt_dialog::Error, false,true);
        restoreWarning.exec();
      }

      GWt_globalParameters* bibi = static_cast<GWt_globalParameters*>(globalParam_);
      bibi->renew();

      GWt_LigneFaisceau* bobo = static_cast<GWt_LigneFaisceau*>(beamLine_);
      bobo->restoreElementCollection();

      console_->addConsoleMessage(string("...terminee"));
      message->show();
    }
}


void PspaApplication::fileTooLarge()
{
  std::stringstream stream;
  stream << maximumRequestSize ();
  std::string maxRequestSize(stream.str());

  std::string message = "This file is too large, please select a one\n";
  message += "Maximum file size is "+ maxRequestSize;
  message += " bytes\n";

  GWt_dialog*  messageBox= new GWt_dialog("Error during upload file" ,message ,GWt_dialog::Error,false,true);
  
  messageBox->show();
}


void PspaApplication::faireDessin()
{
  choixElementDessin_->clear();
  int nombre = dtmanage_->beamLineSize();
  for ( int numero =1; numero <= nombre; numero++)
    {
      choixElementDessin_->addItem(dtmanage_->getLabelFromElementNumero(numero));
    }

}

void PspaApplication::dessiner()
{
  
  toto_->clear();

  int typeFaisceau = choixTypeDessinFaisceau_->currentIndex();

  int index = choixElementDessin_->currentIndex();


  particleBeam* beam = dtmanage_->getDiagnosticBeam(index);

  if ( beam == NULL ) {
        GWt_dialog warningBeamState(" graphical analysis", "the beam does not exist at the end of this element !", GWt_dialog::Error, false,true);
          warningBeamState.exec();
          return;
    }


  if ( typeFaisceau == 0 ) 
    {
      if ( !beam->momentRepresentationOk() ) beam->buildMomentRepresentation();
      faireDessinTransport(toto_, beam);
    }
  else if ( typeFaisceau == 1 ) 
    {
      if ( beam->particleRepresentationOk() ) faireDessinParmela(toto_, beam);
      else {
        GWt_dialog warningBeamState(" graphical analysis", "the beam state does not allow providing a drawing with macroparticles !", GWt_dialog::Error, false,true);
          warningBeamState.exec();
      }
    }
  else {
        GWt_dialog warningTypeDrawing(" graphical analysis", "type of  drawing not programmed !", GWt_dialog::Error, false,true);
           warningTypeDrawing.exec();
 }
  //////////////////////////////////////////
}

void PspaApplication::dessinerEnveloppe()
{
  
  toto_->clear();

  int typeEnveloppe = choixEnveloppeDessin_->currentIndex();
  if ( typeEnveloppe == 0 ) 
    {
      faireDessinEnveloppe(toto_, "x");
    }
  else {
        GWt_dialog warningTypeEnveloppe(" graphical analysis", "type of enveloppe drawing not programmed !", GWt_dialog::Error, false,true);
           warningTypeEnveloppe.exec();
  }
  //////////////////////////////////////////
}

void PspaApplication::faireDessinEnveloppe(WContainerWidget* toto, string type)
{

  GWt_dialog* envDialog = new GWt_dialog("enveloppe",toto_,false);
  envDialog->setMinimumSize(400,400);
  envDialog->setClosable(true);
  envDialog->show();



  //       new WText(nameOfCase_ + " : enveloppe", toto);
        unsigned nbel = dtmanage_->beamLineSize();


  vector<double> xcor;
  vector<double> ycor;


  dtmanage_->donneesRmsEnveloppe(type,1, nbel, xcor,ycor);

  scatterPlot1D(envDialog->contents(),xcor,ycor);

}

void PspaApplication::faireDessinParmela(WContainerWidget* toto, particleBeam* beam)
{

  GWt_dialog* pointsDialog = new GWt_dialog("space phase",toto,false);
  pointsDialog->setMinimumSize(400,400);
  pointsDialog->setClosable(true);
  // pointsDialog->show();



  vector<bareParticle>& partic = beam->getParticleVector();
  new WText(nameOfCase_ + " : espace de phase x,x' "+ " nb partic. "+ mixedTools::intToString(partic.size()), pointsDialog->contents());
  WStandardItemModel *model = new WStandardItemModel(partic.size(), 3, pointsDialog->contents());
  //    model->setHeaderData(0, WString("X"));
  //   model->setHeaderData(1, WString("Y = sin(X)"));


  for (unsigned i = 0; i < partic.size(); ++i) {
    double x= partic.at(i).getPosition().getComponent(0);
    double begamz = partic.at(i).getBetaGamma().getComponent(2);
    double xp = partic.at(i).getBetaGamma().getComponent(0)/begamz;
    //    cout << "x = " << x << " xp= " << xp << endl;
    model->setData(i, 0, x);
    model->setData(i, 1,1.e3*xp);
    model->setData(i, 2,2.e3*xp);
  }

  WCartesianChart *chart = new WCartesianChart(pointsDialog->contents());
  chart->setModel(model);        // set the model
  chart->setXSeriesColumn(0);    // set the column that holds the X data
  chart->setLegendEnabled(true); // enable the legend

  chart->setType(ScatterPlot);   // set type to ScatterPlot

  // Typically, for mathematical functions, you want the axes to cross
  // at the 0 mark:
   chart->axis(XAxis).setLocation(ZeroValue);
   chart->axis(YAxis).setLocation(ZeroValue);

  // Provide space for the X and Y axis and title. 
  chart->setPlotAreaPadding(80, Left);
  chart->setPlotAreaPadding(40, Top | Bottom);
  // Add the curves
  WDataSeries s(1, PointSeries, Y1Axis);
  //  s.setShadow(WShadow(3, 3, WColor(0, 0, 0, 127), 3));
  //    s.setMarker(SquareMarker);
  //  s.setMarkerSize(600.);
  //  cout << "le marker est : " << s.marker() << endl;
     chart->addSeries(s);

  chart->resize(400, 400); // WPaintedWidget must be given explicit size
  

#ifdef HAS_IMAGEMAGIC
 Wt::WRasterImage pngImage("png", 600, 600);
 Wt::WPainter p(&pngImage);
 chart->paint(p);
 std::string name;
 name = workingDir_ + "/chart-"+sessionId ()+".png";
 std::ofstream f(name.c_str(), std::ios::out |std::ios::trunc | std::ios::binary);
 pngImage.write(f);
 new WText("<a href='workingArea/chart-"+sessionId ()+".png' target='_blank'>Afficher l'image</a>",toto);
#endif

  pointsDialog->show();

  //  chart->setMargin(10, Top | Bottom);            // add margin vertically
  //  chart->setMargin(WLength::Auto, Left | Right); // center horizontally
}


// void PspaApplication::addElemToGlobals()
// {
//   static_cast<GWt_globalParameters*>(globalParam_)->addElem();
// }

void PspaApplication::faireDessinTransport(WContainerWidget* toto, particleBeam* beam)
{
  //  WContainerWidget* toto = static_cast<WContainerWidget*>(leDessin_);
  //  toto->clear();

  //  new WText(nameOfCase_ + " : espace de phase x,x' "+ " nb partic. "+ mixedTools::intToString(partic.size()), toto);

  GWt_dialog* ellipseDialog = new GWt_dialog("ellipse",toto,false);
  ellipseDialog->setMinimumSize(400,400);
  ellipseDialog->setClosable(true);
  ellipseDialog->show();


  new WText(nameOfCase_ + " : emittance x,x' " + mixedTools::doubleToString(beam->getUnnormalizedEmittanceX()) + " pi.mm.mrad" , ellipseDialog->contents());
  new WBreak(ellipseDialog->contents());
  new WText(" xmax = " + mixedTools::doubleToString(beam->getSigmaTransportij(1,1)) + " cm ", ellipseDialog->contents());
  new WBreak(ellipseDialog->contents());
  new WText(" x' max = " + mixedTools::doubleToString(beam->getSigmaTransportij(2,2)) + " mrad ", ellipseDialog->contents());
  new WBreak(ellipseDialog->contents());
  new WText(" corr. 12 = " + mixedTools::doubleToString(beam->getSigmaTransportij(2,1))  + " sqrt(cm.rad) ", ellipseDialog->contents());
  
  vector<double> xcor;
  vector<double> ycor;
  //  dtmanage_->getCurrentBeam()->donneesDessinEllipseXxp(xcor,ycor);
  beam->donneesDessinEllipseXxp(xcor,ycor);
  scatterPlot1D(ellipseDialog->contents(),xcor,ycor);

}

// void PspaApplication::scatterPlot1D(WContainerWidget* toto, vector<double>& xcor, vector<double>& ycor)
// {
//   int nbpts = xcor.size();
//   cout << " PspaApplication::scatterPlot1D nbpts = " << nbpts << endl;
//   WStandardItemModel *model = new WStandardItemModel(nbpts, 2, toto);
//   for (int i = 0; i < nbpts; ++i) {
//     model->setData(i, 0, xcor.at(i));
//     model->setData(i, 1, ycor.at(i));
//     //    cout << " PspaApplication::scatterPlot1D el= " << i+1 << " x= " << xcor.at(i) << " y= " << ycor.at(i) << endl;
//   }

//   WCartesianChart *chart = new WCartesianChart(toto);

//   chart->initLayout();

//   chart->setModel(model);        // set the model
//   chart->setXSeriesColumn(0);    // set the column that holds the X data
//   chart->setLegendEnabled(true); // enable the legend

//   chart->setType(ScatterPlot);   // set type to ScatterPlot

//   // Typically, for mathematical functions, you want the axes to cross
//   // at the 0 mark:
//    chart->axis(XAxis).setLocation(ZeroValue);
//    chart->axis(YAxis).setLocation(ZeroValue);

//   // Provide space for the X and Y axis and title. 
// //   chart->setPlotAreaPadding(80, Left);
// //   chart->setPlotAreaPadding(40, Top | Bottom);
//   // Add the curves
//   WDataSeries s(1, CurveSeries, Y1Axis);
//   chart->addSeries(s);

//   // chart->setBackground (WBrush(WColor("blue")));
//   chart->resize(300, 300); // WPaintedWidget must be given explicit size

// #ifdef HAS_IMAGEMAGIC
//  Wt::WRasterImage pngImage("png", 600, 600);
//  Wt::WPainter p(&pngImage);

//  chart->paint(p);
//  std::string name;
//  name = workingDir_ + "/chart-"+sessionId ()+".png";
//  std::ofstream f(name.c_str(), std::ios::out |std::ios::trunc | std::ios::binary);
//  pngImage.write(f);

//  new WText("<a href='workingArea/chart-"+sessionId ()+".png' target='_blank'>Afficher l'image</a>",toto);

//  /*
//  Wt::WPdfImage pdfImage("30cm", "30cm");
//  Wt::WPainter p1(&pdfImage);
//  chart->paint(p1);
//  std::ofstream f1("chart.pdf", std::ios::out | std::ios::binary);
//  pdfImage.write(f1);
//  */
// #endif
// }


void PspaApplication::scatterPlot1D(WContainerWidget* toto, vector<double>& xcor, vector<double>& ycor)
{
  int nbpts = xcor.size();
  cout << " PspaApplication::scatterPlot1D nbpts = " << nbpts << endl;
  WStandardItemModel *model = new WStandardItemModel(nbpts, 2, toto);
  for (int i = 0; i < nbpts; ++i) {
    model->setData(i, 0, xcor.at(i));
    model->setData(i, 1, ycor.at(i));
    //    cout << " PspaApplication::scatterPlot1D el= " << i+1 << " x= " << xcor.at(i) << " y= " << ycor.at(i) << endl;
  }

WCartesianChart *chart = new WCartesianChart(toto);
  chart->setTitle("titre");

  //  chart->initLayout();

  chart->setModel(model);        // set the model
  chart->setXSeriesColumn(0);    // set the column that holds the X data
  chart->setLegendEnabled(true); // enable the legend

  chart->setType(ScatterPlot);   // set type to ScatterPlot

  // Typically, for mathematical functions, you want the axes to cross
  // at the 0 mark:
   chart->axis(XAxis).setLocation(ZeroValue);
   chart->axis(YAxis).setLocation(ZeroValue);

  // Provide space for the X and Y axis and title. 
//   chart->setPlotAreaPadding(80, Left);
//   chart->setPlotAreaPadding(40, Top | Bottom);
  // Add the curves
  WDataSeries s(1, LineSeries, Y1Axis);
  chart->addSeries(s);

  // chart->setBackground (WBrush(WColor("blue")));
  chart->resize(500, 300); // WPaintedWidget must be given explicit size

#ifdef HAS_IMAGEMAGIC
 Wt::WRasterImage pngImage("png", 600, 600);
 Wt::WPainter p(&pngImage);

 chart->paint(p);
 std::string name;
 name = workingDir_ + "/chart-"+sessionId ()+".png";
 std::ofstream f(name.c_str(), std::ios::out |std::ios::trunc | std::ios::binary);
 pngImage.write(f);

 new WText("<a href='workingArea/chart-"+sessionId ()+".png' target='_blank'>Afficher l'image</a>",toto);

 /*
 Wt::WPdfImage pdfImage("30cm", "30cm");
 Wt::WPainter p1(&pdfImage);
 chart->paint(p1);
 std::ofstream f1("chart.pdf", std::ios::out | std::ios::binary);
 pdfImage.write(f1);
 */
#endif
}

void PspaApplication::updateSelections()
{
  string premierText, dernierText;
  if ( selectedSections_.size() > 0 )
    {
      premierText = dtmanage_->getLabelFromElementNumero(1);
      dernierText = dtmanage_->getLabelFromElementNumero( dtmanage_->beamLineSize() );
      (*selectedSections_.begin())->debut->setText(premierText);
      (*selectedSections_.begin())->fin->setText(dernierText);
    }

  cout << "PspaApplication::updateSelections(): " << premierText << " Ã   " << dernierText << endl;
}

string PspaApplication::getSelection()
{
  list<GWt_sectionToExecute*>::iterator itr = selectedSections_.begin();
  string str = (*itr)->fin->text().toUTF8();
  return str;
}

WText* PspaApplication::createTitle(const WString& title) 
{
  WText *result = new WText(title);
  result->setInline(false);
  result->setStyleClass("title");
  result->setMinimumSize(30,30);
  
  return result;
}

// void PspaApplication::addConsoleMessage(WString msg) {
//   WText *w = new WText(console_);
//   w->setTextFormat(PlainText);
//   w->setText(msg);
//   w->setInline(false);
  
//   /*
//    * Little javascript trick to make sure we scroll along with new content
//    */
//   WApplication *app = WApplication::instance();
//   app->doJavaScript(console_->jsRef() + ".scrollTop += "
//                     + console_->jsRef() + ".scrollHeight;");
  
// }


bool PspaApplication::removeExtensionFromConfigName(string& config)
{
  //  string configName;
  string extension(".save");
  bool test = true;
    string::size_type nn = config.rfind('.');
    if ( nn == string::npos ) 
      {
        // pas de point 
        test = false;
      }
    string fin = config.substr(nn);
    if ( fin != extension ) 
      {
        // l'extension n'est pas la bonne
        test = false;
      }
    if ( test )
      {
        string::size_type count = config.length() - extension.length();
        config = config.substr(0, count);
      }
    else
      {
          GWt_dialog checkConfigNameDialog(" checking config file name", " the file must have the extension " + extension, GWt_dialog::Error,true,true);
          checkConfigNameDialog.exec();
      }
    return test;
}

/////////////////////////
//   c'est un embryon d'histogramme

void PspaApplication::dessinerHistogramme()
{
  // pour mon test : histo en energie
  toto_->clear();

  GWt_dialog* pourVoir= new GWt_dialog("histogramme",toto_,false);
  pourVoir->setMinimumSize(400,400);
  pourVoir->setClosable(true);
  pourVoir->show();


  particleBeam* beam = dtmanage_->getDiagnosticBeam(1);
  vector<double> xcor;
  vector<int> hist;
  int cnts;
  beam->histogramme(xcor,hist,cnts);

  cout<<"xcor.size()= "<<xcor.size()<<", hist.size()= "<<hist.size()<<endl;

  //////////////////////////////////////////////////////////////////////////////////

  WContainerWidget *w = toto_;
  int nbpts= xcor.size()+cnts+1;
  WStandardItemModel *model = new WStandardItemModel(nbpts,2,w);
  model->setHeaderData(1, WString("energie"));

  int j= 0;
  if(hist[0] > 0) {
    model->setData(j,0,xcor[0]);
    model->setData(j,1,hist[0]);
    j++;
  } 
  model->setData(j,0,xcor[0]);
  model->setData(j,1,hist[0]);
  j++;
  for (int i = 1; i < nbpts; ++i) {
    if(hist[i] == 0) {
      if(hist[i-1] > 0) {
        model->setData(j,0,xcor[i]);
        model->setData(j,1,hist[i-1]);
        j++;
      }
      model->setData(j,0,xcor[i]);
      model->setData(j,1,hist[i]);
      j++;
    }
    if(hist[i] > 0) {
      model->setData(j,0,xcor[i]);
      model->setData(j,1,hist[i-1]);
      j++;
      model->setData(j,0,xcor[i]);
      model->setData(j,1,hist[i]);
      j++;
    }  
  }
  
  WCartesianChart *chart = new WCartesianChart(w);
  chart->setTitle("Histogramme");
  chart->setModel(model);        // set the model
  chart->setXSeriesColumn(0);    // set the column that holds the categories
  chart->setLegendEnabled(true); // enable the legend

   // Provide space for the X and Y axis and title.
  chart->setPlotAreaPadding(200, Right);
  chart->setPlotAreaPadding(80, Left);
  chart->setPlotAreaPadding(40, Top | Bottom);

  chart->setType(ScatterPlot);
  
  WAxis& axis = chart->axis(XAxis);
  axis.setLabelFormat("%.3f");
  axis.setGridLinesEnabled(true);
  chart->axis(Y1Axis).setGridLinesEnabled(true);

  WDataSeries s(1, LineSeries);
  chart->addSeries(s);
  

  chart->resize(800, 400);

  chart->setMargin(10, Top | Bottom);
  chart->setMargin(WLength::Auto, Left | Right);

  LegendLocation location = LegendOutside;
  Side side = Right;
  AlignmentFlag alignment = AlignMiddle;
  chart->setLegendLocation(location, side, alignment);
  chart->setLegendStyle(chart->legendFont(), WPen(black), WBrush(WColor(0xFF, 0xFA, 0xE5)));
 }