1

// widgets_common.ysl2

     2

     3

in xsl decl labels(*ptr, name="defs_by_labels") alias call-template {

     4

    with "hmi_element", "$hmi_element";

     5

    with "labels"{text *ptr};

     6

    content;

     7

};

     8

     9

decl optional_labels(*ptr) alias - {

    10

    /* TODO add some per label xslt variable to check if exist */

    11

    labels(*ptr){

    12

        with "mandatory","'no'";

    13

        content;

    14

    }

    15

};

    16

    17

decl activable_labels(*ptr) alias - {

    18

    optional_labels(*ptr) {

    19

        with "subelements","'active inactive'";

    20

        content;

    21

    }

    22

};

    23

    24

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

    25

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

    26

    const "eltid","@id";

    27

    const "args" foreach "$widget/arg" > "«@value»"`if "position()!=last()" > ,`

    28

    const "indexes" foreach "$widget/path" {

    29

        choose {

    30

            when "not(@index)" {

    31

                warning > Widget «$widget/@type» id="«$eltid»" : No match for path "«@value»" in HMI tree

    32

            }

    33

            otherwise {

    34

                > «@index»`if "position()!=last()" > ,`

    35

            }

    36

        }

    37

    }

    38

    39

    |   "«@id»": new «$widget/@type»Widget ("«@id»",[«$args»],[«$indexes»],{

    40

    apply "$widget", mode="widget_defs" with "hmi_element",".";

    41

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

    42

}

    43

    44

def "func:unique_types" {

    45

    param "elts_with_type";

    46

    choose {

    47

        when "count($elts_with_type) > 1" {

    48

            const "prior_results","func:unique_types($elts_with_type[position()!=last()])";

    49

            choose {

    50

                when "$elts_with_type[last()][@type = $prior_results/@type]"{

    51

                    // type already in

    52

                    result "$prior_results";

    53

                }

    54

                otherwise {

    55

                    result "$prior_results | $elts_with_type[last()]";

    56

                }

    57

            }

    58

        }

    59

        otherwise {

    60

            result "$elts_with_type";

    61

        }

    62

    }

    63

}

    64

    65

emit "preamble:widget-base-class" {

    66

    ||    

    67

    class Widget {

    68

        offset = 0;

    69

        frequency = 10; /* FIXME arbitrary default max freq. Obtain from config ? */

    70

        unsubscribable = false;

    71

        constructor(elt_id,args,indexes,members){

    72

            this.element_id = elt_id;

    73

            this.element = id(elt_id);

    74

            this.args = args;

    75

            this.indexes = indexes;

    76

            Object.keys(members).forEach(prop => this[prop]=members[prop]);

    77

        }

    78

    79

        unsub(){

    80

            /* remove subsribers */

    81

            if(!this.unsubscribable)

    82

                for(let i = 0; i < this.indexes.length; i++) {

    83

                    let index = this.indexes[i];

    84

                    if(this.relativeness[i])

    85

                        index += this.offset;

    86

                    subscribers[index].delete(this);

    87

                }

    88

            this.offset = 0;

    89

            this.relativeness = undefined;

    90

        }

    91

    92

        sub(new_offset=0, relativeness){

    93

            this.offset = new_offset;

    94

            this.relativeness = relativeness;

    95

            /* add this's subsribers */

    96

            if(!this.unsubscribable)

    97

                for(let i = 0; i < this.indexes.length; i++) {

    98

                    let index = this.indexes[i];

    99

                    if(relativeness[i])

   100

                        index += new_offset;

   101

                    subscribers[index].add(this);

   102

                }

   103

            need_cache_apply.push(this); 

   104

        }

   105

   106

        apply_cache() {

   107

            if(!this.unsubscribable) for(let index of this.indexes){

   108

                /* dispatch current cache in newly opened page widgets */

   109

                let realindex = index+this.offset;

   110

                let cached_val = cache[realindex];

   111

                if(cached_val != undefined)

   112

                    this.new_hmi_value(realindex, cached_val, cached_val);

   113

            }

   114

        }

   115

   116

        get_idx(index) {

   117

             let orig = this.indexes[index];

   118

             return this.relativeness[index] ? orig + this.offset : orig;

   119

        }

   120

        change_hmi_value(index,opstr) {

   121

            return change_hmi_value(this.get_idx(index), opstr);

   122

        }

   123

   124

        apply_hmi_value(index, new_val) {

   125

            return apply_hmi_value(this.get_idx(0), new_val);

   126

        }

   127

   128

        new_hmi_value(index, value, oldval) {

   129

            try {

   130

                // TODO avoid searching, store index at sub()

   131

                for(let i = 0; i < this.indexes.length; i++) {

   132

                    let refindex = this.indexes[i];

   133

                    if(this.relativeness[i])

   134

                        refindex += this.offset;

   135

   136

                    if(index == refindex) {

   137

                        let d = this.dispatch;

   138

                        if(typeof(d) == "function"){

   139

                            d.call(this, value, oldval, i);

   140

                        }

   141

                        else if(typeof(d) == "object"){

   142

                            d[i].call(this, value, oldval);

   143

                        }

   144

                        /* else dispatch_0, ..., dispatch_n ? */

   145

                        /*else {

   146

                            throw new Error("Dunno how to dispatch to widget at index = " + index);

   147

                        }*/

   148

                        break;

   149

                    }

   150

                }

   151

            } catch(err) {

   152

                console.log(err);

   153

            }

   154

        }

   155

    }

   156

    ||

   157

}

   158

   159

emit "declarations:hmi-classes" {

   160

    const "used_widget_types", "func:unique_types($parsed_widgets/widget)";

   161

    apply "$used_widget_types", mode="widget_class";

   162

}

   163

   164

template "widget", mode="widget_class"

   165

||

   166

class «@type»Widget extends Widget{

   167

    /* empty class, as «@type» widget didn't provide any */

   168

}

   169

||

   170

   171

const "excluded_types", "str:split('Page Lang')";

   172

const "excluded_ids","$parsed_widgets/widget[not(@type = $excluded_types)]/@id";

   173

   174

emit "declarations:hmi-elements" {

   175

    | var hmi_widgets = {

   176

    apply  "$hmi_elements[@id = $excluded_ids]", mode="hmi_widgets";

   177

    | }

   178

}

   179

   180

function "defs_by_labels" {

   181

    param "labels","''";

   182

    param "mandatory","'yes'";

   183

    param "subelements","/..";

   184

    param "hmi_element";

   185

    const "widget_type","@type";

   186

    foreach "str:split($labels)" {

   187

        const "name",".";

   188

        const "elt","$result_svg_ns//*[@id = $hmi_element/@id]//*[@inkscape:label=$name][1]";

   189

        choose {

   190

            when "not($elt/@id)" {

   191

                if "$mandatory='yes'" {

   192

                    error > «$widget_type» widget must have a «$name» element

   193

                }

   194

                // otherwise produce nothing

   195

            }

   196

            otherwise {

   197

                |     «$name»_elt: id("«$elt/@id»"),

   198

                if "$subelements" {

   199

                |     «$name»_sub: {

   200

                    foreach "str:split($subelements)" {

   201

                        const "subname",".";

   202

                        const "subelt","$elt/*[@inkscape:label=$subname][1]";

   203

                        choose {

   204

                            when "not($subelt/@id)" {

   205

                                if "$mandatory='yes'" {

   206

                                    error > «$widget_type» widget must have a «$name»/«$subname» element

   207

                                }

   208

                |         /* missing «$name»/«$subname» element */

   209

                            }

   210

                            otherwise {

   211

                |         "«$subname»": id("«$subelt/@id»")`if "position()!=last()" > ,`

   212

                            }

   213

                        }

   214

                    }

   215

                |     },

   216

                }

   217

            }

   218

        }

   219

    }

   220

}

   221

   222

def "func:escape_quotes" {

   223

    param "txt";

   224

    // have to use a python string to enter escaped quote

   225

    const "frst", !"substring-before($txt,'\"')"!;

   226

    const "frstln", "string-length($frst)";

   227

    choose {

   228

        when "$frstln > 0 and string-length($txt) > $frstln" {

   229

            result !"concat($frst,'\\\"',func:escape_quotes(substring-after($txt,'\"')))"!;

   230

        }

   231

        otherwise {

   232

            result "$txt";

   233

        }

   234

    }

   235

}

   236