/*=========================================================================
                                                                                
Program:   bbtk
Module:    $RCSfile: bbtkComplexBlackBox.cxx,v $
Language:  C++
Date:      $Date: 2008/01/22 15:02:00 $
Version:   $Revision: 1.1.1.1 $
                                                                                
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
http://www.creatis.insa-lyon.fr/Public/bbtk/License.html for details.
                                                                                
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notices for more information.
                                                                               
=========================================================================*/


/**
 *  \file 
 *  \brief class bbtk::ComplexBlackBox : user defined complex black boxes
 */
#include "bbtkComplexBlackBox.h"
#include "bbtkBlackBoxDescriptor.h"
#include "bbtkFactory.h"
#include "bbtkConfigurationFile.h"

namespace bbtk
{


  //=======================================================================
  /// Usefull constructor 
  ComplexBlackBox::ComplexBlackBox(const std::string &name,
				   ComplexBlackBoxDescriptor* desc)
    : BlackBox(name),
      mDescriptor(desc)
  {
    bbtkDebugMessageInc("Core",9,
    			"ComplexBlackBox::ComplexBlackBox(\""
			<<name<<"\")"<<std::endl);
    bbAllocateConnectors();
    bbtkDebugDecTab("Core",9);
  }
  //=======================================================================

  //=======================================================================
  /// Constructor from an existing box (copy) with a new name 
  ComplexBlackBox::ComplexBlackBox(ComplexBlackBox& from, 
				   const std::string &name)
    : BlackBox(from,name),
      mDescriptor(from.mDescriptor),
     mExecutionList(from.mExecutionList)    
  {
    bbtkDebugMessageInc("Core",9,
    			"ComplexBlackBox::ComplexBlackBox(\""
			<<from.bbGetName()<<"\",\""
			<<name<<"\")"<<std::endl);

    bbtkDebugMessageInc("Core",9,"* Cloning Black Boxes"<<std::endl);
    BlackBoxMapType::const_iterator i;
    for ( i = from.mBlackBoxMap.begin(); i != from.mBlackBoxMap.end(); ++i ) 
      {
	bbtkDebugMessageInc("Core",9,"* Cloning \""<<i->first<<"\""<<std::endl);
	BlackBox* B = i->second->bbClone(i->second->bbGetName());
	bbUnsafeAddBlackBox(B);
	
	bbtkDebugDecTab("Core",9);
      }
    bbtkDebugDecTab("Core",9);
   
    bbtkDebugMessageInc("Core",9,"* Cloning Connections"<<std::endl);
    ConnectionListType::const_iterator j;
    for ( j = from.mConnectionList.begin(); j != from.mConnectionList.end(); ++j ) 
      {
	bbtkDebugMessageInc("Core",9,"* Cloning \""<<
			    (*j)->GetFullName()<<"\""<<std::endl);

	BlackBox* bbfrom = bbGetBlackBox( (*j)->GetBlackBoxFrom()->bbGetName() );
	BlackBox* bbto = bbGetBlackBox( (*j)->GetBlackBoxTo()->bbGetName() );
	Connection* c = /*mDescriptor->GetFactory()->Create*/ 
	  NewConnection( bbfrom, 
			 (*j)->GetBlackBoxFromOutput(), 
			 bbto, 
			 (*j)->GetBlackBoxToInput() );
	
	bbAddConnection(c);

	bbtkDebugDecTab("Core",9);
      }
    bbtkDebugDecTab("Core",9);

    bbAllocateConnectors();
    bbtkDebugDecTab("Core",9);    
  }
  //=======================================================================

  //======================================================================= 
  ///  Destructor
  ComplexBlackBox::~ComplexBlackBox()
  {
    bbtkDebugMessageInc("Core",9,
			"ComplexBlackBox::~ComplexBlackBox() ["
			<<bbGetFullName()<<"]"<<std::endl);
    
    bbtkDebugMessageInc("Core",9,"* Delete Connections"<<std::endl);
    ConnectionListType::iterator j;
    for ( j = mConnectionList.begin(); j != mConnectionList.end(); ++j ) 
      {
	bbtkDebugMessageInc("Core",9,"* Delete \""<<
			    (*j)->GetFullName()<<"\""<<std::endl);
	delete *j;
	bbtkDebugDecTab("Core",9);
      }
    bbtkDebugDecTab("Core",9);

    
    bbtkDebugMessageInc("Core",9,"* Delete Black Boxes"<<std::endl);
    BlackBoxMapType::iterator i;
    for ( i = mBlackBoxMap.begin(); i != mBlackBoxMap.end(); ++i ) 
      {
	bbtkDebugMessageInc("Core",9,"* Delete \""<<i->first<<"\""<<std::endl);
	i->second->bbDelete();
	bbtkDebugDecTab("Core",9);
      }
    bbtkDebugDecTab("Core",9);
    //    bbtkDebugMessage("Core",9,"EO ComplexBlackBox::~ComplexBlackBox  ["
    //		     <<bbGetFullName()<<"]"<<std::endl);

    
    this->bbDesallocateConnectors();
    bbtkDebugDecTab("Core",9);   
  } 
  //=======================================================================

