source: PSPA/Interface_Web/trunk/pspaWT/sources/userInterface/src/GWt_softwarePanel.cc @ 493

//  GWt_softwarePanel.cpp
//  PSPA
//
//  Created by Garnier Laurent on 30/01/13.//  Copyright (c) 2013 Garnier Laurent. All rights reserved.
//

#include <Wt/WLineEdit>
#include <Wt/WText>
#include <Wt/WComboBox>
#include <Wt/WPanel>
#include <Wt/WBreak>
#include <Wt/WApplication>
#include <Wt/WVBoxLayout>

#include "GWt_softwarePanel.h"
#include "GWt_dialog.h"
#include "GWt_console.h"
#include "GWt_computingBlock.h"
#include "GWt_globalParameters.h"
#include "GWt_sectionToExecute.h"
#include "GWt_pspaApplication.h"
#include "GWt_machine.h"
#define BAVARD 1

GWt_softwarePanelBis::GWt_softwarePanelBis(dataManager* dataManager,GWt_machine* mach)
  : WContainerWidget(),
dtmanage_(dataManager),
UImachine_(mach)
{
  
  // le panel
  WPanel *panelLogiciels = new WPanel(this);
  panelLogiciels->setTitle(" Computing blocks ");
  
  contenuSections_ = new WContainerWidget();
  contenuSections_->addWidget(new WBreak());
  contenuSections_->addWidget(new WBreak());
  cout << " GWt_softwarePanelBis::GWt_softwarePanelBis DISPLAY SOFTWARE PANEL " << endl;
      displayFromControler();
  
  panelLogiciels->setCentralWidget(contenuSections_);
}

GWt_softwarePanelBis::~GWt_softwarePanelBis() {
}

void GWt_softwarePanelBis::displayFromControler()
{      
  cout << " GWt_softwarePanelBis::displayFromControler() " << endl<<endl;

  // Clear all
  contenuSections_->clear();


  // Get all sectionsToExecute from this machine
  if (!UImachine_->getMachineControler()) {
    cout << " GWt_softwarePanelBis::displayFromControler() PAS DE MACHINE " << endl;
    return;
  } else {
    cout << " GWt_softwarePanelBis::displayFromControler() MACHINE TROUVEE " << endl;
  }
  
  if (UImachine_->getMachineControler()->getComputingBlocks().size() == 0) {
    // FIXME : Add a message to tell the user to add first an element
    cout << " GWt_softwarePanelBis::displayFromControler() PAS DE BLOCK " << endl;
  } else {
    cout << " GWt_softwarePanelBis::displayFromControler() NOMBRE DE BLOCK " << UImachine_->getMachineControler()->getComputingBlocks().size() << endl;

    unsigned int firstElemeOfComputingBlockIndex = 0;

    for (unsigned int a=0; a<UImachine_->getMachineControler()->getComputingBlocks().size(); a++) {
      cout << " GWt_softwarePanelBis::displayFromControler() BLOC No " << a+1 << endl;
      abstractElement* premierElement = NULL;
      abstractElement* dernierElement = NULL;
      std::string premierElementLabel = "";
      std::string dernierElementLabel = "";

      if ( !UImachine_->getMachineControler()->getComputingBlocks()[a]->isEmpty() ) {
        premierElement = UImachine_->getMachineControler()->getComputingBlocks()[a]->getFirstElement();
        firstElemeOfComputingBlockIndex = UImachine_->getMachineControler()->getComputingBlocks()[a]->getRankOfFirstElement();
        dernierElement = UImachine_->getMachineControler()->getComputingBlocks()[a]->getLastElement();
      }


      if (premierElement) premierElementLabel = premierElement->getLabel();
      if (dernierElement) dernierElementLabel = dernierElement->getLabel();
      cout << " GWt_softwarePanelBis::displayFromControler() dernier element a afficher " << dernierElementLabel << endl;
      
      WComboBox* lineFromCombo = new WComboBox();
      WComboBox* lineToCombo = new WComboBox();
      fillComboWithElements(lineFromCombo);
      fillComboWithElements(lineToCombo);
      
      // set to first
      lineFromCombo->setCurrentIndex(firstElemeOfComputingBlockIndex);
      // set to last
      lineToCombo->setCurrentIndex(UImachine_->getMachineControler()->getComputingBlocks()[a]->getRankOfLastElement());
      WComboBox* softCombo = new WComboBox();
      
      fillComboWithSoftwares(softCombo,UImachine_->getMachineControler()->getComputingBlocks()[a]->getSoftware()->getName());

      // disable the "to" comboBox
      lineToCombo->disable();

      // disable the first "from" comboBox
      // if (a==0) {
      //   lineFromCombo->disable();
      // }

      // enable the last "to" comboBox
      if (a==UImachine_->getMachineControler()->getComputingBlocks().size()-1) {
                lineToCombo->enable();
      }
      
      // // Add computingBlock Widget
      
      //      GWt_computingBlock* newBlock = new GWt_computingBlock(lineFromCombo,lineToCombo,softCombo,createAddDeletePushButtons(a),UImachine_->getMachineControler()->getComputingBlocks()[a],UImachine_);
      computingBlock* blocPtr = UImachine_->getMachineControler()->getComputingBlocks()[a];
      GWt_computingBlock* newBlock = new GWt_computingBlock(lineFromCombo,lineToCombo,softCombo,createAddDeletePushButtons(blocPtr),blocPtr,UImachine_);

      cout << " GWt_softwarePanelBis::displayFromControler j'ajoute un bloc : " << newBlock << endl;
      cout << " GWt_softwarePanelBis::displayFromControler nb widget avant : " << contenuSections_->count() << endl;
      contenuSections_->addWidget(newBlock);
      cout << " GWt_softwarePanelBis::displayFromControler nb widget apres : " << contenuSections_->count() << endl;
      
    }
  }
}

