source: PSPA/Interface_Web/trunk/pspaWT/src/GWt_pspaApplication.cc @ 87

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

#include <Wt/WLineEdit>
#include <Wt/WText>
#include <Wt/WGridLayout>
#include <Wt/WVBoxLayout>
#include <Wt/WHBoxLayout>
#include <Wt/WImage>
//#include <Wt/WTextArea>
#include <Wt/WBreak>
#include <Wt/WStandardItemModel>
#include <Wt/Chart/WCartesianChart>

#include "GWt_pspaApplication.h"
#include "GWt_LigneFaisceau.h"
#include "GWt_globalParameters.h"
#include "bareParticle.h"
#include "nomDeLogiciel.h"
#include "mixedTools.h"

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


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

  createDragImage("icons/drift.jpg",
                  "icons/drift.jpg","icons/drift.jpg", palette,"drift");
  new WBreak(palette);

  createDragImage("icons/cell.jpg",
                  "icons/cell.jpg","icons/cell.jpg", palette,"cell");
  new WBreak(palette);

  createDragImage("icons/beam.jpg",
                  "icons/beam.jpg","icons/beam.jpg", palette,"beam");
  new WBreak(palette);

  createDragImage("icons/bend.jpg",
                  "icons/bend.jpg","icons/bend.jpg", palette,"bend");
  new WBreak(palette);

  createDragImage("icons/final.jpg",
                  "icons/final.jpg","icons/final.jpg", palette,"final");
  new WBreak(palette);

  createDragImage("icons/lens.jpg",
                  "icons/lens.jpg","icons/lens.jpg", palette,"lens");
  new WBreak(palette);

  palette->setMinimumSize(100,300);

  return palette;
}

WWidget* PspaApplication::createBeamLine()
{
  WContainerWidget* beamLine=new GWt_LigneFaisceau(this);
  beamLine->setMinimumSize(600,200);
  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();


  //   WVBoxLayout* executeLayout = new WVBoxLayout();

  //  executeW->decorationStyle().setBackgroundColor (WColor("yellow"));
  executeW->setMaximumSize(600,150);
  executeW->setMinimumSize(600,150);

  


    //    executeLayout->addWidget(boutonGo);

  // 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_);
  //executeLayout->addWidget(executeW);

  //    executeW->setLayout(executeLayout);


  return executeW;
}

void PspaApplication::addSectionToExecuteW()
{
  unsigned k;
  string premierText, dernierText;

  disableSectionExecute();


  if ( selectedSections_.size() == 0)
    {
      premierText = "1";
      dernierText = mixedTools::intToString( dtmanage_->beamLineSize() );
    }
  else  
    {
      dernierText = selectedSections_.back()->fin->text().toUTF8();
      int dernierNumero = atoi(dernierText.c_str());
      dernierNumero++;
      if ( dernierNumero <= dtmanage_->beamLineSize() )
        {
          premierText = mixedTools::intToString(dernierNumero);   
          dernierText = premierText;
        }
      else 
        {
          premierText = mixedTools::intToString( dtmanage_->beamLineSize() );
          dernierText = premierText;
        }
    }


  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;


  // contenuSections_->addWidget(new WText(" from : "));
  // contenuSections_->addWidget(selectedSections_.back()->debut);
  // contenuSections_->addWidget(new WText(" to : "));
  // contenuSections_->addWidget(selectedSections_.back()->fin);
  // contenuSections_->addWidget(selectedSections_.back()->selection);

  //  newSection->addWidget(new WBreak());
  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();
  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
  (*selectedSections_.begin())->debut->setText("1");
  string currentString =  (*selectedSections_.begin())->fin->text().toUTF8();
  int current = atoi ( currentString.c_str() );
  if ( current <= 0 ) 
    {
      (*selectedSections_.begin())->fin->setText("1");
      current = 1;
    }
  current++;
  if ( current > dtmanage_->beamLineSize() ) current = dtmanage_->beamLineSize();
  currentString = mixedTools::intToString(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++)
    {
      //      string debString = (*itr)->debut->text().toUTF8();
      // debut
      (*itr)->debut->setText(  currentString );
      // fin
      string finString =  (*itr)->fin->text().toUTF8();
      if ( atoi(finString.c_str() ) < current)
        {
          (*itr)->fin->setText(  currentString );
        }

      // preparation de la ligne suivante
      finString =  (*itr)->fin->text().toUTF8();
      current = atoi(finString.c_str()) +1;
      if ( current > dtmanage_->beamLineSize() ) current = dtmanage_->beamLineSize();
      currentString = mixedTools::intToString(current);
    }
  exec_go_->setDisabled(false);
}

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

