Parameters.cpp

   1 #include "Parameters.h"\r
   2 \r
   3 #include "Dispatcher.h"\r
   4 #include "BlockLibraryTree.h"\r
   5 \r
   6 #include "BlockCategory.h"\r
   7 \r
   8 #include "GroupWidget.h"\r
   9 #include "GroupScene.h"\r
  10 #include "GroupItem.h"\r
  11 #include "BoxItem.h"\r
  12 #include "SourceItem.h"\r
  13 #include "InterfaceItem.h"\r
  14 #include "ConnectionItem.h"\r
  15 \r
  16 #include "Graph.h"\r
  17 #include "ReferenceBlock.h"\r
  18 #include "GroupBlock.h"\r
  19 #include "FunctionalBlock.h"\r
  20 #include "ReferenceInterface.h"\r
  21 #include "GroupInterface.h"\r
  22 #include "FunctionalInterface.h"\r
  23 \r
  24 #include "Exception.h"\r
  25 #include "BlocksToConfigureWidget.h"\r
  26 \r
  27 #include "BlockParameterGeneric.h"\r
  28 \r
  29 #include "DelayInputModifier.h"\r
  30 \r
  31 Parameters::Parameters() {\r
  32   categoryTree = NULL;\r
  33   arrowWidth = 5;\r
  34   arrowHeight = 10;\r
  35   arrowLineLength = 10;\r
  36 \r
  37   defaultBlockWidth = 100;\r
  38   defaultBlockHeight = 100;\r
  39   defaultBlockFont = QFont("Arial");\r
  40   defaultBlockFontSize = 12;\r
  41 \r
  42   setArrowPathes();\r
  43 \r
  44   sceneMode = MODE_EDITION; // default mode\r
  45   editState = Parameters::EditNoOperation;\r
  46 \r
  47   unsaveModif = false;\r
  48   isRstClkShown = false;\r
  49 \r
  50   projectPath = QDir::currentPath();\r
  51   \r
  52   validityExtension = "_enb";\r
  53 }\r
  54 \r
  55 Parameters::~Parameters() {\r
  56   clear();\r
  57 }\r
  58 \r
  59 void Parameters::clear() {\r
  60   delete categoryTree;\r
  61   QListIterator<ReferenceBlock *> iter(availableBlocks);\r
  62   while(iter.hasNext()) {\r
  63     ReferenceBlock* item = iter.next();\r
  64     delete item;\r
  65   }\r
  66   availableBlocks.clear();\r
  67   refPathes.clear();\r
  68 }\r
  69 \r
  70 Graph* Parameters::createGraph() {\r
  71   graph = new Graph();\r
  72   return graph;\r
  73 }\r
  74 \r
  75 void Parameters::destroyGraph() {\r
  76   delete graph;\r
  77 }\r
  78 \r
  79 ReferenceBlock* Parameters::getReferenceBlock(int idCategory, int idBlock) {\r
  80 \r
  81   BlockCategory* blockCat = categoryTree->searchCategory(idCategory);\r
  82 \r
  83   if (blockCat == NULL) return NULL;\r
  84   ReferenceBlock* ref = blockCat->getBlock(idBlock);\r
  85   return ref;\r
  86 }\r
  87 \r
  88 void Parameters::createDelayBlock() {\r
  89   delayRef = new ReferenceBlock("no.xml");\r
  90   delayRef->addCategory(100);\r
  91   delayRef->setName("delay");\r
  92 \r
  93   BlockCategory* cat = categoryTree->searchCategory(100);\r
  94   cat->blocks.append(delayRef);\r
  95 \r
  96   AbstractInterface* interIn = new ReferenceInterface(delayRef,"data_in",AbstractInterface::Input, AbstractInterface::Data, "expression","$in_width");\r
  97   delayRef->addInterface(interIn);\r
  98   AbstractInterface* interInCtl = new ReferenceInterface(delayRef,"data_in_enb",AbstractInterface::Input, AbstractInterface::Control, "boolean","1");\r
  99   delayRef->addInterface(interInCtl);\r
 100   interInCtl->setAssociatedIface(interIn);\r
 101   AbstractInterface* interOut = new ReferenceInterface(delayRef,"data_out",AbstractInterface::Output, AbstractInterface::Data, "expression","$in_width");\r
 102   delayRef->addInterface(interOut);\r
 103   AbstractInterface* interOutCtl = new ReferenceInterface(delayRef,"data_out_enb",AbstractInterface::Output, AbstractInterface::Control, "boolean","1");\r
 104   delayRef->addInterface(interOutCtl);\r
 105   interOutCtl->setAssociatedIface(interOut);\r
 106   BlockParameter* param1 = new BlockParameterGeneric(delayRef,"in_width","natural","8");\r
 107   BlockParameter* param2 = new BlockParameterGeneric(delayRef,"dly_length","natural","1");\r
 108   delayRef->addParameter(param1);\r
 109   delayRef->addParameter(param2);\r
 110   delayImpl = new BlockImplementation("no.xml");\r
 111   delayImpl->setDelta("1");\r
 112   QHash<QString,QString> consPattern;\r
 113   consPattern.insert("data_in_enb","1");\r
 114   delayImpl->setConsumptionPattern(consPattern);\r
 115   QHash<QString,QString> prodPattern;\r
 116   prodPattern.insert("data_out_enb","O{$dly_length}1");\r
 117   delayImpl->setProductionPattern(prodPattern);\r
 118   delayImpl->setProductionCounter("1");\r
 119   delayRef->addImplementation(delayImpl);\r
 120   delayImpl->setReference(delayRef);\r
 121   if (! delayImpl->checkPatterns()) {\r
 122     cout << "Delay block creation: failure" << endl;\r
 123   }\r
 124   else {\r
 125     cout << "Delay block creation: success" << endl;\r
 126   }\r
 127 \r
 128 }\r
 129 \r
 130 \r
 131 \r
 132 void Parameters::validateXmlFile(const QString& xmlFileName, const QString& xsdFileName, XmlFileType fileType) throw(Exception) {\r
 133   // opening configFile\r
 134   QFile xmlFile(xmlFileName);\r
 135   if (!xmlFile.open(QIODevice::ReadOnly)) {\r
 136     if (fileType == Configuration) {\r
 137       throw(Exception(CONFIGFILE_NOACCESS));\r
 138     }\r
 139     else if (fileType == Reference) {\r
 140       throw(Exception(BLOCKFILE_NOACCESS));\r
 141     }\r
 142     else if (fileType == Implementation) {\r
 143       throw(Exception(IMPLFILE_NOACCESS));\r
 144     }\r
 145     else if (fileType == Project) {\r
 146       throw(Exception(PROJECTFILE_NOACCESS));\r
 147     }\r
 148   }\r
 149 \r
 150   QFile xsdFile(xsdFileName);\r
 151   if (!xsdFile.open(QIODevice::ReadOnly)) {\r
 152     xsdFile.close();\r
 153     if (fileType == Configuration) {\r
 154       throw(Exception(CONFIGFILE_NOACCESS));\r
 155     }\r
 156     else if (fileType == Reference) {\r
 157       throw(Exception(BLOCKFILE_NOACCESS));\r
 158     }\r
 159     else if (fileType == Implementation) {\r
 160       throw(Exception(IMPLFILE_NOACCESS));\r
 161     }\r
 162     else if (fileType == Project) {\r
 163       throw(Exception(PROJECTFILE_NOACCESS));\r
 164     }\r
 165   }\r
 166 \r
 167   if(validate(xmlFile,xsdFile) == false) {\r
 168     xmlFile.close();\r
 169     xsdFile.close();\r
 170     if (fileType == Configuration) {\r
 171       throw(Exception(CONFIGFILE_CORRUPTED));\r
 172     }\r
 173     else if (fileType == Reference) {\r
 174       throw(Exception(BLOCKFILE_CORRUPTED));\r
 175     }\r
 176     else if (fileType == Implementation) {\r
 177       throw(Exception(IMPLFILE_CORRUPTED));\r
 178     }\r
 179     else if (fileType == Project) {\r
 180       throw(Exception(PROJECTFILE_CORRUPTED));\r
 181     }\r
 182   }\r
 183   xmlFile.close();\r
 184   xsdFile.close();\r
 185 }\r
 186 \r
 187 bool Parameters::validate(QFile& fileXml, QFile& fileSchema) {\r
 188 \r
 189   // 2 files are supposed to be already opened\r
 190   QXmlSchema schema;\r
 191 \r
 192   if(! schema.load(&fileSchema)){\r
 193     cout << "invalid schema" << endl;\r
 194     return false;\r
 195   }\r
 196 \r
 197   QXmlSchemaValidator validator(schema);\r
 198 \r
 199   if(! validator.validate(&fileXml)){\r
 200     cout << "invalid xml" << endl;\r
 201     return false;\r
 202   }\r
 203   return true;\r
 204 }\r
 205 \r
 206 QDomElement Parameters::openProjectFile(const QString& projectFileName) throw(Exception) {\r
 207 \r
 208   try {\r
 209     validateXmlFile(projectFileName,"projectfile.xsd",Project);\r
 210   }\r
 211   catch(Exception err) {\r
 212     throw(err);\r
 213   }\r
 214 \r
 215   QFile projectFile(projectFileName);\r
 216   QDomDocument doc("projectFile");\r
 217 \r
 218   if(!projectFile.open(QIODevice::ReadOnly)) {\r
 219     throw(Exception(PROJECTFILE_NOACCESS));\r
 220   }\r
 221   if(!doc.setContent(&projectFile)) {\r
 222     projectFile.close();\r
 223     throw(Exception(PROJECTFILE_CORRUPTED));\r
 224   }\r
 225   projectFile.close();\r
 226 \r
 227   QDomElement root = doc.documentElement();\r
 228 \r
 229   return root;\r
 230 }\r
 231 \r
 232 GroupWidget *Parameters::loadProject(QDomElement root) throw(Exception) {\r
 233 \r
 234   bool ok = false;\r
 235   GroupWidget* groupWidget = NULL;\r
 236   GroupItem *groupItem = NULL;\r
 237   GroupBlock *groupBlock = NULL;\r
 238 \r
 239   GroupWidget* topGroup = NULL;\r
 240   /**********************************************************\r
 241    1 : getting scene and creating associated group widgets\r
 242   ***********************************************************/\r
 243   QDomNodeList scenesNodes = root.elementsByTagName("scene");\r
 244 \r
 245   int maxIdScene = -1;\r
 246   for(int i=0; i<scenesNodes.length(); i++) {\r
 247     QDomElement currentSceneNode = scenesNodes.at(i).toElement();\r
 248     int idScene = currentSceneNode.attribute("id","none").toInt(&ok);\r
 249     if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 250     if (idScene > maxIdScene) maxIdScene = idScene;\r
 251     int idUpperScene = currentSceneNode.attribute("upper_scene","none").toInt(&ok);\r
 252     if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 253 \r
 254     if (idUpperScene == -1) {\r
 255       topGroup = dispatcher->createTopScene();\r
 256       topScene->setId(idScene);\r
 257       groupItem = topScene->getGroupItem();      \r
 258       cout << "top group added to scene n°" << idScene << endl;\r
 259     }\r
 260     else {\r
 261       cout << "trying to create scene n°" << idScene << " with upper scene n°" <<idUpperScene << endl;\r
 262       GroupScene* upperScene = searchSceneById(idUpperScene, topScene);\r
 263       groupWidget = dispatcher->addNewEmptyGroup(upperScene,false);\r
 264       groupWidget->getScene()->setId(idScene);\r
 265       groupItem = groupWidget->getScene()->getGroupItem();      \r
 266     }\r
 267     groupBlock = AB_TO_GRP(groupItem->getRefBlock());\r
 268     /**********************************************************\r
 269      1.1 : getting the group item of each scene\r
 270     ***********************************************************/\r
 271     QDomElement groupItemNode = currentSceneNode.firstChildElement("group_item");\r
 272     try {\r
 273       groupItem->load(groupItemNode);\r
 274     }\r
 275     catch(Exception err) {\r
 276       throw(err);\r
 277     }\r
 278 \r
 279     if (idUpperScene != -1) {\r
 280       groupWidget->setWindowTitle(groupBlock->getName());\r
 281       groupWidget->show();\r
 282       cout << qPrintable(groupItem->getRefBlock()->getName()) << " has upper box item in " << qPrintable(groupItem->getParentItem()->getScene()->getGroupItem()->getRefBlock()->getName()) << endl;\r
 283     }    \r
 284   }\r
 285   dispatcher->setSceneCounter(maxIdScene+1);\r
 286   cout << "groupItems loaded and windows created succefully!" << endl;\r
 287 \r
 288   /**********************************************************\r
 289    2 : getting the functional blocks of each scene\r
 290   ***********************************************************/\r
 291 \r
 292   for(int i=0; i<scenesNodes.length(); i++){\r
 293     QDomElement currentSceneNode = scenesNodes.at(i).toElement();\r
 294     int idScene = currentSceneNode.attribute("id","none").toInt(&ok);\r
 295     if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 296     cout << "SCENE : " << idScene << endl;\r
 297     GroupScene *currentScene = searchSceneById(idScene,topScene);\r
 298 \r
 299     if(currentScene == NULL) throw(Exception(PROJECTFILE_CORRUPTED));\r
 300     /**********************************************************\r
 301      2.1 : getting sources if it is top scene\r
 302     ***********************************************************/\r
 303     if (currentScene->isTopScene()) {\r
 304       QDomNodeList sourceNodes = currentSceneNode.elementsByTagName("source_item");\r
 305       cout << "top scene has " << sourceNodes.length() << " sources" << endl;\r
 306       for(int j=0; j<sourceNodes.length(); j++) {\r
 307         QDomElement currentSBNode = sourceNodes.at(j).toElement();      \r
 308         SourceItem* sourceItem = new SourceItem(dispatcher,this);\r
 309         try {\r
 310           sourceItem->load(currentSBNode);\r
 311         }\r
 312         catch(Exception err) {\r
 313           throw(err);\r
 314         }\r
 315         cout << "source item has been read, add it to the scene" << endl;\r
 316         // add the block to the GroupScene\r
 317         currentScene->addSourceItem(sourceItem);\r
 318       } \r
 319     }\r
 320     /**********************************************************\r
 321      2.2 : getting functional blocks\r
 322     ***********************************************************/\r
 323     QDomNodeList functionalBlockNodes = currentSceneNode.elementsByTagName("bi_functional");\r
 324 \r
 325     for(int j=0; j<functionalBlockNodes.length(); j++) {\r
 326       QDomElement currentFBNode = functionalBlockNodes.at(j).toElement();      \r
 327       BoxItem* funcItem = new BoxItem(dispatcher,this, currentScene->getGroupItem());\r
 328       try {\r
 329         funcItem->loadFunctional(currentFBNode);\r
 330       }\r
 331       catch(Exception err) {\r
 332         throw(err);\r
 333       }\r
 334       // add the block to the GroupScene\r
 335       currentScene->addBoxItem(funcItem);\r
 336     }\r
 337   }\r
 338   cout << "functional blocks loaded and created succefully!" << endl;\r
 339 \r
 340   /**********************************************************\r
 341    3 : set the BoxItem that represents a GroupItem in a child scene\r
 342   ***********************************************************/\r
 343 \r
 344   for(int i=0; i<scenesNodes.length(); i++){\r
 345     QDomElement currentSceneNode = scenesNodes.at(i).toElement();\r
 346     int idScene = currentSceneNode.attribute("id","none").toInt(&ok);\r
 347     if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 348     GroupScene *currentScene = searchSceneById(idScene, topScene);\r
 349     if(currentScene == NULL) throw(Exception(PROJECTFILE_CORRUPTED));\r
 350 \r
 351     QDomNodeList biGroupNodes = currentSceneNode.elementsByTagName("bi_group");\r
 352 \r
 353     for(int j=0; j<biGroupNodes.length(); j++){\r
 354       QDomElement currentBiGroup = biGroupNodes.at(j).toElement();\r
 355 \r
 356       int id = currentBiGroup.attribute("id","none").toInt(&ok);\r
 357       if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 358 \r
 359       int idGroup = currentBiGroup.attribute("inside_group","none").toInt(&ok);\r
 360       if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 361 \r
 362       QStringList positionStr = currentBiGroup.attribute("position","none").split(",");\r
 363       if(positionStr.length() != 2) throw(Exception(PROJECTFILE_CORRUPTED));\r
 364       int posX = positionStr.at(0).toInt(&ok);\r
 365       if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 366       int posY = positionStr.at(1).toInt(&ok);\r
 367       if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 368 \r
 369       QStringList dimensionStr = currentBiGroup.attribute("dimension","none").split(",");\r
 370       if(dimensionStr.length() != 2) throw(Exception(PROJECTFILE_CORRUPTED));\r
 371       int dimX = dimensionStr.at(0).toInt(&ok);\r
 372       if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 373       int dimY = dimensionStr.at(1).toInt(&ok);\r
 374       if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 375 \r
 376       // get the GroupItem already created and set at phase 1\r
 377       GroupItem *insideGroup = searchGroupItemById(idGroup, topScene);\r
 378       BoxItem* upperItem = NULL;\r
 379       if(insideGroup == NULL) cout << "group null" << endl;      \r
 380       // now search within the scene which BoxItem has a childItem that is = to insideGroup\r
 381       QList<BoxItem *> lst = currentScene->getBoxItems();\r
 382       foreach(BoxItem* item, lst) {\r
 383         if (item->getChildGroupItem() == insideGroup) {\r
 384           upperItem = item;\r
 385           break;\r
 386         }\r
 387       }\r
 388       if (upperItem == NULL) {\r
 389         throw(Exception(PROJECTFILE_CORRUPTED));\r
 390       }\r
 391 \r
 392       upperItem->setId(id);\r
 393       upperItem->setPos(posX,posY);\r
 394       upperItem->setDimension(dimX,dimY);\r
 395 \r
 396       // set interfaces of this BoxItem\r
 397       QDomNodeList interfaceNodes = currentBiGroup.elementsByTagName("big_iface");\r
 398 \r
 399       for(int k=0; k<interfaceNodes.length(); k++){\r
 400         QDomElement currentInterfaceNode = interfaceNodes.at(k).toElement();\r
 401 \r
 402         int id = currentInterfaceNode.attribute("id","none").toInt(&ok);\r
 403         if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 404 \r
 405         QString refName = currentInterfaceNode.attribute("ref_name","none");\r
 406         if(refName == "none") throw(Exception(PROJECTFILE_CORRUPTED));\r
 407 \r
 408         QString orientationStr = currentInterfaceNode.attribute("orientation","none");\r
 409         int orientation = InterfaceItem::getIntOrientation(orientationStr);\r
 410         if(orientation == -1) throw(Exception(PROJECTFILE_CORRUPTED));\r
 411 \r
 412         double position = currentInterfaceNode.attribute("position","none").toDouble(&ok);\r
 413         if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 414 \r
 415         ConnectedInterface *refInter = insideGroup->searchInterfaceItemByName(refName)->refInter;\r
 416         InterfaceItem *ifaceItem = new InterfaceItem(position, orientation, refInter, upperItem, this);\r
 417         ifaceItem->setId(id);\r
 418         upperItem->addInterfaceItem(ifaceItem);\r
 419       }\r
 420     }\r
 421   }\r
 422   cout << "blockItems \"group\" loaded and created succefully!" << endl;\r
 423 \r
 424   QDomNodeList connectionNodes = root.elementsByTagName("connection");\r
 425 \r
 426   for(int i=0; i<connectionNodes.length(); i++){\r
 427     QDomElement currentConnectionNode = connectionNodes.at(i).toElement();\r
 428 \r
 429     int from = currentConnectionNode.attribute("from","none").toInt(&ok);\r
 430     if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 431 \r
 432     int to = currentConnectionNode.attribute("to","none").toInt(&ok);\r
 433     if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 434 \r
 435 \r
 436     InterfaceItem *iface1 = searchInterfaceItemById(from,topScene);\r
 437     InterfaceItem *iface2 = searchInterfaceItemById(to,topScene);\r
 438 \r
 439     if(iface1 != NULL && iface2 != NULL){\r
 440       dispatcher->createConnection(iface1,iface2);\r
 441     } else {\r
 442       cout << "interfaces not found, connect canceled!" << endl;\r
 443     }\r
 444   }\r
 445   cout << "connections loaded and created succefully!" << endl;\r
 446 \r
 447   QDomNodeList modifierNodes = root.elementsByTagName("modifier");\r
 448 \r
 449   for(int i=0; i<modifierNodes.length(); i++){\r
 450     QDomElement currentModifierNode = modifierNodes.at(i).toElement();\r
 451 \r
 452     int id = currentModifierNode.attribute("id","none").toInt(&ok);\r
 453     if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 454 \r
 455     QString typeStr = currentModifierNode.attribute("type","none");\r
 456     if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 457     QString paramsStr = currentModifierNode.attribute("params","none");\r
 458     if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 459 \r
 460     AbstractInputModifier* mod = NULL;\r
 461     if (typeStr == "delay") {\r
 462       int delay = paramsStr.toInt(&ok);\r
 463       if(!ok) throw(Exception(PROJECTFILE_CORRUPTED));\r
 464       mod = new DelayInputModifier(delay);\r
 465     }\r
 466 \r
 467     /* NB: just adding delays for now. To be cont'd */\r
 468     InterfaceItem *iface = searchInterfaceItemById(id,topScene);\r
 469 \r
 470     if(iface != NULL ) {\r
 471       iface->refInter->setInputModifier(mod);\r
 472 \r
 473     } else {\r
 474       cout << "interfaces not found, modifiers setup canceled!" << endl;\r
 475     }\r
 476   }\r
 477   cout << "modifiers loaded and created succefully!" << endl;\r
 478 \r
 479   return topGroup;\r
 480 }\r
 481 \r
 482 void Parameters::loadBlastConfiguration(QString confFile) throw(Exception) {\r
 483 \r
 484   try {\r
 485     validateXmlFile("blastconfig.xml", "blastconfig.xsd",Configuration);\r
 486   }\r
 487   catch(Exception err) {\r
 488     throw(err);\r
 489   }\r
 490 \r
 491   bool ok;\r
 492   // opening configFile\r
 493   QFile configFile(confFile);\r
 494   // reading in into QDomDocument\r
 495   QDomDocument document("configFile");\r
 496 \r
 497   if (!configFile.open(QIODevice::ReadOnly)) {\r
 498     throw(Exception(CONFIGFILE_NOACCESS));\r
 499   }\r
 500   if (!document.setContent(&configFile)) {\r
 501     configFile.close();\r
 502     throw(Exception(CONFIGFILE_NOACCESS));\r
 503   }\r
 504   configFile.close();\r
 505 \r
 506   //Get the root element\r
 507   QDomElement config = document.documentElement();\r
 508 \r
 509   QDomElement eltCat = config.firstChildElement("categories");\r
 510   try {\r
 511     categoryTree = new BlockLibraryTree();\r
 512     categoryTree->load(eltCat);\r
 513   }\r
 514   catch(Exception err) {\r
 515     throw(err);\r
 516   }\r
 517 \r
 518   QDomElement eltReferences = eltCat.nextSiblingElement("references");\r
 519   refLib = eltReferences.attribute("lib_file","none");\r
 520   cout << "references lib : " << qPrintable(refLib)  << endl;\r
 521   int nbPathes;\r
 522   QString nbPathesStr;\r
 523   nbPathesStr = eltReferences.attribute("nb","none");\r
 524   nbPathes = nbPathesStr.toInt(&ok);\r
 525   QDomNodeList listBlockDir = eltReferences.elementsByTagName("reference_lib");\r
 526   if ((!ok) || (nbPathes != listBlockDir.size())) throw(Exception(CONFIGFILE_CORRUPTED));\r
 527 \r
 528   for(int i=0;i<listBlockDir.size();i++) {\r
 529     QDomNode nodeBlockDir = listBlockDir.at(i);\r
 530     QDomElement eltBlockDir = nodeBlockDir.toElement();\r
 531     if (eltBlockDir.isNull()) throw(Exception(CONFIGFILE_CORRUPTED));\r
 532     QString path = eltBlockDir.attribute("path","none");\r
 533     if (path == "none") throw(Exception(CONFIGFILE_CORRUPTED));\r
 534     refPathes.append(path);\r
 535     cout << "references path : " << qPrintable(path) << endl;\r
 536   }\r
 537 \r
 538   QDomElement eltImpl = eltReferences.nextSiblingElement("implementations");\r
 539   implLib = eltImpl.attribute("lib_file","none");\r
 540   cout << "implementation lib : " << qPrintable(implLib)  << endl;\r
 541   nbPathesStr = eltImpl.attribute("nb","none");\r
 542   nbPathes = nbPathesStr.toInt(&ok);\r
 543   QDomNodeList listImplDir = eltImpl.elementsByTagName("impl_lib");\r
 544   if ((!ok) || (nbPathes != listImplDir.size())) throw(Exception(CONFIGFILE_CORRUPTED));\r
 545 \r
 546   for(int i=0;i<listImplDir.size();i++) {\r
 547     QDomNode nodeImplDir = listImplDir.at(i);\r
 548     QDomElement eltImplDir = nodeImplDir.toElement();\r
 549     if (eltImplDir.isNull()) throw(Exception(CONFIGFILE_CORRUPTED));\r
 550     QString path = eltImplDir.attribute("path","none");\r
 551     if (path == "none") throw(Exception(CONFIGFILE_CORRUPTED));\r
 552     implPathes.append(path);\r
 553     cout << "impl path : " << qPrintable(path) << endl << endl;\r
 554   }\r
 555   // getting elt = the element <defaults>\r
 556   // for each child element, initialize the associated attributes of Parameters\r
 557 \r
 558   QDomElement eltDefaults = eltImpl.nextSiblingElement("defaults");\r
 559 \r
 560   QDomElement eltBlocks = eltDefaults.firstChildElement("blocks");\r
 561   QString attributeStr = eltBlocks.attribute("width", "none");\r
 562   defaultBlockWidth = attributeStr.toInt(&ok);\r
 563   if (!ok || defaultBlockWidth < 1) throw(Exception(CONFIGFILE_CORRUPTED));\r
 564   attributeStr = eltBlocks.attribute("height", "none");\r
 565   defaultBlockHeight = attributeStr.toInt(&ok);\r
 566   if (!ok || defaultBlockHeight < 1) throw(Exception(CONFIGFILE_CORRUPTED));\r
 567   attributeStr = eltBlocks.attribute("font_size", "none");\r
 568   defaultBlockFontSize = attributeStr.toFloat(&ok);\r
 569   if (!ok || defaultBlockFontSize < 1) throw(Exception(CONFIGFILE_CORRUPTED));\r
 570   attributeStr = eltBlocks.attribute("font", "none");\r
 571   if (attributeStr == "none") throw(Exception(CONFIGFILE_CORRUPTED));\r
 572   defaultBlockFontName = attributeStr;\r
 573   defaultBlockFont = QFont(defaultBlockFontName, defaultBlockFontSize);\r
 574 \r
 575   QDomElement eltInterfaces = eltBlocks.nextSiblingElement("interfaces");\r
 576   attributeStr = eltInterfaces.attribute("width", "none");\r
 577   arrowWidth = attributeStr.toInt(&ok);\r
 578   if (!ok || arrowWidth < 1) throw(Exception(CONFIGFILE_CORRUPTED));\r
 579   attributeStr = eltInterfaces.attribute("height", "none");\r
 580   arrowHeight = attributeStr.toInt(&ok);\r
 581   if (!ok || arrowHeight < 1) throw(Exception(CONFIGFILE_CORRUPTED));\r
 582   attributeStr = eltInterfaces.attribute("linelength", "none");\r
 583   arrowLineLength = attributeStr.toInt(&ok);\r
 584   if (!ok || arrowLineLength < 1) throw(Exception(CONFIGFILE_CORRUPTED));\r
 585   attributeStr = eltInterfaces.attribute("font_size", "none");\r
 586   defaultIfaceFontSize = attributeStr.toFloat(&ok);\r
 587   if (!ok || defaultIfaceFontSize < 1) throw(Exception(CONFIGFILE_CORRUPTED));\r
 588   attributeStr = eltInterfaces.attribute("font", "none");\r
 589   if (attributeStr == "none") throw(Exception(CONFIGFILE_CORRUPTED));\r
 590   defaultIfaceFontName = attributeStr;\r
 591   defaultIfaceFont = QFont(defaultIfaceFontName, defaultIfaceFontSize);\r
 592 \r
 593   QDomElement eltConnections = eltInterfaces.nextSiblingElement("connections");\r
 594   attributeStr = eltConnections.attribute("gaplength", "none");\r
 595   connGapLength = attributeStr.toInt(&ok);\r
 596   if (!ok || connGapLength < 1) throw(Exception(CONFIGFILE_CORRUPTED));\r
 597 }\r
 598 \r
 599 void Parameters::loadReferencesFromXml() throw(Exception) {\r
 600   cout << "load references from xml" << endl;\r
 601   for(int i=0;i<refPathes.size();i++) {\r
 602     cout << "analyzing " << qPrintable(refPathes.at(i)) << endl;\r
 603     QDir dir(refPathes.at(i));\r
 604     QStringList filter;\r
 605     filter << "*.xml";\r
 606     dir.setNameFilters(filter);\r
 607     QStringList list = dir.entryList();\r
 608     for(int j=0;j<list.size();j++) {\r
 609       QString fileName = dir.absolutePath();\r
 610       fileName.append("/"+list.at(j));\r
 611 \r
 612       QFile blockXML(fileName);\r
 613       if (!blockXML.open(QIODevice::ReadOnly)) {\r
 614         throw(Exception(BLOCKFILE_NOACCESS));\r
 615       }\r
 616       QTextStream in(&blockXML);\r
 617       QString line = in.readLine();\r
 618       line = in.readLine();\r
 619 \r
 620       if (!line.contains("<block")) {\r
 621         blockXML.close();\r
 622         continue;\r
 623       }\r
 624 \r
 625       blockXML.close();\r
 626       try {\r
 627         validateXmlFile(fileName,"reference.xsd",Reference);\r
 628       }\r
 629       catch(Exception err) {\r
 630         throw(err);\r
 631       }\r
 632 \r
 633       // reading in into QDomDocument\r
 634       QDomDocument document ("FileXML");\r
 635       if (!blockXML.open(QIODevice::ReadOnly)) {\r
 636         throw(Exception(BLOCKFILE_NOACCESS));\r
 637       }\r
 638       if (!document.setContent(&blockXML)) {\r
 639         blockXML.close();\r
 640         throw(Exception(BLOCKFILE_NOACCESS));\r
 641       }\r
 642       blockXML.close();\r
 643 \r
 644       QDomElement blockRoot = document.documentElement();\r
 645       QString name = blockRoot.tagName();\r
 646       if (name == "block") {\r
 647 \r
 648         cout << "xml:" << fileName.toStdString() << endl;\r
 649         ReferenceBlock* b = new ReferenceBlock(fileName);\r
 650         try {\r
 651           b->load(blockRoot);\r
 652           b->setHashMd5();\r
 653         }\r
 654         catch(int err) {\r
 655           throw(err);\r
 656         }\r
 657         cout << "xml:" << b->getXmlFile().toStdString() << endl;\r
 658 \r
 659         availableBlocks.append(b);\r
 660         foreach (int id,b->getCategories()) {\r
 661           cout << "ajout du bloc dans cat n° : " << id << endl;\r
 662           BlockCategory* cat = categoryTree->searchCategory(id);\r
 663           cat->blocks.append(b);\r
 664         }\r
 665       }\r
 666     }\r
 667   }\r
 668 }\r
 669 \r
 670 void Parameters::loadReferencesFromLib() throw(Exception) {\r
 671 \r
 672   cout << "loading references from lib" << endl;\r
 673 \r
 674   // removing blocks from category tree if they exist\r
 675   categoryTree->clearBlocks();\r
 676   // deleting existings blocks\r
 677   ReferenceBlock* b = NULL;\r
 678   for(int i=0;i<availableBlocks.size();i++) {\r
 679     b = availableBlocks.at(i);\r
 680     delete b;\r
 681   }\r
 682   availableBlocks.clear();\r
 683 \r
 684   QFile libFile(refLib);\r
 685   if (!libFile.open(QIODevice::ReadOnly)) {\r
 686     throw(Exception(BLOCKFILE_NOACCESS));\r
 687   }\r
 688   QDataStream in(&libFile);\r
 689   quint32 size;\r
 690 \r
 691   in >> size;\r
 692 \r
 693   int nbBlocks;\r
 694   in >> nbBlocks;\r
 695   for(int i=0;i<nbBlocks;i++) {\r
 696     b = new ReferenceBlock("");\r
 697     in >> *b;\r
 698     availableBlocks.append(b);\r
 699     foreach (int id,b->getCategories()) {\r
 700       BlockCategory* cat = categoryTree->searchCategory(id);\r
 701       cat->blocks.append(b);\r
 702     }\r
 703   }\r
 704   libFile.close();\r
 705 }\r
 706 \r
 707 void Parameters::saveReferencesToLib() throw(Exception) {\r
 708 \r
 709   cout << "saving blocks in " << qPrintable(refLib) << endl;\r
 710   QFile libFile(refLib);\r
 711   if (!libFile.open(QIODevice::WriteOnly)) {\r
 712     throw(Exception(BLOCKFILE_NOACCESS));\r
 713   }\r
 714   QDataStream out(&libFile);\r
 715 \r
 716   out.setVersion(QDataStream::Qt_5_0);\r
 717 \r
 718   QByteArray blockData;\r
 719   QDataStream toWrite(&blockData, QIODevice::WriteOnly);\r
 720 \r
 721   toWrite << availableBlocks.size();\r
 722   for(int i=0;i<availableBlocks.size();i++) {\r
 723     ReferenceBlock* b = availableBlocks.at(i);\r
 724     toWrite << *b;\r
 725   }\r
 726 \r
 727   out << blockData;\r
 728 \r
 729   libFile.close();\r
 730 \r
 731 }\r
 732 \r
 733 void Parameters::loadImplementationsFromXml() throw(Exception) {\r
 734 \r
 735   for(int i=0;i<implPathes.size();i++) {\r
 736     cout << "analyzing " << qPrintable(implPathes.at(i)) << endl;\r
 737     QDir dir(implPathes.at(i));\r
 738     QStringList filter;\r
 739     filter << "*.xml";\r
 740     dir.setNameFilters(filter);\r
 741     QStringList list = dir.entryList();\r
 742     for(int j=0;j<list.size();j++) {\r
 743       QString fileName = dir.absolutePath();\r
 744       fileName.append("/"+list.at(j));\r
 745 \r
 746       cout << "checking " << qPrintable(fileName) << " is an implementation file ...";\r
 747       QFile implXML(fileName);\r
 748       if (!implXML.open(QIODevice::ReadOnly)) {\r
 749         throw(Exception(IMPLFILE_NOACCESS));\r
 750       }\r
 751       QTextStream in(&implXML);\r
 752       QString line = in.readLine();\r
 753       line = in.readLine();\r
 754 \r
 755       if (!line.contains("<block_impl")) {\r
 756         implXML.close();\r
 757         continue;\r
 758       }\r
 759 \r
 760       implXML.close();\r
 761       cout << "OK" << endl;\r
 762       cout << "reading " << qPrintable(fileName) << " content ...";\r
 763 \r
 764       try {\r
 765         validateXmlFile(fileName,"implementation.xsd",Implementation);\r
 766       }\r
 767       catch(Exception e) {\r
 768         throw(e);\r
 769       }\r
 770 \r
 771       // reading in into QDomDocument\r
 772       QDomDocument document ("FileXML");\r
 773       if (!implXML.open(QIODevice::ReadOnly)) {\r
 774         throw(Exception(IMPLFILE_NOACCESS));\r
 775       }\r
 776       cout << "OK" << endl;\r
 777       cout << "convert " << qPrintable(fileName) << " content into document...";\r
 778       if (!document.setContent(&implXML)) {\r
 779         implXML.close();\r
 780         throw(Exception(IMPLFILE_NOACCESS));\r
 781       }\r
 782       implXML.close();\r
 783 \r
 784       QDomElement implRoot = document.documentElement();\r
 785       QString refXml = implRoot.attribute("ref_name","none");\r
 786       QString refMd5 = implRoot.attribute("ref_md5","none");\r
 787       BlockImplementation* impl = new BlockImplementation(fileName,refXml,refMd5);\r
 788       try {\r
 789         impl->loadPatterns(implRoot);\r
 790       }\r
 791       catch(int err) {\r
 792         throw(err);\r
 793       }\r
 794       availableImplementations.append(impl);\r
 795 \r
 796       ReferenceBlock* ref = NULL;\r
 797       if (! refMd5.isEmpty()) {\r
 798         ref = searchBlockByMd5(refMd5);\r
 799       }\r
 800       if (ref == NULL) {\r
 801         ref = searchBlockByXml(refXml);\r
 802       }\r
 803       if (ref == NULL) {\r
 804         cout << "Cannot find a reference block for impl :" << qPrintable(fileName) << endl;\r
 805       }      \r
 806       else {          \r
 807         ref->addImplementation(impl);\r
 808         impl->setReference(ref);\r
 809         if (! impl->checkPatterns()) throw(Exception(IMPLFILE_CORRUPTED));\r
 810       }      \r
 811       cout << "OK" << endl;\r
 812     }\r
 813   }\r
 814 }\r
 815 \r
 816 void Parameters::loadImplementationsFromLib() throw(Exception) {\r
 817 \r
 818   cout << "loading implementations from lib" << endl;\r
 819 \r
 820   BlockImplementation* impl = NULL;\r
 821   ReferenceBlock* ref = NULL;\r
 822   for(int i=0;i<availableImplementations.size();i++) {\r
 823     impl = availableImplementations.at(i);\r
 824     delete impl;\r
 825   }\r
 826   availableImplementations.clear();\r
 827 \r
 828   QFile libFile(implLib);\r
 829   if (!libFile.open(QIODevice::ReadOnly)) {\r
 830     throw(Exception(IMPLFILE_NOACCESS));\r
 831   }\r
 832   QDataStream in(&libFile);\r
 833   quint32 size;\r
 834 \r
 835   in >> size;\r
 836 \r
 837   int nbImpls;\r
 838   in >> nbImpls;\r
 839   for(int i=0;i<nbImpls;i++) {\r
 840     impl = new BlockImplementation("");\r
 841     in >> *impl;\r
 842     availableImplementations.append(impl);\r
 843     QString refMd5 = impl->getReferenceMd5();\r
 844     QString refXml = impl->getReferenceXml();\r
 845     ref = NULL;\r
 846     if (! refMd5.isEmpty()) {\r
 847       ref = searchBlockByMd5(refMd5);\r
 848     }\r
 849     if (ref == NULL) {\r
 850       ref = searchBlockByXml(refXml);\r
 851     }\r
 852     if (ref == NULL) {\r
 853       cout << "Cannot find a reference block for impl :" << qPrintable(impl->getXmlFile()) << endl;\r
 854     }\r
 855     else {          \r
 856       ref->addImplementation(impl);\r
 857       impl->setReference(ref);\r
 858       if (! impl->checkPatterns()) throw(Exception(IMPLFILE_CORRUPTED));\r
 859     }\r
 860   }\r
 861   libFile.close();\r
 862 }\r
 863 \r
 864 void Parameters::saveImplementationsToLib() throw(Exception) {\r
 865 \r
 866   cout << "saving implementations in " << qPrintable(implLib) << endl;\r
 867   QFile libFile(implLib);\r
 868   if (!libFile.open(QIODevice::WriteOnly)) {\r
 869     throw(Exception(IMPLFILE_NOACCESS));\r
 870   }\r
 871   QDataStream out(&libFile);\r
 872 \r
 873   out.setVersion(QDataStream::Qt_5_0);\r
 874 \r
 875   QByteArray blockData;\r
 876   QDataStream toWrite(&blockData, QIODevice::WriteOnly);\r
 877 \r
 878   toWrite << availableImplementations.size();\r
 879   for(int i=0;i<availableImplementations.size();i++) {\r
 880     BlockImplementation* impl = availableImplementations.at(i);\r
 881     toWrite << *impl;\r
 882   }\r
 883 \r
 884   out << blockData;\r
 885 \r
 886   libFile.close();\r
 887 \r
 888 }\r
 889 void Parameters::addAvailableBlock(ReferenceBlock *block) {\r
 890   availableBlocks.append(block);\r
 891   foreach (int id,block->getCategories()) {\r
 892     cout << "ajout du bloc dans cat n° : " << id << endl;\r
 893     BlockCategory* cat = categoryTree->searchCategory(id);\r
 894     cat->blocks.append(block);\r
 895   }\r
 896 }\r
 897 \r
 898 void Parameters::parametersValidation() {\r
 899   QList<AbstractBlock*> blocksToConfigure = getBlocksToConfigure();\r
 900 \r
 901   if(!blocksToConfigure.isEmpty()){\r
 902     BlocksToConfigureWidget *widget = new BlocksToConfigureWidget(blocksToConfigure, this, NULL);\r
 903     widget->show();\r
 904   }\r
 905 }\r
 906 \r
 907 void Parameters::connectionsValidation() {\r
 908 \r
 909 #ifdef DEBUG_INCLFUN\r
 910 \r
 911   QStack<AbstractInterface*> *interfaceToValidate = new QStack<AbstractInterface*>;\r
 912   QList<AbstractInterface*> *validatedInterface = new QList<AbstractInterface*>;\r
 913 \r
 914   foreach(AbstractInterface *inter, topWindow->getScene()->getGroupItem()->getRefBlock()->getInterfaces()){\r
 915     foreach(AbstractInterface *connectedInter, inter->getConnectedTo()){\r
 916 \r
 917       inter->setWidth(connectedInter->getWidth());\r
 918       interfaceToValidate->push(connectedInter);\r
 919     }\r
 920   }\r
 921 \r
 922 \r
 923   try{\r
 924     while(!interfaceToValidate->isEmpty()){\r
 925       interfaceToValidate->pop()->connectionsValidation(interfaceToValidate, validatedInterface);\r
 926     }\r
 927   }\r
 928   catch(Exception e){\r
 929     cerr << e.getMessage().toStdString() << endl;\r
 930   }\r
 931 #endif\r
 932 }\r
 933 \r
 934 QList<AbstractBlock *> Parameters::getBlocksToConfigure() {\r
 935 \r
 936 #ifdef DEBUG_INCLFUN\r
 937 \r
 938   QList<AbstractBlock*> *checkedBlocks = new QList<AbstractBlock*>;\r
 939   QList<AbstractBlock*> *blocksToConfigure = new QList<AbstractBlock*>;\r
 940 \r
 941   foreach(AbstractInterface *inter, topWindow->getScene()->getGroupItem()->getRefBlock()->getInterfaces()){\r
 942     foreach(AbstractInterface *connectedInter, inter->getConnectedTo()){\r
 943       if(!checkedBlocks->contains(connectedInter->getOwner())){\r
 944         connectedInter->getOwner()->parametersValidation(checkedBlocks, blocksToConfigure);\r
 945       }\r
 946     }\r
 947   }\r
 948   return *blocksToConfigure;\r
 949 #endif\r
 950 }\r
 951 \r
 952 \r
 953 void Parameters::updateToolbar() {\r
 954   int nb = currentScene->getBoxItems().length();\r
 955   for(int i = 0; i<nb; i++){\r
 956     if(currentScene->getBoxItems().at(i)->isSelected()){\r
 957       currentScene->getGroupWidget()->enableGroupButton(true);\r
 958       return;\r
 959     }\r
 960   }\r
 961   currentScene->getGroupWidget()->enableGroupButton(false);\r
 962 }\r
 963 \r
 964 \r
 965 void Parameters::updateIds() {\r
 966 \r
 967   /* a in-width cross of the graph must be done so that ids of GroupItem\r
 968      are in the correct ordre when saving/loading a project\r
 969    */\r
 970   int countItem = 1;\r
 971   int countIface = 1;\r
 972   QList<GroupScene *> fifo;\r
 973   fifo.append(topScene);\r
 974   while (!fifo.isEmpty()) {\r
 975     GroupScene* scene = fifo.takeFirst();\r
 976     countItem = scene->setItemsId(countItem);\r
 977     countIface = scene->setInterfacesId(countIface);\r
 978     foreach(GroupScene* s, scene->getChildrenScene()) {\r
 979       fifo.append(s);\r
 980     }\r
 981   }\r
 982 }\r
 983 \r
 984 \r
 985 ReferenceBlock *Parameters::searchBlockByXml(QString xmlName) {\r
 986   foreach(ReferenceBlock *block, availableBlocks){\r
 987     if(block->getXmlFile().contains(xmlName))\r
 988       return block;\r
 989   }\r
 990   return NULL;\r
 991 }\r
 992 \r
 993 ReferenceBlock *Parameters::searchBlockByMd5(QString sumMd5) {\r
 994   foreach(ReferenceBlock *block, availableBlocks){\r
 995     if(block->getHashMd5() == sumMd5)\r
 996       return block;\r
 997   }\r
 998   return NULL;\r
 999 }\r
