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