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" > "«func:escape_quotes(@value)»"`if "position()!=last()" > ,`

    28

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

    29

        choose {

    30

            when "not(@index)" {

    31

                choose {

    32

                    when "not(@type)" {

    33

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

    34

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

    35

                    }

    36

                    when "@type = 'PAGE_LOCAL'" 

    37

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

    38

                    when "@type = 'HMI_LOCAL'" 

    39

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

    40

                }

    41

            }

    42

            otherwise {

    43

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

    44

            }

    45

        }

    46

    }

    47

    48

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

    49

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

    50

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

    51

}

    52

    53

def "func:unique_types" {

    54

    param "elts_with_type";

    55

    choose {

    56

        when "count($elts_with_type) > 1" {

    57

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

    58

            choose {

    59

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

    60

                    // type already in

    61

                    result "$prior_results";

    62

                }

    63

                otherwise {

    64

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

    65

                }

    66

            }

    67

        }

    68

        otherwise {

    69

            result "$elts_with_type";

    70

        }

    71

    }

    72

}

    73

    74

emit "preamble:local-variable-indexes" {

    75

    ||

    76

    let hmi_locals = {};

    77

    var last_remote_index = hmitree_types.length - 1;

    78

    var next_available_index = hmitree_types.length;

    79

    80

    const local_defaults = {

    81

    ||

    82

    foreach "$parsed_widgets/widget[@type = 'VarInit']"{

    83

        if "count(path) != 1" error > VarInit «@id» must have only one variable given.

    84

        if "path/@type != 'PAGE_LOCAL' and path/@type != 'HMI_LOCAL'" error > VarInit «@id» only applies to HMI variable.

    85

        | "«path/@value»":«arg[1]/@value»`if "position()!=last()" > ,`

    86

    }

    87

    ||

    88

    };

    89

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

    90

    91

    function page_local_index(varname, pagename){

    92

        let pagevars = hmi_locals[pagename];

    93

        let new_index;

    94

        if(pagevars == undefined){

    95

            new_index = next_available_index++;

    96

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

    97

        } else {

    98

            let result = pagevars[varname];

    99

            if(result != undefined) {

   100

                return result;

   101

            }

   102

   103

            new_index = next_available_index++;

   104

            pagevars[varname] = new_index;

   105

        }

   106

        let defaultval = local_defaults[varname];

   107

        if(defaultval != undefined) 

   108

            cache[new_index] = defaultval; 

   109

        return new_index;

   110

    }

   111

   112

    function hmi_local_index(varname){

   113

        return page_local_index(varname, "HMI_LOCAL");

   114

    }

   115

    ||

   116

}

   117

   118

