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

    24

decl activable_labels(*ptr) alias - {

    25

    optional_labels(*ptr) {

    26

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

    27

        content;

    28

    }

    29

};

    30

    31

in xsl decl widget_desc(%name, match="widget[@type='%name']", mode="widget_desc") alias template {

    32

    type > «@type»

    33

    content;

    34

};

    35

    36

in xsl decl widget_class(%name, *clsname="%nameWidget", match="widget[@type='%name']", mode="widget_class") alias template {

    37

    | class `text **clsname` extends Widget{

    38

    content;

    39

    | }

    40

};

    41

    42

in xsl decl widget_defs(%name, match="widget[@type='%name']", mode="widget_defs") alias template {

    43

    param "hmi_element";

    44

    content;

    45

};

    46

    47

in xsl decl widget_page(%name, match="widget[@type='%name']", mode="widget_page") alias template {

    48

    param "page_desc";

    49

    content;

    50

};

    51

    52

decl gen_index_xhtml alias - {

    53

    content;

    54

};

    55

    56

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

    57

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

    58

    const "eltid","@id";

    59

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

    60

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

    61

        choose {

    62

            when "not(@index)" {

    63

                choose {

    64

                    when "not(@type)" {

    65

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

    66

                        > undefined

    67

                    }

    68

                    when "@type = 'PAGE_LOCAL'" 

    69

                        > "«@value»"

    70

                    when "@type = 'HMI_LOCAL'" 

    71

                        > hmi_local_index("«@value»")

    72

                    otherwise 

    73

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

    74

                }

    75

            }

    76

            otherwise {

    77

                > «@index»

    78

            }

    79

        }

    80

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

    81

    }

    82

    83

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

    84

        choose {

    85

            when "@min and @max"

    86

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

    87

            otherwise

    88

                > undefined

    89

        }

    90

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

    91

    }

    92

    93

    const "freq" choose {

    94

        when "$widget/@freq"

    95

            > "«$widget/@freq»"

    96

        otherwise

    97

            > undefined

    98

    }

    99

   100

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

   101

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

   102

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

   103

}

   104

   105

emit "preamble:local-variable-indexes" {

   106

    ||

   107

   108

    let hmi_locals = {};

   109

    var last_remote_index = hmitree_types.length - 1;

   110

    var next_available_index = hmitree_types.length;

   111

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

   112

   113

    const local_defaults = {

   114

    ||

   115

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

   116

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

   117

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

   118

        >     "«path/@value»":

   119

        choose {

   120

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

   121

            otherwise > «arg[1]/@value»

   122

        }

   123

        > \n

   124

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

   125

    }

   126

    ||

   127

    };

   128

   129

    const persistent_locals = new Set([

   130

    ||

   131

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

   132

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

   133

    }

   134

    ||

   135

    ]);

   136

    var persistent_indexes = new Map();

   137

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

   138

    var updates = new Map();

   139

   140

    function page_local_index(varname, pagename){

   141

        let pagevars = hmi_locals[pagename];

   142

        let new_index;

   143

        if(pagevars == undefined){

   144

            new_index = next_available_index++;

   145

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

   146

        } else {

   147

            let result = pagevars[varname];

   148

            if(result != undefined) {

   149

                return result;

   150

            }

   151

   152

            new_index = next_available_index++;

   153

            pagevars[varname] = new_index;

   154

        }

   155

        let defaultval = local_defaults[varname];

   156

        if(defaultval != undefined) {

   157

            cache[new_index] = defaultval; 

   158

            updates.set(new_index, defaultval);

   159

            if(persistent_locals.has(varname))

   160

                persistent_indexes.set(new_index, varname);

   161

        }

   162

        return new_index;

   163

    }

   164

   165

    function hmi_local_index(varname){

   166

        return page_local_index(varname, "HMI_LOCAL");

   167

    }

   168

    ||

   169

}

   170

   171

