1

include yslt_noindent.yml2

     2

     3

// overrides yslt's output function to set CDATA

     4

decl output(method, cdata-section-elements="xhtml:script");

     5

    11

istylesheet

    12

            /* From Inkscape */

    13

            xmlns:dc="http://purl.org/dc/elements/1.1/"

    14

            xmlns:cc="http://creativecommons.org/ns#"

    15

            xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"

    16

            xmlns:svg="http://www.w3.org/2000/svg"

    17

            xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"

    18

            xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"

    19

            xmlns:xhtml="http://www.w3.org/1999/xhtml"

    20

    21

            /* Our namespace to invoke python code */

    22

            xmlns:ns="beremiz"

    23

            extension-element-prefixes="ns func"

    24

            exclude-result-prefixes="ns str regexp exsl func" {

    25

    26

    /* This retrieves geometry obtained through "inkscape -S"

    27

     * already parsed by python and presented as a list of

    28

     * <bbox x="0" y="0" w="42" h="42">

    29

     */

    30

    const "geometry", "ns:GetSVGGeometry()";

    31

    const "hmitree", "ns:GetHMITree()";

    32

    34

    const "hmi_elements", "//svg:*[starts-with(@inkscape:label, 'HMI:')]";

    35

    const "hmi_geometry", "$geometry[@Id = $hmi_elements/@id]";

    36

    37

    const "hmi_pages", "$hmi_elements[func:parselabel(@inkscape:label)/widget/@type = 'Page']";

    38

    39

    const "default_page" choose {

    40

        when "count($hmi_pages) > 1" {

    41

            const "Home_page", 

    42

                "$hmi_pages[func:parselabel(@inkscape:label)/widget/arg[1]/@value = 'Home']";

    43

            choose {

    44

                when "$Home_page" > Home

    45

                otherwise {

    46

                    error "No Home page defined!";

    47

                }

    48

            }

    49

        }

    50

        when "count($hmi_pages) = 0" {

    51

            error "No page defined!";

    52

        }

    53

        otherwise > «func:parselabel($hmi_pages/@inkscape:label)/widget/arg[1]/@value»

    54

    }

    55

    56

    const "_categories" {

    57

        noindex > HMI_ROOT

    58

        noindex > HMI_LABEL

    59

        noindex > HMI_CLASS

    60

        noindex > HMI_PLC_STATUS

    61

        noindex > HMI_CURRENT_PAGE

    62

    }

    63

    const "categories", "exsl:node-set($_categories)";

    64

    const "_indexed_hmitree" apply "$hmitree", mode="index";

    65

    const "indexed_hmitree", "exsl:node-set($_indexed_hmitree)";

    66

    67

    template "*", mode="index" {

    68

        param "index", "0";

    69

        param "parentpath", "''";

    70

        const "content" {

    71

            const "path"

    72

                choose {

    73

                    when "local-name() = 'HMI_ROOT'" > «$parentpath»

    74

                    otherwise > «$parentpath»/«@name»

    75

                }

    76

            choose {

    77

                when "not(local-name() = $categories/noindex)" {

    78

                    xsl:copy {

    79

                        attrib "index" > «$index»

    80

                        attrib "hmipath" > «$path»

    81

                        foreach "@*" xsl:copy;

    82

                    }

    83

                    /* no node expected below value nodes */

    84

                }

    85

                otherwise {

    86

                    apply "*[1]", mode="index"{

    87

                        with "index", "$index";

    88

                        with "parentpath" > «$path»

    89

                    }

    90

                }

    91

            }

    92

        }

    93

    94

        copy "$content";

    95

        apply "following-sibling::*[1]", mode="index" {

    96

            with "index", "$index + count(exsl:node-set($content)/*)";

    97

            with "parentpath" > «$parentpath»

    98

        }

    99

    }

   100

   101

    /* Identity template :

   102

     *  - copy every attributes 

   103

     *  - copy every sub-elements

   104

     */

   106

      /* use real xsl:copy instead copy-of alias from yslt.yml2 */

   118

    }

   119

   120

    /*const "mark" > =HMI=\n*/

   121

   122

    /* copy root node and add geometry as comment for a test */

   123

    template "/" { 

   124

        comment > Made with SVGHMI. https://beremiz.org

   136

        html xmlns="http://www.w3.org/1999/xhtml" {

   137

            head;

   140

                script{

   141

                    call "scripts";

   142

                }

   143

            }

   144

        }

   145

    }

   146

   147

    func:function name="func:parselabel" {

   148

        param "label";

   149

        const "description", "substring-after($label,'HMI:')";

   150

   151

        const "_args", "substring-before($description,'@')";

   152

        const "args" choose {

   153

            when "$_args" value "$_args";

   154

            otherwise value "$description";

   155

        }

   156

   157

        const "_type", "substring-before($args,':')";

   158

        const "type" choose {

   159

            when "$_type" value "$_type";

   160

            otherwise value "$args";

   161

        }

   162

   163

        const "ast" if "$type" widget {

   164

            attrib "type" > «$type»

   165

            foreach "str:split(substring-after($args, ':'), ':')" {

   166

                arg {

   167

                    attrib "value" > «.»

   168

                }

   169

            }

   170

            const "paths", "substring-after($description,'@')";

   171

            foreach "str:split($paths, '@')" {

   172

                path {

   173

                    attrib "value" > «.»

   174

                }

   175

            }

   176

        }

   177

   178

        func:result select="exsl:node-set($ast)"

   179

    }

   180

   181

    function "scripts"

   182

    {

   183

        | //(function(){

   184

        |

   185

        | var hmi_hash = [«$hmitree/@hash»]; 

   186

   187

        /* TODO re-enable

   188

        ||

   189

        function evaluate_js_from_descriptions() {

   190

            var Page;

   191

            var Input;

   192

            var Display;

   193

            var res = [];

   194

        ||

   195

        const "midmark" > \n«$mark»

   196

        apply """//*[contains(child::svg:desc, $midmark) or \

   197

                     starts-with(child::svg:desc, $mark)]""",2 

   198

              mode="code_from_descs";

   199

        ||

   200

            return res;

   201

        }

   202

        ||

   203

        */

   204

   205

        | var hmi_widgets = {

   206

        foreach "$hmi_elements" {

   207

            const "widget", "func:parselabel(@inkscape:label)/widget";

   208

            | «@id»: {

   209

            |     type: "«$widget/@type»",

   210

            |     args: [

   211

            foreach "$widget/arg"

   212

            |         "«@value»"`if "position()!=last()" > ,`

   213

            |     ],

   214

            |     indexes: [

   215

            foreach "$widget/path" {

   216

                const "hmipath","@value";

   217

                const "hmitree_match","$indexed_hmitree/*[@hmipath = $hmipath]";

   218

                if "count($hmitree_match) = 0"

   219

                    error > No match for HMI «$hmipath»;

   220

            |         «$hmitree_match/@index»`if "position()!=last()" > ,`

   221

            }

   222

            |     ],

   223

            |     element: document.getElementById("«@id»"),

   224

            apply "$widget", mode="widget_defs" with "hmi_element",".";

   225

            | }`if "position()!=last()" > ,`

   226

        }

   227

        | }

   228

        |

   229

        | var hmitree_types = [

   230

   231

        foreach "$indexed_hmitree/*" {

   232

            | /* «@index»  «@hmipath» */ "«substring(local-name(), 5)»"`if "position()!=last()" > ,`

   233

        }

   234

   235

        | ]

   236

        |

   237

        | var page_desc = {

   238

   239

        foreach "$hmi_pages" {

   240

            const "desc", "func:parselabel(@inkscape:label)/widget";

   241

            const "page", "."; 

   242

            const "p", "$hmi_geometry[@Id = $page/@id]"; 

   243

            const "page_ids","""$hmi_geometry[@Id != $page/@id and 

   244

                                @x >= $p/@x and @y >= $p/@y and 

   245

                                @x+@w <= $p/@x+$p/@w and @y+@h <= $p/@y+$p/@h]/@Id""";

   246

            const "page_elements", "$hmi_elements[@id = $page_ids]";

   247

            |     "«$desc/arg[1]/@value»": {

   248

            |         id: "«@id»",

   250

            |         widgets: [

   251

            foreach "$page_ids" {

   252

            |             hmi_widgets.«.»`if "position()!=last()" > ,`

   253

            }

   254

            |         ]

   255

            |     }`if "position()!=last()" > ,`

   256

        }

   257

        | }

   258

   259

        |

   260

        | var default_page = "«$default_page»";

   262

        include text svghmi.js

   263

        | //})();

   264

    }

   265

   266

    /*

   267

        Parses:

   268

        "HMI:WidgetType:param1:param2@path1@path2"

   269

   270

        Into:

   271

        widget type="WidgetType" {

   272

            arg value="param1";

   273

            arg value="param2";

   274

            path value="path1";

   275

            path value="path2";

   276

        }

   277

    */

   278

   279

    template "*", mode="page_desc" {

   280

    }

   281

   282

    template "*", mode="code_from_descs" {

   283

        ||

   284

        {

   285

            var path, role, name, priv;

   286

            var id = "«@id»";

   287

        ||

   288

   289

        /* if label is used, use it as default name */

   290

        if "@inkscape:label"

   291

            |> name = "«@inkscape:label»";

   292

   293

        | /* -------------- */

   294

   295

        // this breaks indent, but fixing indent could break string literals

   296

        value "substring-after(svg:desc, $mark)";

   297

        // nobody reads generated code anyhow...

   298

   299

        ||

   300

   301

            /* -------------- */

   302

            res.push({

   303

                path:path,

   304

                role:role,

   305

                name:name,

   306

                priv:priv

   307

            })

   308

        }

   309

        ||

   310

    }

   311

   312

   313

    template "bbox", mode="testgeo"{

   314

        | ID: «@Id» x: «@x» y: «@y» w: «@w» h: «@h»

   315

    }

   316

   317

    template "*", mode="testtree"{

   318

        param "indent", "''";

   319

        > «$indent» «local-name()» 

   320

        foreach "@*" > «local-name()»=«.» 

   321

        > \n

   322

        apply "*", mode="testtree" {

   323

            with "indent" value "concat($indent,'>')"

   324

        };

   325

    }

   326

   341

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

   342

        param "hmi_element";

   343

        | frequency: 5,

   344

        | dispatch: function(value) {

   345

        choose {

   346

            when "$hmi_element[self::svg:text]"{

   347

            // TODO : care about <tspan> ?

   348

        |   this.element.textContent = String(value);

   349

            }

   350

            otherwise {

   351

                error > Display widget as a group not implemented

   352

            }

   353

        }

   354

        | },

   355

   356

    }

   357

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

   358

        param "hmi_element";

   359

        | frequency: 10,

   361

        | dispatch: function(value) {

   362

        |     this.value_elt.textContent = String(value);

   363

        |     let [min,max,totallength] = this.range;

   364

        |     let length = Math.max(0,Math.min(totallength,(Number(value)-min)*totallength/(max-min)));

   365

        |     let tip = this.range_elt.getPointAtLength(length);

   366

        |     this.needle_elt.setAttribute('d', "M "+this.origin.x+","+this.origin.y+" "+tip.x+","+tip.y);

   367

        | },

   368

        | origin: undefined,

   369

        | range: undefined,

   370

        | init: function() {

   371

        |     this.range = [Number(this.min_elt.textContent), Number(this.max_elt.textContent), this.range_elt.getTotalLength()]

   372

        |     this.origin = this.needle_elt.getPointAtLength(0);

   373

        | },

   374

    }

   375

   376

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

   377

        param "hmi_element";

   378

        | frequency: 5,

   380

        | dispatch: function(value) {

   381

        |     this.value_elt.textContent = String(value);

   382

        | },

   383

        const "edit_elt_id","$hmi_element/*[@inkscape:label='edit'][1]/@id";

   384

        | init: function() {

   385

        if "$edit_elt_id" {

   386

        |     document.getElementById("«$edit_elt_id»").addEventListener(

   387

        |         "click", 

   388

        |         evt => alert('XXX TODO : Edit value'));

   389

        }

   390

        foreach "$hmi_element/*[regexp:test(@inkscape:label,'^[=+\-][0-9]+')]" {

   391

        |     document.getElementById("«@id»").addEventListener(

   392

        |         "click", 

   393

        |         evt => {let new_val = change_hmi_value(this.indexes[0], "«@inkscape:label»");

   394

        |                 this.value_elt.textContent = String(new_val);});

   395

                          /* could gray out value until refreshed */

   396

        }

   397

        | },

   398

    }

   399

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

   400

    }

   401

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

   402

        |     frequency: 5,

   403

    }

   404

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

   405

        |     frequency: 5,

   406

    }

   414

}