add update from web page, callback and some properties 14/17814/1
Antoine ELIAS [Tue, 23 Feb 2016 15:42:36 +0000 (16:42 +0100)]
Change-Id: I6ff070e22d15a9b16f09f2468d9925113af4353f

scilab/modules/core/src/cpp/InitScilab.cpp
scilab/modules/graphic_objects/src/cpp/ScilabWebView.cpp
scilab/modules/graphic_objects/src/cpp/webutils.cpp
scilab/modules/graphic_objects/src/cpp/webutils.hxx
scilab/node/html/index.html
scilab/node/loader.sce [new file with mode: 0644]
scilab/node/scilab_process.js
scilab/node/scilab_server.js

index 06be550..7d36019 100644 (file)
@@ -238,7 +238,7 @@ int StartScilabEngine(ScilabEngineInfo* _pSEI)
 
     if (_pSEI->iNoJvm == 0) // With JVM
     {
-        InitializeTclTk();
+        //InitializeTclTk();
         InitializeJVM();
         InitializeGUI();
 
index e139f1f..8605c6c 100644 (file)
@@ -88,12 +88,64 @@ void ScilabWebView::registerToController(void)
 
     s->on("callback", sio::socket::event_listener_aux([&](std::string const& name, sio::message::ptr const& data, bool isAck, sio::message::list &ack_resp){
         l.lock.lock();
-        int uid = data->get_map()["uid"]->get_int();
+        int uid = (int)data->get_map()["uid"]->get_int();
+
+        switch (WebUtils::getStyle(uid))
+        {
+            case __GO_UI_PUSHBUTTON__:
+                //nothing to update, exec callback only
+                break;
+            case __GO_UI_CHECKBOX__:
+            case __GO_UI_RADIOBUTTON__:
+            {
+                //get checked status
+                bool status = data->get_map()["value"]->get_bool();
+                WebUtils::updateValue(uid, status);
+                break;
+            }
+            case __GO_UI_POPUPMENU__:
+            case __GO_UI_LISTBOX__:
+            {
+                std::vector<double> d;
+                std::vector<sio::message::ptr> v = data->get_map()["value"]->get_vector();
+                for (auto it : v)
+                {
+                    d.push_back(it->get_double() + 1); //1 indexed
+                }
+
+                WebUtils::updateValue(uid, d);
+                break;
+            }
+                break;
+            case __GO_UI_EDIT__:
+            {
+                std::string value = (std::string)data->get_map()["value"]->get_string();
+                WebUtils::updateValue(uid, value);
+                break;
+            }
+            case __GO_UI_SLIDER__:
+            case __GO_UI_SPINNER__:
+            {
+                double value = (double)data->get_map()["value"]->get_double();
+                WebUtils::updateValue(uid, value);
+                break;
+            }
+        }
+
+        l.cond.notify_all();
+        l.lock.unlock();
+
         //get calltype type and callback instruction from MVC
         int cbtype = WebUtils::getIntProperty(uid, __GO_CALLBACKTYPE__);
         std::string cb = WebUtils::getStringProperty(uid, __GO_CALLBACK__);
 
-        std::string str = "if exists(\"gcbo\") then %oldgcbo = gcbo; end;";
+        if (cbtype == -1)
+        {
+            return;
+        }
+
+        std::string str;
+        str = "if exists(\"gcbo\") then %oldgcbo = gcbo; end;";
         str += "gcbo = getcallbackobject(" + std::to_string(uid) + ");";
         str += cb;
         str += ";if exists(\"%oldgcbo\") then gcbo = %oldgcbo; else clear gcbo; end;";
@@ -106,14 +158,18 @@ void ScilabWebView::registerToController(void)
         {
             StoreCommand((char*)str.data());
         }
-        l.cond.notify_all();
-        l.lock.unlock();
     }));
+
+    WebUtils::fillSetter();
 }
 
 void ScilabWebView::unregisterToController(void)
 {
     org_scilab_modules_graphic_objects::CallGraphicController::unregisterScilabWebView(getScilabJavaVM());
+
+    client.sync_close();
+    client.clear_con_listeners();
+
 }
 
 
@@ -128,7 +184,6 @@ void ScilabWebView::createObject(int uid)
     {
         std::string str;
         WebUtils::createFigure(uid, str);
-        std::cout << "createFigure" << str << std::endl;
         s->emit("graphic_create", str);
         return;
     }
@@ -137,6 +192,7 @@ void ScilabWebView::createObject(int uid)
     {
         std::string str;
         WebUtils::createUIControl(uid, str);
+        WebUtils::updateDefaultProperties(uid, str);
         s->emit("graphic_create", str);
         return;
     }
@@ -144,16 +200,14 @@ void ScilabWebView::createObject(int uid)
 
 void ScilabWebView::deleteObject(int uid)
 {
-    //if (WebUtils::isManaged(uid) == false)
-    //{
-    //    return;
-    //}
-
-    //sio::message::ptr obj = sio::object_message::create();
-    //auto& m = obj->get_map();
+    if (WebUtils::isManaged(uid) == false)
+    {
+        return;
+    }
 
-    //m["uid"] = sio::int_message::create(uid);
-    //s->emit("graphic_delete", obj);
+    std::string str;
+    WebUtils::deleteObject(uid, str);
+    s->emit("graphic_delete", str);
 }
 
 void ScilabWebView::updateObject(int uid, int prop)
@@ -163,6 +217,14 @@ void ScilabWebView::updateObject(int uid, int prop)
         return;
     }
 
+    if (prop == __GO_VISIBLE__)
+    {
+        std::string str;
+        WebUtils::setVisible(uid, str);
+        s->emit("graphic_update", str);
+        return;
+    }
+
     if (WebUtils::isFigure(uid))
     {
         switch (prop)
@@ -179,29 +241,12 @@ void ScilabWebView::updateObject(int uid, int prop)
 
     if (WebUtils::isUIcontrol(uid))
     {
-        switch (prop)
+        std::string str;
+        if (WebUtils::set(prop, uid, str))
         {
-            case __GO_PARENT__:
-            {
-                std::string str;
-                WebUtils::setParent(uid, str);
-                s->emit("graphic_update", str);
-                return;
-            }
-            case __GO_POSITION__:
-            {
-                std::string str;
-                WebUtils::setUIPosition(uid, str);
-                s->emit("graphic_update", str);
-                return;
-            }
-            case __GO_UI_STRING__:
-            {
-                std::string str;
-                WebUtils::setUIString(uid, str);
-                s->emit("graphic_update", str);
-                return;
-            }
+            s->emit("graphic_update", str);
         }
+
+        return;
     }
 }
index acfab15..b9c6be9 100644 (file)
 *
 */
 
+#include <iostream>
 #include "webutils.hxx"
 
 extern "C"
 {
+#include "setGraphicObjectProperty.h"
 #include "getGraphicObjectProperty.h"
 #include "graphicObjectProperties.h"
 }
 
+std::unordered_map<int, setFunction> WebUtils::setter;
+
 int WebUtils::getIntProperty(int uid, int prop)
 {
     int val = 0;
@@ -29,6 +33,14 @@ int WebUtils::getIntProperty(int uid, int prop)
     return val;
 }
 
+bool WebUtils::getBoolProperty(int uid, int prop)
+{
+    int val = 0;
+    int* pVal = &val;
+    getGraphicObjectProperty(uid, prop, jni_bool, (void **)&pVal);
+    return val != 0;
+}
+
 double WebUtils::getDoubleProperty(int uid, int prop)
 {
     double val = 0;
@@ -81,14 +93,39 @@ void WebUtils::getStringVectorProperty(int uid, int prop, std::vector<std::strin
     releaseGraphicObjectProperty(prop, pstString, jni_string_vector, size);
 }
 
-std::string WebUtils::getIdString(int uid)
+bool WebUtils::setStringProperty(int uid, int prop, const std::string& value)
+{
+    setGraphicObjectProperty(uid, prop, value.data(), jni_string, 1);
+    return true;
+}
+
+bool WebUtils::setStringVectorProperty(int uid, int prop, const std::vector<std::string>& values)
+{
+    int size = (int)values.size();
+    std::vector<const char*> c(size, NULL);
+    for (int i = 0; i < size; ++i)
+    {
+        c[i] = values[i].data();
+    }
+
+    setGraphicObjectProperty(uid, prop, (void**)c.data(), jni_string_vector, size);
+    return true;
+}
+
+bool WebUtils::setDoubleVectorProperty(int uid, int prop, const std::vector<double>& values)
 {
-    return "'uid" + std::to_string(uid) + "'";
+    setGraphicObjectProperty(uid, prop, values.data(), jni_double_vector, (int)values.size());
+    return true;
 }
 
-std::string WebUtils::getElementById(int uid)
+std::string WebUtils::getIdString(int uid, const std::string& suffix)
 {
-    return "document.getElementById(" + getIdString(uid) + ");";
+    return "'uid" + std::to_string(uid) + suffix + "'";
+}
+
+std::string WebUtils::getElementById(int uid, const std::string& suffix)
+{
+    return "document.getElementById(" + getIdString(uid, suffix) + ");";
 }
 
 std::string WebUtils::createElement(const std::string& type)
@@ -96,27 +133,35 @@ std::string WebUtils::createElement(const std::string& type)
     return "document.createElement('" + type + "');";
 }
 