emit "preamble:widget-base-class" {

   172

    ||

   173

    var pending_widget_animates = [];

   174

   202

    class Widget {

   203

        offset = 0;

   204

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

   205

        unsubscribable = false;

   206

        pending_animate = false;

   207

   208

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

   209

            this.element_id = elt_id;

   210

            this.element = id(elt_id);

   211

            this.args = args;

   212

            this.indexes = indexes;

   213

            this.minmaxes = minmaxes;

   214

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

   215

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

   216

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

   217

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

   218

            this.bound_uninhibit = this.uninhibit.bind(this);

   219

   220

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

   221

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

   222

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

   223

            this.bound_undeafen = this.undeafen.bind(this);

   224

   225

            this.forced_frequency = freq;

   226

            this.clip = true;

   227

        }

   228

   229

        do_init(){

   230

            let forced = this.forced_frequency;

   231

            if(forced !== undefined){

   232

                /*

   233

                once every 10 seconds : 10s

   234

                once per minute : 1m

   235

                once per hour : 1h

   236

                once per day : 1d

   237

                */

   238

                let unit = forced.slice(-1);

   239

                let factor = {

   240

                    "s":1,

   241

                    "m":60,

   242

                    "h":3600,

   243

                    "d":86400}[unit];

   244

   245

                this.frequency = factor ? 1/(factor * Number(forced.slice(0,-1)))

   246

                                          : Number(forced);

   247

            }

   248

   249

            let init = this.init;

   250

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

   251

                try {

   252

                    init.call(this);

   253

                } catch(err) {

   254

                    console.log(err);

   255

                }

   256

            }

   257

        }

   258

   259

        unsub(){

   260

            /* remove subsribers */

   261

            if(!this.unsubscribable)

   262

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

   263

                    /* flush updates pending because of inhibition */

   264

                    let inhibition = this.inhibit[i];

   265

                    if(inhibition != undefined){

   266

                        clearTimeout(inhibition);

   267

                        this.lastapply[i] = undefined;

   268

                        this.uninhibit(i);

   269

                    }

   270

                    let deafened = this.deafen[i];

   271

                    if(deafened != undefined){

   272

                        clearTimeout(deafened);

   273

                        this.lastdispatch[i] = undefined;

   274

                        this.undeafen(i);

   275

                    }

   276

                    let index = this.indexes[i];

   277

                    if(this.relativeness[i])

   278

                        index += this.offset;

   279

                    subscribers(index).delete(this);

   280

                }

   281

            this.offset = 0;

   282

            this.relativeness = undefined;

   283

        }

   284

   285

        sub(new_offset=0, relativeness, container_id){

   286

            this.offset = new_offset;

   287

            this.relativeness = relativeness;

   288

            this.container_id = container_id ;

   289

            /* add this's subsribers */

   290

            if(!this.unsubscribable)

   291

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

   292

                    let index = this.get_variable_index(i);

   293

                    if(index == undefined) continue;

   294

                    subscribers(index).add(this);

   295

                }

   296

            need_cache_apply.push(this); 

   297

        }

   298

   299

        apply_cache() {

   300

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

   301

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

   302

                let realindex = this.get_variable_index(index);

   303

                if(realindex == undefined) continue;

   304

                let cached_val = cache[realindex];

   305

                if(cached_val != undefined)

   306

                    this._dispatch(cached_val, cached_val, index);

   307

            }

   308

        }

   309

   310

        get_variable_index(varnum) {

   311

            let index = this.indexes[varnum];

   312

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

   313

                index = page_local_index(index, this.container_id);

   314

            } else {

   315

                if(this.relativeness[varnum]){

   316

                    index += this.offset;

   317

                }

   318

            }

   319

            return index;

   320

        }

   321

   322

        overshot(new_val, max) {

   323

        }

   324

   325

        undershot(new_val, min) {

   326

        }

   327

   328

        clip_min_max(index, new_val) {

   329

            let minmax = this.minmaxes[index];

   330

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

   331

                let [min,max] = minmax;

   332

                if(new_val < min){

   333

                    this.undershot(new_val, min);

   334

                    return min;

   335

                }

   336

                if(new_val > max){

   337

                    this.overshot(new_val, max);

   338

                    return max;

   339

                }

   340

            }

   341

            return new_val;

   342

        }

   343

   344

        change_hmi_value(index, opstr) {

   345

            let realindex = this.get_variable_index(index);

   346

            if(realindex == undefined) return undefined;

   347

            let old_val = cache[realindex];

   348

            let new_val = eval_operation_string(old_val, opstr);

   349

            if(this.clip)

   350

                new_val = this.clip_min_max(index, new_val);

   351

            return apply_hmi_value(realindex, new_val);

   352

        }

   353

   354

        _apply_hmi_value(index, new_val) {

   355

            let realindex = this.get_variable_index(index);

   356

            if(realindex == undefined) return undefined;

   357

            if(this.clip)

   358

                new_val = this.clip_min_max(index, new_val);

   359

            return apply_hmi_value(realindex, new_val);

   360

        }

   361

   362

        uninhibit(index){

   363

            this.inhibit[index] = undefined;

   364

            let new_val = this.pending[index];

   365

            this.pending[index] = undefined;

   366

            return this.apply_hmi_value(index, new_val);

   367

        }

   368

   369

        apply_hmi_value(index, new_val) {

   370

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

   371

                let now = Date.now();

   372

                let min_interval = 1000/this.frequency;

   373

                let lastapply = this.lastapply[index];

   374

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

   375

                    this.lastapply[index] = now;

   376

                    return this._apply_hmi_value(index, new_val);

   377

                }

   378

                else {

   379

                    let elapsed = now - lastapply;

   380

                    this.pending[index] = new_val;

   381

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

   382

                }

   383

            }

   384

            else {

   385

                this.pending[index] = new_val;

   386

                return new_val;

   387

            }

   388

        }

   389

   390

        new_hmi_value(index, value, oldval) {

   391

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

   392

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

   393

                let refindex = this.get_variable_index(i);

   394

                if(refindex == undefined) continue;

   395

   396

                if(index == refindex) {

   397

                    this._dispatch(value, oldval, i);

   398

                    break;

   399

                }

   400

            }

   401

        }

   402

   403

        undeafen(index){

   404

            this.deafen[index] = undefined;

   405

            let [new_val, old_val] = this.incoming[index];

   406

            this.incoming[index] = undefined;

   407

            this.dispatch(new_val, old_val, index);

   408

        }

   409

   410

        _dispatch(value, oldval, varnum) {

   411

            let dispatch = this.dispatch;

   412

            if(dispatch != undefined){

   413

                if(this.deafen[varnum] == undefined){

   414

                    let now = Date.now();

   415

                    let min_interval = 1000/this.frequency;

   416

                    let lastdispatch = this.lastdispatch[varnum];

   417

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

   418

                        this.lastdispatch[varnum] = now;

   419

                        try {

   420

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

   421

                        } catch(err) {

   422

                            console.log(err);

   423

                        }

   424

                    }

   425

                    else {

   426

                        let elapsed = now - lastdispatch;

   427

                        this.incoming[varnum] = [value, oldval];

   428

                        this.deafen[varnum] = setTimeout(this.bound_undeafen, min_interval - elapsed, varnum);

   429

                    }

   430

                }

   431

                else {

   432

                    this.incoming[varnum] = [value, oldval];

   433

                }

   434

            }

   435

        }

   436

   437

        _animate(){

   438

            this.animate();

   439

            this.pending_animate = false;

   440

        }

   441

   442

        request_animate(){

   443

            if(!this.pending_animate){

   444

                pending_widget_animates.push(this);

   445

                this.pending_animate = true;

   446

                requestHMIAnimation();

   447

            }

   452

        }

   453

    }

   454

    ||

   455

}

   456

   457

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

   458

   459

// Key to filter unique types

   460

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

   461

   462

emit "declarations:hmi-classes" {

   463

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

   464

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

   465

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

   466

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

   467

}

   468

   469

template "widget", mode="widget_class"

   470

||

   471

class «@type»Widget extends Widget{

   472

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

   473

}

   474

||

   475

   476

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

   477

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

   478

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

   479

   480

emit "declarations:hmi-elements" {

   481

    | var hmi_widgets = {

   482

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

   483

    | }

   484

}

   485