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