/*=========================================================================
 Program:   bbtk
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 =========================================================================*/

/* ---------------------------------------------------------------------

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

#include "wxVtkSceneManager.h"

#include <vtkPolygon.h>
#include <vtkUnstructuredGrid.h>

namespace bbtk {

//=========================================================================
wxVtkSceneManager::wxVtkSceneManager(wxGEditorTabPanel *parent,
		wxVtk3DBaseView *baseView, int idManager) {
	_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
		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;

}

//=========================================================================

void wxVtkSceneManager::disconnectDrop() {
	printf("EED %p ~wxVtkSceneManager::disconnectDrop()\n", this);
	//EED02JUIN2010		_baseView->GetWxVTKRenderWindowInteractor()->SetDropTarget(NULL);
	//	_baseView->GetWxVTKRenderWindowInteractor()->SetDropTarget( new tmpClasswxTextDropTarget() );
}

//=========================================================================

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);

	// Important to activate the 2D interaction system
	wxVTKRenderWindowInteractor *iren =
			_baseView->GetWxVTKRenderWindowInteractor();
	interactorstylebaseview->SetInteractor(iren);
	iren->SetInteractorStyle(interactorstylebaseview);
	interactorstylebaseview->SetwxVtkBaseView(_baseView);

	_baseView->GetRenderer()->GetActiveCamera()->ParallelProjectionOn();
	_baseView->GetRenderer()->ResetCamera(-100, 100, -100, 100, 800, 1100);

	_baseView->GetRenderer()->SetBackground(0.9, 0.9, 0.9);
	_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");
}

//=========================================================================

std::string wxVtkSceneManager::generateANewNameForABox() {
	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 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);

	//Prepares the initial model
	//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);

	std::stringstream stream;

	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);

	//Iterate and create the input ports
	std::map<std::string, BlackBoxInputDescriptor*> descriptorInMap =
			descriptor->GetInputDescriptorMap();
	std::map<std::string, BlackBoxInputDescriptor*>::iterator itInput;

	int i = 0;
	for (itInput = descriptorInMap.begin(); itInput != descriptorInMap.end(); ++itInput) {
		BlackBoxInputDescriptor *desc = itInput->second;
		createGInputPort(GINPUTPORT, i, model, desc);
		i++;
	}

	//Iterate and create the output ports
	std::map<std::string, BlackBoxOutputDescriptor*> descriptorOutMap =
			descriptor->GetOutputDescriptorMap();
	std::map<std::string, BlackBoxOutputDescriptor*>::iterator itOutput;

	i = 0;
	for (itOutput = descriptorOutMap.begin(); itOutput
			!= descriptorOutMap.end(); ++itOutput) {
		BlackBoxOutputDescriptor *desc = itOutput->second;
		createGOutputPort(GOUTPUTPORT, i, model, desc);
		i++;
	}

	//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::createGComplexBoxInputPort(std::string inputName) {
	//EED		int windowWidth=_baseView->GetRenWin()->GetSize()[0];
	int windowHeight = _baseView->GetRenWin()->GetSize()[1];

	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;

	//z value is not important yet, because it is only used a parallel projection
	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
	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) {
	//EED		int windowWidth=_baseView->GetRenWin()->GetSize()[0];
	int windowHeight = _baseView->GetRenWin()->GetSize()[1];

	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;

	//z value is not important yet, because it is only used a parallel projection
	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
	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 wxVtkSceneManager::createGInputPort(int portType, int posinBox,
		GBoxModel *blackBox, BlackBoxInputDescriptor *desc) {
	GPortController* portController = createGPort(portType, desc->GetName(),
			desc->GetTypeName(), posinBox, blackBox);
	blackBox->addInputPort((GPortModel*) portController->getModel());
	return portController->getId();
}

//=========================================================================

int wxVtkSceneManager::createGOutputPort(int portType, int posinBox,
		GBoxModel *blackBox, BlackBoxOutputDescriptor *desc) {
	GPortController* portController = createGPort(portType, desc->GetName(),
			desc->GetTypeName(), posinBox, blackBox);
	blackBox->addOutputPort((GPortModel*) portController->getModel());
	return portController->getId();
}

//=========================================================================

GPortController* wxVtkSceneManager::createGPort(int portType,
		std::string bbtkName, std::string bbtkType, int posInBox,
		GBoxModel *blackBox) {
	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);

	model->registerInBox(blackBox, portType, posInBox);

	model->setBBTKType(bbtkType);
	model->setBBTKName(bbtkName);

	model->addObserver(view);
	model->addObserver(this);

	//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);

	model->notifyObservers(_idManager);

	addObjectController(controller);

	return (GPortController*) controller;
}

//=========================================================================

int wxVtkSceneManager::createGConnector(GPortModel* startPort) {
	int type = GCONNECTOR;

	manualConnectorContourController* manContourControl =
			new manualConnectorContourController();
	manualConnectorContourView* manContourView =
			new manualConnectorContourView();
	manualContourModel* manContourModel = new manualContourModel();

	GConnectorController* connectorcontroller = new GConnectorController();
	GConnectorModel* connectorModel = new GConnectorModel();
	vtkGConnectorView* connectorView = new vtkGConnectorView();
	connectorModel->setGObjectType(type);

	manContourModel->SetCloseContour(false);
	connectorModel->setStartPort(startPort);

	manContourView->SetModel(manContourModel);
	manContourView->SetWxVtkBaseView(_baseView);
	manContourView->SetRange(0.5);
	manContourView->SetZ(900);

	manContourView->SetColorNormalContour(0, 0, 1);
	manContourView->SetColorEditContour(0.5, 0.5, 0.5);
	manContourView->SetColorSelectContour(1, 0.8, 0);
	manContourView->SetWidthLine(1);
	manContourView->SetShowText(false);

	manContourControl->SetModelView(manContourModel, manContourView);

	manContourControl->CreateNewManualContour();

	manContourView->RefreshContour();

	double x, y, z;
	connectorModel->getInicPoint(x, y, z);

	manContourControl->SetState(1);
	manContourModel->SetCloseContour(false);

	manContourModel->AddPoint(x, y, z);
	manContourView->AddPoint();

	manContourModel->AddPoint(x, y, z);
	manContourView->AddPoint();

	int bak = manContourControl->GetNumberOfPointsManualContour() - 1;
	manContourControl->_bakIdPoint = bak;
	manContourView->Refresh();

	manContourControl->SetMoving(false);

	connectorcontroller->setModelAndView(connectorModel, connectorView);

	int newId = addObjectController(connectorcontroller);

	connectorcontroller->setManualContourController(manContourControl);
	connectorModel->setManualContourModel(manContourModel);
	connectorView->setManualContourView(manContourView);
	connectorView->setModel(connectorModel);
	connectorView->setBaseView(_baseView);

	connectorModel->addObserver(connectorView);
	connectorModel->addObserver(this);

	return newId;
}

//=========================================================================

void wxVtkSceneManager::registerController(InteractorStyleMaracas *param) {
	vtkInteractorStyleBaseView
			* baseViewControlManager =
					(vtkInteractorStyleBaseView*) _baseView->GetInteractorStyleBaseView();
	baseViewControlManager->AddInteractorStyleMaracas(param);
}

//=========================================================================

void wxVtkSceneManager::unregisterController(InteractorStyleMaracas *param) {
	vtkInteractorStyleBaseView
			* baseViewControlManager =
					(vtkInteractorStyleBaseView*) _baseView->GetInteractorStyleBaseView();
	baseViewControlManager->RemoveInteractorStyleMaracas(param);
}

//=========================================================================

vtkRenderer* wxVtkSceneManager::getRenderer() {
	return _baseView->GetRenderer();
}

//=========================================================================

vtkRenderWindow* wxVtkSceneManager::getRenderWindow() {
	return _baseView->GetRenWin();
}
//=========================================================================


//=========================================================================
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) {
			//EEDBorrame				GObjectController* cont = _controllers[idController];

			if (GetIndexInSelected(idController) == -1) {
				_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];
			GPortModel* startOutputPort = (GPortModel*) cont->getModel();

			// The last one is the controller of the connector
			std::map<int, GObjectController*>::iterator it2;

			for (it2 = _controllers.begin(); it2 != _controllers.end(); ++it2) {
				GObjectController *cont = it2->second;
				if (cont->getGObjectType() == GPORT) {
					GPortModel* port = (GPortModel*) cont->getModel();
					if (port->getPortType() == GINPUTPORT) {
						cont->SetActive(true);
					} else {
						cont->getView()->setState(NOTHING_HAPPENS);
						cont->getModel()->notifyObservers(_idManager);
						cont->SetActive(false);
					}
				} else {
					cont->getView()->setState(NOTHING_HAPPENS);
					cont->getModel()->notifyObservers(_idManager);
					cont->SetActive(false);
				}
			}
			_selectedObjects.clear();
			_idConnectionInCreation = createGConnector(startOutputPort);
		} else if (command == FIN_CREATION_CONTOUR && _worldState
				== INIT_CREATION_CONTOUR) {
			_worldState = NOTHING_HAPPENS;
			//int id = _controllers.size()-1;
			GObjectController *cont = _controllers[_idConnectionInCreation];
			GConnectorModel *modelContour = (GConnectorModel*) cont->getModel();
			GObjectController *finPort = _controllers[idController];

			if (finPort->getGObjectType() == GPORT) {
				GPortModel* modelPort = (GPortModel*) finPort->getModel();
				modelContour->setEndPort(modelPort);
			}

			manualConnectorContourController
					* manCont =
							((GConnectorController*) cont)->getManualContourController();
			manualConnectorContourView
					* connView =
							(manualConnectorContourView*) manCont->GetManualViewBaseContour();
			connView->Refresh();

			std::map<int, GObjectController*>::iterator it2;

			for (it2 = _controllers.begin(); it2 != _controllers.end(); ++it2) {
				GObjectController *cont = it2->second;
				if (cont->getView() != NULL) {
					cont->getView()->setState(NOTHING_HAPPENS);
					cont->getModel()->notifyObservers(_idManager);
				}
				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 < (int) _selectedObjects.size(); i++) {
			int id = _selectedObjects[i];
			GObjectController* cont = _controllers[id];
			if (_startDragging) {
				cont->getView()->setStartDragging(true);
			}
			cont->getView()->moveObject(X, Y);
			cont->getView()->setState(DRAG);
			cont->getModel()->notifyObservers(_idManager);
		}

		std::map<int, GObjectController*>::iterator it;

		for (it = _controllers.begin(); it != _controllers.end(); ++it) {
			GObjectController *desc = it->second;
			if (desc->getGObjectType() == GCONNECTOR) {
				vtkGConnectorView* vconn = (vtkGConnectorView*) desc->getView();
				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();
			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;
		std::map<int, GObjectController*>::iterator it;
		for (it = _controllers.begin(); it != _controllers.end() && isOverPort
				== false; ++it) {
			GObjectController *desc = it->second;
			if (desc->getGObjectType() == GPORT) {
				GPortModel *portmod = (GPortModel*) desc->getModel();
				vtkGObjectView *portView = desc->getView();
				if (portmod->getPortType() == GINPUTPORT
						&& portView->getState() == HIGHLIGHTED) {
					isOverPort = true;
				} // if
			} // if
		} // for

		if (isOverPort == false) {
			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)) {
				UnSelectBlackBoxes();
			}
		}
		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 < (int) _selectedObjects.size(); i++) {
			int id = _selectedObjects[i];
			GObjectController* cont = _controllers[id];
			cont->getView()->setState(SELECTED);
			cont->getModel()->notifyObservers(_idManager);
		}
	}
	return true;
}

//=========================================================================
void wxVtkSceneManager::CancelConnection() {
	if (_worldState == INIT_CREATION_CONTOUR) {
		_worldState = NOTHING_HAPPENS;
		//int lastId = _controllers.size()-1;

		GConnectorController *connector =
				(GConnectorController*) _controllers[_idConnectionInCreation];
		connector->removeFromScene();
		unregisterController(connector);
		_controllers.erase(_idConnectionInCreation);

		std::map<int, GObjectController*>::iterator it;
		for (it = _controllers.begin(); it != _controllers.end(); ++it) {
			GObjectController *desc = it->second;
			desc->SetActive(true);
			desc->getView()->setState(NOTHING_HAPPENS);
			desc->getModel()->notifyObservers(_idManager);
		} // for
	}// if
}

//=========================================================================

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();
	 wxVTKiren->GetEventPosition(X,Y);

	 std::map<int, GObjectController*>::iterator it;

	 bool clickOnObject = false;

	 for(it = _controllers.begin(); it != _controllers.end() && clickOnObject==false; ++it)
	 {
	 GObjectController *cont = it->second;
	 int type = cont->getGObjectType();

	 if(cont->getView()->isPointInside(X,Y))
	 {
	 if(type==GBLACKBOX)
	 {
	 for (int i=0; i< (int)_selectedObjects.size(); i++)
	 {
	 int id = _selectedObjects[i];
	 GObjectController* control = _controllers[id];
	 control->getView()->setState(NOTHING_HAPPENS);
	 }
	 _selectedObjects.clear();

	 GBlackBoxModel *bbmodel = (GBlackBoxModel*)cont->getModel();
	 _parent->editBlackBox(bbmodel);
	 }
	 clickOnObject = true;
	 }
	 }

	 if(clickOnObject==false)
	 {
	 //_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 < (int) _selectedObjects.size(); i++) {
				int id = _selectedObjects[i];
				std::map<int, GObjectController*>::iterator it;
				it = _controllers.find(id);
				if (it != _controllers.end()) {
					deleteObject(id);
				}
			}
			_selectedObjects.clear();
		}
	}

	return true;
}

//=========================================================================

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];
	std::vector<int> controllersToRemove;

	if (control->getGObjectType() == GBLACKBOX || control->getGObjectType()
			== GCOMPLEXINPUTPORT || control->getGObjectType()
			== GCOMPLEXOUTPUTPORT) {
		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 < (int) inputs.size(); i++) {
			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 < (int) outputs.size(); i++) {
			AddControlerToBeRemove(&controllersToRemove,
					outputs[i]->getObjectId());
			if (outputs[i]->isConnected()) {
				boxConnected = true;
			}
		}

		// Add connection controllers to be removed
		std::map<int, GObjectController*>::iterator it;
		for (it = _controllers.begin(); it != _controllers.end(); ++it) {
			GObjectController *cont = it->second;
			int type = cont->getGObjectType();
			if (type == GCONNECTOR) {
				GConnectorModel *conMod = (GConnectorModel*) cont->getModel();
				if (conMod->getStartPort() != NULL
						&& conMod->getStartPort()->getParentBox()->getObjectId()
								== bbmod->getObjectId()) {
					AddControlerToBeRemove(&controllersToRemove,
							conMod->getObjectId());
				}
				if (conMod->getEndPort() != NULL
						&& conMod->getEndPort()->getParentBox()->getObjectId()
								== bbmod->getObjectId()) {
					AddControlerToBeRemove(&controllersToRemove,
							conMod->getObjectId());
				}
			}
		}

		// Add box controller to be removed
		AddControlerToBeRemove(&controllersToRemove, bbmod->getObjectId());
	} else if (control->getGObjectType() == GCONNECTOR) {
		GConnectorModel *conMod = (GConnectorModel*) control->getModel();
		AddControlerToBeRemove(&controllersToRemove, conMod->getObjectId());
	}

	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
}

//=========================================================================

void wxVtkSceneManager::displayBlackBoxInfo(std::string packageName,
		std::string boxName) {
	_parent->displayBlackBoxInfo(packageName, boxName);
}

//=========================================================================

void wxVtkSceneManager::updateStatusBar(std::string textStatus) {
	_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;
}
//=========================================================================
//DFCH
bool wxVtkSceneManager::MakeBoxExecutable() {
	std::map<int, GObjectController*> selected = getSelectedObjects();
	if( selected.empty() )
		return false;
	bool ret = false;
	std::map<int, GObjectController*>::iterator it;
	for (it = selected.begin(); it != selected.end(); ++it) {
		GObjectController* lastSelected = it->second;
		if (lastSelected) {
			vtkGObjectView* view = (vtkGObjectView*) lastSelected->getView();
			GBlackBoxModel *bbmodel =
					(GBlackBoxModel*) lastSelected->getModel();
			view->setState(HIGHLIGHTED);
			if (bbmodel->isExecutable()) {
				bbmodel->setExecutable(false);
			} else {
				bbmodel->setExecutable(true);
			}
			bbmodel->notifyObservers(lastSelected->getId());
			ret = true;
		}
	}
	return ret;
}
//DFCH

//=========================================================================

std::string wxVtkSceneManager::getDiagramBBS(bool wln) {
	bool existsExec = false;

	std::vector<std::string> packages;
	std::vector<int> boxes;
	std::vector<int> connections;
	std::vector<int> execBoxes;

	std::map<int, GObjectController*>::iterator it;

	for (it = _controllers.begin(); it != _controllers.end(); ++it) {
		GObjectController *desc = it->second;
		int type = desc->getGObjectType();

		if (type == GBLACKBOX) {
			GBlackBoxModel *mod = (GBlackBoxModel*) desc->getModel();

			std::string pkg = mod->getBBTKPackage();
			bool existsPkg = false;
			for (int t = 0; t < (int) packages.size() && existsPkg == false; t++) {
				if (packages[t] == pkg) {
					existsPkg = true;
				}
			}
			if (!existsPkg) {
				packages.push_back(pkg);
			}

			boxes.push_back(it->first);
			if (mod->isExecutable()) {
				execBoxes.push_back(it->first);
				existsExec = true;
			}
		} else if (type == GCONNECTOR) {
			connections.push_back(it->first);
		}
	}

	int lnNmbr = 0;
	std::string script = "";
	script += LineNumber(wln, lnNmbr) + "# BBTK GEditor Script\n";
	script += LineNumber(wln, lnNmbr) + "# ----------------------\n";
	script += LineNumber(wln, lnNmbr) + "\n";
	if (existsExec) {
		script += LineNumber(wln, lnNmbr) + "include std\n"; // EED
		script += LineNumber(wln, lnNmbr) + "include itkvtk\n"; // EED
		int 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 < (int) boxes.size(); i++) {
			script += LineNumber(wln, lnNmbr);
			script += "new ";
			int id = boxes[i];
			GObjectController *control = _controllers[id];
			GBlackBoxModel *model = (GBlackBoxModel*) control->getModel();

			script += model->getBBTKType();
			script += " ";
			script += model->getBBTKName();
			script += "\n";

			std::vector<GPortModel*> inputs = model->getInputPorts();
			for (int j = 0; j < (int) inputs.size(); j++) {
				GPortModel* inputPort = inputs[j];
				if (inputPort->isValueSet()) {
					script += LineNumber(wln, lnNmbr);
					script += "  set ";
					script += model->getBBTKName();
					script += ".";
					script += inputPort->getBBTKName();
					script += " ";
					script += inputPort->getValue();
					script += "\n";
				}
			}

			script += LineNumber(wln, lnNmbr);
			script += "\n";

		}

		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];
			GConnectorModel *model = (GConnectorModel*) control->getModel();

			//Start Connection info
			GPortModel *start = model->getStartPort();
			script += start->getParentBox()->getBBTKName();
			script += ".";
			script += start->getBBTKName();

			script += " ";

			//End Connection info
			GPortModel *end = model->getEndPort();
			script += end->getParentBox()->getBBTKName();
			script += ".";
			script += end->getBBTKName();

			script += "\n";
		}

		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];
			GBlackBoxModel *model = (GBlackBoxModel*) control->getModel();

			script += model->getBBTKName();
			script += "\n";
		}

	}

	return script;
}

//=========================================================================

std::string wxVtkSceneManager::saveComplexBoxBBS() {
	std::vector<std::string> packages;
	std::vector<int> boxes;
	std::vector<int> connections;
	std::vector<int> execBoxes;

	std::map<int, GObjectController*>::iterator it;

	for (it = _controllers.begin(); it != _controllers.end(); ++it) {
		GObjectController *desc = it->second;
		int type = desc->getGObjectType();

		if (type == GBLACKBOX) {
			GBlackBoxModel *mod = (GBlackBoxModel*) desc->getModel();

			std::string pkg = mod->getBBTKPackage();
			bool existsPkg = false;
			for (int t = 0; t < (int) packages.size() && existsPkg == false; t++) {
				if (packages[t] == pkg) {
					existsPkg = true;
				}
			}
			if (!existsPkg) {
				packages.push_back(pkg);
			}

			boxes.push_back(it->first);
			if (mod->isExecutable()) {
				execBoxes.push_back(it->first);
			}
		} else if (type == GCONNECTOR) {
			connections.push_back(it->first);
		}
	}

	std::string script = "";

	script += "include std\n"; // EED
	script += "include itkvtk\n"; // EED
	int 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 + " " + _cbPackageName;
	script += "\n";
	script += "\n";

	script += "author \"";
	script += _Author;
	script += "\"\n";

	script += "description \"";
	script += _Description;
	script += "\"\n";
	script += "\n";

	script += "category \"";
	script += _Category;
	script += "\"\n";
	script += "\n";

	// Create boxes
	for (i = 0; i < (int) boxes.size(); i++) {
		script += "new ";
		int id = boxes[i];
		GObjectController *control = _controllers[id];
		GBlackBoxModel *model = (GBlackBoxModel*) control->getModel();

		script += model->getBBTKType();
		script += " ";
		script += model->getBBTKName();
		script += "\n";

		std::vector<GPortModel*> inputs = model->getInputPorts();
		for (int j = 0; j < (int) inputs.size(); j++) {
			GPortModel* inputPort = inputs[j];
			if (inputPort->isValueSet()) {
				script += "  set ";
				script += model->getBBTKName();
				script += ".";
				script += inputPort->getBBTKName();
				script += " ";
				script += inputPort->getValue();
				script += "\n";
			}
		}
		script += "\n";

	}

	// Create connections in the script. If the connection is made with a complex port, it is created the input or output

	std::string complexInputs = "";
	std::string complexOutputs = "";
	script += "\n";

	for (i = 0; i < (int) connections.size(); i++) {
		int id = connections[i];
		GObjectController *control = _controllers[id];
		GConnectorModel *model = (GConnectorModel*) control->getModel();

		//Connection info
		GPortModel *start = model->getStartPort();
		GBoxModel *startBox = start->getParentBox();

		GPortModel *end = model->getEndPort();
		GBoxModel *endBox = end->getParentBox();

		if (startBox->getGObjectType() == GCOMPLEXINPUTPORT) {
			complexInputs += "input ";
			complexInputs += startBox->getBBTKName();

			complexInputs += " ";
			complexInputs += endBox->getBBTKName();
			complexInputs += ".";
			complexInputs += end->getBBTKName();

			complexInputs += " ";
			complexInputs += "\" \"";

			complexInputs += "\n";
		} else if (endBox->getGObjectType() == GCOMPLEXOUTPUTPORT) {
			complexOutputs += "output ";
			complexOutputs += endBox->getBBTKName();

			complexOutputs += " ";
			complexOutputs += startBox->getBBTKName();
			complexOutputs += ".";
			complexOutputs += start->getBBTKName();

			complexOutputs += " ";
			complexOutputs += "\" \"";

			complexOutputs += "\n";
		} else {
			script += "connect ";
			script += startBox->getBBTKName();
			script += ".";
			script += start->getBBTKName();

			script += " ";

			//End Connection info
			script += endBox->getBBTKName();
			script += ".";
			script += end->getBBTKName();

			script += "\n";
		}
	}

	script += "\n";

	for (i = 0; i < (int) execBoxes.size(); i++) {
		script += "exec ";
		int id = execBoxes[i];
		GObjectController *control = _controllers[id];
		GBlackBoxModel *model = (GBlackBoxModel*) control->getModel();

		script += model->getBBTKName();
		script += "\n";
	}

	script += "\n";
	script += "# Complex input ports\n";
	script += complexInputs;

	script += "\n";
	script += "# Complex output ports\n";
	script += complexOutputs;

	script += "\n";
	script += "endefine";
	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;
		cont->removeFromScene();
		unregisterController((InteractorStyleMaracas*) cont);
	}
	_selectedObjects.clear();
	_controllers.clear();
	refreshScene();
}

//=========================================================================


void wxVtkSceneManager::refresh() {
	_baseView->Refresh();
}
//=========================================================================

void wxVtkSceneManager::refreshScene() {
	_baseView->RefreshView();
}

//=========================================================================

void wxVtkSceneManager::centerView() {
	double temp[3];
	_baseView->GetRenderer()->GetActiveCamera()->GetFocalPoint(temp);
	_baseView->GetRenderer()->GetActiveCamera()->SetFocalPoint(0, 0, temp[2]);
	_baseView->GetRenderer()->GetActiveCamera()->GetPosition(temp);
	_baseView->GetRenderer()->GetActiveCamera()->SetPosition(0, 0, temp[2]);
	_baseView->RefreshView();

}

//=========================================================================

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();
		int insize = inputs.size();
		content += "COMPLEXINPUTS:";
		sprintf(buffer, "%d", insize);
		content += buffer;
		content += "\n";

		for (int i = 0; i < insize; i++) {
			int id = inputs[i];
			GObjectController *cont = _controllers[id];
			cont->getModel()->save(content);
		}

		//Print info complex output ports
		std::vector<int> outputs = getComplexOutputPorts();
		int outsize = outputs.size();
		content += "COMPLEXOUTPUTS:";
		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";
	}

	//Print boxes
	std::vector<int> boxes = getBlackBoxes();
	int bsize = boxes.size();
	content += "BOXES:";
	sprintf(buffer, "%d", bsize);
	content += buffer;
	content += "\n";

	for (int i = 0; i < bsize; i++) {
		int id = boxes[i];
		GObjectController *cont = _controllers[id];
		cont->getModel()->save(content);
	}

	//Print connections
	std::vector<int> connections = getConnections();
	int csize = connections.size();
	content += "CONNECTIONS:";
	sprintf(buffer, "%d", csize);
	content += buffer;
	content += "\n";

	for (int i = 0; i < csize; i++) {
		int id = connections[i];
		GObjectController *cont = _controllers[id];
		cont->getModel()->save(content);
	}

}

//=========================================================================

void wxVtkSceneManager::loadDiagram(ifstream &inputStream) {

	std::string version = "<void>";
	std::string line = "";
	char delims[] = ":";
	char *result = NULL;
	getline(inputStream, line);

	bool start = false;
	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") {
			start = true;
			break;
		}
	}

	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 complexTmp[30];
		strcpy(complexTmp, line.c_str());
		result = strtok(complexTmp, delims);
		result = strtok(NULL, delims);
		std::string isComplexBox(result);

		if (isComplexBox == "TRUE") {
			_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[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);//COMPLEX_PORT
				getline(inputStream, line);//name
				std::string inputPortName(line);

				//----------
				getline(inputStream, line);//xInic:yInic:zInic
				char coord[80];
				strcpy(coord, line.c_str());
				result = strtok(coord, delims);//xInic
				std::string xInic(result);
				result = strtok(NULL, delims);//yInic
				std::string yInic(result);
				result = strtok(NULL, delims);//zInic
				std::string zInic(result);

				double xIn, yIn, zIn;
				std::istringstream xSt(xInic);
				xSt >> xIn;
				std::istringstream ySt(yInic);
				ySt >> yIn;
				std::istringstream zSt(zInic);
				zSt >> zIn;

				getline(inputStream, line);//FIN_COMPLEX_PORT

				configGComBoxInputOutputPort(true, inputPortName, xIn, yIn, zIn);

			} // for input complex box


			//-----------------------
			//- COMPLEX OUTPUT PORTS
			//-----------------------

			getline(inputStream, line);//COMPLEXOUTPUTS:num
			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);//COMPLEX_PORT
				getline(inputStream, line);//name
				std::string outputPortName(line);

				//----------
				getline(inputStream, line);//xInic:yInic:zInic
				char coord[80];
				strcpy(coord, line.c_str());
				result = strtok(coord, delims);//xInic
				std::string xInic(result);
				result = strtok(NULL, delims);//yInic
				std::string yInic(result);
				result = strtok(NULL, delims);//zInic
				std::string zInic(result);

				double xIn, yIn, zIn;
				std::istringstream xSt(xInic);
				xSt >> xIn;
				std::istringstream ySt(yInic);
				ySt >> yIn;
				std::istringstream zSt(zInic);
				zSt >> zIn;

				getline(inputStream, line);//FIN_COMPLEX_PORT

				configGComBoxInputOutputPort(false, outputPortName, xIn, yIn,
						zIn);

			} // for output complex box

		} // complex box

		//----------
		getline(inputStream, line);//BOXES:num
		char boxes[9];
		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[150];
			strcpy(box, line.c_str());
			result = strtok(box, delims);//package
			std::string package(result);
			result = strtok(NULL, delims);//type
			std::string type(result);
			result = strtok(NULL, delims);//name
			std::string name(result);

			getline(inputStream, line);//ISEXEC:TRUE|FALSE
			char exec[15];
			strcpy(exec, line.c_str());
			result = strtok(exec, delims);//ISEXEC
			result = strtok(NULL, delims);//TRUE|FALSE
			std::string isExec(result);

			//----------
			getline(inputStream, line);//xInic:yInic:zInic
			char coord[80];
			strcpy(coord, line.c_str());
			result = strtok(coord, delims);//xInic
			std::string xInic(result);
			result = strtok(NULL, delims);//yInic
			std::string yInic(result);
			result = strtok(NULL, delims);//zInic
			std::string zInic(result);

			double xIn, yIn, zIn;
			std::istringstream xSt(xInic);
			xSt >> xIn;
			std::istringstream ySt(yInic);
			ySt >> yIn;
			std::istringstream zSt(zInic);
			zSt >> zIn;

			//----------
			getline(inputStream, line);//xEnd:yEnd:zEnd
			strcpy(coord, line.c_str());
			result = strtok(coord, delims);//xEnd
			std::string xEnd(result);
			result = strtok(NULL, delims);//yEnd
			std::string yEnd(result);
			result = strtok(NULL, delims);//zEnd
			std::string zEnd(result);

			double xEn, yEn, zEn;
			std::istringstream xEt(xEnd);
			xEt >> xEn;
			std::istringstream yEt(yEnd);
			yEt >> yEn;
			std::istringstream zEt(zEnd);
			zEt >> zEn;

			bool boxExecutable = false;
			if (isExec == "TRUE") {
				boxExecutable = true;
			}

			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[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);

				getline(inputStream, line);//PORT o FIN_BOX
				port = line.substr(0, 4);
			} // while

			//EED				bbmod->notifyObservers(_idManager);
		} // for boxes

		/// CONNECTIONS
		//----------
		getline(inputStream, line);//CONNECTIONS:num
		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[200];
			strcpy(connec, line.c_str());
			result = strtok(connec, delims);
			std::string nameStartBox(result);
			result = strtok(NULL, delims);
			std::string nameStartPort(result);
			result = strtok(NULL, delims);
			std::string nameEndBox(result);
			result = strtok(NULL, delims);
			std::string nameEndPort(result);

			int idCon = configGConnetion(nameStartBox, nameStartPort,
					nameEndBox, nameEndPort);

			if (version != "1.0") {
				//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++) {
					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

	} // 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) {
				boxModel = bMod;
			}
		} // for

		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;
			}
		} // for

	} // 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::vector<int> wxVtkSceneManager::getBlackBoxes() {
	std::vector<int> vect;
	std::map<int, GObjectController*>::iterator it;
	for (it = _controllers.begin(); it != _controllers.end(); ++it) {
		GObjectController *cont = it->second;
		if (cont->getGObjectType() == GBLACKBOX) {
			vect.push_back(cont->getId());
		}
	}
	return vect;
}

//=========================================================================

std::vector<int> wxVtkSceneManager::getComplexInputPorts() {
	std::vector<int> vect;
	std::map<int, GObjectController*>::iterator it;
	for (it = _controllers.begin(); it != _controllers.end(); ++it) {
		GObjectController *cont = it->second;
		if (cont->getGObjectType() == GCOMPLEXINPUTPORT) {
			vect.push_back(cont->getId());
		}
	}
	return vect;
}

//=========================================================================

std::vector<int> wxVtkSceneManager::getComplexOutputPorts() {
	std::vector<int> vect;
	std::map<int, GObjectController*>::iterator it;
	for (it = _controllers.begin(); it != _controllers.end(); ++it) {
		GObjectController *cont = it->second;
		if (cont->getGObjectType() == GCOMPLEXOUTPUTPORT) {
			vect.push_back(cont->getId());
		}
	}
	return vect;
}

//=========================================================================

std::vector<int> wxVtkSceneManager::getConnections() {
	std::vector<int> vect;
	std::map<int, GObjectController*>::iterator it;
	for (it = _controllers.begin(); it != _controllers.end(); ++it) {
		GObjectController *cont = it->second;
		if (cont->getGObjectType() == GCONNECTOR) {
			vect.push_back(cont->getId());
		}
	}
	return vect;
}

//=========================================================================

bool wxVtkSceneManager::isComplexBox() {
	return _isComplexBox;
}

//=========================================================================

void wxVtkSceneManager::setComplexBox(bool val) {
	_isComplexBox = val;
}

//=========================================================================

int wxVtkSceneManager::addObjectController(GObjectController* objController) {
	//Register the controller of the new object
	registerController((InteractorStyleMaracas*) objController);
	//Add the object to the objects list
	int newId = _contLastId;//_controllers.size();
	objController->setId(newId);
	_controllers[newId] = objController;
	std::cout
			<< "DFCH: int wxVtkSceneManager::addObjectController(GObjectController* objController) ---- _contLastId = "
			<< _contLastId << std::endl;
	_contLastId++;
	return newId;
}

//=========================================================================

int wxVtkSceneManager::getNumSelectedObjects() {
	return _selectedObjects.size();
}

//=========================================================================

std::map<int, GObjectController*> wxVtkSceneManager::getSelectedObjects() {
	std::map<int, GObjectController*> mapSelected;

	std::map<int, GObjectController*>::iterator it;
	for (it = _controllers.begin(); it != _controllers.end(); ++it) {
		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;
		if (cont->getGObjectType() == GCONNECTOR) {
			GConnectorModel* cmod = (GConnectorModel*) cont->getModel();
			GBoxModel* endPortParentBox = cmod->getEndPort()->getParentBox();
			GBoxModel* startPortParentBox =
					cmod->getStartPort()->getParentBox();

			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;
	for (it = objectsMap.begin(); it != objectsMap.end(); ++it) {
		GObjectController *cont = it->second;
		int type = cont->getGObjectType();

		if (type == GBLACKBOX) {
			// Copy black box
			double xInic, yInic, zInic;
			GBlackBoxModel* copyBox = (GBlackBoxModel*) cont->getModel();
			copyBox->getInicPoint(xInic, yInic, zInic);
			int idBox = createGBlackBox(0, 0, copyBox->getBBTKPackage(),
					copyBox->getBBTKType());

			int idcB = copyBox->getObjectId();
			oldIdNewIdBoxes[idcB] = idBox;
			cont = _controllers[idBox];
			GBlackBoxModel* newbox = (GBlackBoxModel*) cont->getModel();
			newbox->setInicPoint(xInic, yInic, zInic);
			int num = newbox->getNumInputPorts();
			for (int j = 0; j < num; j++) {
				newbox->setValueToInputPort(j, copyBox->getValueInputPort(j));
			}
			newbox->notifyObservers(_idManager);
		} else if (type == GCONNECTOR) {
			int idCon = cont->getId();
			connections.push_back(idCon);
		}

	}

	for (int i = 0; i < (int) connections.size(); i++) {
		int objId = connections[i];
		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();

		GBlackBoxModel* startPortParentBox =
				(GBlackBoxModel*) startPort->getParentBox();
		GBlackBoxModel* endPortParentBox =
				(GBlackBoxModel*) endPort->getParentBox();

		int idNewStartBox = oldIdNewIdBoxes[startPortParentBox->getObjectId()];
		int idNewEndBox = oldIdNewIdBoxes[endPortParentBox->getObjectId()];

		GBlackBoxModel* newStartBox =
				(GBlackBoxModel*) _controllers[idNewStartBox]->getModel();
		GBlackBoxModel* newEndBox =
				(GBlackBoxModel*) _controllers[idNewEndBox]->getModel();

		GPortModel* newStartPort = newStartBox->getOutputPort(startPortIndex);
		GPortModel* newEndPort = newEndBox->getInputPort(endPortIndex);

		// Creates connection
		int idCon = createGConnector(newStartPort);
		GConnectorController *tempp =
				(GConnectorController*) _controllers[idCon];
		GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
		vtkGConnectorView *conView = (vtkGConnectorView*) tempp->getView();
		tempp->endContourCreation();
		conMod->setEndPort(newEndPort);
		conView->updateStartEndPoints();
	}

	std::map<int, int>::iterator itIds;
	for (itIds = oldIdNewIdBoxes.begin(); itIds != oldIdNewIdBoxes.end(); ++itIds) {
		int idOld = itIds->first;
		int idNew = itIds->second;

		GBlackBoxModel* oldBox =
				(GBlackBoxModel*) objectsMap[idOld]->getModel();
		GBlackBoxModel* newBox =
				(GBlackBoxModel*) _controllers[idNew]->getModel();

		std::vector<int> oldInputConnections = oldBox->getConnectedInputs();
		std::vector<int> oldOutputConnections = oldBox->getConnectedOutputs();
		std::vector<int> newInputConnections = newBox->getConnectedInputs();
		std::vector<int> newOutputConnections = newBox->getConnectedOutputs();

		for (int k = 0; k < (int) oldInputConnections.size(); k++) {
			bool exist = false;
			//EED				int toCreate=-1;
			for (int l = 0; l < (int) newInputConnections.size() && !exist; l++) {
				if (oldInputConnections[k] == newInputConnections[l]) {
					exist = true;
				}
			}

			if (exist == false) {
				//Create complex input
				int posInBox = oldInputConnections[k];
				GPortModel* inputPort = oldBox->getInputPort(posInBox);
				std::string inputPortName = inputPort->getBBTKName();
				int idInputPort = createGComplexBoxInputPort(inputPortName);
				GObjectController *cont = _controllers[idInputPort];
				GBoxModel *cbmod = (GBoxModel*) cont->getModel();
				double xIn, yIn, zIn;
				inputPort->getInicPoint(xIn, yIn, zIn);
				yIn += 20;
				cbmod->setInicPoint(xIn, yIn, zIn);
				cbmod->notifyObservers(_idManager);

				GPortModel* inputPortEnd = newBox->getInputPort(posInBox);

				// Creates connection
				int idCon = createGConnector(cbmod->getOutputPort(0));
				GConnectorController *tempp =
						(GConnectorController*) _controllers[idCon];
				GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
				vtkGConnectorView *conView =
						(vtkGConnectorView*) tempp->getView();
				tempp->endContourCreation();
				conMod->setEndPort(inputPortEnd);
				conView->updateStartEndPoints();

			}

		}

		for (int k = 0; k < (int) oldOutputConnections.size(); k++) {
			bool exist = false;
			//EED				int toCreate=-1;
			for (int l = 0; l < (int) newOutputConnections.size() && !exist; l++) {
				if (oldOutputConnections[k] == newOutputConnections[l]) {
					exist = true;
				}
			}

			if (exist == false) {
				//Create complex output
				int posInBox = oldOutputConnections[k];
				GPortModel* outputPort = oldBox->getOutputPort(posInBox);
				std::string outputPortName = outputPort->getBBTKName();
				int idOutputPort = createGComplexBoxOutputPort(outputPortName);
				GObjectController *cont = _controllers[idOutputPort];
				GBoxModel *cbmod = (GBoxModel*) cont->getModel();
				double xIn, yIn, zIn;
				outputPort->getInicPoint(xIn, yIn, zIn);
				yIn -= 20;
				cbmod->setInicPoint(xIn, yIn, zIn);
				cbmod->notifyObservers(_idManager);

				GPortModel* outputPortEnd = newBox->getOutputPort(posInBox);

				// Creates connection
				int idCon = createGConnector(outputPortEnd);
				GConnectorController *tempp =
						(GConnectorController*) _controllers[idCon];
				GConnectorModel *conMod = (GConnectorModel*) tempp->getModel();
				vtkGConnectorView *conView =
						(vtkGConnectorView*) tempp->getView();
				tempp->endContourCreation();
				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

// EOF