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

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

#include "GWt_pspaApplication.h"
#include "GWt_ligneFaisceau.h"
#include "GWt_softwarePanel.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 "GWt_serverFileSelector.h"
#include "trivaluedBool.h"

#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>
#include <Wt/WLineEdit>
#include <Wt/WRadioButton>

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());
    }
    
    // register the absractElementFactory
    abstractElementFactory_ = new GWt_abstractElementFactory();
    abstractElementFactory_->setRFGunEnable(true);
    abstractElementFactory_->setDriftEnable(true);
    abstractElementFactory_->setCellEnable(true);
    abstractElementFactory_->setBendEnable(true);
    abstractElementFactory_->setSolenoEnable(true);
    abstractElementFactory_->setBeamEnable(true);
    abstractElementFactory_->setFitEnable(true);
    
    // include the styleSheet
    WContainerWidget *widroot = root();
    useStyleSheet       ("htdocs/pspa.css");
    dtmanage_ = new dataManager(this);
    dtmanage_->setWorkingDir(workingDir_);
    /*
     * 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);
    
    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);
    
    executeWidget_ = new GWt_softwarePanel(dtmanage_,this);
    
    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();
  vector <GWt_abstractElement*> elems = abstractElementFactory_->getAllElements();
  for (unsigned a = 0; a < elems.size(); a++) {
    elems[a]->createDragImage(palette);
    new WBreak(palette);
  }

  return palette;  
}

void PspaApplication::createDragImage(const char *url,const char *smallurl,const char *mimeType,WContainerWidget *p,WString())
{
  GWt_draggableImage *result = new GWt_draggableImage(url,p);
  
  /*
   * Set the image to be draggable, showing the other image (dragImage)
   * to be used as the widget that is visually dragged.
   */
  result->setDraggable(mimeType,new WImage(smallurl,p),true);
}

void PspaApplication::createBeamLine()
{
  beamLine_ = new GWt_LigneFaisceau(this);
  beamLine_->setMinimumSize(300,100);
}

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


void PspaApplication::dialogOnGraphics()
{
  graphicsDialog_->show();
}

WContainerWidget* PspaApplication::createDrawingWidget()
{
  WGridLayout *glayout= new WGridLayout();
  WContainerWidget* dessin = new WContainerWidget();
  dessin->setLayout(glayout);

  group_ = new Wt::WButtonGroup(this);
  
  /////////////////////////////////////////////////////////////////////
       
  choixEnveloppeDessin_ = new WComboBox();
  choixEnveloppeDessin_->addItem("x");
  // choixEnveloppeDessin_->addItem("y");
  Wt::WRadioButton *button1= new WRadioButton(" enveloppe");
  group_->addButton(button1,1);
  glayout->addWidget(button1,0,1);
  glayout->addWidget(choixEnveloppeDessin_,0,2);
  /////////////////////////////////////////////////////////////////////

  choixElementDessin_ = new WComboBox();
  choixElementDessin_->setMinimumSize(50,10);
  choixTypeDessinFaisceau_ = new WComboBox();
  choixTypeDessinFaisceau_->addItem("courant_snyder");
  choixTypeDessinFaisceau_->addItem("macroparticles");
  Wt::WRadioButton *button2= new WRadioButton(" phase space after element");

    choixAbsPhase_ = new WComboBox();
    choixAbsPhase_->addItem("x");
    choixAbsPhase_->addItem("y");
    choixAbsPhase_->addItem("z");
    choixAbsPhase_->addItem("xp");
    choixAbsPhase_->addItem("yp");
    choixAbsPhase_->addItem("dE/E");
    choixAbsPhase_->setCurrentIndex(0);

    choixOrdPhase_ = new WComboBox();
    choixOrdPhase_->addItem("x");
    choixOrdPhase_->addItem("y");
    choixOrdPhase_->addItem("z");
    choixOrdPhase_->addItem("xp");
    choixOrdPhase_->addItem("yp");
    choixOrdPhase_->addItem("dE/E");
    choixOrdPhase_->setCurrentIndex(3);



  group_->addButton(button2,2);
  glayout->addWidget(button2,1,1);
  glayout->addWidget(choixElementDessin_,1,2);
  glayout->addWidget(choixTypeDessinFaisceau_,1,3);
  //  glayout->addWidget(new WText("abs. :"),2,2);
  glayout->addWidget(choixAbsPhase_,2,2);
  //  glayout->addWidget(new WText("ord. :"),2,4);
  glayout->addWidget(choixOrdPhase_,2,3);
  /////////////////////////////////////////////////////////////////////

  choixHistoDessin_ = new WComboBox();
  Wt::WRadioButton *button3= new WRadioButton(" histogram after element");
  group_->addButton(button3,3);
  glayout->addWidget(button3,3,1);
  glayout->addWidget(choixHistoDessin_,3,2);
  /////////////////////////////////////////////////////////////////////
  
  WPushButton *close= new WPushButton("close"); 
  glayout->addWidget(close,4,1);
  close->clicked().connect(this,&PspaApplication::closeGraphicDialog);
  
  WPushButton *draw= new WPushButton("draw"); 
  glayout->addWidget(draw,4,2,2,1);
  draw->clicked().connect(this,&PspaApplication::dessiner);
  /////////////////////////////////////////////////////////////////////

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

void PspaApplication::closeGraphicDialog()
{
  cout << " close graphicsDialog_" << endl;
  for(unsigned i = 0; i < eDialog_.size(); i++) eDialog_[i]->done(WDialog::Rejected);
  eDialog_.clear();
  graphicsDialog_->done(WDialog::Rejected);
}

void PspaApplication::dessiner()
{
  int k= group_->checkedId();
  cout << "dessiner k= " << k << endl;

  switch(k) {
  case  1: 
    dessinerEnveloppe();
    break;
  case 2:
    dessinerPhaseSpace();
    break;
  case 3:
    dessinerHistogramme();
    break;
  default:
    GWt_dialog graphicalWarning("graphical analysis","select a button",GWt_dialog::Warning,false,true);
    graphicalWarning.exec();
    break;
  }
}

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( nameOfCase_);
}


