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

    22

istylesheet

    23

            /* From Inkscape */

    24

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

    25

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

    26

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

    27

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

    28

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

    29

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

    30

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

    31

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

    32

    33

            /* Our namespace to invoke python code */

    34

            xmlns:ns="beremiz"

    35

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

    36

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

    37

    38

    39

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

    40

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

    41

    42

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

    43

    44

    const "default_page" choose {

    45

        when "count($hmi_pages) > 1" {

    46

            const "Home_page", 

    47

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

    48

            choose {

    49

                when "$Home_page" > Home

    50

                otherwise {

    51

                    error "No Home page defined!";

    52

                }

    53

            }

    54

        }

    55

        when "count($hmi_pages) = 0" {

    56

            error "No page defined!";

    57

        }

    58

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

    59

    }

    60

    61

    const "_categories" {

    62

        noindex > HMI_ROOT

    63

        noindex > HMI_PLC_STATUS

    64

        noindex > HMI_CURRENT_PAGE

    65

    }

    66

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

    67

    68

    69

    // returns all directly or indirectly refered elements

    70

    def "func:refered_elements" {

    71

        param "elems";

    72

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

    73

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

    74

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

    75

        choose {

    76

            when "$originals"

    77

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

    78

            otherwise

    79

                result "$descend";

    80

        }

    81

    }

    82

    85

    86

    def "func:all_related_elements" {

    87

        param "page";

    88

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

    89

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

    90

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

    91

        result "$page_sub_elements";

    92

    }

    93

    94

    def "func:required_elements" {

    95

        param "pages"; 

    96

        choose{

    97

            when "$pages"{

    98

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

    99

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

   100

            }otherwise{

   101

                result "/..";

   102

            }

   103

        }

   104

    }

   105

   106

    const "required_elements",

   107

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

   108

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

   109

   110

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

   111

   112

    def "func:sumarized_elements" {

   113

        param "elements";

   114

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

   115

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

   116

            not(descendant::*[

   117

                not(self::svg:g) and

   118

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

   119

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

   120

            ])]""";

   121

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

   122

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

   123

    }

   124

   125

    def "func:detachable_elements" {

   126

        param "pages";

   127

        choose{

   128

            when "$pages"{

   129

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

   130

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

   131

            }otherwise{

   132

                result "/..";

   133

            }

   134

        }

   135

    }

   136

   137

    // Avoid nested detachables

   138

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

   139

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

   140

   141

   143

   144

   145

    def "func:is_descendant_path" {

   146

        param "descend";

   147

        param "ancest";

   148

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

   149

    }

   150

   151

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

   152

   153

    // Identity template :

   154

    //  - copy every attributes 

   155

    //  - copy every sub-elements

   156

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

   157

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

   158

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

   159

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

   160

    }

   161

   162

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

   163

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

   164

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

   165

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

   166

        attrib "preserveAspectRatio" > none

   167

        attrib "height" > 100vh

   168

        attrib "width" > 100vw

   169

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

   170

    }

   171

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

   172

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

   173

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

   174

    }

   175

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

   176

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

   177

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

   178

    }

   179

   180

   181

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

   182

   183

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

   184

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

   185

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

   186

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

   187

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

   188

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

   189

    //    the same position in all instances

   190

    //

   191

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

   192

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

   193

    //       while keeping static decoration cloned

   194

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

   195

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

   196

    {

   197

        choose {

   198

            when "@id = $to_unlink/@id"

   199

                call "unlink_clone";

   200

            otherwise

   201

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

   202

        }

   203

    }

   204

   205

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

   206

    // that way, style and transforms can be preserved

   207

    const "_excluded_use_attrs" {

   208

        name > href

   209

        name > width

   210

        name > height

   211

        name > x

   212

        name > y

   213

    }

   214

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

   215

   216

    svgfunc "unlink_clone"{

   217

        g{

   218

            // include non excluded attributes

   219

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

   220

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

   221

   222

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

   223

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

   224

                with "seed","@id";

   225

            }

   226

        }

   227

    }

   228

   229

    // clone unlinking is really similar to deep-copy

   230

    // all nodes are sytematically copied

   231

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

   232

        param "seed";

   233

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

   234

    }

   235

   236

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

   237

   238

    // copying widgets would have unwanted effect

   239

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

   240

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

   241

        param "seed";

   242

        choose {

   243

            // node recursive copy ends when finding a widget

   244

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

   245

                // place a clone instead of copying

   246

                use{

   247

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

   248

                }

   249

            }

   250

            otherwise {

   251

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

   252

                    with "seed","$seed";

   253

                }

   254

            }

   255

        }

   256

    }

   257

   258

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

   259

   260

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

   261

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

   262

   263

    template "/" {

   264

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

   271

        comment {

   272

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

   273

        }

   274

        comment {

   275

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

   276

        }

   277

        comment {

   278

            | Detachable :

   279

            foreach "$detachable_elements"{

   280

                | «@id»

   281

            }

   282

        }

   283

        comment {

   284

            | Discardable :

   285

            foreach "$discardable_elements"{

   286

                | «@id»

   287

            }

   288

        }

   289

        comment {

   290

            | Unlinked :

   291

            foreach "$to_unlink"{

   292

                | «@id»

   293

            }

   294

        }

   295

        /**/

   296

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

   297

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

   298

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

   299

            head;

   300

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

   301

                copy "$result_svg";

   302

                script{

   303

                    call "scripts";

   304

                }

   305

            }

   306

        }

   307

    }

   308

   309

    /*

   310

        Parses:

   311

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

   312

   313

        Into:

   314

        widget type="WidgetType" {

   315

            arg value="param1";

   316

            arg value="param2";

   317

            path value="path1";

   318

            path value="path2";

   319

        }

   320

    */

   321

   322

    def "func:parselabel" {

   323

        param "label";

   324

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

   325

   326

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

   327

        const "args" choose {

   328

            when "$_args" value "$_args";

   329

            otherwise value "$description";

   330

        }

   331

   332

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

   333

        const "type" choose {

   334

            when "$_type" value "$_type";

   335

            otherwise value "$args";

   336

        }

   337

   338

        const "ast" if "$type" widget {

   339

            attrib "type" > «$type»

   340

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

   341

                arg {

   342

                    attrib "value" > «.»

   343

                }

   344

            }

   345

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

   346

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

   347

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

   348

                    attrib "value" > «.»

   349

                    const "path", ".";

   350

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

   351

                    if "count($item) = 1"

   352

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

   353

                }

   354

            }

   355

        }

   356

   357

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

   358

    }

   359

   360

    function "scripts"

   361

    {

   362

        | //(function(){

   363

        |

   364

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

   365

        |

   366

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

   367

   368

        /* TODO re-enable

   369

        ||

   370

        function evaluate_js_from_descriptions() {

   371

            var Page;

   372

            var Input;

   373

            var Display;

   374

            var res = [];

   375

        ||

   376

        const "midmark" > \n«$mark»

   377

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

   378

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

   379

              mode="code_from_descs";

   380

        ||

   381

            return res;

   382

        }

   383

        ||

   384

        */

   385

   386

        | var hmi_widgets = {

   387

        foreach "$hmi_elements" {

   388

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

   389

            const "eltid","@id";

   390

        |   "«@id»": {

   391

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

   392

        |     args: [

   393

            foreach "$widget/arg"

   394

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

   395

        |     ],

   396

        |     indexes: [

   397

            foreach "$widget/path" {

   398

                choose {

   399

                    when "not(@index)" {

   400

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

   401

                    }

   402

                    otherwise {

   403

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

   404

                    }

   405

                }

   406

            }

   407

        |     ],

   408

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

   409

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

   410

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

   411

        }

   412

        | }

   413

        |

   414

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

   415

        |

   416

        | var hmitree_types = [

   417

   418

        foreach "$indexed_hmitree/*" {

   419

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

   420

        }

   421

   422

        | ]

   423

        |

   424

   425

        | var detachable_elements = {

   426

        foreach "$detachable_elements"{

   427

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

   428

        }

   429

        | }

   430

   431

        |

   432

        | var page_desc = {

   433

   434

        foreach "$hmi_pages" {

   435

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

   436

            const "page", ".";

   437

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

   438

   439

            const "page_all_elements", "func:all_related_elements($page)";

   440

   441

            const "all_page_widgets","$hmi_elements[@id = $page_all_elements/@id and @id != $page/@id]";

   442

   443

            const "page_relative_widgets",

   444

                "$all_page_widgets[func:is_descendant_path(func:parselabel(@inkscape:label)/widget/path/@value, $desc/path/@value)]";

   445

   446

            // Take closest ancestor in detachable_elements

   447

            // since nested detachable elements are filtered out

   448

            const "required_detachables", 

   449

                """func:sumarized_elements($page_all_elements)/

   450

                   ancestor-or-self::*[@id = $detachable_elements/@id]""";

   451

   452

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

   453

            |     widget: hmi_widgets["«@id»"],

   454

            |     bbox: [«$p/@x», «$p/@y», «$p/@w», «$p/@h»],

   455

            if "$desc/path/@value" {

   456

                if "count($desc/path/@index)=0"

   457

                    warning > Page id="«$page/@id»" : No match for path "«$desc/path/@value»" in HMI tree

   458

            |     page_index: «$desc/path/@index»,

   459

            }

   460

            |     relative_widgets: [

   461

            foreach "$page_relative_widgets" {

   462

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

   463

            }

   464

            |     ],

   465

            |     absolute_widgets: [

   466

            foreach "$all_page_widgets[not(@id = $page_relative_widgets/@id)]" {

   467

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

   468

            }

   469

            |     ],

   470

            |     required_detachables: {

   471

            foreach "$required_detachables" {

   472

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

   473

            }

   474

            |     }

   475

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

   476

        }

   477

        | }

   478

   479

        |

   480

        | var default_page = "«$default_page»";

   481

        | var svg_root = id("«$svg_root_id»");

   482

        include text svghmi.js

   483

        | //})();

   484

    }

   485

   486

    // template "*", mode="code_from_descs" {

   487

    //     ||

   488