  //=========================================================================
  /// Allocates the i/o connectors of the black box
  void ComplexBlackBox::bbAllocateConnectors()
  {  
    bbtkDebugMessageInc("Core",8,
			"ComplexBlackBox::bbAllocateConnectors() ["
			<<bbGetFullName()<<"]"
			<<std::endl);	

    // Input connectors
    const BlackBoxDescriptor::InputDescriptorMapType& imap 
      = bbGetDescriptor()->GetInputDescriptorMap(); 
    BlackBoxDescriptor::InputDescriptorMapType::const_iterator i;	
    for ( i = imap.begin(); i != imap.end(); ++i )			
      {									
	bbtkDebugMessage("Core",8,"* Allocate \""<<i->first<<"\""<<std::endl);
	// Redirect the connector to the internal box connector
	// Cast the BBInputDescriptor into a ComplexBBInputDescriptor
	ComplexBlackBoxInputDescriptor* d = 
	  (ComplexBlackBoxInputDescriptor*)i->second;
	// Get the internal box connector
	BlackBoxInputConnector* c = 
	  bbUnsafeGetBlackBox ( d->GetTarget() )
	  ->bbGetInputConnectorMap()[ d->GetInput() ];
	
	bbGetInputConnectorMap()[i->second->GetName()] = c;
//new BlackBoxInputConnector();
      }									

    // Output connectors
    const BlackBoxDescriptor::OutputDescriptorMapType& omap 
      = bbGetDescriptor()->GetOutputDescriptorMap();		       
    BlackBoxDescriptor::OutputDescriptorMapType::const_iterator o; 
    for ( o = omap.begin(); o != omap.end(); ++o )
      {							
	bbtkDebugMessage("Core",8,"* Allocate \""<<o->first<<"\""<<std::endl);
	// Redirect the connector to the internal box connector
	// Cast the BBOutputDescriptor into a ComplexBBOutputDescriptor
	ComplexBlackBoxOutputDescriptor* d = 
	  (ComplexBlackBoxOutputDescriptor*)o->second;
	// Get the internal box connector
	BlackBoxOutputConnector* c = 
	  bbUnsafeGetBlackBox ( d->GetTarget() )
	  ->bbGetOutputConnectorMap()[ d->GetOutput() ];

	bbGetOutputConnectorMap()[o->second->GetName()] = c;
	//new BlackBoxOutputConnector();
      }
    bbtkDebugDecTab("Core",8);  
  }
  //=========================================================================


  //=========================================================================
  /// Desallocates the i/o connectors of the black box
  void ComplexBlackBox::bbDesallocateConnectors()
  {
    bbtkDebugMessageInc("Core",8,
			"ComplexBlackBox::DesallocateConnectors()"
			<<std::endl);					

    // The connectors have not been allocated by the complex box 
    // but by the internal boxes. Hence **DO NOT** desallocate !
    // just clear the maps to avoid that 
    // BlackBox::bbDesallocateConnectors delete the connectors
    bbGetInputConnectorMap().clear();
    bbGetOutputConnectorMap().clear();

    bbtkDebugDecTab("Core",8);  

  }
  //=========================================================================

  //=======================================================================
  BlackBox* ComplexBlackBox::bbClone(const std::string& name)
  {
    bbtkDebugMessageInc("Core",9,
			"ComplexBlackBox::bbClone(\""<<name<<"\") ["
			<<bbGetFullName()<<"]"<<std::endl);
    
    ComplexBlackBox* CBB = new ComplexBlackBox(*this,name);
    
    bbtkDebugDecTab("Core",9);   

    return CBB;
  }
  //=======================================================================

