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 warning_labels(*ptr) alias - {

    18

    labels(*ptr){

    19

        with "mandatory","'warn'";

    20

        content;

    21

    }

    22

};

    23

    35

decl activable() alias - {

    42

decl activable_labels(*ptr) alias - {

    43

    optional_labels(*ptr) {

    44

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

    45

        content;

    46

    }

    47

};

    48

    49

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

    50

    type > «@type»

    51

    content;

    52

};

    53

    54

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

    55

    | class `text **clsname` extends Widget{

    56

    content;

    57

    | }

    58

};

    59

    60

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

    61

    param "hmi_element";

    66

    content;

    67

};

    68

    69

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

    70

    param "page_desc";

    71

    content;

    72

};

    73

    74

decl gen_index_xhtml alias - {

    75

    content;

    76

};

    77

    78

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

    79

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

    80

    const "eltid","@id";

    81

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

    82

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

    83

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

    84

    }

    85

    86

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

    87

        > [

    88

        choose {

    89

            when "not(@index)" {

    90

                choose {

    91

                    when "not(@type)" {

    92

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

    93

                        > undefined

    94

                    }

    95

                    when "@type = 'PAGE_LOCAL'" 

    96

                        > "«@value»"

    97

                    when "@type = 'HMI_LOCAL'" 

    98

                        > hmi_local_index("«@value»")

    99

                    otherwise 

   100

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

   101

                }

   102

            }

   103

            otherwise {

   104

                > «@index»

   105

            }

   106

        }

   107

        > , {

   108

        if "@min and @max"{

   109

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

   110

                if "@assign"

   111

                    > ,

   112

        }

   113

        if "@assign"

   114

                > assign:"«@assign»"

   115

        > }]

   116

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

   117

    }

   118

   119

    const "freq" choose {

   120

        when "$widget/@freq"

   121

            > "«$widget/@freq»"

   122

        otherwise

   123

            > undefined

   124

    }

   125

   126

    const "enable_expr" choose{

   127

        when "$widget/@enable_expr"

   128

            > true

   129

        otherwise

   130

            > false

   131

    }

   132

   133

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

   134

    if "$widget/@enable_expr" {

   135

   136

    |       assignments: [],

   137

    |       compute_enable: function(value, oldval, varnum) {

   138

    |         let result = false;

   139

    |         do {

   140

        foreach "$widget/path" {

   141

            const "varid","generate-id()";

   142

            const "varnum","position()-1";

   143

            if "@assign" foreach "$widget/path[@assign]" if "$varid = generate-id()" {

   144

    |           if(varnum == «$varnum») this.assignments[«position()-1»] = value;

   145

    |           let «@assign» = this.assignments[«position()-1»];

   146

    |           if(«@assign» == undefined) break;

   147

            }

   148

        }

   149

    |           result = «$widget/@enable_expr»;

   150

    |         } while(0);

   151

    |         this.enable(result);

   152

    |       },

   153

    }

   154

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

   155

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

   156

}

   157

   158

emit "preamble:local-variable-indexes" {

   159

    ||

   160

   161

    let hmi_locals = {};

   162

    var last_remote_index = hmitree_types.length - 1;

   163

    var next_available_index = hmitree_types.length;

   164

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

   165

   166

    const local_defaults = {

   167

    ||

   168

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

   169

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

   170

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

   171

        >     "«path/@value»":

   172

        choose {

   173

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

   174

            otherwise > «arg[1]/@value»

   175

        }

   176

        > \n

   177

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

   178

    }

   179

    ||

   180

    };

   181

   182

    const persistent_locals = new Set([

   183

    ||

   184

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

   185

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

   186

    }

   187

    ||

   188

    ]);

   189

    var persistent_indexes = new Map();

   190

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

   191

    var updates = new Map();

   192

   193

    function page_local_index(varname, pagename){

   194

        let pagevars = hmi_locals[pagename];

   195

        let new_index;

   196

        if(pagevars == undefined){

   197

            new_index = next_available_index++;

   198

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

   199

        } else {

   200

            let result = pagevars[varname];

   201

            if(result != undefined) {

   202

                return result;

   203

            }

   204

   205

            new_index = next_available_index++;

   206

            pagevars[varname] = new_index;

   207

        }

   208

        let defaultval = local_defaults[varname];

   209

        if(defaultval != undefined) {

   210

            cache[new_index] = defaultval; 

   211

            updates.set(new_index, defaultval);

   212

            if(persistent_locals.has(varname))

   213

                persistent_indexes.set(new_index, varname);

   214

        }

   215

        return new_index;

   216

    }

   217

   218

    function hmi_local_index(varname){

   219

        return page_local_index(varname, "HMI_LOCAL");

   220

    }

   221

    ||

   222

}

   223

   224