+std::string WebUtils::getColor(const std::vector<double>& c)
+{
+    if (c[0] == -1)
+    {
+        return "''";
+    }
+
+    std::string str("'rgb(");
+
+    //use abs to convert [-1 -1 -1 ] to (255, 255, 255)
+    str += std::to_string((int)std::abs(c[0] * 255));
+    for (int i = 1; i < c.size(); ++i)
+    {
+        str += ", " + std::to_string((int)std::abs(c[i] * 255));
+    }
+
+    str += ")'";
+
+    return str;
+}
+
 bool WebUtils::isManaged(int uid)
 {
     int type = getType(uid);
     switch (type)
     {
         case __GO_FIGURE__:
-            return true;
         case __GO_UICONTROL__:
-        {
-            int style = getStyle(uid);
-            switch (style)
-            {
-                case __GO_UI_PUSHBUTTON__:
-                {
-                    return true;
-                }
-                default:
-                    return false;
-            }
-            break;
-        }
+            return true;
         default:
             return false;
     }
@@ -138,30 +183,50 @@ int WebUtils::getParent(int uid)
     return getIntProperty(uid, __GO_PARENT__);
 }
 
-void WebUtils::setParent(int uid, std::string& str)
+void WebUtils::setParent(int uid, std::string& str, bool append)
 {
     int parent = getParent(uid);
-    str = "__parent__ = " + getElementById(parent);
-    str += "__child__ = " + getElementById(uid);
+
+    if (append == false)
+    {
+        str = "var __child__ = " + getElementById(uid);
+    }
+
+    str += "var __parent__ = " + getElementById(parent);
     str += "__parent__.appendChild(__child__);";
 }
 
 void WebUtils::getFigureSize(int uid, std::vector<int>& vect)
 {
+    int fig = getFigureId(uid);
     vect.resize(2, 0);
-    getIntVectorProterty(uid, __GO_SIZE__, vect);
+    getIntVectorProterty(fig, __GO_AXES_SIZE__, vect);
 }
 
-void WebUtils::setFigureSize(int uid, std::string& str)
+void WebUtils::setFigureSize(int uid, std::string& str, bool append)
 {
     std::vector<int> size;
     getFigureSize(uid, size);
 
-    str = "__child__ = " + getElementById(uid);
+    if (append == false)
+    {
+        str = "var __child__ = " + getElementById(uid);
+    }
     str += "__child__.style.width = '" + std::to_string(size[0]) + "px';";
     str += "__child__.style.height = '" + std::to_string(size[1]) + "px';";
 }
 
+int WebUtils::getFigureId(int uid)
+{
+    int id = uid;
+    while (isFigure(id) == false)
+    {
+        id = getParent(id);
+    }
+
+    return id;
+}
+
 void WebUtils::getUIPosition(int uid, std::vector<double>& vect)
 {
     vect.resize(4, 0.);
@@ -177,30 +242,476 @@ void WebUtils::getUIString(int uid, std::vector<std::string> & vect)
 }
 
 
-void WebUtils::setUIPosition(int uid, std::string& str)
+void WebUtils::setUIPosition(int uid, std::string& str, bool append)
 {
-    std::vector<int> size;
-    getFigureSize(getParent(uid), size);
     std::vector<double> pos;
     getUIPosition(uid, pos);
 
-    str = "__child__ = " + getElementById(uid);
+    if (append == false)
+    {
+        str = "var __child__ = " + getElementById(uid);
+    }
     str += "__child__.style.left = '" + std::to_string((int)pos[0]) + "px';";
-    str += "__child__.style.top = '" + std::to_string(size[1] - (int)pos[1] - (int)pos[3]) + "px';";
+    str += "__child__.style.bottom = '" + std::to_string((int)pos[1]) + "px';";
     str += "__child__.style.width = '" + std::to_string((int)pos[2]) + "px';";
     str += "__child__.style.height = '" + std::to_string((int)pos[3]) + "px';";
+
+    //to ensure vertical alignement, adapt style.line-height
+    if (hasStyle(uid, __GO_UI_TEXT__) || hasStyle(uid, __GO_UI_CHECKBOX__) || hasStyle(uid, __GO_UI_RADIOBUTTON__))
+    {
+        std::string v;
+        getUIVerticalAlignment(uid, v);
+        if (v == "middle")
+        {
+            str += "__child__.style.lineHeight = '" + std::to_string((int)pos[3]) + "px';";
+        }
+        else
+        {
+            str += "__child__.style.lineHeight = 'initial';";
+        }
+    }
 }
 
-void WebUtils::setUIString(int uid, std::string& str)
+void WebUtils::setUIString(int uid, std::string& str, bool append)
 {
     std::vector<std::string> s;
     getUIString(uid, s);
+    if (s.size() == 0)
+    {
+        s.push_back("");
+    }
+
+    if (hasStyle(uid, __GO_UI_CHECKBOX__) || hasStyle(uid, __GO_UI_RADIOBUTTON__))
+    {
+        if (append == false)
+        {
+            str == "";
+        }
+
+        str += "var __label__ = " + getElementById(uid, "_label");
+        str += "__label__.innerHTML = '" + s[0] + "';";
+    }
+    else if (hasStyle(uid, __GO_UI_POPUPMENU__) || hasStyle(uid, __GO_UI_LISTBOX__))
+    {
+        if (append == false)
+        {
+            str = "var __child__ = " + getElementById(uid);
+        }
+        //remove previous values
+        str += "while (__child__.length) {__child__.remove(0);}";
+
+        str += "var option;";
+        int size = (int)s.size();
+        for (int i = 0; i < size; ++i)
+        {
+            str += "option = new Option('" + s[i] + "');";
+            str += "__child__.add(option);";
+        }
+
+        if (hasStyle(uid, __GO_UI_LISTBOX__))
+        {
+            //switch to listbox instead of combobox
+            str += "__child__.size = 2;";
+        }
+    }
+    else
+    {
+        if (append == false)
+        {
+            str = "var __child__ = " + getElementById(uid);
+        }
+
+        if (isInputType(uid))
+        {
+            str += "__child__.value = '" + s[0] + "';";
+        }
+        else
+        {
+            str += "__child__.innerHTML = '" + s[0] + "';";
+        }
+    }
+}
+
+bool WebUtils::getVisible(int uid)
+{
+    return getBoolProperty(uid, __GO_VISIBLE__);
+}
+
+void WebUtils::setVisible(int uid, std::string& str, bool append)
+{
+    //reverse flag value
+    std::string v = getVisible(uid) ? "inherit" : "hidden";
+    if (append == false)
+    {
+        str = "var __child__ = " + getElementById(uid);
+    }
+
+    str += "__child__.style.visibility  = '" + v + "';";
+}
+
+bool WebUtils::getUIEnable(int uid)
+{
+    return getBoolProperty(uid, __GO_UI_ENABLE__);
+}
+
+void WebUtils::setUIEnable(int uid, std::string& str, bool append)
+{
+    //reverse flag value
+    std::string v = getUIEnable(uid) ? "false" : "true";
+    if (append == false)
+    {
+        str = "var __child__ = " + getElementById(uid);
+    }
+
+    str += "__child__.disabled  = " + v + ";";
+}
+
+bool WebUtils::getUIBackgroundColor(int uid, std::vector<double>& vect)
+{
+    vect.resize(3, 0.);
+    getDoubleVectorProterty(uid, __GO_UI_BACKGROUNDCOLOR__, vect);
+    return true;
+}
+
+void WebUtils::setUIBackgroundColor(int uid, std::string& str, bool append)
+{
+    std::vector<double> c;
+    getUIBackgroundColor(uid, c);
+    if (append == false)
+    {
+        str = "var __child__ = " + getElementById(uid);
+    }
+
+    str += "__child__.style.backgroundColor  = " + getColor(c) + ";";
+}
+
+bool WebUtils::getUIFontAngle(int uid, std::string& str)
+{
+    str = getStringProperty(uid, __GO_UI_FONTANGLE__);
+    return true;
+}
+
+void WebUtils::setUIFontAngle(int uid, std::string& str, bool append)
+{
+    std::string angle;
+    getUIFontAngle(uid, angle);
+    if (append == false)
+    {
+        str = "var __child__ = " + getElementById(uid);
+    }
+
+    str += "__child__.style.fontStyle  = '" + angle + "';";
+}
+
+bool WebUtils::getUIFontName(int uid, std::string& str)
+{
+    str = getStringProperty(uid, __GO_UI_FONTNAME__);
+    return true;
+}
+
+void WebUtils::setUIFontName(int uid, std::string& str, bool append)
+{
+    std::string font;
+    getUIFontName(uid, font);
+    if (append == false)
+    {
+        str = "var __child__ = " + getElementById(uid);
+    }
+
+    str += "__child__.style.fontFamily  = '" + font + "','serif' ;";
+}
+
+bool WebUtils::getUIFontUnits(int uid, std::string& str)
+{
+    str = getStringProperty(uid, __GO_UI_FONTUNITS__);
+    return true;
+}
+
+double WebUtils::getUIFontSize(int uid)
+{
+    return getDoubleProperty(uid, __GO_UI_FONTSIZE__);
+}
+
+void WebUtils::setUIFontSize(int uid, std::string& str, bool append)
+{
+    int size = (int)getUIFontSize(uid);
+
+    std::string units;
+    getUIFontUnits(uid, units);
+
+    if (units == "pixels")
+    {
+        units = "px";
+    }
+    else //"points"
+    {
+        units = "pt";
+        size = (int)(size * 0.75);
+    }
+
+    if (append == false)
+    {
+        str = "var __child__ = " + getElementById(uid);
+    }
+
+    str += "__child__.style.fontSize  = '" + std::to_string(size) + units + "';";
+}
+
+bool WebUtils::getUIFontWeight(int uid, std::string& str)
+{
+    str = getStringProperty(uid, __GO_UI_FONTWEIGHT__);
+    return true;
+}
+
+void WebUtils::setUIFontWeight(int uid, std::string& str, bool append)
+{
+    std::string weight;
+    getUIFontWeight(uid, weight);
+
+    if (append == false)
+    {
+        str = "var __child__ = " + getElementById(uid);
+    }
+
+    str += "__child__.style.fontWeight  = '" + weight + "';";
+}
+
+bool WebUtils::getUIForegroundColor(int uid, std::vector<double>& vect)
+{
+    vect.resize(3, 0.);
+    getDoubleVectorProterty(uid, __GO_UI_FOREGROUNDCOLOR__, vect);
+    return true;
+}
+
+void WebUtils::setUIForegroundColor(int uid, std::string& str, bool append)
+{
+    std::vector<double> c;
+    getUIForegroundColor(uid, c);
+
+    if (append == false)
+    {
+        str = "var __child__ = " + getElementById(uid);
+    }
+
+    str += "__child__.style.color  = " + getColor(c) + ";";
+}
+
+bool WebUtils::getUIHorizontalAlignment(int uid, std::string& str)
+{
+    str = getStringProperty(uid, __GO_UI_HORIZONTALALIGNMENT__);
+    return true;
+}
+
+void WebUtils::setUIHorizontalAlignment(int uid, std::string& str, bool append)
+{
+    std::string align;
+    getUIHorizontalAlignment(uid, align);
+
+    if (append == false)
+    {
+        str = "var __child__ = " + getElementById(uid);
+    }
+
+    str += "__child__.style.textAlign  = '" + align + "';";
+}
+
+bool WebUtils::getUIRelief(int uid, std::string& str)
+{
+    str = getStringProperty(uid, __GO_UI_RELIEF__);
+    return true;
+}
+
+void WebUtils::setUIRelief(int uid, std::string& str, bool append)
+{
+}
 
