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 = getObject<model::Port>(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 = getObject<model::Block>(uid);
  93         switch (p)
  94         {
  95             case SIM_FUNCTION_API:
  96                 o->getSimFunctionApi(v);
  97                 return true;
  98             default:
  99                 break;
 100         }
 101     }
 102     else if (k == DIAGRAM)
 103     {
 104         switch (p)
 105         {
 106             default:
 107                 break;
 108         }
 109     }
 110     else if (k == LINK)
 111     {
 112         model::Link* o = getObject<model::Link>(uid);
 113         switch (p)
 114         {
 115             case COLOR:
 116                 o->getColor(v);
 117                 return true;
 118             case KIND:
 119                 o->getKind(v);
 120                 return true;
 121             default:
 122                 break;
 123         }
 124     }
 125     else if (k == PORT)
 126     {
 127         model::Port* o = getObject<model::Port>(uid);
 128         switch (p)
 129         {
 130             case PORT_KIND:
 131                 o->getKind(v);
 132                 return true;
 133             default:
 134                 break;
 135         }
 136     }
 137     return false;
 138 }
 139
 140 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, bool& v) const
 141 {
 142
 143     if (k == ANNOTATION)
 144     {
 145         switch (p)
 146         {
 147             default:
 148                 break;
 149         }
 150     }
 151     else if (k == BLOCK)
 152     {
 153         switch (p)
 154         {
 155             default:
 156                 break;
 157         }
 158     }
 159     else if (k == DIAGRAM)
 160     {
 161         switch (p)
 162         {
 163             default:
 164                 break;
 165         }
 166     }
 167     else if (k == LINK)
 168     {
 169         switch (p)
 170         {
 171             default:
 172                 break;
 173         }
 174     }
 175     else if (k == PORT)
 176     {
 177         model::Port* o = getObject<model::Port>(uid);
 178         switch (p)
 179         {
 180             case IMPLICIT:
 181                 o->getImplicit(v);
 182                 return true;
 183             default:
 184                 break;
 185         }
 186     }
 187     return false;
 188 }
 189
 190 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::string& v) const
 191 {
 192
 193     if (k == ANNOTATION)
 194     {
 195         model::Annotation* o = getObject<model::Annotation>(uid);
 196         switch (p)
 197         {
 198             case DESCRIPTION:
 199                 o->getDescription(v);
 200                 return true;
 201             case FONT:
 202                 o->getFont(v);
 203                 return true;
 204             case FONT_SIZE:
 205                 o->getFontSize(v);
 206                 return true;
 207             default:
 208                 break;
 209         }
 210     }
 211     else if (k == BLOCK)
 212     {
 213         model::Block* o = getObject<model::Block>(uid);
 214         switch (p)
 215         {
 216             case INTERFACE_FUNCTION:
 217                 o->getInterfaceFunction(v);
 218                 return true;
 219             case SIM_FUNCTION_NAME:
 220                 o->getSimFunctionName(v);
 221                 return true;
 222             case SIM_BLOCKTYPE:
 223                 o->getSimBlocktype(v);
 224                 return true;
 225             case STYLE:
 226                 o->getStyle(v);
 227                 return true;
 228             case LABEL:
 229                 o->getLabel(v);
 230                 return true;
 231             case UID:
 232                 o->getUID(v);
 233                 return true;
 234             default:
 235                 break;
 236         }
 237     }
 238     else if (k == DIAGRAM)
 239     {
 240         model::Diagram* o = getObject<model::Diagram>(uid);;
 241         switch (p)
 242         {
 243             case TITLE:
 244                 o->getTitle(v);
 245                 return true;
 246             case PATH:
 247                 o->getPath(v);
 248                 return true;
 249             case VERSION_NUMBER:
 250                 o->getVersionNumber(v);
 251                 return true;
 252             default:
 253                 break;
 254         }
 255     }
 256     else if (k == LINK)
 257     {
 258         model::Link* o = getObject<model::Link>(uid);
 259         switch (p)
 260         {
 261             case LABEL:
 262                 o->getLabel(v);
 263                 return true;
 264             default:
 265                 break;
 266         }
 267     }
 268     else if (k == PORT)
 269     {
 270         model::Port* o = getObject<model::Port>(uid);
 271         switch (p)
 272         {
 273             case STYLE:
 274                 o->getStyle(v);
 275                 return true;
 276             case LABEL:
 277                 o->getLabel(v);
 278                 return true;
 279             default:
 280                 break;
 281         }
 282     }
 283     return false;
 284 }
 285
 286 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, ScicosID& v) const
 287 {
 288
 289     if (k == ANNOTATION)
 290     {
 291         model::Annotation* o = getObject<model::Annotation>(uid);
 292         switch (p)
 293         {
 294             case PARENT_DIAGRAM:
 295                 o->getParentDiagram(v);
 296                 return true;
 297             case PARENT_BLOCK:
 298                 o->getParentBlock(v);
 299                 return true;
 300             case RELATED_TO:
 301                 v = o->getRelatedTo();
 302                 return true;
 303             default:
 304                 break;
 305         }
 306     }
 307     else if (k == BLOCK)
 308     {
 309         model::Block* o = getObject<model::Block>(uid);
 310         switch (p)
 311         {
 312             case PARENT_DIAGRAM:
 313                 o->getParentDiagram(v);
 314                 return true;
 315             case PARENT_BLOCK:
 316                 o->getParentBlock(v);
 317                 return true;
 318             case PORT_REFERENCE:
 319                 o->getPortReference(v);
 320                 return true;
 321             default:
 322                 break;
 323         }
 324     }
 325     else if (k == DIAGRAM)
 326     {
 327
 328     }
 329     else if (k == LINK)
 330     {
 331         model::Link* o = getObject<model::Link>(uid);
 332         switch (p)
 333         {
 334             case PARENT_DIAGRAM:
 335                 o->getParentDiagram(v);
 336                 return true;
 337             case PARENT_BLOCK:
 338                 o->getParentBlock(v);
 339                 return true;
 340             case SOURCE_PORT:
 341                 o->getSourcePort(v);
 342                 return true;
 343             case DESTINATION_PORT:
 344                 o->getDestinationPort(v);
 345                 return true;
 346             default:
 347                 break;
 348         }
 349     }
 350     else if (k == PORT)
 351     {
 352         model::Port* o = getObject<model::Port>(uid);
 353         switch (p)
 354         {
 355             case SOURCE_BLOCK:
 356                 o->getSourceBlock(v);
 357                 return true;
 358             case CONNECTED_SIGNALS:
 359                 v = o->getConnectedSignals().front();
 360                 return true;
 361             default:
 362                 break;
 363         }
 364     }
 365     return false;
 366 }
 367
 368 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<double>& v) const
 369 {
 370
 371     if (k == ANNOTATION)
 372     {
 373         model::Annotation* o = getObject<model::Annotation>(uid);
 374         switch (p)
 375         {
 376             case GEOMETRY:
 377                 o->getGeometry(v);
 378                 return true;
 379             default:
 380                 break;
 381         }
 382     }
 383     else if (k == BLOCK)
 384     {
 385         model::Block* o = getObject<model::Block>(uid);
 386         switch (p)
 387         {
 388             case GEOMETRY:
 389                 o->getGeometry(v);
 390                 return true;
 391             case ANGLE:
 392                 o->getAngle(v);
 393                 return true;
 394             case EXPRS:
 395                 o->getExprs(v);
 396                 return true;
 397             case STATE:
 398                 o->getState(v);
 399                 return true;
 400             case DSTATE:
 401                 o->getDState(v);
 402                 return true;
 403             case ODSTATE:
 404                 o->getODState(v);
 405                 return true;
 406             case RPAR:
 407                 o->getRpar(v);
 408                 return true;
 409             case OPAR:
 410                 o->getOpar(v);
 411                 return true;
 412             default:
 413                 break;
 414         }
 415     }
 416     else if (k == DIAGRAM)
 417     {
 418         model::Diagram* o = getObject<model::Diagram>(uid);;
 419         switch (p)
 420         {
 421             case PROPERTIES:
 422                 o->getProperties(v);
 423                 return true;
 424             default:
 425                 break;
 426         }
 427     }
 428     else if (k == LINK)
 429     {
 430         model::Link* o = getObject<model::Link>(uid);
 431         switch (p)
 432         {
 433             case CONTROL_POINTS:
 434                 o->getControlPoints(v);
 435                 return true;
 436             case THICK:
 437                 o->getThick(v);
 438                 return true;
 439             default:
 440                 break;
 441         }
 442     }
 443     else if (k == PORT)
 444     {
 445         switch (p)
 446         {
 447             default:
 448                 break;
 449         }
 450     }
 451     return false;
 452 }
 453
 454 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<int>& v) const
 455 {
 456
 457     if (k == ANNOTATION)
 458     {
 459         switch (p)
 460         {
 461             default:
 462                 break;
 463         }
 464     }
 465     else if (k == BLOCK)
 466     {
 467         model::Block* o = getObject<model::Block>(uid);
 468         switch (p)
 469         {
 470             case SIM_DEP_UT:
 471                 o->getSimDepUT(v);
 472                 return true;
 473             case NZCROSS:
 474                 o->getNZcross(v);
 475                 return true;
 476             case NMODE:
 477                 o->getNMode(v);
 478                 return true;
 479             case IPAR:
 480                 o->getIpar(v);
 481                 return true;
 482             default:
 483                 break;
 484         }
 485     }
 486     else if (k == DIAGRAM)
 487     {
 488         switch (p)
 489         {
 490             default:
 491                 break;
 492         }
 493     }
 494     else if (k == LINK)
 495     {
 496         switch (p)
 497         {
 498             default:
 499                 break;
 500         }
 501     }
 502     else if (k == PORT)
 503     {
 504         model::Port* o = getObject<model::Port>(uid);
 505         switch (p)
 506         {
 507             case DATATYPE:
 508                 o->getDataType(v);
 509                 return true;
 510             default:
 511                 break;
 512         }
 513     }
 514     return false;
 515 }
 516
 517 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<std::string>& v) const
 518 {
 519
 520     if (k == ANNOTATION)
 521     {
 522         switch (p)
 523         {
 524             default:
 525                 break;
 526         }
 527     }
 528     else if (k == BLOCK)
 529     {
 530         model::Block* o = getObject<model::Block>(uid);
 531         switch (p)
 532         {
 533             case EQUATIONS:
 534                 o->getEquations(v);
 535                 return true;
 536             default:
 537                 break;
 538         }
 539     }
 540     else if (k == DIAGRAM)
 541     {
 542         model::Diagram* o = getObject<model::Diagram>(uid);
 543         switch (p)
 544         {
 545             case DIAGRAM_CONTEXT:
 546                 o->getContext(v);
 547                 return true;
 548             default:
 549                 break;
 550         }
 551     }
 552     else if (k == LINK)
 553     {
 554         switch (p)
 555         {
 556             default:
 557                 break;
 558         }
 559     }
 560     else if (k == PORT)
 561     {
 562         switch (p)
 563         {
 564             default:
 565                 break;
 566         }
 567     }
 568     return false;
 569 }
 570
 571 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<ScicosID>& v) const
 572 {
 573
 574     if (k == ANNOTATION)
 575     {
 576         switch (p)
 577         {
 578             default:
 579                 break;
 580         }
 581     }
 582     else if (k == BLOCK)
 583     {
 584         model::Block* o = getObject<model::Block>(uid);
 585         switch (p)
 586         {
 587             case INPUTS:
 588                 o->getIn(v);
 589                 return true;
 590             case OUTPUTS:
 591                 o->getOut(v);
 592                 return true;
 593             case EVENT_INPUTS:
 594                 o->getEin(v);
 595                 return true;
 596             case EVENT_OUTPUTS:
 597                 o->getEout(v);
 598                 return true;
 599             case CHILDREN:
 600                 o->getChildren(v);
 601                 return true;
 602             default:
 603                 break;
 604         }
 605     }
 606     else if (k == DIAGRAM)
 607     {
 608         model::Diagram* o = getObject<model::Diagram>(uid);
 609         switch (p)
 610         {
 611             case CHILDREN:
 612                 o->getChildren(v);
 613                 return true;
 614             default:
 615                 break;
 616         }
 617     }
 618     else if (k == LINK)
 619     {
 620         switch (p)
 621         {
 622             default:
 623                 break;
 624         }
 625     }
 626     else if (k == PORT)
 627     {
 628         model::Port* o = getObject<model::Port>(uid);
 629         switch (p)
 630         {
 631             case CONNECTED_SIGNALS:
 632                 v = o->getConnectedSignals();
 633                 return true;
 634             default:
 635                 break;
 636         }
 637     }
 638     return false;
 639 }
 640
 641 } /* namespace org_scilab_modules_scicos */