  //=======================================================================
  /// Main processing method of the box.
  /// Executes the box so that its outputs are up-to-date on exit
  void ComplexBlackBox::bbExecute(bool force)
  {
    bbtkDebugMessageInc("Process",1,
			"ComplexBlackBox::bbExecute() ["
			<<bbGetFullName()<<"]"<<std::endl);

    wx::BeginBusyCursor();
    
    if (mExecutionList.size() != 0) 
      {
	
        std::vector<std::string>::const_iterator i;
        for (i=mExecutionList.begin(); 
	     i!=mExecutionList.end();
	     ++i) 
	  {
	    bbtkDebugMessage("Process",2," -> Executing '"<<*i<<"'"<<std::endl);
	    mBlackBoxMap[*i]->bbExecute(force);
	  }
      }
    else 
      {
	std::map<std::string, BlackBox*>::iterator i;
	for (i=mBlackBoxMap.begin(); i!=mBlackBoxMap.end(); ++i)
	  {
	    i->second->bbExecute(force);
	  }
      } 

    wx::EndBusyCursor();
    
    bbtkDebugDecTab("Process",1);
    
  }
  //==================================================================

  //==================================================================
  void ComplexBlackBox::bbSetModifiedStatus(BlackBoxInputConnector* c)
  {
    bbtkDebugMessage("Process",3,
			"ComplexBlackBox::bbSetModifiedStatus("
		     <<c<<") ["<<bbGetFullName()<<"]"<<std::endl);

    c->GetBlackBox()->bbSetModifiedStatus(c);

    bbtkDebugMessage("Process",3,
		     "EO ComplexBlackBox::bbSetModifiedStatus("
		     <<c<<") ["<<bbGetFullName()<<"]"<<std::endl);
  }
  //==================================================================

  //==================================================================
  void ComplexBlackBox::bbAddToExecutionList( const std::string& name )
  {
        bbtkDebugMessageInc("Core",9,
			"ComplexBlackBox::bbAddToExecutionList(\""
	                <<name<<"\") ["
			<<bbGetFullName()<<"]"<<std::endl);

	mExecutionList.push_back( name );

     bbtkDebugDecTab("Core",9);   

  }
  //==================================================================

  //==================================================================
  IOStatus ComplexBlackBox::bbBackwardUpdate(Connection* caller)
  {
    bbtkDebugMessageInc("Process",1,
			"ComplexBlackBox::bbBackwardUpdate("<<caller->GetFullName()<<") ["
			<<bbGetFullName()<<"]"<<std::endl);

    IOStatus s = UPTODATE;
    const BlackBoxDescriptor::OutputDescriptorMapType& omap 
      = bbGetDescriptor()->GetOutputDescriptorMap(); 
    BlackBoxDescriptor::OutputDescriptorMapType::const_iterator i 
      = omap.find(caller->GetBlackBoxFromOutput());
    if (i!=omap.end())
      {	
	// Cast the BBOutputDescriptor into a ComplexBBOutputDescriptor
	ComplexBlackBoxOutputDescriptor* d = 
	  (ComplexBlackBoxOutputDescriptor*)i->second;
	// Get the internal box 
	BlackBox* b = bbUnsafeGetBlackBox ( d->GetTarget() );
	// Calls BackwardUpdate on it
	bbtkDebugMessageInc("Process",2,"Internal box connected to output : "<<d->GetTarget()<<std::endl);
	IOStatus s1 = b->bbBackwardUpdate(caller);
	// ??? STATUS OF CBBs ???
	// ??? Here it is only the final status of the boxes connected to the output 
	if (s1==MODIFIED) s=MODIFIED;
	bbtkDebugDecTab("Process",2);
      }
    else 
      {
	bbtkError("Connection '"<<caller->GetFullName()<<"' does not point to a valid output of the complex box !");
      }
    bbtkDebugDecTab("Process",1);
    return s;
  }
  //==================================================================
  