-    str = "__child__ = " + getElementById(uid);
-    str += "__child__.innerHTML = '" + s[0] + "';";
+bool WebUtils::getUIVerticalAlignment(int uid, std::string& str)
+{
+    str = getStringProperty(uid, __GO_UI_VERTICALALIGNMENT__);
+    return true;
+}
+
+void WebUtils::setUIVerticalAlignment(int uid, std::string& str, bool append)
+{
+}
+
+int WebUtils::getUILayout(int uid)
+{
+    return getIntProperty(uid, __GO_LAYOUT__);
+    return true;
+}
+
+void WebUtils::setUILayout(int uid, std::string& str, bool append)
+{
+}
+
+double WebUtils::getUIMin(int uid)
+{
+    return getDoubleProperty(uid, __GO_UI_MIN__);
+}
+
+void WebUtils::setUIMin(int uid, std::string& str, bool append)
+{
+    if (hasStyle(uid, __GO_UI_SPINNER__) || hasStyle(uid, __GO_UI_SLIDER__))
+    {
+        double min = getUIMin(uid);
+
+        if (append == false)
+        {
+            str = "var __child__ = " + getElementById(uid);
+        }
+
+        str += "__child__.min  = '" + std::to_string(min) + "';";
+    }
+}
+
+double WebUtils::getUIMax(int uid)
+{
+    return getDoubleProperty(uid, __GO_UI_MAX__);
+}
+
+void WebUtils::setUIMax(int uid, std::string& str, bool append)
+{
+    if (hasStyle(uid, __GO_UI_SPINNER__) || hasStyle(uid, __GO_UI_SLIDER__))
+    {
+        double max = getUIMax(uid);
+
+        if (append == false)
+        {
+            str = "var __child__ = " + getElementById(uid);
+        }
+
+        str += "__child__.max  = '" + std::to_string(max) + "';";
+    }
+}
+
+double WebUtils::getUIStep(int uid)
+{
+    std::vector<double> step(2, 0.);
+    getDoubleVectorProterty(uid, __GO_UI_SLIDERSTEP__, step);
+    return step[0];
+}
+
+void WebUtils::setUIStep(int uid, std::string& str, bool append)
+{
+    if (hasStyle(uid, __GO_UI_SPINNER__) || hasStyle(uid, __GO_UI_SLIDER__))
+    {
+        double step = getUIStep(uid);
+
+        if (append == false)
+        {
+            str = "var __child__ = " + getElementById(uid);
+        }
+
+        str += "__child__.step  = '" + std::to_string(step) + "';";
+    }
+}
+
+bool WebUtils::getUIValue(int uid, std::vector<double>& vect)
+{
+    int size = getIntProperty(uid, __GO_UI_VALUE_SIZE__);
+    vect.resize(size, 0.);
+    getDoubleVectorProterty(uid, __GO_UI_VALUE__, vect);
+    return true;
+}
+
+void WebUtils::setUIValue(int uid, std::string& str, bool append)
+{
+    if (hasStyle(uid, __GO_UI_SPINNER__) || hasStyle(uid, __GO_UI_SLIDER__))
+    {
+        std::vector<double> values;
+        getUIValue(uid, values);
+        if (values.size() == 0)
+        {
+            values.push_back(0);
+        }
+
+        if (append == false)
+        {
+            str = "var __child__ = " + getElementById(uid);
+        }
+
+        str += "__child__.value  = '" + std::to_string(values[0]) + "';";
+    }
+}
+
+bool WebUtils::hasCallback(int uid)
+{
+    return getStringProperty(uid, __GO_CALLBACK__) != "";
+}
+
+void WebUtils::setCallback(int uid, std::string& str, bool append)
+{
+    if (append == false)
+    {
+        str = "var __child__ = " + getElementById(uid);
+    }
+
+    std::string event;
+    std::string func;
+    switch (getStyle(uid))
+    {
+        case __GO_UI_PUSHBUTTON__ :
+            event = "click";
+            func = "onPushButton";
+            break;
+        case __GO_UI_CHECKBOX__:
+            event = "click";
+            func = "onCheckBox";
+            break;
+        case __GO_UI_RADIOBUTTON__:
+            event = "click";
+            func = "onRadioButton";
+            break;
+        case __GO_UI_LISTBOX__:
+            event = "change";
+            func = "onListBox";
+            break;
+        case __GO_UI_POPUPMENU__:
+            event = "change";
+            func = "onComboBox";
+            break;
+/*
+        case __GO_UI_TAB__:
+            event = "click";
+            func = "onPushButton";
+            break;
+*/
+        case __GO_UI_SLIDER__:
+            event = "input";
+            func = "onSlider";
+            break;
+        case __GO_UI_EDIT__:
+            event = "input";
+            func = "onEditBox";
+            break;
+        case __GO_UI_SPINNER__:
+            event = "input";
+            func = "onSpinner";
+            break;
+        default :
+            return;
+    }
+
+    //add callback listener
+    str += "__child__.addEventListener('" + event + "', " + func + ");";
 }
 
 //is
