-/*=========================================================================
+/*=========================================================================
Program: bbtk
Module: $RCSfile$
Language: C++
* Copyright (c) CREATIS-LRMN (Centre de Recherche en Imagerie Medicale)
* Authors : Eduardo Davila, Laurent Guigues, Jean-Pierre Roux
*
-* This software is governed by the CeCILL-B license under French law and
-* abiding by the rules of distribution of free software. You can use,
-* modify and/ or redistribute the software under the terms of the CeCILL-B
-* license as circulated by CEA, CNRS and INRIA at the following URL
-* http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
+* This software is governed by the CeCILL-B license under French law and
+* abiding by the rules of distribution of free software. You can use,
+* modify and/ or redistribute the software under the terms of the CeCILL-B
+* license as circulated by CEA, CNRS and INRIA at the following URL
+* http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
* or in the file LICENSE.txt.
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
-* liability.
+* liability.
*
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL-B license and that you accept its terms.
-* ------------------------------------------------------------------------ */
+* ------------------------------------------------------------------------ */
/**
-* \file
-* \brief Class bbtk::wxVtkSceneManager .
+* \file
+* \brief Class bbtk::wxVtkSceneManager .
*/
#include "wxVtkSceneManager.h"
+ #include <vtkPolygon.h>
+ #include <vtkUnstructuredGrid.h>
+
namespace bbtk
{
//=========================================================================
wxVtkSceneManager::wxVtkSceneManager(wxGEditorTabPanel *parent, wxVtk3DBaseView *baseView,int idManager)
{
- printf ("EED %p wxVtkSceneManager()\n" , this );
- _parent = parent;
- _numBoxes=0;
- _idManager=idManager;
- _baseView=baseView;
- _startDragging=false;
- _isComplexBox=false;
+ _cbName = "ComplexBoxName";
+ _cbPackageName = "PackageName";
+ _Author = "Author ??";
+ _Category = "<VOID>";
+ _Description = "Description ??";
+
+ _parent = parent;
+ _numBoxes = 0;
+ _idManager = idManager;
+ _baseView = baseView;
+ _startDragging = false;
+ _isComplexBox = false;
if( _baseView!=NULL )
{
-//EED02JUIN2010
- _baseView->GetWxVTKRenderWindowInteractor()->SetDropTarget((wxDropTarget*)parent);
+//EED02JUIN2010
+ printf ("RaC-EED 21-06-2010 %p wxVtkSceneManager::wxVtkSceneManager If you comment this line, the drag and drop functionnality is not initialized.\n" , this );
+#ifdef __APPLE__
+ _baseView->GetWxVTKRenderWindowInteractor()->SetDropTarget((wxDropTarget*)parent);
+#endif
+
configureBaseView();
_worldState=NOTHING_HAPPENS;
registerController(this);
-
+
}
+ _idConnectionInCreation = -1;
+ _contLastId = 0;
}
wxVtkSceneManager::~wxVtkSceneManager()
{
+ //FCY memory leaks
printf ("EED %p ~wxVtkSceneManager()\n" , this );
disconnectDrop();
+ delete _baseView;
}
-
+
//=========================================================================
void wxVtkSceneManager::configureBaseView()
{
+printf("EED wxVtkSceneManager::configureBaseView 0\n");
vtkInteractorStyleBaseView2D *interactorstylebaseview = vtkInteractorStyleBaseView2D::New();
_baseView->SetInteractorStyleBaseView(interactorstylebaseview);
interactorstylebaseview->SetInteractor ( iren );
iren->SetInteractorStyle(interactorstylebaseview);
interactorstylebaseview->SetwxVtkBaseView(_baseView);
-
+
_baseView->GetRenderer()->GetActiveCamera()->ParallelProjectionOn();
- _baseView->GetRenderer()->ResetCamera(-100,100,-100,100,900,1000);
-
+ _baseView->GetRenderer()->ResetCamera(-100,100,-100,100,800,1100);
+
_baseView->GetRenderer()->SetBackground(0.9,0.9,0.9);
- _baseView->GetRenderer()->GradientBackgroundOff();
+ _baseView->GetRenderer()->GradientBackgroundOn();
_baseView->Refresh();
+
+ // Actos Port_Text
+ _textActor = vtkTextActor3D::New();
+ _textActor->SetPosition( -9999 , -9999 , 900 );
+ _textActor->SetInput( "<void>" );
+ _textActor->GetTextProperty()->SetFontSize(60);
+ _textActor->GetTextProperty()->BoldOn();
+ _textActor->GetTextProperty()->SetColor(PORTTEXT_NH_R,PORTTEXT_NH_G,PORTTEXT_NH_B);
+
+ _baseView->GetRenderer()->AddActor( _textActor );
+
+
+ // Actor Fill_Port_Text
+
+ //------------
+ double xInic = 0;
+ double yInic = 0;
+ double zInic = 900;
+
+ vtkPolygon *aPolygon = vtkPolygon::New();
+ _fillObjectActor = vtkActor::New();
+
+ _pts = vtkPoints::New();
+
+ double w=100,h=10,b=h/15,t=3;
+ _pts->SetNumberOfPoints(21);
+ _pts->InsertPoint(0, xInic+w*0.33-t/2 , yInic , zInic );
+ _pts->InsertPoint(1, xInic+w*0.33 , yInic-t , zInic );
+ _pts->InsertPoint(2, xInic+w*0.33+t/2 , yInic , zInic );
+ _pts->InsertPoint(3, xInic+w*0.33+t/2 , yInic , zInic );
+ _pts->InsertPoint(4, xInic+w-b*4 , yInic+b*0 , zInic );
+
+ _pts->InsertPoint( 5, xInic+w-b*4 , yInic+b*0 , zInic );
+ _pts->InsertPoint( 6, xInic+w-b*2 , yInic+b*1 , zInic );
+ _pts->InsertPoint( 7, xInic+w-b*1 , yInic+b*2 , zInic );
+ _pts->InsertPoint( 8, xInic+w-b*0 , yInic+b*4 , zInic );
+
+ _pts->InsertPoint( 9, xInic+w-b*0 , yInic+h-b*4 , zInic );
+ _pts->InsertPoint(10, xInic+w-b*1 , yInic+h-b*2 , zInic );
+ _pts->InsertPoint(11, xInic+w-b*2 , yInic+h-b*1 , zInic );
+ _pts->InsertPoint(12, xInic+w-b*4 , yInic+h-b*0 , zInic );
+
+ _pts->InsertPoint(13, xInic+b*4 , yInic+h-b*0 , zInic );
+ _pts->InsertPoint(14, xInic+b*2 , yInic+h-b*1 , zInic );
+ _pts->InsertPoint(15, xInic+b*1 , yInic+h-b*2 , zInic );
+ _pts->InsertPoint(16, xInic+b*0 , yInic+h-b*4 , zInic );
+
+ _pts->InsertPoint(17, xInic+b*0 , yInic+b*4 , zInic );
+ _pts->InsertPoint(18, xInic+b*1 , yInic+b*2 , zInic );
+ _pts->InsertPoint(19, xInic+b*2 , yInic+b*1 , zInic );
+ _pts->InsertPoint(20, xInic+b*4 , yInic+b*0 , zInic );
+
+ aPolygon->GetPointIds()->SetNumberOfIds(21);
+ for (int i=0;i<21; i++)
+ {
+ aPolygon->GetPointIds()->SetId(i, i);
+ }
+
+ vtkUnstructuredGrid *aPolygonGrid = vtkUnstructuredGrid::New();
+ aPolygonGrid->Allocate(1, 1);
+ aPolygonGrid->InsertNextCell(aPolygon->GetCellType(), aPolygon->GetPointIds());
+ aPolygonGrid->SetPoints(_pts);
+ _aPolygonMapper = vtkDataSetMapper::New();
+ _aPolygonMapper->SetInput(aPolygonGrid);
+ _fillObjectActor->SetMapper(_aPolygonMapper);
+ _fillObjectActor->GetProperty()->SetColor(PORTFILL_NH_R,PORTFILL_NH_G,PORTFILL_NH_B);
+ _fillObjectActor->GetProperty()->SetOpacity(0);
+ _aPolygonMapper->Modified();
+
+ _baseView->GetRenderer()->AddActor( _fillObjectActor );
+printf("EED wxVtkSceneManager::configureBaseView 1\n");
}
//=========================================================================
- int wxVtkSceneManager::createGBlackBox(int x, int y, std::string packageName, std::string boxType)
+ std::string wxVtkSceneManager::generateANewNameForABox()
{
- int windowWidth=_baseView->GetRenWin()->GetSize()[0];
- int windowHeight=_baseView->GetRenWin()->GetSize()[1];
+ std::stringstream boxname;
+ if(_numBoxes<10)
+ {
+ boxname << "Box0" << _numBoxes;
+ }else{
+ boxname << "Box" << _numBoxes;
+ }
+ _numBoxes++;
+ return boxname.str();
+ }
+
+ //=========================================================================
+
+ std::string wxVtkSceneManager::findANewNameForABox()
+ {
+ std::string boxname=generateANewNameForABox();
+
+ while (boxExist(boxname)==true)
+ {
+ boxname=generateANewNameForABox();
+ } // while
+
+ return boxname;
+ }
+
+ //=========================================================================
+ void wxVtkSceneManager::configGBlackBox(int idBox, double xIn, double yIn, double zIn, std::string name, bool boxExecutable,double xEn,double yEn,double zEn)
+ {
+ GObjectController *cont = _controllers[idBox];
+ GBlackBoxModel *bbmod = (GBlackBoxModel*)cont->getModel();
+ bbmod->setBBTKName(name);
+ bbmod->setInicPoint(xIn,yIn,zIn);
+ bbmod->setFinalPoint(xEn,yEn,zEn);
+ bbmod->setExecutable(boxExecutable);
+
+ bbmod->notifyObservers(_idManager);
+
+ }
- int type = GBLACKBOX;
+
+ //=========================================================================
+
+ int wxVtkSceneManager::createGBlackBox(int x, int y, std::string packageName, std::string boxType)
+ {
+ _worldState = NOTHING_HAPPENS;
+//EED int windowWidth = _baseView->GetRenWin()->GetSize()[0];
+ int windowHeight = _baseView->GetRenWin()->GetSize()[1];
+
+ int type = GBLACKBOX;
//Create the MVC Objects
-
- GBlackBoxModel *model = (GBlackBoxModel*)GObjectsMVCFactory::getInstance()->createGObjectModel(type);
- vtkGObjectView *view = GObjectsMVCFactory::getInstance()->createGObjectView(type);
- GObjectController* controller = GObjectsMVCFactory::getInstance()->createGObjectController(type);
-
- BlackBoxDescriptor::Pointer descriptor = GObjectsMVCFactory::getInstance()->getBlackBoxDescriptor(packageName, boxType);
-
+
+ GBlackBoxModel *model = (GBlackBoxModel*)GObjectsMVCFactory::getInstance()->createGObjectModel(type);
+ vtkGObjectView *view = GObjectsMVCFactory::getInstance()->createGObjectView(type);
+ GObjectController* controller = GObjectsMVCFactory::getInstance()->createGObjectController(type);
+
+ BlackBoxDescriptor::Pointer descriptor = GObjectsMVCFactory::getInstance()->getBlackBoxDescriptor(packageName, boxType);
+
//Prepares the initial model
- //The coordinates obtained are the following. Top-Left:x=0,y=0 Bottom-Right:x=width,y=height
+ //The coordinates obtained are the following. Top-Left:x=0,y=0 Bottom-Right:x=width,y=height
double xx = x;
double yy = windowHeight-y;
-
+
//z value is not important yet, because it is only used a parallel projection
double zz = 900;
-
_baseView->TransCoordScreenToWorld(xx,yy,zz);
model->setInicPoint(xx,yy,zz);
-
- _numBoxes++;
+
std::stringstream stream;
-
- if(_numBoxes<10)
- {
- stream << "Box0" << _numBoxes;
- }
- else
- {
- stream << "Box" << _numBoxes;
- }
+
+ std::string newBoxName;
+ newBoxName = findANewNameForABox();
+
+
+ stream << newBoxName;
+
std::string arraystring = stream.str();
model->setBBTKName(arraystring);
model->setBBTKType(boxType);
model->setBBTKPackage(packageName);
-
+
model->addObserver(view);
model->addObserver(this);
view->setModel(model);
view->setBaseView(_baseView);
view->initVtkObjects();
-
+
//Associates the controller with the correspondent model and view
controller->setModelAndView(model,view);
//Resgiter change to the observers of the actual model
model->notifyObservers(_idManager);
-
+
int newId = addObjectController(controller);
+
return newId;
}
int wxVtkSceneManager::createGComplexBoxInputPort(std::string inputName)
{
- int windowWidth=_baseView->GetRenWin()->GetSize()[0];
+//EED int windowWidth=_baseView->GetRenWin()->GetSize()[0];
int windowHeight=_baseView->GetRenWin()->GetSize()[1];
-
- int type = GCOMPLEXINPUTPORT;
+
+ int type = GCOMPLEXINPUTPORT;
//Create the MVC Objects
-
- GComplexBoxPortModel *model = (GComplexBoxPortModel*)GObjectsMVCFactory::getInstance()->createGObjectModel(type);
- vtkGObjectView *view = GObjectsMVCFactory::getInstance()->createGObjectView(type);
- GObjectController* controller = GObjectsMVCFactory::getInstance()->createGObjectController(type);
-
- //Prepares the initial model
-
- double xx = 5;
- double yy = windowHeight-5;
-
+
+ GComplexBoxPortModel *model = (GComplexBoxPortModel*)GObjectsMVCFactory::getInstance()->createGObjectModel(type);
+ vtkGObjectView *view = GObjectsMVCFactory::getInstance()->createGObjectView(type);
+ GObjectController* controller = GObjectsMVCFactory::getInstance()->createGObjectController(type);
+
+ //Prepares the initial model
+
+ double xx = 5;
+ double yy = windowHeight-5;
+
//z value is not important yet, because it is only used a parallel projection
- double zz = 900;
+ double zz = 900;
+printf("EED wxVtkSceneManager::createGComplexBoxInputPort 900-450\n");
_baseView->TransCoordScreenToWorld(xx,yy,zz);
model->setInicPoint(xx,yy,zz);
-
+
model->setBBTKName(inputName);
model->setBBTKType("ComplexInputPort");
model->setComplexPortType(type);
-
+
model->addObserver(view);
model->addObserver(this);
-
- //create the output port
+
+ //create the output port
GPortController* portController = createGPort(GOUTPUTPORT,inputName,"ComplexInputPort",0,model);
model->addOutputPort((GPortModel*)portController->getModel());
-
+
//Associates the view with the correspondent renderer and the model.
//(NOTE: Refresh is only made by the view)
view->setModel(model);
view->setBaseView(_baseView);
view->initVtkObjects();
-
+
//Associates the controller with the correspondent model and view
controller->setModelAndView(model,view);
//Resgiter change to the observers of the actual model
model->notifyObservers(_idManager);
-
+
int newId = addObjectController(controller);
return newId;
}
//=========================================================================
-
+
int wxVtkSceneManager::createGComplexBoxOutputPort(std::string outputName)
{
- int windowWidth=_baseView->GetRenWin()->GetSize()[0];
+//EED int windowWidth=_baseView->GetRenWin()->GetSize()[0];
int windowHeight=_baseView->GetRenWin()->GetSize()[1];
- int type = GCOMPLEXOUTPUTPORT;
+ int type = GCOMPLEXOUTPUTPORT;
//Create the MVC Objects
-
- GComplexBoxPortModel *model = (GComplexBoxPortModel*)GObjectsMVCFactory::getInstance()->createGObjectModel(type);
- vtkGObjectView *view = GObjectsMVCFactory::getInstance()->createGObjectView(type);
- GObjectController* controller = GObjectsMVCFactory::getInstance()->createGObjectController(type);
-
- //Prepares the initial model
-
- double xx = 5;
- double yy = windowHeight-5;
-
+
+ GComplexBoxPortModel *model = (GComplexBoxPortModel*)GObjectsMVCFactory::getInstance()->createGObjectModel(type);
+ vtkGObjectView *view = GObjectsMVCFactory::getInstance()->createGObjectView(type);
+ GObjectController *controller = GObjectsMVCFactory::getInstance()->createGObjectController(type);
+
+ //Prepares the initial model
+
+ double xx = 5;
+ double yy = windowHeight-5;
+
//z value is not important yet, because it is only used a parallel projection
- double zz = 900;
+ double zz = 900;
+
+printf("EED wxVtkSceneManager::createGComplexBoxOutputPort 900-450\n");
_baseView->TransCoordScreenToWorld(xx,yy,zz);
model->setInicPoint(xx,yy,zz);
-
+
model->setBBTKName(outputName);
model->setBBTKType("ComplexOutputPort");
model->setComplexPortType(type);
-
+
model->addObserver(view);
model->addObserver(this);
-
- //create the output port
+
+ //create the output port
GPortController* portController = createGPort(GINPUTPORT,outputName,"ComplexInputPort",0,model);
model->addInputPort((GPortModel*)portController->getModel());
-
+
//Associates the view with the correspondent renderer and the model.
//(NOTE: Refresh is only made by the view)
view->setModel(model);
view->setBaseView(_baseView);
view->initVtkObjects();
-
+
//Associates the controller with the correspondent model and view
controller->setModelAndView(model,view);
//Resgiter change to the observers of the actual model
model->notifyObservers(_idManager);
-
+
int newId = addObjectController(controller);
return newId;
}
int type = GPORT;
//Create the MVC Objects
- GPortModel *model = (GPortModel*)GObjectsMVCFactory::getInstance()->createGObjectModel(type);
- vtkGObjectView *view = GObjectsMVCFactory::getInstance()->createGObjectView(type);
- GObjectController* controller = GObjectsMVCFactory::getInstance()->createGObjectController(type);
+ GPortModel *model = (GPortModel*)GObjectsMVCFactory::getInstance()->createGObjectModel(type);
+ vtkGObjectView *view = GObjectsMVCFactory::getInstance()->createGObjectView(type);
+ GObjectController* controller = GObjectsMVCFactory::getInstance()->createGObjectController(type);
model->registerInBox(blackBox,portType, posInBox);
-
+
model->setBBTKType(bbtkType);
model->setBBTKName(bbtkName);
view->setModel(model);
view->setBaseView(_baseView);
view->initVtkObjects();
-
+
//Associates the controller with the correspondent model and view
controller->setModelAndView(model,view);
model->notifyObservers(_idManager);
- int newId = addObjectController(controller);
+ addObjectController(controller);
return (GPortController*)controller;
}
int type = GCONNECTOR;
manualConnectorContourController* manContourControl = new manualConnectorContourController();
- manualConnectorContourView* manContourView = new manualConnectorContourView();
- manualContourModel* manContourModel = new manualContourModel();
+ manualConnectorContourView* manContourView = new manualConnectorContourView();
+ manualContourModel* manContourModel = new manualContourModel();
- GConnectorController* connectorcontroller = new GConnectorController();
- GConnectorModel* connectorModel = new GConnectorModel();
- vtkGConnectorView* connectorView = new vtkGConnectorView();
+ GConnectorController* connectorcontroller = new GConnectorController();
+ GConnectorModel* connectorModel = new GConnectorModel();
+ vtkGConnectorView* connectorView = new vtkGConnectorView();
connectorModel->setGObjectType(type);
manContourModel->SetCloseContour(false);
manContourView->SetShowText(false);
manContourControl->SetModelView( manContourModel , manContourView );
-
+
manContourControl->CreateNewManualContour();
manContourView->RefreshContour();
manContourControl->SetState(1);
manContourModel->SetCloseContour(false);
-
+
manContourModel->AddPoint(x,y,z);
manContourView->AddPoint();
int newId = addObjectController(connectorcontroller);
- connectorcontroller->setManualContourController(manContourControl);
+ connectorcontroller->setManualContourController(manContourControl);
connectorModel->setManualContourModel(manContourModel);
connectorView->setManualContourView(manContourView);
connectorView->setModel(connectorModel);
connectorView->setBaseView(_baseView);
-
+
connectorModel->addObserver(connectorView);
connectorModel->addObserver(this);
}
//=========================================================================
-
+
+ //=========================================================================
+ int wxVtkSceneManager::GetIndexInSelected(int idControler)
+ {
+ int index=-1;
+ for (int i=0; i<(int)_selectedObjects.size(); i++)
+ {
+ if(_selectedObjects[i]==idControler)
+ {
+ index=i;
+ break;
+ }
+ }
+ return index;
+ }
+ //=========================================================================
+
void wxVtkSceneManager::update(int idController,int command)
{
+
if(command != NO_COMMAND)
{
if(command == ADD_TO_SELECTED)
{
- GObjectController* cont = _controllers[idController];
+//EEDBorrame GObjectController* cont = _controllers[idController];
- bool foundID=false;
- for (int i=0; i<_selectedObjects.size() && foundID==false; i++)
- {
- int id = _selectedObjects[i];
- if(id==idController)
- {
- foundID = true;
- }
- }
- if(!foundID)
+ if (GetIndexInSelected(idController)==-1)
{
- int id = idController;
- _selectedObjects.push_back(id);
+ _selectedObjects.push_back(idController);
}
- }
+//EEDBorrame
+// bool foundID=false;
+// for (int i=0; i<(int)_selectedObjects.size() && foundID==false; i++)
+// {
+// if(_selectedObjects[i]==idController)
+// {
+// foundID = true;
+// }
+// }
+// if(!foundID)
+// {
+// _selectedObjects.push_back(idController);
+// }
+
+ }else if(command == REMOVE_FROM_SELECTED)
+ {
+ int index=GetIndexInSelected(idController);
+ if (index>=0)
+ {
+ _selectedObjects.erase( _selectedObjects.begin()+index );
+ }
+ }
else if(command == INIT_CREATION_CONTOUR)
- {
- _worldState = INIT_CREATION_CONTOUR;
- GObjectController* cont = _controllers[idController];
+ {
+ _worldState = INIT_CREATION_CONTOUR;
+ GObjectController* cont = _controllers[idController];
GPortModel* startOutputPort = (GPortModel*)cont->getModel();
-
+
// The last one is the controller of the connector
- for(int i=0;i<_controllers.size();i++)
+ std::map<int, GObjectController*>::iterator it2;
+
+ for(it2 = _controllers.begin(); it2 != _controllers.end(); ++it2)
{
- GObjectController* cont = _controllers[i];
+ GObjectController *cont = it2->second;
if(cont->getGObjectType() == GPORT )
{
GPortModel* port = (GPortModel*)cont->getModel();
cont->getView()->setState(NOTHING_HAPPENS);
cont->getModel()->notifyObservers(_idManager);
cont->SetActive(false);
- }
+ }
}
-
_selectedObjects.clear();
-
- createGConnector(startOutputPort);
-
+ _idConnectionInCreation=createGConnector(startOutputPort);
}
else if(command == FIN_CREATION_CONTOUR && _worldState == INIT_CREATION_CONTOUR)
- {
- _worldState = NOTHING_HAPPENS;
- int id = _controllers.size()-1;
- GObjectController* cont = _controllers[id];
- GConnectorModel* modelContour = (GConnectorModel*)cont->getModel();
+ {
+ _worldState = NOTHING_HAPPENS;
+ //int id = _controllers.size()-1;
+ GObjectController *cont = _controllers[_idConnectionInCreation];
+ GConnectorModel *modelContour = (GConnectorModel*)cont->getModel();
+ GObjectController *finPort = _controllers[idController];
- GObjectController* finPort = _controllers[idController];
if(finPort->getGObjectType() == GPORT)
{
GPortModel* modelPort = (GPortModel*)finPort->getModel();
modelContour->setEndPort(modelPort);
- }
+ }
- manualConnectorContourController* manCont = ((GConnectorController*)cont)->getManualContourController();
+ manualConnectorContourController* manCont = ((GConnectorController*)cont)->getManualContourController();
manualConnectorContourView* connView = (manualConnectorContourView*)manCont->GetManualViewBaseContour();
connView->Refresh();
- for(int i=0;i<_controllers.size();i++)
+ std::map<int, GObjectController*>::iterator it2;
+
+ for(it2 = _controllers.begin(); it2 != _controllers.end(); ++it2)
{
- GObjectController* cont = _controllers[i];
+ GObjectController *cont = it2->second;
if(cont->getView()!=NULL)
{
cont->getView()->setState(NOTHING_HAPPENS);
cont->getModel()->notifyObservers(_idManager);
}
- cont->SetActive(true);
+ cont->SetActive(true);
}
}
-
+
}
+
}
//=========================================================================
bool wxVtkSceneManager::OnMouseMove()
{
int X,Y;
+ bool okStatusMessage = false;
+ bool okPortMessage = false;
wxVTKRenderWindowInteractor *wxVTKiren;
wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
wxVTKiren->GetEventPosition(X,Y);
-
-
+
+
if(_worldState == DRAG_OBJECTS)
- {
- for (int i=0; i<_selectedObjects.size(); i++)
+ {
+ for (int i=0; i<(int)_selectedObjects.size(); i++)
{
int id = _selectedObjects[i];
GObjectController* cont = _controllers[id];
std::map<int, GObjectController*>::iterator it;
+
for(it = _controllers.begin(); it != _controllers.end(); ++it)
{
GObjectController *desc = it->second;
vconn->updateStartEndPoints();
}
}
-
+
_startDragging=false;
}
else if(_worldState == NOTHING_HAPPENS || _worldState == INIT_CREATION_CONTOUR)
{
std::map<int, GObjectController*>::iterator it;
-
+ double px, py, pz;
for(it = _controllers.begin(); it != _controllers.end(); ++it)
{
GObjectController *desc = it->second;
- int type = desc->getGObjectType();
- int state = desc->getView()->getState();
-
- if(state == HIGHLIGHTED){
+ int type = desc->getGObjectType();
+ int state = desc->getView()->getState();
+ desc->getModel()->getCenter(px,py,pz);
+ if(state == HIGHLIGHTED){
+ okStatusMessage = true;
updateStatusBar(desc->getStatusText());
if(type==GBLACKBOX)
{
GBlackBoxModel *mod = (GBlackBoxModel*)desc->getModel();
_parent->displayBlackBoxInfo(mod->getBBTKPackage(),mod->getBBTKType());
- }
- }
+ } // if GBLACKBOX
+ if(type==GPORT)
+ {
+ // PortText
+ okPortMessage = true;
+ py=py+5;
+ _textActor->SetInput( desc->getStatusText().c_str() );
+ _textActor->SetScale(0.1);
+ _textActor->SetPosition( px-25 ,py+1 , pz+2 );
+
+ // FillPortText
+ px=px-33;
+ py=py;
+ _fillObjectActor->SetScale(1);
+ _fillObjectActor->GetProperty()->SetOpacity(0.50);
+ _fillObjectActor->SetPosition(px,py,1);
+ _aPolygonMapper->Modified();
+ } // if GPORT
+
+ } // for controllers it
}
}
-
+ if (okStatusMessage==false)
+ {
+ updateStatusBar("");
+ }
+
+ if (okPortMessage==false)
+ {
+ _textActor->SetScale(0.0001);
+ _fillObjectActor->SetScale(0.0001);
+ }
return true;
}
//=========================================================================
-
+
bool wxVtkSceneManager::OnLeftButtonDown()
{
+
if(_worldState==INIT_CREATION_CONTOUR)
{
bool isOverPort=false;
GObjectController *desc = it->second;
if(desc->getGObjectType()==GPORT)
{
- GPortModel* portmod=(GPortModel*)desc->getModel();
- vtkGObjectView* portView=desc->getView();
+ GPortModel *portmod = (GPortModel*)desc->getModel();
+ vtkGObjectView *portView = desc->getView();
if(portmod->getPortType()==GINPUTPORT && portView->getState()==HIGHLIGHTED)
{
isOverPort=true;
- }
- }
- }
-
+ } // if
+ } // if
+ } // for
+
if(isOverPort==false)
{
- _worldState=NOTHING_HAPPENS;
- int lastId = _controllers.size()-1;
- GConnectorController *connector = (GConnectorController*)_controllers[lastId];
- connector->removeFromScene();
- unregisterController(connector);
- _controllers.erase(lastId);
-
- for(it = _controllers.begin(); it != _controllers.end(); ++it)
+ CancelConnection();
+ UnSelectBlackBoxes();
+ } // isOverPort
+
+ } else { //_worldState
+
+ _worldState = DRAG_OBJECTS;
+ _startDragging = true;
+
+ int shiftkey = _vtkInteractorStyleBaseView->GetInteractor()->GetShiftKey();
+ int ctrlkey = _vtkInteractorStyleBaseView->GetInteractor()->GetControlKey();
+ ctrlkey = ctrlkey + shiftkey;
+
+ GObjectController *cont = GetGBlackBoxControlerPointedByMouse();
+
+
+ if (GetGBlackBoxControlerPointedByMouse()!=NULL)
+ {
+ int state=cont->getView()->getState() ;
+ if( (ctrlkey==0) && (state==HIGHLIGHTED) )
{
- GObjectController *desc = it->second;
- desc->SetActive(true);
- desc->getView()->setState(NOTHING_HAPPENS);
- desc->getModel()->notifyObservers(_idManager);
+ UnSelectBlackBoxes();
}
}
- }
-
- if(_selectedObjects.size()!=0)
- {
- _worldState = DRAG_OBJECTS;
- _startDragging = true;
-
- for (int i = 0; i < _selectedObjects.size(); i++)
+ for (int i = 0; i < (int)_selectedObjects.size(); i++)
{
int id = _selectedObjects[i];
GObjectController* cont = _controllers[id];
cont->getView()->setState(DRAG);
cont->getModel()->notifyObservers(_idManager);
- }
- }
-
-
-
+ } // for
+
+ } // if _selectedObjects.size
+
+
return true;
}
//=========================================================================
-
+
bool wxVtkSceneManager::OnLeftButtonUp()
{
if(_worldState == DRAG_OBJECTS)
{
_worldState = NOTHING_HAPPENS;
- for (int i = 0; i < _selectedObjects.size(); i++)
+ for (int i = 0; i < (int)_selectedObjects.size(); i++)
{
int id = _selectedObjects[i];
GObjectController* cont = _controllers[id];
}
//=========================================================================
-
- bool wxVtkSceneManager::OnRightButtonUp()
+ void wxVtkSceneManager::CancelConnection()
{
if(_worldState==INIT_CREATION_CONTOUR)
{
_worldState=NOTHING_HAPPENS;
- int lastId = _controllers.size()-1;
- GConnectorController *connector = (GConnectorController*)_controllers[lastId];
+ //int lastId = _controllers.size()-1;
+
+ GConnectorController *connector = (GConnectorController*)_controllers[_idConnectionInCreation];
connector->removeFromScene();
unregisterController(connector);
- _controllers.erase(lastId);
+ _controllers.erase(_idConnectionInCreation);
std::map<int, GObjectController*>::iterator it;
for(it = _controllers.begin(); it != _controllers.end(); ++it)
desc->SetActive(true);
desc->getView()->setState(NOTHING_HAPPENS);
desc->getModel()->notifyObservers(_idManager);
- }
- }
+ } // for
+ }// if
+ }
-
- for (int i = 0; i < _selectedObjects.size(); i++)
- {
- int id = _selectedObjects[i];
- GObjectController* cont = _controllers[id];
- cont->SetActive(true);
- cont->getView()->setState(NOTHING_HAPPENS);
- cont->getModel()->notifyObservers(_idManager);
- }
- _selectedObjects.clear();
+ //=========================================================================
+ bool wxVtkSceneManager::OnRightButtonUp()
+ {
+ if(_worldState==INIT_CREATION_CONTOUR)
+ {
+ CancelConnection();
+ }
+ UnSelectBlackBoxes();
return true;
}
//=========================================================================
+ GObjectController *wxVtkSceneManager::GetGBlackBoxControlerPointedByMouse()
+ {
+ GObjectController *result=NULL;
+ int X,Y;
+ wxVTKRenderWindowInteractor *wxVTKiren;
+ wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
+ wxVTKiren->GetEventPosition(X,Y);
+
+ std::map<int, GObjectController*>::iterator it;
+
+ for(it = _controllers.begin(); it != _controllers.end() ; ++it)
+ {
+ GObjectController *cont = it->second;
+ int type = cont->getGObjectType();
+
+ if( cont->getView()->isPointInside(X,Y)==true )
+ {
+ if(type==GBLACKBOX)
+ {
+ result=cont;
+ } // if type
+ } // if isPointInside
+ } // for it
+ return result;
+ }
+
+ //=========================================================================
+ void wxVtkSceneManager::UnSelectBlackBoxes()
+ {
+ for (int i=0; i< (int)_selectedObjects.size(); i++)
+ {
+ int id = _selectedObjects[i];
+ GObjectController* control = _controllers[id];
+ control->getView()->setState(NOTHING_HAPPENS);
+ }// for _selectedObjects
+ _selectedObjects.clear();
+ }
+
+ //=========================================================================
bool wxVtkSceneManager::OnLeftDClick()
{
+ GObjectController *cont = GetGBlackBoxControlerPointedByMouse();
+ if (cont!=NULL)
+ {
+ UnSelectBlackBoxes();
+ _parent->editBlackBox( (GBlackBoxModel*)cont->getModel() );
+ }
+
+/*EED Borrame
+
int X,Y;
wxVTKRenderWindowInteractor *wxVTKiren;
wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
{
GObjectController *cont = it->second;
int type = cont->getGObjectType();
-
+
if(cont->getView()->isPointInside(X,Y))
{
if(type==GBLACKBOX)
{
- for (int i=0; i<_selectedObjects.size(); i++)
+ for (int i=0; i< (int)_selectedObjects.size(); i++)
{
int id = _selectedObjects[i];
GObjectController* control = _controllers[id];
GBlackBoxModel *bbmodel = (GBlackBoxModel*)cont->getModel();
_parent->editBlackBox(bbmodel);
}
- clickOnObject = true;
+ clickOnObject = true;
}
}
{
//_parent->editDiagramParameters(this);
}
-
+*/
return true;
}
-
+
//=========================================================================
bool wxVtkSceneManager::OnChar()
- {
+ {
char keyCode = _vtkInteractorStyleBaseView->GetInteractor()-> GetKeyCode();
-
+
// KeyCode 127 : Delete Key
// KeyCode 8 : Backspace Key
if(keyCode == 8 || keyCode == 127)
{
if(_selectedObjects.size()>0)
{
- for(int i=0;i<_selectedObjects.size();i++)
+ for(int i=0;i<(int)_selectedObjects.size();i++)
{
int id = _selectedObjects[i];
- deleteObject(id);
+ std::map<int,GObjectController*>::iterator it;
+ it = _controllers.find(id);
+ if (it!=_controllers.end())
+ {
+ deleteObject(id);
+ }
}
_selectedObjects.clear();
}
//=========================================================================
+ void wxVtkSceneManager::AddControlerToBeRemove(std::vector<int> *controllersToRemove, int id)
+ {
+
+ int i;
+ bool ok=true;
+ for(i=0 ; i < (int)controllersToRemove->size() ; i++ )
+ {
+ if (id == (*controllersToRemove)[i] )
+ {
+ ok=false;
+ }
+ }
+
+ if (ok==true)
+ {
+ controllersToRemove->push_back( id );
+ }
+
+ }
+
+ //=========================================================================
+
void wxVtkSceneManager::deleteObject(int id)
{
GObjectController *control = _controllers[id];
{
GBoxModel *bbmod = (GBoxModel*)control->getModel();
std::vector<GPortModel*> inputs = bbmod->getInputPorts();
-
+
bool boxConnected = false;
// Add box input controllers to be removed
- for(int i = 0;i<inputs.size();i++)
+ for(int i = 0;i< (int)inputs.size();i++)
{
- controllersToRemove.push_back(inputs[i]->getObjectId());
+ AddControlerToBeRemove( &controllersToRemove, inputs[i]->getObjectId() );
if(inputs[i]->isConnected())
{
boxConnected = true;
std::vector<GPortModel*> outputs = bbmod->getOutputPorts();
// Add box output controllers to be removed
- for(int i = 0;i<outputs.size();i++)
+ for(int i = 0;i<(int)outputs.size();i++)
{
- controllersToRemove.push_back(outputs[i]->getObjectId());
+ AddControlerToBeRemove( &controllersToRemove, outputs[i]->getObjectId() );
if(outputs[i]->isConnected())
{
boxConnected = true;
GConnectorModel *conMod = (GConnectorModel*)cont->getModel();
if(conMod->getStartPort()!=NULL && conMod->getStartPort()->getParentBox()->getObjectId() == bbmod->getObjectId())
{
- controllersToRemove.push_back(conMod->getObjectId());
+ AddControlerToBeRemove( &controllersToRemove, conMod->getObjectId() );
}
if(conMod->getEndPort()!=NULL && conMod->getEndPort()->getParentBox()->getObjectId() == bbmod->getObjectId())
{
- controllersToRemove.push_back(conMod->getObjectId());
+ AddControlerToBeRemove( &controllersToRemove, conMod->getObjectId() );
}
}
}
// Add box controller to be removed
- controllersToRemove.push_back(bbmod->getObjectId());
+ AddControlerToBeRemove( &controllersToRemove, bbmod->getObjectId() );
}
else if(control->getGObjectType()==GCONNECTOR)
- {
+ {
GConnectorModel *conMod = (GConnectorModel*)control->getModel();
- controllersToRemove.push_back(conMod->getObjectId());
+ AddControlerToBeRemove( &controllersToRemove, conMod->getObjectId() );
}
- for(int i = 0;i<controllersToRemove.size();i++)
- {
- int id = controllersToRemove[i];
- GObjectController *cont = _controllers[id];
- cont->removeFromScene();
- unregisterController((InteractorStyleMaracas*)cont);
- _controllers.erase(id);
- }
+ std::map<int,GObjectController*>::iterator it;
+ for(int i = 0;i<(int)controllersToRemove.size();i++)
+ {
+ int key = controllersToRemove[i];
+ it = _controllers.find( key );
+ GObjectController *cont = _controllers[ key ];
+ if(cont!=NULL)
+ {
+ cont->removeFromScene();
+ unregisterController((InteractorStyleMaracas*)cont);
+ _controllers.erase(it);
+ }//if
+ }// for
}
//=========================================================================
_parent->updateStatusBar(textStatus);
}
+
+ //=========================================================================
+ std::string wxVtkSceneManager::LineNumber(bool withLineNumber, int &value)
+ {
+ std::string result="";
+ if (withLineNumber==true)
+ {
+ value++;
+ stringstream StrStream;
+ StrStream << value;
+ std::string strValue=StrStream.str();
+ if (value<10)
+ {
+ result+=" ";
+ }else if (value<100)
+ {
+ result+=" ";
+ }
+
+ result+=strValue+": ";
+ }
+ return result;
+ }
//=========================================================================
- std::string wxVtkSceneManager::getDiagramBBS()
+ std::string wxVtkSceneManager::getDiagramBBS(bool wln)
{
bool existsExec=false;
if(type==GBLACKBOX)
{
GBlackBoxModel *mod = (GBlackBoxModel*)desc->getModel();
-
+
std::string pkg = mod->getBBTKPackage();
bool existsPkg = false;
- for(int t = 0;t<packages.size() && existsPkg == false;t++)
+ for(int t = 0;t< (int)packages.size() && existsPkg == false;t++)
{
if(packages[t]==pkg)
{
}
}
+ int lnNmbr=0;
std::string script = "";
- script+="# BBTK GEditor Script\n";
- script+="# ----------------------\n";
+ script+=LineNumber(wln,lnNmbr)+"# BBTK GEditor Script\n";
+ script+=LineNumber(wln,lnNmbr)+"# ----------------------\n";
+ script+=LineNumber(wln,lnNmbr)+"\n";
if(existsExec)
{
- script+="include std\n"; // EED
- script+="include itkvtk\n"; // EED
+ script+=LineNumber(wln,lnNmbr)+"include std\n"; // EED
+ script+=LineNumber(wln,lnNmbr)+"include itkvtk\n"; // EED
int i;
- for(i = 0; i<packages.size();i++)
+ for(i = 0; i< (int)packages.size();i++)
{
+ script+=LineNumber(wln,lnNmbr);
script+="include ";
script+=packages[i];
script+="\n";
}
+ script+=LineNumber(wln,lnNmbr);
+ script+="\n";
+
+
+//ups2
+
+ script+=LineNumber(wln,lnNmbr);
+ script+="author \"";
+ script+=_Author;
+ script+="\"\n";
+
+ script+=LineNumber(wln,lnNmbr);
+ script+="description \"";
+ script+=_Description;
+ script+="\"\n";
+
+ script+=LineNumber(wln,lnNmbr);
+ script+="category \"";
+ script+=_Category;
+ script+="\"\n";
+
+ script+=LineNumber(wln,lnNmbr);
+ script+="\n";
+
+
// script+="include std\n"; // JPR
- for(i = 0; i<boxes.size();i++)
+ for(i = 0; i < (int)boxes.size();i++)
{
+ script+=LineNumber(wln,lnNmbr);
script+="new ";
int id = boxes[i];
GObjectController *control = _controllers[id];
script+="\n";
std::vector<GPortModel*> inputs = model->getInputPorts();
- for(int j = 0; j<inputs.size();j++)
+ for(int j = 0; j < (int)inputs.size();j++)
{
GPortModel* inputPort = inputs[j];
if(inputPort->isValueSet())
{
- script+="set ";
+ script+=LineNumber(wln,lnNmbr);
+ script+=" set ";
script+=model->getBBTKName();
script+=".";
script+=inputPort->getBBTKName();
}
}
+ script+=LineNumber(wln,lnNmbr);
+ script+="\n";
+
}
- for(i = 0; i<connections.size();i++)
+ script+=LineNumber(wln,lnNmbr);
+ script+="\n";
+
+ for(i = 0; i<(int)connections.size();i++)
{
+ script+=LineNumber(wln,lnNmbr);
script+="connect ";
int id = connections[i];
GObjectController *control = _controllers[id];
script+="\n";
}
- for(i = 0; i<execBoxes.size();i++)
+ script+=LineNumber(wln,lnNmbr);
+ script+="\n";
+ for(i = 0; i<(int)execBoxes.size();i++)
{
+ script+=LineNumber(wln,lnNmbr);
script+="exec ";
int id = execBoxes[i];
GObjectController *control = _controllers[id];
//=========================================================================
- std::string wxVtkSceneManager::saveComplexBoxBBS(std::string cbName,std::string cbAuthor,std::string cbCategory,std::string cbDescription)
+ std::string wxVtkSceneManager::saveComplexBoxBBS()
{
-
std::vector<std::string> packages;
std::vector<int> boxes;
std::vector<int> connections;
if(type==GBLACKBOX)
{
GBlackBoxModel *mod = (GBlackBoxModel*)desc->getModel();
-
+
std::string pkg = mod->getBBTKPackage();
bool existsPkg = false;
- for(int t = 0;t<packages.size() && existsPkg == false;t++)
+ for(int t = 0;t<(int)packages.size() && existsPkg == false;t++)
{
if(packages[t]==pkg)
{
script+="include std\n"; // EED
script+="include itkvtk\n"; // EED
int i;
- for(i = 0; i<packages.size();i++)
+ for(i = 0; i<(int)packages.size();i++)
{
script+="include ";
script+=packages[i];
script+="\n";
}
+ script+="\n";
+
// Definition of a complex box
script+="define ";
- script+=cbName;
+ script+=_cbName+" "+_cbPackageName;
+ script+="\n";
script+="\n";
- script+="author \" ";
- script+=cbAuthor;
+ script+="author \"";
+ script+=_Author;
script+="\"\n";
- script+="description \" ";
- script+=cbDescription;
+ script+="description \"";
+ script+=_Description;
+ script+="\"\n";
+ script+="\n";
+
+ script+="category \"";
+ script+=_Category;
script+="\"\n";
+ script+="\n";
+
// Create boxes
- for(i = 0; i<boxes.size();i++)
+ for(i = 0; i<(int)boxes.size();i++)
{
script+="new ";
int id = boxes[i];
script+="\n";
std::vector<GPortModel*> inputs = model->getInputPorts();
- for(int j = 0; j<inputs.size();j++)
+ for(int j = 0; j<(int)inputs.size();j++)
{
GPortModel* inputPort = inputs[j];
if(inputPort->isValueSet())
{
- script+="set ";
+ script+=" set ";
script+=model->getBBTKName();
script+=".";
script+=inputPort->getBBTKName();
script+="\n";
}
}
+ script+="\n";
}
std::string complexInputs="";
std::string complexOutputs="";
+ script+="\n";
- for(i = 0; i<connections.size();i++)
+ for(i = 0; i<(int)connections.size();i++)
{
int id = connections[i];
GObjectController *control = _controllers[id];
}
}
- for(i = 0; i<execBoxes.size();i++)
+ script+="\n";
+
+ for(i = 0; i<(int)execBoxes.size();i++)
{
script+="exec ";
int id = execBoxes[i];
script+="\n";
script+="endefine";
- script+="\n";
+ script+="\n";
return script;
}
//=========================================================================
void wxVtkSceneManager::deleteAllBoxes()
- {
+ {
std::map<int, GObjectController*>::iterator it;
for(it = _controllers.begin(); it != _controllers.end(); ++it)
{
- GObjectController *cont = it->second;
+ GObjectController *cont = it->second;
cont->removeFromScene();
unregisterController((InteractorStyleMaracas*)cont);
}
_selectedObjects.clear();
- _controllers.clear();
+ _controllers.clear();
refreshScene();
}
//=========================================================================
+
+ void wxVtkSceneManager::refresh()
+ {
+ _baseView->Refresh();
+ }
+ //=========================================================================
+
void wxVtkSceneManager::refreshScene()
{
_baseView->RefreshView();
}
//=========================================================================
-
+
void wxVtkSceneManager::centerView()
{
double temp[3];
//=========================================================================
void wxVtkSceneManager::saveDiagram(std::string &content)
- {
+ {
char buffer [50];
+ content+="CATEGORY:";
+ content+=GetCategory();
+ content+="\n";
+
+ content+="DESCRIPTION:";
+ content+=GetDescription();
+ content+="\n";
+
+ content+="AUTHOR:";
+ content+=GetAuthor();
+ content+="\n";
+
+
//Print info IF COMPLEX BOX
content+="COMPLEXBOX:";
if(_isComplexBox)
{
content+="TRUE\n";
+//ups1
+ content+="COMPLEXBOXNAME:";
+ content+=GetCbName();
+ content+="\n";
+
+ content+="PACKAGENAME:";
+ content+=GetCbPackageName();
+ content+="\n";
//Print info complex input ports
std::vector<int> inputs = getComplexInputPorts();
sprintf (buffer, "%d", insize);
content+=buffer;
content+="\n";
-
+
for(int i = 0;i<insize;i++)
{
int id = inputs[i];
sprintf (buffer, "%d", outsize);
content+=buffer;
content+="\n";
-
+
for(int i = 0;i<outsize;i++)
{
int id = outputs[i];
GObjectController *cont = _controllers[id];
cont->getModel()->save(content);
}
- }
+ } // _isComplexBox
else
{
content+="FALSE\n";
sprintf (buffer, "%d", bsize);
content+=buffer;
content+="\n";
-
+
for(int i = 0;i<bsize;i++)
{
int id = boxes[i];
sprintf (buffer, "%d", csize);
content+=buffer;
content+="\n";
-
+
for(int i = 0;i<csize;i++)
{
int id = connections[i];
void wxVtkSceneManager::loadDiagram(ifstream &inputStream)
{
- std::string line="";
+ std::string version="<void>";
+ std::string line="";
char delims[] = ":";
char *result = NULL;
getline(inputStream,line);
bool start = false;
- while ( !inputStream.eof() )
+ while ( !inputStream.eof() )
{
if(line=="" || line[0]=='#')
{
getline(inputStream,line);
+ if (line=="# - BBTKGEditor v 1.0 BBG BlackBox Diagram file")
+ {
+ version=line.substr(18,3);
+ }
+ if (line=="# - BBTKGEditor v 1.1 BBG BlackBox Diagram file")
+ {
+ version=line.substr(18,3);
+ }
+ if (line=="# - BBTKGEditor v 1.2 BBG BlackBox Diagram file")
+ {
+ version=line.substr(18,3);
+ }
}
else if(line=="APP_START")
{
}
}
+ printf("EED wxVtkSceneManager::loadDiagram version=%s\n",version.c_str());
+
if(start)
{
+ if ((version!="1.0") && (version!="1.1"))
+ {
+ getline(inputStream,line);//CATEGORY:<category of the box>
+ char categoryTmp[30];
+ strcpy( categoryTmp, line.c_str() );
+ result = strtok( categoryTmp, delims );
+ result = strtok( NULL, delims );
+ SetCategory(result);
+
+ getline(inputStream,line);//DESCRIPTION:<description of the box>
+ char descriptionTmp[1024];
+ strcpy( descriptionTmp, line.c_str() );
+ result = strtok( descriptionTmp, delims );
+ result = strtok( NULL, delims );
+ SetDescription(result);
+
+ getline(inputStream,line);//AUTHOR:<author>
+ char authorTmp[255];
+ strcpy( authorTmp, line.c_str() );
+ result = strtok( authorTmp, delims );
+ result = strtok( NULL, delims );
+ SetAuthor(result);
+ }
+
//----------
getline(inputStream,line);//COMPLEX_BOX:TRUE|FALSE
- char complex[15];
- strcpy( complex, line.c_str() );
- result = strtok( complex, delims );
+ char complexTmp[30];
+ strcpy( complexTmp, line.c_str() );
+ result = strtok( complexTmp, delims );
result = strtok( NULL, delims );
std::string isComplexBox(result);
{
_isComplexBox=true;
+ if ((version!="1.0") && (version!="1.1"))
+ {
+ getline(inputStream,line);//COMPLEXNAME:<name of the complex box>
+ char complexboxnameTmp[255];
+ strcpy( complexboxnameTmp, line.c_str() );
+ result = strtok( complexboxnameTmp, delims );
+ result = strtok( NULL, delims );
+ SetCbName(result);
+
+ getline(inputStream,line);//PACKAGENAME:<name of the package of the box>
+ char packagenameTmp[255];
+ strcpy( packagenameTmp, line.c_str() );
+ result = strtok( packagenameTmp, delims );
+ result = strtok( NULL, delims );
+ SetCbPackageName(result);
+ }
+
+
//-----------------------
//- COMPLEX INPUT PORTS
//-----------------------
getline(inputStream,line);//COMPLEXINPUTS:num
- char inputs[18];
+ char inputs[30];
strcpy( inputs, line.c_str() );
result = strtok( inputs, delims );
result = strtok( NULL, delims );
-
+
int numInputs;
std::istringstream inps(result);
inps >> numInputs;
-
+
for(int i = 0;i<numInputs;i++)
{
//----------
getline(inputStream,line);//FIN_COMPLEX_PORT
- int idInputPort = createGComplexBoxInputPort(inputPortName);
- GObjectController *cont = _controllers[idInputPort];
- GBoxModel *cbmod = (GBoxModel*)cont->getModel();
- cbmod->setInicPoint(xIn,yIn,zIn);
- cbmod->notifyObservers(_idManager);
- }
+ configGComBoxInputOutputPort(true, inputPortName,xIn,yIn,zIn);
+
+
+ } // for input complex box
//-----------------------
//-----------------------
getline(inputStream,line);//COMPLEXOUTPUTS:num
- char outputs[18];
+ char outputs[30];
strcpy( outputs, line.c_str() );
result = strtok( outputs, delims );
result = strtok( NULL, delims );
-
+
int numOutputs;
std::istringstream outps(result);
outps >> numOutputs;
-
+
for(int i = 0;i<numOutputs;i++)
{
//----------
getline(inputStream,line);//FIN_COMPLEX_PORT
- int idOutputPort = createGComplexBoxOutputPort(outputPortName);
- GObjectController *cont = _controllers[idOutputPort];
- GBoxModel *cbmod = (GBoxModel*)cont->getModel();
- cbmod->setInicPoint(xIn,yIn,zIn);
- cbmod->notifyObservers(_idManager);
- }
+ configGComBoxInputOutputPort(false, outputPortName,xIn,yIn,zIn);
- }
+ } // for output complex box
+
+ } // complex box
//----------
getline(inputStream,line);//BOXES:num
strcpy( boxes, line.c_str() );
result = strtok( boxes, delims );
result = strtok( NULL, delims );
-
+
int numBoxes;
std::istringstream is(result);
is >> numBoxes;
-
+
for(int i = 0;i<numBoxes;i++)
{
//----------
getline(inputStream,line);//BOX
getline(inputStream,line);//package:type:name
- char box[100];
+ char box[150];
strcpy( box, line.c_str() );
result = strtok( box, delims );//package
std::string package(result);
getline(inputStream,line);//ISEXEC:TRUE|FALSE
char exec[15];
strcpy( exec, line.c_str() );
- result = strtok( exec, delims );//ISEXEC
+ result = strtok( exec, delims );//ISEXEC
result = strtok( NULL, delims );//TRUE|FALSE
std::string isExec(result);
ySt >> yIn;
std::istringstream zSt(zInic);
zSt >> zIn;
-
+
//----------
getline(inputStream,line);//xEnd:yEnd:zEnd
strcpy( coord, line.c_str() );
std::istringstream zEt(zEnd);
zEt >> zEn;
- int idBox = createGBlackBox(0,0,package,type);
- GObjectController *cont = _controllers[idBox];
- GBlackBoxModel *bbmod = (GBlackBoxModel*)cont->getModel();
- bbmod->setBBTKName(name);
- bbmod->setInicPoint(xIn,yIn,zIn);
- bbmod->setFinalPoint(xEn,yEn,zEn);
+ bool boxExecutable=false;
if(isExec=="TRUE")
{
- bbmod->setExecutable(true);
+ boxExecutable= true;
}
- else if(isExec=="FALSE")
- {
- bbmod->setExecutable(false);
- }
-
+
+ int idBox = createGBlackBox(xIn,yIn,package,type);
+ configGBlackBox(idBox, xIn,yIn,zIn,name, boxExecutable,xEn,yEn,zEn);
+
+ GObjectController *cont = _controllers[idBox];
+ GBlackBoxModel *bbmod = (GBlackBoxModel*)cont->getModel();
+
+
//----------
getline(inputStream,line);//PORT o FIN_BOX
std::string port=line.substr(0,4);
while(port=="PORT")
{
getline(inputStream,line);//name:value
- char poort[20];
+ char poort[150];
strcpy( poort, line.c_str() );
result = strtok( poort, delims );//name
std::string name(result);
result = strtok( NULL, delims );//value
std::string value(result);
- bbmod->setValueToInput(name,value);
+ bbmod->setValueToInput(name,value);
getline(inputStream,line);//PORT o FIN_BOX
port=line.substr(0,4);
- }
+ } // while
- bbmod->notifyObservers(_idManager);
- }
+//EED bbmod->notifyObservers(_idManager);
+ } // for boxes
/// CONNECTIONS
//----------
getline(inputStream,line);//CONNECTIONS:num
- char conns[15];
+ char conns[30];
strcpy( conns, line.c_str() );
result = strtok( conns, delims );
result = strtok( NULL, delims );
-
+
int numConns;
std::istringstream isCons(result);
isCons >> numConns;
-
+
for(int i = 0;i<numConns;i++)
{
//----------
getline(inputStream,line);//CONNECTION
getline(inputStream,line);//Startbox.PortName:EndBox.PortName
- char connec[100];
+ char connec[200];
strcpy( connec, line.c_str() );
result = strtok( connec, delims );
std::string nameStartBox(result);
result = strtok( NULL, delims );
std::string nameEndPort(result);
- std::vector<int> lstB = getBlackBoxes();
-
- GPortModel *startP=NULL;
- GPortModel *endP=NULL;
- for(int j = 0;j<lstB.size();j++)
+ int idCon = configGConnetion(nameStartBox, nameStartPort, nameEndBox, nameEndPort);
+
+ if (version!="1.0")
{
- int idB = lstB[j];
- GBlackBoxModel *bbMod = (GBlackBoxModel*)_controllers[idB]->getModel();
- if(_controllers[idB]->getModel()->getBBTKName()==nameStartBox)
- {
- startP = bbMod->getOutputPort(nameStartPort);
- }
- else if(_controllers[idB]->getModel()->getBBTKName()==nameEndBox)
+ //Readding control points of the manualContour
+ //ups1
+ GConnectorController *tempp = (GConnectorController*)_controllers[idCon];
+ GConnectorModel *conMod = (GConnectorModel*)tempp->getModel();
+ vtkGConnectorView *conView= (vtkGConnectorView*)tempp->getView();
+ getline(inputStream,line); //NumberOfControlPoints:##
+ strcpy( conns, line.c_str() );
+ result = strtok( conns, delims );
+ result = strtok( NULL, delims );
+
+ int numberOfControlPoints;
+ std::istringstream isCons(result);
+ isCons >> numberOfControlPoints;
+
+ for (int ii=0;ii<numberOfControlPoints;ii++)
{
- endP = bbMod->getInputPort(nameEndPort);
+ getline(inputStream,line); //XX:YY:ZZ
+ char connec[200];
+ strcpy( connec, line.c_str() );
+
+ double px,py,pz;
+ result = strtok( connec, delims );
+ std::istringstream isPointX(result);
+ isPointX >> px;
+ result = strtok( NULL, delims );
+ std::istringstream isPointY(result);
+ isPointY >> py;
+ result = strtok( NULL, delims );
+ std::istringstream isPointZ(result);
+ isPointZ >> pz;
+
+ conMod->getManualContourModel()->InsertPoint_id(ii+1,px,py,pz);
+ conView->getManualContourView()->AddPoint();
}
- }
+ }// version !=1.0
+
+ } // for numConns
- if(_isComplexBox)
+ } // start
+
+ refresh();
+ }
+ //=========================================================================
+
+
+
+ //=========================================================================
+ void wxVtkSceneManager::configGComBoxInputOutputPort(bool inputoutput, std::string portName, double xIn, double yIn,double zIn)
+ {
+ int idPort;
+ if (inputoutput==true)
+ {
+ idPort = createGComplexBoxInputPort(portName);
+ } else {
+ idPort = createGComplexBoxOutputPort(portName);
+ }
+ GObjectController *cont = _controllers[idPort];
+ GBoxModel *cbmod = (GBoxModel*)cont->getModel();
+ cbmod->setInicPoint(xIn,yIn,zIn);
+ cbmod->notifyObservers(_idManager);
+ }
+ //=========================================================================
+
+
+ //=========================================================================
+ GBoxModel* wxVtkSceneManager::findGBox(std::string boxname)
+ {
+ int j;
+ int idB;
+ GBoxModel *bMod;
+ GBoxModel *boxModel = NULL;
+ std::vector<int> lstB = getBlackBoxes();
+ for(j = 0;j<(int)lstB.size();j++)
+ {
+ idB = lstB[j];
+ bMod = (GBoxModel*)_controllers[idB]->getModel();
+ if(_controllers[idB]->getModel()->getBBTKName()==boxname)
+ {
+ boxModel = bMod;
+ }
+ } // for
+
+ if((_isComplexBox) && (boxModel==NULL))
+ {
+ std::vector<int> lstInputs = getComplexInputPorts();
+ for(j = 0;j<(int)lstInputs.size();j++)
+ {
+ idB = lstInputs[j];
+ bMod = (GBoxModel*)_controllers[idB]->getModel();
+ if(_controllers[idB]->getModel()->getBBTKName()==boxname)
{
- if(startP==NULL)
- {
- std::vector<int> lstInputs = getComplexInputPorts();
- for(int j = 0;j<lstInputs.size();j++)
- {
- int idB = lstInputs[j];
- GBoxModel *cbMod = (GBoxModel*)_controllers[idB]->getModel();
- if(_controllers[idB]->getModel()->getBBTKName()==nameStartBox)
- {
- startP = cbMod->getOutputPort(nameStartPort);
- }
- }
- }
+ boxModel = bMod;
+ }
+ } // for
- if(endP==NULL)
- {
- std::vector<int> lstOutputs = getComplexOutputPorts();
- for(int j = 0;j<lstOutputs.size();j++)
- {
- int idB = lstOutputs[j];
- GBoxModel *cbMod = (GBoxModel*)_controllers[idB]->getModel();
- if(_controllers[idB]->getModel()->getBBTKName()==nameEndBox)
- {
- endP = cbMod->getInputPort(nameEndPort);
- }
- }
- }
+ std::vector<int> lstOutputs = getComplexOutputPorts();
+ for(j = 0;j<(int)lstOutputs.size();j++)
+ {
+ int idB = lstOutputs[j];
+ bMod = (GBoxModel*)_controllers[idB]->getModel();
+ if(_controllers[idB]->getModel()->getBBTKName()==boxname)
+ {
+ boxModel = bMod;
}
-
- int idCon = createGConnector(startP);
- _worldState = NOTHING_HAPPENS;
- GConnectorController *tempp = (GConnectorController*)_controllers[idCon];
+ } // for
- GConnectorModel *conMod = (GConnectorModel*)tempp->getModel();
- vtkGConnectorView *conView = (vtkGConnectorView*)tempp->getView();
- tempp->endContourCreation();
- conMod->setEndPort(endP);
- conView->updateStartEndPoints();
+ } // complex box
- }
- }
+ return boxModel;
+ }
+
+ //=========================================================================
+
+
+ int wxVtkSceneManager::configGConnetion(std::string nameStartBox, std::string nameStartPort, std::string
+ nameEndBox, std::string nameEndPort)
+ {
+
+ GBoxModel *boxModel;
+ GPortModel *startP = NULL;
+ GPortModel *endP = NULL;
+ boxModel= findGBox(nameStartBox);
+ if (boxModel!=NULL)
+ {
+ startP = boxModel->getOutputPort(nameStartPort);
+ }
+
+ boxModel= findGBox(nameEndBox);
+ if (boxModel!=NULL)
+ {
+ endP = boxModel->getInputPort(nameEndPort);
+ }
+
+//ups2
+ int idCon = createGConnector(startP);
+ _worldState = NOTHING_HAPPENS;
+ GConnectorController *tempp = (GConnectorController*)_controllers[idCon];
+
+ GConnectorModel *conMod = (GConnectorModel*)tempp->getModel();
+ vtkGConnectorView *conView = (vtkGConnectorView*)tempp->getView();
+ tempp->endContourCreation();
+ conMod->setEndPort(endP);
+ conView->updateStartEndPoints();
+ return idCon;
+ }
+
+ //=========================================================================
+
+ bool wxVtkSceneManager::boxExist(std::string boxname)
+ {
+ bool ok=false;
+ std::map<int, GObjectController*>::iterator it;
+ for(it = _controllers.begin(); it != _controllers.end(); ++it)
+ {
+ GObjectController *cont = it->second;
+ if(cont->getModel()->getBBTKName()==boxname)
+ {
+ ok=true;
+ }
+ }
+ return ok;
}
//=========================================================================
std::map<int, GObjectController*>::iterator it;
for(it = _controllers.begin(); it != _controllers.end(); ++it)
{
- GObjectController *cont = it->second;
+ GObjectController *cont = it->second;
if(cont->getGObjectType()==GBLACKBOX)
{
vect.push_back(cont->getId());
std::map<int, GObjectController*>::iterator it;
for(it = _controllers.begin(); it != _controllers.end(); ++it)
{
- GObjectController *cont = it->second;
+ GObjectController *cont = it->second;
if(cont->getGObjectType()==GCOMPLEXINPUTPORT)
{
vect.push_back(cont->getId());
std::map<int, GObjectController*>::iterator it;
for(it = _controllers.begin(); it != _controllers.end(); ++it)
{
- GObjectController *cont = it->second;
+ GObjectController *cont = it->second;
if(cont->getGObjectType()==GCOMPLEXOUTPUTPORT)
{
vect.push_back(cont->getId());
std::map<int, GObjectController*>::iterator it;
for(it = _controllers.begin(); it != _controllers.end(); ++it)
{
- GObjectController *cont = it->second;
+ GObjectController *cont = it->second;
if(cont->getGObjectType()==GCONNECTOR)
{
vect.push_back(cont->getId());
}
//=========================================================================
-
+
bool wxVtkSceneManager::isComplexBox()
{
return _isComplexBox;
//Register the controller of the new object
registerController((InteractorStyleMaracas*) objController);
- //Add the object to the objects list
- int newId = _controllers.size();
+ //Add the object to the objects list
+ int newId = _contLastId;//_controllers.size();
objController->setId(newId);
_controllers[newId] = objController;
+ _contLastId++;
return newId;
}
std::map<int, GObjectController*>::iterator it;
for(it = _controllers.begin(); it != _controllers.end(); ++it)
{
- GObjectController *cont = it->second;
+ GObjectController *cont = it->second;
if(cont->getGObjectType()==GBLACKBOX && cont->getView()->getState()==SELECTED)
{
mapSelected[cont->getId()]=cont;
std::map<int, GObjectController*>::iterator it2;
for(it2 = _controllers.begin(); it2 != _controllers.end(); ++it2)
{
- GObjectController *cont = it2->second;
+ GObjectController *cont = it2->second;
if(cont->getGObjectType()==GCONNECTOR)
{
GConnectorModel* cmod = (GConnectorModel*)cont->getModel();
std::map<int, GObjectController*>::iterator iterOBJ1 = mapSelected.find(startPortParentBox->getObjectId());
std::map<int, GObjectController*>::iterator iterOBJ2 = mapSelected.find(endPortParentBox->getObjectId());
-
+
if(iterOBJ1 != mapSelected.end() && iterOBJ2 != mapSelected.end())
- {
+ {
int ID = cont->getId();
mapSelected[ID]=cont;
}
-
}
}
return mapSelected;
void wxVtkSceneManager::addObjects(std::map<int,GObjectController*> objectsMap)
{
-
+
std::map<int,int> oldIdNewIdBoxes;
std::vector<int> connections;
- std::map<int, GObjectController*>::iterator it;
+ std::map<int, GObjectController*>::iterator it;
for(it = objectsMap.begin(); it != objectsMap.end(); ++it)
{
GObjectController *cont = it->second;
int idcB = copyBox->getObjectId();
oldIdNewIdBoxes[idcB]=idBox;
- cont = _controllers[idBox];
+ cont = _controllers[idBox];
GBlackBoxModel* newbox = (GBlackBoxModel*)cont->getModel();
- newbox->setInicPoint(xInic,yInic,zInic);
+ newbox->setInicPoint(xInic,yInic,zInic);
int num = newbox->getNumInputPorts();
for(int j=0;j<num;j++)
{
int idCon = cont->getId();
connections.push_back(idCon);
}
-
+
}
-
- for(int i = 0 ;i<connections.size();i++)
+
+ for(int i = 0 ;i<(int)connections.size();i++)
{
int objId = connections[i];
- GObjectController *cont = objectsMap[objId];
+ GObjectController *cont = objectsMap[objId];
GConnectorModel* connectModel = (GConnectorModel*)cont->getModel();
-
+
GPortModel* startPort = connectModel->getStartPort();
int startPortIndex = startPort->getPosInBox();
GPortModel* endPort = connectModel->getEndPort();
- int endPortIndex = endPort->getPosInBox();
+ int endPortIndex = endPort->getPosInBox();
GBlackBoxModel* startPortParentBox = (GBlackBoxModel*)startPort->getParentBox();
GBlackBoxModel* endPortParentBox = (GBlackBoxModel*)endPort->getParentBox();
-
+
int idNewStartBox = oldIdNewIdBoxes[startPortParentBox->getObjectId()];
int idNewEndBox = oldIdNewIdBoxes[endPortParentBox->getObjectId()];
GPortModel* newStartPort = newStartBox->getOutputPort(startPortIndex);
GPortModel* newEndPort = newEndBox->getInputPort(endPortIndex);
- // Creates connection
+ // Creates connection
int idCon = createGConnector(newStartPort);
- GConnectorController *tempp = (GConnectorController*)_controllers[idCon];
+ GConnectorController *tempp = (GConnectorController*)_controllers[idCon];
GConnectorModel *conMod = (GConnectorModel*)tempp->getModel();
vtkGConnectorView *conView = (vtkGConnectorView*)tempp->getView();
tempp->endContourCreation();
- conMod->setEndPort(newEndPort);
+ conMod->setEndPort(newEndPort);
conView->updateStartEndPoints();
}
- std::map<int, int>::iterator itIds;
+ std::map<int, int>::iterator itIds;
for(itIds = oldIdNewIdBoxes.begin(); itIds != oldIdNewIdBoxes.end(); ++itIds)
{
int idOld = itIds->first;
std::vector<int> newInputConnections = newBox->getConnectedInputs();
std::vector<int> newOutputConnections = newBox->getConnectedOutputs();
- for(int k = 0; k<oldInputConnections.size();k++)
+ for(int k = 0; k<(int)oldInputConnections.size();k++)
{
bool exist=false;
- int toCreate=-1;
- for(int l = 0; l<newInputConnections.size() && !exist;l++)
+//EED int toCreate=-1;
+ for(int l = 0; l<(int)newInputConnections.size() && !exist;l++)
{
if(oldInputConnections[k]==newInputConnections[l])
{
if(exist==false)
{
- //Create complex input
+ //Create complex input
int posInBox = oldInputConnections[k];
GPortModel* inputPort = oldBox->getInputPort(posInBox);
std::string inputPortName = inputPort->getBBTKName();
yIn+=20;
cbmod->setInicPoint(xIn,yIn,zIn);
cbmod->notifyObservers(_idManager);
-
+
GPortModel* inputPortEnd = newBox->getInputPort(posInBox);
- // Creates connection
+ // Creates connection
int idCon = createGConnector(cbmod->getOutputPort(0));
- GConnectorController *tempp = (GConnectorController*)_controllers[idCon];
+ GConnectorController *tempp = (GConnectorController*)_controllers[idCon];
GConnectorModel *conMod = (GConnectorModel*)tempp->getModel();
vtkGConnectorView *conView = (vtkGConnectorView*)tempp->getView();
tempp->endContourCreation();
- conMod->setEndPort(inputPortEnd);
+ conMod->setEndPort(inputPortEnd);
conView->updateStartEndPoints();
}
-
+
}
-
- for(int k = 0; k<oldOutputConnections.size();k++)
+
+ for(int k = 0; k<(int)oldOutputConnections.size();k++)
{
bool exist=false;
- int toCreate=-1;
- for(int l = 0; l<newOutputConnections.size() && !exist;l++)
+//EED int toCreate=-1;
+ for(int l = 0; l<(int)newOutputConnections.size() && !exist;l++)
{
if(oldOutputConnections[k]==newOutputConnections[l])
{
if(exist==false)
{
- //Create complex output
+ //Create complex output
int posInBox = oldOutputConnections[k];
GPortModel* outputPort = oldBox->getOutputPort(posInBox);
std::string outputPortName = outputPort->getBBTKName();
yIn-=20;
cbmod->setInicPoint(xIn,yIn,zIn);
cbmod->notifyObservers(_idManager);
-
+
GPortModel* outputPortEnd = newBox->getOutputPort(posInBox);
- // Creates connection
+ // Creates connection
int idCon = createGConnector(outputPortEnd);
- GConnectorController *tempp = (GConnectorController*)_controllers[idCon];
+ GConnectorController *tempp = (GConnectorController*)_controllers[idCon];
GConnectorModel *conMod = (GConnectorModel*)tempp->getModel();
vtkGConnectorView *conView = (vtkGConnectorView*)tempp->getView();
tempp->endContourCreation();
- conMod->setEndPort(cbmod->getInputPort(0));
+ conMod->setEndPort(cbmod->getInputPort(0));
conView->updateStartEndPoints();
}
-
+
}
}
}
- //=========================================================================
+
+ //=========================================================================
+ void wxVtkSceneManager::SetCbName(std::string cbName)
+ {
+ _cbName=cbName;
+ if (_cbName=="")
+ {
+ _cbName="<complex box name>";
+ }
+ }
+
+ //=========================================================================
+ std::string wxVtkSceneManager::GetCbName()
+ {
+ return _cbName;
+ }
+
+ //=========================================================================
+ void wxVtkSceneManager::SetCbPackageName(std::string packagename)
+ {
+ _cbPackageName=packagename;
+ if (_cbPackageName=="")
+ {
+ _cbPackageName="<package name of the complex box>";
+ }
+ }
+
+ //=========================================================================
+ std::string wxVtkSceneManager::GetCbPackageName()
+ {
+ return _cbPackageName;
+ }
+
+ //=========================================================================
+ void wxVtkSceneManager::SetAuthor(std::string author)
+ {
+ _Author=author;
+ if (_Author=="")
+ {
+ _Author="<author of the box>";
+ }
+ }
+
+ //=========================================================================
+ std::string wxVtkSceneManager::GetAuthor()
+ {
+ return _Author;
+ }
+
+ //=========================================================================
+ void wxVtkSceneManager::SetCategory(std::string category)
+ {
+ _Category=category;
+ if (_Category=="")
+ {
+ _Category="<category of the box>";
+ }
+ }
+
+ //=========================================================================
+ std::string wxVtkSceneManager::GetCategory()
+ {
+ return _Category;
+ }
+
+ //=========================================================================
+ void wxVtkSceneManager::SetDescription(std::string description)
+ {
+ _Description=description;
+ if (_Description=="")
+ {
+ _Description="<description of the box>";
+ }
+ }
+
+ //=========================================================================
+ std::string wxVtkSceneManager::GetDescription()
+ {
+ return _Description;
+ }
+
+ //=========================================================================
+
+
+
+
+
+
} // EO namespace bbtk
git://git.creatis.insa-lyon.fr / bbtkGEditor.git / blobdiff