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