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";

    28

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

    29

        choose {

    30

            when "not(@index)" {

    31

                choose {

    32

                    when "not(@type)" 

    33

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

    34

                    when "@type = 'PAGE_LOCAL'" 

    35

                        > "«substring(@value, 1)»"`if "position()!=last()" > ,`

    36

                    when "@type = 'HMI_LOCAL'" 

    37

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

    38

                }

    39

            }

    40

            otherwise {

    41

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

    42

            }

    43

        }

    44

    }

    45

    46

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

    47

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

    48

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

    49

}

    50

    51

def "func:unique_types" {

    52

    param "elts_with_type";

    53

    choose {

    54

        when "count($elts_with_type) > 1" {

    55

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

    56

            choose {

    57

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

    58

                    // type already in

    59

                    result "$prior_results";

    60

                }

    61

                otherwise {

    62

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

    63

                }

    64

            }

    65

        }

    66

        otherwise {

    67

            result "$elts_with_type";

    68

        }

    69

    }

    70

}

    71

    72

emit "preamble:local-variable-indexes" {

    73

    ||

    74

    let hmi_locals = {};

    75

    var last_remote_index = hmitree_types.length - 1;

    76

    var next_available_index = hmitree_types.length;

    77

    78

    var cache = hmitree_types.map(_ignored => undefined);

    79

    80

    function page_local_index(varname, pagename){

    81

        let pagevars = hmi_locals[pagename];

    82

        let new_index;

    83

        if(pagevars == undefined){

    84

            new_index = next_available_index++;

    85

            hmi_locals[pagename] = {[varname]:new_index}

    86

        } else {

    87

            let result = pagevars[varname];

    88

            if(result != undefined) {

    89

                return result;

    90

            }

    91

    92

            new_index = next_available_index++;

    93

            pagevars[varname] = new_index;

    94

        }

    95

        return new_index;

    96

    }

    97

    98

    function hmi_local_index(varname){

    99

        return page_local_index(varname, "HMI_LOCAL");

   100

    }

   101

    ||

   102

}

   103

   104

emit "preamble:widget-base-class" {

   105

    ||

   106

    var pending_widget_animates = [];

   107

   108

    class Widget {

   109

        offset = 0;

   110

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

   111

        unsubscribable = false;

   112

        pending_animate = false;

   113

   114

        constructor(elt_id,args,indexes,members){

   115

            this.element_id = elt_id;

   116

            this.element = id(elt_id);

   117

            this.args = args;

   118

            this.indexes = indexes;

   119

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

   120

        }

   121

   122

        unsub(){

   123

            /* remove subsribers */

   124

            if(!this.unsubscribable)

   125

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

   126

                    let index = this.indexes[i];

   127

                    if(this.relativeness[i])

   128

                        index += this.offset;

   129

                    subscribers(index).delete(this);

   130

                }

   131

            this.offset = 0;

   132

            this.relativeness = undefined;

   133

        }

   134

   135

        sub(new_offset=0, relativeness, container_id){

   136

            this.offset = new_offset;

   137

            this.relativeness = relativeness;

   138

            this.container_id = container_id ;

   139

            /* add this's subsribers */

   140

            if(!this.unsubscribable)

   141

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

   142

                    let index = this.get_variable_index(i);

   143

                    subscribers(index).add(this);

   144

                }

   145

            need_cache_apply.push(this); 

   146

        }

   147

   148

        apply_cache() {

   149

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

   150

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

   152

                let cached_val = cache[realindex];

   153

                if(cached_val != undefined)

   154

                    this.new_hmi_value(realindex, cached_val, cached_val);

   155

            }

   156

        }

   157

   158

        get_variable_index(varnum) {

   159

            let index = this.indexes[varnum];

   160

            if(typeof(index) == "string"){

   161

                index = page_local_index(index, this.container_id);

   162

            } else {

   163

                if(this.relativeness[varnum]){

   164

                    index += this.offset;

   165

                }

   166

            }

   167

            return index;

   168

        }

   169

        change_hmi_value(index,opstr) {

   170

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

   171

        }

   172

   173

        apply_hmi_value(index, new_val) {

   174

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

   175

        }

   176

   177

        new_hmi_value(index, value, oldval) {

   178

            try {

   179

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

   180

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

   181

                    let refindex = this.get_variable_index(i);

   182

   183

                    if(index == refindex) {

   184

                        let d = this.dispatch;

   185

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

   186

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

   187

                        }

   188

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

   189

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

   190

                        }

   191

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

   192

                        /*else {

   193

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

   194

                        }*/

   195

                        break;

   196

                    }

   197

                }

   198

            } catch(err) {

   199

                console.log(err);

   200

            }

   201

        }

   202

   203

        _animate(){

   204

            this.animate();

   205

            this.pending_animate = false;

   206

        }

   207

   208

        request_animate(){

   209

            if(!this.pending_animate){

   210

                pending_widget_animates.push(this);

   211

                this.pending_animate = true;

   212

                requestHMIAnimation();

   213

            }

   214

   215

        }

   216

    }

   217

    ||

   218

}

   219

   220

emit "declarations:hmi-classes" {

   221

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

   222

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

   223

}

   224

   225

template "widget", mode="widget_class"

   226

||

   227

class «@type»Widget extends Widget{

   228

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

   229

}

   230

||

   231

   234

   235

emit "declarations:hmi-elements" {

   236

    | var hmi_widgets = {

   238

    | }

   239

}

   240

   241

function "defs_by_labels" {

   242

    param "labels","''";

   243

    param "mandatory","'yes'";

   244

    param "subelements","/..";

   245

    param "hmi_element";

   246

    const "widget_type","@type";

   247

    foreach "str:split($labels)" {

   248

        const "name",".";

   249

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

   250

        choose {

   251

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

   252

                if "$mandatory='yes'" {

   253

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

   254

                }

   255

                // otherwise produce nothing

   256

            }

   257

            otherwise {

   258

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

   259

                if "$subelements" {

   260

                |     «$name»_sub: {

   261

                    foreach "str:split($subelements)" {

   262

                        const "subname",".";

   263

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

   264

                        choose {

   265

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

   266

                                if "$mandatory='yes'" {

   267

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

   268

                                }

   269

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

   270

                            }

   271

                            otherwise {

   272

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

   273

                            }

   274

                        }

   275

                    }

   276

                |     },

   277

                }

   278

            }

   279

        }

   280

    }

   281

}

   282

   283

def "func:escape_quotes" {

   284

    param "txt";

   285

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

   287

    choose {

   290

        }

   291

        otherwise {

   292

            result "$txt";

   293

        }

   294

    }

   295

}

   296