1

// detachable_pages.ysl2

     2

//

     3

// compute what elements are required by pages

     4

// and decide where to cut when removing/attaching

     5

// pages elements on page switch

     6

     7

const "hmi_pages_descs", "$parsed_widgets/widget[@type = 'Page']";

     8

const "hmi_pages", "$hmi_elements[@id = $hmi_pages_descs/@id]";

     9

    10

const "default_page" choose {

    11

    when "count($hmi_pages) > 1" {

    12

        choose {

    13

            when "$hmi_pages_descs/arg[1]/@value = 'Home'" > Home

    14

            otherwise {

    15

                error > No Home page defined!

    16

            }

    17

        }

    18

    }

    19

    when "count($hmi_pages) = 0" {

    20

        error > No page defined!

    21

    }

    22

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

    23

}

    24

    25

emit "preamble:default-page" {

    26

    |

    27

    | var default_page = "«$default_page»";

    28

}

    29

    30

const "keypads_descs", "$parsed_widgets/widget[@type = 'Keypad']";

    31

const "keypads", "$hmi_elements[@id = $keypads_descs/@id]";

    32

    33

// returns all directly or indirectly refered elements

    34

def "func:refered_elements" {

    35

    param "elems";

    36

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

    37

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

    38

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

    39

    choose {

    40

        when "$originals"

    41

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

    42

        otherwise

    43

            result "$descend";

    44

    }

    45

}

    46

    47

def "func:all_related_elements" {

    48

    param "page";

    49

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

    50

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

    51

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

    52

    result "$page_sub_elements";

    53

}

    54

    55

def "func:required_elements" {

    56

    param "pages"; 

    57

    choose{

    58

        when "$pages"{

    59

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

    60

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

    61

        }otherwise{

    62

            result "/..";

    63

        }

    64

    }

    65

}

    66

    67

const "required_elements",

    68

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

    69

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

    70

    71

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

    72

    73

def "func:sumarized_elements" {

    74

    param "elements";

    75

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

    78

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

    80

        ])]""";

    81

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

    83

}

    84

    85

def "func:detachable_elements" {

    86

    param "pages";

    87

    choose{

    88

        when "$pages"{

    89

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

    90

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

    91

        }otherwise{

    92

            result "/..";

    93

        }

    94

    }

    95

}

    96

    97

// Avoid nested detachables

    98

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

    99

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

   100

   101

emit "declarations:detachable-elements" {

   102

    |

   103

    | var detachable_elements = {

   104

    foreach "$detachable_elements"{

   105

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

   106

    }

   107

    | }

   108

}

   109

   110

const "forEach_widgets_ids", "$parsed_widgets/widget[@type = 'ForEach']/@id";

   111

const "forEach_widgets", "$hmi_widgets[@id = $forEach_widgets_ids]";

   112

const "in_forEach_widget_ids", "func:refered_elements($forEach_widgets)[not(@id = $forEach_widgets_ids)]/@id";

   113

   114

template "svg:*", mode="page_desc" {

   115

    if "ancestor::*[@id = $hmi_pages/@id]" error > HMI:Page «@id» is nested in another HMI:Page

   116

   117

    const "desc", "func:widget(@id)";

   118

    const "page", ".";

   119

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

   120

   121

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

   122

   123

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

   124

    const "page_managed_widgets","$all_page_widgets[not(@id=$in_forEach_widget_ids)]";

   125

    const "page_relative_widgets",

   126

        "$page_managed_widgets[func:is_descendant_path(func:widget(@id)/path/@value, $desc/path/@value)]";

   127

   128

    // Take closest ancestor in detachable_elements

   129

    // since nested detachable elements are filtered out

   130

    const "required_detachables", 

   131

        """func:sumarized_elements($page_all_elements)/

   132

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

   133

   134

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

   135

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

   136

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

   137

    if "$desc/path/@value" {

   138

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

   139

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

   140

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

   141

    }

   142

    |     widgets: [

   143

    foreach "$page_managed_widgets" {

   144

        const "widget_paths_relativeness" 

   145

            foreach "func:widget(@id)/path" {

   146

                value "func:is_descendant_path(@value, $desc/path/@value)";

   147

                if "position()!=last()" > ,

   148

            }

   149

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

   150

    }

   151

    |     ],

   152

    |     jumps: [

   153

    foreach "$parsed_widgets/widget[@id = $all_page_widgets/@id and @type='Jump']" {

   154

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

   155

    }

   156

    |     ],

   157

    |     required_detachables: {

   158

    foreach "$required_detachables" {

   159

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

   160

    }

   161

    |     }

   162

    /* TODO generate some code for init() instead */

   163

    apply "$parsed_widgets/widget[@id = $all_page_widgets/@id]", mode="per_page_widget_template"{

   164

        with "page_desc", "$desc";

   165

    }

   166

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

   167

}

   168

   169

emit "definitions:page-desc" {

   170

    |

   171

    | var page_desc = {

   172

    apply "$hmi_pages", mode="page_desc";

   173

    | }

   174

}

   175

   176

template "*", mode="per_page_widget_template";

   177

   178

   179

emit "debug:detachable-pages" {

   180

    |

   181

    | DETACHABLES:

   182

    foreach "$detachable_elements"{

   183

        |  «@id»

   184

    }

   185

    | In Foreach:

   186

    foreach "$in_forEach_widget_ids"{

   187

        |  «.»

   188

    }

   189

}