+bool WebUtils::isInputType(int uid)
+{
+    switch (getStyle(uid))
+    {
+        case __GO_UI_EDIT__ : 
+        case __GO_UI_SLIDER__:
+        case __GO_UI_SPINNER__ :
+            return true;
+        default : 
+            return false;
+    }
+}
+
 bool WebUtils::hasStyle(int uid, int style)
 {
     if (isUIcontrol(uid))
@@ -230,12 +741,14 @@ bool WebUtils::isButton(int uid)
 //create
 bool WebUtils::createFigure(int uid, std::string& str)
 {
-    //for the moment figure is a div hardcoded in html page ( .GO_FIGURE )
-    //this function just set figure uid to help children to find it
-    str = "var __temp__ = " + createElement("DIV");
+    //set figure uid to help children to find it
+    str = "var __parent__ = document.getElementById('scilab');";
+    str += "var __temp__ = " + createElement("DIV");
     str += "__temp__.id = " + getIdString(uid) + ";";
     str += "__temp__.className = 'GO_FIGURE';";
-    str += "document.body.appendChild(__temp__);";
+    str += "__parent__.innerHTML += '<br>';";
+    str += "__parent__.appendChild(__temp__);";
+    str += "__parent__.innerHTML += '<br>';";
     return true;
 }
 
@@ -244,24 +757,356 @@ bool WebUtils::createUIControl(int uid, std::string& str)
     int style = getStyle(uid);
     switch (style)
     {
+        case __GO_UI_FRAME__:
+            return createFrame(uid, str);
         case __GO_UI_PUSHBUTTON__:
-        {
             return createPushButton(uid, str);
-        }
-        default :
+        case __GO_UI_TEXT__:
+            return createText(uid, str);
+        case __GO_UI_EDIT__:
+            return createEdit(uid, str);
+        case __GO_UI_CHECKBOX__:
+            return createCheckbox(uid, str);
+        case __GO_UI_RADIOBUTTON__:
+            return createRadio(uid, str);
+        case __GO_UI_SLIDER__:
+            return createSlider(uid, str);
+        case __GO_UI_LISTBOX__:
+            return createListbox(uid, str);
+        case __GO_UI_POPUPMENU__:
+            return createCombobox(uid, str);
+        case __GO_UI_SPINNER__:
+            return createSpinner(uid, str);
+        default:
             return false;
     }
 }
 
-bool WebUtils::createPushButton(int uid, std::string& str)
+bool WebUtils::createCommonIUControl(int uid, const std::string& htmlType, const std::string& cssClass, std::string& str)
 {
     //create a button, with no parent, wait update with _GO_PARENT to update it
-    str += "var __temp__ = " + createElement("BUTTON");
+    str = "var __temp__ = " + createElement(htmlType);
     str += "__temp__.id = " + getIdString(uid) + ";";
-    str += "__temp__.className = 'GO_PUSHBUTTON';";
-    str += "document.body.appendChild(__temp__);";
-    str += "__temp__.onclick = function (){OnUIClick(this)};";
+    str += "__temp__.className = '" + cssClass + "';";
+
+    return true;
+}
 
+bool WebUtils::createPushButton(int uid, std::string& str)
+{
+    //create a <button>
+    createCommonIUControl(uid, "BUTTON", "GO_PUSHBUTTON", str);
+    //add item temporary in main scilabview div waiting __GO_PARENT__ update
+    str += "var __parent__ = document.getElementById('scilab');";
+    str += "__parent__.appendChild(__temp__);";
+
+    return true;
+}
+
+bool WebUtils::createFrame(int uid, std::string& str)
+{
+    //create a <div>
+    createCommonIUControl(uid, "DIV", "GO_FRAME", str);
+    //add item temporary in main div waiting __GO_PARENT__ update
+    str += "var __parent__ = document.getElementById('scilab');";
+    str += "__parent__.appendChild(__temp__);";
 
     return true;
 }
+
+bool WebUtils::createText(int uid, std::string& str)
+{
+    //create a <div>
+    createCommonIUControl(uid, "LABEL", "GO_TEXT", str);
+    //add item temporary in main div waiting __GO_PARENT__ update
+    str += "var __parent__ = document.getElementById('scilab');";
+    str += "__parent__.appendChild(__temp__);";
+
+    return true;
+}
+
+bool WebUtils::createEdit(int uid, std::string& str)
+{
+    //create a <input>
+    createCommonIUControl(uid, "INPUT", "GO_EDIT", str);
+    str += "__temp__.type = 'text';";
+    //add item temporary in main div waiting __GO_PARENT__ update
+    str += "var __parent__ = document.getElementById('scilab');";
+    str += "__parent__.appendChild(__temp__);";
+
+    return true;
+}
+
+bool WebUtils::createCheckbox(int uid, std::string& str)
+{
+    //create a <input>
+
+    //for checkbox we need to create 3 elements.
+
+    //a div to enclose others
+    str = "var __main__ = " + createElement("DIV");
+    str += "__main__.id = " + getIdString(uid) + ";";
+    str += "__main__.className = 'GO_CHECKBOX';";
+    //add item temporary in main div waiting __GO_PARENT__ update
+    str += "var __parent__ = document.getElementById('scilab');";
+    str += "__parent__.appendChild(__main__);";
+
+    //the checkbox itself
+    str += "var __temp__ = " + createElement("INPUT");
+    str += "__temp__.className = 'GO_CHECKBOX_CHECKBOX';";
+    str += "__temp__.type = 'checkbox';";
+    str += "__temp__.id = " + getIdString(uid, "_checkbox") + ";";
+    //add item temporary in main div waiting __GO_PARENT__ update
+    str += "__main__.appendChild(__temp__);";
+
+    //the label of the checkbox
+    str += "var __label__ = " + createElement("LABEL");
+    str += "__label__.id = " + getIdString(uid, "_label") + ";";
+    str += "__label__.className = 'GO_CHECKBOX_LABEL';";
+    str += "__label__.htmlFor = " + getIdString(uid, "_checkbox") + ";";
+    //add item temporary in main div waiting __GO_PARENT__ update
+    str += "__main__.appendChild(__label__);";
+
+    return true;
+}
+
+bool WebUtils::createRadio(int uid, std::string& str)
+{
+    //create a <input>
+
+    //for radio we need to create 3 elements.
+
+    //a div to enclose others
+    str = "var __main__ = " + createElement("DIV");
+    str += "__main__.id = " + getIdString(uid) + ";";
+    str += "__main__.className = 'GO_RADIO';";
+    //add item temporary in main div waiting __GO_PARENT__ update
+    str += "var __parent__ = document.getElementById('scilab');";
+    str += "__parent__.appendChild(__main__);";
+
+    //the radio itself
+    str += "var __temp__ = " + createElement("INPUT");
+    str += "__temp__.className = 'GO_RADIO_RADIO';";
+    str += "__temp__.type = 'radio';";
+    str += "__temp__.id = " + getIdString(uid, "_radio") + ";";
+    //add item temporary in main div waiting __GO_PARENT__ update
+    str += "__main__.appendChild(__temp__);";
+
+    //the label of the checkbox
+    str += "var __label__ = " + createElement("LABEL");
+    str += "__label__.id = " + getIdString(uid, "_label") + ";";
+    str += "__label__.className = 'GO_RADIO_LABEL';";
+    str += "__label__.htmlFor = " + getIdString(uid, "_radio") + ";";
+    //add item temporary in main div waiting __GO_PARENT__ update
+    str += "__main__.appendChild(__label__);";
+
+    return true;
+}
+
+bool WebUtils::createSlider(int uid, std::string& str)
+{
+    //create a <input>
+    createCommonIUControl(uid, "INPUT", "GO_SLIDER", str);
+    str += "__temp__.type = 'range';";
+    //add item temporary in main div waiting __GO_PARENT__ update
+    str += "var __parent__ = document.getElementById('scilab');";
+    str += "__parent__.appendChild(__temp__);";
+
+    return true;
+}
+
+bool WebUtils::createListbox(int uid, std::string& str)
+{
+    //create a <input>
+    createCommonIUControl(uid, "SELECT", "GO_LISTBOX", str);
+    //add item temporary in main div waiting __GO_PARENT__ update
+    str += "var __parent__ = document.getElementById('scilab');";
+    str += "__parent__.appendChild(__temp__);";
+
+    return true;
+}
+
+bool WebUtils::createCombobox(int uid, std::string& str)
+{
+    //create a <input>
+    createCommonIUControl(uid, "SELECT", "GO_COMBOBOX", str);
+    str += "__temp__.size = 1;";
+    //add item temporary in main div waiting __GO_PARENT__ update
+    str += "var __parent__ = document.getElementById('scilab');";
+    str += "__parent__.appendChild(__temp__);";
+
+    return true;
+}
+
+bool WebUtils::createSpinner(int uid, std::string& str)
+{
+    //create a <input>
+    createCommonIUControl(uid, "INPUT", "GO_SPINNER", str);
+    str += "__temp__.type = 'number';";
+    //add item temporary in main div waiting __GO_PARENT__ update
+    str += "var __parent__ = document.getElementById('scilab');";
+    str += "__parent__.appendChild(__temp__);";
+
+    return true;
+}
+
+bool WebUtils::deleteObject(int uid, std::string& str)
+{
+    str = "var __child__ = " + getElementById(uid);
+    str += "__child__.parentNode.removeChild(__child__);";
+
+    return true;
+}
+
+bool WebUtils::updateDefaultProperties(int uid, std::string& update)
+{
+    std::string str;
+
+    //visible
+    setVisible(uid, str);
+    update += str;
+
+    //backgoundcolor
+    setUIBackgroundColor(uid, str);
+    update += str;
+
+    //enable
+    setUIEnable(uid, str);
+    update += str;
+
+    //fontangle
+    setUIFontAngle(uid, str);
+    update += str;
+
+    //fontname
+    setUIFontName(uid, str);
+    update += str;
+
+    //fontsize & fontunits
+    setUIFontSize(uid, str);
+    update += str;
+
+    //fontweight
+    setUIFontWeight(uid, str);
+    update += str;
+
+    //foregroundcolor
+    setUIForegroundColor(uid, str);
+    update += str;
+
+    //horizontalalignment
+    setUIHorizontalAlignment(uid, str);
+    update += str;
+
+    //relief ?
+    setUIRelief(uid, str);
+    update += str;
+
+    //string
+    setUIString(uid, str);
+    update += str;
+
+    //verticalalignment
+    setUIVerticalAlignment(uid, str);
+    update += str;
+
+    //position
+    setUIPosition(uid, str);
+    update += str;
+
+    //layout ?
+    setUILayout(uid, str);
+    update += str;
+
+    //min
+    setUIMin(uid, str);
+    update += str;
+
+    //max
+    setUIMax(uid, str);
+    update += str;
+
+    //step
+    setUIStep(uid, str);
+    update += str;
+
+    //vaue
+    setUIValue(uid, str);
+    update += str;
+
+    //set callback uses to update values from web view
+    setCallback(uid, str);
+    update += str;
+
+    return true;
+}
+
+bool WebUtils::set(int prop, int uid, std::string& str)
+{
+    SETTER::iterator it = setter.find(prop);
+    if (it != setter.end())
+    {
+        it->second(uid, str, false);
+
+        return true;
+    }
+
+    return false;
+}
+
+void WebUtils::fillSetter()
+{
+    setter[__GO_PARENT__] = WebUtils::setParent;
+    setter[__GO_POSITION__] = WebUtils::setUIPosition;
+    setter[__GO_SIZE__] = WebUtils::setFigureSize;
+    setter[__GO_UI_STRING__] = WebUtils::setUIString;
+    setter[__GO_VISIBLE__] = WebUtils::setVisible;
+    setter[__GO_UI_ENABLE__] = WebUtils::setUIEnable;
+    setter[__GO_UI_BACKGROUNDCOLOR__] = WebUtils::setUIBackgroundColor;
+    setter[__GO_UI_FONTANGLE__] = WebUtils::setUIFontAngle;
+    setter[__GO_UI_FONTNAME__] = WebUtils::setUIFontName;
+    setter[__GO_UI_FONTSIZE__] = WebUtils::setUIFontSize;
+    setter[__GO_UI_FONTWEIGHT__] = WebUtils::setUIFontWeight;
+    setter[__GO_UI_FOREGROUNDCOLOR__] = WebUtils::setUIForegroundColor;
+    setter[__GO_UI_HORIZONTALALIGNMENT__] = WebUtils::setUIHorizontalAlignment;
+    setter[__GO_UI_RELIEF__] = WebUtils::setUIRelief;
+    setter[__GO_UI_VERTICALALIGNMENT__] = WebUtils::setUIVerticalAlignment;
+    setter[__GO_LAYOUT__] = WebUtils::setUILayout;
+    setter[__GO_UI_MIN__] = WebUtils::setUIMin;
+    setter[__GO_UI_MAX__] = WebUtils::setUIMax;
+    setter[__GO_UI_SLIDERSTEP__] = WebUtils::setUIStep;
+    setter[__GO_UI_VALUE__] = WebUtils::setUIValue;
+    //setter[__GO_CALLBACK__] = WebUtils::setCallback;
+}
+
+bool WebUtils::updateValue(int uid, const std::string& value)
+{
+    if (hasStyle(uid, __GO_UI_EDIT__))
+    {
+        std::vector<std::string> v(1, value);
+        setStringVectorProperty(uid, __GO_UI_STRING__, v);
+    }
+
+    return false;
+}
+
+bool WebUtils::updateValue(int uid, const std::vector<double>& values)
+{
+    setDoubleVectorProperty(uid, __GO_UI_VALUE__, values);
+    return false;
+}
+
+bool WebUtils::updateValue(int uid, double value)
+{
+    std::vector<double> v(1, value);
+    setDoubleVectorProperty(uid, __GO_UI_VALUE__, v);
+    return false;
+}
+
+bool WebUtils::updateValue(int uid, bool value)
+{
+    std::vector<double> v(1, value ? getUIMax(uid) : getUIMin(uid));
+    setDoubleVectorProperty(uid, __GO_UI_VALUE__, v);
+    return false;
+}
+
index 3fa7123..2aec463 100644 (file)
 
 #include <string>
 #include <vector>
