started VHDL generation of GroupBlock

[blast.git] / Dispatcher.cpp

diff --git a/Dispatcher.cpp b/Dispatcher.cpp
index e7846b4545b9f2f2febed7b4ca57fdb4b3bc5e50..c3ff33fd91b713078ff111e3ec9e2389b630477c 100644 (file)
--- a/Dispatcher.cpp
+++ b/Dispatcher.cpp
@@ -23,6 +23,10 @@
 #include "BlockLibraryWidget.h"
 #include "BlockLibraryTree.h"
 
 #include "BlockLibraryWidget.h"
 #include "BlockLibraryTree.h"
 

+#include "AbstractInputModifier.h"
+#include "DelayInputModifier.h"
+
+

 #include "InterfacePropertiesWindow.h"
 
 int Dispatcher::sceneCounter = 0;
 #include "InterfacePropertiesWindow.h"
 
 int Dispatcher::sceneCounter = 0;


@@ -65,6 +69,9 @@ GroupWidget *Dispatcher::loadProject(const QString& filename) {
     return NULL;
   }
 
     return NULL;
   }
 

+  QFileInfo info(filename);
+  params->projectPath = info.absolutePath();
+  cout << "project path = " << qPrintable(params->projectPath) << endl;

   groupList.append(topGroup);
   return topGroup;
 }
   groupList.append(topGroup);
   return topGroup;
 }


@@ -81,12 +88,10 @@ void Dispatcher::closeCurrentProject() {
   sceneCounter = 0;
 }
 
   sceneCounter = 0;
 }
 