void GWt_softwarePanelBis::fillComboWithElements(Wt::WComboBox* cBox) 
{

  if (cBox == NULL) return;

  if (!UImachine_->getMachineControler()) {
    return;
  }
    for(unsigned int b=0; b < UImachine_->getMachineControler()->getElements().size(); b++) {
      
      abstractElement* abs = UImachine_->getMachineControler()->getElements()[b];
      if (abs != NULL) {
        cBox->addItem(abs->getLabel());
      }
    }
}

void GWt_softwarePanelBis::fillComboWithSoftwares(Wt::WComboBox* cBox, std::string selected)
{
#if BAVARD > 0
  cout << "***********************************" << endl;
  cout << " GWt_softwarePanel::fillComboWithSoftwares " << endl<<endl;
#endif

  if (cBox == NULL) return;
  cBox->clear();

  unsigned nb = nomDeLogiciel::getNumberOfSoftwares();
  unsigned k;
  for(k = 0; k <= nb; k++) { //xx
    cBox->addItem(nomDeLogiciel(k).getString());
    if (nomDeLogiciel(k).getString() == selected) {
      cBox->setCurrentIndex(cBox->count()-1);
    }
  }
  cBox->refresh();
}


Wt::WContainerWidget* GWt_softwarePanelBis::createAddDeletePushButtons(computingBlock* cpbl) 
{
  WContainerWidget* buttonContainer= new WContainerWidget();
  
  Wt::WHBoxLayout* buttonContainerLayout = new Wt::WHBoxLayout();
  buttonContainerLayout->setContentsMargins(0,0,0,0);
  // preparation du bouton add
  WPushButton* exec_add = new WPushButton("+");
  //  exec_add->clicked().connect(this, &GWt_softwarePanelBis::addComputingBlock);
  exec_add->clicked().connect(boost::bind(&GWt_softwarePanelBis::addComputingBlock, this, cpbl));
  exec_add->setStyleClass("roundButton");
  exec_add->setMaximumSize(20,20);
  exec_add->setToolTip("Add new section");
  
  // preparation du bouton delete
  WPushButton* exec_delete = new WPushButton("-");
  //  warningsContainer_->setStyleClass("warningsContainer");

  exec_delete->clicked().connect(boost::bind(&GWt_softwarePanelBis::deleteComputingBlock, this, cpbl));
  exec_delete->setStyleClass("roundButton");
  exec_delete->setMaximumSize(20,20);
  exec_delete->setToolTip("Remove this section");

  buttonContainerLayout->addWidget(exec_add);
  buttonContainerLayout->addWidget(exec_delete);
  buttonContainer->setLayout(buttonContainerLayout);

  return buttonContainer;
}

void GWt_softwarePanelBis::addComputingBlock(computingBlock* cpbl) {
  // We put the last element of the previous sectionToExecute inside
  
  if (!UImachine_->getMachineControler()) {
    return;
  }
  //  UImachine_->getMachineControler()->openNewLastBlock();
    UImachine_->getMachineControler()->openNewBlockAfter(cpbl);
  displayFromControler();
}


// void GWt_softwarePanelBis::deleteComputingBlock(int sectionLabel)
// {
//   cout << " GWt_softwarePanelBis::deleteComputingBlock()" << endl;

//   stringstream st;
//   st << sectionLabel;
//   std::string sectionName = st.str();
//   //FIXME
//   vector<computingBlock*>& compBloc = UImachine_->getMachineControler()->getComputingBlocks();
//   cout << " GWt_softwarePanelBis::deleteComputingBlock() nb blocs = " << compBloc.size() << endl;
//   cout << " GWt_softwarePanelBis::deleteComputingBlock() nb widgets = " << sectionName << endl;
//   cout << " GWt_softwarePanelBis::deleteComputingBlock() nom bloc a detruire = " << contenuSections_->count() << endl;

//   for ( unsigned k=0; k <  compBloc.size(); k++) {

//   }
// /*  if ( dtmanage_->getJobListSize() == 0 ) return;
//   for (unsigned int sectionIndex = 0; sectionIndex< UIsectionsToExecute_deprecated_.size(); sectionIndex++) {
//     if (UIsectionsToExecute_deprecated_[sectionIndex]->objectName() == sectionName) {

//       // delete from dataManager
//       UIsector_->getSectorControler()->clearSectionToExecute(sectionIndex);

//       // delete from User Interface
//       contenuSections_->removeWidget(UIsectionsToExecute_deprecated_[sectionIndex]);
//       delete UIsectionsToExecute_deprecated_[sectionIndex];
//       UIsectionsToExecute_deprecated_.erase (UIsectionsToExecute_deprecated_.begin()+sectionIndex);
//     }
//   }  
// */
//   displayFromControler();
// }

void GWt_softwarePanelBis::deleteComputingBlock(computingBlock* cpbl)
{
  cout << " GWt_softwarePanelBis::deleteComputingBlock(computingBlock*)" << endl;

  UImachine_->getMachineControler()->eraseComputingBlock(cpbl);
  displayFromControler();
}