emit "preamble:widget-base-class" {

   119

    ||

   120

    var pending_widget_animates = [];

   121

   122

    class Widget {

   123

        offset = 0;

   124

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

   125

        unsubscribable = false;

   126

        pending_animate = false;

   127

   128

        constructor(elt_id,args,indexes,members){

   129

            this.element_id = elt_id;

   130

            this.element = id(elt_id);

   131

            this.args = args;

   132

            this.indexes = indexes;

   133

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

   134

        }

   135

   136

        unsub(){

   137

            /* remove subsribers */

   138

            if(!this.unsubscribable)

   139

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

   140

                    let index = this.indexes[i];

   141

                    if(this.relativeness[i])

   142

                        index += this.offset;

   143

                    subscribers(index).delete(this);

   144

                }

   145

            this.offset = 0;

   146

            this.relativeness = undefined;

   147

        }

   148

   149

        sub(new_offset=0, relativeness, container_id){

   150

            this.offset = new_offset;

   151

            this.relativeness = relativeness;

   152

            this.container_id = container_id ;

   153

            /* add this's subsribers */

   154

            if(!this.unsubscribable)

   155

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

   156

                    let index = this.get_variable_index(i);

   157

                    if(index == undefined) continue;

   158

                    subscribers(index).add(this);

   159

                }

   160

            need_cache_apply.push(this); 

   161

        }

   162

   163

        apply_cache() {

   164

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

   165

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

   166

                let realindex = this.get_variable_index(index);

   167

                if(realindex == undefined) continue;

   168

                let cached_val = cache[realindex];

   169

                if(cached_val != undefined)

   170

                    this._dispatch(cached_val, cached_val, index);

   171

            }

   172

        }

   173

   174

        get_variable_index(varnum) {

   175

            let index = this.indexes[varnum];

   176

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

   177

                index = page_local_index(index, this.container_id);

   178

            } else {

   179

                if(this.relativeness[varnum]){

   180

                    index += this.offset;

   181

                }

   182

            }

   183

            return index;

   184

        }

   185

        change_hmi_value(index, opstr) {

   186

            let realindex = this.get_variable_index(index);

   187

            if(realindex == undefined) return undefined;

   188

            return change_hmi_value(realindex, opstr);

   189

        }

   190

   191

        apply_hmi_value(index, new_val) {

   192

            let realindex = this.get_variable_index(index);

   193

            if(realindex == undefined) return undefined;

   194

            return apply_hmi_value(realindex, new_val);

   195

        }

   196

   197

        new_hmi_value(index, value, oldval) {

   198

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

   199

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

   200

                let refindex = this.get_variable_index(i);

   201

                if(refindex == undefined) continue;

   202

   203

                if(index == refindex) {

   204

                    this._dispatch(value, oldval, i);

   205

                    break;

   206

                }

   207

            }

   208

        }

   209

   210

        _dispatch(value, oldval, varnum) {

   211

            let dispatch = this.dispatch;

   212

            if(dispatch != undefined){

   213

                try {

   214

                    dispatch.call(this, value, oldval, varnum);

   215

                } catch(err) {

   216

                    console.log(err);

   217

                }

   218

            }

   219

        }

   220

   221

        _animate(){

   222

            this.animate();

   223

            this.pending_animate = false;

   224

        }

   225

   226

        request_animate(){

   227

            if(!this.pending_animate){

   228

                pending_widget_animates.push(this);

   229

                this.pending_animate = true;

   230

                requestHMIAnimation();

   231

            }

   232

   233

        }

   234

    }

   235

    ||

   236

}

   237

   238

emit "declarations:hmi-classes" {

   239

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

   240

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

   241

}

   242

   243

template "widget", mode="widget_class"

   244

||

   245

class «@type»Widget extends Widget{

   246

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

   247

}

   248

||

   249

   250

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

   251

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

   252

   253

emit "declarations:hmi-elements" {

   254

    | var hmi_widgets = {

   255

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

   256

    | }

   257

}

   258

   259

function "defs_by_labels" {

   260

    param "labels","''";

   261

    param "mandatory","'yes'";

   262

    param "subelements","/..";

   263

    param "hmi_element";

   264

    const "widget_type","@type";

   265

    foreach "str:split($labels)" {

   266

        const "name",".";

   267

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

   268

        choose {

   269

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

   270

                if "$mandatory='yes'" {

   271

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

   272

                }

   273

                // otherwise produce nothing

   274

            }

   275

            otherwise {

   276

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

   277

                if "$subelements" {

   278

                |     «$name»_sub: {

   279

                    foreach "str:split($subelements)" {

   280

                        const "subname",".";

   281

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

   282

                        choose {

   283

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

   284

                                if "$mandatory='yes'" {

   285

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

   286

                                }

   287

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

   288

                            }

   289

                            otherwise {

   290

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

   291

                            }

   292

                        }

   293

                    }

   294

                |     },

   295

                }

   296

            }

   297

        }

   298

    }

   299

}

   300

   301

def "func:escape_quotes" {

   302

    param "txt";

   303

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

   304

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

   305

    choose {

   306

        when !"contains($txt,'\"')"! {

   307

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

   308

        }

   309

        otherwise {

   310

            result "$txt";

   311

        }

   312

    }

   313

}

   314