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

    24

decl activable() alias - {

    25

    |     activable_sub:{

    26

    warning_labels("/active /inactive") {

    27

        content;

    28

    }

    29

    |     }

    30

};

    31

decl activable_labels(*ptr) alias - {

    32

    optional_labels(*ptr) {

    33

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

    34

        content;

    35

    }

    36

};

    37

    38

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

    39

    type > «@type»

    40

    content;

    41

};

    42

    43

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

    44

    | class `text **clsname` extends Widget{

    45

    content;

    46

    | }

    47

};

    48

    49

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

    50

    param "hmi_element";

    51

    content;

    52

};

    53

    54

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

    55

    param "page_desc";

    56

    content;

    57

};

    58

    59

decl gen_index_xhtml alias - {

    60

    content;

    61

};

    62

    63

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

    64

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

    65

    const "eltid","@id";

    66

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

    67

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

    68

        choose {

    69

            when "not(@index)" {

    70

                choose {

    71

                    when "not(@type)" {

    72

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

    73

                        > undefined

    74

                    }

    75

                    when "@type = 'PAGE_LOCAL'" 

    76

                        > "«@value»"

    77

                    when "@type = 'HMI_LOCAL'" 

    78

                        > hmi_local_index("«@value»")

    79

                    otherwise 

    80

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

    81

                }

    82

            }

    83

            otherwise {

    84

                > «@index»

    85

            }

    86

        }

    87

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

    88

    }

    89

    90

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

    91

        choose {

    92

            when "@min and @max"

    93

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

    94

            otherwise

    95

                > undefined

    96

        }

    97

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

    98

    }

    99

   100

    const "freq" choose {

   101

        when "$widget/@freq"

   102

            > "«$widget/@freq»"

   103

        otherwise

   104

            > undefined

   105

    }

   106

   107

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

   108

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

   109

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

   110

}

   111

   112

emit "preamble:local-variable-indexes" {

   113

    ||

   114

   115

    let hmi_locals = {};

   116

    var last_remote_index = hmitree_types.length - 1;

   117

    var next_available_index = hmitree_types.length;

   118

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

   119

   120

    const local_defaults = {

   121

    ||

   122

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

   123

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

   124

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

   125

        >     "«path/@value»":

   126

        choose {

   127

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

   128

            otherwise > «arg[1]/@value»

   129

        }

   130

        > \n

   131

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

   132

    }

   133

    ||

   134

    };

   135

   136

    const persistent_locals = new Set([

   137

    ||

   138

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

   139

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

   140

    }

   141

    ||

   142

    ]);

   143

    var persistent_indexes = new Map();

   144

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

   145

    var updates = new Map();

   146

   147

    function page_local_index(varname, pagename){

   148

        let pagevars = hmi_locals[pagename];

   149

        let new_index;

   150

        if(pagevars == undefined){

   151

            new_index = next_available_index++;

   152

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

   153

        } else {

   154

            let result = pagevars[varname];

   155

            if(result != undefined) {

   156

                return result;

   157

            }

   158

   159

            new_index = next_available_index++;

   160

            pagevars[varname] = new_index;

   161

        }

   162

        let defaultval = local_defaults[varname];

   163

        if(defaultval != undefined) {

   164

            cache[new_index] = defaultval; 

   165

            updates.set(new_index, defaultval);

   166

            if(persistent_locals.has(varname))

   167

                persistent_indexes.set(new_index, varname);

   168

        }

   169

        return new_index;

   170

    }

   171

   172

    function hmi_local_index(varname){

   173

        return page_local_index(varname, "HMI_LOCAL");

   174

    }

   175

    ||

   176

}

   177

   178