PspaApplication::PspaApplication(const WEnvironment& env)
  : WApplication(env)
{
  setTitle("portail PSPA");                               // application title


  if (wApp->environment().javaScript()) {

    dtmanage_ = new dataManager();

    WGridLayout* vBoxLayout = new WGridLayout();

    //    WContainerWidget* iconAndBeamLineContainer = new WContainerWidget();

    WGridLayout* calculLayout = new WGridLayout();


    WGridLayout *iconAndBeamLineLayout = new WGridLayout();


    console_ = new WTextArea();
    console_->setMaximumSize(600,200);


    WGridLayout* toolbarLayout = new WGridLayout();


    //    WPushButton *boutonGo = new WPushButton("execute!");
    WPushButton* boutonSauve = new WPushButton(" sauvegarder la config");
    WPushButton* boutonRestaure = new WPushButton(" restaurer la config");
    //    toolbarLayout->addWidget(boutonGo , 0, 0);
    toolbarLayout->addWidget(boutonSauve , 0, 1);
    toolbarLayout->addWidget(boutonRestaure , 0, 2);

    // boutonGo->clicked().connect(this, &PspaApplication::executer);
    boutonSauve->clicked().connect(this, &PspaApplication::sauver);
    boutonRestaure->clicked().connect(this, &PspaApplication::restaurer);

    beamLine_ = createBeamLine();
    //  calculLayout->addWidget(beamLine_ , 0, 0);

  globalParam_ = createGlobalParamWidget();

 WWidget* executeWidget = createExecuteWidget();

  WGridLayout* globLayout = new WGridLayout();


  //  WContainerWidget* toto = faireDessin();

  leDessin_ = new WContainerWidget();
     new WText("emittance", leDessin_);


  globLayout->addWidget(globalParam_,0,0);
  globLayout->addWidget(executeWidget,1,0);

  globLayout->addWidget(leDessin_,0,1);
  //  calculLayout->addLayout(globLayout,1,0);

  //  calculLayout->addWidget(globalParam_,1,0);


  calculLayout->addWidget(beamLine_ , 1, 0);
  calculLayout->addLayout(globLayout,2,0);
  calculLayout->addLayout(toolbarLayout  ,0,0);
  iconAndBeamLineLayout->addWidget(createPalette() , 0, 0);
  iconAndBeamLineLayout->addLayout(calculLayout  ,0,1);

    iconAndBeamLineLayout->setColumnResizable(0);
    iconAndBeamLineLayout->setColumnStretch(1,1);

  vBoxLayout->addLayout(iconAndBeamLineLayout,1,0);
  vBoxLayout->addWidget(console_,2,0);


    vBoxLayout->setRowResizable(0);
    vBoxLayout->setRowStretch(0,1);

    root()->setLayout(vBoxLayout);

  } else {
    new WText("<i>This examples requires that javascript support is enabled.</i>",root());
  }

}

void PspaApplication::createDragImage(const char *url, const char *smallurl,
                        const char *mimeType,
                                      WContainerWidget *p,WString name)
{
  WImage *result = new WImage(url, p,name);
  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.
   */
  //  printf(" setDraggable %s \n",mimeType);
  result->setDraggable(mimeType, dragImage, true);

}


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

//   int debut, fin;
//   nomDeLogiciel prog;
//   dtmanage_->clearSectionToExecute();
//   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();
//       debut = atoi( debString.c_str()  );
//       fin = atoi(  finString.c_str() );
//       prog = nomDeLogiciel ( (*itr)->selection->currentIndex() );
//       dtmanage_->addSectionToExecute(debut, fin, prog);
//     }

//   string resultat = dtmanage_->executeAll();
//   addConsoleMessage(resultat);
//   faireDessin();
// }

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

  int debut, fin;
  nomDeLogiciel prog;
  list<GWt_sectionToExecute*>::iterator itr;
  dtmanage_->initializeExecution();
  for (itr= selectedSections_.begin(); itr != selectedSections_.end(); itr++)
    {
      string debString = (*itr)->debut->text().toUTF8();
      string finString = (*itr)->fin->text().toUTF8();
      debut = atoi( debString.c_str()  );
      fin = atoi(  finString.c_str() );
      prog = nomDeLogiciel ( (*itr)->selection->currentIndex() );
      cout << " PspaApplication::executer() on lance l'execution de : " << prog.getString() << endl;
      string resul;
        if ( prog == nomDeLogiciel::parmela ) 
          {
            resul = dtmanage_->executeParmela( debut, fin);
                    faireDessin();
            addConsoleMessage(resul);
          }
        else if ( prog == nomDeLogiciel::transport ) 
          {
            resul = dtmanage_->executeTransport( debut, fin);
            faireDessinTransport();
            addConsoleMessage(resul);
          }
        else 
          {
            resul =  " unknown software -- STOP \n ";   
            addConsoleMessage(resul);
            break;
          }
    }
}


void PspaApplication::sauver()
{
  cout << " on sauve " << endl;
  addConsoleMessage("sauvegarde");
  GWt_globalParameters* bibi = static_cast<GWt_globalParameters*>(globalParam_);
  bibi->updateGlobals();
  dtmanage_->saveAll();

}

void PspaApplication::restaurer()
{

  addConsoleMessage(string("restauration..."));

  dtmanage_->restoreAll();

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

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

  bobo->restoreElementCollection();
  addConsoleMessage(string("...terminee"));
}



void PspaApplication::faireDessin()
{
  WContainerWidget* toto = leDessin_;
  toto->clear();
       new WText("emittance", toto);
  vector<bareParticle>& partic = dtmanage_->getCurrentBeam().getParticleVector();


  WStandardItemModel *model = new WStandardItemModel(partic.size(), 3, toto);
  //    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, 10*x);
    model->setData(i, 1,1.e3*xp);
    model->setData(i, 2,2.e3*xp);
  }

  WCartesianChart *chart = new WCartesianChart(toto);
  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(300, 300); // WPaintedWidget must be given explicit size

  //  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 = leDessin_;
  toto->clear();
  new WText("emittance transport", toto);

  vector<double> xcor;
  vector<double> ycor;
  dtmanage_->getCurrentBeam().donneesDessinEllipseXxp(xcor,ycor);
  int nbpts = xcor.size();
  cout << " PspaApplication::faireDessinTransport() 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));
  }

  WCartesianChart *chart = new WCartesianChart(toto);
  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->resize(300, 300); // WPaintedWidget must be given explicit size

}




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

}