1

// hmi_tree.ysl2

     2

     3

     4

// HMI Tree computed from VARIABLES.CSV in svghmi.py

     5

const "hmitree", "ns:GetHMITree()";

     6

     7

const "_categories" {

     8

    noindex > HMI_PLC_STATUS

     9

    noindex > HMI_CURRENT_PAGE

    10

}

    11

const "categories", "exsl:node-set($_categories)";

    12

    13

// HMI Tree Index

    14

const "_indexed_hmitree" apply "$hmitree", mode="index";

    15

const "indexed_hmitree", "exsl:node-set($_indexed_hmitree)";

    16

    17

emit "preamble:hmi-tree" {

    18

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

    19

    |

    20

    | var heartbeat_index = «$indexed_hmitree/*[@hmipath = '/HEARTBEAT']/@index»;

    21

    |

    22

    | var hmitree_types = [

    23

    24

    foreach "$indexed_hmitree/*" 

    25

    |     /* «@index»  «@hmipath» */ "«substring(local-name(), 5)»"`if "position()!=last()" > ,`

    26

    27

    | ];

    28

    |

    29

}

    30

    31

template "*", mode="index" {

    32

    param "index", "0";

    33

    param "parentpath", "''";

    34

    const "content" {

    35

        const "path"

    36

            choose {

    37

                when "count(ancestor::*)=0" > /

    38

                when "count(ancestor::*)=1" > /«@name»

    39

                otherwise > «$parentpath»/«@name»

    40

            }

    41

        choose {

    42

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

    43

                xsl:copy {

    44

                    attrib "index" > «$index»

    45

                    attrib "hmipath" > «$path»

    46

                    foreach "@*" xsl:copy;

    47

                }

    48

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

    49

                     with "index", "$index + 1";

    50

                     with "parentpath" > «$path»

    51

                }

    52

            }

    53

            otherwise {

    54

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

    55

                    with "index", "$index";

    56

                    with "parentpath" > «$path»

    57

                }

    58

            }

    59

        }

    60

    }

    61

    62

    copy "$content";

    63

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

    64

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

    65

        with "parentpath" > «$parentpath»

    66

    }

    67

}

    68

    69

//  Parses:

    70

//  "HMI:WidgetType:param1:param2@path1,path1min,path1max@path2"

    71

//

    72

//  Into:

    73

//  widget type="WidgetType" id="blah456" {

    74

//      arg value="param1";

    75

//      arg value="param2";

    76

//      path value=".path1" index=".path1" min="path1min" max="path1max" type="PAGE_LOCAL";

    77

//      path value="/path1" index="348" type="HMI_INT";

    78

//      path value="path4" index="path4" type="HMI_LOCAL";

    79

//  }

    80

//

    81

template "*", mode="parselabel" {

    82

    const "label","@inkscape:label";

    83

    const "id","@id";

    84

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

    85

    86

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

    87

    const "args" choose {

    88

        when "$_args" value "$_args";

    89

        otherwise value "$description";

    90

    }

    91

    92

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

    93

    const "type" choose {

    94

        when "$_type" value "$_type";

    95

        otherwise value "$args";

    96

    }

    97

    98

    if "$type" widget {

    99

        attrib "id" > «$id»

   100

        attrib "type" > «$type»

   101

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

   102

            arg {

   103

                attrib "value" > «.»

   104

            }

   105

        }

   106

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

   107

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

   108

            if "string-length(.) > 0" path {

   109

                const "pathminmax", "str:split(.,',')";

   110

                const "path", "$pathminmax[1]";

   111

                const "pathminmaxcount", "count($pathminmax)";

   112

                attrib "value" > «$path»

   113

                choose {

   114

                    when "$pathminmaxcount = 3" {

   115

                        attrib "min" > «$pathminmax[2]»

   116

                        attrib "max" > «$pathminmax[3]»

   117

                    }

   118

                    when "$pathminmaxcount = 2" {

   119

                        error > Widget id:«$id» label:«$label» has wrong syntax of path section «$pathminmax»

   120

                    }

   121

                }

   122

                choose {

   123

                    when "regexp:test($path,'^\.[a-zA-Z0-9_]+$')" {

   124

                        attrib "type" > PAGE_LOCAL

   125

                    }

   126

                    when "regexp:test($path,'^[a-zA-Z0-9_]+$')" {

   127

                        attrib "type" > HMI_LOCAL

   128

                    }

   129

                    otherwise {

   130

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

   131

                        const "pathtype", "local-name($item)";

   132

                        if "$pathminmaxcount = 3 and not($pathtype = 'HMI_INT' or $pathtype = 'HMI_REAL')" {

   133

                            error > Widget id:«$id» label:«$label» path section «$pathminmax» use min and max on non mumeric value

   134

                        }

   135

                        if "count($item) = 1" {

   136

                            attrib "index" > «$item/@index»

   137

                            attrib "type" > «$pathtype»

   138

                        }

   139

                    }

   140

                }

   141

            }

   142

        }

   143

    }

   144

}

   145

   146

const "_parsed_widgets" {

   147

    widget type="VarInitPersistent" {

   148

        arg value="0";

   149

        path value="lang";

   150

    }

   151

    apply "$hmi_elements", mode="parselabel";

   152

}

   153

   154

const "parsed_widgets","exsl:node-set($_parsed_widgets)";

   155

   156

def "func:widget" {

   157

    param "id";

   158

    result "$parsed_widgets/widget[@id = $id]";

   159

}

   160

   161

def "func:is_descendant_path" {

   162

    param "descend";

   163

    param "ancest";

   164

    // TODO : use HMI tree to answer more accurately

   165

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

   166

}

   167

   168

def "func:same_class_paths" {

   169

    param "a";

   170

    param "b";

   171

    const "class_a", "$indexed_hmitree/*[@hmipath = $a]/@class";

   172

    const "class_b", "$indexed_hmitree/*[@hmipath = $b]/@class";

   173

    result "$class_a and $class_b and $class_a = $class_b";

   174

}

   175

   176

// Debug data

   177

template "*", mode="testtree"{

   178

    param "indent", "''";

   179

    > «$indent» «local-name()» 

   180

    foreach "@*" > «local-name()»="«.»" 

   181

    > \n

   182

    apply "*", mode="testtree" {

   183

        with "indent" value "concat($indent,'>')"

   184

    };

   185

}

   186

   187

emit "debug:hmi-tree" {

   188

    | Raw HMI tree

   189

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

   190

    |

   191

    | Indexed HMI tree

   192

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

   193

    |

   194

    | Parsed Widgets

   195

    copy "_parsed_widgets";

   196

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

   197

}