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

    25

    |     activable_sub:{

    26

    const "activity" labels("/active /inactive") {

    27

        with "mandatory"{text *level};

    28

        content;

    29

    }

    30

    value "$activity";

    31

    const "has_activity","string-length($activity)>0";

    32

    |     },

    33

    |     has_activity: «$has_activity»,

    34

};

    35

    36

decl activable() alias - {

    37

    _activable("warn")

    38

};

    39

decl optional_activable() alias - {

    40

    _activable("no")

    41

};

    42

    43

decl activable_labels(*ptr) alias - {

    44

    optional_labels(*ptr) {

    45

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

    46

        content;

    47

    }

    48

};

    49

    50

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

    51

    type > «@type»

    52

    content;

    53

};

    54

    55

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

    56

    | class `text **clsname` extends Widget{

    57

    content;

    58

    | }

    59

};

    60

    61

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

    62

    param "hmi_element";

    63

    // all widget potentially has a "disabled" labeled element

    64

    const "disability" optional_labels("/disabled");

    65

    value "$disability";

    66

    const "has_disability","string-length($disability)>0";

    67

    content;

    68

};

    69

    70

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

    71

    param "page_desc";

    72

    content;

    73

};

    74

    75

decl gen_index_xhtml alias - {

    76

    content;

    77

};

    78

    79

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

    80

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

    81

    const "eltid","@id";

    82

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

    83

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

    84

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

    85

    }

    86

    87

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

    88

        > [

    89

        choose {

    90

            when "not(@index)" {

    91

                choose {

    92

                    when "not(@type)" {

    93

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

    94

                        > undefined

    95

                    }

    96

                    when "@type = 'PAGE_LOCAL'" 

    97

                        > "«@value»"

    98

                    when "@type = 'HMI_LOCAL'" 

    99

                        > hmi_local_index("«@value»")

   100

                    otherwise 

   101

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

   102

                }

   103

            }

   104

            otherwise {

   105

                > «@index»

   106

            }

   107

        }

   108

        > , {

   109

        if "@min and @max"{

   110

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

   111

                if "@assign"

   112

                    > ,

   113

        }

   114

        if "@assign"

   115

                > assign:"«@assign»"

   116

        > }]

   117

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

   118

    }

   119

   120

    const "freq" choose {

   121

        when "$widget/@freq"

   122

            > "«$widget/@freq»"

   123

        otherwise

   124

            > undefined

   125

    }

   126

   127

    const "enable_expr" choose{

   128

        when "$widget/@enable_expr"

   129

            > true

   130

        otherwise

   131

            > false

   132

    }

   133

   134

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

   135

    if "$widget/@enable_expr" {

   136

   137

    |       assignments: [],

   138

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

   139

    |         let result = false;

   140

    |         do {

   141

        foreach "$widget/path" {

   142

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

   143

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

   144

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

   145

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

   146

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

   147

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

   148

            }

   149

        }

   150

    |           result = «$widget/@enable_expr»;

   151

    |         } while(0);

   152

    |         this.enable(result);

   153

    |       },

   154

    }

   155

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

   156

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

   157

}

   158

   159

emit "preamble:local-variable-indexes" {

   160

    ||

   161

   162

    let hmi_locals = {};

   163

    var last_remote_index = hmitree_types.length - 1;

   164

    var next_available_index = hmitree_types.length;

   165

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

   166

   167

    const local_defaults = {

   168

    ||

   169

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

   170

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

   171

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

   172

        >     "«path/@value»":

   173

        choose {

   174

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

   175

            otherwise > «arg[1]/@value»

   176

        }

   177

        > \n

   178

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

   179

    }

   180

    ||

   181

    };

   182

   183

    const persistent_locals = new Set([

   184

    ||

   185

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

   186

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

   187

    }

   188

    ||

   189

    ]);

   190

    var persistent_indexes = new Map();

   191

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

   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

            if(persistent_locals.has(varname))

   212

                persistent_indexes.set(new_index, varname);

   213

        }

   214

        return new_index;

   215

    }

   216

   217

    function hmi_local_index(varname){

   218

        return page_local_index(varname, "HMI_LOCAL");

   219

    }

   220

    ||

   221

}

   222

   223