-bool Dispatcher::createConnectionItem(InterfaceItem *iface1, InterfaceItem *iface2) {
+bool Dispatcher::createConnection(InterfaceItem *iface1, InterfaceItem *iface2, bool visible) {

     
   ConnectedInterface* ref1 = iface1->refInter;
     
   ConnectedInterface* ref1 = iface1->refInter;

-  ConnectedInterface* ref2 = iface2->refInter;
-  ConnectedInterface* asso1 = iface1->refInter->getAssociatedIface();
-  ConnectedInterface* asso2 = iface2->refInter->getAssociatedIface();
+  ConnectedInterface* ref2 = iface2->refInter;  

   // connect both interface
 
   bool ok1 = false;
   // connect both interface
 
   bool ok1 = false;


@@ -94,30 +99,21 @@ bool Dispatcher::createConnectionItem(InterfaceItem *iface1, InterfaceItem *ifac
 
   // test the ref1->ref2 connection
   if ((ref1->canConnectTo(ref2)) && (ref2->canConnectFrom(ref1))) {
 
   // test the ref1->ref2 connection
   if ((ref1->canConnectTo(ref2)) && (ref2->canConnectFrom(ref1))) {

-    ref1->connectTo(ref2);
-    ref2->connectFrom(ref1);
-    if ((asso1 != NULL) && (asso2 != NULL)) {
-      asso1->connectTo(asso2);
-      asso2->connectFrom(asso1);
-    }
+    ref1->connectTo(ref2);    

     ok1 = true;
   }
   // if the frist one did not work, test ref2->ref1
   if ((ok1 == false) && (ref2->canConnectTo(ref1)) && (ref1->canConnectFrom(ref2))) {  
     ok1 = true;
   }
   // if the frist one did not work, test ref2->ref1
   if ((ok1 == false) && (ref2->canConnectTo(ref1)) && (ref1->canConnectFrom(ref2))) {  

-    ref2->connectTo(ref1);
-    ref1->connectFrom(ref2);
-    if ((asso1 != NULL) && (asso2 != NULL)) {
-      asso1->connectFrom(asso2);
-      asso2->connectTo(asso1);
-    }
+    ref2->connectTo(ref1);    

     ok2 = true;
   }
   if ((ok1 == true) || (ok2 == true)) {
 
     ok2 = true;
   }
   if ((ok1 == true) || (ok2 == true)) {
 

-    iface1->getOwner()->getScene()->createConnectionItem(iface1,iface2);
+    iface1->getOwner()->getScene()->createConnectionItem(iface1,iface2, visible);

 
     unselectAllItems();
     params->unsaveModif = true;
 
     unselectAllItems();
     params->unsaveModif = true;

+    cout << "created a connection from " << qPrintable(ref1->getName()) << " to " << qPrintable(ref2->getName()) << endl;

     return true;
   }
   return false;
     return true;
   }
   return false;


@@ -178,6 +174,23 @@ void Dispatcher::changeConnectionMode(int mode){
   */
 }
 
   */
 }
 

+void Dispatcher::generateBlockVHDL(BoxItem *item){
+  static QString fctName = "Dispatcher::generateBlockVHDL()";
+#ifdef DEBUG_FCTNAME
+  cout << "call to " << qPrintable(fctName) << endl;
+#endif
+
+  if (item->getRefBlock()->isFunctionalBlock()) {
+    FunctionalBlock* block = AB_TO_FUN(item->getRefBlock());
+    try {
+      block->generateVHDL(params->projectPath);      
+    }
+    catch(Exception e) {
+      cout << qPrintable(e.getMessage()) << endl;
+    }
+  }
+}
+

 void Dispatcher::renameFunctionalBlock(BoxItem *item){
   static QString fctName = "Dispatcher::renameFunctionalBlock()";
 #ifdef DEBUG_FCTNAME
 void Dispatcher::renameFunctionalBlock(BoxItem *item){
   static QString fctName = "Dispatcher::renameFunctionalBlock()";
 #ifdef DEBUG_FCTNAME


@@ -347,6 +360,82 @@ void Dispatcher::renameInterface(InterfaceItem *item) {
   item->getOwner()->nameChanged();  
 }
 
   item->getOwner()->nameChanged();  
 }
 

+void Dispatcher::showPatterns(InterfaceItem *item) {
+  static QString fctName = "Dispatcher::showPatterns()";
+#ifdef DEBUG_FCTNAME
+  cout << "call to " << qPrintable(fctName) << endl;
+#endif
+  QString msg = "";
+  if (item->refInter->getDirection() == AbstractInterface::Input) {
+    msg = "Input pattern of iface ";
+    msg += item->refInter->getName();
+    msg += " owned by ";
+    msg += item->refInter->getOwner()->getName();
+    msg += " is:\n";
+    // get the precursor output pattern
+    ConnectedInterface* connIface = AI_TO_CON(item->refInter->getAssociatedIface());
+    QList<char>* out = connIface->getConnectedFrom()->getOutputPattern();
+    // get the modifier
+    AbstractInputModifier* modifier = connIface->getInputModifier();
+    // check if the input is modified
+    if (modifier != NULL) {
+
+      out = modifier->getModifiedInput(out);
+    }
+
+    foreach(char c, *out) {
+      msg += QString::number((int)c);
+    }
+    msg += "\n";
+  }
+  else if (item->refInter->getDirection() == AbstractInterface::Output) {
+    msg = "Output pattern of iface ";
+    msg += item->refInter->getName();
+    msg += " owned by ";
+    msg += item->refInter->getOwner()->getName();
+    msg += " is:\n";
+    ConnectedInterface* iface = AI_TO_CON(item->refInter->getAssociatedIface());
+    if (iface->getOutputPattern() == NULL) return;
+    foreach(char c, *(iface->getOutputPattern())) {
+      msg += QString::number((int)c);
+    }
+    msg += "\n";
+  }
+  QMessageBox::information(NULL,"Interface pattern",msg,QMessageBox::Ok,QMessageBox::Ok);
+}
+
+void Dispatcher::showModifier(InterfaceItem *item) {
+  static QString fctName = "Dispatcher::showModifier()";
+#ifdef DEBUG_FCTNAME
+  cout << "call to " << qPrintable(fctName) << endl;
+#endif
+  QString msg = "";
+  ConnectedInterface* assoIface = AI_TO_CON(item->refInter->getAssociatedIface());
+  AbstractInputModifier* mod = assoIface->getInputModifier();
+  if (mod->isDelay()) {
+    DelayInputModifier* delay = (DelayInputModifier *)mod;
+    msg = "Pattern of iface ";
+    msg += item->refInter->getName();
+    msg += " owned by ";
+    msg += item->refInter->getOwner()->getName();
+    msg += " is modified by a simple delay of ";
+    msg += QString::number(delay->getDelayLength());
+
+  }
+  QMessageBox::information(NULL,"Interface pattern",msg,QMessageBox::Ok,QMessageBox::Ok);
+}
+
+void Dispatcher::removeModifier(InterfaceItem *item) {
+  static QString fctName = "Dispatcher::showModifier()";
+#ifdef DEBUG_FCTNAME
+  cout << "call to " << qPrintable(fctName) << endl;
+#endif
+
+  ConnectedInterface* assoIface = AI_TO_CON(item->refInter->getAssociatedIface());
+  assoIface->clearInputModifier();
+}
+
+

 void Dispatcher::duplicateBoxItem(BoxItem *item){
   static QString fctName = "Dispatcher::duplicateBoxItem()";
 #ifdef DEBUG_FCTNAME
 void Dispatcher::duplicateBoxItem(BoxItem *item){
   static QString fctName = "Dispatcher::duplicateBoxItem()";
 #ifdef DEBUG_FCTNAME


@@ -415,12 +504,12 @@ void Dispatcher::duplicateInterfaceItem(InterfaceItem *item) {
   refB->addInterface(cloneIface);
 
   InterfaceItem *cloneIfaceItem = new InterfaceItem(item->getPosition(),item->getOrientation(),(ConnectedInterface*)cloneIface,item->getOwner(),params);
   refB->addInterface(cloneIface);
 
   InterfaceItem *cloneIfaceItem = new InterfaceItem(item->getPosition(),item->getOrientation(),(ConnectedInterface*)cloneIface,item->getOwner(),params);

-  item->getOwner()->addInterface(cloneIfaceItem,true);
+  item->getOwner()->addInterfaceItem(cloneIfaceItem,true);

   
   // creating control interface if needed
   if (refI->getAssociatedIface() != NULL) {
     QString ctlName = cloneIface->getName()+"_enb";
   
   // creating control interface if needed
   if (refI->getAssociatedIface() != NULL) {
     QString ctlName = cloneIface->getName()+"_enb";

-    ReferenceInterface* ctlIface = new ReferenceInterface(refB,ctlName,"boolean","1",cloneIface->getDirection(), AbstractInterface::Control, 1);
+    ReferenceInterface* ctlIface = new ReferenceInterface(refB,ctlName,cloneIface->getDirection(), AbstractInterface::Control,"boolean","1", AbstractInterface::LittleEndian, 1);

     refB->addInterface(ctlIface);
     if (! ctlIface->setAssociatedIface(cloneIface)) {
       cerr << "Abnormal case while cloning an interface and creating its associated control interface" << endl;
     refB->addInterface(ctlIface);
     if (! ctlIface->setAssociatedIface(cloneIface)) {
       cerr << "Abnormal case while cloning an interface and creating its associated control interface" << endl;


@@ -429,16 +518,17 @@ void Dispatcher::duplicateInterfaceItem(InterfaceItem *item) {
 }
 
 
 }
 
 

-void Dispatcher::addBlock(int idCategory, int idBlock, int idScene) {
+BoxItem* Dispatcher::addBlock(int idCategory, int idBlock, int idScene) {

   static QString fctName = "Dispatcher::addBlock()";
 #ifdef DEBUG_FCTNAME
   cout << "call to " << qPrintable(fctName) << endl;
 #endif
   bool newSource = false;
   static QString fctName = "Dispatcher::addBlock()";
 #ifdef DEBUG_FCTNAME
   cout << "call to " << qPrintable(fctName) << endl;
 #endif
   bool newSource = false;

+  BoxItem* item = NULL;

   GroupScene *scene = getSceneById(idScene);
   ReferenceBlock* ref = params->getReferenceBlock(idCategory,idBlock);
   // if block has no inputs, propose to add it as a source to top scene
   GroupScene *scene = getSceneById(idScene);
   ReferenceBlock* ref = params->getReferenceBlock(idCategory,idBlock);
   // if block has no inputs, propose to add it as a source to top scene

-  if ((scene->isTopScene()) && (ref->getDataInputs().isEmpty())) {
+  if ((scene->isTopScene()) && (ref->isGeneratorBlock())) {

     int ret = QMessageBox::question(NULL,"Adding a block to top scene","Selected block may be used as a source for the top scene. Do you want to add it as a source ?");
     if (ret == QMessageBox::Yes) {
       newSource = true;      
     int ret = QMessageBox::question(NULL,"Adding a block to top scene","Selected block may be used as a source for the top scene. Do you want to add it as a source ?");
     if (ret == QMessageBox::Yes) {
       newSource = true;      


@@ -451,9 +541,11 @@ void Dispatcher::addBlock(int idCategory, int idBlock, int idScene) {
   else {
     GroupBlock* group = AB_TO_GRP(scene->getGroupItem()->getRefBlock());
     FunctionalBlock* newOne = params->getGraph()->createFunctionalBlock(group, ref);
   else {
     GroupBlock* group = AB_TO_GRP(scene->getGroupItem()->getRefBlock());
     FunctionalBlock* newOne = params->getGraph()->createFunctionalBlock(group, ref);

-    scene->createBoxItem(newOne);
+    item = scene->createBoxItem(newOne);
+    params->blockToItem.insert(newOne,item);

   }
   params->unsaveModif = true;
   }
   params->unsaveModif = true;

+  return item;

 }
 
 
 }
 
 


@@ -465,7 +557,16 @@ GroupWidget *Dispatcher::createTopScene(){
 
   // creating the model part of the group
   Graph* graph = params->createGraph();
 
   // creating the model part of the group
   Graph* graph = params->createGraph();

-  GroupBlock *refBlock = graph->getTopGroup();
+  GroupBlock *topBlock = graph->getTopGroup();
+  // creating the clkrstgen block
+  ReferenceBlock* ref = params->getHiddenReferenceBlock("clkrstgen");
+  FunctionalBlock* newOne = params->getGraph()->createFunctionalBlock(topBlock, ref);  
+  ConnectedInterface* fromIface = AI_TO_CON(topBlock->getIfaceFromName("ext_clk"));
+  ConnectedInterface* toIface = AI_TO_CON(newOne->getIfaceFromName("ext_clk"));
+  fromIface->connectTo(toIface);
+  fromIface = AI_TO_CON(topBlock->getIfaceFromName("ext_reset"));
+  toIface = AI_TO_CON(newOne->getIfaceFromName("ext_reset"));
+  fromIface->connectTo(toIface);

 
   // creating a fake and not connected interface
   //AbstractInterface* iface = new GroupInterface(refBlock,"grp_iface",AbstractInterface::Input,AbstractInterface::Top);
 
   // creating a fake and not connected interface
   //AbstractInterface* iface = new GroupInterface(refBlock,"grp_iface",AbstractInterface::Input,AbstractInterface::Top);


@@ -479,7 +580,8 @@ GroupWidget *Dispatcher::createTopScene(){
   params->setTopScene(scene);
   params->setCurrentScene(scene);
   // creating the view part of the group
   params->setTopScene(scene);
   params->setCurrentScene(scene);
   // creating the view part of the group

-  GroupItem *group = new GroupItem(NULL,refBlock,this,params);
+  GroupItem *group = new GroupItem(NULL,topBlock,this,params);
+

 
   // adding the fake interface to the top group item
   //InterfaceItem* item = new InterfaceItem(0.0 , Parameters::West, (ConnectedInterface*)iface, group, params);
 
   // adding the fake interface to the top group item
   //InterfaceItem* item = new InterfaceItem(0.0 , Parameters::West, (ConnectedInterface*)iface, group, params);


@@ -530,6 +632,7 @@ GroupWidget *Dispatcher::createChildScene(GroupWidget* parentWidget, BoxItem *up
     GroupBlock* groupBlock = AB_TO_GRP(upperItemOfGroupItem->getRefBlock());
     // creating the view part of the group
     GroupItem *groupItem = new GroupItem(upperItemOfGroupItem,groupBlock,this,params);
     GroupBlock* groupBlock = AB_TO_GRP(upperItemOfGroupItem->getRefBlock());
     // creating the view part of the group
     GroupItem *groupItem = new GroupItem(upperItemOfGroupItem,groupBlock,this,params);

+

     // creating the group widget
     group = new GroupWidget(parentWidget, this, params);
     // getting the newly created scene
     // creating the group widget
     group = new GroupWidget(parentWidget, this, params);
     // getting the newly created scene


@@ -830,10 +933,11 @@ void Dispatcher::removeBoxItem(BoxItem *item) {
   removeAllBlockConnections(item);
 
   if (item->getRefBlock()->isFunctionalBlock()) {
   removeAllBlockConnections(item);
 
   if (item->getRefBlock()->isFunctionalBlock()) {

-    FunctionalBlock* block = AB_TO_FUN(item->getRefBlock());
-    GroupBlock* group = AB_TO_GRP(block->getParent());
+    FunctionalBlock* block = AB_TO_FUN(item->getRefBlock());    

     item->getScene()->removeBoxItem(item);
     params->getGraph()->removeFunctionalBlock(block);
     item->getScene()->removeBoxItem(item);
     params->getGraph()->removeFunctionalBlock(block);

+    params->blockToItem.remove(block);
+

   }
   else if (item->getRefBlock()->isGroupBlock()) {
 
   }
   else if (item->getRefBlock()->isGroupBlock()) {
 


@@ -885,43 +989,32 @@ void Dispatcher::removeSourceItem(SourceItem *item) {
 }
 
 
 }
 
 

-void Dispatcher::removeConnection(ConnectionItem *conn) {
+void Dispatcher::removeConnection(ConnectionItem *connItem) {

   static QString fctName = "Dispatcher::removeConnection()";
 #ifdef DEBUG_FCTNAME
   cout << "call to " << qPrintable(fctName) << endl;
 #endif
   static QString fctName = "Dispatcher::removeConnection()";
 #ifdef DEBUG_FCTNAME
   cout << "call to " << qPrintable(fctName) << endl;
 #endif

-  InterfaceItem* fromIfaceItem = conn->getFromInterfaceItem();
-  InterfaceItem* toIfaceItem = conn->getToInterfaceItem();
+  InterfaceItem* fromIfaceItem = connItem->getFromInterfaceItem();
+  InterfaceItem* toIfaceItem = connItem->getToInterfaceItem();

 
 #ifdef DEBUG
   cout << "remove connection from " << qPrintable(fromIfaceItem->refInter->getName()) << " to " << qPrintable(toIfaceItem->refInter->getName()) << endl;
 #endif
 
 
 #ifdef DEBUG
   cout << "remove connection from " << qPrintable(fromIfaceItem->refInter->getName()) << " to " << qPrintable(toIfaceItem->refInter->getName()) << endl;
 #endif
 

-  InterfaceItem* groupIfaceItem = NULL; // in case of one of the two interface belongs to the GroupItem
-  GroupItem* groupItem = NULL;
+  InterfaceItem* groupIfaceItem = NULL; // in case of one of the two interface belongs to the GroupItem, and stays NULL if not
+  GroupItem* groupItem = NULL; // the GroupItem of the scene that contains connItem

 
   ConnectedInterface *fromInter = fromIfaceItem->refInter;
 
   ConnectedInterface *fromInter = fromIfaceItem->refInter;

-  ConnectedInterface *toInter = toIfaceItem->refInter;
-  // process the special case source->group apart
-  if (fromIfaceItem->getOwner()->isSourceItem()) {
-    // remove from graph
-    fromInter->removeConnectedTo(toInter);
-    toInter->clearConnectedFrom();
-    // remove from scene
-    fromIfaceItem->removeConnectionItem(conn);
-    toIfaceItem->removeConnectionItem(conn);
-    groupItem->getScene()->removeConnectionItem(conn);
-    return;
-  }
-  
+  ConnectedInterface *toInter = toIfaceItem->refInter;  

   
   

+  // test if one of the interface bounded to item is owned by a GroupItem

   if (fromIfaceItem->getOwner()->isGroupItem()) {
   if (fromIfaceItem->getOwner()->isGroupItem()) {

-    groupIfaceItem = fromIfaceItem;
-    groupItem = toIfaceItem->getOwner()->getScene()->getGroupItem();
+    groupItem = ABI_TO_GI(fromIfaceItem->getOwner());
+    groupIfaceItem = fromIfaceItem;    

   }
   else if (toIfaceItem->getOwner()->isGroupItem()) {
   }
   else if (toIfaceItem->getOwner()->isGroupItem()) {

-    groupIfaceItem = toIfaceItem;
-    groupItem = fromIfaceItem->getOwner()->getScene()->getGroupItem();
+    groupItem = ABI_TO_GI(toIfaceItem->getOwner());
+    groupIfaceItem = toIfaceItem;    

   }
   else {
     groupItem = fromIfaceItem->getOwner()->getScene()->getGroupItem();
   }
   else {
     groupItem = fromIfaceItem->getOwner()->getScene()->getGroupItem();


@@ -931,16 +1024,8 @@ void Dispatcher::removeConnection(ConnectionItem *conn) {
 #ifdef DEBUG
   cout << "removing connections from graph ..." ;
 #endif  
 #ifdef DEBUG
   cout << "removing connections from graph ..." ;
 #endif  

-  if (fromInter->getDirection() == AbstractInterface::InOut) {
-    fromInter->clearConnectedTo();
-    fromInter->clearConnectedFrom();
-    toInter->clearConnectedTo();
-    toInter->clearConnectedFrom();
-  }
-  else {
-    fromInter->removeConnectedTo(toInter);
-    toInter->clearConnectedFrom();
-  }
+  fromInter->disconnectTo(toInter);
+  

 #ifdef DEBUG
   cout << "done." << endl ;
 #endif
 #ifdef DEBUG
   cout << "done." << endl ;
 #endif


@@ -948,25 +1033,35 @@ void Dispatcher::removeConnection(ConnectionItem *conn) {
   // removing the connection from scene
 #ifdef DEBUG
   cout << "removing connections from scene ..." ;
   // removing the connection from scene
 #ifdef DEBUG
   cout << "removing connections from scene ..." ;

-#endif
-  fromIfaceItem->removeConnectionItem(conn);
-  toIfaceItem->removeConnectionItem(conn);
-  groupItem->getScene()->removeConnectionItem(conn);
+#endif  
+  groupItem->getScene()->removeConnectionItem(connItem);

 
 #ifdef DEBUG
   cout << "done." << endl ;
 #endif
 
 #ifdef DEBUG
   cout << "done." << endl ;
 #endif

-
+  
+  // if one of the interface bounded to connItem is owned by the GroupItem of the scene

   if (groupIfaceItem != NULL) {
   if (groupIfaceItem != NULL) {

-    ConnectedInterface* groupInter = groupIfaceItem->refInter;
-    groupItem->removeInterface(groupIfaceItem);
-
-    BoxItem* parent2Item = groupItem->getParentItem();
-    if (parent2Item != NULL) {
-      InterfaceItem* group2IfaceItem = parent2Item->searchInterfaceByRef(groupInter);
-      parent2Item->removeInterface(group2IfaceItem);
+    
+    // determine if the interface must be removed since it has no more connections.
+    bool groupInterRemove = false;
+    if ((groupIfaceItem->refInter->isConnectedTo() == false) && (groupIfaceItem->refInter->isConnectedFrom() == false)) groupInterRemove = true;
+    
+    if (groupInterRemove) {
+      // get the GroupInterface from interface item
+      ConnectedInterface* groupInter = groupIfaceItem->refInter;            
+      // remove interface from GroupItem, and delete it.
+      groupItem->removeInterfaceItem(groupIfaceItem);      
+      // get the parent BoxItem of GroupItem if it exists.
+      BoxItem* parent2Item = groupItem->getParentItem();
+      if (parent2Item != NULL) {
+        InterfaceItem* group2IfaceItem = parent2Item->searchInterfaceItemByRef(groupInter);
+        // remove interface intem in parent BoxItem
+        parent2Item->removeInterfaceItem(group2IfaceItem);
+      }
+      // remove GroupInterface in the graph.
+      groupInter->getOwner()->removeInterface(groupInter);

     }
     }

-    groupInter->getOwner()->removeInterface(groupInter);

   }
 }
 
   }
 }
 


@@ -976,8 +1071,7 @@ void Dispatcher::showBlocksLibrary(){
   mainWindow->getLibrary()->raise();
 }
 
   mainWindow->getLibrary()->raise();
 }
 

-void Dispatcher::showProperties(InterfaceItem *inter)
-{
+void Dispatcher::showProperties(InterfaceItem *inter) {

   new InterfacePropertiesWindow(inter);
 }
 
   new InterfacePropertiesWindow(inter);
 }
 


@@ -999,154 +1093,32 @@ void Dispatcher::connectInterToGroup(InterfaceItem *item){
   // creating/adding the group interface in the graph model
   GroupInterface *groupInter = new GroupInterface(parentBlock,refInter->getName()+"_group",refInter->getDirection(),refInter->getPurpose());  
   parentItem->getRefBlock()->addInterface(groupInter);
   // creating/adding the group interface in the graph model
   GroupInterface *groupInter = new GroupInterface(parentBlock,refInter->getName()+"_group",refInter->getDirection(),refInter->getPurpose());  
   parentItem->getRefBlock()->addInterface(groupInter);

-  // creating/adding the group control interface in the graph model
-  GroupInterface *groupCtlInter = new GroupInterface(parentBlock,refInter->getName()+"_group_enb",refInter->getDirection(),AbstractInterface::Control);
-  groupCtlInter->setAssociatedIface(groupInter);
-  parentItem->getRefBlock()->addInterface(groupCtlInter);
-
-  // connect both interface
-  bool ok = true;
-  if (refInter->getDirection() == AbstractInterface::Output) {
-    ok = refInter->connectTo(groupInter);
-    ok = ok & groupInter->connectFrom(refInter);    
-  }
-  else if (refInter->getDirection() == AbstractInterface::Input) {
-    ok = groupInter->connectTo(refInter);
-    ok = ok & refInter->connectFrom(groupInter);
-  }
-  else if (refInter->getDirection() == AbstractInterface::InOut) {
-    ok = refInter->connectTo(groupInter);
-    ok = ok & groupInter->connectFrom(refInter);
-    ok = ok & groupInter->connectTo(refInter);
-    ok = ok & refInter->connectFrom(groupInter);
-  }
-  if (!ok) {
-    cerr << "abnormal case while connecting a block iface to its parent group" << endl;
+  // creating/adding the group control interface in the graph model if the purpose is data
+  if (refInter->getPurpose() == AbstractInterface::Data) {
+    GroupInterface *groupCtlInter = new GroupInterface(parentBlock,refInter->getName()+"_group_enb",refInter->getDirection(),AbstractInterface::Control);
+    groupCtlInter->setAssociatedIface(groupInter);
+    parentItem->getRefBlock()->addInterface(groupCtlInter);

   }
   // creating/adding the group interface in the current scene model, and connection item
   InterfaceItem *groupIfaceItem = new InterfaceItem(0,item->getOrientation(),groupInter,parentItem,params);
   }
   // creating/adding the group interface in the current scene model, and connection item
   InterfaceItem *groupIfaceItem = new InterfaceItem(0,item->getOrientation(),groupInter,parentItem,params);

-  parentItem->addInterface(groupIfaceItem,true);
+  parentItem->addInterfaceItem(groupIfaceItem,true);

 
 

-  parentItem->getScene()->createConnectionItem(item, groupIfaceItem);
+  // creating the connection, in graph and with an item
+  createConnection(item, groupIfaceItem);

 
   // if groupItem is not topGroup, must also add a new interface to the parent BlockItem
   BoxItem* parent2Item = parentItem->getParentItem();
   if(parent2Item != NULL){
     InterfaceItem *blockIfaceItem = new InterfaceItem(0,item->getOrientation(),groupInter,parent2Item,params);
 
   // if groupItem is not topGroup, must also add a new interface to the parent BlockItem
   BoxItem* parent2Item = parentItem->getParentItem();
   if(parent2Item != NULL){
     InterfaceItem *blockIfaceItem = new InterfaceItem(0,item->getOrientation(),groupInter,parent2Item,params);

-    parent2Item->addInterface(blockIfaceItem,true);
+    parent2Item->addInterfaceItem(blockIfaceItem,true);

   }
 
 
   parentItem->getScene()->updateConnectionItemsShape();
   unselectAllItems();
   params->unsaveModif = true;
   }
 
 
   parentItem->getScene()->updateConnectionItemsShape();
   unselectAllItems();
   params->unsaveModif = true;

-
-

 }
 
 }
 

-void Dispatcher::disconnectInterFromGroup(InterfaceItem *item) {
-  static QString fctName = "Dispatcher::disconnectInterFromGroup()";
-#ifdef DEBUG_FCTNAME
-  cout << "call to " << qPrintable(fctName) << endl;
-#endif
-
-  // getting the GroupBlock and GroupItem that are parent of the block that owns item
-  ConnectedInterface *refInter = item->refInter;
-  ConnectedInterface *groupInter = NULL;
-  GroupBlock* parentGroup = AB_TO_GRP(refInter->getOwner()->getParent());
-  GroupItem *parentItem = item->getOwner()->getScene()->getGroupItem();
-
-  // removing the connection from graph
-#ifdef DEBUG
-  cout << "removing connections from graph ..." ;
-#endif
-
-  if (refInter->getDirection() == AbstractInterface::Output) {
-    groupInter = refInter->getConnectionToParentGroup(); // must be a single connection to
-    refInter->removeConnectedTo(groupInter);
-    groupInter->clearConnectedFrom();
-  }
-  else if (refInter->getDirection() == AbstractInterface::Input) {
-    groupInter = refInter->getConnectedFrom();
-    refInter->clearConnectedFrom();
-    groupInter->removeConnectedTo(refInter);
-  }
-  else if (refInter->getDirection() == AbstractInterface::InOut) {
-    groupInter = refInter->getConnectionToParentGroup(); // must be a single connection to
-    refInter->clearConnectedTo();
-    refInter->clearConnectedFrom();
-    groupInter->clearConnectedTo();
-    groupInter->clearConnectedFrom();
-  }
-#ifdef DEBUG
-  cout << "done." << endl ;
-#endif
-
-  if (groupInter == NULL) {
-    cerr << "abnormal case 1 while removing an interface item of a block, linked to a parent group" << endl;
-  }
-
-#ifdef DEBUG
-  cout << "getting group interface item, and connection item ..." ;
-#endif
-
-
-  InterfaceItem* groupIfaceItem = parentItem->searchInterfaceByRef(groupInter);
-  if (groupIfaceItem == NULL) {
-    cerr << "abnormal case 2 while removing an interface item of a block, linked to a parent group" << endl;
-  }
-  ConnectionItem* conn = parentItem->getScene()->searchConnectionItem(item,groupIfaceItem);
-  if (conn == NULL) {
-    cerr << "abnormal case 3 while removing an interface item of a block, linked to a parent group" << endl;
-  }
-#ifdef DEBUG
-  cout << "done." << endl ;
-#endif
-
-  // removing the interface group item from the group item, and the connection item
-#ifdef DEBUG
-  cout << "removing group interface item, and connection item ..." ;
-#endif
-
-  bool groupInterRemove = false;
-  if ((groupInter->isConnectedTo() == false) && (groupInter->isConnectedFrom() == false)) groupInterRemove = true;
-  
-  item->removeConnectionItem(conn);
-  groupIfaceItem->removeConnectionItem(conn);
-  if (groupInterRemove) {
-    parentItem->removeInterface(groupIfaceItem); // CAUTION : this deletes the interface item.
-  }
-  parentItem->getScene()->removeConnectionItem(conn);
-#ifdef DEBUG
-  cout << "done." << endl ;
-#endif
-
-  if (groupInterRemove) {
-    // removing the interface box item in the parent scene
-#ifdef DEBUG
-    cout << "removing the inteeface item of box item in parent scene if needed ..." ;
-#endif
-    
-    BoxItem* parent2Item = parentItem->getParentItem();
-    if (parent2Item != NULL) {
-      InterfaceItem* group2IfaceItem = parent2Item->searchInterfaceByRef(groupInter);
-      parent2Item->removeInterface(group2IfaceItem);
-    }
-#ifdef DEBUG
-    cout << "done." << endl ;
-#endif
-    
-    // removing the interface group from the group
-#ifdef DEBUG
-    cout << "removing group interface ..." ;
-#endif
-    parentGroup->removeInterface(groupInter);
-#ifdef DEBUG
-    cout << "done." << endl ;
-#endif
-  }
-
-}

 void Dispatcher::removeFunctionalInterface(InterfaceItem *item) {
   static QString fctName = "Dispatcher::removeBlockInterface()";
 #ifdef DEBUG_FCTNAME
 void Dispatcher::removeFunctionalInterface(InterfaceItem *item) {
   static QString fctName = "Dispatcher::removeBlockInterface()";
 #ifdef DEBUG_FCTNAME


@@ -1165,7 +1137,7 @@ void Dispatcher::removeFunctionalInterface(InterfaceItem *item) {
   }
 
   ConnectedInterface* ref = item->refInter;
   }
 
   ConnectedInterface* ref = item->refInter;

-  item->getOwner()->removeInterface(item);
+  item->getOwner()->removeInterfaceItem(item);

   FunctionalBlock* fun = AB_TO_FUN(ref->getOwner());
   fun->removeInterface(ref);
 }
   FunctionalBlock* fun = AB_TO_FUN(ref->getOwner());
   fun->removeInterface(ref);
 }


@@ -1176,15 +1148,11 @@ void Dispatcher::removeGroupInterface(InterfaceItem *item) {
   cout << "call to " << qPrintable(fctName) << endl;
 #endif
 
   cout << "call to " << qPrintable(fctName) << endl;
 #endif
 

-  /* NB: there is a single connection between item and another one that is owned
-     by a BoxItem. Thus, we just have to find it and to call disconnectInterFromGroup();
+  /* NB: just remove all connections from/to this item, since when there are no more
+     ones to a GroupItem, it is automatically deleted.

    */
    */

-  ConnectionItem* conn = item->connections.at(0);
-  if (conn->getFromInterfaceItem() == item) {
-    disconnectInterFromGroup(conn->getToInterfaceItem());
-  }
-  else {
-    disconnectInterFromGroup(conn->getFromInterfaceItem());
+  foreach(ConnectionItem* conn, item->connections) {
+    removeConnection(conn);

   }
 }
 
   }
 }
 


@@ -1252,3 +1220,32 @@ InterfaceItem* Dispatcher::getInterfaceItemById(int id) {
   return NULL;
 }
 
   return NULL;
 }
 

+void Dispatcher::findGraphModifications(FunctionalBlock *block) {
+  static QString fctName = "Dispatcher::findGraphModifications()";
+#ifdef DEBUG_FCTNAME
+  cout << "call to " << qPrintable(fctName) << endl;
+#endif
+
+  block->computeAdmittanceDelays();
+  // get the block item that is associated to block
+  BoxItem* toBlockItem = params->blockToItem.value(block);
+
+  /* VERSION 1: just add delays if needed */
+  QMap<AbstractInterface*,QList<int>* > delays = block->getAdmittanceDelays();
+  QMapIterator<AbstractInterface*,QList<int>* > iterD(delays);
+  while (iterD.hasNext()) {
+    iterD.next();
+    QList<int>* delay = iterD.value();
+    if (delay->at(0) > 0) {
+      // create delay and associate it to the connected input
+
+      ConnectedInterface* toIface = AI_TO_CON(iterD.key());
+      AbstractInputModifier* mod = new DelayInputModifier(toIface, delay->at(0));
+      cout << "modify input of " << qPrintable(toIface->getName()) << endl;
+      toIface->setInputModifier(mod);
+      // repaint
+      toBlockItem->update();
+    }
+  }
+}
+