1

// widget_jsontable.ysl2

     2

     3

template "widget[@type='JsonTable']", mode="widget_class"

     4

    ||

     5

    class JsonTableWidget extends Widget{

     6

        // arbitrary defaults to avoid missing entries in query

     7

        cache = [0,100,50];

     8

        init() {

     9

            this.spread_json_data_bound = this.spread_json_data.bind(this);

    10

        }

    11

    12

        handle_http_response(response) {

    13

            if (!response.ok) {

    14

              console.log("HTTP error, status = " + response.status);

    15

            }

    16

            return response.json();

    17

        }

    18

    19

        do_http_request(...opt) {

    20

            const query = {

    21

                args: this.args,

    22

                range: this.cache[1],

    23

                position: this.cache[2],

    24

                visible: this.visible,

    25

                extra: this.cache.slice(4),

    26

                options: opt

    27

            };

    28

    29

            const options = {

    30

                 method: 'POST',

    31

                 body: JSON.stringify(query),

    32

                 headers: {'Content-Type': 'application/json'}

    33

            };

    34

    35

            fetch(this.args[0], options)

    36

                .then(this.handle_http_response)

    37

                .then(this.spread_json_data_bound);

    38

    39

        }

    40

        dispatch(value, oldval, index) {

    41

            this.cache[index] = value;

    42

            this.do_http_request();

    43

        }

    44

        make_on_click(...options){

    45

            let that = this;

    46

            return function(evt){

    47

                that.do_http_request(...options);

    48

            }

    49

        }

    50

        // on_click(evt, ...options) {

    51

        //     this.do_http_request(...options);

    52

        // }

    53

    }

    54

    ||

    55

    56

template "svg:*", mode="json_table_elt_render" {

    57

    error > JsonTable Widget can't contain element of type «local-name()».

    58

}

    59

    60

    61

const "hmi_textstylelists_descs", "$parsed_widgets/widget[@type = 'TextStyleList']";

    62

const "hmi_textstylelists", "$hmi_elements[@id = $hmi_textstylelists_descs/@id]";

    63

    64

const "textstylelist_related" foreach "$hmi_textstylelists" list {

    65

    attrib "listid" value "@id";

    66

    foreach "func:refered_elements(.)" elt {

    67

        attrib "eltid" value "@id";

    68

    }

    69

}

    70

const "textstylelist_related_ns", "exsl:node-set($textstylelist_related)";

    71

    72

def "func:json_expressions" {

    73

    param "expressions";

    74

    param "label";

    75

    76

    // compute javascript expressions to access JSON data

    77

    // desscribed in given svg element's "label"

    78

    // knowing that parent element already has given "expressions".

    79

    80

    choose {

    81

        when "$label" {

    82

            const "suffixes", "str:split($label)";

    83

            const "res" foreach "$suffixes" expression {

    84

                const "suffix",".";

    85

                const "pos","position()";

    86

                // take last available expression (i.e can have more suffixes than expressions)

    87

                const "expr","$expressions[position() <= $pos][last()]/expression";

    88

                choose {

    89

                    when "contains($suffix,'=')" {

    90

                        const "name", "substring-before($suffix,'=')";

    91

                        if "$expr/@name[. != $name]"

    92

                            error > JsonTable : missplaced '=' or inconsistent names in Json data expressions.

    93

                        attrib "name" value "$name";

    94

                        attrib "content" > «$expr/@content»«substring-after($suffix,'=')»

    95

                    }

    96

                    otherwise {

    97

                        copy "$expr/@name";

    98

                        attrib "content" > «$expr/@content»«$suffix»

    99

                    }

   100

                }

   101

            }

   102

            result "exsl:node-set($res)";

   103

        }

   104

        // Empty labels are ignored, expressions are then passed as-is.

   105

        otherwise result "$expressions";

   106

    }

   107

   108

}

   109

   110

const "initexpr" expression attrib "content" > jdata

   111

const "initexpr_ns", "exsl:node-set($initexpr)";

   112

   113

template "svg:use", mode="json_table_elt_render" {

   114

    param "expressions";

   115

    // cloned element must be part of a HMI:List

   116

    const "targetid", "substring-after(@xlink:href,'#')";

   117

    const "from_list", "$hmi_lists[(@id | */@id) = $targetid]";

   118

   119

    choose {

   120

        when "count($from_list) > 0" {

   121

            |         id("«@id»").setAttribute("xlink:href",

   122

            // obtain new target id from HMI:List widget

   123

            |             "#"+hmi_widgets["«$from_list/@id»"].items[«$expressions/expression[1]/@content»]);

   124

        }

   125

        otherwise

   126

            warning > Clones (svg:use) in JsonTable Widget must point to a valid HMI:List widget or item. Reference "«@xlink:href»" is not valid and will not be updated.

   127

    }

   128

}

   129

   130