emit "preamble:widget-base-class" {

   224

    ||

   225

    var pending_widget_animates = [];

   226

   227

    function _hide(elt, placeholder){

   228

        if(elt.parentNode != null)

   229

            placeholder.parentNode.removeChild(elt);

   230

    }

   231

    function _show(elt, placeholder){

   232

        placeholder.parentNode.insertBefore(elt, placeholder);

   233

    }

   234

   235

    function set_activity_state(eltsub, state){

   236

        if(eltsub.active_elt != undefined){

   237

            if(eltsub.active_elt_placeholder == undefined){

   238

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

   239

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

   240

            }

   241

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

   242

        }

   243

        if(eltsub.inactive_elt != undefined){

   244

            if(eltsub.inactive_elt_placeholder == undefined){

   245

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

   246

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

   247

            }

   248

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

   249

        }

   250

    }

   251

   252

    class Widget {

   253

        offset = 0;

   254

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

   255

        unsubscribable = false;

   256

        pending_animate = false;

   257

   258

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

   259

            this.element_id = elt_id;

   260

            this.element = id(elt_id);

   261

            this.args = args;

   262

   263

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

   264

            this.indexes_length = this.indexes.length;

   265

   266

            this.enable_expr = enable_expr;

   267

            this.enable_state = true;

   268

            this.enable_displayed_state = true;

   269

            this.enabled_elts = [];

   270

   271

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

   272

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

   273

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

   274

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

   275

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

   276

   277

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

   278

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

   279

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

   280

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

   281

   282

            this.forced_frequency = freq;

   283

            this.clip = true;

   284

        }

   285

   286

        do_init(){

   287

            let forced = this.forced_frequency;

   288

            if(forced !== undefined){

   289

                /*

   290

                once every 10 seconds : 10s

   291

                once per minute : 1m

   292

                once per hour : 1h

   293

                once per day : 1d

   294

                */

   295

                let unit = forced.slice(-1);

   296

                let factor = {

   297

                    "s":1,

   298

                    "m":60,

   299

                    "h":3600,

   300

                    "d":86400}[unit];

   301

   302

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

   303

                                          : Number(forced);

   304

            }

   305

   306

            let init = this.init;

   307

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

   308

                try {

   309

                    init.call(this);

   310

                } catch(err) {

   311

                    console.log(err);

   312

                }

   313

            }

   314

   315

            if(this.enable_expr){

   316

                this.enable_state = false;

   317

                this.enable_displayed_state = false;

   318

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

   319

                    let label = child.getAttribute("inkscape:label");

   320

                    if(label!="disabled"){

   321

                        this.enabled_elts.push(child);

   322

                        this.element.removeChild(child);

   323

                    }

   324

                }

   325

            }

   326

        }

   327

   328

        unsub(){

   329

            /* remove subsribers */

   330

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

   331

                /* flush updates pending because of inhibition */

   332

                let inhibition = this.inhibit[i];

   333

                if(inhibition != undefined){

   334

                    clearTimeout(inhibition);

   335

                    this.lastapply[i] = undefined;

   336

                    this.uninhibit(i);

   337

                }

   338

                let deafened = this.deafen[i];

   339

                if(deafened != undefined){

   340

                    clearTimeout(deafened);

   341

                    this.lastdispatch[i] = undefined;

   342

                    this.undeafen(i);

   343

                }

   344

                let index = this.get_variable_index(i);

   345

                subscribers(index).delete(this);

   346

            }

   347

            this.offset = 0;

   348

            this.relativeness = undefined;

   349

        }

   350

   351

        sub(new_offset=0, relativeness, container_id){

   352

            this.offset = new_offset;

   353

            this.relativeness = relativeness;

   354

            this.container_id = container_id ;

   355

            /* add this's subsribers */

   356

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

   357

                let index = this.get_variable_index(i);

   358

                if(index == undefined) continue;

   359

                subscribers(index).add(this);

   360

            }

   361

            this.apply_cache(); 

   362

        }

   363

   364

        apply_cache() {

   365

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

   366

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

   367

                let realindex = this.get_variable_index(i);

   368

                if(realindex == undefined) continue;

   369

                let cached_val = cache[realindex];

   370

                if(cached_val != undefined)

   371

                    this.feed_data_for_dispatch(cached_val, cached_val, i);

   372

            }

   373

        }

   374

   375

        get_variable_index(varnum) {

   376

            let index = this.indexes[varnum];

   377

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

   378

                index = page_local_index(index, this.container_id);

   379

            } else {

   380

                if(this.relativeness[varnum]){

   381

                    index += this.offset;

   382

                }

   383

            }

   384

            return index;

   385

        }

   386

   387

        overshot(new_val, max) {

   388

        }

   389

   390

        undershot(new_val, min) {

   391

        }

   392

   393

        clip_min_max(index, new_val) {

   394

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

   395

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

   396

                let [min,max] = minmax;

   397

                if(new_val < min){

   398

                    this.undershot(new_val, min);

   399

                    return min;

   400

                }

   401

                if(new_val > max){

   402

                    this.overshot(new_val, max);

   403

                    return max;

   404

                }

   405

            }

   406

            return new_val;

   407

        }

   408

   409

        change_hmi_value(index, opstr) {

   410

            let realindex = this.get_variable_index(index);

   411

            if(realindex == undefined) return undefined;

   412

            let old_val = cache[realindex];

   413

            let new_val = eval_operation_string(old_val, opstr);

   414

            if(this.clip)

   415

                new_val = this.clip_min_max(index, new_val);

   416

            return apply_hmi_value(realindex, new_val);

   417

        }

   418

   419

        _apply_hmi_value(index, new_val) {

   420

            let realindex = this.get_variable_index(index);

   421

            if(realindex == undefined) return undefined;

   422

            if(this.clip)

   423

                new_val = this.clip_min_max(index, new_val);

   424

            return apply_hmi_value(realindex, new_val);

   425

        }

   426

   427

        uninhibit(index){

   428

            this.inhibit[index] = undefined;

   429

            let new_val = this.pending[index];

   430

            this.pending[index] = undefined;

   431

            return this.apply_hmi_value(index, new_val);

   432

        }

   433

   434

        apply_hmi_value(index, new_val) {

   435

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

   436

                let now = Date.now();

   437

                let min_interval = 1000/this.frequency;

   438

                let lastapply = this.lastapply[index];

   439

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

   440

                    this.lastapply[index] = now;

   441

                    return this._apply_hmi_value(index, new_val);

   442

                }

   443

                else {

   444

                    let elapsed = now - lastapply;

   445

                    this.pending[index] = new_val;

   446

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

   447

                }

   448

            }

   449

            else {

   450

                this.pending[index] = new_val;

   451

                return new_val;

   452

            }

   453

        }

   454

   455

        new_hmi_value(index, value, oldval) {

   456

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

   457

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

   458

                let refindex = this.get_variable_index(i);

   459

                if(refindex == undefined) continue;

   460

   461

                if(index == refindex) {

   462

                    this.feed_data_for_dispatch(value, oldval, i);

   463

                    break;

   464

                }

   465

            }

   466

        }

   467

   468

        undeafen(index){

   469

            this.deafen[index] = undefined;

   470

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

   471

            this.incoming[index] = undefined;

   472

            this.do_dispatch(new_val, old_val, index);

   473

        }

   474

   475

        enable(enabled){

   476

            if(this.enable_state != enabled){

   477

                this.enable_state = enabled;

   478

                this.request_animate();

   479

            }

   480

        }

   481

   482

        animate_enable(){

   483

            if(this.enable_state && !this.enable_displayed_state){

   484

                //show widget

   485

                for(let child of this.enabled_elts){