+#include <unordered_map>
+
+typedef void(*setFunction)(int, std::string&, bool);
 
 class WebUtils
 {
     WebUtils() {}
     ~WebUtils() {}
 
-private:
+    typedef std::unordered_map<int, setFunction> SETTER;
+    static SETTER setter;
 
     static bool hasStyle(int uid, int style);
+    static bool isInputType(int uid);
 
-    static std::string getIdString(int uid);
-    static std::string getElementById(int uid);
+    static std::string getIdString(int uid, const std::string& suffix = "");
+    static std::string getElementById(int uid, const std::string& suffix = "");
     static std::string createElement(const std::string& type);
 
+    static std::string getColor(const std::vector<double>& c);
 public:
 
+    static void fillSetter();
+    static bool set(int prop, int uid, std::string& str);
+
+    static bool updateValue(int uid, bool value);
+    static bool updateValue(int uid, double value);
+    static bool updateValue(int uid, const std::string& value);
+    static bool updateValue(int uid, const std::vector<double>& values);
     static int getIntProperty(int uid, int prop);
+    static bool getBoolProperty(int uid, int prop);
     static double getDoubleProperty(int uid, int prop);
     static std::string getStringProperty(int uid, int prop);
 
@@ -42,20 +56,79 @@ public:
     static void getDoubleVectorProterty(int uid, int prop, std::vector<double>& vect);
     static void  getStringVectorProperty(int uid, int prop, std::vector<std::string>& vect);
 
+    static bool setStringProperty(int uid, int prop, const std::string& value);
+    static bool setStringVectorProperty(int uid, int prop, const std::vector<std::string>& values);
+
+    static bool setDoubleProperty(int uid, int prop, double value);
+    static bool setDoubleVectorProperty(int uid, int prop, const std::vector<double>& values);
+
 
     //commoms
     static int getType(int uid);
     static int getStyle(int uid);
     static int getParent(int uid);
-    static void setParent(int uid, std::string& str);
+    static int getFigureId(int uid);
+    static void setParent(int uid, std::string& str, bool append = false);
     static void getUIPosition(int uid, std::vector<double>& vect);
-    static void setUIPosition(int uid, std::string& str);
+    static void setUIPosition(int uid, std::string& str, bool append = false);
 
     static void getFigureSize(int uid, std::vector<int>& vect);
-    static void setFigureSize(int uid, std::string& str);
+    static void setFigureSize(int uid, std::string& str, bool append = false);
 
     static void getUIString(int uid, std::vector<std::string>& vect);
-    static void setUIString(int uid, std::string& str);
+    static void setUIString(int uid, std::string& str, bool append = false);
+
+    static bool getVisible(int uid);
+    static void setVisible(int uid, std::string& str, bool append = false);
+
+    static bool getUIEnable(int uid);
+    static void setUIEnable(int uid, std::string& str, bool append = false);
+
+    static bool getUIBackgroundColor(int uid, std::vector<double>& vect);
+    static void setUIBackgroundColor(int uid, std::string& str, bool append = false);
+
+    static bool getUIFontAngle(int uid, std::string& str);
+    static void setUIFontAngle(int uid, std::string& str, bool append = false);
+
+    static bool getUIFontName(int uid, std::string& str);
+    static void setUIFontName(int uid, std::string& str, bool append = false);
+
+    static bool getUIFontUnits(int uid, std::string& str);
+    static double getUIFontSize(int uid);
+    static void setUIFontSize(int uid, std::string& str, bool append = false);
+
+    static bool getUIFontWeight(int uid, std::string& str);
+    static void setUIFontWeight(int uid, std::string& str, bool append = false);
+
+    static bool getUIForegroundColor(int uid, std::vector<double>& vect);
+    static void setUIForegroundColor(int uid, std::string& str, bool append = false);
+
+    static bool getUIHorizontalAlignment(int uid, std::string& str);
+    static void setUIHorizontalAlignment(int uid, std::string& str, bool append = false);
+
+    static bool getUIRelief(int uid, std::string& str);
+    static void setUIRelief(int uid, std::string& str, bool append = false);
+
+    static bool getUIVerticalAlignment(int uid, std::string& str);
+    static void setUIVerticalAlignment(int uid, std::string& str, bool append = false);
+
+    static int getUILayout(int uid);
+    static void setUILayout(int uid, std::string& str, bool append = false);
+
+    static double getUIMin(int uid);
+    static void setUIMin(int uid, std::string& str, bool append = false);
+
+    static double getUIMax(int uid);
+    static void setUIMax(int uid, std::string& str, bool append = false);
+
+    static double getUIStep(int uid);
+    static void setUIStep(int uid, std::string& str, bool append = false);
+
+    static bool getUIValue(int uid, std::vector<double>& vect);
+    static void setUIValue(int uid, std::string& str, bool append = false);
+
+    static bool hasCallback(int uid);
+    static void setCallback(int uid, std::string& str, bool append = false);
 
     //is
     static bool isManaged(int uid);
@@ -65,10 +138,24 @@ public:
     
     //create
     static bool createFigure(int uid, std::string& str);
+
+    static bool createCommonIUControl(int uid, const std::string& htmlType, const std::string& cssClass, std::string& str);
     static bool createUIControl(int uid, std::string& str);
     static bool createPushButton(int uid, std::string& str);
-
+    static bool createFrame(int uid, std::string& str);
+    static bool createText(int uid, std::string& str);
+    static bool createEdit(int uid, std::string& str);
+    static bool createCheckbox(int uid, std::string& str);
+    static bool createRadio(int uid, std::string& str);
+    static bool createSlider(int uid, std::string& str);
+    static bool createListbox(int uid, std::string& str);
+    static bool createCombobox(int uid, std::string& str);
+    static bool createSpinner(int uid, std::string& str);
+
+    //update
+    static bool updateDefaultProperties(int uid, std::string& str);
     //delete
+    static bool deleteObject(int uid, std::string& str);
 
 
     //cupdate
index bb10427..e435c02 100644 (file)
 <!DOCTYPE HTML>
 <html>
-<head>
-    <meta charset='UTF-8' />
-    <title>Scilab via Socket.IO v0.3</title>
-    <script type='text/javascript' src='/socket.io/socket.io.js'></script>
-    <style type='text/css'>
-    
-    body {
-        background-color : rgb(192,192,192);
-        color : black;
-        text-align : center;
-    }
-    
-    .log {
-        background-color : white;
-        opacity : 1;
-        width : 500px;
-        height : 100px;
-        margin : auto;
-        text-align:left;
-        border : 2px rgb(0,0,0) solid;
-        overflow : auto;
-        font-family: 'Lucida Console', Monaco, monospace;
-        font-size:10pt;
-    }
-    .GO_FIGURE {
-        /*
-            must be relative or absolute 
-            to allow absolue positioning of children
-        */
-        position: relative;
-        background-color : white;
-        width : 600px;
-        height : 600px;
-        margin : auto;
-        border : 2px rgb(0,0,0) solid;
-        overflow : auto;
-        text-align: left;
-    }
-
-    .GO_PUSHBUTTON {
-        position: absolute;
-        left: 20px;
-        top: 440px;
-        width : 40px;
-        height : 20px;
-        text-align:center;
-        overflow : hidden;
-        font-family: Tahoma;
-        font-size:11pt;
-    }
-
-    #infobar {
-        background-color : rgb(192,192,192);
-        opacity : 1;
-        width : 500px;
-        height : 20px;
-        margin : auto;
-        border : 1px rgb(0,0,0) solid;
-        font-weight: bold;
-    }
-    
-    #command {
-        background-color : white;
-        opacity : 1;
-        width : 500px;
-        height : 100px;
-        margin : auto;
-        border : 2px rgb(0,0,0) solid;
-        overflow : auto;
-        font-family: 'Lucida Console', Monaco, monospace;
-        font-size:10pt;
-    }
-
-    </style>
-</head>
+    <head>
+        <meta charset='UTF-8' />
+        <title>Scilab WebView</title>
+        <script type='text/javascript' src='/socket.io/socket.io.js'></script>
+        <style type='text/css'>
+body {
+    background-color : rgb(192,192,192);
+    color : black;
+    text-align : center;
+}
+
+.log {
+    background-color : white;
+    opacity : 1;
+    width : 500px;
+    height : 100px;
+    margin : auto;
+    text-align:left;
+    border : 2px rgb(0,0,0) solid;
+    overflow : auto;
+    font-family: 'Lucida Console', Monaco, monospace;
+    font-size:11px;
+}
+
+.GO_FIGURE {
+    /*
+        "position" must be relative or absolute 
+        to allow absolue positioning of children
+    */
+    position: relative;
+    background-color : rgb(192,192,192);
+    width : 610px;
+    height : 460px;
+    margin : auto;
+    border : 2px rgb(0,0,0) solid;
+    overflow : auto;
+    text-align: left;
+}
+
+.GO_PUSHBUTTON {
+    position: absolute;
+    left: 20px;
+    bottom: 40px;
+    width : 40px;
+    height : 20px;
+    text-align:center;
+    overflow : hidden;
+    font-family: Tahoma, Verdana, Segoe, sans-serif;
+    font-size: 11px;
+    visibility:inherit;
+}
+
+.GO_FRAME {
+    position: absolute;
+    background-color : white;
+    left: 20px;
+    bottom: 40px;
+    width : 40px;
+    height : 20px;
+    text-align:center;
+    overflow : hidden;
+    font-family: Tahoma, Verdana, Segoe, sans-serif;
+    font-size:11px;
+    border : 1px rgb(0,0,0) solid;
+    visibility:inherit;
+}
+
+.GO_TEXT {
+    position: absolute;
+    background-color : white;
+    left: 20px;
+    bottom: 40px;
+    width : 40px;
+    height : 20px;
+    line-height:20px;
+    text-align:left;
+    vertical-align: middle;
+    overflow : hidden;
+    font-family: Tahoma, Verdana, Segoe, sans-serif;
+    font-size:11px;
+    visibility:inherit;
+}
+
+.GO_EDIT {
+    position: absolute;
+    background-color : white;
+    left: 20px;
+    bottom: 40px;
+    width : 40px;
+    height : 20px;
+    text-align:left;
+    overflow : hidden;
+    font-family: Tahoma, Verdana, Segoe, sans-serif;
+    font-size:11px;
+    visibility:inherit;
+}
+
+.GO_CHECKBOX {
+    position: absolute;
+    background-color : white;
+    left: 20px;
+    bottom: 40px;
+    width : 40px;
+    height : 20px;
+    line-height:20px;
+    text-align:left;
+    vertical-align: middle;
+    overflow : hidden;
+    font-family: Tahoma, Verdana, Segoe, sans-serif;
+    font-size:11px;
+    visibility:inherit;
+}
+
+.GO_CHECKBOX_LABEL {
+    background-color : inherit;
+    left: 20px;
+    bottom: 40px;
+    width : 40px;
+    height : 20px;
+    text-align:left;
+    overflow : hidden;
+    font-family: inherit;
+    font-size:inherit;
+    visibility:inherit;
+}
+
+.GO_CHECKBOX_CHECKBOX {
+    background-color : inherit;
+    left: 0px;
+    bottom: 0px;
+    overflow : hidden;
+    visibility:inherit;
+}
+
+.GO_RADIO {
+    position: absolute;
+    background-color : white;
+    left: 20px;
+    bottom: 40px;
+    width : 40px;
+    height : 20px;
+    line-height:20px;
+    text-align:left;
+    vertical-align: middle;
+    overflow : hidden;
+    font-family: Tahoma, Verdana, Segoe, sans-serif;
+    font-size:11px;
+    visibility:inherit;
+}
+
+.GO_RADIO_LABEL {
+    background-color : inherit;
+    left: 20px;
+    bottom: 40px;
+    width : 40px;
+    height : 20px;
+    text-align:left;
+    overflow : hidden;
+    font-family: inherit;
+    font-size:inherit;
+    visibility:inherit;
+}
+
+.GO_RADIO_RADIO {
+    background-color : inherit;
+    left: 0px;
+    bottom: 0px;
+    overflow : hidden;
+    visibility:inherit;
+}
+
+.GO_SLIDER {
+    position: absolute;
+    background-color : white;
+    left: 20px;
+    bottom: 40px;
+    width : 40px;
+    height : 20px;
+    overflow : hidden;
+    visibility:inherit;
+}
+
+.GO_LISTBOX {
+    position: absolute;
+    background-color : white;
+    left: 20px;
+    bottom: 40px;
+    width : 40px;
+    height : 20px;
+    overflow : auto;
+    visibility:inherit;
+}
+
+.GO_COMBOBOX {
+    position: absolute;
+    background-color : white;
+    left: 20px;
+    bottom: 40px;
+    width : 40px;
+    height : 20px;
+    overflow : auto;
+    visibility:inherit;
+}
+
+.GO_SPINNER {
+    position: absolute;
+    background-color : white;
+    left: 20px;
+    bottom: 40px;
+    width : 40px;
+    height : 20px;
+    text-align:right;
+    overflow : hidden;
+    font-family: Tahoma, Verdana, Segoe, sans-serif;
+    font-size:11px;
+    visibility:inherit;
+}
+
+.window {
+    /*
+        "position" must be relative or absolute 
+        to allow absolue positioning of children
+    */
+    position: relative;
+    background-color : rgb(192.192.192);
+    margin : auto;
+    /*
+    border : 2px rgb(0,0,0) solid;
+    */
+    overflow : auto;
+    text-align: left;
+}
+
+#infobar {
+    background-color : rgb(192,192,192);
+    opacity : 1;
+    width : 500px;
+    height : 20px;
+    margin : auto;
+    border : 1px rgb(0,0,0) solid;
+    font-weight: bold;
+}
+        </style>
+    </head>
     <body>
         <h1>Scilab WebView</h1>
         <div id='infobar'></div>