  /*
  //==================================================================
  void ComplexBlackBox::bbForwardUpdate(Connection* caller)
  { 
    bbtkDebugMessageInc("Process",1,
			"ComplexBlackBox::bbForwardUpdate("<<caller->GetFullName()<<") ["
			<<bbGetFullName()<<"]"<<std::endl);

    const BlackBoxDescriptor::InputDescriptorMapType& imap 
      = bbGetDescriptor()->GetInputDescriptorMap(); 
    BlackBoxDescriptor::InputDescriptorMapType::const_iterator i 
      = imap.find(caller->GetBlackBoxToInput());
    if (i!=imap.end())
      {	
	// Cast the BBOutputDescriptor into a ComplexBBOutputDescriptor
	ComplexBlackBoxInputDescriptor* d = 
	  (ComplexBlackBoxInputDescriptor*)i->second;
	// Get the internal box 
	BlackBox* b = bbUnsafeGetBlackBox ( d->GetTarget() );
	// Calls ForwardUpdate on it
	bbtkDebugMessage("Process",2,"-> Internal box connected to input : "<<d->GetTarget()<<std::endl);
	b->bbForwardUpdate(caller);
      }
    else 
      {
	bbtkError("Connection '"<<caller->GetFullName()<<"' does not point to a valid input of the complex box !");
      }
    bbtkDebugDecTab("Process",1);
  }
  //==================================================================
  */


  //==================================================================
  Data ComplexBlackBox::bbGetOutput( const std::string &name )
  {
    bbtkDebugMessageInc("Data",7,
			"ComplexBlackBox::bbGetOutput(\""<<name<<"\") ["
			<<bbGetFullName()<<"]"<<std::endl);

    ComplexBlackBoxOutputDescriptor* d = 
      (ComplexBlackBoxOutputDescriptor*)
      bbGetDescriptor()->GetOutputDescriptor(name);
    
    Data p = bbGetBlackBox(d->GetTarget())->bbGetOutput(d->GetOutput());


    bbtkDebugDecTab("Data",7);
    return p;
  }
  //==================================================================

  //==================================================================
  ///  Gets the input Data of a given name
  Data ComplexBlackBox::bbGetInput( const std::string &name ) 
  {
    bbtkDebugMessageInc("Data",7,
			"ComplexBlackBox::bbGetInput(\""<<name<<"\") ["
			<<bbGetFullName()<<"]"<<std::endl);  

    ComplexBlackBoxInputDescriptor* d = 
      (ComplexBlackBoxInputDescriptor*)
      bbGetDescriptor()->GetInputDescriptor(name);

    Data p = bbGetBlackBox(d->GetTarget())->bbGetInput(d->GetInput());

    bbtkDebugDecTab("Data",7);
    return p;
  }
  //==================================================================

  //==================================================================
  ///  Sets the data of the output called <name>
  void ComplexBlackBox::bbSetOutput( const std::string &name, Data data)
  {
    bbtkDebugMessageInc("Data",7,
			"ComplexBlackBox::bbSetOutput(\""<<name<<"\",data) ["
			<<bbGetFullName()<<"]"<<std::endl); 

    ComplexBlackBoxOutputDescriptor* d = 
      (ComplexBlackBoxOutputDescriptor*)
      bbGetDescriptor()->GetOutputDescriptor(name);
    
    bbGetBlackBox(d->GetTarget())->bbSetOutput(d->GetOutput(),data);

    bbtkDebugDecTab("Data",7);
  }
  //==================================================================
  
  //==================================================================
  ///  Sets the data of the input called <name>
  void ComplexBlackBox::bbSetInput( const std::string &name, Data data,
				    bool setModified)
  {
    bbtkDebugMessageInc("Data",7,
			"ComplexBlackBox::bbSetInput(\""<<name<<"\",data) ["
			<<bbGetFullName()<<"]"<<std::endl);  

    ComplexBlackBoxInputDescriptor* d = (ComplexBlackBoxInputDescriptor*)
      bbGetDescriptor()->GetInputDescriptor(name);

    bbGetBlackBox(d->GetTarget())->bbSetInput(d->GetInput(),data,setModified);

    bbtkDebugDecTab("Data",7);
  }
  //==================================================================

 
  //==================================================================
  ///  Sets the data of the input called <name>
  void ComplexBlackBox::bbBruteForceSetInputPointer( const std::string &name, 
						     void* data,
						     bool setModified)
  {
    bbtkDebugMessageInc("Data",7,
			"ComplexBlackBox::bbBruteForceSetInputPointer('"
			<<name<<"',"<<data<<") ["
			<<bbGetFullName()<<"]"<<std::endl);  

    ComplexBlackBoxInputDescriptor* d = (ComplexBlackBoxInputDescriptor*)
      bbGetDescriptor()->GetInputDescriptor(name);

    bbGetBlackBox(d->GetTarget())->bbBruteForceSetInputPointer(d->GetInput(),
							       data,
							       setModified);

    bbtkDebugDecTab("Data",7);
  }
  //==================================================================

