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