Dispatcher.cpp

   1 #include "Dispatcher.h"
   2 #include "Parameters.h"
   3 #include "MainWindow.h"
   4
   5 #include "ExternalResource.h"
   6
   7 #include "Graph.h"
   8 #include "ReferenceBlock.h"
   9 #include "GroupBlock.h"
  10 #include "FunctionalBlock.h"
  11
  12 #include "ConnectedInterface.h"
  13 #include "ReferenceInterface.h"
  14 #include "GroupInterface.h"
  15 #include "FunctionalInterface.h"
  16
  17 #include "GroupWidget.h"
  18 #include "GroupScene.h"
  19 #include "GroupItem.h"
  20 #include "BoxItem.h"
  21 #include "SourceItem.h"
  22 #include "InterfaceItem.h"
  23 #include "ConnectionItem.h"
  24
  25 #include "BlockLibraryWidget.h"
  26 #include "BlockLibraryTree.h"
  27
  28 #include "AbstractInputModifier.h"
  29 #include "DelayInputModifier.h"
  30
  31
  32 #include "InterfacePropertiesWindow.h"
  33
  34 int Dispatcher::sceneCounter = 0;
  35
  36 Dispatcher::Dispatcher(Parameters* _params, MainWindow* _window) {
  37   params = _params;
  38   mainWindow =_window;
  39   params->setDispatcher(this);
  40   currentGroup = NULL;
  41   topGroup = NULL;
  42 }
  43
  44 GroupWidget *Dispatcher::loadProject(const QString& filename) {
  45
  46   QDomElement root;
  47   try {
  48     root = params->openProjectFile(filename);
  49   }
  50   catch(Exception err) {
  51     return NULL;
  52   }
  53
  54   /*
  55   // creating the top widget/scene
  56   topGroup = new GroupWidget(NULL,this,params);
  57   currentGroup = topGroup;
  58   // getting the newly created scene
  59   GroupScene *scene = topGroup->getScene();
  60
  61   params->setTopScene(scene);
  62   params->setCurrentScene(scene);
  63 */
  64   try {
  65     topGroup = params->loadProject(root);
  66   }
  67   catch(Exception e){
  68     cerr << qPrintable(e.getDefaultMessage()) << endl;
  69     cerr << "Aborting ..." << endl;
  70     // TO DO : deleteting topGroup and all
  71     return NULL;
  72   }
  73
  74   QFileInfo info(filename);
  75   params->projectPath = info.absolutePath();
  76   params->projectName = info.baseName();
  77   cout << "project path = " << qPrintable(params->projectPath) << endl;
  78   groupList.append(topGroup);
  79   return topGroup;
  80 }
  81
  82 void Dispatcher::closeCurrentProject() {
  83
  84   foreach(GroupWidget* win, groupList) {
  85     win->deleteLater();
  86   }
  87   groupList.clear();
  88   params->destroyGraph();
  89   topGroup = NULL;
  90   currentGroup = NULL;
  91   sceneCounter = 0;
  92 }
  93
  94 bool Dispatcher::createConnection(InterfaceItem *iface1, InterfaceItem *iface2, bool visible) {
  95
  96   ConnectedInterface* ref1 = iface1->refInter;
  97   ConnectedInterface* ref2 = iface2->refInter;
  98   // connect both interface
  99
 100   bool ok1 = false;
 101   bool ok2 = false;
 102
 103   // test the ref1->ref2 connection
 104   if ((ref1->canConnectTo(ref2)) && (ref2->canConnectFrom(ref1))) {
 105     ref1->connectTo(ref2);
 106     ok1 = true;
 107   }
 108   // if the frist one did not work, test ref2->ref1
 109   if ((ok1 == false) && (ref2->canConnectTo(ref1)) && (ref1->canConnectFrom(ref2))) {
 110     ref2->connectTo(ref1);
 111     ok2 = true;
 112   }
 113   if ((ok1 == true) || (ok2 == true)) {
 114
 115     iface1->getOwner()->getScene()->createConnectionItem(iface1,iface2, visible);
 116
 117     unselectAllItems();
 118     params->unsaveModif = true;
 119     cout << "created a connection from " << qPrintable(ref1->getName()) << " to " << qPrintable(ref2->getName()) << endl;
 120     return true;
 121   }
 122   return false;
 123 }
 124
 125
 126 void Dispatcher::unselectAllItems(int direction){
 127
 128   GroupScene *scene = params->getCurrentScene();
 129
 130   foreach(BoxItem* block, scene->getBoxItems()) {
 131     block->setSelected(false);
 132     block->setCurrentInterface(NULL);
 133   }
 134   scene->unselecteInterfaces();
 135   scene->update();
 136 }
 137
 138 void Dispatcher::setCurrentGroupWidget(GroupWidget *win){
 139   win->setFocus();
 140   win->changeConnectionMode(-1);
 141   currentGroup = win;
 142   params->setCurrentScene(win->getScene());
 143 }
 144
 145 void Dispatcher::changeConnectionMode(int mode){
 146
 147   /*
 148   foreach(GroupWidget* win, groupList){
 149
 150     QToolButton* buttonNewConnection = win->getButtonNewConnection();
 151
 152     QPalette pal = buttonNewConnection->palette();
 153
 154     if(mode == -1){
 155       if(params->sceneMode != Parameters::EditOnConnection){
 156         params->sceneMode = Parameters::EditOnConnection;
 157         pal.setColor(QPalette::Button, QColor(Qt::lightGray));
 158       } else {
 159         params->sceneMode = Parameters::EditNoOperation;
 160         pal.setColor(QPalette::Button, QColor("#edeceb"));
 161       }
 162     }
 163     else if(mode == Parameters::EditOnConnection){
 164       params->sceneMode = Parameters::EditOnConnection;
 165       pal.setColor(QPalette::Button, QColor(Qt::lightGray));
 166     }
 167     else {
 168       params->sceneMode = Parameters::EditNoOperation;
 169       pal.setColor(QPalette::Button, QColor("#edeceb"));
 170     }
 171     unselectAllInterfaces();
 172
 173     buttonNewConnection->setAutoFillBackground(true);
 174     buttonNewConnection->setPalette(pal);
 175     buttonNewConnection->update();
 176   }
 177   */
 178 }
 179
 180 void Dispatcher::generateVHDL() throw(Exception) {
 181   static QString fctName = "Dispatcher::generateVHDL()";
 182 #ifdef DEBUG_FCTNAME
 183   cout << "call to " << qPrintable(fctName) << endl;
 184 #endif
 185
 186   QDir baseDir(params->projectPath);
 187   QDir srcDir(params->projectPath+"/src");
 188
 189   if (!baseDir.exists()) {
 190     cerr << "Project path " << qPrintable(params->projectPath) << " no longer exists. First, recreate it and put the project file within. Then retry to generate." << endl;
 191     return;
 192   }
 193
 194   if (srcDir.exists()) {
 195     srcDir.removeRecursively();
 196   }
 197   baseDir.mkdir("src");
 198
 199   if (! baseDir.exists("testbench")) {
 200     baseDir.mkdir("testbench");
 201   }
 202   if (! baseDir.exists("Makefile")) {
 203     QFile make("/home/sdomas/Projet/Blast/code/blast/Makefile-isim");
 204     QString dest = params->projectPath;
 205     dest += "/Makefile";
 206     make.copy(dest);
 207   }
 208
 209   // copying external resources
 210   QString dest = params->projectPath;
 211   dest += "/src/";
 212   try {
 213     params->getGraph()->generateVHDL(dest);
 214
 215     QList<QString> extResources = params->getGraph()->getExternalResources();
 216     foreach(QString name, extResources) {
 217       cout << qPrintable(name) << endl;
 218       QList<ExternalResource*> lstRes = params->searchResourceByName(name);
 219       foreach(ExternalResource* res, lstRes) {
 220         QFile resFile(res->getFile());
 221         QFileInfo info(res->getFile());
 222         QString destFile = dest+info.fileName();
 223         cout << "copying " << qPrintable(res->getFile()) << " into " << qPrintable(destFile) << endl;
 224         resFile.copy(destFile);
 225       }
 226     }
 227   }
 228   catch(Exception e) {
 229     throw(e);
 230   }
 231
 232   // creating parameters file
 233   QString paramName = params->projectPath+"/params-isim.txt";
 234   QFile paramFile(paramName);
 235   if (!paramFile.open(QIODevice::WriteOnly)) {
 236     throw(Exception(PROJECTPATH_NOACCESS));
 237   }
 238   QTextStream out(&paramFile);
 239   out << "PROJECT_NAME := " << params->projectName << endl << endl;
 240   out << "SRC_DIR := src" << endl;
 241   out << "TB_DIR := testbench" << endl << endl;
 242   out << "VHDL_SRC := ";
 243   QStringList filter;
 244   filter << "*.vhd" ;
 245   srcDir.setNameFilters(filter);
 246   QStringList listVHDL = srcDir.entryList();
 247   for(int j=0;j<listVHDL.size();j++) {
 248     if (j > 0) {
 249       out << "\t";
 250     }
 251     out << "$(SRC_DIR)/" << qPrintable(listVHDL.at(j));
 252     if (j != listVHDL.size()-1) {
 253       out << " \\";
 254     }
 255     out << endl;
 256   }
 257   out << endl;
 258   out << "VL_SRC := ${XILINX}/verilog/src/glbl.v" << endl << endl;
 259   out << "TB_SRC := $(TB_DIR)/$(PROJECT_NAME)_tb.vhd" << endl << endl;
 260   out << "SIMU_EXE := $(PROJECT_NAME)_tb" << endl << endl;
 261
 262   paramFile.close();
 263
 264
 265 }
 266
 267 void Dispatcher::generateBlockVHDL(BoxItem *item){
 268   static QString fctName = "Dispatcher::generateBlockVHDL()";
 269 #ifdef DEBUG_FCTNAME
 270   cout << "call to " << qPrintable(fctName) << endl;
 271 #endif
 272
 273   if (item->getRefBlock()->isFunctionalBlock()) {
 274     FunctionalBlock* block = AB_TO_FUN(item->getRefBlock());
 275     try {
 276       block->generateVHDL(params->projectPath);
 277     }
 278     catch(Exception e) {
 279       cout << qPrintable(e.getMessage()) << endl;
 280     }
 281   }
 282 }
 283
 284 void Dispatcher::renameFunctionalBlock(BoxItem *item){
 285   static QString fctName = "Dispatcher::renameFunctionalBlock()";
 286 #ifdef DEBUG_FCTNAME
 287   cout << "call to " << qPrintable(fctName) << endl;
 288 #endif
 289
 290   GroupWidget* win = item->getScene()->getGroupWidget();
 291
 292   bool ok = false;
 293   QString text = "";
 294   while (!ok) {
 295     text = QInputDialog::getText(win, "Rename a functional block",
 296                                        "New name:", QLineEdit::Normal,
 297                                        item->getRefBlock()->getName(), &ok);
 298     if (!ok) return;
 299
 300     if (text == item->getRefBlock()->getName()) return;
 301
 302     if( (text.isEmpty()) || (text.length() > 30)) {
 303       QMessageBox::warning(win,"Error in given name",
 304                            "the block name must be shorter than 30 characters, cannot be empty",
 305                            QMessageBox::Ok);
 306       ok = false;
 307     }
 308     else {
 309       FunctionalBlock* block = params->getGraph()->getFunctionalBlockByName(text, AB_TO_GRP(item->getRefBlock()->getParent()));
 310       if (block != NULL) {
 311         QMessageBox::warning(win,"Error in given name",
 312                              "the name provided is similar to that of another functional block within the group",
 313                              QMessageBox::Ok);
 314         ok = false;
 315       }
 316     }
 317   }
 318
 319   item->getRefBlock()->setName(text);
 320   item->nameChanged();
 321 }
 322
 323 void Dispatcher::renameGroupBlock(GroupItem *item){
 324   static QString fctName = "Dispatcher::renameGroupBlock()";
 325 #ifdef DEBUG_FCTNAME
 326   cout << "call to " << qPrintable(fctName) << endl;
 327 #endif
 328
 329   GroupWidget* win = item->getScene()->getGroupWidget();
 330
 331   bool ok = false;
 332   QString text = "";
 333   while (!ok) {
 334     text = QInputDialog::getText(win, "Rename a group",
 335                                        "New name:", QLineEdit::Normal,
 336                                        item->getRefBlock()->getName(), &ok);
 337     if (!ok) return;
 338
 339     if (text == item->getRefBlock()->getName()) return;
 340
 341     if( (text.isEmpty()) || (text.length() > 30)) {
 342       QMessageBox::warning(win,"Error in given name",
 343                            "the block name must be shorter than 30 characters, cannot be empty",
 344                            QMessageBox::Ok);
 345       ok = false;
 346     }
 347     else {
 348       GroupBlock* block = params->getGraph()->getGroupBlockByName(text);
 349       if (block != NULL) {
 350         QMessageBox::warning(win,"Error in given name",
 351                              "the name provided is similar to that of another group",
 352                              QMessageBox::Ok);
 353         ok = false;
 354       }
 355     }
 356   }
 357
 358   item->getRefBlock()->setName(text);
 359   if(item->getScene()->getGroupWidget()->isTopGroup()) {
 360     mainWindow->setWindowTitle("blast - "+text);
 361   }
 362   else {
 363     item->getScene()->getGroupWidget()->setWindowTitle("blast - "+text);
 364   }
 365   item->nameChanged();
 366   mainWindow->getLibrary()->updateComboScene();
 367 }
 368
 369 void Dispatcher::renameSourceBlock(SourceItem *item){
 370   static QString fctName = "Dispatcher::renameSourceBlock()";
 371 #ifdef DEBUG_FCTNAME
 372   cout << "call to " << qPrintable(fctName) << endl;
 373 #endif
 374
 375   GroupWidget* win = item->getScene()->getGroupWidget();
 376
 377   bool ok = false;
 378   QString text = "";
 379   while (!ok) {
 380     text = QInputDialog::getText(win, "Rename a source",
 381                                        "New name:", QLineEdit::Normal,
 382                                        item->getRefBlock()->getName(), &ok);
 383     if (!ok) return;
 384
 385     if (text == item->getRefBlock()->getName()) return;
 386
 387     if( (text.isEmpty()) || (text.length() > 30)) {
 388       QMessageBox::warning(win,"Error in given name",
 389                            "the block name must be shorter than 30 characters, cannot be empty",
 390                            QMessageBox::Ok);
 391       ok = false;
 392     }
 393     else {
 394       FunctionalBlock* block = params->getGraph()->getSourceBlockByName(text);
 395       if (block != NULL) {
 396         QMessageBox::warning(win,"Error in given name",
 397                              "the name provided is similar to that of another source block within the top group",
 398                              QMessageBox::Ok);
 399         ok = false;
 400       }
 401     }
 402   }
 403
 404   item->getRefBlock()->setName(text);
 405   item->nameChanged();
 406 }
 407
 408
 409 void Dispatcher::renameInterface(InterfaceItem *item) {
 410   static QString fctName = "Dispatcher::renameInterface()";
 411 #ifdef DEBUG_FCTNAME
 412   cout << "call to " << qPrintable(fctName) << endl;
 413 #endif
 414
 415   GroupWidget* win = item->getOwner()->getScene()->getGroupWidget();
 416
 417   bool ok = false;
 418   QString text = "";
 419   while (!ok) {
 420     text = QInputDialog::getText(win, "Rename an interface",
 421                                        "New name:", QLineEdit::Normal,
 422                                        item->refInter->getName(), &ok);
 423
 424     if (!ok) return;
 425
 426     if (text == item->refInter->getName()) return;
 427
 428     if( (text.isEmpty()) || (text.length() > 30)) {
 429       QMessageBox::warning(win,"Error in given name",
 430                            "the interface name must be shorter than 30 characters, cannot be empty",
 431                            QMessageBox::Ok);
 432       ok = false;
 433     }
 434     else {
 435       AbstractInterface* iface = item->refInter->getOwner()->getIfaceFromName(text);
 436       if (iface != NULL) {
 437         QMessageBox::warning(win,"Error in given name",
 438                              "the name provided is similar to that of another interface",
 439                              QMessageBox::Ok);
 440         ok = false;
 441       }
 442     }
 443   }
 444   item->refInter->setName(text);
 445   AbstractInterface* assoIface = item->refInter->getAssociatedIface();
 446   if (assoIface != NULL) {
 447     assoIface->setName(text+"_enb");
 448   }
 449   item->updateName(text);
 450   item->getOwner()->nameChanged();
 451 }
 452
 453 void Dispatcher::showPatterns(InterfaceItem *item) {
 454   static QString fctName = "Dispatcher::showPatterns()";
 455 #ifdef DEBUG_FCTNAME
 456   cout << "call to " << qPrintable(fctName) << endl;
 457 #endif
 458   QString msg = "";
 459   if (item->refInter->getDirection() == AbstractInterface::Input) {
 460     msg = "Input pattern of iface ";
 461     msg += item->refInter->getName();
 462     msg += " owned by ";
 463     msg += item->refInter->getOwner()->getName();
 464     msg += " is:\n";
 465     // get the precursor output pattern
 466     ConnectedInterface* connIface = AI_TO_CON(item->refInter->getAssociatedIface());
 467     QList<char>* out = connIface->getConnectedFrom()->getOutputPattern();
 468     // get the modifier
 469     AbstractInputModifier* modifier = connIface->getInputModifier();
 470     // check if the input is modified
 471     if (modifier != NULL) {
 472
 473       out = modifier->getModifiedInput(out);
 474     }
 475
 476     foreach(char c, *out) {
 477       msg += QString::number((int)c);
 478     }
 479     msg += "\n";
 480   }
 481   else if (item->refInter->getDirection() == AbstractInterface::Output) {
 482     msg = "Output pattern of iface ";
 483     msg += item->refInter->getName();
 484     msg += " owned by ";
 485     msg += item->refInter->getOwner()->getName();
 486     msg += " is:\n";
 487     ConnectedInterface* iface = AI_TO_CON(item->refInter->getAssociatedIface());
 488     if (iface->getOutputPattern() == NULL) return;
 489     foreach(char c, *(iface->getOutputPattern())) {
 490       msg += QString::number((int)c);
 491     }
 492     msg += "\n";
 493   }
 494   QMessageBox::information(NULL,"Interface pattern",msg,QMessageBox::Ok,QMessageBox::Ok);
 495 }
 496
 497 void Dispatcher::showModifier(InterfaceItem *item) {
 498   static QString fctName = "Dispatcher::showModifier()";
 499 #ifdef DEBUG_FCTNAME
 500   cout << "call to " << qPrintable(fctName) << endl;
 501 #endif
 502   QString msg = "";
 503   ConnectedInterface* assoIface = AI_TO_CON(item->refInter->getAssociatedIface());
 504   AbstractInputModifier* mod = assoIface->getInputModifier();
 505   if (mod->isDelay()) {
 506     DelayInputModifier* delay = (DelayInputModifier *)mod;
 507     msg = "Pattern of iface ";
 508     msg += item->refInter->getName();
 509     msg += " owned by ";
 510     msg += item->refInter->getOwner()->getName();
 511     msg += " is modified by a simple delay of ";
 512     msg += QString::number(delay->getDelayLength());
 513
 514   }
 515   QMessageBox::information(NULL,"Interface pattern",msg,QMessageBox::Ok,QMessageBox::Ok);
 516 }
 517
 518 void Dispatcher::removeModifier(InterfaceItem *item) {
 519   static QString fctName = "Dispatcher::showModifier()";
 520 #ifdef DEBUG_FCTNAME
 521   cout << "call to " << qPrintable(fctName) << endl;
 522 #endif
 523
 524   ConnectedInterface* assoIface = AI_TO_CON(item->refInter->getAssociatedIface());
 525   assoIface->clearInputModifier();
 526 }
 527
 528
 529 void Dispatcher::duplicateBoxItem(BoxItem *item){
 530   static QString fctName = "Dispatcher::duplicateBoxItem()";
 531 #ifdef DEBUG_FCTNAME
 532   cout << "call to " << qPrintable(fctName) << endl;
 533 #endif
 534
 535   GroupScene *scene = item->getScene();
 536   AbstractBlock* block = item->getRefBlock();
 537   AbstractBlock *newBlock;
 538
 539   // only duplicate functional blocks
 540   if(block->isFunctionalBlock()) {
 541
 542     // adding to the model
 543     FunctionalBlock* funBlock = (FunctionalBlock*)block;
 544     newBlock = params->getGraph()->duplicateFunctionalBlock(funBlock);
 545     // adding to the view
 546     scene->createBoxItem(newBlock);
 547
 548     params->unsaveModif = true;
 549   }
 550 }
 551
 552 void Dispatcher::duplicateSourceItem(SourceItem *item) {
 553   static QString fctName = "Dispatcher::duplicateSourceItem()";
 554 #ifdef DEBUG_FCTNAME
 555   cout << "call to " << qPrintable(fctName) << endl;
 556 #endif
 557
 558   GroupScene *scene = item->getScene();
 559   AbstractBlock* block = item->getRefBlock();
 560   AbstractBlock *newBlock;
 561
 562   // only duplicate functional blocks
 563   if(block->isFunctionalBlock()) {
 564
 565     // adding to the model
 566     FunctionalBlock* funBlock = (FunctionalBlock*)block;
 567     newBlock = params->getGraph()->duplicateSourceBlock(funBlock);
 568     // adding to the view
 569     scene->createSourceItem(newBlock);
 570
 571     params->unsaveModif = true;
 572   }
 573 }
 574
 575 void Dispatcher::duplicateInterfaceItem(InterfaceItem *item) {
 576   static QString fctName = "Dispatcher::duplicateInterfaceItem()";
 577 #ifdef DEBUG_FCTNAME
 578   cout << "call to " << qPrintable(fctName) << endl;
 579 #endif
 580
 581   AbstractInterface *refI = item->refInter;
 582   if (! refI->isFunctionalInterface()) return;
 583
 584   AbstractBlock *refB = refI->getOwner();
 585   if(! refB->isFunctionalBlock()) return;
 586
 587   FunctionalInterface* iface = (FunctionalInterface*)refI;
 588   AbstractInterface *cloneIface = iface->clone();
 589   if (cloneIface == NULL) {
 590     QMessageBox::warning(NULL,"Error while cloning an interface","the interface cannot be cloned because its maximum multiplicity is reached", QMessageBox::Ok);
 591     return;
 592   }
 593
 594   refB->addInterface(cloneIface);
 595
 596   InterfaceItem *cloneIfaceItem = new InterfaceItem(item->getPosition(),item->getOrientation(),(ConnectedInterface*)cloneIface,item->getOwner(),params);
 597   item->getOwner()->addInterfaceItem(cloneIfaceItem,true);
 598
 599   // creating control interface if needed
 600   if (refI->getAssociatedIface() != NULL) {
 601     QString ctlName = cloneIface->getName()+"_enb";
 602     ReferenceInterface* ctlIface = new ReferenceInterface(refB,ctlName,cloneIface->getDirection(), AbstractInterface::Control,"boolean","1", AbstractInterface::LittleEndian, 1);
 603     refB->addInterface(ctlIface);
 604     if (! ctlIface->setAssociatedIface(cloneIface)) {
 605       cerr << "Abnormal case while cloning an interface and creating its associated control interface" << endl;
 606     }
 607   }
 608 }
 609
 610
 611 BoxItem* Dispatcher::addBlock(int idCategory, int idBlock, int idScene) {
 612   static QString fctName = "Dispatcher::addBlock()";
 613 #ifdef DEBUG_FCTNAME
 614   cout << "call to " << qPrintable(fctName) << endl;
 615 #endif
 616   bool newSource = false;
 617   BoxItem* item = NULL;
 618   GroupScene *scene = getSceneById(idScene);
 619   ReferenceBlock* ref = params->getReferenceBlock(idCategory,idBlock);
 620   // if block has no inputs, propose to add it as a source to top scene
 621   if ((scene->isTopScene()) && (ref->isGeneratorBlock())) {
 622     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 ?");
 623     if (ret == QMessageBox::Yes) {
 624       newSource = true;
 625     }
 626   }
 627   if (newSource) {
 628     FunctionalBlock* newOne = params->getGraph()->createSourceBlock(ref);
 629     scene->createSourceItem(newOne);
 630   }
 631   else {
 632     GroupBlock* group = AB_TO_GRP(scene->getGroupItem()->getRefBlock());
 633     FunctionalBlock* newOne = params->getGraph()->createFunctionalBlock(group, ref);
 634     item = scene->createBoxItem(newOne);
 635     params->blockToItem.insert(newOne,item);
 636   }
 637   params->unsaveModif = true;
 638   return item;
 639 }
 640
 641
 642 GroupWidget *Dispatcher::createTopScene(){
 643   static QString fctName = "Dispatcher::createTopScene()";
 644 #ifdef DEBUG_FCTNAME
 645   cout << "call to " << qPrintable(fctName) << endl;
 646 #endif
 647
 648   // creating the model part of the group
 649   Graph* graph = params->createGraph();
 650   GroupBlock *topBlock = graph->getTopGroup();
 651   // creating the clkrstgen block
 652   ReferenceBlock* ref = params->getHiddenReferenceBlock("clkrstgen");
 653   FunctionalBlock* newOne = params->getGraph()->createFunctionalBlock(topBlock, ref);
 654   ConnectedInterface* fromIface = AI_TO_CON(topBlock->getIfaceFromName("ext_clk"));
 655   ConnectedInterface* toIface = AI_TO_CON(newOne->getIfaceFromName("ext_clk"));
 656   fromIface->connectTo(toIface);
 657   fromIface = AI_TO_CON(topBlock->getIfaceFromName("ext_reset"));
 658   toIface = AI_TO_CON(newOne->getIfaceFromName("ext_reset"));
 659   fromIface->connectTo(toIface);
 660
 661   // creating a fake and not connected interface
 662   //AbstractInterface* iface = new GroupInterface(refBlock,"grp_iface",AbstractInterface::Input,AbstractInterface::Top);
 663
 664   // creating the group widget
 665   topGroup = new GroupWidget(NULL,this,params);
 666   currentGroup = topGroup;
 667   // getting the newly created scene
 668   GroupScene *scene = topGroup->getScene();
 669   scene->setId(sceneCounter++);
 670   params->setTopScene(scene);
 671   params->setCurrentScene(scene);
 672   // creating the view part of the group
 673   GroupItem *group = new GroupItem(NULL,topBlock,this,params);
 674
 675
 676   // adding the fake interface to the top group item
 677   //InterfaceItem* item = new InterfaceItem(0.0 , Parameters::West, (ConnectedInterface*)iface, group, params);
 678   //group->addInterface(item,true);
 679
 680   scene->setGroupItem(group);
 681
 682   groupList.append(topGroup);
 683   return topGroup;
 684 }
 685
 686 GroupWidget* Dispatcher::addNewEmptyGroup(GroupScene* scene, bool show) {
 687   static QString fctName = "Dispatcher::addNewEmptyGroup();";
 688 #ifdef DEBUG_FCTNAME
 689   cout << "call to " << qPrintable(fctName) << endl;
 690 #endif
 691
 692   // getting the parent block in the graph
 693   GroupBlock* parent = AB_TO_GRP(scene->getGroupItem()->getRefBlock());
 694   cout << "new group : parent = "<< qPrintable(parent->getName()) << endl;
 695   GroupBlock* groupBlock = params->getGraph()->createChildGroupBlock(parent);
 696   cout << "new group : child = "<< qPrintable(groupBlock->getName()) << ", child of " << qPrintable(groupBlock->getParent()->getName()) << endl;
 697   // creating the BlockItem in the scene
 698   BoxItem* newItem = scene->createBoxItem(groupBlock);
 699
 700   params->unsaveModif = true;
 701
 702   GroupWidget* child = createChildScene(scene->getGroupWidget(),newItem);
 703   if (show) child->show();
 704   return child;
 705
 706 }
 707
 708 GroupWidget *Dispatcher::createChildScene(GroupWidget* parentWidget, BoxItem *upperItemOfGroupItem) {
 709   static QString fctName = "Dispatcher::createChildScene()";
 710 #ifdef DEBUG_FCTNAME
 711   cout << "call to " << qPrintable(fctName) << endl;
 712 #endif
 713
 714   GroupWidget* group = NULL;
 715   /* NB: this method may be called during design process or when loading
 716      a project. In this case, upperItemOfGroupItem is NULL, thus a lot of things
 717      cannot be initialized yet. This is why there are 2 cases below
 718    */
 719
 720   if (upperItemOfGroupItem != NULL) {
 721     // getting back the goup block already created
 722     GroupBlock* groupBlock = AB_TO_GRP(upperItemOfGroupItem->getRefBlock());
 723     // creating the view part of the group
 724     GroupItem *groupItem = new GroupItem(upperItemOfGroupItem,groupBlock,this,params);
 725
 726     // creating the group widget
 727     group = new GroupWidget(parentWidget, this, params);
 728     // getting the newly created scene
 729     GroupScene *scene = group->getScene();
 730     scene->setId(sceneCounter++);
 731     // affecting group item to the scene
 732     scene->setGroupItem(groupItem);
 733     groupList.append(group);
 734
 735     mainWindow->getLibrary()->updateComboScene();
 736   }
 737   else {
 738     GroupItem *groupItem = new GroupItem(this,params);
 739     // creating the group widget
 740     group = new GroupWidget(parentWidget, this, params);
 741     // getting the newly created scene
 742     GroupScene *scene = group->getScene();
 743     // affecting group item to the scene
 744     scene->setGroupItem(groupItem);
 745     groupList.append(group);
 746   }
 747   return group;
 748 }
 749
 750 void Dispatcher::destroyScene(GroupScene *scene) {
 751   foreach(GroupScene* s, scene->getChildrenScene()) {
 752     destroyScene(s);
 753   }
 754
 755   if (scene->getNbChildScene() == 0) {
 756     // remove scene from the parent list, if possible
 757     if (scene->getParentScene() != NULL) {
 758       scene->getParentScene()->removeChildScene(scene);
 759     }
 760     // destroy the GroupWidget
 761     groupList.removeAll(scene->getGroupWidget());
 762     scene->getGroupWidget()->deleteLater();
 763   }
 764   else {
 765     cerr << "Abnormal case when destroying a scene" << endl;
 766   }
 767 }
 768
 769 void Dispatcher::showRaiseWindow(BoxItem *item) {
 770   static QString fctName = "Dispatcher::showRaiseWindow()";
 771 #ifdef DEBUG_FCTNAME
 772   cout << "call to " << qPrintable(fctName) << endl;
 773 #endif
 774
 775   cout << "raising child scene of " << qPrintable(item->getRefBlock()->getName()) << endl;
 776   GroupItem* child = item->getChildGroupItem();
 777   if (child == NULL) {
 778     cerr << "abnormal case: child group item is null " << endl;
 779     return;
 780   }
 781
 782   GroupWidget* win = child->getScene()->getGroupWidget();
 783
 784   win->showNormal();
 785   win->raise();
 786   win->activateWindow();
 787
 788   currentGroup = win;
 789   params->setCurrentScene(currentGroup->getScene());
 790 }
 791
 792 void Dispatcher::showRstClkIface(AbstractBoxItem *item) {
 793   static QString fctName = "Dispatcher::showRstClkIface()";
 794 #ifdef DEBUG_FCTNAME
 795   cout << "call to " << qPrintable(fctName) << endl;
 796 #endif
 797
 798   item->setRstClkVisible(!item->isRstClkVisible());
 799
 800 }
 801
 802 void Dispatcher::showWishboneIface(AbstractBoxItem *item) {
 803   static QString fctName = "Dispatcher::showWishboneIface()";
 804 #ifdef DEBUG_FCTNAME
 805   cout << "call to " << qPrintable(fctName) << endl;
 806 #endif
 807
 808   item->setWishboneVisible(!item->isWishboneVisible());
 809 }
 810
 811 void Dispatcher::addNewFullGroup() {
 812   static QString fctName = "Dispatcher::addNewFullGroup()";
 813 #ifdef DEBUG_FCTNAME
 814   cout << "call to " << qPrintable(fctName) << endl;
 815 #endif
 816
 817
 818 #ifdef DEBUG_INCLFUN
 819
 820   QList<BlockItem*> listBlocks = params->getCurrentScene()->getSelectedBlocks(); //selected blocks in the current scene
 821   QList<AbstractBlock*> listAbstractBlocks;   //abstract blocks in the group
 822   QList<ConnectionItem *> connections = params->getCurrentScene()->getConnectionItems();
 823
 824   /* What must be done:
 825      1 - creating a new GroupBlock
 826      2 - moving the selected blocks from the current GroupBlock to the new GroupBlock
 827      3 - creating a BlockItem that references the new GroupBlock
 828      4 - creating a new GroupWidget
 829      5 - creating a new GroupItem added to the scene of the GroupWidget
 830
 831    */
 832
 833   /* step 1 : creating new GroupBlock that will have as a parent the GroupBlock
 834      associated to the GroupItem of the current scene
 835    */
 836   GroupBlock* parentBlock = params->getCurrentScene()->getGroupItem()->getRefBlock();
 837   GroupBlock* newGroupBlock = new GroupBlock(parentBlock);
 838   /* step 2: moving selected blocks */
 839   foreach(BlockItem* blockItem, listBlocks) {
 840     parentBlock->removeBlock(blockItem->getRefBlock());
 841     newGroupBlock->addBlock(blockItem->getRefBlock());
 842   }
 843
 844   GroupItem *parent = currentGroup->getScene()->getGroupItem();
 845   GroupBlock *groupBlock = new GroupBlock(((GroupBlock*)parent->getRefBlock()),params->currentWindow);
 846   BlockItem *blockItem = new BlockItem(params->getCurrentScene()->getGroupItem(),groupBlock,this,params);
 847   GroupItem *groupItem = new GroupItem(blockItem,groupBlock,this,params);
 848
 849   //create the new window
 850   GroupWidget* win = new GroupWidget(this,params);
 851   win->getScene()->setGroupItem(groupItem);
 852   win->getScene()->addItem(groupItem);
 853   ((GroupBlock*)groupItem->getRefBlock())->setWindow(win);
 854   params->addWindow(win);
 855   win->show();
 856
 857   //add the new group
 858   params->getCurrentScene()->addBlockItem(blockItem);
 859   params->getCurrentScene()->addItem(blockItem);
 860   ((GroupItem*)params->getCurrentScene()->getGroupItem())->addBlockItem(blockItem);
 861
 862   //replace selected blocks in the group
 863   foreach(AbstractBoxItem *block, listBlocks){
 864     ((GroupItem*)block->getParentItem())->removeBlockItem(block);
 865     ((GroupBlock*)block->getParentItem()->getRefBlock())->removeBlock(block->getRefBlock());
 866     params->getCurrentScene()->removeItem(block);
 867     params->getCurrentScene()->removeBlockItem(block);
 868
 869     groupBlock->addBlock(block->getRefBlock());
 870     listAbstractBlocks.append(block->getRefBlock());
 871
 872     block->setUpperItem(groupItem);
 873     groupItem->addBlockItem(block);
 874     win->getScene()->addItem(block);
 875     win->getScene()->addBlockItem(block);
 876   }
 877
 878   //replace connection between selected blocks in the group
 879   foreach(ConnectionItem *conn, connections){
 880     if(listBlocks.contains(conn->getFromInterfaceItem()->getOwner())){
 881       if(listBlocks.contains(conn->getToInterfaceItem()->getOwner())){
 882         parent->removeConnection(conn);
 883         params->getCurrentScene()->removeItem(conn);
 884
 885         groupItem->addConnection(conn);
 886         win->getScene()->addItem(conn);
 887       }
 888     }
 889   }
 890
 891   //create new interfaces and connections for the new group
 892   foreach(AbstractBoxItem *block, listBlocks){
 893     foreach(InterfaceItem *inter, block->getInterfaces()){
 894       cout << "inter : " << inter->getName().toStdString() << endl;
 895       if(inter->refInter->getConnectedFrom() != NULL && inter->refInter->getDirection() == AbstractInterface::Input){
 896         cout << "connected from non null" << endl;
 897         if(!listAbstractBlocks.contains(inter->refInter->getConnectedFrom()->getOwner())){
 898
 899           AbstractInterface *iface = inter->refInter->clone(0);
 900           iface->setName(iface->getName()+"_group");
 901           groupBlock->addInterface(iface);
 902
 903           InterfaceItem *ifaceItem = new InterfaceItem(0,Parameters::East,iface,blockItem,params);
 904           blockItem->addInterface(ifaceItem);
 905           blockItem->resetInterfacesPosition();
 906
 907           InterfaceItem *ifaceGroupItem = new InterfaceItem(0,Parameters::West,iface,groupItem,params);
 908           groupItem->addInterface(ifaceGroupItem);
 909           groupItem->resetInterfacesPosition();
 910           foreach(ConnectionItem* conn, currentGroup->getScene()->getInterfaceConnections(inter)){
 911             if(conn->getToInterfaceItem() == inter){
 912               conn->setToInterfaceItem(ifaceItem);
 913               ifaceItem->refInter->setConnectedFrom(NULL);
 914               conn->getFromInterfaceItem()->refInter->clearConnectedTo();
 915               connect(ifaceItem,conn->getFromInterfaceItem());
 916             }
 917           }
 918           params->setCurrentWindow(win);
 919
 920           inter->refInter->setConnectedFrom(NULL);
 921           ifaceGroupItem->refInter->clearConnectedTo();
 922           connect(inter,ifaceGroupItem);
 923           params->setCurrentWindow(mainWindow);
 924         }
 925       }
 926
 927       if(!inter->refInter->getConnectedTo().isEmpty() && inter->refInter->getDirection() == AbstractInterface::Output){
 928         cout << "connected to non null" << endl;
 929         foreach(AbstractInterface *iface, inter->refInter->getConnectedTo()){
 930           if(!listAbstractBlocks.contains(iface->getOwner())){
 931
 932             AbstractInterface *iface = inter->refInter->clone(0);
 933             iface->setName(iface->getName()+"_group");
 934             groupBlock->addInterface(iface);
 935
 936             InterfaceItem *ifaceItem = new InterfaceItem(0,Parameters::East,iface,blockItem,params);
 937             blockItem->addInterface(ifaceItem);
 938             blockItem->resetInterfacesPosition();
 939
 940             foreach(ConnectionItem* conn, currentGroup->getScene()->getInterfaceConnections(inter)){
 941               if(conn->getFromInterfaceItem() == inter){
 942                 conn->setFromInterfaceItem(ifaceItem);
 943                 iface->addConnectedTo(conn->getToInterfaceItem()->refInter);
 944                 conn->getToInterfaceItem()->refInter->setConnectedFrom(iface);
 945               }
 946             }
 947
 948             InterfaceItem *ifaceGroupItem = new InterfaceItem(0,Parameters::East,iface,groupItem,params);
 949             groupItem->addInterface(ifaceGroupItem);
 950             groupItem->resetInterfacesPosition();
 951             inter->refInter->clearConnectedTo();
 952             ifaceGroupItem->refInter->setConnectedFrom(NULL);
 953             connect(ifaceGroupItem,inter);
 954           }
 955         }
 956       }
 957     }
 958   }
 959
 960   //update window
 961
 962   parent->updateShape();
 963   currentGroup->getScene()->updateConnectionItemsShape();
 964   currentGroup = win;
 965   groupItem->updateShape();
 966   win->getScene()->updateConnectionItemsShape();
 967   groupItem->update(groupItem->boundingRect());
 968
 969 #endif
 970 }
 971
 972 void Dispatcher::removeBoxItem(BoxItem *item) {
 973   static QString fctName = "Dispatcher::removeBoxItem()";
 974 #ifdef DEBUG_FCTNAME
 975   cout << "call to " << qPrintable(fctName) << endl;
 976 #endif
 977
 978   /* a BoxItem (group of func) can be removed only if none of its
 979      interfaces is connected to a group interface that is itself
 980      connected to another one.
 981   */
 982   bool canRemove = true;
 983
 984   foreach(InterfaceItem* ifaceItem, item->getInterfaces()) {
 985     foreach(ConnectionItem* conn, ifaceItem->connections) {
 986       InterfaceItem* other = NULL;
 987       if (conn->getFromInterfaceItem() == ifaceItem) {
 988         other = conn->getToInterfaceItem();
 989       }
 990       else {
 991         other = conn->getFromInterfaceItem();
 992       }
 993
 994       if (other->getOwner()->isGroupItem()) {
 995         ConnectedInterface* ref = other->refInter;
 996         if ((ref->isConnectedFrom()) && (ref->isConnectedTo())) {
 997           canRemove = false;
 998         }
 999       }
1000     }
1001   }
1002   if (!canRemove) {
1003     QMessageBox::warning(NULL,"Forbidden operation",
1004                          "The block has at least one connection to a group interface that is totally connected.",
1005                          QMessageBox::Ok);
1006     return;
1007   }
1008
1009   QString msg = "";
1010   if (item->getRefBlock()->isFunctionalBlock()) {
1011     msg = "Removing block ";
1012   }
1013   else {
1014      msg = "Removing group ";
1015   }
1016   msg += item->getRefBlock()->getName();
1017   msg += " and all its connections.\n\nAre you sure ?";
1018
1019   int ret = QMessageBox::question(NULL,"Removing functional block",msg, QMessageBox::Ok | QMessageBox::Cancel, QMessageBox::Ok);
1020   if (ret == QMessageBox::Cancel) {
1021     return;
1022   }
1023   removeAllBlockConnections(item);
1024
1025   if (item->getRefBlock()->isFunctionalBlock()) {
1026     FunctionalBlock* block = AB_TO_FUN(item->getRefBlock());
1027     item->getScene()->removeBoxItem(item);
1028     params->getGraph()->removeFunctionalBlock(block);
1029     params->blockToItem.remove(block);
1030
1031   }
1032   else if (item->getRefBlock()->isGroupBlock()) {
1033
1034     GroupBlock* group = AB_TO_GRP(item->getRefBlock());
1035
1036     // remove all child scenes recursively
1037     GroupItem* subgroup = item->getChildGroupItem();
1038     destroyScene(subgroup->getScene());
1039     // remove the BoxItem
1040     item->getScene()->removeBoxItem(item);
1041     // remove the group from the graph
1042     params->getGraph()->removeGroupBlock(group);
1043   }
1044 }
1045
1046 void Dispatcher::removeAllBlockConnections(AbstractBoxItem *item) {
1047   static QString fctName = "Dispatcher::removeAllBlockConnection()";
1048 #ifdef DEBUG_FCTNAME
1049   cout << "call to " << qPrintable(fctName) << endl;
1050 #endif
1051
1052   foreach(InterfaceItem* ifaceItem, item->getInterfaces()) {
1053     foreach(ConnectionItem* conn, ifaceItem->connections) {
1054       removeConnection(conn);
1055     }
1056   }
1057 }
1058
1059 void Dispatcher::removeSourceItem(SourceItem *item) {
1060   static QString fctName = "Dispatcher::removeSourceItem()";
1061 #ifdef DEBUG_FCTNAME
1062   cout << "call to " << qPrintable(fctName) << endl;
1063 #endif
1064
1065   QString msg = "Removing source ";
1066
1067   msg += item->getRefBlock()->getName();
1068   msg += " and all its connections.\n\nAre you sure ?";
1069
1070   int ret = QMessageBox::question(NULL,"Removing source block",msg, QMessageBox::Ok | QMessageBox::Cancel, QMessageBox::Ok);
1071   if (ret == QMessageBox::Cancel) {
1072     return;
1073   }
1074   removeAllBlockConnections(item);
1075
1076   FunctionalBlock* block = AB_TO_FUN(item->getRefBlock());
1077   item->getScene()->removeSourceItem(item);
1078   params->getGraph()->removeSourceBlock(block);
1079 }
1080
1081
1082 void Dispatcher::removeConnection(ConnectionItem *connItem) {
1083   static QString fctName = "Dispatcher::removeConnection()";
1084 #ifdef DEBUG_FCTNAME
1085   cout << "call to " << qPrintable(fctName) << endl;
1086 #endif
1087   InterfaceItem* fromIfaceItem = connItem->getFromInterfaceItem();
1088   InterfaceItem* toIfaceItem = connItem->getToInterfaceItem();
1089
1090 #ifdef DEBUG
1091   cout << "remove connection from " << qPrintable(fromIfaceItem->refInter->getName()) << " to " << qPrintable(toIfaceItem->refInter->getName()) << endl;
1092 #endif
1093
1094   InterfaceItem* groupIfaceItem = NULL; // in case of one of the two interface belongs to the GroupItem, and stays NULL if not
1095   GroupItem* groupItem = NULL; // the GroupItem of the scene that contains connItem
1096
1097   ConnectedInterface *fromInter = fromIfaceItem->refInter;
1098   ConnectedInterface *toInter = toIfaceItem->refInter;
1099
1100   // test if one of the interface bounded to item is owned by a GroupItem
1101   if (fromIfaceItem->getOwner()->isGroupItem()) {
1102     groupItem = ABI_TO_GI(fromIfaceItem->getOwner());
1103     groupIfaceItem = fromIfaceItem;
1104   }
1105   else if (toIfaceItem->getOwner()->isGroupItem()) {
1106     groupItem = ABI_TO_GI(toIfaceItem->getOwner());
1107     groupIfaceItem = toIfaceItem;
1108   }
1109   else {
1110     groupItem = fromIfaceItem->getOwner()->getScene()->getGroupItem();
1111   }
1112
1113   // removing the connection from graph
1114 #ifdef DEBUG
1115   cout << "removing connections from graph ..." ;
1116 #endif
1117   fromInter->disconnectTo(toInter);
1118
1119 #ifdef DEBUG
1120   cout << "done." << endl ;
1121 #endif
1122
1123   // removing the connection from scene
1124 #ifdef DEBUG
1125   cout << "removing connections from scene ..." ;
1126 #endif
1127   groupItem->getScene()->removeConnectionItem(connItem);
1128
1129 #ifdef DEBUG
1130   cout << "done." << endl ;
1131 #endif
1132
1133   // if one of the interface bounded to connItem is owned by the GroupItem of the scene
1134   if (groupIfaceItem != NULL) {
1135
1136     // determine if the interface must be removed since it has no more connections.
1137     bool groupInterRemove = false;
1138     if ((groupIfaceItem->refInter->isConnectedTo() == false) && (groupIfaceItem->refInter->isConnectedFrom() == false)) groupInterRemove = true;
1139
1140     if (groupInterRemove) {
1141       // get the GroupInterface from interface item
1142       ConnectedInterface* groupInter = groupIfaceItem->refInter;
1143       // remove interface from GroupItem, and delete it.
1144       groupItem->removeInterfaceItem(groupIfaceItem);
1145       // get the parent BoxItem of GroupItem if it exists.
1146       BoxItem* parent2Item = groupItem->getParentItem();
1147       if (parent2Item != NULL) {
1148         InterfaceItem* group2IfaceItem = parent2Item->searchInterfaceItemByRef(groupInter);
1149         // remove interface intem in parent BoxItem
1150         parent2Item->removeInterfaceItem(group2IfaceItem);
1151       }
1152       // remove GroupInterface in the graph.
1153       groupInter->getOwner()->removeInterface(groupInter);
1154     }
1155   }
1156 }
1157
1158 void Dispatcher::showBlocksLibrary(){
1159   cout << "showing block library" << endl;
1160   mainWindow->getLibrary()->show();
1161   mainWindow->getLibrary()->raise();
1162 }
1163
1164 void Dispatcher::showProperties(InterfaceItem *inter) {
1165   new InterfacePropertiesWindow(inter);
1166 }
1167
1168 /* connectInterToGroup() :
1169    The only way for a block (functional of group) within a GroupItem to be connected
1170    to the latter is to right-click on one of its interfaces and to choose "connect to group".
1171    That action will create a new InterfaceItem on the GroupItem and a connectionItem between the
1172    interfaces.
1173 */
1174 void Dispatcher::connectInterToGroup(InterfaceItem *item){
1175
1176   // getting the GroupBlock and GroupItem that are parent of the block that owns item
1177   ConnectedInterface *refInter = item->refInter;
1178   cout << "owner of iface = " << qPrintable(refInter->getOwner()->getName()) << endl;
1179   GroupBlock* parentBlock = AB_TO_GRP(refInter->getOwner()->getParent());
1180   cout << "create iface for parent group = " << qPrintable(parentBlock->getName()) << endl;
1181   GroupItem *parentItem = item->getOwner()->getScene()->getGroupItem();
1182
1183   // creating/adding the group interface in the graph model
1184   GroupInterface *groupInter = new GroupInterface(parentBlock,refInter->getName()+"_group",refInter->getDirection(),refInter->getPurpose());
1185   parentItem->getRefBlock()->addInterface(groupInter);
1186   // creating/adding the group control interface in the graph model if the purpose is data
1187   if (refInter->getPurpose() == AbstractInterface::Data) {
1188     GroupInterface *groupCtlInter = new GroupInterface(parentBlock,refInter->getName()+"_group_enb",refInter->getDirection(),AbstractInterface::Control);
1189     groupCtlInter->setAssociatedIface(groupInter);
1190     parentItem->getRefBlock()->addInterface(groupCtlInter);
1191   }
1192   // creating/adding the group interface in the current scene model, and connection item
1193   InterfaceItem *groupIfaceItem = new InterfaceItem(0,item->getOrientation(),groupInter,parentItem,params);
1194   parentItem->addInterfaceItem(groupIfaceItem,true);
1195
1196   // creating the connection, in graph and with an item
1197   createConnection(item, groupIfaceItem);
1198
1199   // if groupItem is not topGroup, must also add a new interface to the parent BlockItem
1200   BoxItem* parent2Item = parentItem->getParentItem();
1201   if(parent2Item != NULL){
1202     InterfaceItem *blockIfaceItem = new InterfaceItem(0,item->getOrientation(),groupInter,parent2Item,params);
1203     parent2Item->addInterfaceItem(blockIfaceItem,true);
1204   }
1205
1206
1207   parentItem->getScene()->updateConnectionItemsShape();
1208   unselectAllItems();
1209   params->unsaveModif = true;
1210 }
1211
1212 void Dispatcher::removeFunctionalInterface(InterfaceItem *item) {
1213   static QString fctName = "Dispatcher::removeBlockInterface()";
1214 #ifdef DEBUG_FCTNAME
1215   cout << "call to " << qPrintable(fctName) << endl;
1216 #endif
1217
1218   /* first, remove all connections from item
1219      NB:  if there is a connection to a group interface, then this
1220      method should not be called if the group interface is also
1221      connected to another interface. Normally, this is not possible
1222      because such a check is done when creating the contextual menu
1223      that allows to remove an interface.
1224    */
1225   foreach(ConnectionItem* conn, item->connections) {
1226     removeConnection(conn);
1227   }
1228
1229   ConnectedInterface* ref = item->refInter;
1230   item->getOwner()->removeInterfaceItem(item);
1231   FunctionalBlock* fun = AB_TO_FUN(ref->getOwner());
1232   fun->removeInterface(ref);
1233 }
1234
1235 void Dispatcher::removeGroupInterface(InterfaceItem *item) {
1236   static QString fctName = "Dispatcher::removeGroupInterface()";
1237 #ifdef DEBUG_FCTNAME
1238   cout << "call to " << qPrintable(fctName) << endl;
1239 #endif
1240
1241   /* NB: just remove all connections from/to this item, since when there are no more
1242      ones to a GroupItem, it is automatically deleted.
1243    */
1244   foreach(ConnectionItem* conn, item->connections) {
1245     removeConnection(conn);
1246   }
1247 }
1248
1249 QMap<int, QString> Dispatcher::getAllGroupNames() {
1250
1251   QMap<int, QString> list;
1252   foreach(GroupWidget *group, groupList) {
1253     list.insert(group->getScene()->getId(), group->getScene()->getGroupItem()->getRefBlock()->getName());
1254   }
1255   return list;
1256 }
1257
1258 GroupScene* Dispatcher::getSceneById(int id) {
1259   foreach(GroupWidget *group, groupList){
1260     if(group->getScene()->getId() == id)
1261       return group->getScene();
1262   }
1263   cout << "search scene by id :" << id << " :: not found..." << endl;
1264   return NULL;
1265 }
1266
1267 GroupItem *Dispatcher::getGroupItemById(int id) {
1268   foreach(GroupWidget *group, groupList) {
1269     GroupScene* scene = group->getScene();
1270     if (scene->getGroupItem()->getId() == id) return scene->getGroupItem();
1271   }
1272   cout << "search GroupItem by id :" << id << " :: not found..." << endl;
1273   return NULL;
1274 }
1275
1276 BoxItem *Dispatcher::getBoxItemById(int id) {
1277   foreach(GroupWidget *group, groupList) {
1278
1279     GroupScene* scene = group->getScene();
1280     foreach(BoxItem *item, scene->getBoxItems()){
1281       if(item->getId() == id){
1282           return item;
1283       }
1284     }
1285   }
1286   cout << "search BlockItem by id :" << id << " :: not found..." << endl;
1287   return NULL;
1288 }
1289
1290 InterfaceItem* Dispatcher::getInterfaceItemById(int id) {
1291
1292   foreach(GroupWidget *group, groupList) {
1293
1294     GroupScene* scene = group->getScene();
1295
1296     foreach(InterfaceItem *item, scene->getGroupItem()->getInterfaces()){
1297       if(item->getId() == id){
1298         return item;
1299       }
1300     }
1301     foreach(BoxItem *block, scene->getBoxItems()){
1302       foreach(InterfaceItem *item, block->getInterfaces()){
1303         if(item->getId() == id){
1304           return item;
1305         }
1306       }
1307     }
1308   }
1309   cout << "search interface by id :" << id << " :: not found..." << endl;
1310   return NULL;
1311 }
1312
1313 void Dispatcher::findGraphModifications(FunctionalBlock *block) {
1314   static QString fctName = "Dispatcher::findGraphModifications()";
1315 #ifdef DEBUG_FCTNAME
1316   cout << "call to " << qPrintable(fctName) << endl;
1317 #endif
1318
1319   block->computeAdmittanceDelays();
1320   // get the block item that is associated to block
1321   BoxItem* toBlockItem = params->blockToItem.value(block);
1322
1323   /* VERSION 1: just add delays if needed */
1324   QMap<AbstractInterface*,QList<int>* > delays = block->getAdmittanceDelays();
1325   QMapIterator<AbstractInterface*,QList<int>* > iterD(delays);
1326   while (iterD.hasNext()) {
1327     iterD.next();
1328     QList<int>* delay = iterD.value();
1329     if (delay->at(0) > 0) {
1330       // create delay and associate it to the connected input
1331
1332       ConnectedInterface* toIface = AI_TO_CON(iterD.key());
1333       AbstractInputModifier* mod = new DelayInputModifier(toIface, delay->at(0));
1334       cout << "modify input of " << qPrintable(toIface->getName()) << endl;
1335       toIface->setInputModifier(mod);
1336       // repaint
1337       toBlockItem->update();
1338     }
1339   }
1340 }
1341