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

    19

istylesheet

    20

            /* From Inkscape */

    21

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

    22

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

    23

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

    24

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

    25

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

    26

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

    27

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

    28

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

    29

    30

            /* Our namespace to invoke python code */

    31

            xmlns:ns="beremiz"

    32

            extension-element-prefixes="ns func"

    33

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

    34

    35

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

    36

     * already parsed by python and presented as a list of

    37

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

    38

     */

    39

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

    40

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

    41

    42

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

    43

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

    44

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

    45

    46

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

    47

    48

    const "default_page" choose {

    49

        when "count($hmi_pages) > 1" {

    50

            const "Home_page", 

    51

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

    52

            choose {

    53

                when "$Home_page" > Home

    54

                otherwise {

    55

                    error "No Home page defined!";

    56

                }

    57

            }

    58

        }

    59

        when "count($hmi_pages) = 0" {

    60

            error "No page defined!";

    61

        }

    62

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

    63

    }

    64

    65

    const "_categories" {

    66

        noindex > HMI_ROOT

    67

        noindex > HMI_NODE

    68

        noindex > HMI_PLC_STATUS

    69

        noindex > HMI_CURRENT_PAGE

    70

    }

    71

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

    72

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

    73

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

    74

    75

    76

    // returns all directly or indirectly refered elements

    77

    def "func:refered_elements" {

    78

        param "elems";

    79

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

    80

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

    81

        // TODO optimize using Xpath' id()

    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

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

   204

   205

    def "func:overlapping_geometry" {

   206

        param "elt";

   207

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

   208

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

   209

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

   210

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

   211

    }

   212

   213

    def "func:all_related_elements" {

   214

        param "page";

   215

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

   216

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

   217

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

   218

        result "$page_sub_elements";

   219

    }

   220

   221

    def "func:required_elements" {

   222

        param "pages"; 

   223

        choose{

   224

            when "$pages"{

   225

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

   226

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

   227

            }otherwise{

   228

                result "/..";

   229

            }

   230

        }

   231

    }

   232

   233

    const "required_elements", 

   234

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

   235

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

   236

   237

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

   238

   239

    def "func:sumarized_elements" {

   240

        param "elements";

   241

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

   242

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

   243

            not(descendant::*[

   244

                not(self::svg:g) and 

   245

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

   246

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

   247

            ])]""";

   248

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

   249

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

   250

    }

   251

   252

    def "func:detachable_elements" {

   253

        param "pages"; 

   254

        choose{

   255

            when "$pages"{

   256

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

   257

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

   258

            }otherwise{

   259

                result "/..";

   260

            }

   261

        }

   262

    }

   263

   264

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

   265

    // const "essential_elements", "$detachable_elements | /svg:svg/svg:defs";

   266

    // const "required_elements", "$essential_elements//svg:* | $essential_elements/ancestor-or-self::svg:*";

   267

   268

    template "*", mode="index" {

   269

        param "index", "0";

   270

        param "parentpath", "''";

   271

        const "content" {

   272

            const "path"

   273

                choose {

   274

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

   275

                    otherwise > «$parentpath»/«@name»

   276

                }

   277

            choose {

   278

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

   279

                    xsl:copy {

   280

                        attrib "index" > «$index»

   281

                        attrib "hmipath" > «$path»

   282

                        foreach "@*" xsl:copy;

   283

                    }

   284

                    /* no node expected below value nodes */

   285

                }

   286

                otherwise {

   287

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

   288

                        with "index", "$index";

   289

                        with "parentpath" > «$path»

   290

                    }

   291

                }

   292

            }

   293

        }

   294

   295

        copy "$content";

   296

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

   297

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

   298

            with "parentpath" > «$parentpath»

   299

        }

   300

    }

   301

   302

    /* Identity template :

   303

     *  - copy every attributes 

   304

     *  - copy every sub-elements

   305

     */

   306

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

   307

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

   308

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

   309

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

   310

    }

   311

   312

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

   313

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

   314

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

   315

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

   316

        attrib "preserveAspectRatio" > none

   317

        attrib "height" > 100vh

   318

        attrib "width" > 100vw

   319

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

   320

    }

   321

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

   322

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

   323

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

   324

    }

   325

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

   326

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

   327

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

   328

    }

   329

   330

   331

    //// Commented out before implementing runtime DOM remove/append on page switch - would have side effect

   332

    ////

   333

    //// /* clone unlinkink until widget for better perf with webkit */

   334

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

   335

    //// {

   336

    ////     g{

   337

    ////         attrib "style" > «@style»

   338

    ////         attrib "transform" > «@transform»

   339

    ////         /* keep same id and label in case it is a widget */

   340

    ////         //attrib "inkscape:label","@inkscape:label";

   341

    ////         attrib "id" > «@id»

   342

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

   343

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

   344

    ////     }

   345

    //// }

   346

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

   347

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

   348

    ////     choose {

   349

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

   350

    ////             use{

   351

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

   352

    ////             }

   353

    ////         }

   354

    ////         otherwise {

   355

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

   356

    ////         }

   357

    ////     }

   358

    //// }

   359

   360

    // template "svg:use/@style", mode="inline_svg"{

   361

    //     attrib "style" > all:initial;

   362

    //     //«.»

   363

    // }

   364

   365

    // template "svg:*[concat('#',@id) = //svg:use/@xlink:href]/@style", mode="inline_svg"{

   366

    //     attrib "style" > all:unset;

   367

    //     //«.»

   368

    // }

   369

   370

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

   371

   372

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

   373

    template "/" { 

   374

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

   375

        /* DEBUG DATA */

   376

        comment {

   377

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

   378

        }

   379

        comment {

   380

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

   381

        }

   382

        comment {

   383

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

   384

        }

   385

        comment {

   386

            | Detachable :

   387

            foreach "$detachable_elements"{

   388

                | «@id»

   389

            }

   390

        }

   391

        comment {

   392

            | Discardable :

   393

            foreach "$discardable_elements"{

   394

                | «@id»

   395

            }

   396

        }

   397

        /**/

   398

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

   399

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

   400

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

   401

            head;

   402

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

   403

                apply "svg:svg", mode="inline_svg";

   404

                script{

   405

                    call "scripts";

   406

                }

   407

            }

   408

        }

   409

    }

   410

   411

    /*

   412

        Parses:

   413

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

   414

   415

        Into:

   416

        widget type="WidgetType" {

   417

            arg value="param1";

   418

            arg value="param2";

   419

            path value="path1";

   420

            path value="path2";

   421

        }

   422

    */

   423

   424

    def "func:parselabel" {

   425

        param "label";

   426

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

   427

   428

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

   429

        const "args" choose {

   430

            when "$_args" value "$_args";

   431

            otherwise value "$description";

   432

        }

   433

   434

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

   435

        const "type" choose {

   436

            when "$_type" value "$_type";

   437

            otherwise value "$args";

   438

        }

   439

   440

        const "ast" if "$type" widget {

   441

            attrib "type" > «$type»

   442

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

   443

                arg {

   444

                    attrib "value" > «.»

   445

                }

   446

            }

   447

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

   448

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

   449

                path {

   450

                    attrib "value" > «.»

   451

                }

   452

            }

   453

        }

   454

   455

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

   456

    }

   457

   458

    function "scripts"

   459

    {

   460

        | //(function(){

   461

        |

   462

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

   463

        |

   464

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

   465

   466

        /* TODO re-enable

   467

        ||

   468

        function evaluate_js_from_descriptions() {

   469

            var Page;

   470

            var Input;

   471

            var Display;

   472

            var res = [];

   473

        ||

   474

        const "midmark" > \n«$mark»

   475

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

   476

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

   477

              mode="code_from_descs";

   478

        ||

   479

            return res;

   480

        }

   481

        ||

   482

        */

   483

   484

        | var hmi_widgets = {

   485

        foreach "$hmi_elements" {

   486

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

   490

            foreach "$widget/arg"