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/*" 

    33

    34

    | ];

    35

    |

    36

}

    37

    38

template "*", mode="index" {

    39

    param "index", "0";

    40

    param "parentpath", "''";

    41

    const "content" {

    42

        const "path"

    43

            choose {

    44

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

    45

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

    46

                otherwise > «$parentpath»/«@name»

    47

            }

    48

        choose {

    49

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

    50

                xsl:copy {

    51

                    attrib "index" > «$index»

    52

                    attrib "hmipath" > «$path»

    53

                    foreach "@*" xsl:copy;

    54

                }

    55

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

    56

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

    57

                     with "parentpath" > «$path»

    58

                }

    59

            }

    60

            otherwise {

    61

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

    62

                    with "index", "$index";

    63

                    with "parentpath" > «$path»

    64

                }

    65

            }

    66

        }

    67

    }

    68

    69

    copy "$content";

    70

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

    71

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

    72

        with "parentpath" > «$parentpath»

    73

    }

    74

}

    75

    76

//  Parses:

    77

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

    78

//

    79

//  Into:

    80

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

    81

//      arg value="param1";

    82

//      arg value="param2";

    83

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

    84

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

    85

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

    86

//  }

    87

//

    88

template "*", mode="parselabel" {

    89

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

    90

    const "id","@id";

    91

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

    92

    93

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

    94

    const "args" choose {

    95

        when "$_args" value "$_args";

    96

        otherwise value "$description";

    97

    }

    98

    99

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

   100

    const "type" choose {

   101

        when "$_type" value "$_type";

   102

        otherwise value "$args";

   103

    }

   104

   105

    if "$type" widget {

   106

        attrib "id" > «$id»

   107

        attrib "type" > «$type»

   108

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

   109

            arg {

   110

                attrib "value" > «.»

   111

            }

   112

        }

   113

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

   114

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

   115

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

   116

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

   117

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

   118

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

   119

                attrib "value" > «$path»

   120

                choose {

   121

                    when "$pathminmaxcount = 3" {

   122

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

   123

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

   124

                    }

   125

                    when "$pathminmaxcount = 2" {

   126

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

   127

                    }

   128

                }

   129

                choose {

   130

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

   131

                        attrib "type" > PAGE_LOCAL

   132

                    }

   133

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

   134

                        attrib "type" > HMI_LOCAL

   135

                    }

   136

                    otherwise {

   137

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

   138

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

   139

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

   140

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

   141

                        }

   142

                        if "count($item) = 1" {

   143

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

   144

                            attrib "type" > «$pathtype»

   145

                        }

   146

                    }

   147

                }

   148

            }

   149

        }

   150

    }

   151

}

   152

   153

const "_parsed_widgets" {

   154

    widget type="VarInitPersistent" {

   155

        arg value="0";

   156

        path value="lang";

   157

    }

   158

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

   159

}

   160

   161

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

   162

   163

def "func:widget" {

   164

    param "id";

   165

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

   166

}

   167

   168

def "func:is_descendant_path" {

   169

    param "descend";

   170

    param "ancest";

   171

    // TODO : use HMI tree to answer more accurately

   172

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

   173

}

   174

   175

def "func:same_class_paths" {

   176

    param "a";

   177

    param "b";

   178

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

   179

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

   180

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

   181

}

   182

   183

// Debug data

   184

template "*", mode="testtree"{

   185

    param "indent", "''";

   186

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

   187

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

   188

    > \n

   189

    apply "*", mode="testtree" {

   190

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

   191

    };

   192

}

   193

   194

emit "debug:hmi-tree" {

   195

    | Raw HMI tree

   196

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

   197

    |

   198

    | Indexed HMI tree

   199

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

   200

    |

   201

    | Parsed Widgets

   202

    copy "_parsed_widgets";

   203

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

   204

}