Dispatcher.cpp

   1 #include "Dispatcher.h"
   2 #include "Parameters.h"
   3 #include "MainWindow.h"
   4
   5 #include "Graph.h"
   6 #include "ReferenceBlock.h"
   7 #include "GroupBlock.h"
   8 #include "FunctionalBlock.h"
   9
  10 #include "ConnectedInterface.h"
  11 #include "ReferenceInterface.h"
  12 #include "GroupInterface.h"
  13 #include "FunctionalInterface.h"
  14
  15 #include "GroupWidget.h"
  16 #include "GroupScene.h"
  17 #include "GroupItem.h"
  18 #include "BoxItem.h"
  19 #include "InterfaceItem.h"
  20 #include "ConnectionItem.h"
  21
  22 #include "BlockLibraryWidget.h"
  23 #include "BlockLibraryTree.h"
  24
  25 #include "InterfacePropertiesWindow.h"
  26
  27 int Dispatcher::sceneCounter = 0;
  28
  29 Dispatcher::Dispatcher(Parameters* _params, MainWindow* _window) {
  30   params = _params;
  31   mainWindow =_window;
  32   params->setDispatcher(this);
  33   currentGroup = NULL;
  34   topGroup = NULL;
  35 }
  36
  37 GroupWidget *Dispatcher::loadProject(const QString& filename) {
  38
  39   QDomElement root;
  40   try {
  41     root = params->openProjectFile(filename);
  42   }
  43   catch(Exception err) {
  44     return NULL;
  45   }
  46
  47   // creating the top widget/scene
  48   topGroup = new GroupWidget(NULL,this,params);
  49   currentGroup = topGroup;
  50   // getting the newly created scene
  51   GroupScene *scene = topGroup->getScene();
  52
  53   params->setTopScene(scene);
  54   params->setCurrentScene(scene);
  55
  56   try {
  57     params->loadProject(root);
  58   }
  59   catch(Exception e){
  60     cerr << qPrintable(e.getDefaultMessage()) << endl;
  61     cerr << "Aborting ..." << endl;
  62     // TO DO : deleteting topGroup and all
  63     return NULL;
  64   }
  65
  66   groupList.append(topGroup);
  67   return topGroup;
  68 }
  69
  70 void Dispatcher::closeCurrentProject() {
  71
  72   foreach(GroupWidget* win, groupList) {
  73     win->deleteLater();
  74   }
  75   params->destroyGraph();
  76 }
  77
  78 bool Dispatcher::connect(InterfaceItem *iface1, InterfaceItem *iface2) {
  79
  80   ConnectedInterface* ref1 = iface1->refInter;
  81   ConnectedInterface* ref2 = iface2->refInter;
  82   // connect both interface
  83
  84   bool ok1 = false;
  85   bool ok2 = false;
  86
  87   if (ref1->canConnectTo(ref2)) {
  88     ok1 = ref1->connectTo(ref2);
  89     ok1 = ok1 & ref2->connectFrom(ref1);
  90   }
  91   if (ref2->canConnectTo(ref1)) {
  92     ok2 = ref2->connectTo(ref1);
  93     ok2 = ok2 & ref1->connectFrom(ref2);
  94   }
  95   if ((ok1 == true) || (ok2 == true)) {
  96
  97     iface1->getOwner()->getScene()->createConnectionItem(iface1,iface2);
  98
  99     unselectAllItems();
 100     params->unsaveModif = true;
 101     return true;
 102   }
 103   return false;
 104 }
 105
 106 void Dispatcher::checkSelection(){
 107   InterfaceItem *iface1 = NULL;
 108   InterfaceItem *iface2 = NULL;
 109
 110   GroupScene *scene = params->getCurrentScene();
 111   QList<AbstractBoxItem*> list = scene->getGroupAndBlocks();
 112   foreach(AbstractBoxItem *block, list){
 113     InterfaceItem *tmp = block->getCurrentInterface();
 114     if (tmp != NULL) {
 115       if (iface1 == NULL) {
 116         iface1 = tmp;
 117       }
 118       else {
 119         iface2 = tmp;
 120       }
 121     }
 122   }
 123   if(iface1 != NULL && iface2 != NULL){
 124     connect(iface1,iface2);
 125   }
 126 }
 127
 128 void Dispatcher::unselectAllItems(int direction){
 129
 130   GroupScene *scene = params->getCurrentScene();
 131
 132   foreach(BoxItem* block, scene->getBlockItems()) {
 133     block->setSelected(false);
 134     block->setCurrentInterface(NULL);
 135   }
 136   scene->unselecteInterfaces();
 137   scene->update();
 138 }
 139
 140 void Dispatcher::setCurrentGroupWidget(GroupWidget *win){
 141   win->setFocus();
 142   win->changeConnectionMode(-1);
 143   currentGroup = win;
 144   params->setCurrentScene(win->getScene());
 145 }
 146
 147 void Dispatcher::changeConnectionMode(int mode){
 148
 149   /*
 150   foreach(GroupWidget* win, groupList){
 151
 152     QToolButton* buttonNewConnection = win->getButtonNewConnection();
 153
 154     QPalette pal = buttonNewConnection->palette();
 155
 156     if(mode == -1){
 157       if(params->sceneMode != Parameters::EditOnConnection){
 158         params->sceneMode = Parameters::EditOnConnection;
 159         pal.setColor(QPalette::Button, QColor(Qt::lightGray));
 160       } else {
 161         params->sceneMode = Parameters::EditNoOperation;
 162         pal.setColor(QPalette::Button, QColor("#edeceb"));
 163       }
 164     }
 165     else if(mode == Parameters::EditOnConnection){
 166       params->sceneMode = Parameters::EditOnConnection;
 167       pal.setColor(QPalette::Button, QColor(Qt::lightGray));
 168     }
 169     else {
 170       params->sceneMode = Parameters::EditNoOperation;
 171       pal.setColor(QPalette::Button, QColor("#edeceb"));
 172     }
 173     unselectAllInterfaces();
 174
 175     buttonNewConnection->setAutoFillBackground(true);
 176     buttonNewConnection->setPalette(pal);
 177     buttonNewConnection->update();
 178   }
 179   */
 180 }
 181
 182 void Dispatcher::rename(AbstractBoxItem *item){
 183
 184   bool ok;
 185   QString text = QInputDialog::getText(NULL, "Rename an element",
 186                                        "New name:", QLineEdit::Normal,
 187                                        item->getRefBlock()->getName(), &ok);
 188
 189   if(ok){
 190     if(!text.isEmpty() && text.length() < 30){
 191       item->getRefBlock()->setName(text);
 192       if(item->isGroupItem()){
 193         if (currentGroup->isTopGroup()) {
 194           mainWindow->setWindowTitle("blast - "+text);
 195         }
 196         else {
 197           currentGroup->setWindowTitle("blast - "+text);
 198         }
 199       }
 200
 201       mainWindow->getLibrary()->updateComboScene();
 202     }
 203     else {
 204       QMessageBox::warning(NULL,"Error in given name",
 205                            "the element name must be shorter than 30 characters and can't be empty!",
 206                            QMessageBox::Ok);
 207       rename(item);
 208     }
 209   }
 210 }
 211
 212 void Dispatcher::rename(InterfaceItem *item){
 213   bool ok;
 214   QString text = QInputDialog::getText(NULL, "Rename an interface",
 215                                        "New name:", QLineEdit::Normal,
 216                                        item->refInter->getName(), &ok);
 217
 218   /* CAUTION: when renaming an interface item, there are two cases :
 219      - it refers to a functional block interface (fbi): the fbi keeps its name
 220      and the new name is given to item
 221      - it refers to a group block interface (gbi) : both gbi and item store the new name
 222
 223    */
 224   if(ok && !text.isEmpty() && text.length() < 30) {
 225     if (item->refInter->getOwner()->isGroupBlock()) {
 226       item->refInter->setName(text);
 227     }
 228     item->setName(text);
 229
 230   }
 231   else {
 232     QMessageBox::warning(NULL,"Error in given name",
 233                          "the interface name must be shorter than 30 characters and can't be empty!",
 234                          QMessageBox::Ok);
 235     rename(item);
 236   }
 237 }
 238
 239 void Dispatcher::duplicateBlock(BoxItem *item){
 240
 241   GroupScene *scene = params->getCurrentScene();
 242   AbstractBlock* block = item->getRefBlock();
 243   AbstractBlock *newBlock;
 244
 245   // only duplicate functional blocks
 246   if(block->isFunctionalBlock()) {
 247
 248     // adding to the model
 249     FunctionalBlock* funBlock = (FunctionalBlock*)block;
 250     newBlock = params->duplicateFunctionalBlock(funBlock);
 251     // adding to the view
 252     scene->createBlockItem(newBlock);
 253
 254     params->unsaveModif = true;
 255   }
 256 }
 257
 258 void Dispatcher::duplicateInterface(InterfaceItem *item){
 259   AbstractInterface *refI = item->refInter;
 260   if (! refI->isFunctionalInterface()) return;
 261
 262   AbstractBlock *refB = refI->getOwner();
 263   if(! refB->isFunctionalBlock()) return;
 264
 265   FunctionalInterface* iface = (FunctionalInterface*)refI;
 266   AbstractInterface *otherRef = iface->clone();
 267   if (otherRef == NULL) {
 268     QMessageBox::warning(NULL,"Error while cloning an interface","the interface cannot be cloned because its maximum multiplicity is reached", QMessageBox::Ok);
 269     return;
 270   }
 271
 272   refB->addInterface(otherRef);
 273
 274   InterfaceItem *otherIface = new InterfaceItem(item->getPosition(),item->getOrientation(),(ConnectedInterface*)otherRef,item->getOwner(),params);
 275   item->getOwner()->addInterface(otherIface,true);
 276 }
 277
 278
 279 void Dispatcher::addBlock(int idCategory, int idBlock, int idScene) {
 280
 281   GroupScene *scene = searchSceneById(idScene);
 282   FunctionalBlock* newOne = params->addFunctionalBlock(idCategory, idBlock);
 283   scene->createBlockItem(newOne);
 284 }
 285
 286
 287 GroupWidget *Dispatcher::createTopScene(){
 288
 289   // creating the model part of the group
 290   Graph* graph = params->createGraph();
 291   GroupBlock *refBlock = graph->getTopGroup();
 292
 293   // creating a fake and not connected interface
 294   //AbstractInterface* iface = new GroupInterface(refBlock,"grp_iface",AbstractInterface::Input,AbstractInterface::Top);
 295
 296   // creating the group widget
 297   topGroup = new GroupWidget(NULL,this,params);
 298   currentGroup = topGroup;
 299   // getting the newly created scene
 300   GroupScene *scene = topGroup->getScene();
 301   scene->setId(sceneCounter++);
 302   params->setTopScene(scene);
 303   params->setCurrentScene(scene);
 304   // creating the view part of the group
 305   GroupItem *group = new GroupItem(NULL,refBlock,this,params);
 306
 307   // adding the fake interface to the top group item
 308   //InterfaceItem* item = new InterfaceItem(0.0 , Parameters::West, (ConnectedInterface*)iface, group, params);
 309   //group->addInterface(item,true);
 310
 311   scene->setGroupItem(group);
 312
 313   groupList.append(topGroup);
 314   return topGroup;
 315 }
 316
 317 GroupWidget *Dispatcher::createChildScene(GroupWidget* parentWidget, BoxItem *upperItemOfGroupItem) {
 318
 319   // getting back the goup block already created
 320   GroupBlock* groupBlock = NULL;
 321   if (upperItemOfGroupItem != NULL) {
 322     groupBlock = AB_TO_GRP(upperItemOfGroupItem->getRefBlock());
 323   }
 324   // creating the view part of the group
 325   GroupItem *groupItem = new GroupItem(upperItemOfGroupItem,groupBlock,this,params);
 326   // creating the group widget
 327   GroupWidget* group = new GroupWidget(parentWidget, this, params);
 328   // getting the newly created scene
 329   GroupScene *scene = group->getScene();
 330   scene->setId(sceneCounter++);
 331   // affecting group item to the scene
 332   scene->setGroupItem(groupItem);
 333   groupList.append(group);
 334
 335   mainWindow->getLibrary()->updateComboScene();
 336
 337   return group;
 338 }
 339
 340 void Dispatcher::showRaiseWindow(AbstractBoxItem *item) {
 341   GroupWidget* win = item->getScene()->getGroupWindow();
 342   if (win->isTopGroup()) {
 343     mainWindow->show();
 344     mainWindow->raise();
 345   }
 346   else {
 347     win->show();
 348     win->raise();
 349   }
 350   currentGroup = win;
 351   params->setCurrentScene(currentGroup->getScene());
 352 }
 353
 354 void Dispatcher::showRstClkInter(AbstractBoxItem *item) {
 355
 356   item->setRstClkVisible(!item->isRstClkVisible());
 357   item->resetInterfacesPosition();
 358
 359   item->getScene()->updateConnectionItemsShape();
 360 }
 361
 362 void Dispatcher::addNewFullGroup() {
 363
 364 #ifdef DEBUG_INCLFUN
 365
 366   QList<BlockItem*> listBlocks = params->getCurrentScene()->getSelectedBlocks(); //selected blocks in the current scene
 367   QList<AbstractBlock*> listAbstractBlocks;   //abstract blocks in the group
 368   QList<ConnectionItem *> connections = params->getCurrentScene()->getConnectionItems();
 369
 370   /* What must be done:
 371      1 - creating a new GroupBlock
 372      2 - moving the selected blocks from the current GroupBlock to the new GroupBlock
 373      3 - creating a BlockItem that references the new GroupBlock
 374      4 - creating a new GroupWidget
 375      5 - creating a new GroupItem added to the scene of the GroupWidget
 376
 377    */
 378
 379   /* step 1 : creating new GroupBlock that will have as a parent the GroupBlock
 380      associated to the GroupItem of the current scene
 381    */
 382   GroupBlock* parentBlock = params->getCurrentScene()->getGroupItem()->getRefBlock();
 383   GroupBlock* newGroupBlock = new GroupBlock(parentBlock);
 384   /* step 2: moving selected blocks */
 385   foreach(BlockItem* blockItem, listBlocks) {
 386     parentBlock->removeBlock(blockItem->getRefBlock());
 387     newGroupBlock->addBlock(blockItem->getRefBlock());
 388   }
 389
 390   GroupItem *parent = currentGroup->getScene()->getGroupItem();
 391   GroupBlock *groupBlock = new GroupBlock(((GroupBlock*)parent->getRefBlock()),params->currentWindow);
 392   BlockItem *blockItem = new BlockItem(params->getCurrentScene()->getGroupItem(),groupBlock,this,params);
 393   GroupItem *groupItem = new GroupItem(blockItem,groupBlock,this,params);
 394
 395   //create the new window
 396   GroupWidget* win = new GroupWidget(this,params);
 397   win->getScene()->setGroupItem(groupItem);
 398   win->getScene()->addItem(groupItem);
 399   ((GroupBlock*)groupItem->getRefBlock())->setWindow(win);
 400   params->addWindow(win);
 401   win->show();
 402
 403   //add the new group
 404   params->getCurrentScene()->addBlockItem(blockItem);
 405   params->getCurrentScene()->addItem(blockItem);
 406   ((GroupItem*)params->getCurrentScene()->getGroupItem())->addBlockItem(blockItem);
 407
 408   //replace selected blocks in the group
 409   foreach(AbstractBoxItem *block, listBlocks){
 410     ((GroupItem*)block->getParentItem())->removeBlockItem(block);
 411     ((GroupBlock*)block->getParentItem()->getRefBlock())->removeBlock(block->getRefBlock());
 412     params->getCurrentScene()->removeItem(block);
 413     params->getCurrentScene()->removeBlockItem(block);
 414
 415     groupBlock->addBlock(block->getRefBlock());
 416     listAbstractBlocks.append(block->getRefBlock());
 417
 418     block->setUpperItem(groupItem);
 419     groupItem->addBlockItem(block);
 420     win->getScene()->addItem(block);
 421     win->getScene()->addBlockItem(block);
 422   }
 423
 424   //replace connection between selected blocks in the group
 425   foreach(ConnectionItem *conn, connections){
 426     if(listBlocks.contains(conn->getFromInterfaceItem()->getOwner())){
 427       if(listBlocks.contains(conn->getToInterfaceItem()->getOwner())){
 428         parent->removeConnection(conn);
 429         params->getCurrentScene()->removeItem(conn);
 430
 431         groupItem->addConnection(conn);
 432         win->getScene()->addItem(conn);
 433       }
 434     }
 435   }
 436
 437   //create new interfaces and connections for the new group
 438   foreach(AbstractBoxItem *block, listBlocks){
 439     foreach(InterfaceItem *inter, block->getInterfaces()){
 440       cout << "inter : " << inter->getName().toStdString() << endl;
 441       if(inter->refInter->getConnectedFrom() != NULL && inter->refInter->getDirection() == AbstractInterface::Input){
 442         cout << "connected from non null" << endl;
 443         if(!listAbstractBlocks.contains(inter->refInter->getConnectedFrom()->getOwner())){
 444
 445           AbstractInterface *iface = inter->refInter->clone(0);
 446           iface->setName(iface->getName()+"_group");
 447           groupBlock->addInterface(iface);
 448
 449           InterfaceItem *ifaceItem = new InterfaceItem(0,Parameters::East,iface,blockItem,params);
 450           blockItem->addInterface(ifaceItem);
 451           blockItem->resetInterfacesPosition();
 452
 453           InterfaceItem *ifaceGroupItem = new InterfaceItem(0,Parameters::West,iface,groupItem,params);
 454           groupItem->addInterface(ifaceGroupItem);
 455           groupItem->resetInterfacesPosition();
 456           foreach(ConnectionItem* conn, currentGroup->getScene()->getInterfaceConnections(inter)){
 457             if(conn->getToInterfaceItem() == inter){
 458               conn->setToInterfaceItem(ifaceItem);
 459               ifaceItem->refInter->setConnectedFrom(NULL);
 460               conn->getFromInterfaceItem()->refInter->clearConnectedTo();
 461               connect(ifaceItem,conn->getFromInterfaceItem());
 462             }
 463           }
 464           params->setCurrentWindow(win);
 465
 466           inter->refInter->setConnectedFrom(NULL);
 467           ifaceGroupItem->refInter->clearConnectedTo();
 468           connect(inter,ifaceGroupItem);
 469           params->setCurrentWindow(mainWindow);
 470         }
 471       }
 472
 473       if(!inter->refInter->getConnectedTo().isEmpty() && inter->refInter->getDirection() == AbstractInterface::Output){
 474         cout << "connected to non null" << endl;
 475         foreach(AbstractInterface *iface, inter->refInter->getConnectedTo()){
 476           if(!listAbstractBlocks.contains(iface->getOwner())){
 477
 478             AbstractInterface *iface = inter->refInter->clone(0);
 479             iface->setName(iface->getName()+"_group");
 480             groupBlock->addInterface(iface);
 481
 482             InterfaceItem *ifaceItem = new InterfaceItem(0,Parameters::East,iface,blockItem,params);
 483             blockItem->addInterface(ifaceItem);
 484             blockItem->resetInterfacesPosition();
 485
 486             foreach(ConnectionItem* conn, currentGroup->getScene()->getInterfaceConnections(inter)){
 487               if(conn->getFromInterfaceItem() == inter){
 488                 conn->setFromInterfaceItem(ifaceItem);
 489                 iface->addConnectedTo(conn->getToInterfaceItem()->refInter);
 490                 conn->getToInterfaceItem()->refInter->setConnectedFrom(iface);
 491               }
 492             }
 493
 494             InterfaceItem *ifaceGroupItem = new InterfaceItem(0,Parameters::East,iface,groupItem,params);
 495             groupItem->addInterface(ifaceGroupItem);
 496             groupItem->resetInterfacesPosition();
 497             inter->refInter->clearConnectedTo();
 498             ifaceGroupItem->refInter->setConnectedFrom(NULL);
 499             connect(ifaceGroupItem,inter);
 500           }
 501         }
 502       }
 503     }
 504   }
 505
 506   //update window
 507
 508   parent->updateShape();
 509   currentGroup->getScene()->updateConnectionItemsShape();
 510   currentGroup = win;
 511   groupItem->updateShape();
 512   win->getScene()->updateConnectionItemsShape();
 513   groupItem->update(groupItem->boundingRect());
 514
 515 #endif
 516 }
 517
 518 void Dispatcher::removeBlock(AbstractBoxItem *item) {
 519
 520 #ifdef DEBUG_INCLFUN
 521
 522   GroupScene *scene = params->getCurrentScene();
 523   AbstractBlock* block = item->getRefBlock();
 524   if (block->isReferenceBlock()) return;
 525
 526   GroupBlock* group = (GroupBlock*)item->getParentItem()->getRefBlock();
 527
 528   removeConnections(item);
 529
 530   //récupérer l'objet
 531   group->removeBlock(block);
 532
 533   //remove the associated window
 534   if(block->isGroupBlock()){
 535     foreach(QWidget *window, params->windows){
 536       if(!window->inherits("MainWindow")){
 537         if(((GroupWidget*)window)->getScene()->getGroupItem()->getRefBlock() == block){
 538           params->removeWindow(window);
 539           delete window;
 540         }
 541       }
 542     }
 543   }
 544
 545   delete block;
 546
 547   //supprimer l'item de la scène
 548   cout << "dispatcher : remove item of scene " << params->currentWindow << endl;
 549   ((GroupItem *)scene->getGroupItem())->removeBlockItem(item);
 550   scene->removeItem(item);
 551   scene->removeBlockItem(item);
 552   delete item;
 553
 554   ((GroupItem *)scene->getGroupItem())->updateShape();
 555
 556   params->updateToolbar();
 557   params->unsaveModif = true;
 558
 559 #endif
 560 }
 561
 562 void Dispatcher::removeAllBlockConnections(AbstractBoxItem *block) {
 563
 564   GroupScene* scene = block->getScene();
 565   // supprimer les connections associées au bloc
 566   foreach (ConnectionItem *conn, scene->getConnectionItems()) {
 567     if(conn->getToInterfaceItem()->owner == block || conn->getFromInterfaceItem()->owner == block){
 568       removeConnection(conn);
 569     }
 570   }
 571   scene->getGroupItem()->updateInterfacesAndConnections();
 572 }
 573
 574 void Dispatcher::removeConnection(ConnectionItem *conn) {
 575
 576   GroupScene *scene = params->getCurrentScene();
 577   GroupItem* currentGroup = scene->getGroupItem();
 578
 579   conn->getFromInterfaceItem()->unconnectTo(conn->getToInterfaceItem());
 580
 581   scene->removeConnectionItem(conn);
 582   delete conn;
 583
 584   currentGroup->updateInterfacesAndConnections();
 585   params->unsaveModif = true;
 586 }
 587
 588 void Dispatcher::removeUselessGroupInterfaces() {
 589
 590   GroupScene *scene = params->getCurrentScene();
 591   GroupItem* currentGroup = scene->getGroupItem();
 592
 593   foreach(InterfaceItem *inter, currentGroup->getInterfaces()) {
 594     if(inter->refInter->getConnectedTo().length() == 0) {
 595       // NB : remove from view also remove from model
 596       currentGroup->removeInterface(inter);
 597     }
 598   }
 599   scene->updateConnectionItemsShape();
 600 }
 601
 602 void Dispatcher::showBlocksLibrary(){
 603   cout << "showing block library" << endl;
 604   mainWindow->getLibrary()->show();
 605   mainWindow->getLibrary()->raise();
 606 }
 607
 608 void Dispatcher::showProperties(InterfaceItem *inter)
 609 {
 610   new InterfacePropertiesWindow(inter);
 611 }
 612
 613 /* connectInterToGroup() :
 614    The only way for a block (functional of group) within a GroupItem to be connected
 615    to the latter is to right-click on one of its interfaces and to choose "connect to group".
 616    That action will create a new InterfaceItem on the GroupItem and a connectionItem between the
 617    interfaces.
 618 */
 619 void Dispatcher::connectInterToGroup(InterfaceItem *item){
 620
 621   // getting the GroupBlock and GroupItem that are parent of the block that owns item
 622   ConnectedInterface *refInter = item->refInter;
 623   cout << "owner of iface = " << qPrintable(refInter->getOwner()->getName()) << endl;
 624   GroupBlock* parentBlock = AB_TO_GRP(refInter->getOwner()->getParent());
 625   cout << "create iface for parent group = " << qPrintable(parentBlock->getName()) << endl;
 626   GroupItem *parentItem = item->getOwner()->getScene()->getGroupItem();
 627
 628   // creating/adding the group interface in the graph model
 629   GroupInterface *groupInter = new GroupInterface(parentBlock,refInter->getName()+"_group",refInter->getDirection(),refInter->getLevel());
 630   groupInter->setType(refInter->getType());
 631   groupInter->setWidth(refInter->getWidth());
 632   groupInter->setPurpose(refInter->getPurpose());
 633   parentItem->getRefBlock()->addInterface(groupInter);
 634
 635   // connect both interface
 636   bool ok = true;
 637   if (refInter->getDirection() == AbstractInterface::Output) {
 638     ok = refInter->connectTo(groupInter);
 639     ok = ok & groupInter->connectFrom(refInter);
 640   }
 641   else if (refInter->getDirection() == AbstractInterface::Input) {
 642     ok = groupInter->connectTo(refInter);
 643     ok = ok & refInter->connectFrom(groupInter);
 644   }
 645   else if (refInter->getDirection() == AbstractInterface::InOut) {
 646     ok = refInter->connectTo(groupInter);
 647     ok = ok & groupInter->connectFrom(refInter);
 648     ok = ok & groupInter->connectTo(refInter);
 649     ok = ok & refInter->connectFrom(groupInter);
 650   }
 651   if (!ok) {
 652     cerr << "abnormal case while connecting a block iface to its parent group" << endl;
 653   }
 654   // creating/adding the group interface in the current scene model, and connection item
 655   InterfaceItem *groupIfaceItem = new InterfaceItem(0,item->getOrientation(),groupInter,parentItem,params);
 656   parentItem->addInterface(groupIfaceItem,true);
 657
 658   parentItem->getScene()->createConnectionItem(item, groupIfaceItem);
 659
 660   // if groupItem is not topGroup, must also add a new interface to the parent BlockItem
 661   BoxItem* parent2Item = parentItem->getParentItem();
 662   if(parent2Item != NULL){
 663     InterfaceItem *blockIfaceItem = new InterfaceItem(0,item->getOrientation(),groupInter,parent2Item,params);
 664     parent2Item->addInterface(blockIfaceItem,true);
 665   }
 666
 667
 668   parentItem->getScene()->updateConnectionItemsShape();
 669   unselectAllItems();
 670   params->unsaveModif = true;
 671
 672
 673 }
 674
 675 void Dispatcher::disconnectInterFromGroup(InterfaceItem *item) {
 676   static QString fctName = "Dispatcher::disconnectInterFromGroup()";
 677 #ifdef DEBUG_FCTNAME
 678   cout << "call to " << qPrintable(fctName) << endl;
 679 #endif
 680
 681   // getting the GroupBlock and GroupItem that are parent of the block that owns item
 682   ConnectedInterface *refInter = item->refInter;
 683   ConnectedInterface *groupInter = NULL;
 684   GroupBlock* parentGroup = AB_TO_GRP(refInter->getOwner()->getParent());
 685   GroupItem *parentItem = item->getOwner()->getScene()->getGroupItem();
 686
 687   // removing the connection from graph
 688 #ifdef DEBUG
 689   cout << "removing connections from graph ..." ;
 690 #endif
 691
 692   if (refInter->getDirection() == AbstractInterface::Output) {
 693     groupInter = refInter->getConnectionToParentGroup(); // must be a single connection to
 694     refInter->clearConnectedTo();
 695     groupInter->clearConnectedFrom();
 696   }
 697   else if (refInter->getDirection() == AbstractInterface::Input) {
 698     groupInter = refInter->getConnectedFrom();
 699     refInter->clearConnectedFrom();
 700     groupInter->clearConnectedTo();
 701   }
 702   else if (refInter->getDirection() == AbstractInterface::InOut) {
 703     groupInter = refInter->getConnectionToParentGroup(); // must be a single connection to
 704     refInter->clearConnectedTo();
 705     refInter->clearConnectedFrom();
 706     groupInter->clearConnectedTo();
 707     groupInter->clearConnectedFrom();
 708   }
 709 #ifdef DEBUG
 710   cout << "done." << endl ;
 711 #endif
 712
 713   if (groupInter == NULL) {
 714     cerr << "abnormal case 1 while removing an interface item of a block, linked to a parent group" << endl;
 715   }
 716
 717 #ifdef DEBUG
 718   cout << "getting group interface item, and connection item ..." ;
 719 #endif
 720
 721
 722   InterfaceItem* groupIfaceItem = parentItem->searchInterfaceByRef(groupInter);
 723   if (groupIfaceItem == NULL) {
 724     cerr << "abnormal case 2 while removing an interface item of a block, linked to a parent group" << endl;
 725   }
 726   ConnectionItem* conn = parentItem->getScene()->searchConnectionItem(item,groupIfaceItem);
 727   if (conn == NULL) {
 728     cerr << "abnormal case 3 while removing an interface item of a block, linked to a parent group" << endl;
 729   }
 730 #ifdef DEBUG
 731   cout << "done." << endl ;
 732 #endif
 733
 734   // removing the interface group item from the group item, and the connection item
 735 #ifdef DEBUG
 736   cout << "removing group interface item, and connection item ..." ;
 737 #endif
 738
 739   item->removeConnectionItem(conn);
 740   groupIfaceItem->removeConnectionItem(conn);
 741   parentItem->removeInterface(groupIfaceItem); // CAUTION : this deletes the interface item.
 742   parentItem->getScene()->removeConnectionItem(conn);
 743 #ifdef DEBUG
 744   cout << "done." << endl ;
 745 #endif
 746
 747   // removing the interface box item in the parent scene
 748 #ifdef DEBUG
 749   cout << "removing the inteeface item of box item in parent scene if needed ..." ;
 750 #endif
 751
 752   BoxItem* parent2Item = parentItem->getParentItem();
 753   if (parent2Item != NULL) {
 754     InterfaceItem* group2IfaceItem = parent2Item->searchInterfaceByRef(groupInter);
 755     parent2Item->removeInterface(group2IfaceItem);
 756   }
 757 #ifdef DEBUG
 758   cout << "done." << endl ;
 759 #endif
 760
 761   // removing the interface group from the group
 762 #ifdef DEBUG
 763   cout << "removing group interface ..." ;
 764 #endif
 765   parentGroup->removeInterface(groupInter);
 766 #ifdef DEBUG
 767   cout << "done." << endl ;
 768 #endif
 769
 770 }
 771
 772 void Dispatcher::removeGroupInterface(InterfaceItem *item) {
 773   static QString fctName = "Dispatcher::removeGroupInterface()";
 774 #ifdef DEBUG_FCTNAME
 775   cout << "call to " << qPrintable(fctName) << endl;
 776 #endif
 777
 778   /* NB: there is a single connection between item and another one that is owned
 779      by a BoxItem. Thus, we just have to find it and to call disconnectInterFromGroup();
 780    */
 781   ConnectionItem* conn = item->connections.at(0);
 782   if (conn->getFromInterfaceItem() == item) {
 783     disconnectInterFromGroup(conn->getToInterfaceItem());
 784   }
 785   else {
 786     disconnectInterFromGroup(conn->getFromInterfaceItem());
 787   }
 788 }
 789
 790 QMap<int, QString> Dispatcher::getAllGroupNames() {
 791
 792   QMap<int, QString> list;
 793   foreach(GroupWidget *group, groupList) {
 794     list.insert(group->getScene()->getId(), group->getScene()->getGroupItem()->getRefBlock()->getName());
 795   }
 796   return list;
 797 }
 798
 799 GroupScene* Dispatcher::searchSceneById(int id) {
 800   foreach(GroupWidget *group, groupList){
 801     if(group->getScene()->getId() == id)
 802       return group->getScene();
 803   }
 804   cout << "search scene by id :" << id << " :: not found..." << endl;
 805   return NULL;
 806 }
 807
 808 GroupItem *Dispatcher::searchGroupItemById(int id) {
 809   foreach(GroupWidget *group, groupList) {
 810     GroupScene* scene = group->getScene();
 811     if (scene->getGroupItem()->getId() == id) return scene->getGroupItem();
 812   }
 813   cout << "search GroupItem by id :" << id << " :: not found..." << endl;
 814   return NULL;
 815 }
 816
 817 BoxItem *Dispatcher::searchBlockItemById(int id) {
 818   foreach(GroupWidget *group, groupList) {
 819
 820     GroupScene* scene = group->getScene();
 821     foreach(BoxItem *item, scene->getBlockItems()){
 822       if(item->getId() == id){
 823           return item;
 824       }
 825     }
 826   }
 827   cout << "search BlockItem by id :" << id << " :: not found..." << endl;
 828   return NULL;
 829 }
 830
 831 InterfaceItem* Dispatcher::searchInterfaceItemById(int id) {
 832
 833   foreach(GroupWidget *group, groupList) {
 834
 835     GroupScene* scene = group->getScene();
 836
 837     foreach(InterfaceItem *item, scene->getGroupItem()->getInterfaces()){
 838       if(item->getId() == id){
 839         return item;
 840       }
 841     }
 842     foreach(BoxItem *block, scene->getBlockItems()){
 843       foreach(InterfaceItem *item, block->getInterfaces()){
 844         if(item->getId() == id){
 845           return item;
 846         }
 847       }
 848     }
 849   }
 850   cout << "search interface by id :" << id << " :: not found..." << endl;
 851   return NULL;
 852 }
 853