emit "preamble:widget-base-class" {

   179

    ||

   180

    var pending_widget_animates = [];

   181

   182

    function _hide(elt, placeholder){

   183

        if(elt.parentNode != null)

   184

            placeholder.parentNode.removeChild(elt);

   185

    }

   186

    function _show(elt, placeholder){

   187

        placeholder.parentNode.insertBefore(elt, placeholder);

   188

    }

   189

   190

    function set_activation_state(eltsub, state){

   191

        if(eltsub.active_elt != undefined){

   192

            if(eltsub.active_elt_placeholder == undefined){

   193

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

   194

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

   195

            }

   196

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

   197

        }

   198

        if(eltsub.inactive_elt != undefined){

   199

            if(eltsub.inactive_elt_placeholder == undefined){

   200

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

   201

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

   202

            }

   203

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

   204

        }

   205

    }

   206

   207

    function activate_activable(eltsub) {

   208

        set_activation_state(eltsub, true);

   209

    }

   210

   211

    function inactivate_activable(eltsub) {

   212

        set_activation_state(eltsub, false);

   213

    }

   214

   215

    class Widget {

   216

        offset = 0;

   217

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

   218

        unsubscribable = false;

   219

        pending_animate = false;

   220

   221

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

   222

            this.element_id = elt_id;

   223

            this.element = id(elt_id);

   224

            this.args = args;

   225

            this.indexes = indexes;

   226

            this.minmaxes = minmaxes;

   227

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

   228

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

   229

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

   230

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

   231

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

   232

   233

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

   234

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

   235

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

   236

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

   237

   238

            this.forced_frequency = freq;

   239

            this.clip = true;

   240

        }

   241

   242

        do_init(){

   243

            let forced = this.forced_frequency;

   244

            if(forced !== undefined){

   245

                /*

   246

                once every 10 seconds : 10s

   247

                once per minute : 1m

   248

                once per hour : 1h

   249

                once per day : 1d

   250

                */

   251

                let unit = forced.slice(-1);

   252

                let factor = {

   253

                    "s":1,

   254

                    "m":60,

   255

                    "h":3600,

   256

                    "d":86400}[unit];

   257

   258

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

   259

                                          : Number(forced);

   260

            }

   261

   262

            let init = this.init;

   263

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

   264

                try {

   265

                    init.call(this);

   266

                } catch(err) {

   267

                    console.log(err);

   268

                }

   269

            }

   270

        }

   271

   272

        unsub(){

   273

            /* remove subsribers */

   274

            if(!this.unsubscribable)

   275

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

   276

                    /* flush updates pending because of inhibition */

   277

                    let inhibition = this.inhibit[i];

   278

                    if(inhibition != undefined){

   279

                        clearTimeout(inhibition);

   280

                        this.lastapply[i] = undefined;

   281

                        this.uninhibit(i);

   282

                    }

   283

                    let deafened = this.deafen[i];

   284

                    if(deafened != undefined){

   285

                        clearTimeout(deafened);

   286

                        this.lastdispatch[i] = undefined;

   287

                        this.undeafen(i);

   288

                    }

   289

                    let index = this.indexes[i];

   290

                    if(this.relativeness[i])

   291

                        index += this.offset;

   292

                    subscribers(index).delete(this);

   293

                }

   294

            this.offset = 0;

   295

            this.relativeness = undefined;

   296

        }

   297

   298

        sub(new_offset=0, relativeness, container_id){

   299

            this.offset = new_offset;

   300

            this.relativeness = relativeness;

   301

            this.container_id = container_id ;

   302

            /* add this's subsribers */

   303

            if(!this.unsubscribable)

   304

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

   305

                    let index = this.get_variable_index(i);

   306

                    if(index == undefined) continue;

   307

                    subscribers(index).add(this);

   308

                }

   309

            need_cache_apply.push(this); 

   310

        }

   311

   312

        apply_cache() {

   313

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

   314

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

   315

                let realindex = this.get_variable_index(index);

   316

                if(realindex == undefined) continue;

   317

                let cached_val = cache[realindex];

   318

                if(cached_val != undefined)

   319

                    this._dispatch(cached_val, cached_val, index);

   320

            }

   321

        }

   322

   323

        get_variable_index(varnum) {

   324

            let index = this.indexes[varnum];

   325

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

   326

                index = page_local_index(index, this.container_id);

   327

            } else {

   328

                if(this.relativeness[varnum]){

   329

                    index += this.offset;

   330

                }

   331

            }

   332

            return index;

   333

        }

   334

   335

        overshot(new_val, max) {

   336

        }

   337

   338

        undershot(new_val, min) {

   339

        }

   340

   341

        clip_min_max(index, new_val) {

   342

            let minmax = this.minmaxes[index];

   343

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

   344

                let [min,max] = minmax;

   345

                if(new_val < min){

   346

                    this.undershot(new_val, min);

   347

                    return min;

   348

                }

   349

                if(new_val > max){

   350

                    this.overshot(new_val, max);

   351

                    return max;

   352

                }

   353

            }

   354

            return new_val;

   355

        }

   356

   357

        change_hmi_value(index, opstr) {

   358

            let realindex = this.get_variable_index(index);

   359

            if(realindex == undefined) return undefined;

   360

            let old_val = cache[realindex];

   361

            let new_val = eval_operation_string(old_val, opstr);

   362

            if(this.clip)

   363

                new_val = this.clip_min_max(index, new_val);

   364

            return apply_hmi_value(realindex, new_val);

   365

        }

   366

   367

        _apply_hmi_value(index, new_val) {

   368

            let realindex = this.get_variable_index(index);

   369

            if(realindex == undefined) return undefined;

   370

            if(this.clip)

   371

                new_val = this.clip_min_max(index, new_val);

   372

            return apply_hmi_value(realindex, new_val);

   373

        }

   374

   375

        uninhibit(index){

   376

            this.inhibit[index] = undefined;

   377

            let new_val = this.pending[index];

   378

            this.pending[index] = undefined;

   379

            return this.apply_hmi_value(index, new_val);

   380

        }

   381

   382

        apply_hmi_value(index, new_val) {

   383

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

   384

                let now = Date.now();

   385

                let min_interval = 1000/this.frequency;

   386

                let lastapply = this.lastapply[index];

   387

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

   388

                    this.lastapply[index] = now;

   389

                    return this._apply_hmi_value(index, new_val);

   390

                }

   391

                else {

   392

                    let elapsed = now - lastapply;

   393

                    this.pending[index] = new_val;

   394

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

   395

                }

   396

            }

   397

            else {

   398

                this.pending[index] = new_val;

   399

                return new_val;

   400

            }

   401

        }

   402

   403

        new_hmi_value(index, value, oldval) {

   404

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

   405

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

   406

                let refindex = this.get_variable_index(i);

   407

                if(refindex == undefined) continue;

   408

   409

                if(index == refindex) {

   410

                    this._dispatch(value, oldval, i);

   411

                    break;

   412

                }

   413

            }

   414

        }

   415

   416

        undeafen(index){

   417

            this.deafen[index] = undefined;

   418

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

   419

            this.incoming[index] = undefined;

   420

            this.dispatch(new_val, old_val, index);

   421

        }

   422

   423

        _dispatch(value, oldval, varnum) {

   424

            let dispatch = this.dispatch;

   425

            if(dispatch != undefined){

   426

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

   427

                    let now = Date.now();

   428

                    let min_interval = 1000/this.frequency;

   429

                    let lastdispatch = this.lastdispatch[varnum];

   430

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

   431

                        this.lastdispatch[varnum] = now;

   432

                        try {

   433

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

   434

                        } catch(err) {

   435

                            console.log(err);

   436

                        }

   437

                    }

   438

                    else {

   439

                        let elapsed = now - lastdispatch;

   440

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

   441

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

   442

                    }

   443

                }

   444

                else {

   445

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

   446

                }

   447

            }

   448

        }

   449

   450

        _animate(){

   451

            this.animate();

   452

            this.pending_animate = false;

   453

        }

   454

   455

        request_animate(){

   456

            if(!this.pending_animate){

   457

                pending_widget_animates.push(this);

   458

                this.pending_animate = true;

   459

                requestHMIAnimation();

   460

            }

   461

        }

   462

   463

        set_activation_state(state){

   464

            set_activation_state(this.activable_sub, state);

   465

        }

   466

    }

   467

    ||

   468

}

   469

   470

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

   471

   472

// Key to filter unique types

   473

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

   474

   475

emit "declarations:hmi-classes" {

   476

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

   477

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

   478

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

   479

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

   480

}

   481

   482

template "widget", mode="widget_class"

   483

||

   484

class «@type»Widget extends Widget{

   485

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