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]";

    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"

   107

            when "$d0 and not($d1)"

   125

            otherwise

   126

                result "0"; /* no intersection*/

   127

        }

   128

    }

   129

   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"{

   194

                result "$x_intersect * $y_intersect";

   195

            }

   196

            otherwise result "0";

   197

        }

   198

    }

   199

   203

    def "func:overlapping_geometry" {

   204

        param "elt";

   205

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

   213

    }

   214

   215

    def "func:sumarized_elements" {

   216

        param "elements";

   217

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

   218

        /* TODO exclude globally discardable elements from group fulfillment check */

   219

        const "filled_groups", "$short_list/parent::svg:*[not(descendant::*[not(self::svg:g)][not(@id = $short_list/descendant-or-self::*[not(self::svg:g)]/@id)])]";

   220

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

   221

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

   222

    }

   223

   224

    def "func:all_related_elements" {

   225

        param "page";

   226

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

   227

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

   228

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

   229

        result "$page_sub_elements";

   230

    }

   231

   232

    def "func:detachable_elements" {

   233

        param "pages"; 

   234

        choose{

   235

            when "$pages"{

   236

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

   237

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

   238

            }otherwise{

   239

                result "/..";

   240

            }

   241

        }

   242

    }

   243

   244

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

   245

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

   246

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

   247

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

   248

   249

    template "*", mode="index" {

   250

        param "index", "0";

   251

        param "parentpath", "''";

   252

        const "content" {

   253

            const "path"

   254

                choose {

   255

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

   256

                    otherwise > «$parentpath»/«@name»

   257

                }

   258

            choose {

   259

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

   260

                    xsl:copy {

   261

                        attrib "index" > «$index»

   262

                        attrib "hmipath" > «$path»

   263

                        foreach "@*" xsl:copy;

   264

                    }

   265

                    /* no node expected below value nodes */

   266

                }

   267

                otherwise {

   268

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

   269

                        with "index", "$index";

   270

                        with "parentpath" > «$path»

   271

                    }

   272

                }

   273

            }

   274

        }

   275

   276

        copy "$content";

   277

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

   278

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

   279

            with "parentpath" > «$parentpath»

   280

        }

   281

    }

   282

   283

    /* Identity template :

   284

     *  - copy every attributes 

   285

     *  - copy every sub-elements

   286

     */

   287

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

   288

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

   289

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

   290

      /* TODO filter out globally discardable elements */

   291

    }

   292

   293

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

   294

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

   295

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

   296

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

   297

        attrib "preserveAspectRatio" > none

   298

        attrib "height" > 100vh

   299

        attrib "width" > 100vw

   300

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

   301

    }

   302

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

   303

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

   304

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

   305

    }

   306

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

   307

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

   308

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

   309

    }

   310

   311

   312

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

   313

    ////

   314

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

   315

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

   316

    //// {

   317

    ////     g{

   318

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

   319

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

   320

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

   321

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

   322

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

   323

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

   324

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

   325

    ////     }

   326

    //// }

   327

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

   328

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

   329

    ////     choose {

   330

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

   331

    ////             use{

   332

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

   333

    ////             }

   334

    ////         }

   335

    ////         otherwise {

   336

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

   337

    ////         }

   338

    ////     }

   339

    //// }

   340

   341

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

   342

    //     attrib "style" > all:initial;

   343

    //     //«.»

   344

    // }

   345

   346

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

   347

    //     attrib "style" > all:unset;

   348

    //     //«.»

   349

    // }

   350

   351

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

   352

   353

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

   354

    template "/" { 

   355

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

   356

        /* DEBUG DATA */

   357

        comment {

   358

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

   359

        }

   360

        comment {

   361

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

   362

        }

   363

        comment {

   364

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

   365

        }

   366

        comment {

   367

            | Detachable :

   368

            foreach "$detachable_elements"{

   369

                | «@id»

   370

            }

   371

        }

   372

        comment {

   373

            | Discardable :

   374

            foreach "$discardable_elements"{

   375

                | «@id»

   376

            }

   377

        }

   378

        /**/

   379

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

   380

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

   381

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

   382

            head;

   383

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

   384

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

   385

                script{

   386

                    call "scripts";

   387

                }

   388

            }

   389

        }

   390

    }

   391

   392

    /*

   393

        Parses:

   394

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

   395

   396

        Into:

   397

        widget type="WidgetType" {

   398

            arg value="param1";

   399

            arg value="param2";

   400

            path value="path1";

   401

            path value="path2";

   402

        }

   403

    */

   404

   405

    def "func:parselabel" {

   406

        param "label";

   407

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

   408

   409

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

   410

        const "args" choose {

   411

            when "$_args" value "$_args";

   412

            otherwise value "$description";

   413

        }

   414

   415

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

   416

        const "type" choose {

   417

            when "$_type" value "$_type";

   418

            otherwise value "$args";

   419

        }

   420

   421

        const "ast" if "$type" widget {

   422

            attrib "type" > «$type»

   423

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

   424

                arg {

   425

                    attrib "value" > «.»

   426

                }

   427

            }

   428

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

   429

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

   430

                path {

   431

                    attrib "value" > «.»

   432

                }

   433

            }

   434

        }

   435

   436

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

   437

    }

   438

   439

    function "scripts"

   440

    {

   441

        | //(function(){

   442

        |

   443

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

   444

   445

        /* TODO re-enable

   446

        ||

   447

        function evaluate_js_from_descriptions() {

   448

            var Page;

   449

            var Input;

   450

            var Display;

   451

            var res = [];

   452

        ||

   453

        const "midmark" > \n«$mark»

   454

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

   455

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

   456

              mode="code_from_descs";

   457

        ||

   458

            return res;

   459

        }

   460

        ||

   461

        */

   462

   463

        | var hmi_widgets = {

   464

        foreach "$hmi_elements" {

   465

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

   466

            | "«@id»": {

   467

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

   468

            |     args: [

   469

            foreach "$widget/arg"

   470

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

   471

            |     ],

   472

            |     indexes: [

   473

            foreach "$widget/path" {

   474

                const "hmipath","@value";

   475

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

   476

                choose {

   477

                    when "count($hmitree_match) = 0" {

   478

                        warning > No match for path "«$hmipath»" in HMI tree

   479

                    }

   480

                    otherwise {

   481

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

   482

                    }

   483

                }

   484

            }

   485

            |     ],

   486

            |     element: document.getElementById("«@id»"),

   487

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

   488

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

   489

        }

   490

        | }

   491

        |