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

    88

    def "func:intersect_1d" {

    89

        // it is assumed that a1 > a0 and b1 > b0

    90

        param "a0";

    91

        param "a1";

    92

        param "b0";

    93

        param "b1";

    94

    95

        const "d0", "$a0 >= $b0";

    96

        const "d1", "$a1 >= $b1";

    97

        choose {

    98

            when "not($d0) and $d1"

    99

                // b contained in a

   100

                //   a0<b0 b1<a1

   101

                // a +--------+

   102

                // b    +--+

   103

                result "3";

   104

            when "$d0 and not($d1)"

   105

                // a contained in b

   106

                //   b0<a0 a1<b1

   107

                // a    +--+

   108

                // b +--------+

   109

                result "2";

   110

            when "$d0 and $d1 and $a0 < $b1"

   111

                // a and b are overlapped 

   112

                //   b0<a0<b1<a1

   113

                // a    +-----+

   114

                // b +-----+

   115

                result "1";

   116

            when "not($d0) and not($d1) and $b0 < $a1"

   117

                // a and b are overlapped

   118

                //   a0<b0<a1<b1

   119

                // a +-----+

   120

                // b    +-----+

   121

                result "1";

   122

            otherwise

   123

                result "0"; /* no intersection*/

   124

        }

   125

    }

   126

   127

    // returns :

   128

    // 0 - no intersection

   129

    //            .-----.

   130

    //    .-----. |    b|

   131

    //    |     | |     |

   132

    //    |     | '-----'

   133

    //    |a    |

   134

    //    '-----'

   135

    //

   136

    // 1 - overlapping

   137

    //        .-----.

   138

    //    .---|--. b|

   139

    //    |   |  |  |

   140

    //    |   '-----'

   141

    //    |a     |

   142

    //    '------'

   143

    //

   144

    // 2 - overlapping

   145

    //        .-----.

   146

    //        |  a  |

   147

    //    .---|-----|---.

   148

    //    |   '-----'   |

   149

    //    | b           |

   150

    //    '-------------'

   151

    //

   152

    // 3 - overlapping

   153

    //        .-----.

   154

    //        |  b  |

   155

    //    .---|-----|---.

   156

    //    |   '-----'   |

   157

    //    | a           |

   158

    //    '-------------'

   159

    //

   160

    // 4 - a contained in b

   161

    //    .-------------.

   162

    //    |   .-----.   |

   163

    //    |   |  a  |   |

   164

    //    |b  '-----'   |

   165

    //    '-------------'

   166

    //

   167

    // 6 - overlapping

   168

    //        .----.

   169

    //        |   b|

   170

    //    .---|----|---.

   171

    //    |a  |    |   |

   172

    //    '---|----|---'

   173

    //        '----'

   174

    //

   175

    // 9 - b contained in a

   176

    //    .-------------.

   177

    //    |   .-----.   |

   178

    //    |   |  b  |   |

   179

    //    |a  '-----'   |

   180

    //    '-------------'

   181

    //

   182

    def "func:intersect" {

   183

        param "a";

   184

        param "b";

   185

   186

        const "x_intersect", "func:intersect_1d($a/@x, $a/@x+$a/@w, $b/@x, $b/@x+$b/@w)";

   187

   188

        choose{

   189

            when "$x_intersect != 0"{

   190

                const "y_intersect", "func:intersect_1d($a/@y, $a/@y+$a/@h, $b/@y, $b/@y+$b/@h)";

   191

                result "$x_intersect * $y_intersect";

   192

            }

   193

            otherwise result "0";

   194

        }

   195

    }

   196

   197

    // return overlapping geometry for a given element

   198

    // all intersercting element are returned

   199

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

   200

    def "func:overlapping_geometry" {

   201

        param "elt";

   202

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

   203

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

   204

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

   205

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

   206

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

   207

    }

   208

   209

    def "func:all_related_elements" {

   210

        param "page";

   211

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

   212

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

   213

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

   214

        result "$page_sub_elements";

   215

    }

   216

   217

    def "func:required_elements" {

   218

        param "pages"; 

   219

        choose{

   220

            when "$pages"{

   221

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

   222

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

   223

            }otherwise{

   224

                result "/..";

   225

            }

   226

        }

   227

    }

   228

   229

    const "required_elements",

   230

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

   231

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

   232

   233

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

   234

   235

    def "func:sumarized_elements" {

   236

        param "elements";

   237

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

   238

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

   239

            not(descendant::*[

   240

                not(self::svg:g) and

   241

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

   242

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

   243

            ])]""";

   244

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

   245

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

   246

    }

   247

   248

    def "func:detachable_elements" {

   249

        param "pages";

   250

        choose{

   251

            when "$pages"{

   252

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

   253

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

   254

            }otherwise{

   255

                result "/..";

   256

            }

   257

        }

   258

    }

   259

   260

    // Avoid nested detachables

   261

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

   262

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

   263

   265

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

   266

   270

    template "*", mode="index" {

   271

        param "index", "0";

   272

        param "parentpath", "''";

   273

        const "content" {

   274

            const "path"

   275

                choose {

   276

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

   277

                    otherwise > «$parentpath»/«@name»

   278

                }

   279

            choose {

   280

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

   281

                    xsl:copy {

   282

                        attrib "index" > «$index»

   283

                        attrib "hmipath" > «$path»

   284

                        foreach "@*" xsl:copy;

   285

                    }

   286

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

   287

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

   288

                         with "parentpath" > «$path»

   289

                    }

   290

                }

   291

                otherwise {

   292

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

   293

                        with "index", "$index";

   294

                        with "parentpath" > «$path»

   295

                    }

   296

                }

   297

            }

   298

        }

   299

   300

        copy "$content";

   301

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

   302

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

   303

            with "parentpath" > «$parentpath»

   304

        }

   305

    }

   306

   307

   308

   309

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

   310

   311

    // Identity template :

   312

    //  - copy every attributes 

   313

    //  - copy every sub-elements

   314

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

   315

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

   316

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

   317

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

   318

    }

   319

   320

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

   321

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

   322

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

   323

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

   324

        attrib "preserveAspectRatio" > none

   325

        attrib "height" > 100vh

   326

        attrib "width" > 100vw

   327

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

   328

    }

   329

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

   330

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

   331

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

   332

    }

   333

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

   334

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

   335

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

   336

    }

   337

   338

   339

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

   340

   341

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

   342

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

   343

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

   344

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

   345

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

   346

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

   347

    //    the same position in all instances

   348

    //

   349

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

   350

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

   351

    //       while keeping static decoration cloned

   352

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

   353

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

   354

    {

   355

        choose {

   356

            when "@id = $to_unlink/@id"

   357

                call "unlink_clone";

   358

            otherwise

   359

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

   360

        }

   361

    }

   362

   363

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

   364

    // that way, style and transforms can be preserved

   365

    const "_excluded_use_attrs" {

   366

        name > href

   367

        name > width

   368

        name > height

   369

        name > x

   370

        name > y

   371

    }

   372

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

   373

   374

    svgfunc "unlink_clone"{

   375

        g{

   376

            // include non excluded attributes

   377

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

   378

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

   379

   380

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

   381

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

   382

                with "seed","@id";

   383

            }

   384

        }

   385

    }

   386

   387

    // clone unlinking is really similar to deep-copy

   388

    // all nodes are sytematically copied

   389

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

   390

        param "seed";

   391

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

   392

    }

   393

   394

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

   395

   396

    // copying widgets would have unwanted effect

   397

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

   398

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

   399

        param "seed";

   400

        choose {

   401

            // node recursive copy ends when finding a widget

   402

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

   403

                // place a clone instead of copying

   404

                use{

   405

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

   406

                }

   407

            }

   408

            otherwise {

   409

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

   410

                    with "seed","$seed";

   411

                }

   412

            }

   413

        }

   414

    }

   415

   416

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

   417

   418

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

   419

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

   420

   421

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

   422

    template "/" {

   423

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

   424

        /* DEBUG DATA */

   425

        comment {

   426

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

   427

        }

   428

        comment {

   429

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

   430

        }

   431

        comment {

   432

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

   433

        }

   434

        comment {

   435

            | Detachable :

   436

            foreach "$detachable_elements"{

   437

                | «@id»

   438

            }

   439

        }

   440

        comment {

   441

            | Discardable :

   442

            foreach "$discardable_elements"{

   443

                | «@id»

   444

            }

   445

        }

   446

        comment {

   447

            | Unlinked :

   448

            foreach "$to_unlink"{

   449

                | «@id»

   450

            }

   451

        }

   452

        /**/

   453

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

   454

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

   455

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

   456

            head;

   457

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

   458

                copy "$result_svg";

   459

                script{

   460

                    call "scripts";

   461

                }

   462

            }

   463

        }

   464

    }

   465

   466

    /*

   467

        Parses:

   468

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

   469

   470

        Into:

   471

        widget type="WidgetType" {

   472

            arg value="param1";

   473

            arg value="param2";

   474

            path value="path1";

   475

            path value="path2";

   476

        }

   477

    */

   478

   479

    def "func:parselabel" {

   480

        param "label";

   481

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

   482

   483

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

   484

        const "args" choose {

   485

            when "$_args" value "$_args";

   486

            otherwise value "$description";

   487

        }

   488

   489

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

   490

        const "type" choose {