-        </br>
-            <textarea id='command'>
-if 0 then
-    f = createWindow();
-    uicontrol("position", [50 50 100 40], "string", "+ 1", "callback", "v = eval(get(''num'', ''string''));set(''num'', ''string'', string(v + 1));");
-    uicontrol("position", [170 50 100 40], "string", "0", "tag", "num");
-    uicontrol("position", [290 50 100 40], "string", "- 1", "callback", "v = eval(get(''num'', ''string''));set(''num'', ''string'', string(v - 1));");
-end
-
-if 1 then
-    f = createWindow();
-    f.position(3:4) = [500, 500];
-    for i=1:100
-        x = floor((i-1) / 10);
-        y = modulo((i-1), 10);
-        uicontrol("position", [50*x, 50*y,50,50],"string", string(x) + string(y), "callback", "set(gcbo, ''string'', ''clicked'')");
-    end
-end
-            </textarea>
-            </br>
-            <button id="cmdbtn" onClick="execute()">Execute</button>
         <h3>Logger:</h3>
         <div class='log' id='logger'></div>
+        <br>
+        <div class='window' id='scilab'></div>
+        
         <script type='text/javascript'>
             var command;
             // connect to server
             var socket = io();
 
-            resetLogger('');
+            resetLogger();
             setInfo('');
             