  //==================================================================
  /// Adds the black box to the complex box
  void ComplexBlackBox::bbAddBlackBox( BlackBox* b)
  {
    bbtkDebugMessageInc("Core",7,
			"ComplexBlackBox::AddBlackBox(\""<<b->bbGetName()
			<<"\") ["
			<<bbGetFullName()<<"]"<<std::endl);  
    
    if ( bbUnsafeGetBlackBox(b->bbGetName()) ) 
      {
	bbtkError("a black box called \""<<b->bbGetName()
		  <<"\" already exists");
      }
    b->bbSetParent(this);
    mBlackBoxMap[b->bbGetName()] = b;

    bbtkDebugDecTab("Core",7);
  }
  //==================================================================

  //==================================================================
  /// Adds the black box to the complex box (unsafe)
  void ComplexBlackBox::bbUnsafeAddBlackBox( BlackBox* b)
  {
    bbtkDebugMessageInc("Core",7,
			"ComplexBlackBox::UnsafeAddBlackBox(\""<<b->bbGetName()
			<<"\") ["
			<<bbGetFullName()<<"]"<<std::endl);  
    
    b->bbSetParent(this);
    mBlackBoxMap[b->bbGetName()] = b;

    bbtkDebugDecTab("Core",7);
  }
  //==================================================================

  //==================================================================
  /// Removes the black box from the complex box
  void ComplexBlackBox::bbRemoveBlackBox( const std::string& name )
  {
    bbtkDebugMessageInc("Core",7,
			"ComplexBlackBox::RemoveBlackBox(\""<<name<<"\") ["
			<<bbGetFullName()<<"]"<<std::endl);  

    bbtkError("ComplexBlackBox::RemoveBlackBox not implemented");

    bbtkDebugDecTab("Core",7);
  }
  //==================================================================

  //==================================================================
  /// Adds the connection to the complex box
  void ComplexBlackBox::bbAddConnection( Connection* c)
  {
    bbtkDebugMessageInc("Core",7,
			"ComplexBlackBox::AddConnection(\""<<"..."<<"\") ["
			<<bbGetFullName()<<"]"<<std::endl);  

    mConnectionList.push_back(c);

    bbtkDebugDecTab("Core",7);
  }
  //==================================================================
  //    void RemoveConnection( );

  //==================================================================
  /// Returns the black box with name <name>
  BlackBox* ComplexBlackBox::bbGetBlackBox( const std::string& name )
  {
    bbtkDebugMessageInc("Core",9,
			"ComplexBlackBox::GetBlackBox(\""<<name<<"\") ["
			<<bbGetFullName()<<"]"<<std::endl);  

    BlackBoxMapType::iterator i = mBlackBoxMap.find(name);
    if ( i == mBlackBoxMap.end() ) 
      {
	bbtkError("the black box \""<<name<<"\" does not exist");
      }

    bbtkDebugDecTab("Core",9);
    return i->second;
  }
  //==================================================================

  //==================================================================
  /// Returns the black box with name <name> : does not throw an exception 
  /// if it does not exist but return a null pointer
  BlackBox* ComplexBlackBox::bbUnsafeGetBlackBox( const std::string& name )
  {
    bbtkDebugMessageInc("Core",9,
			"ComplexBlackBox::UnsafeGetBlackBox(\""<<name<<"\") ["
			<<bbGetFullName()<<"]"
			<<std::endl);  

    BlackBoxMapType::iterator i = mBlackBoxMap.find(name);
    if ( i == mBlackBoxMap.end() ) 
      {
	bbtkDebugDecTab("Core",9);
	return 0;
      }

    bbtkDebugDecTab("Core",9);
    return i->second;
    
  }
  //==================================================================

  //==================================================================
  void ComplexBlackBox::bbPrintBlackBoxes()
  {
    bbtkDebugMessageInc("Core",9,
			"ComplexBlackBox::PrintBlackBoxes() ["
			<<bbGetFullName()<<"]"
			<<std::endl);  

    BlackBoxMapType::iterator i;
    for ( i = mBlackBoxMap.begin(); i != mBlackBoxMap.end(); ++i ) 
      {
	bbtkMessage("Help",1,i->second->bbGetFullName()<<std::endl);
      }

    bbtkDebugDecTab("Core",9);
  }
  //==================================================================


 
  //=========================================================================
  /// Virtual
  void ComplexBlackBox::bbWriteDotInputOutputName(FILE *ff,bool inputoutput,int detail, int level)
  {
    if (inputoutput)
      {
	fprintf(ff,"%s_IN_%p",bbGetTypeName().c_str(),this);
      } else {
      fprintf(ff,"%s_OUT_%p",bbGetTypeName().c_str(),this);
    } // if inputoutput
  }
  //=========================================================================


