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

    35

                    }

    36

                    when "@type = 'PAGE_LOCAL'" 

    37

                        > "«@value»"

    38

                    when "@type = 'HMI_LOCAL'" 

    39

                        > hmi_local_index("«@value»")

    40

                    otherwise 

    41

                        error > Internal error while processing widget's non indexed HMI tree path : unknown type

    42

                }

    43

            }

    44

            otherwise {

    45

                > «@index»

    46

            }

    47

        }

    48

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

    49

    }

    50

    51

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

    52

        choose {

    53

            when "@min and @max"

    54

                > [«@min»,«@max»]

    55

            otherwise

    56

                > undefined

    57

        }

    58

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

    59

    }

    60

    61

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

    62

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

    63

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

    64

}

    65

    66

emit "preamble:local-variable-indexes" {

    67

    ||

    68

    let hmi_locals = {};

    69

    var last_remote_index = hmitree_types.length - 1;

    70

    var next_available_index = hmitree_types.length;

    71

    let cookies = new Map(document.cookie.split("; ").map(s=>s.split("=")));

    72

    73

    const local_defaults = {

    74

    ||

    75

    foreach "$parsed_widgets/widget[starts-with(@type,'VarInit')]"{

    76

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

    77

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

    78

        >     "«path/@value»":

    79

        choose {

    80

            when "@type = 'VarInitPersistent'" > cookies.has("«path/@value»")?cookies.get("«path/@value»"):«arg[1]/@value»

    81

            otherwise > «arg[1]/@value»

    82

        }

    83

        > \n

    84

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

    85

    }

    86

    ||

    87

    };

    88

    89

    const persistent_locals = new Set([

    90

    ||

    91

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

    92

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

    93

    }

    94

    ||

    95

    ]);

    96

    var persistent_indexes = new Map();

    97

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

    98

    99

    function page_local_index(varname, pagename){

   100

        let pagevars = hmi_locals[pagename];

   101

        let new_index;

   102

        if(pagevars == undefined){

   103

            new_index = next_available_index++;

   104

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

   105

        } else {

   106

            let result = pagevars[varname];

   107

            if(result != undefined) {

   108

                return result;

   109

            }

   110

   111

            new_index = next_available_index++;

   112

            pagevars[varname] = new_index;

   113

        }

   114

        let defaultval = local_defaults[varname];

   115

        if(defaultval != undefined) {

   116

            cache[new_index] = defaultval; 

   117

            updates[new_index] = defaultval;

   118

            if(persistent_locals.has(varname))

   119

                persistent_indexes.set(new_index, varname);

   120

        }

   121

        return new_index;

   122

    }

   123

   124

    function hmi_local_index(varname){

   125

        return page_local_index(varname, "HMI_LOCAL");

   126

    }

   127

    ||

   128

}

   129

   130

