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

    44

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

    45

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

    46

    const "eltid","@id";

    47

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

    48

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

    49

        choose {

    50

            when "not(@index)" {

    51

                choose {

    52

                    when "not(@type)" {

    53

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

    54

                        > undefined

    55

                    }

    56

                    when "@type = 'PAGE_LOCAL'" 

    57

                        > "«@value»"

    58

                    when "@type = 'HMI_LOCAL'" 

    59

                        > hmi_local_index("«@value»")

    60

                    otherwise 

    61

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

    62

                }

    63

            }

    64

            otherwise {

    65

                > «@index»

    66

            }

    67

        }

    68

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

    69

    }

    70

    71

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

    72

        choose {

    73

            when "@min and @max"

    74

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

    75

            otherwise

    76

                > undefined

    77

        }

    78

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

    79

    }

    80

    81

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

    82

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

    83

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

    84

}

    85

    86

emit "preamble:local-variable-indexes" {

    87

    ||

    88

    89

    let hmi_locals = {};

    90

    var last_remote_index = hmitree_types.length - 1;

    91

    var next_available_index = hmitree_types.length;

    92

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

    93

    94

    const local_defaults = {

    95

    ||

    96

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

    97

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

    98

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

    99

        >     "«path/@value»":

   100

        choose {

   101

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

   102

            otherwise > «arg[1]/@value»

   103

        }

   104

        > \n

   105

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

   106

    }

   107

    ||

   108

    };

   109

   110

    const persistent_locals = new Set([

   111

    ||

   112

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

   113

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

   114

    }

   115

    ||

   116

    ]);

   117

    var persistent_indexes = new Map();

   118

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

   119

    var updates = new Map();

   120

   121

    function page_local_index(varname, pagename){

   122

        let pagevars = hmi_locals[pagename];

   123

        let new_index;

   124

        if(pagevars == undefined){

   125

            new_index = next_available_index++;

   126

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

   127

        } else {

   128

            let result = pagevars[varname];

   129

            if(result != undefined) {

   130

                return result;

   131

            }

   132

   133

            new_index = next_available_index++;

   134

            pagevars[varname] = new_index;

   135

        }

   136

        let defaultval = local_defaults[varname];

   137

        if(defaultval != undefined) {

   138

            cache[new_index] = defaultval; 

   139

            updates.set(new_index, defaultval);

   140

            if(persistent_locals.has(varname))

   141

                persistent_indexes.set(new_index, varname);

   142

        }

   143

        return new_index;

   144

    }

   145

   146

    function hmi_local_index(varname){

   147

        return page_local_index(varname, "HMI_LOCAL");

   148

    }

   149

    ||

   150

}

   151

   152