emit "preamble:widget-base-class" {

   225

    ||

   226

    var pending_widget_animates = [];

   227

   228

    function _hide(elt, placeholder){

   229

        if(elt.parentNode != null)

   230

            placeholder.parentNode.removeChild(elt);

   231

    }

   232

    function _show(elt, placeholder){

   233

        placeholder.parentNode.insertBefore(elt, placeholder);

   234

    }

   235

   236

    function set_activation_state(eltsub, state){

   237

        if(eltsub.active_elt != undefined){

   238

            if(eltsub.active_elt_placeholder == undefined){

   239

                eltsub.active_elt_placeholder = document.createComment("");

   240

                eltsub.active_elt.parentNode.insertBefore(eltsub.active_elt_placeholder, eltsub.active_elt);

   241

            }

   242

            (state?_show:_hide)(eltsub.active_elt, eltsub.active_elt_placeholder);

   243

        }

   244

        if(eltsub.inactive_elt != undefined){

   245

            if(eltsub.inactive_elt_placeholder == undefined){

   246

                eltsub.inactive_elt_placeholder = document.createComment("");

   247

                eltsub.inactive_elt.parentNode.insertBefore(eltsub.inactive_elt_placeholder, eltsub.inactive_elt);

   248

            }

   249

            ((state || state==undefined)?_hide:_show)(eltsub.inactive_elt, eltsub.inactive_elt_placeholder);

   250

        }

   251

    }

   252

   253

    function activate_activable(eltsub) {

   254

        set_activation_state(eltsub, true);

   255

    }

   256

   257

    function inactivate_activable(eltsub) {

   258

        set_activation_state(eltsub, false);

   259

    }

   260

   261

    class Widget {

   262

        offset = 0;

   263

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

   264

        unsubscribable = false;

   265

        pending_animate = false;

   266

   267

        constructor(elt_id, freq, args, variables, enable_expr, members){

   268

            this.element_id = elt_id;

   269

            this.element = id(elt_id);

   270

            this.args = args;

   271

            [this.indexes, this.variables_options] = (variables.length>0) ? zip(...variables) : [[],[]];

   272

            this.indexes_length = this.indexes.length;

   273

            this.enable_expr = enable_expr;

   278

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

   279

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

   280

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

   281

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

   282

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

   283

   284

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

   285

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

   286

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

   287

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

   288

   289

            this.forced_frequency = freq;

   290

            this.clip = true;

   291

        }

   292

   293

        do_init(){

   294

            let forced = this.forced_frequency;

   295

            if(forced !== undefined){

   296

                /*

   297

                once every 10 seconds : 10s

   298

                once per minute : 1m

   299

                once per hour : 1h

   300

                once per day : 1d

   301

                */

   302

                let unit = forced.slice(-1);

   303

                let factor = {

   304

                    "s":1,

   305

                    "m":60,

   306

                    "h":3600,

   307

                    "d":86400}[unit];

   308

   309

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

   310

                                          : Number(forced);

   311

            }

   312

   313

            let init = this.init;

   314

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

   315

                try {

   316

                    init.call(this);

   317

                } catch(err) {

   318

                    console.log(err);

   319

                }

   320

            }

   321

   322

            if(this.enable_expr){

   323

                this.enable_state = false;

   324

                this.enable_displayed_state = false;

   325

                for(let child of Array.from(this.element.children)){

   328

                        this.enabled_elts.push(child);

   329

                        this.element.removeChild(child);

   330

                    }

   331

                }

   332

            }

   333

        }

   334

   335

        unsub(){

   336

            /* remove subsribers */

   356

            this.offset = 0;

   357

            this.relativeness = undefined;

   358

        }

   359

   360

        sub(new_offset=0, relativeness, container_id){

   361

            this.offset = new_offset;

   362

            this.relativeness = relativeness;

   363

            this.container_id = container_id ;

   364

            /* add this's subsribers */

   370

            need_cache_apply.push(this); 

   371

        }

   372

   373

        apply_cache() {

   375

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

   376

                let realindex = this.get_variable_index(index);

   377

                if(realindex == undefined) continue;

   378

                let cached_val = cache[realindex];

   379

                if(cached_val != undefined)

   380

                    this._dispatch(cached_val, cached_val, index);

   381

            }

   382

        }

   383

   384

        get_variable_index(varnum) {

   385

            let index = this.indexes[varnum];

   386

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

   387

                index = page_local_index(index, this.container_id);

   388

            } else {

   389

                if(this.relativeness[varnum]){

   390

                    index += this.offset;

   391

                }

   392

            }

   393

            return index;

   394

        }

   395

   396

        overshot(new_val, max) {

   397

        }

   398

   399

        undershot(new_val, min) {

   400

        }

   401

   402

        clip_min_max(index, new_val) {

   403

            let minmax = this.variables_options[index].minmax;

   404

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

   405

                let [min,max] = minmax;

   406

                if(new_val < min){

   407

                    this.undershot(new_val, min);

   408

                    return min;

   409

                }

   410

                if(new_val > max){

   411

                    this.overshot(new_val, max);

   412

                    return max;

   413

                }

   414

            }

   415

            return new_val;

   416

        }

   417

   418

        change_hmi_value(index, opstr) {

   419

            let realindex = this.get_variable_index(index);

   420

            if(realindex == undefined) return undefined;

   421

            let old_val = cache[realindex];

   422

            let new_val = eval_operation_string(old_val, opstr);

   423

            if(this.clip)

   424

                new_val = this.clip_min_max(index, new_val);

   425

            return apply_hmi_value(realindex, new_val);

   426

        }

   427

   428

        _apply_hmi_value(index, new_val) {

   429

            let realindex = this.get_variable_index(index);

   430

            if(realindex == undefined) return undefined;

   431

            if(this.clip)

   432

                new_val = this.clip_min_max(index, new_val);

   433

            return apply_hmi_value(realindex, new_val);

   434

        }

   435

   436

        uninhibit(index){

   437

            this.inhibit[index] = undefined;

   438

            let new_val = this.pending[index];

   439

            this.pending[index] = undefined;

   440

            return this.apply_hmi_value(index, new_val);

   441

        }

   442

   443

        apply_hmi_value(index, new_val) {

   444

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

   445

                let now = Date.now();

   446

                let min_interval = 1000/this.frequency;

   447

                let lastapply = this.lastapply[index];

   448

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

   449

                    this.lastapply[index] = now;

   450

                    return this._apply_hmi_value(index, new_val);

   451

                }

   452

                else {

   453

                    let elapsed = now - lastapply;

   454

                    this.pending[index] = new_val;

   455

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

   456

                }

   457

            }

   458

            else {

   459

                this.pending[index] = new_val;

   460

                return new_val;

   461

            }

   462

        }

   463

   464

        new_hmi_value(index, value, oldval) {

   465

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

   466

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

   467

                let refindex = this.get_variable_index(i);

   468

                if(refindex == undefined) continue;

   469

   470

                if(index == refindex) {

   471

                    this._dispatch(value, oldval, i);

   472

                    break;

   473

                }

   474

            }

   475

        }

   476

   477

        undeafen(index){

   478

            this.deafen[index] = undefined;

   479

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

   480

            this.incoming[index] = undefined;

   481

            this.dispatch(new_val, old_val, index);

   482

        }

   483

   484

        enable(enabled){

   485

            if(this.enable_state != enabled){