emit "preamble:widget-base-class" {

   131

    ||

   132

    var pending_widget_animates = [];

   133

   134

    class Widget {

   135

        offset = 0;

   136

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

   137

        unsubscribable = false;

   138

        pending_animate = false;

   139

   140

        constructor(elt_id,args,indexes,minmaxes,members){

   141

            this.element_id = elt_id;

   142

            this.element = id(elt_id);

   143

            this.args = args;

   144

            this.indexes = indexes;

   145

            this.minmaxes = minmaxes;

   146

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

   147

        }

   148

   149

        unsub(){

   150

            /* remove subsribers */

   151

            if(!this.unsubscribable)

   152

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

   153

                    let index = this.indexes[i];

   154

                    if(this.relativeness[i])

   155

                        index += this.offset;

   156

                    subscribers(index).delete(this);

   157

                }

   158

            this.offset = 0;

   159

            this.relativeness = undefined;

   160

        }

   161

   162

        sub(new_offset=0, relativeness, container_id){

   163

            this.offset = new_offset;

   164

            this.relativeness = relativeness;

   165

            this.container_id = container_id ;

   166

            /* add this's subsribers */

   167

            if(!this.unsubscribable)

   168

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

   169

                    let index = this.get_variable_index(i);

   170

                    if(index == undefined) continue;

   171

                    subscribers(index).add(this);

   172

                }

   173

            need_cache_apply.push(this); 

   174

        }

   175

   176

        apply_cache() {

   177

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

   178

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

   179

                let realindex = this.get_variable_index(index);

   180

                if(realindex == undefined) continue;

   181

                let cached_val = cache[realindex];

   182

                if(cached_val != undefined)

   183

                    this._dispatch(cached_val, cached_val, index);

   184

            }

   185

        }

   186

   187

        get_variable_index(varnum) {

   188

            let index = this.indexes[varnum];

   189

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

   190

                index = page_local_index(index, this.container_id);

   191

            } else {

   192

                if(this.relativeness[varnum]){

   193

                    index += this.offset;

   194

                }

   195

            }

   196

            return index;

   197

        }

   198

   199

        overshot(new_val, max) {

   200

        }

   201

   202

        undershot(new_val, min) {

   203

        }

   204

   205

        clip_min_max(index, new_val) {

   206

            let minmax = this.minmaxes[index];

   207

            if(minmax !== undefined && typeof new_val == "number") {

   208

                let [min,max] = minmax;

   209

                if(new_val < min){

   210

                    this.undershot(new_val, min);

   211

                    return min;

   212

                }

   213

                if(new_val > max){

   214

                    this.overshot(new_val, max);

   215

                    return max;

   216

                }

   217

            }

   218

            return new_val;

   219

        }

   220

   221

        change_hmi_value(index, opstr) {

   222

            let realindex = this.get_variable_index(index);

   223

            if(realindex == undefined) return undefined;

   224

            let old_val = cache[realindex];

   225

            let new_val = eval_operation_string(old_val, opstr);

   226

            new_val = this.clip_min_max(index, new_val);

   227

            return apply_hmi_value(realindex, new_val);

   228

        }

   229

   230

        apply_hmi_value(index, new_val) {

   231

            let realindex = this.get_variable_index(index);

   232

            if(realindex == undefined) return undefined;

   233

            new_val = this.clip_min_max(index, new_val);

   234

            return apply_hmi_value(realindex, new_val);

   235

        }

   236

   237

        new_hmi_value(index, value, oldval) {

   238

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

   239

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

   240

                let refindex = this.get_variable_index(i);

   241

                if(refindex == undefined) continue;

   242

   243

                if(index == refindex) {

   244

                    this._dispatch(value, oldval, i);

   245

                    break;

   246

                }

   247

            }

   248

        }

   249

   250

        _dispatch(value, oldval, varnum) {

   251

            let dispatch = this.dispatch;

   252

            if(dispatch != undefined){

   253

                try {

   254

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

   255

                } catch(err) {

   256

                    console.log(err);

   257

                }

   258

            }

   259

        }

   260

   261

        _animate(){

   262

            this.animate();

   263

            this.pending_animate = false;

   264

        }

   265

   266

        request_animate(){

   267

            if(!this.pending_animate){

   268

                pending_widget_animates.push(this);

   269

                this.pending_animate = true;

   270

                requestHMIAnimation();

   271

            }

   272

   273

        }

   274

   275

        activate_activable(eltsub) {

   276

            eltsub.inactive.style.display = "none";

   277

            eltsub.active.style.display = "";

   278

        }

   279

   280

        inactivate_activable(eltsub) {

   281

            eltsub.active.style.display = "none";

   282

            eltsub.inactive.style.display = "";

   283

        }

   284

    }

   285

    ||

   286

}

   287

   288

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

   289

   290

// Key to filter unique types

   291

key "TypesKey", "widget", "@type";

   292

   293

emit "declarations:hmi-classes" {

   294

    const "used_widget_types", """$parsed_widgets/widget[

   295

                                    generate-id() = generate-id(key('TypesKey', @type)) and 

   296

                                    not(@type = $excluded_types)]""";

   297

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

   298

}

   299

   300

template "widget", mode="widget_class"

   301

||

   302

class «@type»Widget extends Widget{

   303

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

   304

}

   305

||

   306

   307

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

   308

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

   309

   310

emit "declarations:hmi-elements" {

   311

    | var hmi_widgets = {

   312

    apply "$hmi_widgets", mode="hmi_widgets";

   313

    | }

   314

}

   315

   316

function "defs_by_labels" {

   317

    param "labels","''";

   318

    param "mandatory","'yes'";

   319

    param "subelements","/..";

   320

    param "hmi_element";

   321

    const "widget_type","@type";

   322

    foreach "str:split($labels)" {

   323

        const "name",".";

   324

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

   325

        choose {

   326

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

   327

                if "$mandatory='yes'" {

   328

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

   329

                }

   330

                // otherwise produce nothing

   331

            }

   332

            otherwise {

   333

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

   334

                if "$subelements" {

   335

                |     «$name»_sub: {

   336

                    foreach "str:split($subelements)" {

   337

                        const "subname",".";

   338

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

   339

                        choose {

   340

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

   341

                                if "$mandatory='yes'" {

   342

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

   343

                                }

   344

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

   345

                            }

   346

                            otherwise {

   347

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

   348

                            }

   349

                        }

   350

                    }

   351

                |     },

   352

                }

   353

            }

   354

        }

   355

    }

   356

}

   357

   358

def "func:escape_quotes" {

   359

    param "txt";

   360

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

   361

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

   362

    choose {

   363

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

   364

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

   365

        }

   366

        otherwise {

   367

            result "$txt";

   368

        }

   369

    }

   370

}

   371