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