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

     6

in xsl decl labels(*ptr, name="defs_by_labels") alias call-template {

     7

    with "hmi_element", "$hmi_element";

     8

    with "labels"{text *ptr};

     9

};

    10

    11

in xsl decl optional_labels(*ptr, name="defs_by_labels") alias call-template {

    12

    with "hmi_element", "$hmi_element";

    13

    with "labels"{text *ptr};

    14

    with "mandatory","'no'";

    15

};

    16

    17

in xsl decl svgtmpl(match, xmlns="http://www.w3.org/2000/svg") alias template;

    18

in xsl decl svgfunc(name, xmlns="http://www.w3.org/2000/svg") alias template;

    19

    20

istylesheet

    21

            /* From Inkscape */

    22

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

    23

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

    24

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

    25

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

    26

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

    27

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

    28

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

    29

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

    30

    31

            /* Our namespace to invoke python code */

    32

            xmlns:ns="beremiz"

    33

            extension-element-prefixes="ns func exsl regexp str dyn"

    34

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

    35

    36

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

    37

     * already parsed by python and presented as a list of

    38

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

    39

     */

    40

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

    41

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

    42

    43

    const "svg_root_id", "/svg:svg/@id";

    44

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

    45

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

    46

    47

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

    48

    49

    const "default_page" choose {

    50

        when "count($hmi_pages) > 1" {

    51

            const "Home_page", 

    52

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

    53

            choose {

    54

                when "$Home_page" > Home

    55

                otherwise {

    56

                    error "No Home page defined!";

    57

                }

    58

            }

    59

        }

    60

        when "count($hmi_pages) = 0" {

    61

            error "No page defined!";

    62

        }

    63

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

    64

    }

    65

    66

    const "_categories" {

    67

        noindex > HMI_ROOT

    68

        noindex > HMI_PLC_STATUS

    69

        noindex > HMI_CURRENT_PAGE

    70

    }

    71

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

    72

    73

    74

    // returns all directly or indirectly refered elements

    75

    def "func:refered_elements" {

    76

        param "elems";

    77

        const "descend", "$elems/descendant-or-self::svg:*";

    78

        const "clones", "$descend[self::svg:use]";

    79

        const "originals", "//svg:*[concat('#',@id) = $clones/@xlink:href]";

    80

        choose {

    81

            when "$originals"

    82

                result "$descend | func:refered_elements($originals)";

    83

            otherwise

    84

                result "$descend";

    85

        }

    86

    }

    87

    89

    90

    // return overlapping geometry for a given element

    91

    // all intersercting element are returned

    92

    // except groups, that must be contained to be counted in

    93

    def "func:overlapping_geometry" {

    94

        param "elt";

    95

        const "groups", "/svg:svg | //svg:g";

    96

        const "g", "$geometry[@Id = $elt/@id]"; 

    97

        const "candidates", "$geometry[@Id != $elt/@id]";

    98

        result """$candidates[(@Id = $groups/@id and (func:intersect($g, .) = 9)) or 

    99

                              (not(@Id = $groups/@id) and (func:intersect($g, .) > 0 ))]""";

   100

    }

   101

   102

    def "func:all_related_elements" {

   103

        param "page";

   104

        const "page_overlapping_geometry", "func:overlapping_geometry($page)";

   105

        const "page_overlapping_elements", "//svg:*[@id = $page_overlapping_geometry/@Id]";

   106

        const "page_sub_elements", "func:refered_elements($page | $page_overlapping_elements)";

   107

        result "$page_sub_elements";

   108

    }

   109

   110

    def "func:required_elements" {

   111

        param "pages"; 

   112

        choose{

   113

            when "$pages"{

   114

                result """func:all_related_elements($pages[1])

   115

                          | func:required_elements($pages[position()!=1])""";

   116

            }otherwise{

   117

                result "/..";

   118

            }

   119

        }

   120

    }

   121

   122

    const "required_elements",

   123

        """//svg:defs/descendant-or-self::svg:*

   124

           | func:required_elements($hmi_pages)/ancestor-or-self::svg:*""";

   125

   126

    const "discardable_elements", "//svg:*[not(@id = $required_elements/@id)]";

   127

   128

    def "func:sumarized_elements" {

   129

        param "elements";

   130

        const "short_list", "$elements[not(ancestor::*/@id = $elements/@id)]";

   131

        const "filled_groups", """$short_list/parent::svg:*[

   132

            not(descendant::*[

   133

                not(self::svg:g) and

   134

                not(@id = $discardable_elements/@id) and

   135

                not(@id = $short_list/descendant-or-self::*[not(self::svg:g)]/@id)

   136

            ])]""";

   137

        const "groups_to_add", "$filled_groups[not(ancestor::*/@id = $filled_groups/@id)]";

   138

        result "$groups_to_add | $short_list[not(ancestor::svg:g/@id = $filled_groups/@id)]";

   139

    }

   140

   141

    def "func:detachable_elements" {

   142

        param "pages";

   143

        choose{

   144

            when "$pages"{

   145

                result """func:sumarized_elements(func:all_related_elements($pages[1]))

   146

                          | func:detachable_elements($pages[position()!=1])""";

   147

            }otherwise{

   148

                result "/..";

   149

            }

   150

        }

   151

    }

   152

   153

    // Avoid nested detachables

   154

    const "_detachable_elements", "func:detachable_elements($hmi_pages)";

   155

    const "detachable_elements", "$_detachable_elements[not(ancestor::*/@id = $_detachable_elements/@id)]";

   156

   157

   158

    //////////////// HMI Tree Index

   159

   160

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

   161

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

   162

   163

    template "*", mode="index" {

   164

        param "index", "0";

   165

        param "parentpath", "''";

   166

        const "content" {

   167

            const "path"

   168

                choose {

   169

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

   170

                    otherwise > «$parentpath»/«@name»

   171

                }

   172

            choose {

   173

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

   174

                    xsl:copy {

   175

                        attrib "index" > «$index»

   176

                        attrib "hmipath" > «$path»

   177

                        foreach "@*" xsl:copy;

   178

                    }

   179

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

   180

                         with "index", "$index + 1";

   181

                         with "parentpath" > «$path»

   182

                    }

   183

                }

   184

                otherwise {

   185

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

   186

                        with "index", "$index";

   187

                        with "parentpath" > «$path»

   188

                    }

   189

                }

   190

            }

   191

        }

   192

   193

        copy "$content";

   194

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

   195

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

   196

            with "parentpath" > «$parentpath»

   197

        }

   198

    }

   199

   200

   201

    def "func:is_descendant_path" {

   202

        param "descend";

   203

        param "ancest";

   204

        result "string-length($ancest) > 0 and starts-with($descend,$ancest)";

   205

    }

   206

   207

    //////////////// Inline SVG

   208

   209

    // Identity template :

   210

    //  - copy every attributes 

   211

    //  - copy every sub-elements

   212

    template "@* | node()", mode="inline_svg" {

   213

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

   214

      if "not(@id = $discardable_elements/@id)"

   215

          xsl:copy apply "@* | node()", mode="inline_svg";

   216

    }

   217

   218

    // replaces inkscape's height and width hints. forces fit

   219

    template "svg:svg/@width", mode="inline_svg";

   220

    template "svg:svg/@height", mode="inline_svg";

   221

    svgtmpl "svg:svg", mode="inline_svg" svg {

   222

        attrib "preserveAspectRatio" > none

   223

        attrib "height" > 100vh

   224

        attrib "width" > 100vw

   225

        apply "@* | node()", mode="inline_svg";

   226

    }

   227

    // ensure that coordinate in CSV file generated by inkscape are in default reference frame

   228

    template "svg:svg[@viewBox!=concat('0 0 ', @width, ' ', @height)]", mode="inline_svg" {

   229

        error > ViewBox settings other than X=0, Y=0 and Scale=1 are not supported

   230

    }

   231

    // ensure that coordinate in CSV file generated by inkscape match svg default unit

   232

    template "sodipodi:namedview[@units!='px' or @inkscape:document-units!='px']", mode="inline_svg" {

   233

        error > All units must be set to "px" in Inkscape's document properties

   234

    }

   235

   236

   237

    //////////////// Clone Unlinking

   238

   239

    // svg:use (inkscape's clones) inside a widgets are

   240

    // replaced by real elements they refer in order to :

   241

    //  - allow finding "needle" element in "meter" widget,

   242

    //    even if "needle" is in a group refered by a svg use.

   243

    //  - if "needle" is visible through a svg:use for

   244

    //    each instance of the widget, then needle would show

   245

    //    the same position in all instances

   246

    //

   247

    // For now, clone unlinkink applies to descendants of all widget except HMI:Page

   248

    // TODO: narrow application of clone unlinking to active elements,

   249

    //       while keeping static decoration cloned

   250

    const "to_unlink", "$hmi_elements[not(@id = $hmi_pages)]//svg:use";

   251

    svgtmpl "svg:use", mode="inline_svg"

   252

    {

   253

        choose {

   254

            when "@id = $to_unlink/@id"

   255

                call "unlink_clone";

   256

            otherwise

   257

                xsl:copy apply "@* | node()", mode="inline_svg";

   258

        }

   259

    }

   260

   261

    // to unlink a clone, an group containing a copy of target element is created

   262

    // that way, style and transforms can be preserved

   263

    const "_excluded_use_attrs" {

   264

        name > href

   265

        name > width

   266

        name > height

   267

        name > x

   268

        name > y

   269

    }

   270

    const "excluded_use_attrs","exsl:node-set($_excluded_use_attrs)";

   271

   272

    svgfunc "unlink_clone"{

   273

        g{

   274

            // include non excluded attributes

   275

            foreach "@*[not(local-name() = $excluded_use_attrs/name)]"

   276

                attrib "{name()}" > «.»

   277

   278

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

   279

            apply "//svg:*[@id = $targetid]", mode="unlink_clone"{

   280

                with "seed","@id";

   281

            }

   282

        }

   283

    }

   284

   285

    // clone unlinking is really similar to deep-copy

   286

    // all nodes are sytematically copied

   287

    svgtmpl "@id", mode="unlink_clone" {

   288

        param "seed";

   289

        attrib "id" > «$seed»_«.»

   290

    }

   291

   292

    svgtmpl "@*", mode="unlink_clone" xsl:copy;

   293

   294

    // copying widgets would have unwanted effect

   295

    // instead widget is refered through a svg:use.

   296

    svgtmpl "svg:*", mode="unlink_clone" {

   297

        param "seed";

   298

        choose {

   299

            // node recursive copy ends when finding a widget

   300

            when "@id = $hmi_elements/@id" {

   301

                // place a clone instead of copying

   302

                use{

   303

                    attrib "xlink:href" > «concat('#',@id)»

   304

                }

   305

            }

   306

            otherwise {

   307

                xsl:copy apply "@* | node()", mode="unlink_clone" {

   308

                    with "seed","$seed";

   309

                }

   310

            }

   311

        }

   312

    }

   313

   314

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

   315

   316

    const "result_svg" apply "/", mode="inline_svg";

   317

    const "result_svg_ns", "exsl:node-set($result_svg)";

   318

   319

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

   320

    template "/" {

   321

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

   322

        /* DEBUG DATA */

   323

        comment {

   324

            apply "$hmi_geometry", mode="testgeo";

   325

        }

   326

        comment {

   327

            apply "$hmitree", mode="testtree";

   328

        }

   329

        comment {

   330

            apply "$indexed_hmitree", mode="testtree";

   331

        }

   332

        comment {

   333

            | Detachable :

   334

            foreach "$detachable_elements"{

   335

                | «@id»

   336

            }

   337

        }

   338

        comment {

   339

            | Discardable :

   340

            foreach "$discardable_elements"{

   341

                | «@id»

   342

            }

   343

        }

   344

        comment {

   345

            | Unlinked :

   346

            foreach "$to_unlink"{

   347

                | «@id»

   348

            }

   349

        }

   350

        /**/

   351

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

   352

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

   353

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

   354

            head;

   355

            body style="margin:0;overflow:hidden;" {

   356

                copy "$result_svg";

   357

                script{

   358

                    call "scripts";

   359

                }

   360

            }

   361

        }

   362

    }

   363

   364

    /*

   365

        Parses:

   366

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

   367

   368

        Into:

   369

        widget type="WidgetType" {

   370

            arg value="param1";

   371

            arg value="param2";

   372

            path value="path1";

   373

            path value="path2";

   374

        }

   375

    */

   376

   377

    def "func:parselabel" {

   378

        param "label";

   379

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

   380

   381

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

   382

        const "args" choose {

   383

            when "$_args" value "$_args";

   384

            otherwise value "$description";

   385

        }

   386

   387

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

   388

        const "type" choose {

   389

            when "$_type" value "$_type";

   390

            otherwise value "$args";

   391

        }

   392

   393

        const "ast" if "$type" widget {

   394

            attrib "type" > «$type»

   395

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

   396

                arg {

   397

                    attrib "value" > «.»

   398

                }

   399

            }

   400

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

   401

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

   402

                if "string-length(.) > 0" path {

   403

                    attrib "value" > «.»

   404

                    const "path", ".";

   405

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

   406

                    if "count($item) = 1"

   407

                        attrib "index" > «$item/@index»

   408

                }

   409

            }

   410

        }

   411

   412

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

   413

    }

   414

   415

    function "scripts"

   416

    {

   417

        | //(function(){

   418

        |

   419

        | id = idstr => document.getElementById(idstr);

   420

        |

   421

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

   422

   423

        /* TODO re-enable

   424

        ||

   425

        function evaluate_js_from_descriptions() {

   426

            var Page;

   427

            var Input;

   428

            var Display;

   429

            var res = [];

   430

        ||

   431

        const "midmark" > \n«$mark»

   432

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

   433

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

   434

              mode="code_from_descs";

   435

        ||

   436

            return res;

   437

        }

   438

        ||

   439

        */

   440

   441

        | var hmi_widgets = {

   442

        foreach "$hmi_elements" {

   443

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

   444

            const "eltid","@id";

   445

        |   "«@id»": {

   446

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

   447

        |     args: [

   448

            foreach "$widget/arg"

   449

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

   450

        |     ],

   451

        |     indexes: [

   452

            foreach "$widget/path" {

   453

                choose {

   454

                    when "not(@index)" {

   455

                        warning > Widget «$widget/@type» id="«$eltid»" : No match for path "«@value»" in HMI tree

   456

                    }

   457

                    otherwise {

   458

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

   459

                    }

   460

                }

   461

            }

   462

        |     ],

   463

        |     element: id("«@id»"),

   464

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

   465

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

   466

        }

   467

        | }

   468

        |

   469

        | var heartbeat_index = «$indexed_hmitree/*[@hmipath = '/HEARTBEAT']/@index»;

   470

        |

   471

        | var hmitree_types = [

   472

   473

        foreach "$indexed_hmitree/*" {

   474

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

   475

        }

   476

   477

        | ]

   478

        |

   479

   480

        | var detachable_elements = {

   481

        foreach "$detachable_elements"{

   482

        |     "«@id»":[id("«@id»"), id("«../@id»")]`if "position()!=last()" > ,`

   483

        }

   484

        | }

   485

   486

        |

   487

        | var page_desc = {

   488