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

    const "screensaverpage", "$hmi_pages_descs[arg[1]/@value = 'ScreenSaver']";

    29

    const "delay" choose {

    30

        when "$screensaverpage" {

    31

            const "delaystr", "$screensaverpage/arg[2]/@value";

    32

            if "not(regexp:test($delaystr,'^[0-9]+$'))"

    33

                error > ScreenSaver page has missing or malformed delay argument.

    34

            value "$delaystr";

    35

        }

    36

        otherwise > null

    37

    }

    38

    | var screensaver_delay = «$delay»;

    39

}

    40

    41

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

    42

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

    43

    44

// returns all directly or indirectly refered elements

    45

def "func:refered_elements" {

    46

    param "elems";

    47

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

    48

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

    49

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

    50

    choose {

    51

        when "$originals"

    52

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

    53

        otherwise

    54

            result "$descend";

    55

    }

    56

}

    57

    58

// variable "overlapping_geometry" was added for optimization.

    59

// It avoids calling func:overlapping_geometry 3 times for each page

    60

// (apparently libxml doesn't cache exslt function results)

    61

// in order to optimize further, func:overlapping_geometry 

    62

// should be implemented in python or even C,

    63

// as this is still the main bottleneck here

    64

const "_overlapping_geometry" {

    65

    foreach "$hmi_pages | $keypads" {

    66

        const "k", "concat('overlapping:', @id)";

    67

        value "ns:ProgressStart($k, concat('collecting membership of ', @inkscape:label))";

    68

        elt {

    69

            attrib "id" > «@id»

    70

            copy "func:overlapping_geometry(.)";

    71

        }

    72

        value "ns:ProgressEnd($k)";

    73

    }

    74

}

    75

    76

const "overlapping_geometry", "exsl:node-set($_overlapping_geometry)";

    77

    78

def "func:all_related_elements" {

    79

    param "page";

    80

    const "page_overlapping_geometry", "$overlapping_geometry/elt[@id = $page/@id]/*";

    81

    const "overlapping_candidates", "//svg:*[not(starts-with((ancestor::svg:g | .) /@inkscape:label, 'DISCARD:'))]";

    82

    const "page_overlapping_elements", "$overlapping_candidates[@id = $page_overlapping_geometry/@Id]";

    83

    const "page_widgets_elements", """

    84

        $hmi_elements[not(@id=$page/@id)

    85

                      and descendant-or-self::svg:*/@id = $page_overlapping_elements/@id]

    86

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

    87

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

    88

    result "$page_sub_elements";

    89

}

    90

    91

    92

def "func:required_elements" {

    93

    param "pages"; 

    94

    choose{

    95

        when "$pages"{

    96

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

    97

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

    98

        }otherwise{

    99

            result "/..";

   100

        }

   101

    }

   102

}

   103

   104

const "required_page_elements",

   105

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

   106

   107

const "required_list_elements", "func:refered_elements(($hmi_lists | $hmi_textlists)[@id = $required_page_elements/@id])/ancestor-or-self::svg:*";

   108

   109

const "required_elements", "$defs | $required_list_elements | $required_page_elements";

   110

   111

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

   112

   113

def "func:sumarized_elements" {

   114

    param "elements";

   115

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

   116

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

   117

        not(child::*[

   118

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

   119

            not(@id = $short_list/@id)

   120

        ])]""";

   121

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

   122

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

   123

}

   124

   125

def "func:detachable_elements" {

   126

    param "pages";

   127

    choose{

   128

        when "$pages"{

   129

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

   130

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

   131

        }otherwise{

   132

            result "/..";

   133

        }

   134

    }

   135

}

   136

   137

// Avoid nested detachables

   138

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

   139

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

   140

   141

emit "declarations:page-class" {

   142

    | class PageWidget extends Widget{}

   143

}

   144

   145

emit "declarations:detachable-elements" {

   146

    |

   147

    | var detachable_elements = {

   148

    foreach "$detachable_elements"{

   149

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

   150

    }

   151

    | }

   152

}

   153

   154

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

   155

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

   156

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

   157

   158

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

   159

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

   160

   161

   162

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

   163

    const "pagename", "$desc/arg[1]/@value";

   164

    const "msg", "concat('generating page description ', $pagename)";

   165

    value "ns:ProgressStart($pagename, $msg)";

   166

    const "page", ".";

   167

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

   168

   169

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

   170

   171

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

   172

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

   173

   174

    const "page_root_path", "$desc/path[not(@assign)]";

   175

    if "count($page_root_path)>1"

   176

        error > Page id="«$page/@id»" : only one root path can be declared

   177

   178

    const "page_relative_widgets",

   179

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

   180

   181

    // Take closest ancestor in detachable_elements

   182

    // since nested detachable elements are filtered out

   183

    const "sumarized_page", 

   184

        """func:sumarized_elements($page_all_elements)""";

   185

   186

    const "required_detachables", 

   187

        """$sumarized_page/

   188

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

   189

   190

    |   "«$pagename»": {

   191

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

   192

    if "count($page_root_path)=1"{

   193

        if "count($page_root_path/@index)=0"

   194

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

   195

    |     page_index: «$page_root_path/@index»,

   196

    |     page_class: "«$indexed_hmitree/*[@hmipath = $page_root_path/@value]/@class»",

   197

    }

   198

    |     widgets: [

   199

    |         [hmi_widgets["«$page/@id»"], []],

   200

    foreach "$page_managed_widgets" {

   201

        const "widget_paths_relativeness" 

   202

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

   203

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

   204

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

   205

            }

   206

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

   207

    }

   208

    |     ],

   209

    |     jumps: [

   210

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

   211

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

   212

    }

   213

    |     ],

   214

    |     required_detachables: {

   215

    foreach "$required_detachables" {

   216

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

   217

    }

   218

    |     }

   219

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

   220

        with "page_desc", "$desc";

   221

    }

   222

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

   223

    value "ns:ProgressEnd($pagename)";

   224

}

   225

   226

emit "definitions:page-desc" {

   227

    |

   228

    | var page_desc = {

   229

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

   230

    | }

   231

}

   232

   233

template "*", mode="widget_page";

   234

   235

   236

emit "debug:detachable-pages" {

   237

    |

   238

    | DETACHABLES:

   239

    foreach "$detachable_elements"{

   240

        |  «@id»

   241

    }

   242

    | DISCARDABLES:

   243

    foreach "$discardable_elements"{

   244

        |  «@id»

   245

    }

   246

    | In Foreach:

   247

    foreach "$in_forEach_widget_ids"{

   248

        |  «.»

   249

    }

   250

    | Overlapping 

   251

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

   252

}