void PspaApplication::restaurer()
{
    GWt_serverFileSelector * fs = new GWt_serverFileSelector("Select a configuration file",workingDir_);
    nameOfCase_ = fs->exec();
    
    if (nameOfCase_ == "")
        return;
    
    dialogSave_ = NULL;
    
    bool test = dtmanage_->restoreElements(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();
    
    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(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();
                
        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();
  choixHistoDessin_->clear();
  int nombre = dtmanage_->getBeamLineSize();
  cout << " PspaApplication::faireDessin() nb elements : " << nombre << endl;
  for(int i = 1; i <= nombre; i++) {
    choixElementDessin_->addItem(dtmanage_->getLabelFromElementNumero(i));
    choixHistoDessin_->addItem(dtmanage_->getLabelFromElementNumero(i));
  } 
}

void PspaApplication::dessinerPhaseSpace()
{    
  toto_->clear();
    
  int typeFaisceau = choixTypeDessinFaisceau_->currentIndex();
  int index = choixElementDessin_->currentIndex();
  unsigned xabs = choixAbsPhase_->currentIndex();
  unsigned yord = choixOrdPhase_->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, xabs, yord);
      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);
  eDialog_.push_back(envDialog);
  envDialog->setMinimumSize(400,400);
  envDialog->setClosable(true);
  envDialog->show();
      
  //       new WText(nameOfCase_ + " : enveloppe", toto);
  unsigned nbel = dtmanage_->getBeamLineSize();
  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, unsigned indexAbs, unsigned indexOrd )
{
  cout << " faireDessinParmela " << endl;
  GWt_dialog* pointsDialog = new GWt_dialog("space phase",toto,false);
  eDialog_.push_back(pointsDialog);
  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(), 2, pointsDialog->contents());
    //    model->setHeaderData(0, WString("X"));
    //   model->setHeaderData(1, WString("Y = sin(X)"));
    
    if ( indexAbs > 5 || indexOrd > 5 ) return;

    for (unsigned i = 0; i < partic.size(); ++i) {
      double valAbs, valOrd;
      double begamz = partic.at(i).getBetaGamma().getComponent(2);
      if ( indexAbs <= 2 ) {
        valAbs = partic.at(i).getPosition().getComponent(indexAbs);
        cout << " i= " << i << " valabs = " << valAbs << endl;
      } else {
        if ( indexAbs == 5 ) {
          cout << " PspaApplication::faireDessinParmela : deltap non programme " << endl;
          return;
        } else {
          if ( begamz != 0.0) {
            valAbs = 1.e3*partic.at(i).getBetaGamma().getComponent(indexAbs-3)/begamz;
          } else {
            valAbs = 0.0;
          }
        }
      }

      if ( indexOrd <= 2 ) {
        valOrd = partic.at(i).getPosition().getComponent(indexOrd);
      } else {
        if ( indexOrd == 5 ) {
          cout << " PspaApplication::faireDessinParmela : deltap non programme " << endl;
          return;
        } else {


          if ( begamz != 0.0) {
            valOrd = 1.e3*partic.at(i).getBetaGamma().getComponent(indexOrd-3)/begamz;
          } else {
            valOrd = 0.0;
          }
        cout << " i= " << i << " valord = " << valOrd << endl;
        }
      }
      

        // double x= partic.at(i).getPosition().getComponent(0);
        // double begamz = partic.at(i).getBetaGamma().getComponent(2);
        // double xp;
        // if ( begamz != 0.0) {
        //   xp = partic.at(i).getBetaGamma().getComponent(0)/begamz;
        // } else {
        //   xp = 0.0;
        // }
        // //    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);
        model->setData(i, 0, valAbs);
        model->setData(i, 1,  valOrd);
    }
      cout << " faireDessinParmela : FAISCEAU VU  " << endl;

    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::faireDessinTransport(WContainerWidget* toto, particleBeam* beam)
{
  GWt_dialog* ellipseDialog = new GWt_dialog("ellipse",toto,false);
  eDialog_.push_back(ellipseDialog);
  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
}



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;
}