  //=========================================================================
  BlackBox *ComplexBlackBox::bbFindBlackBox(const std::string &blackboxname)
  {
    BlackBox *blackbox=NULL;
    std::string subname="";
    std::string restname="";
    std::string delimiters(">");
    // Skip delimiters at beginning.
    std::string::size_type lastPos = blackboxname.find_first_not_of(delimiters, 0);
    // Find first "non-delimiter".
    std::string::size_type pos     = blackboxname.find_first_of(delimiters, lastPos);
	    
    // Found a token, add it to the vector.
    subname = blackboxname.substr(lastPos, pos - lastPos);
    restname = blackboxname.substr(lastPos+pos - lastPos+1, 999);

    if (restname==subname)
      {
	restname="";
      }

    BlackBoxMapType::iterator i = mBlackBoxMap.find(subname);
    if ( i == mBlackBoxMap.end() ) 
      {
	blackbox = NULL;
      } else {
      blackbox = i->second;
      if (restname!="")
	{
	  blackbox = blackbox->bbFindBlackBox(restname);
	}
    }
    return blackbox;
  }
  //=========================================================================

  //=========================================================================
  void ComplexBlackBox::bbInsertHTMLGraph(  std::ofstream& s, 
					    int detail, 
					    int level,
					    bool instanceOrtype,
					    const std::string& output_dir,
					    bool relative_link )
  {
    
    std::string directory(output_dir);

    if (output_dir.length() == 0) 
      {
	// Don't pollute the file store with  "doc_tmp" directories ... 
	std::string default_doc_dir = ConfigurationFile::GetInstance().Get_default_doc_tmp();
	directory =  default_doc_dir + "/" + "doc_tmp";
      }
    
    std::string simplefilename  (this->bbGetTypeName()+"_"+this->bbGetName());
    std::string simplefilename_png (simplefilename+".png");
    std::string filename           (directory+"/"+simplefilename);
    std::string filename_png       (filename+".png");
    std::string filename_cmap      (filename+".cmap");
    std::string filename_dot       (filename+".dot");

    std::string filename_png2	("\""	+ filename_png	+ "\"");
    std::string filename_cmap2	("\""	+ filename_cmap	+ "\"");
    std::string filename_dot2	("\""	+ filename_dot	+ "\"");
    

    std::string command1 ("dot -T png -o "  
			  + filename_png2  + " " + filename_dot2);
    std::string command1a("dot -T cmap -o " 
			  + filename_cmap2 + " " + filename_dot2);

    // 1. Generating .dot file
    FILE *ff;
    ff = fopen(filename_dot.c_str(),"w");
    fprintf(ff,"digraph bbtk_graph{\n");
    fprintf(ff,"rankdir=LR%s\n",";");
    fprintf(ff,"node [shape=record]%s\n",";");

    this->bbWriteDotFileBlackBox(ff,this,detail,level,
				 instanceOrtype,
				 relative_link );

    fprintf(ff,"}\n");
    fclose(ff);

    // 2. Executing .dot file -> png
    system( command1.c_str() );   
    // 3. Executing .dot file -> cmap
    system( command1a.c_str() );  
    
    // 4. HTML code insertion
    // 4.1 image
    (s) << "<center><img src=\"" << simplefilename_png 
	 <<   "\" border=\"0\" usemap=\"#map_"<< simplefilename 
	 <<"\" alt=\"\"></center>\n";

    // 4.2 map
    (s) << "<map name=\"map_"<< simplefilename <<"\">\n";
    FILE *ff2;
    char c;
    ff2=fopen(filename_cmap.c_str(),"r");
    while (!feof(ff2))
      {
	c=fgetc(ff2);
	if (c!=-1)
	  {
	    (s) << c;
	  }
      }
    (s) << "</map>\n\n";
    
    // End
  }
  //=========================================================================


