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

!debug_output_calls = []

    21

    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

    83

    include geometry.ysl2

    84

    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

   142

    include hmi_tree.ysl2

   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

   265

   266

        // use python to call all debug output from included definitions

   270

        comment {

   271

            | Detachable :

   272

            foreach "$detachable_elements"{

   273

                | «@id»

   274

            }

   275

        }

   276

        comment {

   277

            | Discardable :

   278

            foreach "$discardable_elements"{

   279

                | «@id»

   280

            }

   281

        }

   282

        comment {

   283

            | Unlinked :

   284

            foreach "$to_unlink"{

   285

                | «@id»

   286

            }

   287

        }

   288

        /**/

   289

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

   290

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

   291

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

   292

            head;

   293

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

   294

                copy "$result_svg";

   295

                script{

   296

                    call "scripts";

   297

                }

   298

            }

   299

        }

   300

    }

   301

   302

    /*

   303

        Parses:

   304

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

   305

   306

        Into:

   307

        widget type="WidgetType" {

   308

            arg value="param1";

   309

            arg value="param2";

   310

            path value="path1";

   311

            path value="path2";

   312

        }

   313

    */

   314

   315

    def "func:parselabel" {

   316

        param "label";

   317

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

   318

   319

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

   320

        const "args" choose {

   321

            when "$_args" value "$_args";

   322

            otherwise value "$description";

   323

        }

   324

   325

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

   326

        const "type" choose {

   327

            when "$_type" value "$_type";

   328

            otherwise value "$args";

   329

        }

   330

   331

        const "ast" if "$type" widget {

   332

            attrib "type" > «$type»

   333

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

   334

                arg {

   335

                    attrib "value" > «.»

   336

                }

   337

            }

   338

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

   339

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

   340

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

   341

                    attrib "value" > «.»

   342

                    const "path", ".";

   343

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

   344

                    if "count($item) = 1"

   345

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

   346

                }

   347

            }

   348

        }

   349

   350

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

   351

    }

   352

   353

    function "scripts"

   354

    {

   355

        | //(function(){

   356

        |

   357

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

   358

        |

   359

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

   360

   361

        /* TODO re-enable

   362

        ||

   363

        function evaluate_js_from_descriptions() {

   364

            var Page;

   365

            var Input;

   366

            var Display;

   367

            var res = [];

   368

        ||

   369

        const "midmark" > \n«$mark»

   370

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

   371

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

   372

              mode="code_from_descs";

   373

        ||

   374

            return res;

   375

        }

   376

        ||

   377

        */

   378

   379

        | var hmi_widgets = {

   380

        foreach "$hmi_elements" {

   381

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

   382

            const "eltid","@id";

   383

        |   "«@id»": {

   384

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

   385

        |     args: [

   386

            foreach "$widget/arg"

   387

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

   388

        |     ],

   389

        |     indexes: [

   390

            foreach "$widget/path" {

   391

                choose {

   392

                    when "not(@index)" {

   393

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

   394

                    }

   395

                    otherwise {

   396

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

   397

                    }

   398

                }

   399

            }

   400

        |     ],

   401

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

   402

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

   403

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

   404

        }

   405

        | }

   406

        |

   407

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

   408

        |

   409

        | var hmitree_types = [

   410

   411

        foreach "$indexed_hmitree/*" {

   412

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

   413

        }

   414

   415

        | ]

   416

        |

   417

   418

        | var detachable_elements = {

   419

        foreach "$detachable_elements"{

   420

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

   421

        }

   422

        | }

   423

   424

        |

   425

        | var page_desc = {

   426

   427

        foreach "$hmi_pages" {

   428

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

   429

            const "page", ".";

   430

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

   431

   432

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

   433

   434

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

   435

   436

            const "page_relative_widgets",

   437

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

   438

   439

            // Take closest ancestor in detachable_elements

   440

            // since nested detachable elements are filtered out

   441

            const "required_detachables", 

   442

                """func:sumarized_elements($page_all_elements)/

   443

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

   444

   445

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

   446

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

   447

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

   448

            if "$desc/path/@value" {

   449

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

   450

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

   451

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

   452

            }

   453

            |     relative_widgets: [

   454

            foreach "$page_relative_widgets" {

   455

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

   456

            }

   457

            |     ],

   458

            |     absolute_widgets: [

   459

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

   460

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

   461

            }

   462

            |     ],

   463

            |     required_detachables: {

   464

            foreach "$required_detachables" {

   465

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

   466

            }

   467

            |     }

   468

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

   469

        }

   470

        | }

   471

   472

        |

   473

        | var default_page = "«$default_page»";

   474

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

   475

        include text svghmi.js

   476

        | //})();

   477

    }

   478

   479

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

   480

    //     ||

   481

    //     {

   482

    //         var path, role, name, priv;

   483

    //         var id = "«@id»";

   484

    //     ||

   485

   486

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

   487

    //     if "@inkscape:label"

   488