Changeset 305 in PSPA for Interface_Web


Ignore:
Timestamp:
Feb 1, 2013, 8:08:52 PM (11 years ago)
Author:
garnier
Message:

Suppression de la classe "elementsCollection" et bug fixed #20

Location:
Interface_Web/trunk/pspaWT
Files:
36 edited

Legend:

Unmodified
Added
Removed

  • Interface_Web/trunk/pspaWT/History

    r302 r305  
    66     =========================================================
    77
    8 31 Janvier 2012  Laurent Garnier
     81er Février 2013 Laurent Garnier
     9- Suppression de la classe "elementsCollection", celle-ci stockait le contenu de
     10  la beamLine, qui était déja stokée de façon graphique, toutes les méthodes ont étées
     11  reportées sur le dataManager
     12
     13- abstractSoftware, softwareTransport, softwareParmela :
     14  o  remplacement de "elementsCollection" par "dataManager"
     15
     16- dataManager : Ajout des méthodes provenant de "elementsCollection"
     17- GWt_elementLigneFaisceau :
     18  o suppression de l'image "fleche" et quelques renommages
     19- GWt_bend, GWt_drift, GWt_beam
     20  GWt_soleno, GWt_fit, GWt_rfgun
     21  GWt_cell : quelques simplifications internes
     22- GWt_LigneFaisceau :
     23  o Ajout des méthodes provenant de "elementsCollection"
     24  o mise à jour des labels à chaque ajout d'élément
     25- PspaApplication : qq changements pour la lecture/sauvegarde des éléments (bug fixed #20)
     26- GWt_abstractElement : quelques renommages
     27- GWt_softwarePanel : remplacement de "elementsCollection" par "dataManager"
     28
     2931 Janvier 2013  Laurent Garnier
    930- dataManager : Suppression des références au workingDir et passage de
    1031  cette variable dans la classe elle même
    … …  
    1334- GWt_softwarePanel : Création de cette classe pour gérer l'ancien "executeWidget"
    1435
    15 30 Janvier 2012  Laurent Garnier
     3630 Janvier 2013  Laurent Garnier
    1637- dataManager : Ajout de la méthode removeElement()
    1738- GWt_elementLigneFaisceau : Amélioration de la gestion interne à cette classe
    … …  
    2950 classes héritées softwareParmela, softwareTransport
    3051
    31 29 Janvier 2012  Laurent Garnier
     5229 Janvier 2013  Laurent Garnier
    3253- Ajout de la classe GWt_abstractElementFactory
    3354- GWt_bend, GWt_drift, GWt_beam
    … …  
    4566- GWt_pspaApplication : ajout d'une abstractElementFactory
    4667
    47 28 Janvier 2012  Laurent Garnier
     6828 Janvier 2013  Laurent Garnier
    4869- GWt_ligneFaisceau:
    4970  o Suppression de code inutile
    … …  
    6586  o Remise en ordre du label sans les 999
    6687
    67 25 Janvier 2012  Laurent Garnier
     8825 Janvier 2013  Laurent Garnier
    6889- Insertion dans la drop box ok + images ok
    6990- Restaurer la config refonctionne
    7091- Avec un ascenseur qui marche mieux
    7192 
    72 24 Janvier 2012  Laurent Garnier
     9324 Janvier 2013  Laurent Garnier
    7394- Ameliorations sur la drop zone
    7495- re-identation du code dans la partie graphique
    7596- Insertion dans la drop box ok
    7697
    77 23 Janvier 2012  Laurent Garnier
     9823 Janvier 2013  Laurent Garnier
    7899- quelques renommages et améliorations sur la drop zone
    79100
    80 22 Janvier 2012  Laurent Garnier
     10122 Janvier 2013  Laurent Garnier
    81102- Fix probleme de compilation introduit par la derniÚre revision (260)
    82103- refactoring (suite)
    83104
    84 21 Janvier 2012  Laurent Garnier
     10521 Janvier 2013  Laurent Garnier
    85106- Grosse modifications pour une meilleur gestion des drag & drop (a terminer)
    86107- Deplacement des styles dans la feuille css
    … …  
    90111- refactoring
    91112
    92 19 Janvier 2012  Laurent Garnier
     11319 Janvier 2013  Laurent Garnier
    93114- Ajout d'icones pour la toolbar et d'un fond sur le programme
    94115
    95 18 Janvier 2012  Laurent Garnier
     11618 Janvier 2013  Laurent Garnier
    96117- Mise à jour de la partie web (drop zone). Aucune modification majeures,
    97118  uniquement des méthodes modifiées en vue de faire mieux. Quelques problÚmes

  • Interface_Web/trunk/pspaWT/sources/controler/include/abstractSoftware.h

    r304 r305  
    1111using namespace std;
    1212
     13class dataManager;
     14
    1315class abstractSoftware
    1416{
    … …  
    1719
    1820  globalParameters* globParamPtr_;
    19   elementsCollection* beamLinePtr_;
     21  dataManager* dataManager_;
    2022
    2123
    … …  
    2628 public :
    2729
    28   abstractSoftware(globalParameters* globals, elementsCollection* beamLine);
     30  abstractSoftware(globalParameters* globals, dataManager* dt);
    2931  ~abstractSoftware() {;}
    3032

  • Interface_Web/trunk/pspaWT/sources/controler/include/dataManager.h

    r302 r305  
    1313#include "parmelaParticle.h"
    1414
    15 
     15class PspaApplication;
    1616
    1717class dataManager
    1818{
    1919   
    20     elementsCollection elementsGallery_;
    21     globalParameters globParam_;
    22     particleBeam* currentBeam_;
    23    
    24     vector<particleBeam> diagnosticBeam_;
    25    
    26     vector<sectionToExecute*> jobList_;
    27    
    28     void removeFile(string nameOfFile);
    29     void clearSectionToExecute();
    3020public:
    3121   
    32     dataManager() {
    33         currentBeam_ = NULL;
    34         workingDir_="";
    35     }
    36     ~dataManager() {
    37         unsigned k;
    38         for (k=0; k < jobList_.size();k++) {
    39             if ( jobList_[k] != NULL ) delete jobList_[k];
    40         }
    41         if ( currentBeam_ == NULL ) delete currentBeam_;
    42     }
     22    dataManager(PspaApplication*);
     23    virtual ~dataManager();
    4324   
    44     inline int beamLineSize() {return elementsGallery_.size();}
     25    inline int getBeamLineSize();
    4526    inline globalParameters* getGlobalParameters()  {return &globParam_;}
    46     inline elementsCollection* getCollection() {return &elementsGallery_;}
     27//    inline elementsCollection* getCollection() {return &elementsGallery_;}
    4728    inline particleBeam* getCurrentBeam() {return currentBeam_;}
    4829   
    … …  
    5334    abstractElement* addElement(typedElement elemType);
    5435    void removeElement(string);
     36
     37    /**
     38     Get the label from the order number in the beam line
     39     @return return "" if not found
     40     */
    5541    string getLabelFromElementNumero(int numero);
     42
     43    /**
     44     Get the numero from the label in the beam line
     45     @return return -1 if not found
     46     */
     47    int getNumeroFromElementLabel(string);
     48    abstractElement* getElementPointerFromIndex(int);
     49   
    5650    void initializeExecution();
    5751    trivaluedBool checkExecute(string& diagnostic);
    … …  
    6660   
    6761private:
     62    //    elementsCollection elementsGallery_;
     63    globalParameters globParam_;
     64    particleBeam* currentBeam_;
     65   
     66    vector<particleBeam> diagnosticBeam_;
     67   
     68    vector<sectionToExecute*> jobList_;
     69   
     70    void removeFile(string nameOfFile);
     71    void clearSectionToExecute();
     72
    6873    string workingDir_;
     74    PspaApplication* pspa_;
    6975};
    7076#endif

  • Interface_Web/trunk/pspaWT/sources/controler/include/elementsCollection.h

    r295 r305  
    2727  abstractElement* getElementPointerFromNumero(int num) const;
    2828
    29   int getNumeroFromLabel(string lab);
     29  int getNumeroFromElementLabel(string lab);
    3030
    3131  void eraseElement(string label);

  • Interface_Web/trunk/pspaWT/sources/controler/include/softwareGenerator.h

    r304 r305  
    1818
    1919
    20  softwareGenerator(globalParameters* globals, elementsCollection* beamLine);
     20 softwareGenerator(globalParameters* globals, dataManager* );
    2121
    2222  virtual ~softwareGenerator() {;}

  • Interface_Web/trunk/pspaWT/sources/controler/include/softwareParmela.h

    r304 r305  
    1414
    1515 public :
    16   softwareParmela(globalParameters* globals, elementsCollection* beamLine);
     16  softwareParmela(globalParameters* globals, dataManager* beamLine);
    1717
    1818  virtual ~softwareParmela() {;}

  • Interface_Web/trunk/pspaWT/sources/controler/include/softwareTransport.h

    r304 r305  
    1414
    1515 public :
    16   softwareTransport(globalParameters* globals, elementsCollection* beamLine);
     16  softwareTransport(globalParameters* globals, dataManager* beamLine);
    1717
    1818  virtual ~softwareTransport() {;}

  • Interface_Web/trunk/pspaWT/sources/controler/src/abstractSoftware.cc

    r295 r305  
    11#include "abstractSoftware.h"
     2#include "dataManager.h"
    23
    34abstractSoftware::abstractSoftware()
    … …  
    67}
    78
    8 abstractSoftware::abstractSoftware(globalParameters* globals, elementsCollection* beamLine) {
     9abstractSoftware::abstractSoftware(globalParameters* globals, dataManager* dt) {
    910  globParamPtr_ = globals;
    10   beamLinePtr_ = beamLine;
     11  dataManager_ = dt;
    1112}
    1213

  • Interface_Web/trunk/pspaWT/sources/controler/src/dataManager.cc

    r304 r305  
    44#include "softwareParmela.h"
    55#include "softwareTransport.h"
     6#include "GWt_pspaApplication.h"
    67#include "softwareGenerator.h"
    78
    … …  
    1011//#include <algorithm>
    1112
    12 abstractElement* dataManager::addElement(typedElement elemType)
    13 {
    14   return elementsGallery_.addElement(elemType);
    15 }
    16 
    17 
    18 void dataManager::removeElement(string elem) {
    19     elementsGallery_.eraseElement(elem);
    20 }
    21 
     13
     14dataManager::dataManager(PspaApplication* pspa) :
     15currentBeam_(NULL)
     16,workingDir_("")
     17,pspa_ ( pspa)
     18{
     19}
     20
     21
     22dataManager::~dataManager() {
     23    unsigned k;
     24    for (k=0; k < jobList_.size();k++) {
     25        if ( jobList_[k] != NULL ) delete jobList_[k];
     26    }
     27    if ( currentBeam_ == NULL ) delete currentBeam_;
     28}
     29
     30
     31/*
     32 abstractElement* dataManager::addElement(typedElement elemType)
     33 {
     34 return elementsGallery_.addElement(elemType);
     35 }
     36 
     37 
     38 void dataManager::removeElement(string elem) {
     39 elementsGallery_.eraseElement(elem);
     40 }
     41 */
    2242
    2343string dataManager::getLabelFromElementNumero(int numero)
    2444{
    25   abstractElement* ptr = elementsGallery_.getElementPointerFromNumero(numero);
    26   if ( ptr == NULL ) return "";
    27   return ptr->getLabel();
     45    abstractElement* ptr = pspa_->getBeamLine()->getAbstractElement(numero-1);
     46    if ( ptr == NULL ) return "";
     47    return ptr->getLabel();
     48}
     49
     50
     51int dataManager::getNumeroFromElementLabel(string label){
     52    int index = -1;
     53    unsigned int k;
     54   
     55    for (k = 0; k < getBeamLineSize() ; k++)
     56    {
     57        if (pspa_->getBeamLine()->getAbstractElement(k) != NULL){
     58            if ( pspa_->getBeamLine()->getAbstractElement(k)->getLabel() == label )
     59            {
     60                index = (int)k + 1;
     61                return index;
     62            }
     63        }
     64    }
     65    return index;
     66}
     67
     68
     69abstractElement* dataManager::getElementPointerFromIndex(int k){
     70    return pspa_->getBeamLine()->getAbstractElement(k);
    2871}
    2972
    … …  
    3174void dataManager::addSectionToExecute(int debut, int fin, nomDeLogiciel prog)
    3275{
    33   jobList_.push_back(new sectionToExecute);
    34   jobList_.back()->firstElement = debut;
    35   jobList_.back()->lastElement = fin;
    36   jobList_.back()->software  = prog;
     76    jobList_.push_back(new sectionToExecute);
     77    jobList_.back()->firstElement = debut;
     78    jobList_.back()->lastElement = fin;
     79    jobList_.back()->software  = prog;
    3780}
    3881
    3982void dataManager::clearSectionToExecute()
    4083{
    41   unsigned k;
    42   for(k = 0; k < jobList_.size(); k++)
    43     {
    44       if ( jobList_[k] != NULL ) delete jobList_[k];
    45     }
    46   jobList_.clear();
     84    unsigned k;
     85    for(k = 0; k < jobList_.size(); k++)
     86    {
     87        if ( jobList_[k] != NULL ) delete jobList_[k];
     88    }
     89    jobList_.clear();
    4790}
    4891
    4992trivaluedBool dataManager::checkExecute(string& diagnostic)
    5093{
    51   cout << "dataManager::checkExecute()" << endl;
     94
     95   cout << "dataManager::checkExecute()" << endl;
    5296  trivaluedBool resul = ok;
    5397  unsigned k,j;
    … …  
    77121}
    78122
     123
    79124trivaluedBool dataManager::checkElementsForExec(nomDeLogiciel logiciel, unsigned indexDeb, unsigned indexFin, string& diagnostic)
    80125{
    81   trivaluedBool resul = ok;
    82   diagnostic.clear();
    83   trivaluedBool accepted;
    84   abstractElement* elPtr;
    85   for(unsigned j = indexDeb; j <= indexFin; j++) {
    86     elPtr = elementsGallery_.getElementPointerFromIndex(j);
    87     accepted = elPtr->is_accepted_by_software(logiciel);
    88     if(accepted  == error  ) {
    89       diagnostic += " the element " + elPtr->getNomdElement().getElementName() + " is not allowed with " + logiciel.getString() + " \n";
    90       resul = error;
    91     } else if ( accepted  == warning ) {
    92       diagnostic += " the element " + elPtr->getNomdElement().getElementName() + " will be ignored by " + logiciel.getString() + " \n";
    93       if ( resul != error ) resul = warning;
    94     }
    95   }
    96   return resul;
     126    trivaluedBool resul = ok;
     127    diagnostic.clear();
     128    trivaluedBool accepted;
     129    abstractElement* elPtr;
     130    for(unsigned j = indexDeb; j <= indexFin; j++) {
     131        elPtr = pspa_->getBeamLine()->getAbstractElement(j);
     132        accepted = elPtr->is_accepted_by_software(logiciel);
     133        if(accepted  == error  ) {
     134            diagnostic += " the element " + elPtr->getNomdElement().getElementName() + " is not allowed with " + logiciel.getString() + " \n";
     135            resul = error;
     136        } else if ( accepted  == warning ) {
     137            diagnostic += " the element " + elPtr->getNomdElement().getElementName() + " will be ignored by " + logiciel.getString() + " \n";
     138            if ( resul != error ) resul = warning;
     139        }
     140    }
     141    return resul;
    97142}
    98143
    … …  
    114159}
    115160
    116 void dataManager::removeFile(string nameOfFile) 
    117 {
    118   ifstream fileExists;
    119   fileExists.open(nameOfFile.c_str(), ios::in);
    120   if (fileExists) {
    121     fileExists.close();
    122     remove(nameOfFile.c_str());
    123   }
     161void dataManager::removeFile(string nameOfFile)
     162{
     163    ifstream fileExists;
     164    fileExists.open(nameOfFile.c_str(), ios::in);
     165    if (fileExists) {
     166        fileExists.close();
     167        remove(nameOfFile.c_str());
     168    }
    124169}
    125170
    126171bool dataManager::executeAll(string &resul)
    127172{
    128   bool success = true;
    129   resul.clear();
    130   string resultatPartiel;
    131   unsigned k;
    132   abstractSoftware* softw =NULL;
    133 
    134   for(k = 0; k < jobList_.size(); k++)
     173    bool success = true;
     174    resul.clear();
     175    string resultatPartiel;
     176    unsigned k;
     177    abstractSoftware* softw =NULL;
     178   
     179    for(k = 0; k < jobList_.size(); k++)
    135180    {
    136181      int debut = jobList_[k]->firstElement;
    … …  
    141186      string inputFileName;
    142187      if(jobList_[k]->software == nomDeLogiciel::parmela) {
    143         softw = new softwareParmela(&globParam_, &elementsGallery_);
     188        softw = new softwareParmela(&globParam_, this);
    144189        inputFileName = "parmin";
    145190      } else if (jobList_[k]->software == nomDeLogiciel::transport) {
    146         softw = new softwareTransport(&globParam_, &elementsGallery_);
     191        softw = new softwareTransport(&globParam_, this);
    147192        inputFileName = "transport.input";
    148193      } else if (jobList_[k]->software == nomDeLogiciel::generator) {
    149         softw = new softwareGenerator(&globParam_, &elementsGallery_);
     194        softw = new softwareGenerator(&globParam_, this);
    150195        inputFileName = "generator.in";
    151196      } else {
    … …  
    173218      if ( !success ) break;
    174219    }
    175   return success;
    176 }
     220    return success;
     221}
     222
    177223
    178224void dataManager::saveConfiguration( string nameOfFile)
    179225{
    180   ofstream outfile;
    181   string name = workingDir_ + nameOfFile + ".save";
    182   outfile.open(name.c_str(), ios::out);
    183   if (!outfile) {
    184     cerr << " error opening output file for persistency " << name << endl;
    185   }
    186 
    187   outfile << globParam_.FileOutputFlow();
    188   unsigned k;
    189   abstractElement* elPtr;
    190   for ( k=0 ; k < elementsGallery_.size() ; k++)
    191     {
    192       elPtr = elementsGallery_.getElementPointerFromIndex(k);
    193       outfile << elPtr->FileOutputFlow();
    194     }
    195   outfile.close();   
    196 }
     226    ofstream outfile;
     227    string name = workingDir_ + nameOfFile + ".save";
     228    outfile.open(name.c_str(), ios::out);
     229    if (!outfile) {
     230        cerr << " error opening output file for persistency " << name << endl;
     231    }
     232   
     233    outfile << globParam_.FileOutputFlow();
     234    unsigned k;
     235    abstractElement* elPtr;
     236    for ( k=0 ; k < getBeamLineSize() ; k++)
     237    {
     238        elPtr = pspa_->getBeamLine()->getAbstractElement(k);
     239        outfile << elPtr->FileOutputFlow();
     240    }
     241    outfile.close();
     242}
     243
    197244
    198245bool dataManager::restoreElements( string inputFileName)
    199246{
    200   cout << "dataManager::restoreElements() fichier " << inputFileName << endl;
    201   ifstream infile;
    202    string name = workingDir_ + inputFileName + ".save";
    203   infile.open(name.c_str(), ios::in);
    204   if (!infile) {
    205     cerr << " error opening input stream " << name << endl;
    206     return false;
    207   }
    208   else cout << " successful opening input stream " << name << endl;
    209 
    210   string globalTitle;
    211   if ( infile >> globalTitle ) {
    212     if ( globalTitle == string("globals") ) {
    213       globParam_.raz();
    214       globParam_.FileInput(infile);
     247    cout << "dataManager::restoreElements() fichier " << inputFileName << endl;
     248    ifstream infile;
     249    string name = workingDir_ + inputFileName + ".save";
     250    infile.open(name.c_str(), ios::in);
     251    if (!infile) {
     252        cerr << " error opening input stream " << name << endl;
     253        return false;
     254    }
     255    else cout << " successful opening input stream " << name << endl;
     256   
     257    string globalTitle;
     258    if ( infile >> globalTitle ) {
     259        if ( globalTitle == string("globals") ) {
     260            globParam_.raz();
     261            globParam_.FileInput(infile);
     262        } else {
     263            cerr << " dataManager::restoreElements ERROR : global parameters seems to be missing" << endl;
     264            return false;
     265        }
    215266    } else {
    216       cerr << " dataManager::restoreElements ERROR : global parameters seems to be missing" << endl;
    217       return false;
    218     }
    219   } else {
    220     cerr << " dataManager::restoreElements ERROR : reading data save file" << endl;
    221     return false;
    222   }
    223 
    224   elementsGallery_.raz();
    225   //  typedElement elem;
    226  typedElement elementType;
    227   string elementLabel;
    228   //  while (infile >> ielem) {
    229   while (infile >> elementLabel) {
    230     //    elem = (typedElement)ielem;
    231     //    abstractElement* nouveau = addElement(elem);
    232     elementType = nomdElements::getTypeFromLabel(elementLabel);
    233     abstractElement* nouveau = addElement( elementType);
    234     if ( nouveau == NULL ) {
    235       cerr << " dataManager::restoreElements ERROR : restoring element " << elementLabel << " failed " << endl;
    236       return false;
    237     }
    238     nouveau->FileInput(infile);
    239   } 
    240   infile.close();
    241 
    242   // debug
    243   unsigned k;
    244   for(k = 0; k <  elementsGallery_.size(); k++) {
    245     abstractElement* ptr= elementsGallery_.getElementPointerFromIndex(k);
    246     cout << "reupere " << ptr->getLabel() << endl;
    247   }
    248 
    249 
    250   return true;
    251 }
    252 
    253 particleBeam* dataManager::getDiagnosticBeam(unsigned index)
    254 {
    255   cout << " particleBeam* dataManager je vais dessiner " << getLabelFromElementNumero(index+1) << endl;
    256 
    257 
    258   if (  index >= diagnosticBeam_.size() ) {
    259       return NULL;
     267        cerr << " dataManager::restoreElements ERROR : reading data save file" << endl;
     268        return false;
     269    }
     270   
     271    pspa_->getBeamLine()->clear();
     272   
     273    //  typedElement elem;
     274    typedElement elementType;
     275    string elementLabel;
     276    //  while (infile >> ielem) {
     277    while (infile >> elementLabel) {
     278        //    elem = (typedElement)ielem;
     279        //    abstractElement* nouveau = addElement(elem);
     280        elementType = nomdElements::getTypeFromLabel(elementLabel);
     281        //    abstractElement* nouveau = addElement( elementType);
     282       
     283        abstractElement* nouveau = pspa_->getBeamLine()->addElement(elementType);
     284       
     285        if ( nouveau == NULL ) {
     286            cerr << " dataManager::restoreElements ERROR : restoring element " << elementLabel << " failed " << endl;
     287            return false;
     288        }
     289        nouveau->FileInput(infile);
     290    }
     291    infile.close();
     292
     293    // after adding, set the good label on GUI
     294    pspa_->getBeamLine()->update();
     295   
     296    // debug
     297    unsigned k;
     298    for(k = 0; k < getBeamLineSize(); k++) {
     299        abstractElement* ptr = pspa_->getBeamLine()->getAbstractElement(k);
     300       
     301        cout << "reupere " << ptr->getLabel() << endl;
     302    }
     303    return true;
     304}
     305
     306
     307particleBeam* dataManager::getDiagnosticBeam(unsigned index)
     308{
     309   
     310   
     311    if (  index >= diagnosticBeam_.size() ) {
     312        return NULL;
    260313    }
    261314    else {
    262       return &diagnosticBeam_.at(index);
    263     }
    264 }
     315        return &diagnosticBeam_.at(index);
     316    }
     317}
     318
    265319
    266320void dataManager::donneesRmsEnveloppe( string type, unsigned int numeroDeb, unsigned int numeroFin, vector<double>& xcor, vector<double>& ycor)
    267321{
    268   unsigned k;
    269   if ( numeroDeb < 1 ) numeroDeb = 1;
    270   if ( numeroFin > diagnosticBeam_.size() ) numeroFin = diagnosticBeam_.size();
    271 
    272   unsigned indexDeb = numeroDeb -1;
    273   unsigned indexFin = numeroFin -1;
    274 
    275   double longueur = 0.0;
    276   double valeur = 0.0;
    277   xcor.clear();
    278   ycor.clear();
    279   if ( type == "x" )
    280     {
    281       for (k= indexDeb; k <= indexFin; k++)
    282         {
    283           if ( !diagnosticBeam_.at(k).momentRepresentationOk() ) diagnosticBeam_.at(k).buildMomentRepresentation();
    284           longueur += elementsGallery_.getElementPointerFromIndex(k)->getLenghtOfElement();
    285           valeur = diagnosticBeam_.at(k).getXmaxRms();
    286           xcor.push_back(longueur);
    287           ycor.push_back(valeur);
    288         }
    289     }
    290   else
    291     {
    292       cerr << " dataManager::donneesRmsEnveloppe type " << type << " not programmed " << endl;
    293       return;
    294     }
    295 }
    296 
     322    unsigned k;
     323    if ( numeroDeb < 1 ) numeroDeb = 1;
     324    if ( numeroFin > diagnosticBeam_.size() ) numeroFin = diagnosticBeam_.size();
     325   
     326    unsigned indexDeb = numeroDeb -1;
     327    unsigned indexFin = numeroFin -1;
     328   
     329    double longueur = 0.0;
     330    double valeur = 0.0;
     331    xcor.clear();
     332    ycor.clear();
     333    if ( type == "x" )
     334    {
     335        for (k= indexDeb; k <= indexFin; k++)
     336        {
     337            if ( !diagnosticBeam_.at(k).momentRepresentationOk() ) diagnosticBeam_.at(k).buildMomentRepresentation();
     338            longueur += pspa_->getBeamLine()->getAbstractElement(k)->getLenghtOfElement();
     339            valeur = diagnosticBeam_.at(k).getXmaxRms();
     340            xcor.push_back(longueur);
     341            ycor.push_back(valeur);
     342        }
     343    }
     344    else
     345    {
     346        cerr << " dataManager::donneesRmsEnveloppe type " << type << " not programmed " << endl;
     347        return;
     348    }
     349}
     350
     351int dataManager::getBeamLineSize() {
     352    return pspa_->getBeamLine()->getBeamLineSize();
     353}

  • Interface_Web/trunk/pspaWT/sources/controler/src/elementsCollection.cc

    r295 r305  
    100100}
    101101
    102 int elementsCollection::getNumeroFromLabel(string lab)
     102int elementsCollection::getNumeroFromElementLabel(string lab)
    103103{
    104104  unsigned int k;

  • Interface_Web/trunk/pspaWT/sources/controler/src/softwareGenerator.cc

    r304 r305  
    22#include "abstractElement.h"
    33#include "parmelaParticle.h"
     4#include "dataManager.h"
    45
    56
    … …  
    1213
    1314
    14 softwareGenerator::softwareGenerator(globalParameters* globals, elementsCollection* beamLine) : abstractSoftware(globals, beamLine)
     15softwareGenerator::softwareGenerator(globalParameters* globals, dataManager* dt) : abstractSoftware(globals, dt)
    1516{
    1617  ;
    … …  
    2425
    2526  abstractElement* elPtr;
    26   elPtr = beamLinePtr_->getElementPointerFromNumero(numeroDeb);
     27  elPtr = dataManager_->getElementPointerFromIndex(numeroDeb);
    2728
    2829  if ( elPtr->getNomdElement().getElementType() != RFgun ) {

  • Interface_Web/trunk/pspaWT/sources/controler/src/softwareParmela.cc

    r304 r305  
    44#include "mathematicalConstants.h"
    55#include "PhysicalConstants.h"
     6#include "dataManager.h"
    67
    78
    … …  
    1112}
    1213
    13 softwareParmela::softwareParmela(globalParameters* globals, elementsCollection* beamLine) : abstractSoftware(globals, beamLine)
     14softwareParmela::softwareParmela(globalParameters* globals, dataManager* dt) : abstractSoftware(globals, dt)
    1415{
    1516  ;
    … …  
    2021  unsigned int k;
    2122
    22   if ( numeroDeb < 1 || numeroFin > beamLinePtr_->size() ) {
     23  if ( numeroDeb < 1 || numeroFin > dataManager_->getBeamLineSize() ) {
    2324    cerr << " index of element out of limits " << endl;
    2425    return false;
    … …  
    2627
    2728
    28   unsigned indexDeb = numeroDeb - 1;
    29   unsigned indexFin = numeroFin - 1;
     29    unsigned indexDeb = numeroDeb - 1;
     30    unsigned indexFin = numeroFin - 1;
    3031
    3132  ofstream outfile;
    … …  
    3940  abstractElement* elPtr;
    4041  double initalKineticEnergy = 0.0;
    41   elPtr = beamLinePtr_->getElementPointerFromIndex(indexDeb);
     42  elPtr = dataManager_->getElementPointerFromIndex(indexDeb);
    4243  if ( elPtr->getNomdElement().getElementType() != RFgun ) {
    4344    cerr << " dataManager::createInputFileParmela : the first element should be rfgun" << endl;
    … …  
    5758  for ( k = indexDeb; k <= indexFin; k++)
    5859    {
    59       elPtr = beamLinePtr_->getElementPointerFromIndex(k);
     60      elPtr = dataManager_->getElementPointerFromIndex(k);
    6061      outfile << elPtr->parmelaOutputFlow() << endl;
    6162    }
    … …  
    131132            if (!beamFromParmela(workingDir,k, globParamPtr_->getFrequency(), centroid, refPart,particles ))
    132133              {
    133                 abstractElement* elem = beamLinePtr_->getElementPointerFromNumero(k);
     134                abstractElement* elem = dataManager_->getElementPointerFromIndex(k);
    134135                if ( elem->is_accepted_by_software(nomDeLogiciel::parmela) == warning) {
    135136                  int avantDernier = beams.size() -2;

  • Interface_Web/trunk/pspaWT/sources/controler/src/softwareTransport.cc

    r304 r305  
    22#include "abstractElement.h"
    33#include "beam2Moments.h"
     4#include "dataManager.h"
    45
    56#include <algorithm>
    … …  
    1011}
    1112
    12 softwareTransport::softwareTransport(globalParameters* globals, elementsCollection* beamLine) : abstractSoftware(globals, beamLine)
     13softwareTransport::softwareTransport(globalParameters* globals, dataManager* dt) : abstractSoftware(globals, dt)
    1314{
    1415  ;
    … …  
    1920{
    2021  unsigned int k;
    21   if ( numeroDeb < 1 || numeroFin > beamLinePtr_->size() ) {
     22  if ( numeroDeb < 1 || numeroFin > dataManager_->getBeamLineSize() ) {
    2223    cerr << " numero of element out of limits " << endl;
    2324    return false;
    2425  }
    2526
    26   unsigned indexDeb = numeroDeb - 1;
    27   unsigned indexFin = numeroFin - 1;
     27    unsigned indexDeb = numeroDeb - 1;
     28    unsigned indexFin = numeroFin - 1;
    2829
    2930  abstractElement* premierEl = NULL;
    30   premierEl = beamLinePtr_->getElementPointerFromIndex(indexDeb);
     31  premierEl = dataManager_->getElementPointerFromIndex(indexDeb);
    3132
    3233  // ceinture et bretelles
    … …  
    9091  for ( k=indexDeb; k <= indexFin; k++)
    9192    {
    92       elPtr = beamLinePtr_->getElementPointerFromIndex(k);
     93      elPtr = dataManager_->getElementPointerFromIndex(k);
    9394      outfile << elPtr->transportOutputFlow() << endl;
    9495    }
    … …  
    164165            //      string elemLabel = getLabelFromElementNumero (k);
    165166
    166             abstractElement* ptr = beamLinePtr_->getElementPointerFromNumero(k);
     167            abstractElement* ptr = dataManager_->getElementPointerFromIndex(k);
    167168
    168169            if ( ptr == NULL ) {

  • Interface_Web/trunk/pspaWT/sources/userInterface/include/GWt_abstractElement.h

    r294 r305  
    55#include "abstractElement.h"
    66#include "GWt_console.h"
     7#include "elementDrift.h"
     8#include "elementRfgun.h"
     9#include "elementCell.h"
     10#include "elementSoleno.h"
     11#include "elementBend.h"
     12#include "elementBeam.h"
     13#include "elementFit.h"
     14
    715
    816#include <Wt/WDialog>
    … …  
    4250    void clicked();
    4351    void doubleClicked();
    44     void setLabelWidget();
    4552    void updateLabelWidget();
    4653    //  GWt_draggableImage* getImage();
    4754    WContainerWidget* getWidget();
    48     abstractElement* getElement();
     55    abstractElement* getAbstractElement();
    4956   
    5057    virtual void dialogDone() = 0;

  • Interface_Web/trunk/pspaWT/sources/userInterface/include/GWt_beam.h

    r293 r305  
    1919   
    2020    GWt_beam() {;}
    21     GWt_beam(abstractElement* elem, GWt_elementLigneFaisceau* );
     21    GWt_beam(GWt_elementLigneFaisceau* );
    2222    ~GWt_beam() {;}
    2323    virtual void dialogDone();

  • Interface_Web/trunk/pspaWT/sources/userInterface/include/GWt_bend.h

    r293 r305  
    1818   
    1919    GWt_bend() {;}
    20     GWt_bend(abstractElement* elem, GWt_elementLigneFaisceau* );
     20    GWt_bend(GWt_elementLigneFaisceau* );
    2121    ~GWt_bend() {;}
    2222    virtual void dialogDone();

  • Interface_Web/trunk/pspaWT/sources/userInterface/include/GWt_cell.h

    r293 r305  
    2929   
    3030    GWt_cell() {;}
    31     GWt_cell(abstractElement* elem, GWt_elementLigneFaisceau* );
     31    GWt_cell(GWt_elementLigneFaisceau* );
    3232    ~GWt_cell() {;}
    3333    virtual void dialogDone();

  • Interface_Web/trunk/pspaWT/sources/userInterface/include/GWt_drift.h

    r293 r305  
    2121   
    2222    GWt_drift() {;}
    23     GWt_drift(abstractElement* elem, GWt_elementLigneFaisceau* );
     23    GWt_drift(GWt_elementLigneFaisceau* );
    2424    ~GWt_drift() {;}
    2525    virtual void dialogDone();

  • Interface_Web/trunk/pspaWT/sources/userInterface/include/GWt_elementLigneFaisceau.h

    r301 r305  
    3333   
    3434    GWt_elementLigneFaisceau(PspaApplication*);
    35     GWt_elementLigneFaisceau(abstractElement*,PspaApplication*);
     35    GWt_elementLigneFaisceau(typedElement,PspaApplication*);
    3636   
    3737    ~GWt_elementLigneFaisceau();
    … …  
    3939   
    4040    inline WText* getElementName() {
    41         return elementName_;
     41        return elementLabel_;
    4242    }
    4343   
    4444    inline WText* getElementIcon() {
    45         return elementName_;
     45        return elementLabel_;
    4646    }
    4747   
    48     void setElementName(std::string label);
     48    void setElementLabel(std::string label);
    4949   
    5050    inline GWt_dropZoneLigneFaisceau* getDropZoneLeft() {
    … …  
    5656    }
    5757
    58     inline GWt_abstractElement* getElement() {
    59         return abstractElement_;
     58    inline GWt_abstractElement* getGWt_AbstractElement() {
     59        return GWt_abstractElement_;
    6060    }
    6161   
    … …  
    6464    void removeDone(GWt_abstractElement*);
    6565    std::string getElementNumberInBeamLine(nomdElements el);
    66     void initialize_ligneFaisceau(abstractElement*);
     66    void initialize_ligneFaisceau(typedElement eType);
    6767    GWt_dialog* messageDropZone_;
    6868    WText* firstTimeInsertMessage_;
    … …  
    7070    GWt_dropZoneLigneFaisceau* dropZoneLeft_;
    7171    GWt_dropZoneLigneFaisceau* dropZoneRight_;
    72     WText* elementName_;
     72    WText* elementLabel_;
    7373    PspaApplication* pspa_;
    74     GWt_abstractElement* abstractElement_;
     74    GWt_abstractElement* GWt_abstractElement_;
    7575};
    7676#endif

  • Interface_Web/trunk/pspaWT/sources/userInterface/include/GWt_fit.h

    r293 r305  
    1515   
    1616    GWt_fit() {;}
    17     GWt_fit(abstractElement* elem, GWt_elementLigneFaisceau* );
     17    GWt_fit(GWt_elementLigneFaisceau* );
    1818    ~GWt_fit() {;}
    1919    virtual void dialogDone();

  • Interface_Web/trunk/pspaWT/sources/userInterface/include/GWt_ligneFaisceau.h

    r299 r305  
    77#include "GWt_pspaApplication.h"
    88#include "GWt_abstractElement.h"
    9 #include "GWt_dropZoneLigneFaisceau.h"
    109
    1110#include <Wt/WApplication>
    … …  
    1514
    1615using namespace Wt;
     16
     17class GWt_dropZoneLigneFaisceau;
    1718
    1819class Compteur {
    … …  
    4445     and we center everything
    4546     */
    46     void addElement(typedElement eType, GWt_dropZoneLigneFaisceau* dropContainer);
     47    abstractElement* addElement(typedElement eType, GWt_dropZoneLigneFaisceau* dropContainer);
     48    abstractElement* addElement(typedElement eType);
     49   
    4750    void removeElement(GWt_abstractElement*);
    4851
    … …  
    5154    }
    5255   
    53     void restoreElementCollectionFromDataManager();
     56    /** return the abstract element at a position
     57     @param : position in the beam line
     58     */
     59    abstractElement* getAbstractElement(int i);
     60//    void restoreElementCollectionFromDataManager();
    5461    void clickEvent(WContainerWidget*);
    5562    void deleteElement(WContainerWidget*);
     63    int getBeamLineSize();
     64 
     65    /**
     66     remove all elements from beam line
     67     */
     68    void clear();
     69   
     70    /**
     71     Return a vector contains all abstract elements in the beam line
     72     */
     73    vector <abstractElement*> getAllAbstractElements();
     74   
     75    void update();
     76
    5677    private :
    5778    void manageLineFaisceauLayout();
    58    
     79    GWt_dropZoneLigneFaisceau* allDropZone_;
    5980   
    6081};

  • Interface_Web/trunk/pspaWT/sources/userInterface/include/GWt_pspaApplication.h

    r302 r305  
    2222#include "GWt_abstractElementFactory.h"
    2323#include "GWt_softwarePanel.h"
     24#include "GWt_ligneFaisceau.h"
    2425
    2526using namespace Wt;
    … …  
    4041    WLineEdit* saveNameEdit_;
    4142    WLineEdit* openNameEdit_;
     43    GWt_LigneFaisceau* beamLine_;
    4244   
    4345   
    4446    // WContainerWidget* console_;
    4547    WWidget* globalParam_;
    46     WWidget* beamLine_;
    4748    // WContainerWidget* leDessin_;
    4849    GWt_dialog* graphicsDialog_;
    … …  
    6162    WText*   createTitle(const WString&);
    6263    WWidget* createPalette();
    63     WWidget* createBeamLine();
     64    void createBeamLine();
    6465    WWidget* createGlobalParamWidget();
    6566    WWidget* createExecuteWidget();
    … …  
    106107        return executeWidget_;
    107108    };
     109    inline GWt_LigneFaisceau* getBeamLine() {
     110        return beamLine_;
     111    }
    108112
    109113    inline GWt_abstractElementFactory* getAbstractElementFactory() {

  • Interface_Web/trunk/pspaWT/sources/userInterface/include/GWt_rfgun.h

    r304 r305  
    2828   
    2929    GWt_rfgun() {;}
    30     GWt_rfgun(abstractElement* elem, GWt_elementLigneFaisceau* );
     30    GWt_rfgun(GWt_elementLigneFaisceau* );
    3131    ~GWt_rfgun() {;}
    3232    virtual void dialogDone();

  • Interface_Web/trunk/pspaWT/sources/userInterface/include/GWt_soleno.h

    r293 r305  
    2727   
    2828    GWt_soleno() {;}
    29     GWt_soleno( abstractElement* elem, GWt_elementLigneFaisceau* );
     29    GWt_soleno(GWt_elementLigneFaisceau* );
    3030    ~GWt_soleno() {;}
    3131    virtual  void dialogDone();

  • Interface_Web/trunk/pspaWT/sources/userInterface/src/GWt_abstractElement.cc

    r301 r305  
    7979void GWt_abstractElement::updateLabelWidget()
    8080{
    81    elementLigneFaiseauContainer_->setElementName(abstractElement_->getLabel());
    82    
    83     /*  string str = abstractElement_->getLabel();
    84      wc_item_->setText(str);
    85      */
    86 }
    87 
    88 void GWt_abstractElement::setLabelWidget()
    89 {
    90     /*
    91      string str = abstractElement_->getLabel();
    92      wc_item_ = new WText(str);
    93      wc_item_->setObjectName("aText");
    94      wc_->addWidget(wc_item_);
    95      */
     81    elementLigneFaiseauContainer_->setElementLabel(abstractElement_->getLabel());
    9682}
    9783
    … …  
    10490void GWt_abstractElement::doubleClicked()
    10591{
    106     StandardButton result = WMessageBox::show("PSPA : Delete element", WString("Delete '")+WString(getElement()->getLabel())+"' ?", Ok | Cancel);
     92    StandardButton result = WMessageBox::show("PSPA : Delete element", WString("Delete '")+WString(getAbstractElement()->getLabel())+"' ?", Ok | Cancel);
    10793
    10894    if (result == Cancel ) {
    … …  
    125111}
    126112
    127 abstractElement* GWt_abstractElement::getElement() {
     113abstractElement* GWt_abstractElement::getAbstractElement() {
    128114    return abstractElement_;
    129115}

  • Interface_Web/trunk/pspaWT/sources/userInterface/src/GWt_beam.cc

    r294 r305  
    88#include <Wt/WPushButton>
    99
    10 GWt_beam::GWt_beam(abstractElement* elem, GWt_elementLigneFaisceau* elemLigne)
    11 :GWt_abstractElement(elem)
     10GWt_beam::GWt_beam(GWt_elementLigneFaisceau* elemLigne)
     11:GWt_abstractElement(new elementBeam())
    1212{
    1313    elementLigneFaiseauContainer_ = elemLigne;

  • Interface_Web/trunk/pspaWT/sources/userInterface/src/GWt_bend.cc

    r294 r305  
    99#include <Wt/WPushButton>
    1010
    11 GWt_bend::GWt_bend(abstractElement* elem, GWt_elementLigneFaisceau* elemLigne )
    12 :GWt_abstractElement(elem)
     11GWt_bend::GWt_bend(GWt_elementLigneFaisceau* elemLigne )
     12:GWt_abstractElement(new elementBend())
    1313{
    1414    elementLigneFaiseauContainer_ = elemLigne;

  • Interface_Web/trunk/pspaWT/sources/userInterface/src/GWt_cell.cc

    r294 r305  
    1010#include <Wt/WPanel>
    1111
    12 GWt_cell::GWt_cell(abstractElement* elem, GWt_elementLigneFaisceau* elemLigne)
    13 :GWt_abstractElement(elem)
     12GWt_cell::GWt_cell(GWt_elementLigneFaisceau* elemLigne)
     13:GWt_abstractElement(new elementCell())
    1414{
    1515    elementLigneFaiseauContainer_ = elemLigne;

  • Interface_Web/trunk/pspaWT/sources/userInterface/src/GWt_drift.cc

    r294 r305  
    99#include <Wt/WPushButton>
    1010
    11 GWt_drift::GWt_drift(abstractElement* elem, GWt_elementLigneFaisceau* elemLigne)
    12 :GWt_abstractElement(elem)
     11GWt_drift::GWt_drift(GWt_elementLigneFaisceau* elemLigne)
     12:GWt_abstractElement(new elementDrift())
    1313{
    1414    elementLigneFaiseauContainer_ = elemLigne;

  • Interface_Web/trunk/pspaWT/sources/userInterface/src/GWt_elementLigneFaisceau.cc

    r301 r305  
    3232dropZoneLeft_(NULL),
    3333dropZoneRight_(NULL),
    34 abstractElement_(NULL),
    35 elementName_(NULL),
     34GWt_abstractElement_(NULL),
     35elementLabel_(NULL),
    3636pspa_(pspa)
    3737{
    3838   
    39     initialize_ligneFaisceau(NULL);
    40 }
    41 
    42 GWt_elementLigneFaisceau::GWt_elementLigneFaisceau(abstractElement* abstractElement, PspaApplication* pspa)
     39    initialize_ligneFaisceau(inconnu);
     40}
     41
     42
     43GWt_elementLigneFaisceau::GWt_elementLigneFaisceau(typedElement type, PspaApplication* pspa)
    4344: WContainerWidget(),
    4445firstTimeInsertMessage_(NULL),
    4546dropZoneLeft_(NULL),
    4647dropZoneRight_(NULL),
    47 abstractElement_(NULL),
    48 elementName_(NULL),
     48GWt_abstractElement_(NULL),
     49elementLabel_(NULL),
    4950pspa_(pspa)
    5051{
    … …  
    5253    setObjectName("elementLigneFaisceau");
    5354
    54     initialize_ligneFaisceau(abstractElement);
    55 }
    56 
    57 
    58 void GWt_elementLigneFaisceau::initialize_ligneFaisceau(abstractElement* abstractElement)
     55    initialize_ligneFaisceau(type);
     56}
     57
     58
     59void GWt_elementLigneFaisceau::initialize_ligneFaisceau(typedElement eType)
    5960{
    6061   
    … …  
    8081   
    8182    // change object name in order to manage css :
     83    dropZoneLeft_->resize(10,30);
    8284    dropZoneRight_->resize(10,30);
    83    
    84    
    85     WContainerWidget* arrow = new WContainerWidget();
    86     new WImage(arrow);
    87     arrow->resize(10,30);
    88    
    89     arrow->setStyleClass("elementLigneFaiseau_arrow");
    90     dropZoneLeft_->addWidget(arrow);
    9185   
    9286    gridLayout->addWidget       (dropZoneLeft_,0,0);
    … …  
    9488   
    9589    // add the image if present
    96     if (abstractElement != NULL) {
    97         typedElement eType = abstractElement->getNomdElement().getElementType();
    98        
    99         switch (  eType ) {
    100             case RFgun :
    101                 abstractElement_ = new GWt_rfgun(abstractElement, this);
    102                 break;
    103             case drift :
    104                 abstractElement_ = new GWt_drift(abstractElement, this);
    105                 break;
    106             case cell  :
    107                 abstractElement_ = new GWt_cell(abstractElement, this);
    108                 break;
    109             case bend  :
    110                 abstractElement_ = new GWt_bend(abstractElement, this);
    111                 break;
    112             case soleno  :
    113                 abstractElement_ = new GWt_soleno(abstractElement, this);
    114                 break;
    115             case beam  :
    116                 abstractElement_ = new GWt_beam(abstractElement, this);
    117                 break;
    118             case fit  :
    119                 abstractElement_ = new GWt_fit(abstractElement, this);
    120                 break;
    121             case inconnu :
    122                 abstractElement_ = NULL;
    123         }
    124         if (abstractElement_ != NULL) {
    125             gridLayout->addWidget       (abstractElement_,0,1);
    126             abstractElement_->setMaximumSize(32,32);
    127             abstractElement_->setMinimumSize(32,32);
    128             abstractElement_->setToolTip(abstractElement_->print());
    129         }
    130     }
     90   
     91    switch (  eType ) {
     92        case RFgun :
     93            GWt_abstractElement_ = new GWt_rfgun(this);
     94            break;
     95        case drift :
     96            GWt_abstractElement_ = new GWt_drift(this);
     97            break;
     98        case cell  :
     99            GWt_abstractElement_ = new GWt_cell(this);
     100            break;
     101        case bend  :
     102            GWt_abstractElement_ = new GWt_bend(this);
     103            break;
     104        case soleno  :
     105            GWt_abstractElement_ = new GWt_soleno(this);
     106            break;
     107        case beam  :
     108            GWt_abstractElement_ = new GWt_beam(this);
     109            break;
     110        case fit  :
     111            GWt_abstractElement_ = new GWt_fit(this);
     112            break;
     113        case inconnu :
     114            GWt_abstractElement_ = NULL;
     115    }
     116    if (GWt_abstractElement_ != NULL) {
     117        gridLayout->addWidget   (GWt_abstractElement_,0,1);
     118        GWt_abstractElement_->setMaximumSize(32,32);
     119        GWt_abstractElement_->setMinimumSize(32,32);
     120        GWt_abstractElement_->setToolTip(GWt_abstractElement_->print());
     121    }
     122   
    131123    // add second line
    132     if (abstractElement == NULL) {
    133         elementName_ = new WText();
     124    if (GWt_abstractElement_ == NULL) {
     125        elementLabel_ = new WText();
    134126    } else {
    135         elementName_ = new WText(abstractElement->getLabel());
    136     }
    137    
    138     gridLayout->addWidget       (elementName_,1,0,1,3,Wt::AlignCenter |Wt::AlignMiddle);
     127        elementLabel_ = new WText(GWt_abstractElement_->getAbstractElement()->getLabel());
     128    }
     129   
     130    gridLayout->addWidget       (elementLabel_,1,0,1,3,Wt::AlignCenter |Wt::AlignMiddle);
    139131   
    140132    gridLayout->setColumnStretch (0,1);
    … …  
    160152
    161153
    162 
    163 
    164154void GWt_elementLigneFaisceau::addElement(GWt_abstractElement* elem){
    165155   
    166156    clear();
    167     abstractElement_ = elem;
    168     addWidget(abstractElement_);
     157    GWt_abstractElement_ = elem;
     158    addWidget(GWt_abstractElement_);
    169159    if (static_cast <WContainerWidget*> (parent())) {
    170160        WContainerWidget* wc = static_cast <WContainerWidget*> (parent());
    … …  
    177167    dropZoneLeft_ = NULL;
    178168}
     169
    179170
    180171std::string GWt_elementLigneFaisceau::getElementNumberInBeamLine(nomdElements elem){
    … …  
    218209}
    219210
    220 void GWt_elementLigneFaisceau::setElementName(std::string label) {
    221     elementName_->setText(label);
    222 }
    223 
     211
     212void GWt_elementLigneFaisceau::setElementLabel(std::string label) {
     213    elementLabel_->setText(label);
     214}
     215

  • Interface_Web/trunk/pspaWT/sources/userInterface/src/GWt_fit.cc

    r294 r305  
    99#include <Wt/WComboBox>
    1010
    11 GWt_fit::GWt_fit(abstractElement* elem, GWt_elementLigneFaisceau* elemLigne)
    12 :GWt_abstractElement(elem)
     11GWt_fit::GWt_fit(GWt_elementLigneFaisceau* elemLigne)
     12:GWt_abstractElement(new elementFit())
    1313{
    1414    elementLigneFaiseauContainer_ = elemLigne;

  • Interface_Web/trunk/pspaWT/sources/userInterface/src/GWt_ligneFaisceau.cc

    r302 r305  
    3535   
    3636   
     37    clear();
     38}
     39
     40
     41void GWt_LigneFaisceau::clear() {
     42    ligneFaisceauLayout_->clear();
     43
    3744    // add the first drop zone
    3845    decorationStyle().setBorder (WBorder (WBorder::Dotted));
    39     GWt_dropZoneLigneFaisceau* allDropZone= new GWt_dropZoneLigneFaisceau(pspa_);
     46    allDropZone_ = new GWt_dropZoneLigneFaisceau(pspa_);
    4047    WVBoxLayout* fit = new WVBoxLayout();
    41     allDropZone->setLayout(fit);
     48    allDropZone_->setLayout(fit);
    4249   
    4350    fit->addWidget(new WText("Drag elements here...."),1,Wt::AlignCenter |Wt::AlignMiddle);
    44     ligneFaisceauLayout_->addWidget(allDropZone,1);
    45 }
    46 
    47 
    48 
    49 void GWt_LigneFaisceau::restoreElementCollectionFromDataManager()
    50 {
    51    
    52     cout<<"GWt_LigneFaisceau::restoreElementCollection()"<<endl;
    53    
    54     ligneFaisceauLayout_->clear();
    55    
    56     delete[] nObjets_;
     51    ligneFaisceauLayout_->addWidget(allDropZone_,1);
     52}
     53
     54
     55abstractElement* GWt_LigneFaisceau::addElement(typedElement eType){
     56    return addElement(eType,NULL);
     57}
     58
     59
     60
     61abstractElement* GWt_LigneFaisceau::addElement(typedElement eType, GWt_dropZoneLigneFaisceau* dropContainer ){
     62
     63    abstractElement* abstractElem = NULL;
     64   
     65    cout << " Entree addElement element " << nomdElements::getLabelFromType(eType) << endl;
     66   
    5767    int nElements= nomdElements ::getNumberOfElements();
    5868    nObjets_= new Compteur[nElements];
    5969   
    60     int nbElem = pspa_->getDataManager()->beamLineSize();
    61     unsigned int k;
    62    
    63     for(k = 0; k < (unsigned)nbElem; k++)
    64     {
    65         abstractElement* ptr = pspa_->getDataManager()->getCollection()->getElementPointerFromIndex(k);
    66        
    67         nObjets_[ptr->getNomdElement().getElementType()].incr();
    68        
    69         ligneFaisceauLayout_->addWidget(new GWt_elementLigneFaisceau(ptr,pspa_),1);
    70        
    71     }
    72     manageLineFaisceauLayout();
    73 }
    74 
    75 
    76 void GWt_LigneFaisceau::addElement(typedElement eType, GWt_dropZoneLigneFaisceau* dropContainer ){
    77    
    78     cout << " Entree addElement element " << nomdElements::getLabelFromType(eType) << endl;
    79    
    80     int nElements= nomdElements ::getNumberOfElements();
    81     nObjets_= new Compteur[nElements];
    82    
    83     // 2 cases :
     70    // 3 cases :
    8471    // -dropContainer is an element of the ligneFaisceauLayout_
    8572    // -dropContainer is an element of the GWt_elementLigneFaisceau_
     73    // -dropContainer is NULL, insert in the last element
    8674   
    8775    if(eType == inconnu) {
    8876        cout << "GWt_LigneFaisceau::element type " << eType << " inconnu " << endl;
    89         return;
     77        return NULL;
    9078    }
    9179   
    9280    // add the element to the datamanager
    93     abstractElement* ptr = pspa_->getDataManager()->addElement(eType);
     81//    abstractElement* ptr = pspa_->getDataManager()->addElement(eType);
    9482   
    9583    // first time we insert an element :
    … …  
    9785    if ((ligneFaisceauLayout_->count() == 1) && (!firstElemIsElement)) {
    9886        int index = indexOf (dropContainer);
    99         if (index != -1) { // found
     87        if ((index != -1) || (dropContainer == NULL)){ // found
    10088            // remove global drop zone
    10189            ligneFaisceauLayout_->clear();
     90
    10291            // add first element
    103             ligneFaisceauLayout_->addWidget(new GWt_elementLigneFaisceau(ptr,pspa_),1);
     92            GWt_elementLigneFaisceau* elemLigneFaisceau = new GWt_elementLigneFaisceau(eType, pspa_);
     93            abstractElem = elemLigneFaisceau->getGWt_AbstractElement()->getAbstractElement();
     94           
     95            ligneFaisceauLayout_->addWidget(new GWt_elementLigneFaisceau(eType, pspa_),1);
    10496            // remove arrow from begin and end
    10597           
    10698        } else { // error
    107             return;
     99            return NULL;
    108100        }
    109101    } else {
    … …  
    124116       
    125117        //  ligneFaisceauLayout_->addWidget(new GWt_elementLigneFaiseau(ptr),0);
     118        GWt_elementLigneFaisceau* elemLigneFaisceau = new GWt_elementLigneFaisceau(eType, pspa_);
    126119        if (index != -1) {
    127             nObjets_[ptr->getNomdElement().getElementType()].incr();
    128             ligneFaisceauLayout_->insertWidget(index,new GWt_elementLigneFaisceau(ptr,pspa_),1);
     120//            nObjets_[ptr->getNomdElement().getElementType()].incr();
     121            ligneFaisceauLayout_->insertWidget(index,elemLigneFaisceau,1);
     122            abstractElem = elemLigneFaisceau->getGWt_AbstractElement()->getAbstractElement();
     123        } else {
     124            ligneFaisceauLayout_->addWidget(elemLigneFaisceau,1);
     125            abstractElem = elemLigneFaisceau->getGWt_AbstractElement()->getAbstractElement();
    129126        }
    130127    }
    131128    manageLineFaisceauLayout();
    132    
     129
     130    return abstractElem;
    133131}
    134132
    … …  
    137135    // special : hide/setVisible arrow :
    138136    for (int a=0; a< ligneFaisceauLayout_->count(); a++) {
    139         GWt_elementLigneFaisceau* elem = static_cast <GWt_elementLigneFaisceau*> (ligneFaisceauLayout_->itemAt(a)->widget ());
    140         if (elem) {
     137        if (GWt_elementLigneFaisceau* elem = dynamic_cast <GWt_elementLigneFaisceau*> (ligneFaisceauLayout_->itemAt(a)->widget ())) {
     138
     139            // update labels
     140            elem->getGWt_AbstractElement()->updateLabelWidget();
     141           
     142            //  one element
    141143            if ((a == 0) && (a == (ligneFaisceauLayout_->count()-1))) {
    142144                elem->getDropZoneLeft()->setStyleClass("elementLigneFaiseau_transparent");
    143145                elem->getDropZoneRight()->setStyleClass("elementLigneFaiseau_transparent");
    144                 elem->getDropZoneLeft()->widget(0)->setHidden(true);
    145                 printf(" - -  %d\n",a);
     146
     147                // first
    146148            } else if (a == 0){
    147149                elem->getDropZoneLeft()->setStyleClass("elementLigneFaiseau_transparent");
    148150                elem->getDropZoneRight()->setStyleClass("elementLigneFaiseau_line");
    149                 elem->getDropZoneLeft()->widget(0)->setHidden(true);
    150                 printf(" - D %d\n",a);
     151
     152                // last
    151153            } else if (a == (ligneFaisceauLayout_->count()-1)){
    152154                elem->getDropZoneLeft()->setStyleClass("elementLigneFaiseau_line");
    153155                elem->getDropZoneRight()->setStyleClass("elementLigneFaiseau_transparent");
    154                 elem->getDropZoneLeft()->widget(0)->setHidden(false);
    155156               
    156                 printf(" L - %d\n",a);
     157               
     158                // middle elements
    157159            } else {
    158160                elem->getDropZoneLeft()->setStyleClass("elementLigneFaiseau_line");
    159161                elem->getDropZoneRight()->setStyleClass("elementLigneFaiseau_line");
    160                 elem->getDropZoneLeft()->widget(0)->setHidden(false);
    161                 printf(" L D %d\n",a);
    162162            }
    163163        }
    … …  
    167167
    168168
    169 void GWt_LigneFaisceau::removeElement(GWt_abstractElement* abstractElement) {
    170     if (abstractElement == NULL)
     169
     170void GWt_LigneFaisceau::update() {
     171    manageLineFaisceauLayout();
     172}
     173
     174
     175void GWt_LigneFaisceau::removeElement(GWt_abstractElement* GWt_abstractElement) {
     176    if (GWt_abstractElement == NULL)
    171177        return;
    172178   
    … …  
    178184        GWt_elementLigneFaisceau* elem = static_cast <GWt_elementLigneFaisceau*> (ligneFaisceauLayout_->itemAt(a)->widget ());
    179185        if (elem) {
    180             if (elem->getElement() == abstractElement) {
     186            if (elem->getGWt_AbstractElement() == GWt_abstractElement) {
    181187                index = a;
    182188            }
    … …  
    186192    if (index != -1) {
    187193        // remove element from the list
    188         pspa_->getDataManager()->removeElement(abstractElement->getElement()->getLabel());
     194//        pspa_->getDataManager()->removeElement(GWt_abstractElement->getElement()->getLabel());
    189195       
    190196        ligneFaisceauLayout_->removeItem(ligneFaisceauLayout_->itemAt(index));
    191         delete abstractElement;
     197        delete GWt_abstractElement;
    192198       
    193199        // manage widgets if necessary
    194200        manageLineFaisceauLayout();
    195201    }
    196    
    197    
    198 }
    199 
     202}
     203
     204
     205abstractElement* GWt_LigneFaisceau::getAbstractElement(int i){
     206    int index = 0;
     207
     208    // first if 1
     209//    i--;
     210   
     211    for (int a=0; a< ligneFaisceauLayout_->count(); a++) {
     212        if (GWt_elementLigneFaisceau* elem = dynamic_cast <GWt_elementLigneFaisceau*> (ligneFaisceauLayout_->itemAt(a)->widget ())) {
     213            if (index == i) {
     214                printf("GWt_LigneFaisceau::getAbstractElement %d %s\n",i,elem->getGWt_AbstractElement()->getAbstractElement()->getLabel().c_str());
     215                return elem->getGWt_AbstractElement()->getAbstractElement();
     216            }
     217            index ++;
     218        }
     219    }
     220    return NULL;
     221}
     222
     223
     224int GWt_LigneFaisceau::getBeamLineSize() {
     225    int count = 0;
     226    for (int a=0; a< ligneFaisceauLayout_->count(); a++) {
     227        if (dynamic_cast <GWt_elementLigneFaisceau*> (ligneFaisceauLayout_->itemAt(a)->widget ())) {
     228            count ++;
     229        }
     230    }
     231    return count;
     232}
     233
     234
     235vector <abstractElement*> GWt_LigneFaisceau::getAllAbstractElements(){
     236    vector <abstractElement*> elems;
     237    for (int a=0; a< ligneFaisceauLayout_->count(); a++) {
     238        if (GWt_elementLigneFaisceau* elem = dynamic_cast <GWt_elementLigneFaisceau*> (ligneFaisceauLayout_->itemAt(a)->widget ())) {
     239            elems.push_back(elem->getGWt_AbstractElement()->getAbstractElement());
     240        }
     241    }
     242    return elems;
     243}
     244

  • Interface_Web/trunk/pspaWT/sources/userInterface/src/GWt_pspaApplication.cc

    r302 r305  
    6767    WContainerWidget *widroot = root();
    6868    useStyleSheet       ("htdocs/pspa.css");
    69     dtmanage_ = new dataManager();
     69    dtmanage_ = new dataManager(this);
    7070    dtmanage_->setWorkingDir(workingDir_);
    7171    /*
    … …  
    123123    layout->addWidget(createPalette(), 2, 0, 4, 1);
    124124   
    125     beamLine_ = createBeamLine();
     125    createBeamLine();
     126
    126127    WScrollArea* scroll = new  WScrollArea();
    127128    scroll->setWidget(beamLine_);
    … …  
    212213}
    213214
    214 WWidget* PspaApplication::createBeamLine()
    215 {
    216     WContainerWidget* beamLine = new GWt_LigneFaisceau(this);
    217     beamLine->setMinimumSize(300,100);
    218     return beamLine;
     215void PspaApplication::createBeamLine()
     216{
     217    beamLine_ = new GWt_LigneFaisceau(this);
     218    beamLine_->setMinimumSize(300,100);
    219219}
    220220
    … …  
    361361   
    362362    GWt_LigneFaisceau* bobo = static_cast<GWt_LigneFaisceau*>(beamLine_);
    363     bobo->restoreElementCollectionFromDataManager();
     363//    bobo->restoreElementCollectionFromDataManager();
    364364   
    365365    console_->addConsoleMessage(string("...terminee"));
    … …  
    421421       
    422422        GWt_LigneFaisceau* bobo = static_cast<GWt_LigneFaisceau*>(beamLine_);
    423         bobo->restoreElementCollectionFromDataManager();
     423//        bobo->restoreElementCollectionFromDataManager();
    424424       
    425425        console_->addConsoleMessage(string("...terminee"));
    … …  
    448448{
    449449    choixElementDessin_->clear();
    450     int nombre = dtmanage_->beamLineSize();
     450    int nombre = dtmanage_->getBeamLineSize();
    451451    for ( int numero =1; numero <= nombre; numero++)
    452452    {
    … …  
    523523   
    524524    //       new WText(nameOfCase_ + " : enveloppe", toto);
    525     unsigned nbel = dtmanage_->beamLineSize();
     525    unsigned nbel = dtmanage_->getBeamLineSize();
    526526   
    527527   

  • Interface_Web/trunk/pspaWT/sources/userInterface/src/GWt_rfgun.cc

    r304 r305  
    88#include <Wt/WPushButton>
    99
    10 GWt_rfgun::GWt_rfgun(abstractElement* elem, GWt_elementLigneFaisceau* elemLigne)
    11 :GWt_abstractElement(elem)
     10GWt_rfgun::GWt_rfgun(GWt_elementLigneFaisceau* elemLigne)
     11:GWt_abstractElement(new elementRfgun())
    1212{
    1313    elementLigneFaiseauContainer_ = elemLigne;

  • Interface_Web/trunk/pspaWT/sources/userInterface/src/GWt_softwarePanel.cc

    r302 r305  
    7777        premierText = dtmanage_->getLabelFromElementNumero(1);
    7878       
    79         dernierText = dtmanage_->getLabelFromElementNumero(dtmanage_->beamLineSize());
     79        dernierText = dtmanage_->getLabelFromElementNumero(dtmanage_->getBeamLineSize());
    8080    }
    8181    else
    8282    {
    8383        dernierText = selectedSections_.back()->fin->text().toUTF8();
    84         int dernierNumero = dtmanage_->getCollection()->getNumeroFromLabel(dernierText);
     84        int dernierNumero = dtmanage_->getNumeroFromElementLabel(dernierText);
    8585        dernierNumero++;
    86         if ( dernierNumero <= dtmanage_->beamLineSize() )
     86        if ( dernierNumero <= dtmanage_->getBeamLineSize() )
    8787        {
    8888            premierText = dtmanage_->getLabelFromElementNumero(dernierNumero);
    … …  
    9090        else
    9191        {
    92             premierText = dtmanage_->getLabelFromElementNumero(dtmanage_->beamLineSize());
     92            premierText = dtmanage_->getLabelFromElementNumero(dtmanage_->getBeamLineSize());
    9393        }
    9494        dernierText = premierText;
    … …  
    139139   
    140140    string currentString =  (*selectedSections_.begin())->fin->text().toUTF8();
    141     int current = dtmanage_->getCollection()->getNumeroFromLabel( currentString);
     141    int current = dtmanage_->getNumeroFromElementLabel( currentString);
    142142   
    143143    cout << " numero " << current << endl;
    144144    // si la fin est mal definie on prend toute la config par defaut
    145     if ( current <= 0 || current > dtmanage_->beamLineSize() )
    146     {
    147         current = dtmanage_->beamLineSize();
     145    if ( current <= 0 || current > dtmanage_->getBeamLineSize() )
     146    {
     147        current = dtmanage_->getBeamLineSize();
    148148        currentString =  dtmanage_->getLabelFromElementNumero(current);
    149149        (*selectedSections_.begin())->fin->setText(currentString);
    … …  
    159159    {
    160160        // debut
    161         if ( current >= dtmanage_->beamLineSize() )
     161        if ( current >= dtmanage_->getBeamLineSize() )
    162162        {
    163163            //    GWt_tools::addConsoleMessage(" bad section definition !  \n ");
    … …  
    171171        string finString =  (*itr)->fin->text().toUTF8();
    172172       
    173         int numeroFin = dtmanage_->getCollection()->getNumeroFromLabel( finString);
    174        
    175         if ( numeroFin <= current || numeroFin > dtmanage_->beamLineSize())
     173        int numeroFin = dtmanage_->getNumeroFromElementLabel( finString);
     174       
     175        if ( numeroFin <= current || numeroFin > dtmanage_->getBeamLineSize())
    176176        {
    177177            //    GWt_tools::addConsoleMessage(" bad section definition !  \n ");
    … …  
    209209       
    210210       
    211         int debut = dtmanage_->getCollection()->getNumeroFromLabel(debString);
    212         int fin = dtmanage_->getCollection()->getNumeroFromLabel(finString);
     211        int debut = dtmanage_->getNumeroFromElementLabel(debString);
     212        int fin = dtmanage_->getNumeroFromElementLabel(finString);
    213213        nomDeLogiciel prog = nomDeLogiciel ( (*itr)->selection->currentIndex() );
    214214        dtmanage_->addSectionToExecute(debut,fin,prog);
    … …  
    250250    {
    251251        premierText = dtmanage_->getLabelFromElementNumero(1);
    252         dernierText = dtmanage_->getLabelFromElementNumero( dtmanage_->beamLineSize() );
     252        dernierText = dtmanage_->getLabelFromElementNumero( dtmanage_->getBeamLineSize() );
    253253        (*selectedSections_.begin())->debut->setText(premierText);
    254254        (*selectedSections_.begin())->fin->setText(dernierText);

  • Interface_Web/trunk/pspaWT/sources/userInterface/src/GWt_soleno.cc

    r294 r305  
    88#include <Wt/WPushButton>
    99
    10 GWt_soleno::GWt_soleno(abstractElement* elem, GWt_elementLigneFaisceau* elemLigne)
    11 :GWt_abstractElement(elem)
     10GWt_soleno::GWt_soleno(GWt_elementLigneFaisceau* elemLigne)
     11:GWt_abstractElement(new elementSoleno())
    1212{
    1313    elementLigneFaiseauContainer_ = elemLigne;
Note: See TracChangeset for help on using the changeset viewer.