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

#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 "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>

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();
    //  palette->setLayout(new WVBoxLayout());
    
    // nomdElements *e= new nomdElements();
    // int nElts= e->getNumberOfElements();
    // delete e;
    //  nomdElements bidon;
    
    vector <GWt_abstractElement*> elems = abstractElementFactory_->getAllElements();
    for (int a = 0; a< elems.size(); a++) {
        elems[a]->createDragImage(palette);
        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);
    
    /*
     * 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()
{
    // 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::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()
{
    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(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->restoreElementCollectionFromDataManager();
    
    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();
    int nombre = dtmanage_->getBeamLineSize();
    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_->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)
{
    
    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
}



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