-            //callback
-            function execute() {
-                resetLogger();
-                data = document.getElementById('command').value;
-                socket.emit('command', data);
-                var objCmd = document.getElementById('cmdbtn');
-                objCmd.disabled  = true;
-                return false;
+            function onPushButton() {
+                var id = parseInt(this.id.substring(3)); //ignore "uid"
+                socket.emit("callback", {uid:id});
+           }
+            
+            function onCheckBox() {
+                var id = parseInt(this.id.substring(3)); //ignore "uid"
+                socket.emit("callback", {uid:id, value:this.checked});
             }
             
-            //callback click
-            function OnUIClick(elem) {
-                var id = elem.id;
-                id = parseInt(id.substring(3)); //ignore "uid"
-                socket.emit("callback", {uid:id});
+            function onRadioButton() {
+                var id = parseInt(this.id.substring(3)); //ignore "uid"
+                socket.emit("callback", {uid:id, value:this.checked});
+            }
+
+            function onListBox() {
+                var id = parseInt(this.id.substring(3)); //ignore "uid"
+                var data = [];
+                for(var i = 0 ; i < this.options.length; ++i) {
+                    if(this.options[i].selected) {
+                        data.push(i);
+                    }
+                }
+                socket.emit("callback", {uid:id, value:data});
+            }
+            
+            function onComboBox() {
+            }
+            
+            function onTab() {
+            }
+            
+            function onSlider() {
+                var id = parseInt(this.id.substring(3)); //ignore "uid"
+                socket.emit("callback", {uid:id, value:parseFloat(this.value)});
+            }
+            
+            function onEditBox() {
+                var id = parseInt(this.id.substring(3)); //ignore "uid"
+                socket.emit("callback", {uid:id, value:this.value});
+           }
+            
+            function onSpinner() {
+                var id = parseInt(this.id.substring(3)); //ignore "uid"
+                socket.emit("callback", {uid:id, value:parseFloat(this.value)});
             }
-             //tools
+            
+            //tools
             function setInfo(data) {
                 document.getElementById('infobar').innerHTML = data;
             }
             
-           function resetLogger(data) {
+           function resetLogger() {
                 var objDiv = document.getElementById('logger');
                 objDiv.innerHTML = '';
             }
@@ -142,19 +324,26 @@ end
             }
             
             //socket events management
-            socket.on('status', function (msg) {
-                setInfo(msg);
-            });
-
             socket.on('command_end', function () {
-                var objCmd = document.getElementById('cmdbtn');
-                objCmd.disabled  = false;
             });
 
             socket.on('disconnect', function () {
                 setInfo('Connection lost');
             });
             
+            socket.on('status', function (msg) {
+                if(msg.data == "ready") {
+                    setInfo("Scilab is ready");
+                    resetLogger();
+                    //reset "scilab" page
+                    var parent = document.getElementById('scilab');
+                    parent.innerHTML = "";
+                } else {
+                    setInfo("Scilab is busy");
+                }
+                setLogger('<font color="black">' +  msg.data + '</font>');
+            });
+            
             socket.on('graphic_create', function (msg) {
                 //setLogger('<font color="green">' +  msg.data + '</font>');
                 eval(msg.data);
@@ -162,6 +351,7 @@ end
             
             socket.on('graphic_delete', function (msg) {
                 //setLogger('<font color="red">' + 'graphic_delete(' + msg.uid + ')' + '</font>');
+                eval(msg.data);
             });
             
             socket.on('graphic_update', function (msg) {
diff --git a/scilab/node/loader.sce b/scilab/node/loader.sce
new file mode 100644 (file)
index 0000000..c5a34c2
--- /dev/null
@@ -0,0 +1,112 @@
+if 1 then
+    f1 = createWindow();
+    f1.position(3:4) = [250, 100];
+
+    uicontrol(f1, "position", [25 25 50 50], "string", "+1", "callback", "v = eval(get(''num'', ''string''));set(''num'', ''string'', string(v + 1));");
+    uicontrol(f1, "position", [100 25 50 50], "string", "0", "tag", "num", "callback", "set(''num'', ''string'', ''0'');");
+    uicontrol(f1, "position", [175 25 50 50], "string", "-1", "callback", "v = eval(get(''num'', ''string''));set(''num'', ''string'', string(v - 1));");
+end
+
+if 0 then
+    f2 = createWindow();
+    f2.visible = %f;
+    f2.position(3:4) = [500, 600];
+    for i=1:81
+        x = floor((i-1) / 9);
+        y = modulo((i-1), 9);
+        uicontrol(f2, "position", [25 + 50*x, 125 + 50*y,50,50],"string", string(x) + " - " + string(y), "callback", "set(gcbo, ''enable'', %f)");
+    end
+    
+    uicontrol(f2, "position", [200, 25, 100, 50], "string", "reset", "callback", "c = gcbo.parent.children;for i=1:size(c, ''*''), c(i).enable = %t;end");
+    f2.visible = %t;
+end
+
+if 0 then
+    xdel(winsid());
+    clear;
+    
+    function reset()
+        minval = get("min", "value");
+        maxval = get("max", "value");
+        set("slider", "value", string(((maxval - minval) / 2) + minval));
+    endfunction
+    
+    function onchange()
+        set("slider", "min", get("min", "value"));
+        step = get("step", "value");
+        set("slider", "sliderstep", [step, step*10]);
+        set("slider", "max", get("max", "value"));
+    endfunction
+    
+    f = createWindow();
+    f.visible = %f;
+    f.position(3:4) = [300, 200];
+    
+    uicontrol("style", "text", "string", "0", "position", [120, 160, 60, 20], "horizontalalignment", "center", "tag", "val");
+    uicontrol("style", "slider", "position", [10 120 280 30], "min", -100, "max", 100, "sliderstep", [1, 1], "value", 0, "tag", "slider");
+
+    uicontrol("style", "text", "string", "min", "position", [25 80 50 20], "horizontalalignment", "center");
+    uicontrol("style", "text", "string", "step", "position", [125 80 50 20], "horizontalalignment", "center");
+    uicontrol("style", "text", "string", "max", "position", [225 80 50 20], "horizontalalignment", "center");
+    
+    uicontrol("style", "spinner", "min", -100, "max", 0, "sliderstep", [1, 1], "value", "-100", "position", [25 50 50 20], "horizontalalignment", "center", "tag", "min");
+    uicontrol("style", "spinner", "min", 1, "max", 10, "sliderstep", [1, 1], "value", "1", "position", [125 50 50 20], "horizontalalignment", "center", "tag", "step");
+    uicontrol("style", "spinner", "min", 0, "max", 100, "sliderstep", [1, 1], "value", "100", "position", [225 50 50 20], "horizontalalignment", "center", "tag", "max");
+
+    uicontrol("style", "pushbutton", "string", "reset", "position", [100 10 100 30], "callback", "reset");
+    f.visible = %t;
+    
+    set("slider", "callback", "val = gcbo.value;set(""val"", ""string"", string(val));");
+    set("min", "callback", "onchange");
+    set("step", "callback", "onchange");
+    set("max", "callback", "onchange");
+    
+end
+
+
+if 0 then
+    f = createWindow();
+    f.position = [200 200 240 470];
+    f.figure_name = "";
+
+    fr1 = uicontrol("style", "frame", "position", [10 10 220 450], "border", createBorder("etched"));
+    spinner = uicontrol(fr1, "style", "spinner", "string", "0", "position", [10 410 200 30], "horizontalalignment", "right", "min", 0, "max", 5, "backgroundcolor", [0 1 0]);
+    label = uicontrol(fr1, "style", "text", "string", "usedeprecatedskin=""off""", "position", [10 370 200 30], "backgroundcolor", [1 0 1]);
+    editbox = uicontrol(fr1, "style", "edit", "string", "Edit", "position", [10 330 200 30], "backgroundcolor", [1 0 0]);
+    button = uicontrol(fr1, "style", "pushbutton", "string", "Pushbutton", "position", [10 290 200 30]);
+    checkbox = uicontrol(fr1, "style", "checkbox", "string", "Checkbox", "position", [10 250 200 30], "backgroundcolor", [0 0 1]);
+    radio = uicontrol(fr1, "style", "radiobutton", "string", "Radiobutton", "position", [10 210 200 30], "backgroundcolor", [1 0 1]);
+    slider = uicontrol(fr1, "style", "slider", "position", [10 150 200 50]);
+    frame = uicontrol(fr1, "style", "frame", "position", [10 110 200 30], "backgroundcolor", [0.5 0.5 0.5]);
+    listbox = uicontrol(fr1, "style", "listbox", "string", "listbox1|listbox2|listbox3|listbox4|listbox5", "position", [10 50 200 50], "backgroundcolor", [0.2 0.2 0.2]);
+    combo = uicontrol(fr1, "style", "popupmenu", "string", "popupmenu1|popupmenu2", "position", [10 10 200 30], "backgroundcolor", [0.8 0.8 0.8]);
+end
+
+if 0 then
+    xdel(winsid());
+    clear;
+
+    function onchange()
+        R = get("sliderR", "value") / 255;
+        G = get("sliderG", "value") / 255;
+        B = get("sliderB", "value") / 255;
+        set("color", "backgroundcolor", [R, G, B]);
+    endfunction
+    
+
+    f = createWindow();
+    f.visible = %f;
+    f.position(3:4) = [396, 130];
+
+    uicontrol("style", "slider", "position", [10 10 256 30], "min", 0, "max", 255, "sliderstep", [1, 1], "value", 0, "tag", "sliderB");
+    uicontrol("style", "slider", "position", [10 50 256 30], "min", 0, "max", 255, "sliderstep", [1, 1], "value", 0, "tag", "sliderG");
+    uicontrol("style", "slider", "position", [10 90 256 30], "min", 0, "max", 255, "sliderstep", [1, 1], "value", 0, "tag", "sliderR");
+    
+    uicontrol("style", "frame", "position", [286 20 90 90], "tag", "color", "backgroundcolor", [0, 0, 0]);
+    
+    set("sliderR", "callback", "onchange");
+    set("sliderG", "callback", "onchange");
+    set("sliderB", "callback", "onchange");
+    
+    f.visible = %t;
+end
index d705161..ddd061a 100644 (file)
@@ -4,7 +4,9 @@ var L = console.log;
 var id = -1;
 var io = [];
 
-var debug = false;
+var debug = true;
+var command_ready = false;
+var graphic_ready = false;
 
 process.on('message', function(msg){
     switch(msg.msgtype.toLowerCase()) {
@@ -26,9 +28,16 @@ process.on('message', function(msg){
                 });
 
                 socket.on('disconnect', function () {
-                    L('scilab disconnected');
+                    L('scilab command disconnected'+ '(' + process.pid + ')');
+                    command_ready = false;
                 });
-            });
+
+                //send to server scilab is ready
+                command_ready = true;
+                if(graphic_ready) {
+                    process.send({msgtype:"status", data:"ready"});
+                }
+           });
 
             //start graphic server to chat with graphic
             port += 1;
@@ -39,23 +48,35 @@ process.on('message', function(msg){
                 L("Scilab graphic connected");
 
                 socket.on('graphic_create', function (msg) {
+                    //L('graphic_create');
+                    //L(msg);
                     process.send({msgtype:'graphic_create', data:msg});
                 });
 
                 socket.on('graphic_delete', function (msg) {
+                    //L('graphic_delete');
+                    //L(msg);
                     process.send({msgtype:'graphic_delete', data:msg});
                 });
 
                 socket.on('graphic_update', function (msg) {
+                    //L('graphic_update');
+                    //L(msg);
                     process.send({msgtype:'graphic_update', data:msg});
                 });
 
                 socket.on('disconnect', function () {
-                    L('scilab disconnected');
+                    L('scilab graphic disconnected'+ '(' + process.pid + ')');
+                    graphic_ready = false;
                 });
+                
+                //send to server scilab is ready
+                graphic_ready = true;
+                if(command_ready) {
+                    process.send({msgtype:"status", data:"ready"});
+                }
             });
 
-
             //launch scilab with init command
             var app = process.env.SCI + "/bin/wscilex.exe";
 
@@ -63,10 +84,11 @@ process.on('message', function(msg){
             
             //to debug
             if(debug) {
+/*
                 scilabApp.stdout.on('data', function(data) {
                     L("scilab out :" + data.toString());
                 });
-                
+*/                
                 scilabApp.stderr.on('data', function(data) {
                     L("scilab err :" + data.toString());
                 });
@@ -86,14 +108,14 @@ process.on('message', function(msg){
             commandio.emit("command", {data:msg.data});
             break;
         case 'callback' : 
-            L('callback (' + process.pid + ') : ' + msg.data.uid);
-            graphicio.emit("callback", {uid:msg.data.uid});
+            graphicio.emit("callback", msg.data);
             break;
         case 'restart' :
             L('restart' + '(' + process.pid + ')');
             break;
         case 'quit' :
             L('quit' + '(' + process.pid + ')');
+            commandio.emit("command", {data:'quit'});
             break;
         default :
             L('unknow message : ' + msg.msgtype);
index c8c58bc..d692d7a 100644 (file)
@@ -33,6 +33,14 @@ io.on('connection', function (socket) {
                 //forward message
                 socket.emit(msg.msgtype, msg);
                 break;
+            case 'status':
+                if(msg.data == 'ready') {
+                    //send ready message to client
+                    socket.emit(msg.msgtype, msg);
+                    //send execution of initial script to scilab
+                    child.send({msgtype:'command', data:"exec('SCI/node/loader.sce', -1);"});
+                }
+            break;
             default:
                 L('not manage : ' + msg.msgtype);
                 break;
@@ -41,9 +49,6 @@ io.on('connection', function (socket) {
 
     child.send({msgtype:'initialization', id:child.pid});
 
-    // send connection status to client
-    socket.emit('status', 'Client connected');
-    
     //receive command from client
     socket.on('command', function (data) {
         child.send({msgtype:'command', data:data});
@@ -60,57 +65,4 @@ io.on('connection', function (socket) {
 
 });
 
-
-/*
-
-
-var server = http.createServer(function (req, res) {
-    //create scilab child
-    L("req : " + req.toString());
-    var socket;
-    var child = fork('./scilab_process.js');
-    //messaging with scilab js
-    child.on('message', function(msg){
-        switch(msg.msgtype.toLowerCase()) {
-            case 'command_end':
-                socket.emit(msg.msgtype);
-                break;
-            case 'graphic_create':
-            case 'graphic_delete':
-            case 'graphic_update':
-                //forward message
-                socket.emit(msg.msgtype, msg);
-                break;
-            default:
-                L('not manage : ' + msg.msgtype);
-                break;
-        }
-    });
-
-    child.send({msgtype:'initialization', id:child.pid});
-    fs.readFile('./html/index.html', 'utf-8', function(error, content) {
-        res.writeHead(200, {'Content-Type' : 'text/html'});
-        res.end(content);
-    })
-
-  
-
-    //messaging with web client
-    io.sockets.on('connection', function (s) {
-        socket = s;
-        // send connection status to client
-        socket.emit('status', 'Client connected');
-        
-        //receive command from client
-        socket.on('command', function (data) {
-            child.send({msgtype:'command', data:data});
-        });
-    });
-}).listen(1337, function(){
-    L("gné");
-});
-
-
-*/
-
 L('Server running at http://127.0.0.1:1337/');