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;

    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"

    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_NODE

    69

        noindex > HMI_PLC_STATUS

    70

        noindex > HMI_CURRENT_PAGE

    71

    }

    72

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

    73

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

    74

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

    75

    76

    77

    // returns all directly or indirectly refered elements

    78

    def "func:refered_elements" {

    79

        param "elems";

    80

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

    81

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

    82

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

    83

        choose {

    84

            when "$originals"

    85

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

    86

            otherwise

    87

                result "$descend";

    88

        }

    89

    }

    90

    91

    def "func:intersect_1d" {

    92

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

    93

        param "a0";

    94

        param "a1";

    95

        param "b0";

    96

        param "b1";

    97

    98

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

    99

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

   100

        choose {

   101

            when "not($d0) and $d1"

   102

                // b contained in a

   103

                //   a0<b0 b1<a1

   104

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

   105

                // b    +--+

   106

                result "3";

   107

            when "$d0 and not($d1)"

   108

                // a contained in b

   109

                //   b0<a0 a1<b1

   110

                // a    +--+

   111

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

   112

                result "2";

   113

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

   114

                // a and b are overlapped 

   115

                //   b0<a0<b1<a1

   116

                // a    +-----+

   117

                // b +-----+

   118

                result "1";

   119

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

   120

                // a and b are overlapped

   121

                //   a0<b0<a1<b1

   122

                // a +-----+

   123

                // b    +-----+

   124

                result "1";

   125

            otherwise

   126

                result "0"; /* no intersection*/

   127

        }

   128

    }

   129

   130

    // returns :

   131

    // 0 - no intersection

   132

    //            .-----.

   133

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

   134

    //    |     | |     |

   135

    //    |     | '-----'

   136

    //    |a    |

   137

    //    '-----'

   138

    //

   139

    // 1 - overlapping

   140

    //        .-----.

   141

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

   142

    //    |   |  |  |

   143

    //    |   '-----'

   144

    //    |a     |

   145

    //    '------'

   146

    //

   147

    // 2 - overlapping

   148

    //        .-----.

   149

    //        |  a  |

   150

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

   151

    //    |   '-----'   |

   152

    //    | b           |

   153

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

   154

    //

   155

    // 3 - overlapping

   156

    //        .-----.

   157

    //        |  b  |

   158

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

   159

    //    |   '-----'   |

   160

    //    | a           |

   161

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

   162

    //

   163

    // 4 - a contained in b

   164

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

   165

    //    |   .-----.   |

   166

    //    |   |  a  |   |

   167

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

   168

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

   169

    //

   170

    // 6 - overlapping

   171

    //        .----.

   172

    //        |   b|

   173

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

   174

    //    |a  |    |   |

   175

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

   176

    //        '----'

   177

    //

   178

    // 9 - b contained in a

   179

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

   180

    //    |   .-----.   |

   181

    //    |   |  b  |   |

   182

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

   183

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

   184

    //

   185

    def "func:intersect" {

   186

        param "a";

   187

        param "b";

   188

   189

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

   190

   191

        choose{

   192

            when "$x_intersect != 0"{

   193

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

   194

                result "$x_intersect * $y_intersect";

   195

            }

   196

            otherwise result "0";

   197

        }

   198

    }

   199

   200

    // return overlapping geometry for a given element

   201

    // all intersercting element are returned

   202

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

   203

    def "func:overlapping_geometry" {

   204

        param "elt";

   205

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

   206

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

   207

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

   208

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

   209

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

   210

    }

   211

   212

    def "func:all_related_elements" {

   213

        param "page";

   214

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

   215

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

   216

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

   217

        result "$page_sub_elements";

   218

    }

   219

   220

    def "func:required_elements" {

   221

        param "pages"; 

   222

        choose{

   223

            when "$pages"{

   224

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

   225

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

   226

            }otherwise{

   227

                result "/..";

   228

            }

   229

        }

   230

    }

   231

   232

    const "required_elements",

   233

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

   234

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

   235

   236

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

   237

   238

    def "func:sumarized_elements" {

   239

        param "elements";

   240

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

   241

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

   242

            not(descendant::*[

   243

                not(self::svg:g) and

   244

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

   245

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

   246

            ])]""";

   247

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

   248

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

   249

    }

   250

   251

    def "func:detachable_elements" {

   252

        param "pages";

   253

        choose{

   254

            when "$pages"{

   255

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

   256

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

   257

            }otherwise{

   258

                result "/..";

   259

            }

   260

        }

   261

    }

   262

   263

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

   264

   265

   266

   267

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

   268

   269

    template "*", mode="index" {

   270

        param "index", "0";

   271

        param "parentpath", "''";

   272

        const "content" {

   273

            const "path"

   274

                choose {

   275

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

   276

                    otherwise > «$parentpath»/«@name»

   277

                }

   278

            choose {

   279

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

   280

                    xsl:copy {

   281

                        attrib "index" > «$index»

   282

                        attrib "hmipath" > «$path»

   283

                        foreach "@*" xsl:copy;

   284

                    }

   285

                    /* no node expected below value nodes */

   286

                }

   287

                otherwise {

   288

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

   289

                        with "index", "$index";

   290

                        with "parentpath" > «$path»

   291

                    }

   292

                }

   293

            }

   294

        }

   295

   296

        copy "$content";

   297

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

   298

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

   299

            with "parentpath" > «$parentpath»

   300

        }

   301

    }

   302

   303

   304

   305

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

   306

   307

    // Identity template :

   308

    //  - copy every attributes 

   309

    //  - copy every sub-elements

   310

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

   311

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

   312

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

   313

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

   314

    }

   315

   316

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

   317

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

   318

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

   319

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

   320

        attrib "preserveAspectRatio" > none

   321

        attrib "height" > 100vh

   322

        attrib "width" > 100vw

   323

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

   324

    }

   325

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

   326

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

   327

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

   328

    }

   329

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

   330

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

   331

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

   332

    }

   333

   411

   412

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

   413

   417

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

   418

    template "/" {

   419

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

   420

        /* DEBUG DATA */

   421

        comment {

   422

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

   423

        }

   424

        comment {

   425

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

   426

        }

   427

        comment {

   428

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

   429

        }

   430

        comment {

   431

            | Detachable :

   432

            foreach "$detachable_elements"{

   433

                | «@id»

   434

            }

   435

        }

   436

        comment {

   437

            | Discardable :

   438

            foreach "$discardable_elements"{

   439

                | «@id»

   440

            }

   441

        }

   448

        /**/

   449

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

   450

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

   451

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

   452

            head;

   453

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

   455

                script{

   456

                    call "scripts";

   457

                }

   458

            }

   459

        }

   460

    }

   461

   462

    /*

   463

        Parses:

   464

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

   465

   466

        Into:

   467

        widget type="WidgetType" {

   468

            arg value="param1";

   469

            arg value="param2";

   470

            path value="path1";

   471

            path value="path2";

   472

        }

   473

    */

   474

   475

    def "func:parselabel" {

   476

        param "label";

   477

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

   478

   479

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

   480

        const "args" choose {

   481

            when "$_args" value "$_args";

   482

            otherwise value "$description";

   483

        }

   484

   485

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

   486

        const "type" choose {

   487

            when "$_type" value "$_type";

   488

            otherwise value "$args";

   489

        }

   490