1 /*=========================================================================
7 =========================================================================*/
9 /* ---------------------------------------------------------------------
11 * Copyright (c) CREATIS-LRMN (Centre de Recherche en Imagerie Medicale)
12 * Authors : Eduardo Davila, Laurent Guigues, Jean-Pierre Roux
14 * This software is governed by the CeCILL-B license under French law and
15 * abiding by the rules of distribution of free software. You can use,
16 * modify and/ or redistribute the software under the terms of the CeCILL-B
17 * license as circulated by CEA, CNRS and INRIA at the following URL
18 * http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
19 * or in the file LICENSE.txt.
21 * As a counterpart to the access to the source code and rights to copy,
22 * modify and redistribute granted by the license, users are provided only
23 * with a limited warranty and the software's author, the holder of the
24 * economic rights, and the successive licensors have only limited
27 * The fact that you are presently reading this means that you have had
28 * knowledge of the CeCILL-B license and that you accept its terms.
29 * ------------------------------------------------------------------------ */
33 * \brief Class bbtk::wxVtkSceneManager .
36 #include "wxVtkSceneManager.h"
38 #include <vtkPolygon.h>
39 #include <vtkUnstructuredGrid.h>
43 //=========================================================================
44 wxVtkSceneManager::wxVtkSceneManager(wxGEditorTabPanel *parent,
45 wxVtk3DBaseView *baseView, int idManager) {
46 _cbName = "ComplexBoxName";
47 _cbPackageName = "PackageName";
48 _Author = "Author ??";
50 _Description = "Description ??";
54 _idManager = idManager;
56 _startDragging = false;
57 _isComplexBox = false;
59 if (_baseView != NULL) {
62 "RaC-EED 21-06-2010 %p wxVtkSceneManager::wxVtkSceneManager If you comment this line, the drag and drop functionnality is not initialized.\n",
65 _baseView->GetWxVTKRenderWindowInteractor()->SetDropTarget((wxDropTarget*)parent);
69 _worldState = NOTHING_HAPPENS;
70 registerController(this);
73 _idConnectionInCreation = -1;
78 //=========================================================================
80 void wxVtkSceneManager::disconnectDrop() {
81 printf("EED %p ~wxVtkSceneManager::disconnectDrop()\n", this);
82 //EED02JUIN2010 _baseView->GetWxVTKRenderWindowInteractor()->SetDropTarget(NULL);
83 // _baseView->GetWxVTKRenderWindowInteractor()->SetDropTarget( new tmpClasswxTextDropTarget() );
86 //=========================================================================
88 wxVtkSceneManager::~wxVtkSceneManager() {
90 printf("EED %p ~wxVtkSceneManager()\n", this);
95 //=========================================================================
97 void wxVtkSceneManager::configureBaseView() {
98 printf("EED wxVtkSceneManager::configureBaseView 0\n");
99 vtkInteractorStyleBaseView2D *interactorstylebaseview =
100 vtkInteractorStyleBaseView2D::New();
102 _baseView->SetInteractorStyleBaseView(interactorstylebaseview);
104 // Important to activate the 2D interaction system
105 wxVTKRenderWindowInteractor *iren =
106 _baseView->GetWxVTKRenderWindowInteractor();
107 interactorstylebaseview->SetInteractor(iren);
108 iren->SetInteractorStyle(interactorstylebaseview);
109 interactorstylebaseview->SetwxVtkBaseView(_baseView);
111 _baseView->GetRenderer()->GetActiveCamera()->ParallelProjectionOn();
112 _baseView->GetRenderer()->ResetCamera(-100, 100, -100, 100, 800, 1100);
114 _baseView->GetRenderer()->SetBackground(0.9, 0.9, 0.9);
115 _baseView->GetRenderer()->GradientBackgroundOn();
116 _baseView->Refresh();
119 _textActor = vtkTextActor3D::New();
120 _textActor->SetPosition(-9999, -9999, 900);
121 _textActor->SetInput("<void>");
122 _textActor->GetTextProperty()->SetFontSize(60);
123 _textActor->GetTextProperty()->BoldOn();
124 _textActor->GetTextProperty()->SetColor(PORTTEXT_NH_R, PORTTEXT_NH_G,
127 _baseView->GetRenderer()->AddActor(_textActor);
129 // Actor Fill_Port_Text
136 vtkPolygon *aPolygon = vtkPolygon::New();
137 _fillObjectActor = vtkActor::New();
139 _pts = vtkPoints::New();
141 double w = 100, h = 10, b = h / 15, t = 3;
142 _pts->SetNumberOfPoints(21);
143 _pts->InsertPoint(0, xInic + w * 0.33 - t / 2, yInic, zInic);
144 _pts->InsertPoint(1, xInic + w * 0.33, yInic - t, zInic);
145 _pts->InsertPoint(2, xInic + w * 0.33 + t / 2, yInic, zInic);
146 _pts->InsertPoint(3, xInic + w * 0.33 + t / 2, yInic, zInic);
147 _pts->InsertPoint(4, xInic + w - b * 4, yInic + b * 0, zInic);
149 _pts->InsertPoint(5, xInic + w - b * 4, yInic + b * 0, zInic);
150 _pts->InsertPoint(6, xInic + w - b * 2, yInic + b * 1, zInic);
151 _pts->InsertPoint(7, xInic + w - b * 1, yInic + b * 2, zInic);
152 _pts->InsertPoint(8, xInic + w - b * 0, yInic + b * 4, zInic);
154 _pts->InsertPoint(9, xInic + w - b * 0, yInic + h - b * 4, zInic);
155 _pts->InsertPoint(10, xInic + w - b * 1, yInic + h - b * 2, zInic);
156 _pts->InsertPoint(11, xInic + w - b * 2, yInic + h - b * 1, zInic);
157 _pts->InsertPoint(12, xInic + w - b * 4, yInic + h - b * 0, zInic);
159 _pts->InsertPoint(13, xInic + b * 4, yInic + h - b * 0, zInic);
160 _pts->InsertPoint(14, xInic + b * 2, yInic + h - b * 1, zInic);
161 _pts->InsertPoint(15, xInic + b * 1, yInic + h - b * 2, zInic);
162 _pts->InsertPoint(16, xInic + b * 0, yInic + h - b * 4, zInic);
164 _pts->InsertPoint(17, xInic + b * 0, yInic + b * 4, zInic);
165 _pts->InsertPoint(18, xInic + b * 1, yInic + b * 2, zInic);
166 _pts->InsertPoint(19, xInic + b * 2, yInic + b * 1, zInic);
167 _pts->InsertPoint(20, xInic + b * 4, yInic + b * 0, zInic);
169 aPolygon->GetPointIds()->SetNumberOfIds(21);
170 for (int i = 0; i < 21; i++) {
171 aPolygon->GetPointIds()->SetId(i, i);
174 vtkUnstructuredGrid *aPolygonGrid = vtkUnstructuredGrid::New();
175 aPolygonGrid->Allocate(1, 1);
176 aPolygonGrid->InsertNextCell(aPolygon->GetCellType(),
177 aPolygon->GetPointIds());
178 aPolygonGrid->SetPoints(_pts);
179 _aPolygonMapper = vtkDataSetMapper::New();
180 _aPolygonMapper->SetInput(aPolygonGrid);
181 _fillObjectActor->SetMapper(_aPolygonMapper);
182 _fillObjectActor->GetProperty()->SetColor(PORTFILL_NH_R, PORTFILL_NH_G,
184 _fillObjectActor->GetProperty()->SetOpacity(0);
185 _aPolygonMapper->Modified();
187 _baseView->GetRenderer()->AddActor(_fillObjectActor);
188 printf("EED wxVtkSceneManager::configureBaseView 1\n");
191 //=========================================================================
193 std::string wxVtkSceneManager::generateANewNameForABox() {
194 std::stringstream boxname;
195 if (_numBoxes < 10) {
196 boxname << "Box0" << _numBoxes;
198 boxname << "Box" << _numBoxes;
201 return boxname.str();
204 //=========================================================================
206 std::string wxVtkSceneManager::findANewNameForABox() {
207 std::string boxname = generateANewNameForABox();
209 while (boxExist(boxname) == true) {
210 boxname = generateANewNameForABox();
216 //=========================================================================
217 void wxVtkSceneManager::configGBlackBox(int idBox, double xIn, double yIn,
218 double zIn, std::string name, bool boxExecutable, double xEn,
219 double yEn, double zEn) {
220 GObjectController *cont = _controllers[idBox];
221 GBlackBoxModel *bbmod = (GBlackBoxModel*) cont->getModel();
222 bbmod->setBBTKName(name);
223 bbmod->setInicPoint(xIn, yIn, zIn);
224 bbmod->setFinalPoint(xEn, yEn, zEn);
225 bbmod->setExecutable(boxExecutable);
227 bbmod->notifyObservers(_idManager);
231 //=========================================================================
233 int wxVtkSceneManager::createGBlackBox(int x, int y, std::string packageName,
234 std::string boxType) {
235 _worldState = NOTHING_HAPPENS;
236 //EED int windowWidth = _baseView->GetRenWin()->GetSize()[0];
237 int windowHeight = _baseView->GetRenWin()->GetSize()[1];
239 int type = GBLACKBOX;
241 //Create the MVC Objects
245 (GBlackBoxModel*) GObjectsMVCFactory::getInstance()->createGObjectModel(
247 vtkGObjectView *view =
248 GObjectsMVCFactory::getInstance()->createGObjectView(type);
249 GObjectController* controller =
250 GObjectsMVCFactory::getInstance()->createGObjectController(type);
252 BlackBoxDescriptor::Pointer descriptor =
253 GObjectsMVCFactory::getInstance()->getBlackBoxDescriptor(
254 packageName, boxType);
256 //Prepares the initial model
257 //The coordinates obtained are the following. Top-Left:x=0,y=0 Bottom-Right:x=width,y=height
260 double yy = windowHeight - y;
262 //z value is not important yet, because it is only used a parallel projection
264 _baseView->TransCoordScreenToWorld(xx, yy, zz);
265 model->setInicPoint(xx, yy, zz);
267 std::stringstream stream;
269 std::string newBoxName;
270 newBoxName = findANewNameForABox();
272 stream << newBoxName;
274 std::string arraystring = stream.str();
276 model->setBBTKName(arraystring);
277 model->setBBTKType(boxType);
278 model->setBBTKPackage(packageName);
280 model->addObserver(view);
281 model->addObserver(this);
283 //Iterate and create the input ports
284 std::map<std::string, BlackBoxInputDescriptor*> descriptorInMap =
285 descriptor->GetInputDescriptorMap();
286 std::map<std::string, BlackBoxInputDescriptor*>::iterator itInput;
289 for (itInput = descriptorInMap.begin(); itInput != descriptorInMap.end(); ++itInput) {
290 BlackBoxInputDescriptor *desc = itInput->second;
291 createGInputPort(GINPUTPORT, i, model, desc);
295 //Iterate and create the output ports
296 std::map<std::string, BlackBoxOutputDescriptor*> descriptorOutMap =
297 descriptor->GetOutputDescriptorMap();
298 std::map<std::string, BlackBoxOutputDescriptor*>::iterator itOutput;
301 for (itOutput = descriptorOutMap.begin(); itOutput
302 != descriptorOutMap.end(); ++itOutput) {
303 BlackBoxOutputDescriptor *desc = itOutput->second;
304 createGOutputPort(GOUTPUTPORT, i, model, desc);
308 //Associates the view with the correspondent renderer and the model.
309 //(NOTE: Refresh is only made by the view)
310 view->setModel(model);
311 view->setBaseView(_baseView);
312 view->initVtkObjects();
314 //Associates the controller with the correspondent model and view
315 controller->setModelAndView(model, view);
317 //Resgiter change to the observers of the actual model
318 model->notifyObservers(_idManager);
320 int newId = addObjectController(controller);
326 //=========================================================================
328 int wxVtkSceneManager::createGComplexBoxInputPort(std::string inputName) {
329 //EED int windowWidth=_baseView->GetRenWin()->GetSize()[0];
330 int windowHeight = _baseView->GetRenWin()->GetSize()[1];
332 int type = GCOMPLEXINPUTPORT;
334 //Create the MVC Objects
338 (GComplexBoxPortModel*) GObjectsMVCFactory::getInstance()->createGObjectModel(
340 vtkGObjectView *view =
341 GObjectsMVCFactory::getInstance()->createGObjectView(type);
342 GObjectController* controller =
343 GObjectsMVCFactory::getInstance()->createGObjectController(type);
345 //Prepares the initial model
348 double yy = windowHeight - 5;
350 //z value is not important yet, because it is only used a parallel projection
352 printf("EED wxVtkSceneManager::createGComplexBoxInputPort 900-450\n");
354 _baseView->TransCoordScreenToWorld(xx, yy, zz);
355 model->setInicPoint(xx, yy, zz);
357 model->setBBTKName(inputName);
358 model->setBBTKType("ComplexInputPort");
359 model->setComplexPortType(type);
361 model->addObserver(view);
362 model->addObserver(this);
364 //create the output port
365 GPortController* portController = createGPort(GOUTPUTPORT, inputName,
366 "ComplexInputPort", 0, model);
367 model->addOutputPort((GPortModel*) portController->getModel());
369 //Associates the view with the correspondent renderer and the model.
370 //(NOTE: Refresh is only made by the view)
371 view->setModel(model);
372 view->setBaseView(_baseView);
373 view->initVtkObjects();
375 //Associates the controller with the correspondent model and view
376 controller->setModelAndView(model, view);
378 //Resgiter change to the observers of the actual model
379 model->notifyObservers(_idManager);
381 int newId = addObjectController(controller);
385 //=========================================================================
387 int wxVtkSceneManager::createGComplexBoxOutputPort(std::string outputName) {
388 //EED int windowWidth=_baseView->GetRenWin()->GetSize()[0];
389 int windowHeight = _baseView->GetRenWin()->GetSize()[1];
391 int type = GCOMPLEXOUTPUTPORT;
393 //Create the MVC Objects
397 (GComplexBoxPortModel*) GObjectsMVCFactory::getInstance()->createGObjectModel(
399 vtkGObjectView *view =
400 GObjectsMVCFactory::getInstance()->createGObjectView(type);
401 GObjectController *controller =
402 GObjectsMVCFactory::getInstance()->createGObjectController(type);
404 //Prepares the initial model
407 double yy = windowHeight - 5;
409 //z value is not important yet, because it is only used a parallel projection
412 printf("EED wxVtkSceneManager::createGComplexBoxOutputPort 900-450\n");
414 _baseView->TransCoordScreenToWorld(xx, yy, zz);
415 model->setInicPoint(xx, yy, zz);
417 model->setBBTKName(outputName);
418 model->setBBTKType("ComplexOutputPort");
419 model->setComplexPortType(type);
421 model->addObserver(view);
422 model->addObserver(this);
424 //create the output port
425 GPortController* portController = createGPort(GINPUTPORT, outputName,
426 "ComplexInputPort", 0, model);
427 model->addInputPort((GPortModel*) portController->getModel());
429 //Associates the view with the correspondent renderer and the model.
430 //(NOTE: Refresh is only made by the view)
431 view->setModel(model);
432 view->setBaseView(_baseView);
433 view->initVtkObjects();
435 //Associates the controller with the correspondent model and view
436 controller->setModelAndView(model, view);
438 //Resgiter change to the observers of the actual model
439 model->notifyObservers(_idManager);
441 int newId = addObjectController(controller);
445 //=========================================================================
447 int wxVtkSceneManager::createGInputPort(int portType, int posinBox,
448 GBoxModel *blackBox, BlackBoxInputDescriptor *desc) {
449 GPortController* portController = createGPort(portType, desc->GetName(),
450 desc->GetTypeName(), posinBox, blackBox);
451 blackBox->addInputPort((GPortModel*) portController->getModel());
452 return portController->getId();
455 //=========================================================================
457 int wxVtkSceneManager::createGOutputPort(int portType, int posinBox,
458 GBoxModel *blackBox, BlackBoxOutputDescriptor *desc) {
459 GPortController* portController = createGPort(portType, desc->GetName(),
460 desc->GetTypeName(), posinBox, blackBox);
461 blackBox->addOutputPort((GPortModel*) portController->getModel());
462 return portController->getId();
465 //=========================================================================
467 GPortController* wxVtkSceneManager::createGPort(int portType,
468 std::string bbtkName, std::string bbtkType, int posInBox,
469 GBoxModel *blackBox) {
472 //Create the MVC Objects
475 (GPortModel*) GObjectsMVCFactory::getInstance()->createGObjectModel(
477 vtkGObjectView *view =
478 GObjectsMVCFactory::getInstance()->createGObjectView(type);
479 GObjectController* controller =
480 GObjectsMVCFactory::getInstance()->createGObjectController(type);
482 model->registerInBox(blackBox, portType, posInBox);
484 model->setBBTKType(bbtkType);
485 model->setBBTKName(bbtkName);
487 model->addObserver(view);
488 model->addObserver(this);
490 //Associates the view with the correspondent renderer and the model.
491 //(NOTE: Refresh is only made by the view)
492 view->setModel(model);
493 view->setBaseView(_baseView);
494 view->initVtkObjects();
496 //Associates the controller with the correspondent model and view
497 controller->setModelAndView(model, view);
499 model->notifyObservers(_idManager);
501 addObjectController(controller);
503 return (GPortController*) controller;
506 //=========================================================================
508 int wxVtkSceneManager::createGConnector(GPortModel* startPort) {
509 int type = GCONNECTOR;
511 manualConnectorContourController* manContourControl =
512 new manualConnectorContourController();
513 manualConnectorContourView* manContourView =
514 new manualConnectorContourView();
515 manualContourModel* manContourModel = new manualContourModel();
517 GConnectorController* connectorcontroller = new GConnectorController();
518 GConnectorModel* connectorModel = new GConnectorModel();
519 vtkGConnectorView* connectorView = new vtkGConnectorView();
520 connectorModel->setGObjectType(type);
522 manContourModel->SetCloseContour(false);
523 connectorModel->setStartPort(startPort);
525 manContourView->SetModel(manContourModel);
526 manContourView->SetWxVtkBaseView(_baseView);
527 manContourView->SetRange(0.5);
528 manContourView->SetZ(900);
530 manContourView->SetColorNormalContour(0, 0, 1);
531 manContourView->SetColorEditContour(0.5, 0.5, 0.5);
532 manContourView->SetColorSelectContour(1, 0.8, 0);
533 manContourView->SetWidthLine(1);
534 manContourView->SetShowText(false);
536 manContourControl->SetModelView(manContourModel, manContourView);
538 manContourControl->CreateNewManualContour();
540 manContourView->RefreshContour();
543 connectorModel->getInicPoint(x, y, z);
545 manContourControl->SetState(1);
546 manContourModel->SetCloseContour(false);
548 manContourModel->AddPoint(x, y, z);
549 manContourView->AddPoint();
551 manContourModel->AddPoint(x, y, z);
552 manContourView->AddPoint();
554 int bak = manContourControl->GetNumberOfPointsManualContour() - 1;
555 manContourControl->_bakIdPoint = bak;
556 manContourView->Refresh();
558 manContourControl->SetMoving(false);
560 connectorcontroller->setModelAndView(connectorModel, connectorView);
562 int newId = addObjectController(connectorcontroller);
564 connectorcontroller->setManualContourController(manContourControl);
565 connectorModel->setManualContourModel(manContourModel);
566 connectorView->setManualContourView(manContourView);
567 connectorView->setModel(connectorModel);
568 connectorView->setBaseView(_baseView);
570 connectorModel->addObserver(connectorView);
571 connectorModel->addObserver(this);
576 //=========================================================================
578 void wxVtkSceneManager::registerController(InteractorStyleMaracas *param) {
579 vtkInteractorStyleBaseView
580 * baseViewControlManager =
581 (vtkInteractorStyleBaseView*) _baseView->GetInteractorStyleBaseView();
582 baseViewControlManager->AddInteractorStyleMaracas(param);
585 //=========================================================================
587 void wxVtkSceneManager::unregisterController(InteractorStyleMaracas *param) {
588 vtkInteractorStyleBaseView
589 * baseViewControlManager =
590 (vtkInteractorStyleBaseView*) _baseView->GetInteractorStyleBaseView();
591 baseViewControlManager->RemoveInteractorStyleMaracas(param);
594 //=========================================================================
596 vtkRenderer* wxVtkSceneManager::getRenderer() {
597 return _baseView->GetRenderer();
600 //=========================================================================
602 vtkRenderWindow* wxVtkSceneManager::getRenderWindow() {
603 return _baseView->GetRenWin();
605 //=========================================================================
608 //=========================================================================
609 int wxVtkSceneManager::GetIndexInSelected(int idControler) {
611 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
612 if (_selectedObjects[i] == idControler) {
619 //=========================================================================
621 void wxVtkSceneManager::update(int idController, int command) {
623 if (command != NO_COMMAND) {
624 if (command == ADD_TO_SELECTED) {
625 //EEDBorrame GObjectController* cont = _controllers[idController];
627 if (GetIndexInSelected(idController) == -1) {
628 _selectedObjects.push_back(idController);
632 // bool foundID=false;
633 // for (int i=0; i<(int)_selectedObjects.size() && foundID==false; i++)
635 // if(_selectedObjects[i]==idController)
642 // _selectedObjects.push_back(idController);
645 } else if (command == REMOVE_FROM_SELECTED) {
646 int index = GetIndexInSelected(idController);
648 _selectedObjects.erase(_selectedObjects.begin() + index);
650 } else if (command == INIT_CREATION_CONTOUR) {
651 _worldState = INIT_CREATION_CONTOUR;
652 GObjectController* cont = _controllers[idController];
653 GPortModel* startOutputPort = (GPortModel*) cont->getModel();
655 // The last one is the controller of the connector
656 std::map<int, GObjectController*>::iterator it2;
658 for (it2 = _controllers.begin(); it2 != _controllers.end(); ++it2) {
659 GObjectController *cont = it2->second;
660 if (cont->getGObjectType() == GPORT) {
661 GPortModel* port = (GPortModel*) cont->getModel();
662 if (port->getPortType() == GINPUTPORT) {
663 cont->SetActive(true);
665 cont->getView()->setState(NOTHING_HAPPENS);
666 cont->getModel()->notifyObservers(_idManager);
667 cont->SetActive(false);
670 cont->getView()->setState(NOTHING_HAPPENS);
671 cont->getModel()->notifyObservers(_idManager);
672 cont->SetActive(false);
675 _selectedObjects.clear();
676 _idConnectionInCreation = createGConnector(startOutputPort);
677 } else if (command == FIN_CREATION_CONTOUR && _worldState
678 == INIT_CREATION_CONTOUR) {
679 _worldState = NOTHING_HAPPENS;
680 //int id = _controllers.size()-1;
681 GObjectController *cont = _controllers[_idConnectionInCreation];
682 GConnectorModel *modelContour = (GConnectorModel*) cont->getModel();
683 GObjectController *finPort = _controllers[idController];
685 if (finPort->getGObjectType() == GPORT) {
686 GPortModel* modelPort = (GPortModel*) finPort->getModel();
687 modelContour->setEndPort(modelPort);
688 _parent->saveTempDiagram();
691 manualConnectorContourController
693 ((GConnectorController*) cont)->getManualContourController();
694 manualConnectorContourView
696 (manualConnectorContourView*) manCont->GetManualViewBaseContour();
699 std::map<int, GObjectController*>::iterator it2;
701 for (it2 = _controllers.begin(); it2 != _controllers.end(); ++it2) {
702 GObjectController *cont = it2->second;
703 if (cont->getView() != NULL) {
704 cont->getView()->setState(NOTHING_HAPPENS);
705 cont->getModel()->notifyObservers(_idManager);
707 cont->SetActive(true);
715 //=========================================================================
717 bool wxVtkSceneManager::OnMouseMove() {
719 bool okStatusMessage = false;
720 bool okPortMessage = false;
721 wxVTKRenderWindowInteractor *wxVTKiren;
723 = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
724 wxVTKiren->GetEventPosition(X, Y);
726 if (_worldState == DRAG_OBJECTS) {
727 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
728 int id = _selectedObjects[i];
729 GObjectController* cont = _controllers[id];
730 if (_startDragging) {
731 cont->getView()->setStartDragging(true);
733 cont->getView()->moveObject(X, Y);
734 cont->getView()->setState(DRAG);
735 cont->getModel()->notifyObservers(_idManager);
738 std::map<int, GObjectController*>::iterator it;
740 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
741 GObjectController *desc = it->second;
742 if (desc->getGObjectType() == GCONNECTOR) {
743 vtkGConnectorView* vconn = (vtkGConnectorView*) desc->getView();
744 vconn->updateStartEndPoints();
748 _startDragging = false;
750 } else if (_worldState == NOTHING_HAPPENS || _worldState
751 == INIT_CREATION_CONTOUR) {
752 std::map<int, GObjectController*>::iterator it;
754 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
755 GObjectController *desc = it->second;
756 int type = desc->getGObjectType();
757 int state = desc->getView()->getState();
758 desc->getModel()->getCenter(px, py, pz);
760 if (state == HIGHLIGHTED) {
761 okStatusMessage = true;
762 updateStatusBar(desc->getStatusText());
763 if (type == GBLACKBOX) {
764 GBlackBoxModel *mod = (GBlackBoxModel*) desc->getModel();
765 _parent->displayBlackBoxInfo(mod->getBBTKPackage(),
770 okPortMessage = true;
772 _textActor->SetInput(desc->getStatusText().c_str());
773 _textActor->SetScale(0.1);
774 _textActor->SetPosition(px - 25, py + 1, pz + 2);
779 _fillObjectActor->SetScale(1);
780 _fillObjectActor->GetProperty()->SetOpacity(0.50);
781 _fillObjectActor->SetPosition(px, py, 1);
782 _aPolygonMapper->Modified();
785 } // for controllers it
788 if (okStatusMessage == false) {
792 if (okPortMessage == false) {
793 _textActor->SetScale(0.0001);
794 _fillObjectActor->SetScale(0.0001);
799 //=========================================================================
801 bool wxVtkSceneManager::OnLeftButtonDown() {
803 if (_worldState == INIT_CREATION_CONTOUR) {
804 bool isOverPort = false;
805 std::map<int, GObjectController*>::iterator it;
806 for (it = _controllers.begin(); it != _controllers.end() && isOverPort
808 GObjectController *desc = it->second;
809 if (desc->getGObjectType() == GPORT) {
810 GPortModel *portmod = (GPortModel*) desc->getModel();
811 vtkGObjectView *portView = desc->getView();
812 if (portmod->getPortType() == GINPUTPORT
813 && portView->getState() == HIGHLIGHTED) {
819 if (isOverPort == false) {
821 UnSelectBlackBoxes();
825 } else { //_worldState
827 _worldState = DRAG_OBJECTS;
828 _startDragging = true;
831 _vtkInteractorStyleBaseView->GetInteractor()->GetShiftKey();
833 _vtkInteractorStyleBaseView->GetInteractor()->GetControlKey();
834 ctrlkey = ctrlkey + shiftkey;
836 GObjectController *cont = GetGBlackBoxControlerPointedByMouse();
838 if (GetGBlackBoxControlerPointedByMouse() != NULL) {
839 int state = cont->getView()->getState();
840 if ((ctrlkey == 0) && (state == HIGHLIGHTED)) {
841 UnSelectBlackBoxes();
844 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
845 int id = _selectedObjects[i];
846 GObjectController* cont = _controllers[id];
847 cont->getView()->setState(DRAG);
848 cont->getModel()->notifyObservers(_idManager);
851 } // if _selectedObjects.size
857 //=========================================================================
859 bool wxVtkSceneManager::OnLeftButtonUp() {
860 if (_worldState == DRAG_OBJECTS) {
861 _worldState = NOTHING_HAPPENS;
863 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
864 int id = _selectedObjects[i];
865 GObjectController* cont = _controllers[id];
866 cont->getView()->setState(SELECTED);
867 cont->getModel()->notifyObservers(_idManager);
873 //=========================================================================
874 void wxVtkSceneManager::CancelConnection() {
875 if (_worldState == INIT_CREATION_CONTOUR) {
876 _worldState = NOTHING_HAPPENS;
877 //int lastId = _controllers.size()-1;
879 GConnectorController *connector =
880 (GConnectorController*) _controllers[_idConnectionInCreation];
881 connector->removeFromScene();
882 unregisterController(connector);
883 _controllers.erase(_idConnectionInCreation);
885 std::map<int, GObjectController*>::iterator it;
886 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
887 GObjectController *desc = it->second;
888 desc->SetActive(true);
889 desc->getView()->setState(NOTHING_HAPPENS);
890 desc->getModel()->notifyObservers(_idManager);
895 //=========================================================================
897 bool wxVtkSceneManager::OnRightButtonUp() {
898 if (_worldState == INIT_CREATION_CONTOUR) {
901 UnSelectBlackBoxes();
907 bool wxVtkSceneManager::OnMiddleButtonDown() {
910 this->_vtkInteractorStyleBaseView->StartPan();
915 bool wxVtkSceneManager::OnMiddleButtonUp() {
918 this->_vtkInteractorStyleBaseView->EndPan();
925 //=========================================================================
927 GObjectController *wxVtkSceneManager::GetGBlackBoxControlerPointedByMouse() {
928 GObjectController *result = NULL;
930 wxVTKRenderWindowInteractor *wxVTKiren;
932 = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
933 wxVTKiren->GetEventPosition(X, Y);
935 std::map<int, GObjectController*>::iterator it;
937 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
938 GObjectController *cont = it->second;
939 int type = cont->getGObjectType();
941 if (cont->getView()->isPointInside(X, Y) == true) {
942 if (type == GBLACKBOX) {
945 } // if isPointInside
950 //=========================================================================
951 void wxVtkSceneManager::UnSelectBlackBoxes() {
952 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
953 int id = _selectedObjects[i];
954 GObjectController* control = _controllers[id];
955 control->getView()->setState(NOTHING_HAPPENS);
956 }// for _selectedObjects
957 _selectedObjects.clear();
960 //=========================================================================
961 bool wxVtkSceneManager::OnLeftDClick() {
962 GObjectController *cont = GetGBlackBoxControlerPointedByMouse();
964 UnSelectBlackBoxes();
965 _parent->editBlackBox((GBlackBoxModel*) cont->getModel());
971 wxVTKRenderWindowInteractor *wxVTKiren;
972 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
973 wxVTKiren->GetEventPosition(X,Y);
975 std::map<int, GObjectController*>::iterator it;
977 bool clickOnObject = false;
979 for(it = _controllers.begin(); it != _controllers.end() && clickOnObject==false; ++it)
981 GObjectController *cont = it->second;
982 int type = cont->getGObjectType();
984 if(cont->getView()->isPointInside(X,Y))
988 for (int i=0; i< (int)_selectedObjects.size(); i++)
990 int id = _selectedObjects[i];
991 GObjectController* control = _controllers[id];
992 control->getView()->setState(NOTHING_HAPPENS);
994 _selectedObjects.clear();
996 GBlackBoxModel *bbmodel = (GBlackBoxModel*)cont->getModel();
997 _parent->editBlackBox(bbmodel);
999 clickOnObject = true;
1003 if(clickOnObject==false)
1005 //_parent->editDiagramParameters(this);
1011 //=========================================================================
1013 bool wxVtkSceneManager::OnChar() {
1014 char keyCode = _vtkInteractorStyleBaseView->GetInteractor()-> GetKeyCode();
1015 int ctrlkey = _vtkInteractorStyleBaseView->GetInteractor()->GetControlKey();
1017 // KeyCode 127 : Delete Key
1018 // KeyCode 8 : Backspace Key
1019 if (keyCode == 8 || keyCode == 127) {
1020 if (_selectedObjects.size() > 0) {
1021 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
1022 int id = _selectedObjects[i];
1023 std::map<int, GObjectController*>::iterator it;
1024 it = _controllers.find(id);
1025 if (it != _controllers.end()) {
1029 _selectedObjects.clear();
1035 if(_selectedObjects.size()){
1036 std::cout<<"objects to copy :";
1037 for(int i=0;i<_selectedObjects.size();i++){
1038 std::cout<<_selectedObjects.at(i)<<" ";
1040 DuplicateObjects(getSelectedObjects());
1042 std::cout<<"No objects to copy\n";
1049 //=========================================================================
1051 void wxVtkSceneManager::AddControlerToBeRemove(
1052 std::vector<int> *controllersToRemove, int id) {
1056 for (i = 0; i < (int) controllersToRemove->size(); i++) {
1057 if (id == (*controllersToRemove)[i]) {
1063 controllersToRemove->push_back(id);
1068 //=========================================================================
1070 void wxVtkSceneManager::deleteObject(int id) {
1071 GObjectController *control = _controllers[id];
1072 std::vector<int> controllersToRemove;
1074 if (control->getGObjectType() == GBLACKBOX || control->getGObjectType()
1075 == GCOMPLEXINPUTPORT || control->getGObjectType()
1076 == GCOMPLEXOUTPUTPORT) {
1077 GBoxModel *bbmod = (GBoxModel*) control->getModel();
1078 std::vector<GPortModel*> inputs = bbmod->getInputPorts();
1080 bool boxConnected = false;
1082 // Add box input controllers to be removed
1083 for (int i = 0; i < (int) inputs.size(); i++) {
1084 AddControlerToBeRemove(&controllersToRemove,
1085 inputs[i]->getObjectId());
1086 if (inputs[i]->isConnected()) {
1087 boxConnected = true;
1091 std::vector<GPortModel*> outputs = bbmod->getOutputPorts();
1093 // Add box output controllers to be removed
1094 for (int i = 0; i < (int) outputs.size(); i++) {
1095 AddControlerToBeRemove(&controllersToRemove,
1096 outputs[i]->getObjectId());
1097 if (outputs[i]->isConnected()) {
1098 boxConnected = true;
1102 // Add connection controllers to be removed
1103 std::map<int, GObjectController*>::iterator it;
1104 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
1105 GObjectController *cont = it->second;
1106 int type = cont->getGObjectType();
1107 if (type == GCONNECTOR) {
1108 GConnectorModel *conMod = (GConnectorModel*) cont->getModel();
1109 if (conMod->getStartPort() != NULL
1110 && conMod->getStartPort()->getParentBox()->getObjectId()
1111 == bbmod->getObjectId()) {
1112 AddControlerToBeRemove(&controllersToRemove,
1113 conMod->getObjectId());
1115 if (conMod->getEndPort() != NULL
1116 && conMod->getEndPort()->getParentBox()->getObjectId()
1117 == bbmod->getObjectId()) {
1118 AddControlerToBeRemove(&controllersToRemove,
1119 conMod->getObjectId());
1124 // Add box controller to be removed
1125 AddControlerToBeRemove(&controllersToRemove, bbmod->getObjectId());
1126 } else if (control->getGObjectType() == GCONNECTOR) {
1127 GConnectorModel *conMod = (GConnectorModel*) control->getModel();
1128 AddControlerToBeRemove(&controllersToRemove, conMod->getObjectId());
1131 std::map<int, GObjectController*>::iterator it;
1133 for (int i = 0; i < (int) controllersToRemove.size(); i++) {
1134 int key = controllersToRemove[i];
1135 it = _controllers.find(key);
1136 GObjectController *cont = _controllers[key];
1138 cont->removeFromScene();
1139 unregisterController((InteractorStyleMaracas*) cont);
1140 _controllers.erase(it);
1143 _parent->saveTempDiagram();
1146 //=========================================================================
1148 void wxVtkSceneManager::displayBlackBoxInfo(std::string packageName,
1149 std::string boxName) {
1150 _parent->displayBlackBoxInfo(packageName, boxName);
1153 //=========================================================================
1155 void wxVtkSceneManager::updateStatusBar(std::string textStatus) {
1156 _parent->updateStatusBar(textStatus);
1159 //=========================================================================
1160 std::string wxVtkSceneManager::LineNumber(bool withLineNumber, int &value) {
1161 std::string result = "";
1162 if (withLineNumber == true) {
1164 stringstream StrStream;
1166 std::string strValue = StrStream.str();
1169 } else if (value < 100) {
1173 result += strValue + ": ";
1177 //=========================================================================
1179 bool wxVtkSceneManager::MakeBoxExecutable() {
1180 std::map<int, GObjectController*> selected = getSelectedObjects();
1181 if( selected.empty() )
1184 std::map<int, GObjectController*>::iterator it;
1185 for (it = selected.begin(); it != selected.end(); ++it) {
1186 GObjectController* lastSelected = it->second;
1188 vtkGObjectView* view = (vtkGObjectView*) lastSelected->getView();
1189 GBlackBoxModel *bbmodel =
1190 (GBlackBoxModel*) lastSelected->getModel();
1191 view->setState(HIGHLIGHTED);
1192 if (bbmodel->isExecutable()) {
1193 bbmodel->setExecutable(false);
1195 bbmodel->setExecutable(true);
1197 bbmodel->notifyObservers(lastSelected->getId());
1205 //=========================================================================
1207 std::string wxVtkSceneManager::getDiagramBBS(bool wln) {
1208 bool existsExec = false;
1210 std::vector<std::string> packages;
1211 std::vector<int> boxes;
1212 std::vector<int> connections;
1213 std::vector<int> execBoxes;
1215 std::map<int, GObjectController*>::iterator it;
1217 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
1218 GObjectController *desc = it->second;
1219 int type = desc->getGObjectType();
1221 if (type == GBLACKBOX) {
1222 GBlackBoxModel *mod = (GBlackBoxModel*) desc->getModel();
1224 std::string pkg = mod->getBBTKPackage();
1225 bool existsPkg = false;
1226 for (int t = 0; t < (int) packages.size() && existsPkg == false; t++) {
1227 if (packages[t] == pkg) {
1232 packages.push_back(pkg);
1235 boxes.push_back(it->first);
1236 if (mod->isExecutable()) {
1237 execBoxes.push_back(it->first);
1240 } else if (type == GCONNECTOR) {
1241 connections.push_back(it->first);
1246 std::string script = "";
1247 script += LineNumber(wln, lnNmbr) + "# BBTK GEditor Script\n";
1248 script += LineNumber(wln, lnNmbr) + "# ----------------------\n";
1249 script += LineNumber(wln, lnNmbr) + "\n";
1251 script += LineNumber(wln, lnNmbr) + "include std\n"; // EED
1252 script += LineNumber(wln, lnNmbr) + "include itkvtk\n"; // EED
1254 for (i = 0; i < (int) packages.size(); i++) {
1255 script += LineNumber(wln, lnNmbr);
1256 script += "include ";
1257 script += packages[i];
1261 script += LineNumber(wln, lnNmbr);
1266 script += LineNumber(wln, lnNmbr);
1267 script += "author \"";
1271 script += LineNumber(wln, lnNmbr);
1272 script += "description \"";
1273 script += _Description;
1276 script += LineNumber(wln, lnNmbr);
1277 script += "category \"";
1278 script += _Category;
1281 script += LineNumber(wln, lnNmbr);
1284 // script+="include std\n"; // JPR
1286 for (i = 0; i < (int) boxes.size(); i++) {
1287 script += LineNumber(wln, lnNmbr);
1290 GObjectController *control = _controllers[id];
1291 GBlackBoxModel *model = (GBlackBoxModel*) control->getModel();
1293 script += model->getBBTKType();
1295 script += model->getBBTKName();
1298 std::vector<GPortModel*> inputs = model->getInputPorts();
1299 for (int j = 0; j < (int) inputs.size(); j++) {
1300 GPortModel* inputPort = inputs[j];
1301 if (inputPort->isValueSet()) {
1302 script += LineNumber(wln, lnNmbr);
1304 script += model->getBBTKName();
1306 script += inputPort->getBBTKName();
1308 script += inputPort->getValue();
1313 script += LineNumber(wln, lnNmbr);
1318 script += LineNumber(wln, lnNmbr);
1321 for (i = 0; i < (int) connections.size(); i++) {
1322 script += LineNumber(wln, lnNmbr);
1323 script += "connect ";
1324 int id = connections[i];
1325 GObjectController *control = _controllers[id];
1326 GConnectorModel *model = (GConnectorModel*) control->getModel();
1328 //Start Connection info
1329 GPortModel *start = model->getStartPort();
1330 script += start->getParentBox()->getBBTKName();
1332 script += start->getBBTKName();
1336 //End Connection info
1337 GPortModel *end = model->getEndPort();
1338 script += end->getParentBox()->getBBTKName();
1340 script += end->getBBTKName();
1345 script += LineNumber(wln, lnNmbr);
1347 for (i = 0; i < (int) execBoxes.size(); i++) {
1348 script += LineNumber(wln, lnNmbr);
1350 int id = execBoxes[i];
1351 GObjectController *control = _controllers[id];
1352 GBlackBoxModel *model = (GBlackBoxModel*) control->getModel();
1354 script += model->getBBTKName();
1363 //=========================================================================
1365 std::string wxVtkSceneManager::saveComplexBoxBBS() {
1366 std::vector<std::string> packages;
1367 std::vector<int> boxes;
1368 std::vector<int> connections;
1369 std::vector<int> execBoxes;
1371 std::map<int, GObjectController*>::iterator it;
1373 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
1374 GObjectController *desc = it->second;
1375 int type = desc->getGObjectType();
1377 if (type == GBLACKBOX) {
1378 GBlackBoxModel *mod = (GBlackBoxModel*) desc->getModel();
1380 std::string pkg = mod->getBBTKPackage();
1381 bool existsPkg = false;
1382 for (int t = 0; t < (int) packages.size() && existsPkg == false; t++) {
1383 if (packages[t] == pkg) {
1388 packages.push_back(pkg);
1391 boxes.push_back(it->first);
1392 if (mod->isExecutable()) {
1393 execBoxes.push_back(it->first);
1395 } else if (type == GCONNECTOR) {
1396 connections.push_back(it->first);
1400 std::string script = "";
1402 script += "include std\n"; // EED
1403 script += "include itkvtk\n"; // EED
1405 for (i = 0; i < (int) packages.size(); i++) {
1406 script += "include ";
1407 script += packages[i];
1412 // Definition of a complex box
1413 script += "define ";
1414 script += _cbName + " " + _cbPackageName;
1418 script += "author \"";
1422 script += "description \"";
1423 script += _Description;
1427 script += "category \"";
1428 script += _Category;
1433 for (i = 0; i < (int) boxes.size(); i++) {
1436 GObjectController *control = _controllers[id];
1437 GBlackBoxModel *model = (GBlackBoxModel*) control->getModel();
1439 script += model->getBBTKType();
1441 script += model->getBBTKName();
1444 std::vector<GPortModel*> inputs = model->getInputPorts();
1445 for (int j = 0; j < (int) inputs.size(); j++) {
1446 GPortModel* inputPort = inputs[j];
1447 if (inputPort->isValueSet()) {
1449 script += model->getBBTKName();
1451 script += inputPort->getBBTKName();
1453 script += inputPort->getValue();
1461 // Create connections in the script. If the connection is made with a complex port, it is created the input or output
1463 std::string complexInputs = "";
1464 std::string complexOutputs = "";
1467 for (i = 0; i < (int) connections.size(); i++) {
1468 int id = connections[i];
1469 GObjectController *control = _controllers[id];
1470 GConnectorModel *model = (GConnectorModel*) control->getModel();
1473 GPortModel *start = model->getStartPort();
1474 GBoxModel *startBox = start->getParentBox();
1476 GPortModel *end = model->getEndPort();
1477 GBoxModel *endBox = end->getParentBox();
1479 if (startBox->getGObjectType() == GCOMPLEXINPUTPORT) {
1480 complexInputs += "input ";
1481 complexInputs += startBox->getBBTKName();
1483 complexInputs += " ";
1484 complexInputs += endBox->getBBTKName();
1485 complexInputs += ".";
1486 complexInputs += end->getBBTKName();
1488 complexInputs += " ";
1489 complexInputs += "\" \"";
1491 complexInputs += "\n";
1492 } else if (endBox->getGObjectType() == GCOMPLEXOUTPUTPORT) {
1493 complexOutputs += "output ";
1494 complexOutputs += endBox->getBBTKName();
1496 complexOutputs += " ";
1497 complexOutputs += startBox->getBBTKName();
1498 complexOutputs += ".";
1499 complexOutputs += start->getBBTKName();
1501 complexOutputs += " ";
1502 complexOutputs += "\" \"";
1504 complexOutputs += "\n";
1506 script += "connect ";
1507 script += startBox->getBBTKName();
1509 script += start->getBBTKName();
1513 //End Connection info
1514 script += endBox->getBBTKName();
1516 script += end->getBBTKName();
1524 for (i = 0; i < (int) execBoxes.size(); i++) {
1526 int id = execBoxes[i];
1527 GObjectController *control = _controllers[id];
1528 GBlackBoxModel *model = (GBlackBoxModel*) control->getModel();
1530 script += model->getBBTKName();
1535 script += "# Complex input ports\n";
1536 script += complexInputs;
1539 script += "# Complex output ports\n";
1540 script += complexOutputs;
1543 script += "endefine";
1549 //=========================================================================
1551 void wxVtkSceneManager::deleteAllBoxes() {
1552 std::map<int, GObjectController*>::iterator it;
1553 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
1554 GObjectController *cont = it->second;
1555 cont->removeFromScene();
1556 unregisterController((InteractorStyleMaracas*) cont);
1558 _selectedObjects.clear();
1559 _controllers.clear();
1563 //=========================================================================
1566 void wxVtkSceneManager::refresh() {
1567 _baseView->Refresh();
1569 //=========================================================================
1571 void wxVtkSceneManager::refreshScene() {
1572 _baseView->RefreshView();
1575 //=========================================================================
1577 void wxVtkSceneManager::centerView() {
1579 _baseView->GetRenderer()->GetActiveCamera()->GetFocalPoint(temp);
1580 _baseView->GetRenderer()->GetActiveCamera()->SetFocalPoint(0, 0, temp[2]);
1581 _baseView->GetRenderer()->GetActiveCamera()->GetPosition(temp);
1582 _baseView->GetRenderer()->GetActiveCamera()->SetPosition(0, 0, temp[2]);
1583 _baseView->RefreshView();
1587 //=========================================================================
1589 void wxVtkSceneManager::saveDiagram(std::string &content) {
1592 content += "CATEGORY:";
1593 content += GetCategory();
1596 content += "DESCRIPTION:";
1597 content += GetDescription();
1600 content += "AUTHOR:";
1601 content += GetAuthor();
1604 //Print info IF COMPLEX BOX
1605 content += "COMPLEXBOX:";
1606 if (_isComplexBox) {
1607 content += "TRUE\n";
1609 content += "COMPLEXBOXNAME:";
1610 content += GetCbName();
1613 content += "PACKAGENAME:";
1614 content += GetCbPackageName();
1617 //Print info complex input ports
1618 std::vector<int> inputs = getComplexInputPorts();
1619 int insize = inputs.size();
1620 content += "COMPLEXINPUTS:";
1621 sprintf(buffer, "%d", insize);
1625 for (int i = 0; i < insize; i++) {
1627 GObjectController *cont = _controllers[id];
1628 cont->getModel()->save(content);
1631 //Print info complex output ports
1632 std::vector<int> outputs = getComplexOutputPorts();
1633 int outsize = outputs.size();
1634 content += "COMPLEXOUTPUTS:";
1635 sprintf(buffer, "%d", outsize);
1639 for (int i = 0; i < outsize; i++) {
1640 int id = outputs[i];
1641 GObjectController *cont = _controllers[id];
1642 cont->getModel()->save(content);
1646 content += "FALSE\n";
1650 std::vector<int> boxes = getBlackBoxes();
1651 int bsize = boxes.size();
1652 content += "BOXES:";
1653 sprintf(buffer, "%d", bsize);
1657 for (int i = 0; i < bsize; i++) {
1659 GObjectController *cont = _controllers[id];
1660 cont->getModel()->save(content);
1664 std::vector<int> connections = getConnections();
1665 int csize = connections.size();
1666 content += "CONNECTIONS:";
1667 sprintf(buffer, "%d", csize);
1671 for (int i = 0; i < csize; i++) {
1672 int id = connections[i];
1673 GObjectController *cont = _controllers[id];
1674 cont->getModel()->save(content);
1679 //=========================================================================
1681 void wxVtkSceneManager::loadDiagram(stringstream &inputStream) {
1683 std::string version = "<void>";
1684 std::string line = "";
1685 char delims[] = ":";
1686 char *result = NULL;
1688 getline(inputStream, line);
1691 while (!inputStream.eof()) {
1692 if (line == "" || line[0] == '#') {
1693 getline(inputStream, line);
1694 if (line == "# - BBTKGEditor v 1.0 BBG BlackBox Diagram file") {
1695 version = line.substr(18, 3);
1697 if (line == "# - BBTKGEditor v 1.1 BBG BlackBox Diagram file") {
1698 version = line.substr(18, 3);
1700 if (line == "# - BBTKGEditor v 1.2 BBG BlackBox Diagram file") {
1701 version = line.substr(18, 3);
1703 } else if (line == "APP_START") {
1709 printf("EED wxVtkSceneManager::loadDiagram version=%s\n", version.c_str());
1713 if ((version != "1.0") && (version != "1.1")) {
1714 getline(inputStream, line);//CATEGORY:<category of the box>
1715 char categoryTmp[30];
1716 strcpy(categoryTmp, line.c_str());
1717 result = strtok(categoryTmp, delims);
1718 result = strtok(NULL, delims);
1719 SetCategory(result);
1721 getline(inputStream, line);//DESCRIPTION:<description of the box>
1722 char descriptionTmp[1024];
1723 strcpy(descriptionTmp, line.c_str());
1724 result = strtok(descriptionTmp, delims);
1725 result = strtok(NULL, delims);
1726 SetDescription(result);
1728 getline(inputStream, line);//AUTHOR:<author>
1729 char authorTmp[255];
1730 strcpy(authorTmp, line.c_str());
1731 result = strtok(authorTmp, delims);
1732 result = strtok(NULL, delims);
1737 getline(inputStream, line);//COMPLEX_BOX:TRUE|FALSE
1738 char complexTmp[30];
1739 strcpy(complexTmp, line.c_str());
1740 result = strtok(complexTmp, delims);
1741 result = strtok(NULL, delims);
1742 std::string isComplexBox(result);
1744 if (isComplexBox == "TRUE") {
1745 _isComplexBox = true;
1747 if ((version != "1.0") && (version != "1.1")) {
1748 getline(inputStream, line);//COMPLEXNAME:<name of the complex box>
1749 char complexboxnameTmp[255];
1750 strcpy(complexboxnameTmp, line.c_str());
1751 result = strtok(complexboxnameTmp, delims);
1752 result = strtok(NULL, delims);
1755 getline(inputStream, line);//PACKAGENAME:<name of the package of the box>
1756 char packagenameTmp[255];
1757 strcpy(packagenameTmp, line.c_str());
1758 result = strtok(packagenameTmp, delims);
1759 result = strtok(NULL, delims);
1760 SetCbPackageName(result);
1763 //-----------------------
1764 //- COMPLEX INPUT PORTS
1765 //-----------------------
1766 getline(inputStream, line);//COMPLEXINPUTS:num
1768 strcpy(inputs, line.c_str());
1769 result = strtok(inputs, delims);
1770 result = strtok(NULL, delims);
1773 std::istringstream inps(result);
1776 for (int i = 0; i < numInputs; i++) {
1778 getline(inputStream, line);//COMPLEX_PORT
1779 getline(inputStream, line);//name
1780 std::string inputPortName(line);
1783 getline(inputStream, line);//xInic:yInic:zInic
1785 strcpy(coord, line.c_str());
1786 result = strtok(coord, delims);//xInic
1787 std::string xInic(result);
1788 result = strtok(NULL, delims);//yInic
1789 std::string yInic(result);
1790 result = strtok(NULL, delims);//zInic
1791 std::string zInic(result);
1793 double xIn, yIn, zIn;
1794 std::istringstream xSt(xInic);
1796 std::istringstream ySt(yInic);
1798 std::istringstream zSt(zInic);
1801 getline(inputStream, line);//FIN_COMPLEX_PORT
1803 configGComBoxInputOutputPort(true, inputPortName, xIn, yIn, zIn);
1805 } // for input complex box
1808 //-----------------------
1809 //- COMPLEX OUTPUT PORTS
1810 //-----------------------
1812 getline(inputStream, line);//COMPLEXOUTPUTS:num
1814 strcpy(outputs, line.c_str());
1815 result = strtok(outputs, delims);
1816 result = strtok(NULL, delims);
1819 std::istringstream outps(result);
1820 outps >> numOutputs;
1822 for (int i = 0; i < numOutputs; i++) {
1824 getline(inputStream, line);//COMPLEX_PORT
1825 getline(inputStream, line);//name
1826 std::string outputPortName(line);
1829 getline(inputStream, line);//xInic:yInic:zInic
1831 strcpy(coord, line.c_str());
1832 result = strtok(coord, delims);//xInic
1833 std::string xInic(result);
1834 result = strtok(NULL, delims);//yInic
1835 std::string yInic(result);
1836 result = strtok(NULL, delims);//zInic
1837 std::string zInic(result);
1839 double xIn, yIn, zIn;
1840 std::istringstream xSt(xInic);
1842 std::istringstream ySt(yInic);
1844 std::istringstream zSt(zInic);
1847 getline(inputStream, line);//FIN_COMPLEX_PORT
1849 configGComBoxInputOutputPort(false, outputPortName, xIn, yIn,
1852 } // for output complex box
1857 getline(inputStream, line);//BOXES:num
1859 strcpy(boxes, line.c_str());
1860 result = strtok(boxes, delims);
1861 result = strtok(NULL, delims);
1864 std::istringstream is(result);
1867 for (int i = 0; i < numBoxes; i++) {
1869 getline(inputStream, line);//BOX
1870 getline(inputStream, line);//package:type:name
1872 strcpy(box, line.c_str());
1873 result = strtok(box, delims);//package
1874 std::string package(result);
1875 result = strtok(NULL, delims);//type
1876 std::string type(result);
1877 result = strtok(NULL, delims);//name
1878 std::string name(result);
1880 getline(inputStream, line);//ISEXEC:TRUE|FALSE
1882 strcpy(exec, line.c_str());
1883 result = strtok(exec, delims);//ISEXEC
1884 result = strtok(NULL, delims);//TRUE|FALSE
1885 std::string isExec(result);
1888 getline(inputStream, line);//xInic:yInic:zInic
1890 strcpy(coord, line.c_str());
1891 result = strtok(coord, delims);//xInic
1892 std::string xInic(result);
1893 result = strtok(NULL, delims);//yInic
1894 std::string yInic(result);
1895 result = strtok(NULL, delims);//zInic
1896 std::string zInic(result);
1898 double xIn, yIn, zIn;
1899 std::istringstream xSt(xInic);
1901 std::istringstream ySt(yInic);
1903 std::istringstream zSt(zInic);
1907 getline(inputStream, line);//xEnd:yEnd:zEnd
1908 strcpy(coord, line.c_str());
1909 result = strtok(coord, delims);//xEnd
1910 std::string xEnd(result);
1911 result = strtok(NULL, delims);//yEnd
1912 std::string yEnd(result);
1913 result = strtok(NULL, delims);//zEnd
1914 std::string zEnd(result);
1916 double xEn, yEn, zEn;
1917 std::istringstream xEt(xEnd);
1919 std::istringstream yEt(yEnd);
1921 std::istringstream zEt(zEnd);
1924 bool boxExecutable = false;
1925 if (isExec == "TRUE") {
1926 boxExecutable = true;
1929 int idBox = createGBlackBox(xIn, yIn, package, type);
1930 configGBlackBox(idBox, xIn, yIn, zIn, name, boxExecutable, xEn,
1933 GObjectController *cont = _controllers[idBox];
1934 GBlackBoxModel *bbmod = (GBlackBoxModel*) cont->getModel();
1937 getline(inputStream, line);//PORT o FIN_BOX
1938 std::string port = line.substr(0, 4);
1939 while (port == "PORT") {
1940 getline(inputStream, line);//name:value
1942 strcpy(poort, line.c_str());
1943 result = strtok(poort, delims);//name
1944 std::string name(result);
1945 result = strtok(NULL, delims);//value
1946 std::string value(result);
1948 bbmod->setValueToInput(name, value);
1950 getline(inputStream, line);//PORT o FIN_BOX
1951 port = line.substr(0, 4);
1954 //EED bbmod->notifyObservers(_idManager);
1959 getline(inputStream, line);//CONNECTIONS:num
1961 strcpy(conns, line.c_str());
1962 result = strtok(conns, delims);
1963 result = strtok(NULL, delims);
1966 std::istringstream isCons(result);
1969 for (int i = 0; i < numConns; i++) {
1971 getline(inputStream, line);//CONNECTION
1972 getline(inputStream, line);//Startbox.PortName:EndBox.PortName
1975 strcpy(connec, line.c_str());
1976 result = strtok(connec, delims);
1977 std::string nameStartBox(result);
1978 result = strtok(NULL, delims);
1979 std::string nameStartPort(result);
1980 result = strtok(NULL, delims);
1981 std::string nameEndBox(result);
1982 result = strtok(NULL, delims);
1983 std::string nameEndPort(result);
1985 int idCon = configGConnetion(nameStartBox, nameStartPort,
1986 nameEndBox, nameEndPort);
1988 if (version != "1.0") {
1989 //Readding control points of the manualContour
1991 GConnectorController *tempp =
1992 (GConnectorController*) _controllers[idCon];
1993 GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
1994 vtkGConnectorView *conView =
1995 (vtkGConnectorView*) tempp->getView();
1996 getline(inputStream, line); //NumberOfControlPoints:##
1997 strcpy(conns, line.c_str());
1998 result = strtok(conns, delims);
1999 result = strtok(NULL, delims);
2001 int numberOfControlPoints;
2002 std::istringstream isCons(result);
2003 isCons >> numberOfControlPoints;
2005 for (int ii = 0; ii < numberOfControlPoints; ii++) {
2006 getline(inputStream, line); //XX:YY:ZZ
2008 strcpy(connec, line.c_str());
2011 result = strtok(connec, delims);
2012 std::istringstream isPointX(result);
2014 result = strtok(NULL, delims);
2015 std::istringstream isPointY(result);
2017 result = strtok(NULL, delims);
2018 std::istringstream isPointZ(result);
2021 conMod->getManualContourModel()->InsertPoint_id(ii + 1, px,
2023 conView->getManualContourView()->AddPoint();
2033 //=========================================================================
2036 //=========================================================================
2037 void wxVtkSceneManager::configGComBoxInputOutputPort(bool inputoutput,
2038 std::string portName, double xIn, double yIn, double zIn) {
2040 if (inputoutput == true) {
2041 idPort = createGComplexBoxInputPort(portName);
2043 idPort = createGComplexBoxOutputPort(portName);
2045 GObjectController *cont = _controllers[idPort];
2046 GBoxModel *cbmod = (GBoxModel*) cont->getModel();
2047 cbmod->setInicPoint(xIn, yIn, zIn);
2048 cbmod->notifyObservers(_idManager);
2050 //=========================================================================
2053 //=========================================================================
2054 GBoxModel* wxVtkSceneManager::findGBox(std::string boxname) {
2058 GBoxModel *boxModel = NULL;
2059 std::vector<int> lstB = getBlackBoxes();
2060 for (j = 0; j < (int) lstB.size(); j++) {
2062 bMod = (GBoxModel*) _controllers[idB]->getModel();
2063 if (_controllers[idB]->getModel()->getBBTKName() == boxname) {
2068 if ((_isComplexBox) && (boxModel == NULL)) {
2069 std::vector<int> lstInputs = getComplexInputPorts();
2070 for (j = 0; j < (int) lstInputs.size(); j++) {
2072 bMod = (GBoxModel*) _controllers[idB]->getModel();
2073 if (_controllers[idB]->getModel()->getBBTKName() == boxname) {
2078 std::vector<int> lstOutputs = getComplexOutputPorts();
2079 for (j = 0; j < (int) lstOutputs.size(); j++) {
2080 int idB = lstOutputs[j];
2081 bMod = (GBoxModel*) _controllers[idB]->getModel();
2082 if (_controllers[idB]->getModel()->getBBTKName() == boxname) {
2092 //=========================================================================
2095 int wxVtkSceneManager::configGConnetion(std::string nameStartBox,
2096 std::string nameStartPort, std::string nameEndBox,
2097 std::string nameEndPort) {
2099 GBoxModel *boxModel;
2100 GPortModel *startP = NULL;
2101 GPortModel *endP = NULL;
2103 boxModel = findGBox(nameStartBox);
2104 if (boxModel != NULL) {
2105 startP = boxModel->getOutputPort(nameStartPort);
2108 boxModel = findGBox(nameEndBox);
2109 if (boxModel != NULL) {
2110 endP = boxModel->getInputPort(nameEndPort);
2114 int idCon = createGConnector(startP);
2115 _worldState = NOTHING_HAPPENS;
2116 GConnectorController *tempp = (GConnectorController*) _controllers[idCon];
2118 GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
2119 vtkGConnectorView *conView = (vtkGConnectorView*) tempp->getView();
2120 tempp->endContourCreation();
2121 conMod->setEndPort(endP);
2122 conView->updateStartEndPoints();
2126 //=========================================================================
2128 bool wxVtkSceneManager::boxExist(std::string boxname) {
2130 std::map<int, GObjectController*>::iterator it;
2131 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2132 GObjectController *cont = it->second;
2133 if (cont->getModel()->getBBTKName() == boxname) {
2140 //=========================================================================
2142 std::vector<int> wxVtkSceneManager::getBlackBoxes() {
2143 std::vector<int> vect;
2144 std::map<int, GObjectController*>::iterator it;
2145 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2146 GObjectController *cont = it->second;
2147 if (cont->getGObjectType() == GBLACKBOX) {
2148 vect.push_back(cont->getId());
2154 //=========================================================================
2156 std::vector<int> wxVtkSceneManager::getComplexInputPorts() {
2157 std::vector<int> vect;
2158 std::map<int, GObjectController*>::iterator it;
2159 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2160 GObjectController *cont = it->second;
2161 if (cont->getGObjectType() == GCOMPLEXINPUTPORT) {
2162 vect.push_back(cont->getId());
2168 //=========================================================================
2170 std::vector<int> wxVtkSceneManager::getComplexOutputPorts() {
2171 std::vector<int> vect;
2172 std::map<int, GObjectController*>::iterator it;
2173 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2174 GObjectController *cont = it->second;
2175 if (cont->getGObjectType() == GCOMPLEXOUTPUTPORT) {
2176 vect.push_back(cont->getId());
2182 //=========================================================================
2184 std::vector<int> wxVtkSceneManager::getConnections() {
2185 std::vector<int> vect;
2186 std::map<int, GObjectController*>::iterator it;
2187 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2188 GObjectController *cont = it->second;
2189 if (cont->getGObjectType() == GCONNECTOR) {
2190 vect.push_back(cont->getId());
2196 //=========================================================================
2198 bool wxVtkSceneManager::isComplexBox() {
2199 return _isComplexBox;
2202 //=========================================================================
2204 void wxVtkSceneManager::setComplexBox(bool val) {
2205 _isComplexBox = val;
2208 //=========================================================================
2210 int wxVtkSceneManager::addObjectController(GObjectController* objController) {
2211 //Register the controller of the new object
2212 registerController((InteractorStyleMaracas*) objController);
2213 //Add the object to the objects list
2214 int newId = _contLastId;//_controllers.size();
2215 objController->setId(newId);
2216 _controllers[newId] = objController;
2218 << "DFCH: int wxVtkSceneManager::addObjectController(GObjectController* objController) ---- _contLastId = "
2219 << _contLastId << std::endl;
2224 //=========================================================================
2226 void wxVtkSceneManager::DuplicateObjects(std::map<int, GObjectController*> objectsMap) {
2228 std::map<int, int> oldIdNewIdBoxes;
2229 std::vector<int> connections;
2231 std::vector<int> newBoxesID;
2233 std::map<int, GObjectController*>::iterator it;
2234 for (it = objectsMap.begin(); it != objectsMap.end(); ++it) {
2235 GObjectController *cont = it->second;
2236 int type = cont->getGObjectType();
2238 if (type == GBLACKBOX) {
2240 double xInic, yInic, zInic;
2241 GBlackBoxModel* copyBox = (GBlackBoxModel*) cont->getModel();
2242 copyBox->getInicPoint(xInic, yInic, zInic);
2243 int idBox = createGBlackBox(0, 0, copyBox->getBBTKPackage(),
2244 copyBox->getBBTKType());
2246 int idcB = copyBox->getObjectId();
2247 oldIdNewIdBoxes[idcB] = idBox;
2248 cont = _controllers[idBox];
2249 GBlackBoxModel* newbox = (GBlackBoxModel*) cont->getModel();
2250 newbox->setInicPoint(xInic, yInic, zInic);
2251 int num = newbox->getNumInputPorts();
2252 for (int j = 0; j < num; j++) {
2253 newbox->setValueToInputPort(j, copyBox->getValueInputPort(j));
2255 newbox->move(xInic + 20, yInic + 20, zInic);
2256 newbox->notifyObservers(_idManager);
2257 newBoxesID.push_back(newbox->getObjectId());
2259 } else if (type == GCONNECTOR) {
2260 int idCon = cont->getId();
2261 connections.push_back(idCon);
2266 for (int i = 0; i < (int) connections.size(); i++) {
2267 int objId = connections[i];
2268 GObjectController *cont = objectsMap[objId];
2269 GConnectorModel* connectModel = (GConnectorModel*) cont->getModel();
2271 GPortModel* startPort = connectModel->getStartPort();
2272 int startPortIndex = startPort->getPosInBox();
2273 GPortModel* endPort = connectModel->getEndPort();
2274 int endPortIndex = endPort->getPosInBox();
2276 GBlackBoxModel* startPortParentBox =
2277 (GBlackBoxModel*) startPort->getParentBox();
2278 GBlackBoxModel* endPortParentBox =
2279 (GBlackBoxModel*) endPort->getParentBox();
2281 int idNewStartBox = oldIdNewIdBoxes[startPortParentBox->getObjectId()];
2282 int idNewEndBox = oldIdNewIdBoxes[endPortParentBox->getObjectId()];
2284 GBlackBoxModel* newStartBox =
2285 (GBlackBoxModel*) _controllers[idNewStartBox]->getModel();
2286 GBlackBoxModel* newEndBox =
2287 (GBlackBoxModel*) _controllers[idNewEndBox]->getModel();
2289 GPortModel* newStartPort = newStartBox->getOutputPort(startPortIndex);
2290 GPortModel* newEndPort = newEndBox->getInputPort(endPortIndex);
2292 // Creates connection
2293 int idCon = createGConnector(newStartPort);
2294 GConnectorController *tempp =
2295 (GConnectorController*) _controllers[idCon];
2296 GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
2297 vtkGConnectorView *conView = (vtkGConnectorView*) tempp->getView();
2298 tempp->endContourCreation();
2299 conMod->setEndPort(newEndPort);
2300 conView->updateStartEndPoints();
2303 /// the new selected boxes are the duplicate ones
2305 UnSelectBlackBoxes();
2306 for (int i = 0; i < newBoxesID.size(); i++) {
2307 _selectedObjects.push_back(newBoxesID.at(i));
2310 for (int i = 0; i < (int) _selectedObjects.size(); i++) {
2311 int id = _selectedObjects[i];
2312 GObjectController* cont = _controllers[id];
2314 cont->getView()->setState(SELECTED);
2315 cont->getModel()->notifyObservers(_idManager);
2322 //=========================================================================
2324 int wxVtkSceneManager::getNumSelectedObjects() {
2325 return _selectedObjects.size();
2328 //=========================================================================
2330 std::map<int, GObjectController*> wxVtkSceneManager::getSelectedObjects() {
2331 std::map<int, GObjectController*> mapSelected;
2333 std::map<int, GObjectController*>::iterator it;
2334 for (it = _controllers.begin(); it != _controllers.end(); ++it) {
2335 GObjectController *cont = it->second;
2336 if (cont->getGObjectType() == GBLACKBOX && cont->getView()->getState()
2338 mapSelected[cont->getId()] = cont;
2342 std::map<int, GObjectController*>::iterator it2;
2343 for (it2 = _controllers.begin(); it2 != _controllers.end(); ++it2) {
2344 GObjectController *cont = it2->second;
2345 if (cont->getGObjectType() == GCONNECTOR) {
2346 GConnectorModel* cmod = (GConnectorModel*) cont->getModel();
2347 GBoxModel* endPortParentBox = cmod->getEndPort()->getParentBox();
2348 GBoxModel* startPortParentBox =
2349 cmod->getStartPort()->getParentBox();
2351 std::map<int, GObjectController*>::iterator iterOBJ1 =
2352 mapSelected.find(startPortParentBox->getObjectId());
2353 std::map<int, GObjectController*>::iterator iterOBJ2 =
2354 mapSelected.find(endPortParentBox->getObjectId());
2356 if (iterOBJ1 != mapSelected.end() && iterOBJ2 != mapSelected.end()) {
2357 int ID = cont->getId();
2358 mapSelected[ID] = cont;
2365 //=========================================================================
2367 void wxVtkSceneManager::addObjects(std::map<int, GObjectController*> objectsMap) {
2369 std::map<int, int> oldIdNewIdBoxes;
2370 std::vector<int> connections;
2372 std::map<int, GObjectController*>::iterator it;
2373 for (it = objectsMap.begin(); it != objectsMap.end(); ++it) {
2374 GObjectController *cont = it->second;
2375 int type = cont->getGObjectType();
2377 if (type == GBLACKBOX) {
2379 double xInic, yInic, zInic;
2380 GBlackBoxModel* copyBox = (GBlackBoxModel*) cont->getModel();
2381 copyBox->getInicPoint(xInic, yInic, zInic);
2382 int idBox = createGBlackBox(0, 0, copyBox->getBBTKPackage(),
2383 copyBox->getBBTKType());
2385 int idcB = copyBox->getObjectId();
2386 oldIdNewIdBoxes[idcB] = idBox;
2387 cont = _controllers[idBox];
2388 GBlackBoxModel* newbox = (GBlackBoxModel*) cont->getModel();
2389 newbox->setInicPoint(xInic, yInic, zInic);
2390 int num = newbox->getNumInputPorts();
2391 for (int j = 0; j < num; j++) {
2392 newbox->setValueToInputPort(j, copyBox->getValueInputPort(j));
2394 newbox->notifyObservers(_idManager);
2395 } else if (type == GCONNECTOR) {
2396 int idCon = cont->getId();
2397 connections.push_back(idCon);
2402 for (int i = 0; i < (int) connections.size(); i++) {
2403 int objId = connections[i];
2404 GObjectController *cont = objectsMap[objId];
2405 GConnectorModel* connectModel = (GConnectorModel*) cont->getModel();
2407 GPortModel* startPort = connectModel->getStartPort();
2408 int startPortIndex = startPort->getPosInBox();
2409 GPortModel* endPort = connectModel->getEndPort();
2410 int endPortIndex = endPort->getPosInBox();
2412 GBlackBoxModel* startPortParentBox =
2413 (GBlackBoxModel*) startPort->getParentBox();
2414 GBlackBoxModel* endPortParentBox =
2415 (GBlackBoxModel*) endPort->getParentBox();
2417 int idNewStartBox = oldIdNewIdBoxes[startPortParentBox->getObjectId()];
2418 int idNewEndBox = oldIdNewIdBoxes[endPortParentBox->getObjectId()];
2420 GBlackBoxModel* newStartBox =
2421 (GBlackBoxModel*) _controllers[idNewStartBox]->getModel();
2422 GBlackBoxModel* newEndBox =
2423 (GBlackBoxModel*) _controllers[idNewEndBox]->getModel();
2425 GPortModel* newStartPort = newStartBox->getOutputPort(startPortIndex);
2426 GPortModel* newEndPort = newEndBox->getInputPort(endPortIndex);
2428 // Creates connection
2429 int idCon = createGConnector(newStartPort);
2430 GConnectorController *tempp =
2431 (GConnectorController*) _controllers[idCon];
2432 GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
2433 vtkGConnectorView *conView = (vtkGConnectorView*) tempp->getView();
2434 tempp->endContourCreation();
2435 conMod->setEndPort(newEndPort);
2436 conView->updateStartEndPoints();
2439 std::map<int, int>::iterator itIds;
2440 for (itIds = oldIdNewIdBoxes.begin(); itIds != oldIdNewIdBoxes.end(); ++itIds) {
2441 int idOld = itIds->first;
2442 int idNew = itIds->second;
2444 GBlackBoxModel* oldBox =
2445 (GBlackBoxModel*) objectsMap[idOld]->getModel();
2446 GBlackBoxModel* newBox =
2447 (GBlackBoxModel*) _controllers[idNew]->getModel();
2449 std::vector<int> oldInputConnections = oldBox->getConnectedInputs();
2450 std::vector<int> oldOutputConnections = oldBox->getConnectedOutputs();
2451 std::vector<int> newInputConnections = newBox->getConnectedInputs();
2452 std::vector<int> newOutputConnections = newBox->getConnectedOutputs();
2454 for (int k = 0; k < (int) oldInputConnections.size(); k++) {
2456 //EED int toCreate=-1;
2457 for (int l = 0; l < (int) newInputConnections.size() && !exist; l++) {
2458 if (oldInputConnections[k] == newInputConnections[l]) {
2463 if (exist == false) {
2464 //Create complex input
2465 int posInBox = oldInputConnections[k];
2466 GPortModel* inputPort = oldBox->getInputPort(posInBox);
2467 std::string inputPortName = inputPort->getBBTKName();
2468 int idInputPort = createGComplexBoxInputPort(inputPortName);
2469 GObjectController *cont = _controllers[idInputPort];
2470 GBoxModel *cbmod = (GBoxModel*) cont->getModel();
2471 double xIn, yIn, zIn;
2472 inputPort->getInicPoint(xIn, yIn, zIn);
2474 cbmod->setInicPoint(xIn, yIn, zIn);
2475 cbmod->notifyObservers(_idManager);
2477 GPortModel* inputPortEnd = newBox->getInputPort(posInBox);
2479 // Creates connection
2480 int idCon = createGConnector(cbmod->getOutputPort(0));
2481 GConnectorController *tempp =
2482 (GConnectorController*) _controllers[idCon];
2483 GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
2484 vtkGConnectorView *conView =
2485 (vtkGConnectorView*) tempp->getView();
2486 tempp->endContourCreation();
2487 conMod->setEndPort(inputPortEnd);
2488 conView->updateStartEndPoints();
2494 for (int k = 0; k < (int) oldOutputConnections.size(); k++) {
2496 //EED int toCreate=-1;
2497 for (int l = 0; l < (int) newOutputConnections.size() && !exist; l++) {
2498 if (oldOutputConnections[k] == newOutputConnections[l]) {
2503 if (exist == false) {
2504 //Create complex output
2505 int posInBox = oldOutputConnections[k];
2506 GPortModel* outputPort = oldBox->getOutputPort(posInBox);
2507 std::string outputPortName = outputPort->getBBTKName();
2508 int idOutputPort = createGComplexBoxOutputPort(outputPortName);
2509 GObjectController *cont = _controllers[idOutputPort];
2510 GBoxModel *cbmod = (GBoxModel*) cont->getModel();
2511 double xIn, yIn, zIn;
2512 outputPort->getInicPoint(xIn, yIn, zIn);
2514 cbmod->setInicPoint(xIn, yIn, zIn);
2515 cbmod->notifyObservers(_idManager);
2517 GPortModel* outputPortEnd = newBox->getOutputPort(posInBox);
2519 // Creates connection
2520 int idCon = createGConnector(outputPortEnd);
2521 GConnectorController *tempp =
2522 (GConnectorController*) _controllers[idCon];
2523 GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
2524 vtkGConnectorView *conView =
2525 (vtkGConnectorView*) tempp->getView();
2526 tempp->endContourCreation();
2527 conMod->setEndPort(cbmod->getInputPort(0));
2528 conView->updateStartEndPoints();
2538 //=========================================================================
2539 void wxVtkSceneManager::SetCbName(std::string cbName) {
2541 if (_cbName == "") {
2542 _cbName = "<complex box name>";
2546 //=========================================================================
2547 std::string wxVtkSceneManager::GetCbName() {
2551 //=========================================================================
2552 void wxVtkSceneManager::SetCbPackageName(std::string packagename) {
2553 _cbPackageName = packagename;
2554 if (_cbPackageName == "") {
2555 _cbPackageName = "<package name of the complex box>";
2559 //=========================================================================
2560 std::string wxVtkSceneManager::GetCbPackageName() {
2561 return _cbPackageName;
2564 //=========================================================================
2565 void wxVtkSceneManager::SetAuthor(std::string author) {
2567 if (_Author == "") {
2568 _Author = "<author of the box>";
2572 //=========================================================================
2573 std::string wxVtkSceneManager::GetAuthor() {
2577 //=========================================================================
2578 void wxVtkSceneManager::SetCategory(std::string category) {
2579 _Category = category;
2580 if (_Category == "") {
2581 _Category = "<category of the box>";
2585 //=========================================================================
2586 std::string wxVtkSceneManager::GetCategory() {
2590 //=========================================================================
2591 void wxVtkSceneManager::SetDescription(std::string description) {
2592 _Description = description;
2593 if (_Description == "") {
2594 _Description = "<description of the box>";
2598 //=========================================================================
2599 std::string wxVtkSceneManager::GetDescription() {
2600 return _Description;
2603 //=========================================================================
2606 } // EO namespace bbtk