scilab/modules/graphic_objects/src/cpp/webutils.cpp

   1 /*
   2 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3 *  Copyright (C) 2016 - Scilab Enterprises - Antoine ELIAS
   4 *
   5 * Copyright (C) 2012 - 2016 - Scilab Enterprises
   6 *
   7 * This file is hereby licensed under the terms of the GNU GPL v2.0,
   8 * pursuant to article 5.3.4 of the CeCILL v.2.1.
   9 * This file was originally licensed under the terms of the CeCILL v2.1,
  10 * and continues to be available under such terms.
  11 * For more information, see the COPYING file which you should have received
  12 * along with this program.
  13 *
  14 */
  15
  16 #include <string.h>
  17 #include <iostream>
  18 #include <cmath>
  19 #include "webutils.hxx"
  20
  21 extern "C"
  22 {
  23 #include "setGraphicObjectProperty.h"
  24 #include "getGraphicObjectProperty.h"
  25 #include "graphicObjectProperties.h"
  26 #include "LayoutType.h"
  27 #include "BorderLayoutType.h"
  28 }
  29
  30 WebUtils::SETTER WebUtils::setter;
  31 WebUtils::WAITING_PROP WebUtils::waitprop;
  32
  33 int WebUtils::getIntProperty(int uid, int prop)
  34 {
  35     int val = 0;
  36     int* pVal = &val;
  37     getGraphicObjectProperty(uid, prop, jni_int, (void **)&pVal);
  38     return val;
  39 }
  40
  41 bool WebUtils::getBoolProperty(int uid, int prop)
  42 {
  43     int val = 0;
  44     int* pVal = &val;
  45     getGraphicObjectProperty(uid, prop, jni_bool, (void **)&pVal);
  46     return val != 0;
  47 }
  48
  49 double WebUtils::getDoubleProperty(int uid, int prop)
  50 {
  51     double val = 0;
  52     double* pVal = &val;
  53     getGraphicObjectProperty(uid, prop, jni_double, (void **)&pVal);
  54     return val;
  55 }
  56
  57 void WebUtils::getDoubleVectorProterty(int uid, int prop, std::vector<double>& vect)
  58 {
  59     double* values = NULL;
  60     getGraphicObjectProperty(uid, prop, jni_double_vector, (void**)&values);
  61
  62     int size = (int)vect.size();
  63     memcpy(vect.data(), values, size * sizeof(double));
  64     releaseGraphicObjectProperty(prop, values, jni_double_vector, size);
  65 }
  66
  67 void WebUtils::getIntVectorProterty(int uid, int prop, std::vector<int>& vect)
  68 {
  69     int* values = NULL;
  70     getGraphicObjectProperty(uid, prop, jni_int_vector, (void**)&values);
  71
  72     int size = (int)vect.size();
  73     memcpy(vect.data(), values, size * sizeof(int));
  74     releaseGraphicObjectProperty(prop, values, jni_int_vector, size);
  75 }
  76
  77 std::string WebUtils::getStringProperty(int uid, int prop)
  78 {
  79     std::string str;
  80     char* val = NULL;
  81     getGraphicObjectProperty(uid, prop, jni_string, (void**)&val);
  82     str = val;
  83     releaseGraphicObjectProperty(prop, val, jni_string, 1);
  84     return str;
  85 }
  86
  87 void WebUtils::getStringVectorProperty(int uid, int prop, std::vector<std::string>& vect)
  88 {
  89     char **pstString = NULL;
  90     getGraphicObjectProperty(uid, prop, jni_string_vector, (void **)&pstString);
  91
  92     int size = (int)vect.size();
  93     for (int i = 0; i < size; ++i)
  94     {
  95         vect[i] = pstString[i];
  96     }
  97
  98     releaseGraphicObjectProperty(prop, pstString, jni_string_vector, size);
  99 }
 100
 101 bool WebUtils::setStringProperty(int uid, int prop, const std::string& value)
 102 {
 103     setGraphicObjectProperty(uid, prop, value.data(), jni_string, 1);
 104     return true;
 105 }
 106
 107 bool WebUtils::setStringVectorProperty(int uid, int prop, const std::vector<std::string>& values)
 108 {
 109     int size = (int)values.size();
 110     std::vector<const char*> c(size, NULL);
 111     for (int i = 0; i < size; ++i)
 112     {
 113         c[i] = values[i].data();
 114     }
 115
 116     setGraphicObjectProperty(uid, prop, (void**)c.data(), jni_string_vector, size);
 117     return true;
 118 }
 119
 120 bool WebUtils::setDoubleVectorProperty(int uid, int prop, const std::vector<double>& values)
 121 {
 122     setGraphicObjectProperty(uid, prop, values.data(), jni_double_vector, (int)values.size());
 123     return true;
 124 }
 125
 126 std::string WebUtils::getIdString(int uid, const std::string& suffix)
 127 {
 128     return "'uid" + std::to_string(uid) + suffix + "'";
 129 }
 130
 131 std::string WebUtils::getElementById(int uid, const std::string& suffix)
 132 {
 133     return "document.getElementById(" + getIdString(uid, suffix) + ");";
 134 }
 135
 136 std::string WebUtils::createElement(const std::string& type)
 137 {
 138     return "document.createElement('" + type + "');";
 139 }
 140
 141 std::string WebUtils::getColor(const std::vector<double>& c)
 142 {
 143     if (c[0] == -1)
 144     {
 145         return "''";
 146     }
 147
 148     std::string str("'rgb(");
 149
 150     //use abs to convert [-1 -1 -1 ] to (255, 255, 255)
 151     str += std::to_string((int)std::abs(c[0] * 255));
 152     for (int i = 1; i < c.size(); ++i)
 153     {
 154         str += ", " + std::to_string((int)std::abs(c[i] * 255));
 155     }
 156
 157     str += ")'";
 158
 159     return str;
 160 }
 161
 162 std::string WebUtils::getSubPadding(int val)
 163 {
 164     if (val)
 165     {
 166         return std::to_string(val) + "px ";
 167     }
 168
 169     return "0 ";
 170 }
 171
 172 std::string WebUtils::getPadding(int t, int r, int b, int l)
 173 {
 174     std::string ret;
 175
 176     ret += getSubPadding(t);
 177     ret += getSubPadding(r);
 178     ret += getSubPadding(b);
 179     ret += getSubPadding(l);
 180
 181     return ret;
 182 }
 183
 184 bool WebUtils::isManaged(int uid)
 185 {
 186     int type = getType(uid);
 187     switch (type)
 188     {
 189         case __GO_FIGURE__:
 190         case __GO_UICONTROL__:
 191             return true;
 192         default:
 193             return false;
 194     }
 195 }
 196
 197 //commons
 198 int WebUtils::getType(int uid)
 199 {
 200     return getIntProperty(uid, __GO_TYPE__);
 201 }
 202
 203 int WebUtils::getStyle(int uid)
 204 {
 205     return getIntProperty(uid, __GO_STYLE__);
 206 }
 207
 208 bool WebUtils::hasValidParent(int uid)
 209 {
 210     return getParent(uid) != 0;
 211 }
 212
 213 int WebUtils::getParent(int uid)
 214 {
 215     return getIntProperty(uid, __GO_PARENT__);
 216 }
 217
 218 void WebUtils::setParent(int uid, std::ostringstream& ostr, bool append)
 219 {
 220     int parent = getParent(uid);
 221
 222     if (append == false)
 223     {
 224         ostr << "var __child__ = " << getElementById(uid) << std::endl;
 225     }
 226
 227     ostr << "var __parent__ = " << getElementById(parent) << std::endl;
 228     ostr << "__parent__.appendChild(__child__);" << std::endl;
 229
 230     if (hasStyle(parent, __GO_UI_TAB__))
 231     {
 232         //add button and properties for tab
 233         addTabChild(parent, uid, ostr);
 234     }
 235
 236     if (getUILayout(parent) == LAYOUT_BORDER && hasStyle(parent, __GO_UI_TAB__) == false)
 237     {
 238         //force update of border position, especially for center
 239         addInWaitingQueue(uid, __GO_UI_BORDER_PREFERREDSIZE__);
 240     }
 241
 242     setWaitingProperties(uid, ostr, true);
 243 }
 244
 245 void WebUtils::getFigureSize(int uid, std::vector<int>& vect)
 246 {
 247     int fig = getFigureId(uid);
 248     vect.resize(2, 0);
 249     getIntVectorProterty(fig, __GO_AXES_SIZE__, vect);
 250 }
 251
 252 void WebUtils::setFigureSize(int uid, std::ostringstream& ostr, bool append)
 253 {
 254     std::vector<int> size;
 255     getFigureSize(uid, size);
 256
 257     if (append == false)
 258     {
 259         ostr << "var __child__ = " << getElementById(uid) << std::endl;
 260     }
 261     ostr << "__child__.style.width = '" << size[0] << "px';" << std::endl;
 262     ostr << "__child__.style.height = '" << size[1] << "px';" << std::endl;
 263 }
 264
 265 int WebUtils::getFigureId(int uid)
 266 {
 267     int id = uid;
 268     while (isFigure(id) == false)
 269     {
 270         id = getParent(id);
 271     }
 272
 273     return id;
 274 }
 275
 276 void WebUtils::getUIPosition(int uid, std::vector<double>& vect)
 277 {
 278     vect.resize(4, 0.);
 279     getDoubleVectorProterty(uid, __GO_POSITION__, vect);
 280 }
 281
 282 void WebUtils::getUIString(int uid, std::vector<std::string> & vect)
 283 {
 284     int size = getIntProperty(uid, __GO_UI_STRING_SIZE__);
 285     //int col = getIntProperty(uid, __GO_UI_STRING_COLNB__);
 286     vect.resize(size, "");
 287     getStringVectorProperty(uid, __GO_UI_STRING__, vect);
 288 }
 289
 290
 291 void WebUtils::setUIPosition(int uid, std::ostringstream& ostr, bool append)
 292 {
 293     std::vector<double> pos;
 294     getUIPosition(uid, pos);
 295
 296     if (append == false)
 297     {
 298         ostr << "var __child__ = " << getElementById(uid) << std::endl;
 299     }
 300
 301     ostr << "__child__.style.left = '" << (int)pos[0] << "px';" << std::endl;
 302     ostr << "__child__.style.bottom = '" << (int)pos[1] << "px';" << std::endl;
 303     ostr << "__child__.style.width = '" << (int)pos[2] << "px';" << std::endl;
 304     ostr << "__child__.style.height = '" << (int)pos[3] << "px';" << std::endl;
 305
 306     //to ensure vertical alignement, adapt style.line-height
 307     if (hasStyle(uid, __GO_UI_TEXT__) || hasStyle(uid, __GO_UI_CHECKBOX__) || hasStyle(uid, __GO_UI_RADIOBUTTON__))
 308     {
 309         std::string v;
 310         getUIVerticalAlignment(uid, v);
 311         if (v == "middle")
 312         {
 313             ostr << "__child__.style.lineHeight = '" << (int)pos[3] << "px';" << std::endl;
 314         }
 315         else
 316         {
 317             ostr << "__child__.style.lineHeight = 'initial';" << std::endl;
 318         }
 319     }
 320 }
 321
 322 void WebUtils::setUIString(int uid, std::ostringstream& ostr, bool append)
 323 {
 324     std::vector<std::string> s;
 325     getUIString(uid, s);
 326     if (s.size() == 0)
 327     {
 328         s.push_back("");
 329     }
 330
 331     switch (getStyle(uid))
 332     {
 333         case __GO_UI_CHECKBOX__:
 334         case __GO_UI_RADIOBUTTON__:
 335         {
 336             if (append == false)
 337             {
 338                 ostr << "var __child__ = " << getElementById(uid) << std::endl;
 339             }
 340
 341             ostr << "var __label__ = " << getElementById(uid, "_label") << std::endl;
 342             ostr << "__label__.innerHTML = '" << s[0] << "';" << std::endl;
 343             break;
 344         }
 345
 346         case __GO_UI_POPUPMENU__ :
 347         case __GO_UI_LISTBOX__:
 348         {
 349             if (append == false)
 350             {
 351                 ostr << "var __child__ = " << getElementById(uid) << std::endl;
 352             }
 353
 354             //remove previous values
 355             ostr << "while (__child__.length) {__child__.remove(0);}" << std::endl;
 356
 357             ostr << "var option;" << std::endl;
 358             int size = (int)s.size();
 359             for (int i = 0; i < size; ++i)
 360             {
 361                 ostr << "option = new Option('" << s[i] << "');" << std::endl;
 362                 ostr << "__child__.add(option);" << std::endl;
 363             }
 364
 365             if (hasStyle(uid, __GO_UI_LISTBOX__))
 366             {
 367                 //switch to listbox instead of combobox
 368                 ostr << "__child__.size = 2;" << std::endl;
 369             }
 370             break;
 371         }
 372
 373         case __GO_UI_TAB__:
 374         {
 375             //nothing to do
 376             break;
 377         }
 378
 379         case __GO_UI_FRAME__:
 380         {
 381             //if parent is a GO_UI_TAB, change value of button
 382             if (hasStyle(getParent(uid), __GO_UI_TAB__))
 383             {
 384                 if (append == false)
 385                 {
 386                     ostr << "var __child__ = " << getElementById(uid) << std::endl;
 387                 }
 388
 389                 ostr << "var __btn__ = " + getElementById(uid, "_btn") << std::endl;
 390                 ostr << "__btn__.value = '" << s[0] << "';" << std::endl;
 391             }
 392             break;
 393         }
 394
 395         default:
 396         {
 397             if (append == false)
 398             {
 399                 ostr << "var __child__ = " << getElementById(uid) << std::endl;
 400             }
 401
 402             if (isInputType(uid))
 403             {
 404                 ostr << "__child__.value = '" << s[0] << "';" << std::endl;
 405             }
 406             else
 407             {
 408                 ostr << "__child__.innerHTML = '" << s[0] << "';" << std::endl;
 409             }
 410             break;
 411         }
 412     }
 413
 414     {
 415     }
 416 }
 417
 418 bool WebUtils::getVisible(int uid)
 419 {
 420     return getBoolProperty(uid, __GO_VISIBLE__);
 421 }
 422
 423 void WebUtils::setVisible(int uid, std::ostringstream& ostr, bool append)
 424 {
 425     //reverse flag value
 426     std::string v = getVisible(uid) ? "inherit" : "hidden";
 427     if (append == false)
 428     {
 429         ostr << "var __child__ = " << getElementById(uid) << std::endl;
 430     }
 431
 432     ostr << "__child__.style.visibility  = '" << v << "';" << std::endl;
 433 }
 434
 435 bool WebUtils::getUIEnable(int uid)
 436 {
 437     return getBoolProperty(uid, __GO_UI_ENABLE__);
 438 }
 439
 440 void WebUtils::setUIEnable(int uid, std::ostringstream& ostr, bool append)
 441 {
 442     //reverse flag value
 443     std::string v = getUIEnable(uid) ? "false" : "true";
 444     if (append == false)
 445     {
 446         ostr << "var __child__ = " << getElementById(uid) << std::endl;
 447     }
 448
 449     ostr << "__child__.disabled  = " << v << ";" << std::endl;
 450 }
 451
 452 bool WebUtils::getUIBackgroundColor(int uid, std::vector<double>& vect)
 453 {
 454     vect.resize(3, 0.);
 455     getDoubleVectorProterty(uid, __GO_UI_BACKGROUNDCOLOR__, vect);
 456     return true;
 457 }
 458
 459 void WebUtils::setUIBackgroundColor(int uid, std::ostringstream& ostr, bool append)
 460 {
 461     std::vector<double> c;
 462     getUIBackgroundColor(uid, c);
 463     if (append == false)
 464     {
 465         ostr << "var __child__ = " << getElementById(uid) << std::endl;
 466     }
 467
 468     ostr << "__child__.style.backgroundColor  = " << getColor(c) << ";" << std::endl;
 469 }
 470
 471 bool WebUtils::getUIFontAngle(int uid, std::string& val)
 472 {
 473     val = getStringProperty(uid, __GO_UI_FONTANGLE__);
 474     return true;
 475 }
 476
 477 void WebUtils::setUIFontAngle(int uid, std::ostringstream& ostr, bool append)
 478 {
 479     std::string angle;
 480     getUIFontAngle(uid, angle);
 481     if (append == false)
 482     {
 483         ostr << "var __child__ = " << getElementById(uid) << std::endl;
 484     }
 485
 486     ostr << "__child__.style.fontStyle  = '" << angle << "';" << std::endl;
 487 }
 488
 489 bool WebUtils::getUIFontName(int uid, std::string& val)
 490 {
 491     val = getStringProperty(uid, __GO_UI_FONTNAME__);
 492     return true;
 493 }
 494
 495 void WebUtils::setUIFontName(int uid, std::ostringstream& ostr, bool append)
 496 {
 497     std::string font;
 498     getUIFontName(uid, font);
 499     if (append == false)
 500     {
 501         ostr << "var __child__ = " << getElementById(uid) << std::endl;
 502     }
 503
 504     ostr << "__child__.style.fontFamily  = '" << font << "','serif' ;" << std::endl;
 505 }
 506
 507 bool WebUtils::getUIFontUnits(int uid, std::string& val)
 508 {
 509     val =  getStringProperty(uid, __GO_UI_FONTUNITS__);
 510     return true;
 511 }
 512
 513 double WebUtils::getUIFontSize(int uid)
 514 {
 515     return getDoubleProperty(uid, __GO_UI_FONTSIZE__);
 516 }
 517
 518 void WebUtils::setUIFontSize(int uid, std::ostringstream& ostr, bool append)
 519 {
 520     int size = (int)getUIFontSize(uid);
 521
 522     std::string units;
 523     getUIFontUnits(uid, units);
 524
 525     if (units == "pixels")
 526     {
 527         units = "px";
 528     }
 529     else //"points"
 530     {
 531         units = "pt";
 532         size = (int)(size * 0.75);
 533     }
 534
 535     if (append == false)
 536     {
 537         ostr << "var __child__ = " << getElementById(uid) << std::endl;
 538     }
 539
 540     ostr << "__child__.style.fontSize  = '" << size << units << "';" << std::endl;
 541 }
 542
 543 bool WebUtils::getUIFontWeight(int uid, std::string& val)
 544 {
 545     val = getStringProperty(uid, __GO_UI_FONTWEIGHT__);
 546     return true;
 547 }
 548
 549 void WebUtils::setUIFontWeight(int uid, std::ostringstream& ostr, bool append)
 550 {
 551     std::string weight;
 552     getUIFontWeight(uid, weight);
 553
 554     if (append == false)
 555     {
 556         ostr << "var __child__ = " << getElementById(uid) << std::endl;
 557     }
 558
 559     ostr << "__child__.style.fontWeight  = '" << weight << "';" << std::endl;
 560 }
 561
 562 bool WebUtils::getUIForegroundColor(int uid, std::vector<double>& vect)
 563 {
 564     vect.resize(3, 0.);
 565     getDoubleVectorProterty(uid, __GO_UI_FOREGROUNDCOLOR__, vect);
 566     return true;
 567 }
 568
 569 void WebUtils::setUIForegroundColor(int uid, std::ostringstream& ostr, bool append)
 570 {
 571     std::vector<double> c;
 572     getUIForegroundColor(uid, c);
 573
 574     if (append == false)
 575     {
 576         ostr << "var __child__ = " << getElementById(uid) << std::endl;
 577     }
 578
 579     ostr << "__child__.style.color  = " << getColor(c) << ";" << std::endl;
 580 }
 581
 582 bool WebUtils::getUIHorizontalAlignment(int uid, std::string& val)
 583 {
 584     val = getStringProperty(uid, __GO_UI_HORIZONTALALIGNMENT__);
 585     return true;
 586 }
 587
 588 void WebUtils::setUIHorizontalAlignment(int uid, std::ostringstream& ostr, bool append)
 589 {
 590     std::string align;
 591     getUIHorizontalAlignment(uid, align);
 592
 593     if (append == false)
 594     {
 595         ostr << "var __child__ = " << getElementById(uid) << std::endl;
 596     }
 597
 598     ostr << "__child__.style.textAlign  = '" << align << "';" << std::endl;
 599 }
 600
 601 bool WebUtils::getUIRelief(int uid, std::string& val)
 602 {
 603     val = getStringProperty(uid, __GO_UI_RELIEF__);
 604     return true;
 605 }
 606
 607 void WebUtils::setUIRelief(int uid, std::ostringstream& ostr, bool append)
 608 {
 609 }
 610
 611 bool WebUtils::getUIVerticalAlignment(int uid, std::string& val)
 612 {
 613     val = getStringProperty(uid, __GO_UI_VERTICALALIGNMENT__);
 614     return true;
 615 }
 616
 617 void WebUtils::setUIVerticalAlignment(int uid, std::ostringstream& ostr, bool append)
 618 {
 619 }
 620
 621 int WebUtils::getUILayout(int uid)
 622 {
 623     return getIntProperty(uid, __GO_LAYOUT__);
 624     return true;
 625 }
 626
 627 void WebUtils::setUILayout(int uid, std::ostringstream& ostr, bool append)
 628 {
 629     if (isFigure(uid) || hasStyle(uid, __GO_UI_FRAME__))
 630     {
 631         //TODO clean previous layout before create new one
 632
 633         if (append == false)
 634         {
 635             ostr << "var __child__ = " << getElementById(uid) << ";" << std::endl;
 636         }
 637
 638         int layout = getUILayout(uid);
 639         switch (layout)
 640         {
 641             case LAYOUT_BORDER:
 642             {
 643                 //create a table ( ascii art powa ! )
 644                 //+---------------------+
 645                 //|         TOP         |
 646                 //+---+-------------+---+
 647                 //| L |             | R |
 648                 //| E |             | I |
 649                 //| F |   CENTER    | G |
 650                 //| T |             | H |
 651                 //|   |             | T |
 652                 //+---+-------------+---+
 653                 //|       BOTTOM        |
 654                 //+---------------------+
 655
 656                 //add "frame" in child to be more ... flexible ;)
 657
 658                 ostr << "var __layout__ = " << createElement("DIV") << std::endl;
 659                 ostr << "__layout__.id = " << getIdString(uid, "_layout") << ";" << std::endl;
 660                 ostr << "__layout__.style.display = 'flex';" << std::endl;
 661                 ostr << "__layout__.style.flexDirection = 'column';" << std::endl;
 662                 ostr << "__layout__.style.width = '100%';" << std::endl;
 663                 ostr << "__layout__.style.height = '100%';" << std::endl;
 664
 665                 //add top
 666                 ostr << "var __top__ = " << createElement("HEADER") << std::endl;
 667                 ostr << "__top__.id = " << getIdString(uid, "_top") << ";" << std::endl;
 668                 ostr << "__top__.style.width = '100%';" << std::endl;
 669
 670                 //add middle band
 671                 ostr << "var __middle__ = " << createElement("DIV") << std::endl;
 672                 ostr << "__middle__.id = " << getIdString(uid, "_middle") << ";" << std::endl;
 673                 ostr << "__middle__.style.flex = '1';" << std::endl;
 674                 ostr << "__middle__.style.display = 'flex';" << std::endl;
 675
 676                 //add left
 677                 ostr << "var __left__ = " << createElement("ASIDE") << std::endl;
 678                 ostr << "__left__.id = " << getIdString(uid, "_left") << ";" << std::endl;
 679                 ostr << "__left__.style.display = 'flex';" << std::endl;
 680
 681                 //add center
 682                 ostr << "var __center__ = " << createElement("ARTICLE") << std::endl;
 683                 ostr << "__center__.id = " << getIdString(uid, "_center") << ";" << std::endl;
 684                 ostr << "__center__.style.flex = '1';" << std::endl;
 685                 ostr << "__center__.style.display = 'flex';" << std::endl;
 686                 ostr << "__center__.style.width = '100%';" << std::endl;
 687
 688                 //add right
 689                 ostr << "var __right__ = " << createElement("ASIDE") << std::endl;
 690                 ostr << "__right__.id = " << getIdString(uid, "_right") << ";" << std::endl;
 691                 ostr << "__right__.style.display = 'flex';" << std::endl;
 692
 693                 //add bottom
 694                 ostr << "var __bottom__ = " << createElement("FOOTER") << std::endl;
 695                 ostr << "__bottom__.id = " << getIdString(uid, "_bottom") << ";" << std::endl;
 696                 ostr << "__bottom__.style.width = '100%';" << std::endl;
 697
 698                 //hierarchie
 699                 ostr << "__middle__.appendChild(__left__);" << std::endl;
 700                 ostr << "__middle__.appendChild(__center__);" << std::endl;
 701                 ostr << "__middle__.appendChild(__right__);" << std::endl;
 702
 703                 ostr << "__layout__.appendChild(__top__);" << std::endl;
 704                 ostr << "__layout__.appendChild(__middle__);" << std::endl;
 705                 ostr << "__layout__.appendChild(__bottom__);" << std::endl;
 706
 707                 ostr << "__child__.appendChild(__layout__);" << std::endl;
 708                 break;
 709             }
 710             case LAYOUT_GRID:
 711             {
 712                 break;
 713             }
 714             case LAYOUT_GRIDBAG:
 715             {
 716                 //add empty table
 717                 ostr << "var __table__ = " << createElement("TABLE") << std::endl;
 718                 ostr << "__table__.id = " << getIdString(uid, "_table") << ";" << std::endl;
 719                 ostr << "__table__.style.margin = '0';" << std::endl;
 720                 ostr << "__table__.style.padding = '0';" << std::endl;
 721                 ostr << "__table__.style.width = '100%';" << std::endl;
 722                 ostr << "__table__.style.height = '100%';" << std::endl;
 723                 ostr << "__table__.style.borderCollapse = 'collapse';" << std::endl;
 724
 725                 //table in parent
 726                 ostr << "__child__.appendChild(__table__);" << std::endl;
 727                 break;
 728             }
 729             default:
 730             case LAYOUT_NONE:
 731             {
 732                 break;
 733             }
 734
 735         }
 736     }
 737 }
 738
 739 double WebUtils::getUIMin(int uid)
 740 {
 741     return getDoubleProperty(uid, __GO_UI_MIN__);
 742 }
 743
 744 void WebUtils::setUIMin(int uid, std::ostringstream& ostr, bool append)
 745 {
 746     if (hasStyle(uid, __GO_UI_SPINNER__) || hasStyle(uid, __GO_UI_SLIDER__))
 747     {
 748         double min = getUIMin(uid);
 749
 750         if (append == false)
 751         {
 752             ostr << "var __child__ = " << getElementById(uid) << std::endl;
 753         }
 754
 755         ostr << "__child__.min  = '" << min << "';" << std::endl;
 756     }
 757 }
 758
 759 double WebUtils::getUIMax(int uid)
 760 {
 761     return getDoubleProperty(uid, __GO_UI_MAX__);
 762 }
 763
 764 void WebUtils::setUIMax(int uid, std::ostringstream& ostr, bool append)
 765 {
 766     if (hasStyle(uid, __GO_UI_SPINNER__) || hasStyle(uid, __GO_UI_SLIDER__))
 767     {
 768         double max = getUIMax(uid);
 769
 770         if (append == false)
 771         {
 772             ostr << "var __child__ = " << getElementById(uid) << std::endl;
 773         }
 774
 775         ostr << "__child__.max  = '" << max << "';" << std::endl;
 776     }
 777 }
 778
 779 double WebUtils::getUIStep(int uid)
 780 {
 781     std::vector<double> step(2, 0.);
 782     getDoubleVectorProterty(uid, __GO_UI_SLIDERSTEP__, step);
 783     return step[0];
 784 }
 785
 786 void WebUtils::setUIStep(int uid, std::ostringstream& ostr, bool append)
 787 {
 788     if (hasStyle(uid, __GO_UI_SPINNER__) || hasStyle(uid, __GO_UI_SLIDER__))
 789     {
 790         double step = getUIStep(uid);
 791
 792         if (append == false)
 793         {
 794             ostr << "var __child__ = " << getElementById(uid) << std::endl;
 795         }
 796
 797         ostr << "__child__.step  = '" << step << "';" << std::endl;
 798     }
 799 }
 800
 801 bool WebUtils::getUIValue(int uid, std::vector<double>& vect)
 802 {
 803     int size = getIntProperty(uid, __GO_UI_VALUE_SIZE__);
 804     vect.resize(size, 0.);
 805     getDoubleVectorProterty(uid, __GO_UI_VALUE__, vect);
 806     return true;
 807 }
 808
 809 void WebUtils::setUIValue(int uid, std::ostringstream& ostr, bool append)
 810 {
 811     switch (getStyle(uid))
 812     {
 813         case __GO_UI_SPINNER__:
 814         case __GO_UI_SLIDER__:
 815         {
 816             std::vector<double> values;
 817             getUIValue(uid, values);
 818             if (values.size() == 0)
 819             {
 820                 values.push_back(0);
 821             }
 822
 823             if (append == false)
 824             {
 825                 ostr << "var __child__ = " << getElementById(uid) << std::endl;
 826             }
 827
 828             ostr << "__child__.value  = '" << values[0] << "';" << std::endl;
 829             break;
 830         }
 831
 832         case __GO_UI_TAB__:
 833         {
 834             std::vector<double> values;
 835             getUIValue(uid, values);
 836             if (values.size() == 0)
 837             {
 838                 values.push_back(0);
 839             }
 840
 841             if (append == false)
 842             {
 843                 ostr << "var __child__ = " << getElementById(uid) << std::endl;
 844             }
 845
 846             ostr << "tabSelectHelper(__child__, " << values[0] << ");" << std::endl;
 847             break;
 848         }
 849     }
 850 }
 851
 852 void WebUtils::getUIBorderPreferredSize(int uid, std::vector<int>& vect)
 853 {
 854     vect.resize(2, 0);
 855     getIntVectorProterty(uid, __GO_UI_BORDER_PREFERREDSIZE__, vect);
 856 }
 857
 858 void WebUtils::getUIBorderPadding(int uid, std::vector<int>& vect)
 859 {
 860     vect.resize(2, 0);
 861     getIntVectorProterty(uid, __GO_BORDER_OPT_PADDING__, vect);
 862 }
 863
 864 int WebUtils::getUIBorderPosition(int uid)
 865 {
 866     return getIntProperty(uid, __GO_UI_BORDER_POSITION__);
 867 }
 868
 869 void WebUtils::setUIBorder(int uid, std::ostringstream& ostr, bool append)
 870 {
 871     int parent = getParent(uid);
 872     //std::cerr << "setUIBorder : " << uid << " -> " << parent << std::endl;
 873     std::string position;
 874     std::string padding;
 875     int border = getUIBorderPosition(uid);
 876
 877     std::vector<int> pad;
 878     getUIBorderPadding(parent, pad);
 879
 880     std::vector<int> size;
 881     getUIBorderPreferredSize(uid, size);
 882
 883
 884
 885     if (append == false)
 886     {
 887         ostr << "var __child__ = " << getElementById(uid) << std::endl;
 888     }
 889
 890     switch (border)
 891     {
 892         default:
 893         case BORDER_CENTER:
 894             position = "_center";
 895             ostr << "__child__.style.width = 'inherit';" << std::endl;
 896             ostr << "__child__.style.height = 'inherit';" << std::endl;
 897             padding = getPadding(0, 0, 0, 0);
 898             break;
 899         case BORDER_BOTTOM:
 900             position = "_bottom";
 901             ostr << "__child__.style.width = '100%';" << std::endl;
 902
 903             if (size[1] == -1)
 904             {
 905                 ostr << "__child__.style.height = 'inherit';" << std::endl;
 906             }
 907             else
 908             {
 909                 ostr << "__child__.style.height = '" << getSubPadding(size[1]) << "';" << std::endl;
 910             }
 911
 912             padding = getPadding(pad[1], 0, 0, 0);
 913             break;
 914         case BORDER_TOP:
 915             position = "_top";
 916             ostr << "__child__.style.width = '100%';" << std::endl;
 917
 918             if (size[1] == -1)
 919             {
 920                 ostr << "__child__.style.height = 'inherit';" << std::endl;
 921             }
 922             else
 923             {
 924                 ostr << "__child__.style.height = '" << getSubPadding(size[1]) << "';" << std::endl;
 925             }
 926
 927             padding = getPadding(0, 0, pad[1], 0);
 928             break;
 929         case BORDER_LEFT:
 930             position = "_left";
 931
 932             if (size[0] == -1)
 933             {
 934                 ostr << "__child__.style.width = 'inherit';" << std::endl;
 935             }
 936             else
 937             {
 938                 ostr << "__child__.style.width = '" << getSubPadding(size[0]) << "';" << std::endl;
 939             }
 940
 941             ostr << "__child__.style.height = 'inherit';" << std::endl;
 942             padding = getPadding(0, pad[0], 0, 0);
 943             break;
 944         case BORDER_RIGHT:
 945             position = "_right";
 946
 947             if (size[0] == -1)
 948             {
 949                 ostr << "__child__.style.width = 'inherit';" << std::endl;
 950             }
 951             else
 952             {
 953                 ostr << "__child__.style.width = '" << getSubPadding(size[0]) << "';" << std::endl;
 954             }
 955
 956             ostr << "__child__.style.height = 'inherit';" << std::endl;
 957             padding = getPadding(0, 0, 0, pad[0]);
 958             break;
 959     }
 960
 961
 962     //move child in targeted cell
 963     ostr << "__parent__ = " << getElementById(parent, position) << std::endl;
 964     ostr << "__parent__.appendChild(__child__);" << std::endl;
 965     ostr << "__parent__.style.padding = '" << padding << "';" << std::endl;
 966
 967     //to well perform positionning, we must clear some default properties
 968     //position left, right, width, height,
 969
 970     ostr << "__child__.style.position = 'inherit';" << std::endl;
 971     ostr << "__child__.style.left = 'inherit';" << std::endl;
 972     ostr << "__child__.style.bottom = 'inherit';" << std::endl;
 973 }
 974
 975 void WebUtils::getUIGridBagGrid(int uid, std::vector<int>& vect)
 976 {
 977     vect.resize(4, 0);
 978     getIntVectorProterty(uid, __GO_UI_GRIDBAG_GRID__, vect);
 979 }
 980
 981
 982 void WebUtils::setUIGridBag(int uid, std::ostringstream& ostr, bool append)
 983 {
 984     int parent = getParent(uid);
 985     std::vector<int> grid;
 986     getUIGridBagGrid(uid, grid);
 987
 988     if (append == false)
 989     {
 990         ostr << "var __child__ = " << getElementById(uid) << std::endl;
 991     }
 992
 993     ostr << "__child__.style.position = 'inherit';" << std::endl;
 994     ostr << "__child__.style.left = 'inherit';" << std::endl;
 995     ostr << "__child__.style.bottom = 'inherit';" << std::endl;
 996     ostr << "__child__.style.width = '100%';" << std::endl;
 997     ostr << "__child__.style.height = '100%';" << std::endl;
 998     //we have to create a td with grid information and add it to the good cell ( or create if not exist ! )
 999
1000     //build td child
1001     std::string td;
1002     td = "var __td__ = " + createElement("TD");
1003
1004     std::string name("_" + std::to_string(grid[0]) + "_" + std::to_string(grid[1]));
1005     td += "__td__.id = " + getIdString(parent, name) + ";";
1006
1007     if (grid[2] != 1)
1008     {
1009         td += "__td__.colSpan = '" + std::to_string(grid[2]) + "';";
1010     }
1011
1012     if (grid[3] != 1)
1013     {
1014         td += "__td__.rowSpan = '" + std::to_string(grid[3]) + "';";
1015     }
1016
1017     td += "__td__.appendChild(__child__);";
1018
1019     //build or get tr
1020     name = "_" + std::to_string(grid[1]);
1021     std::string tr;
1022     tr = "var __tr__ = " + getElementById(parent, name);
1023     tr += "var __table__ = " + getElementById(parent, "_table");
1024     tr += "if(__tr__ == null){";
1025     tr += "__tr__ = " + createElement("TR");
1026     tr += "__tr__.id = " + getIdString(parent, name) + ";";
1027     tr += "gridbagHelperTR(__table__, __tr__, " + std::to_string(grid[1]) + ");";
1028     tr += "}";
1029     tr += "gridbagHelperTD(__tr__,__td__, " + std::to_string(grid[0]) + ");";
1030
1031     //to force refresh of table, move it to another component and restore it
1032     std::string tricktoforcerefresh("var __scilab__ = document.getElementById('scilab');");
1033     tricktoforcerefresh += "__scilab__.appendChild(__table__);";
1034     tricktoforcerefresh += "var __parent__ = " + getElementById(parent);
1035     tricktoforcerefresh += "__parent__.appendChild(__table__);";
1036
1037
1038     ostr << td << std::endl;
1039     ostr << tr << std::endl;
1040     ostr << tricktoforcerefresh << std::endl;
1041 }
1042
1043 bool WebUtils::hasCallback(int uid)
1044 {
1045     return getStringProperty(uid, __GO_CALLBACK__) != "";
1046 }
1047
1048 void WebUtils::setCallback(int uid, std::ostringstream& ostr, bool append)
1049 {
1050     if (append == false)
1051     {
1052         ostr << "var __child__ = " << getElementById(uid) << std::endl;
1053     }
1054
1055     std::string event;
1056     std::string func;
1057     switch (getStyle(uid))
1058     {
1059         case __GO_UI_PUSHBUTTON__ :
1060             event = "click";
1061             func = "onPushButton";
1062             break;
1063         case __GO_UI_CHECKBOX__:
1064             event = "click";
1065             func = "onCheckBox";
1066             break;
1067         case __GO_UI_RADIOBUTTON__:
1068             event = "click";
1069             func = "onRadioButton";
1070             break;
1071         case __GO_UI_LISTBOX__:
1072             event = "change";
1073             func = "onListBox";
1074             break;
1075         case __GO_UI_POPUPMENU__:
1076             event = "change";
1077             func = "onComboBox";
1078             break;
1079         /*
1080                 case __GO_UI_TAB__:
1081                     event = "click";
1082                     func = "onPushButton";
1083                     break;
1084         */
1085         case __GO_UI_SLIDER__:
1086             event = "input";
1087             func = "onSlider";
1088             break;
1089         case __GO_UI_EDIT__:
1090             event = "input";
1091             func = "onEditBox";
1092             break;
1093         case __GO_UI_SPINNER__:
1094             event = "input";
1095             func = "onSpinner";
1096             break;
1097         default :
1098             return;
1099     }
1100
1101     //add callback listener
1102     ostr << "__child__.addEventListener('" << event << "', " << func << ");" << std::endl;
1103 }
1104
1105 //is
1106 bool WebUtils::isInputType(int uid)
1107 {
1108     switch (getStyle(uid))
1109     {
1110         case __GO_UI_EDIT__ :
1111         case __GO_UI_SLIDER__:
1112         case __GO_UI_SPINNER__ :
1113             return true;
1114         default :
1115             return false;
1116     }
1117 }
1118
1119 bool WebUtils::hasStyle(int uid, int style)
1120 {
1121     if (isUIcontrol(uid))
1122     {
1123         return getStyle(uid) == style;
1124     }
1125
1126     return false;
1127 }
1128
1129 bool WebUtils::isFigure(int uid)
1130 {
1131     return getType(uid) == __GO_FIGURE__;
1132 }
1133
1134 bool WebUtils::isUIcontrol(int uid)
1135 {
1136     return getType(uid) == __GO_UICONTROL__;
1137 }
1138
1139 bool WebUtils::isButton(int uid)
1140 {
1141     return hasStyle(uid, __GO_UI_PUSHBUTTON__);
1142 }
1143
1144
1145 //create
1146 bool WebUtils::createFigure(int uid, std::ostringstream& ostr)
1147 {
1148     //set figure uid to help children to find it
1149     ostr << "var __parent__ = document.getElementById('scilab');" << std::endl;
1150     ostr << "var __temp__ = " << createElement("DIV") << std::endl;
1151     ostr << "__temp__.id = " << getIdString(uid) << ";" << std::endl;
1152     ostr << "__temp__.className = 'GO_FIGURE';" << std::endl;
1153     ostr << "__parent__.innerHTML += '<br>';" << std::endl;
1154     ostr << "__parent__.appendChild(__temp__);" << std::endl;
1155     ostr << "__parent__.innerHTML += '<br>';" << std::endl;
1156     return true;
1157 }
1158
1159 bool WebUtils::createUIControl(int uid, std::ostringstream& ostr)
1160 {
1161     int style = getStyle(uid);
1162     switch (style)
1163     {
1164         case __GO_UI_FRAME__:
1165             return createFrame(uid, ostr);
1166         case __GO_UI_PUSHBUTTON__:
1167             return createPushButton(uid, ostr);
1168         case __GO_UI_TEXT__:
1169             return createText(uid, ostr);
1170         case __GO_UI_EDIT__:
1171             return createEdit(uid, ostr);
1172         case __GO_UI_CHECKBOX__:
1173             return createCheckbox(uid, ostr);
1174         case __GO_UI_RADIOBUTTON__:
1175             return createRadio(uid, ostr);
1176         case __GO_UI_SLIDER__:
1177             return createSlider(uid, ostr);
1178         case __GO_UI_LISTBOX__:
1179             return createListbox(uid, ostr);
1180         case __GO_UI_POPUPMENU__:
1181             return createCombobox(uid, ostr);
1182         case __GO_UI_SPINNER__:
1183             return createSpinner(uid, ostr);
1184         case __GO_UI_TAB__:
1185             return createTab(uid, ostr);
1186         default:
1187             return false;
1188     }
1189 }
1190
1191 bool WebUtils::createCommonIUControl(int uid, const std::string& htmlType, const std::string& cssClass, std::ostringstream& ostr)
1192 {
1193     //create a button, with no parent, wait update with _GO_PARENT to update it
1194     ostr << "var __temp__ = " << createElement(htmlType) << std::endl;
1195     ostr << "__temp__.id = " << getIdString(uid) << ";" << std::endl;
1196     ostr << "__temp__.className = '" << cssClass << "';" << std::endl;
1197
1198     return true;
1199 }
1200
1201 bool WebUtils::createPushButton(int uid, std::ostringstream& ostr)
1202 {
1203     //create a <button>
1204     createCommonIUControl(uid, "BUTTON", "GO_PUSHBUTTON", ostr);
1205     //add item temporary in main scilabview div waiting __GO_PARENT__ update
1206     ostr << "var __parent__ = document.getElementById('scilab');" << std::endl;
1207     ostr << "__parent__.appendChild(__temp__);" << std::endl;
1208
1209     return true;
1210 }
1211
1212 bool WebUtils::createFrame(int uid, std::ostringstream& ostr)
1213 {
1214     //create a <div>
1215     createCommonIUControl(uid, "DIV", "GO_FRAME", ostr);
1216     //add item temporary in main div waiting __GO_PARENT__ update
1217     ostr << "var __parent__ = document.getElementById('scilab');" << std::endl;
1218     ostr << "__parent__.appendChild(__temp__);" << std::endl;
1219
1220     return true;
1221 }
1222
1223 bool WebUtils::createText(int uid, std::ostringstream& ostr)
1224 {
1225     //create a <div>
1226     createCommonIUControl(uid, "LABEL", "GO_TEXT", ostr);
1227     //add item temporary in main div waiting __GO_PARENT__ update
1228     ostr << "var __parent__ = document.getElementById('scilab');" << std::endl;
1229     ostr << "__parent__.appendChild(__temp__);" << std::endl;
1230
1231     return true;
1232 }
1233
1234 bool WebUtils::createEdit(int uid, std::ostringstream& ostr)
1235 {
1236     //create a <input>
1237     createCommonIUControl(uid, "INPUT", "GO_EDIT", ostr);
1238     ostr << "__temp__.type = 'text';" << std::endl;
1239     //add item temporary in main div waiting __GO_PARENT__ update
1240     ostr << "var __parent__ = document.getElementById('scilab');" << std::endl;
1241     ostr << "__parent__.appendChild(__temp__);" << std::endl;
1242
1243     return true;
1244 }
1245
1246 bool WebUtils::createCheckbox(int uid, std::ostringstream& ostr)
1247 {
1248     //create a <input>
1249
1250     //for checkbox we need to create 3 elements.
1251
1252     //a div to enclose others
1253     ostr << "var __main__ = " << createElement("DIV") << std::endl;
1254     ostr << "__main__.id = " << getIdString(uid) << ";" << std::endl;
1255     ostr << "__main__.className = 'GO_CHECKBOX';" << std::endl;
1256     //add item temporary in main div waiting __GO_PARENT__ update
1257     ostr << "var __parent__ = document.getElementById('scilab');" << std::endl;
1258     ostr << "__parent__.appendChild(__main__);" << std::endl;
1259
1260     //the checkbox itself
1261     ostr << "var __temp__ = " << createElement("INPUT") << std::endl;
1262     ostr << "__temp__.className = 'GO_CHECKBOX_CHECKBOX';" << std::endl;
1263     ostr << "__temp__.type = 'checkbox';" << std::endl;
1264     ostr << "__temp__.id = " << getIdString(uid, "_checkbox") << ";" << std::endl;
1265     //add item temporary in main div waiting __GO_PARENT__ update
1266     ostr << "__main__.appendChild(__temp__);" << std::endl;
1267
1268     //the label of the checkbox
1269     ostr << "var __label__ = " << createElement("LABEL") << std::endl;
1270     ostr << "__label__.id = " << getIdString(uid, "_label") << ";" << std::endl;
1271     ostr << "__label__.className = 'GO_CHECKBOX_LABEL';" << std::endl;
1272     ostr << "__label__.htmlFor = " << getIdString(uid, "_checkbox") << ";" << std::endl;
1273     //add item temporary in main div waiting __GO_PARENT__ update
1274     ostr << "__main__.appendChild(__label__);" << std::endl;
1275
1276     return true;
1277 }
1278
1279 bool WebUtils::createRadio(int uid, std::ostringstream& ostr)
1280 {
1281     //create a <input>
1282
1283     //for radio we need to create 3 elements.
1284
1285     //a div to enclose others
1286     ostr << "var __main__ = " << createElement("DIV") << std::endl;
1287     ostr << "__main__.id = " << getIdString(uid) << ";" << std::endl;
1288     ostr << "__main__.className = 'GO_RADIO';" << std::endl;
1289     //add item temporary in main div waiting __GO_PARENT__ update
1290     ostr << "var __parent__ = document.getElementById('scilab');" << std::endl;
1291     ostr << "__parent__.appendChild(__main__)" << std::endl;
1292
1293     //the radio itself
1294     ostr << "var __temp__ = " << createElement("INPUT") << std::endl;
1295     ostr << "__temp__.className = 'GO_RADIO_RADIO';" << std::endl;
1296     ostr << "__temp__.type = 'radio';" << std::endl;
1297     ostr << "__temp__.id = " << getIdString(uid, "_radio") << ";" << std::endl;
1298     //add item temporary in main div waiting __GO_PARENT__ update
1299     ostr << "__main__.appendChild(__temp__);" << std::endl;
1300
1301     //the label of the checkbox
1302     ostr << "var __label__ = " << createElement("LABEL") << std::endl;
1303     ostr << "__label__.id = " << getIdString(uid, "_label") << ";" << std::endl;
1304     ostr << "__label__.className = 'GO_RADIO_LABEL';" << std::endl;
1305     ostr << "__label__.htmlFor = " << getIdString(uid, "_radio") << ";" << std::endl;
1306     //add item temporary in main div waiting __GO_PARENT__ update
1307     ostr << "__main__.appendChild(__label__);" << std::endl;
1308
1309     return true;
1310 }
1311
1312 bool WebUtils::createSlider(int uid, std::ostringstream& ostr)
1313 {
1314     //create a <input>
1315     createCommonIUControl(uid, "INPUT", "GO_SLIDER", ostr);
1316     ostr << "__temp__.type = 'range';" << std::endl;
1317     //add item temporary in main div waiting __GO_PARENT__ update
1318     ostr << "var __parent__ = document.getElementById('scilab');" << std::endl;
1319     ostr << "__parent__.appendChild(__temp__);" << std::endl;
1320
1321     return true;
1322 }
1323
1324 bool WebUtils::createListbox(int uid, std::ostringstream& ostr)
1325 {
1326     //create a <input>
1327     createCommonIUControl(uid, "SELECT", "GO_LISTBOX", ostr);
1328     //add item temporary in main div waiting __GO_PARENT__ update
1329     ostr << "var __parent__ = document.getElementById('scilab');" << std::endl;
1330     ostr << "__parent__.appendChild(__temp__);" << std::endl;
1331
1332     return true;
1333 }
1334
1335 bool WebUtils::createCombobox(int uid, std::ostringstream& ostr)
1336 {
1337     //create a <input>
1338     createCommonIUControl(uid, "SELECT", "GO_COMBOBOX", ostr);
1339     ostr << "__temp__.size = 1;" << std::endl;
1340     //add item temporary in main div waiting __GO_PARENT__ update
1341     ostr << "var __parent__ = document.getElementById('scilab');" << std::endl;
1342     ostr << "__parent__.appendChild(__temp__);" << std::endl;
1343
1344     return true;
1345 }
1346
1347 bool WebUtils::createSpinner(int uid, std::ostringstream& ostr)
1348 {
1349     //create a <input>
1350     createCommonIUControl(uid, "INPUT", "GO_SPINNER", ostr);
1351     ostr << "__temp__.type = 'number';" << std::endl;
1352     //add item temporary in main div waiting __GO_PARENT__ update
1353     ostr << "var __parent__ = document.getElementById('scilab');" << std::endl;
1354     ostr << "__parent__.appendChild(__temp__);" << std::endl;
1355
1356     return true;
1357 }
1358
1359 bool WebUtils::createTab(int uid, std::ostringstream& ostr)
1360 {
1361     //create a <input>
1362     createCommonIUControl(uid, "DIV", "GO_TAB", ostr);
1363
1364     //create a list
1365     ostr << "var __ul__ = " << createElement("UL") << std::endl;
1366     ostr << "__ul__.id = " << getIdString(uid, "_ul") << ";" << std::endl;
1367     ostr << "__temp__.appendChild(__ul__);" << std::endl;
1368
1369
1370     //add item temporary in main div waiting __GO_PARENT__ update
1371     ostr << "var __parent__ = document.getElementById('scilab');" << std::endl;
1372     ostr << "__parent__.appendChild(__temp__);" << std::endl;
1373
1374     return true;
1375 }
1376
1377 bool WebUtils::addTabChild(int uid, int child, std::ostringstream& ostr)
1378 {
1379     std::vector<std::string> vect;
1380
1381     //create il
1382     ostr << "var __li__ = " << createElement("LI") << std::endl;
1383     ostr << "__li__.id = " << getIdString(child, "_li") << ";" << std::endl;
1384
1385     //create input button
1386     ostr << "var __btn__ = " << createElement("INPUT") << std::endl;
1387     ostr << "__btn__.id = " << getIdString(child, "_btn") << ";" << std::endl;
1388     ostr << "__btn__.type = 'button';" << std::endl;
1389     ostr << "__btn__.addEventListener('click', onTab);" << std::endl;
1390
1391     //add button in il
1392     ostr << "__li__.appendChild(__btn__);" << std::endl;
1393
1394     //add il as first child in ul
1395     ostr << "var __ul__ = " << getElementById(uid, "_ul") << std::endl;
1396     ostr << "__ul__.insertBefore(__li__, __ul__.firstChild);" << std::endl;
1397
1398     //update child properties
1399     ostr << "__child__.style.position = 'inherit';" << std::endl;
1400     ostr << "__child__.style.left = 'inherit';" << std::endl;
1401     ostr << "__child__.style.bottom = 'inherit';" << std::endl;
1402     ostr << "__child__.style.width = '100%';" << std::endl;
1403     ostr << "__child__.style.height = '100%';" << std::endl;
1404
1405     //be carefull, we change __child__ to tab uid instead of frame uid
1406     setUIValue(uid, ostr);
1407     return true;
1408 }
1409
1410
1411 bool WebUtils::deleteObject(int uid, std::ostringstream& ostr)
1412 {
1413     ostr << "var __child__ = " << getElementById(uid) << std::endl;
1414     ostr << "__child__.parentNode.removeChild(__child__);" << std::endl;
1415
1416     return true;
1417 }
1418
1419 bool WebUtils::updateDefaultProperties(int uid, std::ostringstream& ostr)
1420 {
1421     //visible
1422     setVisible(uid, ostr);
1423
1424     //backgoundcolor
1425     setUIBackgroundColor(uid, ostr, true);
1426
1427     //enable
1428     setUIEnable(uid, ostr, true);
1429
1430     //fontangle
1431     setUIFontAngle(uid, ostr, true);
1432
1433     //fontname
1434     setUIFontName(uid, ostr, true);
1435
1436     //fontsize & fontunits
1437     setUIFontSize(uid, ostr, true);
1438
1439     //fontweight
1440     setUIFontWeight(uid, ostr, true);
1441
1442     //foregroundcolor
1443     setUIForegroundColor(uid, ostr, true);
1444
1445     //horizontalalignment
1446     setUIHorizontalAlignment(uid, ostr, true);
1447
1448     //relief ?
1449     setUIRelief(uid, ostr, true);
1450
1451     //string
1452     setUIString(uid, ostr, true);
1453
1454     //verticalalignment
1455     setUIVerticalAlignment(uid, ostr, true);
1456
1457     //position
1458     setUIPosition(uid, ostr, true);
1459
1460     //layout ?
1461     setUILayout(uid, ostr, true);
1462
1463     //min
1464     setUIMin(uid, ostr, true);
1465
1466     //max
1467     setUIMax(uid, ostr, true);
1468
1469     //step
1470     setUIStep(uid, ostr, true);
1471
1472     //vaue
1473     setUIValue(uid, ostr, true);
1474
1475     //set callback uses to update values from web view
1476     setCallback(uid, ostr, true);
1477
1478     return true;
1479 }
1480
1481 bool WebUtils::set(int prop, int uid, std::ostringstream& ostr, bool append)
1482 {
1483     SETTER::iterator it = setter.find(prop);
1484     if (it != setter.end())
1485     {
1486         it->second(uid, ostr, append);
1487
1488         return true;
1489     }
1490
1491     return false;
1492 }
1493
1494 void WebUtils::fillSetter()
1495 {
1496     setter[__GO_PARENT__] = WebUtils::setParent;
1497     setter[__GO_POSITION__] = WebUtils::setUIPosition;
1498     setter[__GO_SIZE__] = WebUtils::setFigureSize;
1499     setter[__GO_UI_STRING__] = WebUtils::setUIString;
1500     setter[__GO_VISIBLE__] = WebUtils::setVisible;
1501     setter[__GO_UI_ENABLE__] = WebUtils::setUIEnable;
1502     setter[__GO_UI_BACKGROUNDCOLOR__] = WebUtils::setUIBackgroundColor;
1503     setter[__GO_UI_FONTANGLE__] = WebUtils::setUIFontAngle;
1504     setter[__GO_UI_FONTNAME__] = WebUtils::setUIFontName;
1505     setter[__GO_UI_FONTSIZE__] = WebUtils::setUIFontSize;
1506     setter[__GO_UI_FONTWEIGHT__] = WebUtils::setUIFontWeight;
1507     setter[__GO_UI_FOREGROUNDCOLOR__] = WebUtils::setUIForegroundColor;
1508     setter[__GO_UI_HORIZONTALALIGNMENT__] = WebUtils::setUIHorizontalAlignment;
1509     setter[__GO_UI_RELIEF__] = WebUtils::setUIRelief;
1510     setter[__GO_UI_VERTICALALIGNMENT__] = WebUtils::setUIVerticalAlignment;
1511     setter[__GO_LAYOUT__] = WebUtils::setUILayout;
1512     setter[__GO_UI_MIN__] = WebUtils::setUIMin;
1513     setter[__GO_UI_MAX__] = WebUtils::setUIMax;
1514     setter[__GO_UI_SLIDERSTEP__] = WebUtils::setUIStep;
1515     setter[__GO_UI_VALUE__] = WebUtils::setUIValue;
1516     //preferred size is the last property to be set for border constraints
1517     setter[__GO_UI_BORDER_PREFERREDSIZE__] = WebUtils::setUIBorder;
1518     //preferred size is the last property to be set for gridbag constraints
1519     setter[__GO_UI_GRIDBAG_PREFERREDSIZE__] = WebUtils::setUIGridBag;
1520     //setter[__GO_CALLBACK__] = WebUtils::setCallback;
1521 }
1522
1523 bool WebUtils::updateValue(int uid, const std::string& value)
1524 {
1525     if (hasStyle(uid, __GO_UI_EDIT__))
1526     {
1527         std::vector<std::string> v(1, value);
1528         setStringVectorProperty(uid, __GO_UI_STRING__, v);
1529     }
1530
1531     return false;
1532 }
1533
1534 bool WebUtils::updateValue(int uid, const std::vector<double>& values)
1535 {
1536     setDoubleVectorProperty(uid, __GO_UI_VALUE__, values);
1537     return false;
1538 }
1539
1540 bool WebUtils::updateValue(int uid, double value)
1541 {
1542     std::vector<double> v(1, value);
1543     setDoubleVectorProperty(uid, __GO_UI_VALUE__, v);
1544     return false;
1545 }
1546
1547 bool WebUtils::updateValue(int uid, bool value)
1548 {
1549     std::vector<double> v(1, value ? getUIMax(uid) : getUIMin(uid));
1550     setDoubleVectorProperty(uid, __GO_UI_VALUE__, v);
1551     return false;
1552 }
1553
1554 void WebUtils::addInWaitingQueue(int uid, int prop)
1555 {
1556     std::cerr << "add in queue : " << uid << "(" << prop << ")" << std::endl;
1557     waitprop[uid].push_back(prop);
1558 }
1559
1560 void WebUtils::setWaitingProperties(int uid, std::ostringstream& ostr, bool append)
1561 {
1562     WAITING_PROP::iterator it = waitprop.find(uid);
1563     if (it != waitprop.end())
1564     {
1565         for (int prop : it->second)
1566         {
1567             set(prop, uid, ostr, append);
1568         }
1569         waitprop.erase(it);
1570     }
1571 }