  //=========================================================================
  /// Write Graphviz-dot description in file 
  void ComplexBlackBox::bbWriteDotFileBlackBox(FILE *ff,
					       BlackBox *parentblackbox, 
					       int detail, int level,
					       bool instanceOrtype,
					       bool relative_link )   
  {
    std::string tmp1;
    std::string valueStr("");
    Package *package = this->bbGetDescriptor()->GetPackage(); 

    if (package!=NULL)
      {
	if (relative_link)
	  tmp1 = this->bbGetDescriptor()->GetPackage()->GetDocRelativeURL();
	else 
	  tmp1 = this->bbGetDescriptor()->GetPackage()->GetDocURL();
      } 
    else 
      {
	tmp1 = "Caspitas";
      }

    std::string tmp2=bbGetTypeName();
    std::string url(tmp1 + "#" + tmp2 );	
    fprintf( ff , "subgraph cluster_%s_%p {\n",bbGetName().c_str(),this);

    if (!(   (bbGetTypeName()=="workspace") && (bbGetName()=="workspacePrototype")) )
      {
	fprintf( ff , "  URL = \"%s\" %s",url.c_str(),";");
      }

    std::string boxname="["+bbGetTypeName()+"]";
    if (this!=parentblackbox)
      {
	if (detail==0)
	  {
	    boxname=bbGetName();
	  } else {
	  boxname = bbGetName();
	  boxname = boxname + "   [" +this->bbGetDescriptor()->GetPackage()->GetName()+"::"+ bbGetTypeName() + "]";
	}

      }
    fprintf( ff , "  label = \"%s\"%s\n",  boxname.c_str() ,";");



    //	fprintf( ff , "  style=filled%s\n",";");
    //	fprintf( ff , "  color=grey%s\n",";");
    fprintf( ff , "  node [style=filled]%s\n",";");
    fprintf( ff , "  fillcolor=grey%s\n",";");
    fprintf( ff , "  edge [color=blue]%s\n",";");


    // Labels Salida
    std::string labelStr1;
    std::string labelStr2;
    labelStr1 = boxname + "\\n(output)" ; 
    labelStr2 = " | {{ ";
    bool tmp; 
    tmp=false;
    OutputConnectorMapType::iterator i;

    const BlackBoxDescriptor::OutputDescriptorMapType& omap = this->bbGetDescriptor()->GetOutputDescriptorMap();
    BlackBoxDescriptor::OutputDescriptorMapType::const_iterator o;	
    for ( o = omap.begin();  o != omap.end(); ++o ) 
      {
	if (tmp==true)
	  {
	    labelStr2=labelStr2+" | ";
	  }
	tmp=true;
	if (instanceOrtype==true)
	  {
	    valueStr = this->bbGetOutputAsString(o->second->GetName()/*
								   ,factory*/) + " = ";
	  } 
	labelStr2=labelStr2+"<"+o->second->GetName().c_str()+"> " + valueStr + o->second->GetName().c_str();
      }

    labelStr2 = labelStr2+ " } }";



    if (detail==1)
      {
	labelStr1 = labelStr1 + labelStr2;
      }

    if (tmp){
      fprintf(ff,"  " );
      bbWriteDotInputOutputName(ff,false,detail,level);
      fprintf( ff , " [shape=record, style=filled,fillcolor=grey,color=red,label=\"%s\"]%s\n",labelStr1.c_str(),";" );
    }


    // label Entrada
    labelStr1 = boxname + "\\n(input)" ; 
    labelStr2 = " | {{ "; 
    tmp=false;
    InputConnectorMapType::iterator ii;

    const BlackBoxDescriptor::InputDescriptorMapType& imap = this->bbGetDescriptor()->GetInputDescriptorMap();	
    BlackBoxDescriptor::InputDescriptorMapType::const_iterator iii;
    for ( iii = imap.begin();  iii != imap.end(); ++iii ) 
      {
	if (tmp==true)
	  {
	    labelStr2=labelStr2+" | ";
	  }
	tmp=true;
	if (instanceOrtype==true)
	  {
	    valueStr = this->bbGetInputAsString(iii->second->GetName()/*,factory*/) + " = ";
	  } 
	labelStr2=labelStr2+"<"+iii->second->GetName().c_str()+"> " + valueStr + iii->second->GetName().c_str();
      }


    labelStr2 = labelStr2+ " } }";
    if (detail==1)
      {
	labelStr1 = labelStr1 + labelStr2;
      }
    if (tmp){
      fprintf(ff,"  " );
      bbWriteDotInputOutputName(ff,true,detail,level);
      fprintf( ff , " [shape=record, style=filled,fillcolor=grey,color=red,label=\"%s\"]%s\n",labelStr1.c_str(),";" );
    }


    // Body
    BlackBoxMapType::iterator j;
    for ( j = mBlackBoxMap.begin(); j != mBlackBoxMap.end(); ++j ) 
      {
	if (level>-1)
	  {
	    j->second->bbWriteDotFileBlackBox(ff,parentblackbox,detail,
					      level-1,
					      instanceOrtype,
					      relative_link);
	  }
      }

    fprintf( ff , "}\n\n");

    fprintf( ff , "  edge[color=blue]%s\n",";");

    if (level>-1)
      {
	// Relation Input  with the inside BlackBox of the this ComplexBlackbox
	ComplexBlackBoxDescriptor::InputDescriptorMapType::iterator xx;
	ComplexBlackBoxDescriptor::InputDescriptorMapType idmt=bbGetDescriptor()->GetInputDescriptorMap();
	for ( xx = idmt.begin(); xx != idmt.end(); ++xx ) 
	  {
	    ComplexBlackBoxInputDescriptor *cbbid = (ComplexBlackBoxInputDescriptor*)xx->second;

	    fprintf(ff,"  ");
	    bbWriteDotInputOutputName(ff,true,detail,level);
	    if (detail==1)
	      {
		fprintf(ff,":%s",cbbid->GetName().c_str() );
	      }
	    fprintf(ff,"->" );
	    BlackBox *bb = bbGetBlackBox( cbbid->GetTarget() ); 
	    bb->bbWriteDotInputOutputName(ff,true,detail,level);
	    if (detail==1)
	      {
		fprintf(ff,":%s \n", cbbid->GetInput().c_str() );
	      }
	  }// for xx



	fprintf(ff,"\n \n");



	// Relation Output ComplexBlackBox
	ComplexBlackBoxDescriptor::OutputDescriptorMapType::iterator yy;
	ComplexBlackBoxDescriptor::OutputDescriptorMapType odmt=bbGetDescriptor()->GetOutputDescriptorMap();
	for ( yy = odmt.begin(); yy != odmt.end(); ++yy ) 
	  {
	    ComplexBlackBoxOutputDescriptor *cbbod = (ComplexBlackBoxOutputDescriptor*)yy->second;
	    fprintf(ff,"  ");
	    BlackBox *bb = bbGetBlackBox( cbbod->GetTarget() ); 
	    bb->bbWriteDotInputOutputName(ff,false,detail,level);
	    if (detail==1)
	      {
		fprintf(ff,":%s", cbbod->GetOutput().c_str() );
	      }
	    fprintf(ff,"->" );
	    bbWriteDotInputOutputName(ff,false,detail,level);
	    if (detail==1)
	      {
		fprintf(ff,":%s",cbbod->GetName().c_str() );
	      }
	    fprintf(ff,"\n");
	  } // for yy

      } // if level



	// Relation from the out side of this ComplexBlackBox with its Inputs
    if (this!=parentblackbox) {
      for ( ii = bbGetInputConnectorMap().begin(); 
	    ii != bbGetInputConnectorMap().end(); ++ii ) 
	{
	  if (ii->second)
	    {
	      Connection* con = ii->second->GetConnection();
	      if (con!=NULL){
		BlackBox *a=con->GetBlackBoxFrom();
		BlackBox *b=con->GetBlackBoxTo();
		fprintf(ff,"  ");
		a->bbWriteDotInputOutputName(ff,false,detail,level);
		if (detail==1)
		  {
		    fprintf(ff,":%s",con->GetBlackBoxFromOutput().c_str());
		  }
		fprintf(ff,"->");
		b->bbWriteDotInputOutputName(ff,true,detail,level);
		if (detail==1)
		  {
		    fprintf(ff,":%s",con->GetBlackBoxToInput().c_str());
		  }
		fprintf(ff,"%s\n",";");
	      } // if con
	    } // if second
	} // for
    } // if parentblackbox

  }
  //=========================================================================

  /*


  //=======================================================================
  /// Generates the list of the packages of which its depends 
  /// (cause an internal box belongs to it)
  void ComplexBlackBox::GetPackagesDependencies(std::vector<Package*>& deps)
  {
    deps.clear;
    BlackBoxMapType::iterator i;
    for ( i = mBlackBoxMap.begin(); i != mBlackBoxMap.end(); ++i ) 
      {
	deps.push_back(i->second->bbGetDescriptor()->GetPackage());
      }

  }
  //=======================================================================
  */
}