template "svg:text", mode="json_table_elt_render" {

   131

    param "expressions";

   132

    const "value_expr", "$expressions/expression[1]/@content";

   133

    const "original", "@original";

   134

    const "from_textstylelist", "$textstylelist_related_ns/list[elt/@eltid = $original]";

   135

    choose {

   136

   137

        when "count($from_textstylelist) > 0" {

   138

            const "content_expr", "$expressions/expression[2]/@content";

   139

            if "string-length($content_expr) = 0 or $expressions/expression[2]/@name != 'textContent'"

   140

                error > Clones (svg:use) in JsonTable Widget pointing to a HMI:TextStyleList widget or item must have a "textContent=.someVal" assignement following value expression in label.

   141

            |         {

   142

            |           let elt = id("«@id»");

   143

            |           elt.textContent = String(«$content_expr»);

   144

            |           elt.style = hmi_widgets["«$from_textstylelist/@listid»"].styles[«$value_expr»];

   145

            |         }

   146

        }

   147

        otherwise {

   148

            |         id("«@id»").textContent = String(«$value_expr»);

   149

        }

   150

    }

   151

}

   152

   153

   154

// only labels comming from Json widget are counted in

   155

def "func:filter_non_widget_label" {

   156

    param "elt";

   157

    param "widget_elts";

   158

    const "eltid" choose {

   159

        when "$elt/@original" value "$elt/@original";

   160

        otherwise value "$elt/@id";

   161

    }

   162

    result "$widget_elts[@id=$eltid]/@inkscape:label";

   163

}

   164

   165

template "svg:*", mode="json_table_render_except_comments"{

   166

    param "expressions";

   167

    param "widget_elts";

   168

   169

    const "label", "func:filter_non_widget_label(., $widget_elts)";

   170

    // filter out "# commented" elements

   171

    if "not(starts-with($label,'#'))" 

   172

        apply ".", mode="json_table_render"{

   173

            with "expressions", "$expressions";

   174

            with "widget_elts", "$widget_elts";

   175

            with "label", "$label";

   176

        }

   177

}

   178

   179

   180

template "svg:*", mode="json_table_render" {

   181

    param "expressions";

   182

    param "widget_elts";

   183

    param "label";

   184

   185

    const "new_expressions", "func:json_expressions($expressions, $label)";

   186

   187

    const "elt",".";

   188

    foreach "$new_expressions/expression[position() > 1][starts-with(@name,'onClick')]"

   189

    |         id("«$elt/@id»").onclick = this.make_on_click('«@name»', «@content»);

   190

   191

    apply ".", mode="json_table_elt_render"

   192

        with "expressions", "$new_expressions";

   193

}

   194

   195

template "svg:g", mode="json_table_render" {

   196

    param "expressions";

   197

    param "widget_elts";

   198

    param "label";

   199

    const "gid", "@id";

   200

   201

    // use intermediate variables for optimization

   202

    const "varprefix" > obj_«$gid»_

   203

    |         try {

   204

   205

    foreach "$expressions/expression"{

   206

    |          let «$varprefix»«position()» = «@content»;

   207

    |          if(«$varprefix»«position()» == undefined) {

   208

    |               console.log("«$varprefix»«position()» = «@content»");

   209

    |               throw null;

   210

    |          }

   211

    }

   212

   213

    // because we put values in a variables, we can replace corresponding expression with variable name

   214

    const "new_expressions" foreach "$expressions/expression" xsl:copy {

   215

        copy "@name";

   216

        attrib "content" > «$varprefix»«position()»

   217

    }

   218

   219

    // revert hiding in case it did happen before

   220

    |           id("«@id»").style = "«@style»";

   221

   222

    apply "*", mode="json_table_render_except_comments" {

   223

        with "expressions", "func:json_expressions(exsl:node-set($new_expressions), $label)";

   224

        with "widget_elts", "$widget_elts";

   225

    }

   226

    |         } catch(err) {

   227

    |           id("«$gid»").style = "display:none";

   228

    |         }

   229

}

   230

   231

template "widget[@type='JsonTable']", mode="widget_defs" {

   232

    param "hmi_element";

   233

    labels("data");

   234

    optional_labels("forward backward cursor");

   235

    const "data_elt", "$result_svg_ns//*[@id = $hmi_element/@id]/*[@inkscape:label = 'data']";

   236

    |     visible: «count($data_elt/*[@inkscape:label])»,

   237

    |     spread_json_data: function(janswer) {

   238

    |         let [range,position,jdata] = janswer;

   239

    |         this.apply_hmi_value(1, range);

   240

    |         this.apply_hmi_value(2, position);

   241

    |         this.apply_hmi_value(3, this.visible);

   242

    apply "$data_elt", mode="json_table_render_except_comments" {

   243

        with "expressions","$initexpr_ns";

   244

        with "widget_elts","$hmi_element/*[@inkscape:label = 'data']/descendant::svg:*";

   245

    }

   246

    |     }

   247

}