void PspaApplication::dessinerHistogramme()
{
  // pour mon test : histo en energie
  toto_->clear();
  
  GWt_dialog* histoDialog = new GWt_dialog("histogramme",toto_,false);
  eDialog_.push_back(histoDialog);
  histoDialog->setMinimumSize(400,400);
  histoDialog->setClosable(true);
  histoDialog->show();
  
  int index = choixHistoDessin_->currentIndex();    
  particleBeam* beam = dtmanage_->getDiagnosticBeam(index);
  if (beam == NULL) {
    GWt_dialog warningBeamState("histogram","the beam does not exist at the end of this element !", GWt_dialog::Error, false,true);
    warningBeamState.exec();
    return;
  }
  
  if (!beam->particleRepresentationOk()) {
    GWt_dialog warningBeamState("histogram", "the beam state does not allow providing a drawing with macroparticles !", GWt_dialog::Error, false,true);
    warningBeamState.exec();
    return;
  }

  vector<double> xcor;
  vector<int> hist;
  int cnts;
  double out[3]= {0.0};
  beam->histogramme(xcor,hist,cnts,out);
  
  cout<<"xcor.size()= "<<xcor.size()<<", hist.size()= "<<hist.size()<<endl;
  //////////////////////////////////////////////////////////////////////////////////

  WContainerWidget *w= histoDialog->contents();
  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++;
    }
  }
  
  // legendes
  new WText(" entries : "+ mixedTools::intToString((int)out[0]),w);
  new WBreak(w);
  new WText(" mean : "+ mixedTools::doubleToString(out[1])+" MeV",w);
  new WBreak(w);
  new WText(" rms : "+ mixedTools::doubleToString(out[2])+" KeV",w);
  
  WCartesianChart *chart = new WCartesianChart(w);
  chart->setTitle("Histogram of particle energies");
  chart->setModel(model);        // set the model
  chart->setXSeriesColumn(0);    // set the column that holds the categories
  chart->setLegendEnabled(false); // 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);
  axis.setTitle(WString("legende x"));

  chart->axis(Y1Axis).setGridLinesEnabled(true);
  chart->axis(Y1Axis).setTitle(WString("legende y"));
    
  WDataSeries s(1, LineSeries);
  s.setFillRange(ZeroValueFill);
  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)));
}