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

     9

    10

const "default_page" choose {

    11

    when "count($hmi_pages) > 1" {

    12

        const "Home_page", 

    14

        choose {

    15

            when "$Home_page" > Home

    16

            otherwise {

    17

                error "No Home page defined!";

    18

            }

    19

        }

    20

    }

    21

    when "count($hmi_pages) = 0" {

    22

        error "No page defined!";

    23

    }

    25

}

    26

    27

// returns all directly or indirectly refered elements

    28

def "func:refered_elements" {

    29

    param "elems";

    30

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

    31

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

    32

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

    33

    choose {

    34

        when "$originals"

    35

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

    36

        otherwise

    37

            result "$descend";

    38

    }

    39

}

    40

    41

def "func:all_related_elements" {

    42

    param "page";

    43

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

    44

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

    45

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

    46

    result "$page_sub_elements";

    47

}

    48

    49

def "func:required_elements" {

    50

    param "pages"; 

    51

    choose{

    52

        when "$pages"{

    53

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

    54

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

    55

        }otherwise{

    56

            result "/..";

    57

        }

    58

    }

    59

}

    60

    61

const "required_elements",

    62

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

    63

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

    64

    65

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

    66

    67

def "func:sumarized_elements" {

    68

    param "elements";

    69

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

    70

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

    71

        not(descendant::*[

    72

            not(self::svg:g) and

    73

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

    74

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

    75

        ])]""";

    76

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

    77

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

    78

}

    79

    80

def "func:detachable_elements" {

    81

    param "pages";

    82

    choose{

    83

        when "$pages"{

    84

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

    85

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

    86

        }otherwise{

    87

            result "/..";

    88

        }

    89

    }

    90

}

    91

    92

// Avoid nested detachables

    93

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

    94

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

    95

    96

def "func:is_descendant_path" {

    97

    param "descend";

    98

    param "ancest";

    99

    result "string-length($ancest) > 0 and starts-with($descend,$ancest)";

   100

}

   101

   102

   103

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

   105

    const "page", ".";

   106

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

   107

   108

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

   109

   111

   112

    const "page_relative_widgets",

   114

   115

    // Take closest ancestor in detachable_elements

   116

    // since nested detachable elements are filtered out

   117

    const "required_detachables", 

   118

        """func:sumarized_elements($page_all_elements)/

   119

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

   120

   121

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

   122

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

   123

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

   124

    if "$desc/path/@value" {

   125

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

   126

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

   127

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

   128

    }

   129

    |     relative_widgets: [

   130

    foreach "$page_relative_widgets" {

   131

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

   132

    }

   133

    |     ],

   134

    |     absolute_widgets: [

   135

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

   136

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

   137

    }

   138

    |     ],

   139

    |     required_detachables: {

   140

    foreach "$required_detachables" {

   141

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

   142

    }

   143

    |     }

   144

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

   145

}

   146

   147

function "debug_detachables" {

   148

    foreach "$detachable_elements"{

   149

        |  «@id»

   150

    }

   151

}

   152

!debug_output_calls.append("debug_detachables")