/*=========================================================================
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)
	{
		_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()
	{
		printf ("EED %p ~wxVtkSceneManager()\n" , this );
		disconnectDrop();
	}

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

	void wxVtkSceneManager::configureBaseView()
	{
		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 );
	}

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

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

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

			// 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::string cbName,std::string cbAuthor,std::string cbCategory,std::string cbDescription)
	{

		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;
		script+="\n";
		script+="\n";

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

		script+="description \" ";
		script+=cbDescription;
		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];

		//Print info IF COMPLEX BOX
		content+="COMPLEXBOX:";
		if(_isComplexBox)
		{
			content+="TRUE\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;
		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);
					printf("EED wxVtkSceneManager::loadDiagram  version=%s\n",version.c_str());
				}

			}
			else if(line=="APP_START")
			{
				start = true;
				break;
			}
		}

		if(start)
		{

			//----------
			getline(inputStream,line);//COMPLEX_BOX:TRUE|FALSE
			char complex[30];
			strcpy( complex, line.c_str() );
			result = strtok( complex, delims );
			result = strtok( NULL, delims );
			std::string isComplexBox(result);

			if(isComplexBox=="TRUE")
			{
				_isComplexBox=true;

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

				}

			}

		}


	}

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

}  // EO namespace bbtk

// EOF