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 "keypads_descs", "$parsed_widgets/widget[@type = 'Keypad']";

    11

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

    12

    13

const "default_page" choose {

    14

    when "count($hmi_pages) > 1" {

    15

        choose {

    16

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

    17

            otherwise {

    18

                error "No Home page defined!";

    19

            }

    20

        }

    21

    }

    22

    when "count($hmi_pages) = 0" {

    23

        error "No page defined!";

    24

    }

    25

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

    26

}

    27

    28

// returns all directly or indirectly refered elements

    29

def "func:refered_elements" {

    30

    param "elems";

    31

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

    32

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

    33

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

    34

    choose {

    35

        when "$originals"

    36

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

    37

        otherwise

    38

            result "$descend";

    39

    }

    40

}

    41

    42

def "func:all_related_elements" {

    43

    param "page";

    44

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

    45

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

    46

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

    47

    result "$page_sub_elements";

    48

}

    49

    50

def "func:required_elements" {

    51

    param "pages"; 

    52

    choose{

    53

        when "$pages"{

    54

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

    55

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

    56

        }otherwise{

    57

            result "/..";

    58

        }

    59

    }

    60

}

    61

    62

const "required_elements",

    63

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

    64

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

    65

    66

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

    67

    68

def "func:sumarized_elements" {

    69

    param "elements";

    70

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

    71

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

    72

        not(descendant::*[

    73

            not(self::svg:g) and

    74

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

    75

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

    76

        ])]""";

    77

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

    78

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

    79

}

    80

    81

def "func:detachable_elements" {

    82

    param "pages";

    83

    choose{

    84

        when "$pages"{

    85

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

    86

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

    87

        }otherwise{

    88

            result "/..";

    89

        }

    90

    }

    91

}

    92

    93

// Avoid nested detachables

    94

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

    95

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

    96

    97

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

    98

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

    99

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

   100

   101

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

   102

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

   103

    const "page", ".";

   104

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

   105

   106

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

   107

   108

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

   109

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

   110

    const "page_relative_widgets",

   111

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

   112

   113

    // Take closest ancestor in detachable_elements

   114

    // since nested detachable elements are filtered out

   115

    const "required_detachables", 

   116

        """func:sumarized_elements($page_all_elements)/

   117

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

   118

   119

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

   120

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

   121

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

   122

    if "$desc/path/@value" {

   123

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

   124

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

   125

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

   126

    }

   127

    |     relative_widgets: [

   128

    foreach "$page_relative_widgets" {

   129

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

   130

    }

   131

    |     ],

   132

    |     absolute_widgets: [

   133

    foreach "$page_managed_widgets[not(@id = $page_relative_widgets/@id)]" {

   134

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

   135

    }

   136

    |     ],

   137

    |     jumps: [

   138

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

   139

        const "_id","@id";

   140

        const "opts" call "jump_widget_activity" with "hmi_element", "$hmi_elements[@id=$_id]";

   141

        if "string-length($opts)>0"

   142

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

   143

    }

   144

    |     ],

   145

    |     required_detachables: {

   146

    foreach "$required_detachables" {

   147

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

   148

    }

   149

    |     }

   150

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

   151

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

   152

        with "page_desc", "$desc";

   153

    }

   154

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

   155

}

   156

   157

template "*", mode="per_page_widget_template";

   158

   159

   160

reflect:detachable_pages;

   161

   162

template "reflect:detachable-pages", mode="debug" {

   163

   164

    | DETACHABLES:

   165

    foreach "$detachable_elements"{

   166

        |  «@id»

   167

    }

   168

    | In Foreach:

   169

    foreach "$in_forEach_widget_ids"{

   170

        |  «.»

   171

    }

   172

}