emit "preamble:widget-base-class" {

   153

    ||

   154

    var pending_widget_animates = [];

   155

   156

    class Widget {

   157

        offset = 0;

   158

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

   159

        unsubscribable = false;

   160

        pending_animate = false;

   161

   162

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

   163

            this.element_id = elt_id;

   164

            this.element = id(elt_id);

   165

            this.args = args;

   166

            this.indexes = indexes;

   167

            this.minmaxes = minmaxes;

   168

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

   169

            this.lastapply = indexes.map(() => undefined);

   170

            this.inhibit = indexes.map(() => undefined);

   171

            this.pending = indexes.map(() => undefined);

   172

            this.bound_unhinibit = this.unhinibit.bind(this);

   173

        }

   174

   175

        unsub(){

   176

            /* remove subsribers */

   177

            if(!this.unsubscribable)

   178

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

   179

                    /* flush updates pending because of inhibition */

   180

                    let inhibition = this.inhibit[i];

   181

                    if(inhibition != undefined){

   182

                        clearTimeout(inhibition);

   183

                        this.lastapply[i] = undefined;

   184

                        this.unhinibit(i);

   185

                    }

   186

                    let index = this.indexes[i];

   187

                    if(this.relativeness[i])

   188

                        index += this.offset;

   189

                    subscribers(index).delete(this);

   190

                }

   191

            this.offset = 0;

   192

            this.relativeness = undefined;

   193

        }

   194

   195

        sub(new_offset=0, relativeness, container_id){

   196

            this.offset = new_offset;

   197

            this.relativeness = relativeness;

   198

            this.container_id = container_id ;

   199

            /* add this's subsribers */

   200

            if(!this.unsubscribable)

   201

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

   202

                    let index = this.get_variable_index(i);

   203

                    if(index == undefined) continue;

   204

                    subscribers(index).add(this);

   205

                }

   206

            need_cache_apply.push(this); 

   207

        }

   208

   209

        apply_cache() {

   210

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

   211

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

   212

                let realindex = this.get_variable_index(index);

   213

                if(realindex == undefined) continue;

   214

                let cached_val = cache[realindex];

   215

                if(cached_val != undefined)

   216

                    this._dispatch(cached_val, cached_val, index);

   217

            }

   218

        }

   219

   220

        get_variable_index(varnum) {

   221

            let index = this.indexes[varnum];

   222

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

   223

                index = page_local_index(index, this.container_id);

   224

            } else {

   225

                if(this.relativeness[varnum]){

   226

                    index += this.offset;

   227

                }

   228

            }

   229

            return index;

   230

        }

   231

   232

        overshot(new_val, max) {

   233

        }

   234

   235

        undershot(new_val, min) {

   236

        }

   237

   238

        clip_min_max(index, new_val) {

   239

            let minmax = this.minmaxes[index];

   240

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

   241

                let [min,max] = minmax;

   242

                if(new_val < min){

   243

                    this.undershot(new_val, min);

   244

                    return min;

   245

                }

   246

                if(new_val > max){

   247

                    this.overshot(new_val, max);

   248

                    return max;

   249

                }

   250

            }

   251

            return new_val;

   252

        }

   253

   254

        change_hmi_value(index, opstr) {

   255

            let realindex = this.get_variable_index(index);

   256

            if(realindex == undefined) return undefined;

   257

            let old_val = cache[realindex];

   258

            let new_val = eval_operation_string(old_val, opstr);

   259

            new_val = this.clip_min_max(index, new_val);

   260

            return apply_hmi_value(realindex, new_val);

   261

        }

   262

   263

        _apply_hmi_value(index, new_val) {

   264

            let realindex = this.get_variable_index(index);

   265

            if(realindex == undefined) return undefined;

   266

            new_val = this.clip_min_max(index, new_val);

   267

            return apply_hmi_value(realindex, new_val);

   268

        }

   269

   270

        unhinibit(index){

   271

            this.inhibit[index] = undefined;

   272

            let new_val = this.pending[index];

   273

            this.pending[index] = undefined;

   274

            return this.apply_hmi_value(index, new_val);

   275

        }

   276

   277

        apply_hmi_value(index, new_val) {

   278

            if(this.inhibit[index] == undefined){

   279

                let now = Date.now();

   280

                let min_interval = 1000/this.frequency;

   281

                let lastapply = this.lastapply[index];

   282

                if(lastapply == undefined || now > lastapply + min_interval){

   283

                    this.lastapply[index] = now;

   284

                    return this._apply_hmi_value(index, new_val);

   285

                }

   286

                else {

   287

                    let elapsed = now - lastapply;

   288

                    this.pending[index] = new_val;

   289

                    this.inhibit[index] = setTimeout(this.bound_unhinibit, min_interval - elapsed, index);

   290

                }

   291

            }

   292

            else {

   293

                this.pending[index] = new_val;

   294

                return new_val;

   295

            }

   296

        }

   297

   298

        new_hmi_value(index, value, oldval) {

   299

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

   300

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

   301

                let refindex = this.get_variable_index(i);

   302

                if(refindex == undefined) continue;

   303

   304

                if(index == refindex) {

   305

                    this._dispatch(value, oldval, i);

   306

                    break;

   307

                }

   308

            }

   309

        }

   310

   311

        _dispatch(value, oldval, varnum) {

   312

            let dispatch = this.dispatch;

   313

            if(dispatch != undefined){

   314

                try {

   315

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

   316

                } catch(err) {

   317

                    console.log(err);

   318

                }

   319

            }

   320

        }

   321

   322

        _animate(){

   323

            this.animate();

   324

            this.pending_animate = false;

   325

        }

   326

   327

        request_animate(){

   328

            if(!this.pending_animate){

   329

                pending_widget_animates.push(this);

   330

                this.pending_animate = true;

   331

                requestHMIAnimation();

   332

            }

   333

   334

        }

   335

   336

        activate_activable(eltsub) {

   337

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

   338

            eltsub.active.style.display = "";

   339

        }

   340

   341

        inactivate_activable(eltsub) {

   342

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

   343

            eltsub.inactive.style.display = "";

   344

        }

   345

    }

   346

    ||

   347

}

   348

   349

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

   350

   351

// Key to filter unique types

   352

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

   353

   354

emit "declarations:hmi-classes" {

   355

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

   356

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

   357

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

   358

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

   359

}

   360

   361

template "widget", mode="widget_class"

   362

||

   363

class «@type»Widget extends Widget{

   364

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

   365

}

   366

||

   367

   368

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

   369

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

   370

const "result_widgets","$result_svg_ns//*[@id = $hmi_widgets/@id]";

   371

   372

emit "declarations:hmi-elements" {

   373

    | var hmi_widgets = {

   374

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

   375

    | }

   376

}

   377

   378

function "defs_by_labels" {

   379

    param "labels","''";

   380

    param "mandatory","'yes'";

   381

    param "subelements","/..";

   382

    param "hmi_element";

   383

    const "widget_type","@type";

   384

    foreach "str:split($labels)" {

   385

        const "name",".";

   386

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

   387

        choose {

   388

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

   389

                if "$mandatory='yes'" {

   390

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

   391

                }

   392

                // otherwise produce nothing

   393

            }

   394

            otherwise {

   395

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

   396

                if "$subelements" {

   397

                |     «$name»_sub: {

   398

                    foreach "str:split($subelements)" {

   399

                        const "subname",".";

   400

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

   401

                        choose {

   402

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

   403

                                if "$mandatory='yes'" {

   404

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

   405

                                }

   406

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

   407

                            }

   408

                            otherwise {

   409

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

   410

                            }

   411

                        }

   412

                    }

   413

                |     },

   414

                }

   415

            }

   416

        }

   417

    }

   418

}

   419

   420

def "func:escape_quotes" {

   421

    param "txt";

   422

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

   423

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

   424

    choose {

   425

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

   426

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

   427

        }

   428

        otherwise {

   429

            result "$txt";

   430

        }

   431

    }

   432

}

   433