scilab/modules/scicos/src/cpp/Model_getObjectProperties.cpp

   1 /*
   2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  *  Copyright (C) 2014-2014 - Scilab Enterprises - Clement DAVID
   4  *
   5  *  This file must be used under the terms of the CeCILL.
   6  *  This source file is licensed as described in the file COPYING, which
   7  *  you should have received as part of this distribution.  The terms
   8  *  are also available at
   9  *  http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  10  *
  11  */
  12
  13 #include <string>
  14 #include <vector>
  15
  16 #include "Model.hxx"
  17 #include "utilities.hxx"
  18
  19 #include "model/BaseObject.hxx"
  20 #include "model/Annotation.hxx"
  21 #include "model/Diagram.hxx"
  22 #include "model/Block.hxx"
  23 #include "model/Link.hxx"
  24 #include "model/Port.hxx"
  25
  26 namespace org_scilab_modules_scicos
  27 {
  28
  29 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, double& v)  const
  30 {
  31
  32     if (k == ANNOTATION)
  33     {
  34         switch (p)
  35         {
  36             default:
  37                 break;
  38         }
  39     }
  40     else if (k == BLOCK)
  41     {
  42         switch (p)
  43         {
  44             default:
  45                 break;
  46         }
  47     }
  48     else if (k == DIAGRAM)
  49     {
  50         switch (p)
  51         {
  52             default:
  53                 break;
  54         }
  55     }
  56     else if (k == LINK)
  57     {
  58         switch (p)
  59         {
  60             default:
  61                 break;
  62         }
  63     }
  64     else if (k == PORT)
  65     {
  66         model::Port* o = static_cast<model::Port*>(getObject(uid));
  67         switch (p)
  68         {
  69             case FIRING:
  70                 o->getFiring(v);
  71                 return true;
  72             default:
  73                 break;
  74         }
  75     }
  76     return false;
  77 }
  78
  79 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, int& v) const
  80 {
  81
  82     if (k == ANNOTATION)
  83     {
  84         switch (p)
  85         {
  86             default:
  87                 break;
  88         }
  89     }
  90     else if (k == BLOCK)
  91     {
  92         model::Block* o = static_cast<model::Block*>(getObject(uid));
  93         switch (p)
  94         {
  95             case SIM_FUNCTION_API:
  96                 o->getSimFunctionApi(v);
  97                 return true;
  98             case NZCROSS:
  99                 o->getNZcross(v);
 100                 return true;
 101             case NMODE:
 102                 o->getNMode(v);
 103                 return true;
 104             default:
 105                 break;
 106         }
 107     }
 108     else if (k == DIAGRAM)
 109     {
 110         switch (p)
 111         {
 112             default:
 113                 break;
 114         }
 115     }
 116     else if (k == LINK)
 117     {
 118         model::Link* o = static_cast<model::Link*>(getObject(uid));
 119         switch (p)
 120         {
 121             case COLOR:
 122                 o->getColor(v);
 123                 return true;
 124             case KIND:
 125                 o->getKind(v);
 126                 return true;
 127             default:
 128                 break;
 129         }
 130     }
 131     else if (k == PORT)
 132     {
 133         model::Port* o = static_cast<model::Port*>(getObject(uid));
 134         switch (p)
 135         {
 136             case PORT_KIND:
 137                 o->getKind(v);
 138                 return true;
 139             default:
 140                 break;
 141         }
 142     }
 143     return false;
 144 }
 145
 146 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, bool& v) const
 147 {
 148
 149     if (k == ANNOTATION)
 150     {
 151         switch (p)
 152         {
 153             default:
 154                 break;
 155         }
 156     }
 157     else if (k == BLOCK)
 158     {
 159         switch (p)
 160         {
 161             default:
 162                 break;
 163         }
 164     }
 165     else if (k == DIAGRAM)
 166     {
 167         switch (p)
 168         {
 169             default:
 170                 break;
 171         }
 172     }
 173     else if (k == LINK)
 174     {
 175         switch (p)
 176         {
 177             default:
 178                 break;
 179         }
 180     }
 181     else if (k == PORT)
 182     {
 183         model::Port* o = static_cast<model::Port*>(getObject(uid));
 184         switch (p)
 185         {
 186             case IMPLICIT:
 187                 o->getImplicit(v);
 188                 return true;
 189             default:
 190                 break;
 191         }
 192     }
 193     return false;
 194 }
 195
 196 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::string& v) const
 197 {
 198
 199     if (k == ANNOTATION)
 200     {
 201         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
 202         switch (p)
 203         {
 204             case DESCRIPTION:
 205                 o->getDescription(v);
 206                 return true;
 207             case FONT:
 208                 o->getFont(v);
 209                 return true;
 210             case FONT_SIZE:
 211                 o->getFontSize(v);
 212                 return true;
 213             default:
 214                 break;
 215         }
 216     }
 217     else if (k == BLOCK)
 218     {
 219         model::Block* o = static_cast<model::Block*>(getObject(uid));
 220         switch (p)
 221         {
 222             case INTERFACE_FUNCTION:
 223                 o->getInterfaceFunction(v);
 224                 return true;
 225             case SIM_FUNCTION_NAME:
 226                 o->getSimFunctionName(v);
 227                 return true;
 228             case SIM_BLOCKTYPE:
 229                 o->getSimBlocktype(v);
 230                 return true;
 231             case STYLE:
 232                 o->getStyle(v);
 233                 return true;
 234             case LABEL:
 235                 o->getLabel(v);
 236                 return true;
 237             case UID:
 238                 o->getUID(v);
 239                 return true;
 240             default:
 241                 break;
 242         }
 243     }
 244     else if (k == DIAGRAM)
 245     {
 246         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
 247         switch (p)
 248         {
 249             case TITLE:
 250                 o->getTitle(v);
 251                 return true;
 252             case PATH:
 253                 o->getPath(v);
 254                 return true;
 255             case VERSION_NUMBER:
 256                 o->getVersionNumber(v);
 257                 return true;
 258             default:
 259                 break;
 260         }
 261     }
 262     else if (k == LINK)
 263     {
 264         model::Link* o = static_cast<model::Link*>(getObject(uid));
 265         switch (p)
 266         {
 267             case LABEL:
 268                 o->getLabel(v);
 269                 return true;
 270             default:
 271                 break;
 272         }
 273     }
 274     else if (k == PORT)
 275     {
 276         model::Port* o = static_cast<model::Port*>(getObject(uid));
 277         switch (p)
 278         {
 279             case STYLE:
 280                 o->getStyle(v);
 281                 return true;
 282             case LABEL:
 283                 o->getLabel(v);
 284                 return true;
 285             default:
 286                 break;
 287         }
 288     }
 289     return false;
 290 }
 291
 292 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, ScicosID& v) const
 293 {
 294
 295     if (k == ANNOTATION)
 296     {
 297         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
 298         switch (p)
 299         {
 300             case PARENT_DIAGRAM:
 301                 o->getParentDiagram(v);
 302                 return true;
 303             case RELATED_TO:
 304                 v = o->getRelatedTo();
 305                 return true;
 306             default:
 307                 break;
 308         }
 309     }
 310     else if (k == BLOCK)
 311     {
 312         model::Block* o = static_cast<model::Block*>(getObject(uid));
 313         switch (p)
 314         {
 315             case PARENT_DIAGRAM:
 316                 o->getParentDiagram(v);
 317                 return true;
 318             default:
 319                 break;
 320         }
 321     }
 322     else if (k == DIAGRAM)
 323     {
 324
 325     }
 326     else if (k == LINK)
 327     {
 328         model::Link* o = static_cast<model::Link*>(getObject(uid));
 329         switch (p)
 330         {
 331             case PARENT_DIAGRAM:
 332                 o->getParentDiagram(v);
 333                 return true;
 334             case SOURCE_PORT:
 335                 o->getSourcePort(v);
 336                 return true;
 337             case DESTINATION_PORT:
 338                 o->getDestinationPort(v);
 339                 return true;
 340             default:
 341                 break;
 342         }
 343     }
 344     else if (k == PORT)
 345     {
 346         model::Port* o = static_cast<model::Port*>(getObject(uid));
 347         switch (p)
 348         {
 349             case CONNECTED_SIGNALS:
 350                 v = o->getConnectedSignals().front();
 351                 return true;
 352             default:
 353                 break;
 354         }
 355     }
 356     else
 357     {
 358     }
 359     return false;
 360 }
 361
 362 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<double>& v) const
 363 {
 364
 365     if (k == ANNOTATION)
 366     {
 367         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
 368         switch (p)
 369         {
 370             case GEOMETRY:
 371                 o->getGeometry(v);
 372                 return true;
 373             default:
 374                 break;
 375         }
 376     }
 377     else if (k == BLOCK)
 378     {
 379         model::Block* o = static_cast<model::Block*>(getObject(uid));
 380         switch (p)
 381         {
 382             case GEOMETRY:
 383                 o->getGeometry(v);
 384                 return true;
 385             case ANGLE:
 386                 o->getAngle(v);
 387                 return true;
 388             case STATE:
 389                 o->getState(v);
 390                 return true;
 391             case DSTATE:
 392                 o->getDState(v);
 393                 return true;
 394             case RPAR:
 395                 o->getRpar(v);
 396                 return true;
 397             default:
 398                 break;
 399         }
 400     }
 401     else if (k == DIAGRAM)
 402     {
 403         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
 404         switch (p)
 405         {
 406             case PROPERTIES:
 407                 o->getProperties(v);
 408                 return true;
 409             default:
 410                 break;
 411         }
 412     }
 413     else if (k == LINK)
 414     {
 415         model::Link* o = static_cast<model::Link*>(getObject(uid));
 416         switch (p)
 417         {
 418             case CONTROL_POINTS:
 419                 o->getControlPoints(v);
 420                 return true;
 421             case THICK:
 422                 o->getThick(v);
 423                 return true;
 424             default:
 425                 break;
 426         }
 427     }
 428     else if (k == PORT)
 429     {
 430         switch (p)
 431         {
 432             default:
 433                 break;
 434         }
 435     }
 436
 437     return false;
 438 }
 439
 440 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<int>& v) const
 441 {
 442
 443     if (k == ANNOTATION)
 444     {
 445         switch (p)
 446         {
 447             default:
 448                 break;
 449         }
 450     }
 451     else if (k == BLOCK)
 452     {
 453         model::Block* o = static_cast<model::Block*>(getObject(uid));
 454         switch (p)
 455         {
 456             case SIM_DEP_UT:
 457                 o->getSimDepUT(v);
 458                 return true;
 459             case IPAR:
 460                 o->getIpar(v);
 461                 return true;
 462             default:
 463                 break;
 464         }
 465     }
 466     else if (k == DIAGRAM)
 467     {
 468         switch (p)
 469         {
 470             default:
 471                 break;
 472         }
 473     }
 474     else if (k == LINK)
 475     {
 476         switch (p)
 477         {
 478             default:
 479                 break;
 480         }
 481     }
 482     else if (k == PORT)
 483     {
 484         model::Port* o = static_cast<model::Port*>(getObject(uid));
 485         switch (p)
 486         {
 487             case DATATYPE:
 488                 o->getDataType(v);
 489                 return true;
 490             default:
 491                 break;
 492         }
 493     }
 494     return false;
 495 }
 496
 497 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<std::string>& v) const
 498 {
 499
 500     if (k == ANNOTATION)
 501     {
 502         switch (p)
 503         {
 504             default:
 505                 break;
 506         }
 507     }
 508     else if (k == BLOCK)
 509     {
 510         model::Block* o = static_cast<model::Block*>(getObject(uid));
 511         switch (p)
 512         {
 513             case EXPRS:
 514                 o->getExprs(v);
 515                 return true;
 516             default:
 517                 break;
 518         }
 519     }
 520     else if (k == DIAGRAM)
 521     {
 522         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
 523         switch (p)
 524         {
 525             case DIAGRAM_CONTEXT:
 526                 o->getContext(v);
 527                 return true;
 528             default:
 529                 break;
 530         }
 531     }
 532     else if (k == LINK)
 533     {
 534         switch (p)
 535         {
 536             default:
 537                 break;
 538         }
 539     }
 540     else if (k == PORT)
 541     {
 542         switch (p)
 543         {
 544             default:
 545                 break;
 546         }
 547     }
 548     return false;
 549 }
 550
 551 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<ScicosID>& v) const
 552 {
 553
 554     if (k == ANNOTATION)
 555     {
 556         switch (p)
 557         {
 558             default:
 559                 break;
 560         }
 561     }
 562     else if (k == BLOCK)
 563     {
 564         model::Block* o = static_cast<model::Block*>(getObject(uid));
 565         switch (p)
 566         {
 567             case INPUTS:
 568                 o->getIn(v);
 569                 return true;
 570             case OUTPUTS:
 571                 o->getOut(v);
 572                 return true;
 573             case EVENT_INPUTS:
 574                 o->getEin(v);
 575                 return true;
 576             case EVENT_OUTPUTS:
 577                 o->getEout(v);
 578                 return true;
 579             case CHILDREN:
 580                 o->getChildren(v);
 581                 return true;
 582             default:
 583                 break;
 584         }
 585     }
 586     else if (k == DIAGRAM)
 587     {
 588         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
 589         switch (p)
 590         {
 591             case CHILDREN:
 592                 o->getChildren(v);
 593                 return true;
 594             default:
 595                 break;
 596         }
 597     }
 598     else if (k == LINK)
 599     {
 600         switch (p)
 601         {
 602             default:
 603                 break;
 604         }
 605     }
 606     else if (k == PORT)
 607     {
 608         model::Port* o = static_cast<model::Port*>(getObject(uid));
 609         switch (p)
 610         {
 611             case CONNECTED_SIGNALS:
 612                 v = o->getConnectedSignals();
 613                 return true;
 614             default:
 615                 break;
 616         }
 617     }
 618     return false;
 619 }
 620
 621 } /* namespace org_scilab_modules_scicos */