1000 \r
1001 void Parameters::save(QString confFile) {\r
1002 \r
1003 //#ifdef DEBUG_INCLFUN\r
1004 \r
1005   updateIds();\r
1006   QList<ConnectionItem*> allConnections;\r
1007   QFile file(confFile);\r
1008   if(file.open(QIODevice::WriteOnly)){\r
1009 \r
1010     QXmlStreamWriter writer(&file);\r
1011 \r
1012     writer.setAutoFormatting(true);\r
1013     writer.writeStartDocument();\r
1014 \r
1015     writer.writeStartElement("blast_project");\r
1016     writer.writeStartElement("scenes");\r
1017 \r
1018     writer.writeAttribute("count",QString::number(dispatcher->getNumberOfScenes()));\r
1019 \r
1020     // cross the scene level by level using a FIFO\r
1021     QList<GroupScene*> fifoScene;\r
1022     fifoScene.append(topScene);\r
1023 \r
1024     GroupScene *scene;\r
1025     while (!fifoScene.isEmpty()) {\r
1026       scene = fifoScene.takeFirst();\r
1027       scene->save(writer);\r
1028       foreach(GroupScene* s, scene->getChildrenScene()) {\r
1029         fifoScene.append(s);\r
1030       }\r
1031 \r
1032       foreach(ConnectionItem* item, scene->getConnectionItems()) {\r
1033         allConnections.append(item);\r
1034       }\r
1035     }\r
1036     writer.writeEndElement();    //</scenes>\r
1037 \r
1038     writer.writeStartElement("connections");\r
1039     foreach(ConnectionItem* item, allConnections) {\r
1040 \r
1041       writer.writeStartElement("connection");\r
1042 \r
1043       writer.writeAttribute("from",QString::number(item->getFromInterfaceItem()->getId()));\r
1044       writer.writeAttribute("to", QString::number(item->getToInterfaceItem()->getId()));\r
1045 \r
1046       writer.writeEndElement();\r
1047     }\r
1048 \r
1049     writer.writeEndElement();    //</connections>\r
1050 \r
1051     QList<InterfaceItem *> lstIfaceItem;\r
1052     // search for modifiers\r
1053     foreach(ConnectionItem* item, allConnections) {\r
1054       InterfaceItem* fromIfaceItem = item->getFromInterfaceItem();\r
1055       AbstractInputModifier* mod = fromIfaceItem->refInter->getInputModifier();\r
1056       if (mod != NULL) {\r
1057         if (!lstIfaceItem.contains(fromIfaceItem)) lstIfaceItem.append(fromIfaceItem);\r
1058       }\r
1059       InterfaceItem* toIfaceItem = item->getToInterfaceItem();\r
1060       mod = toIfaceItem->refInter->getInputModifier();\r
1061       if (mod != NULL) {\r
1062         if (!lstIfaceItem.contains(toIfaceItem)) lstIfaceItem.append(toIfaceItem);\r
1063       }\r
1064     }\r
1065     // write input modifiers\r
1066     writer.writeStartElement("modifiers");\r
1067     foreach(InterfaceItem* item, lstIfaceItem) {\r
1068       AbstractInputModifier* mod = item->refInter->getInputModifier();\r
1069       if (mod != NULL) {\r
1070         writer.writeStartElement("modifier");\r
1071         writer.writeAttribute("id", QString::number(item->getId()));\r
1072         writer.writeAttribute("type",mod->getTypeStr());\r
1073         writer.writeAttribute("params", mod->getParametersStr());\r
1074         writer.writeEndElement();\r
1075       }\r
1076     }\r
1077 \r
1078     writer.writeEndElement();    //</modifiers>\r
1079     writer.writeEndElement();      //</blast_project\r
1080 \r
1081     writer.writeEndDocument();\r
1082 \r
1083     file.close();\r
1084     unsaveModif = false;\r
1085   }\r
1086 //#endif\r
1087 }\r
1088 \r
1089 void Parameters::setArrowPathes() {\r
1090   QPainterPath _inArrow;\r
1091   _inArrow.lineTo(arrowLineLength,0);\r
1092   _inArrow.lineTo(arrowLineLength+arrowWidth,-arrowHeight/2);\r
1093   _inArrow.lineTo(arrowLineLength+arrowWidth,arrowHeight/2);\r
1094   _inArrow.lineTo(arrowLineLength,0);\r
1095   _inArrow.closeSubpath();\r
1096   inArrow = _inArrow;\r
1097 \r
1098   QPainterPath _outArrow;\r
1099   _outArrow.lineTo(arrowLineLength,0);\r
1100   _outArrow.lineTo(arrowLineLength,-arrowHeight/2);\r
1101   _outArrow.lineTo(arrowLineLength+arrowWidth,0);\r
1102   _outArrow.lineTo(arrowLineLength,arrowHeight/2);\r
1103   _outArrow.lineTo(arrowLineLength,0);\r
1104   _outArrow.closeSubpath();\r
1105   outArrow = _outArrow;\r
1106 \r
1107 }\r
1108 \r
1109 GroupScene* Parameters::searchSceneById(int id, GroupScene *scene) {\r
1110 \r
1111   if (scene->getId() == id) return scene;\r
1112   GroupScene* sc = NULL;\r
1113 \r
1114   foreach(GroupScene *s, scene->getChildrenScene()) {\r
1115     sc = searchSceneById(id,s);\r
1116     if (sc != NULL) return sc;\r
1117   }\r
1118   return NULL;\r
1119 }\r
1120 \r
1121 GroupItem* Parameters::searchGroupItemById(int id, GroupScene *scene) {\r
1122 \r
1123   if (scene->getGroupItem()->getId() == id) return scene->getGroupItem();\r
1124 \r
1125   GroupItem* item = NULL;\r
1126   foreach(GroupScene *s, scene->getChildrenScene()) {\r
1127     item = searchGroupItemById(id,s);\r
1128     if (item != NULL) return item;\r
1129   }\r
1130   return NULL;\r
1131 }\r
1132 \r
1133 BoxItem* Parameters::searchBlockItemById(int id, GroupScene *scene) {\r
1134 \r
1135   foreach(BoxItem *item, scene->getBoxItems()){\r
1136     if(item->getId() == id){\r
1137       return item;\r
1138     }\r
1139   }\r
1140 \r
1141   BoxItem* item = NULL;\r
1142   foreach(GroupScene *s, scene->getChildrenScene()) {\r
1143     item = searchBlockItemById(id,s);\r
1144     if (item != NULL) return item;\r
1145   }\r
1146   return NULL;\r
1147 }\r
1148 \r
1149 BoxItem* Parameters::searchFunctionalBlock(AbstractBlock* block) {\r
1150 \r
1151   return searchFunctionalBlockRecur(block,topScene);\r
1152 }\r
1153 \r
1154 BoxItem* Parameters::searchFunctionalBlockRecur(AbstractBlock* block, GroupScene* scene) {\r
1155 \r
1156   foreach(BoxItem *item, scene->getBoxItems()){\r
1157     if(item->getRefBlock() == block) {\r
1158       return item;\r
1159     }\r
1160   }\r
1161 \r
1162   BoxItem* item = NULL;\r
1163   foreach(GroupScene *s, scene->getChildrenScene()) {\r
1164     item = searchFunctionalBlockRecur(block,s);\r
1165     if (item != NULL) return item;\r
1166   }\r
1167   return NULL;\r
1168 }\r
1169 \r
1170 InterfaceItem* Parameters::searchInterfaceItemById(int id, GroupScene* scene) {\r
1171 \r
1172   foreach(InterfaceItem *item, scene->getGroupItem()->getInterfaces()){\r
1173     if(item->getId() == id){\r
1174       return item;\r
1175     }\r
1176   }\r
1177   if (scene->isTopScene()) {\r
1178     foreach(SourceItem *block, scene->getSourceItems()){\r
1179       foreach(InterfaceItem *item, block->getInterfaces()){\r
1180         if(item->getId() == id){\r
1181           return item;\r
1182         }\r
1183       }\r
1184     } \r
1185   }\r
1186   foreach(BoxItem *block, scene->getBoxItems()){\r
1187     foreach(InterfaceItem *item, block->getInterfaces()){\r
1188       if(item->getId() == id){\r
1189         return item;\r
1190       }\r
1191     }\r
1192   }\r
1193   InterfaceItem* item = NULL;\r
1194   foreach(GroupScene *s, scene->getChildrenScene()) {\r
1195     item = searchInterfaceItemById(id,s);\r
1196     if (item != NULL) return item;\r
1197   }\r
1198   return NULL;\r
1199 }\r