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

    var updates = new Map();

   193

   194

    function page_local_index(varname, pagename){

   195

        let pagevars = hmi_locals[pagename];

   196

        let new_index;

   197

        if(pagevars == undefined){

   198

            new_index = next_available_index++;

   199

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

   200

        } else {

   201

            let result = pagevars[varname];

   202

            if(result != undefined) {

   203

                return result;

   204

            }

   205

   206

            new_index = next_available_index++;

   207

            pagevars[varname] = new_index;

   208

        }

   209

        let defaultval = local_defaults[varname];

   210

        if(defaultval != undefined) {

   211

            cache[new_index] = defaultval; 

   212

            updates.set(new_index, defaultval);

   213

            if(persistent_locals.has(varname))

   214

                persistent_indexes.set(new_index, varname);

   215

        }

   216

        return new_index;

   217

    }

   218

   219

    function hmi_local_index(varname){

   220

        return page_local_index(varname, "HMI_LOCAL");

   221

    }

   222

    ||

   223

}

   224

   225

emit "preamble:widget-base-class" {

   226

    ||

   227

    var pending_widget_animates = [];

   228

   229

    function _hide(elt, placeholder){

   230

        if(elt.parentNode != null)

   231

            placeholder.parentNode.removeChild(elt);

   232

    }

   233

    function _show(elt, placeholder){

   234

        placeholder.parentNode.insertBefore(elt, placeholder);

   235

    }

   236

   237

    function set_activity_state(eltsub, state){

   238

        if(eltsub.active_elt != undefined){

   239

            if(eltsub.active_elt_placeholder == undefined){

   240

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

   241

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

   242

            }

   243

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

   244

        }

   245

        if(eltsub.inactive_elt != undefined){

   246

            if(eltsub.inactive_elt_placeholder == undefined){

   247

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

   248

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

   249

            }

   250

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

   251

        }

   252

    }

   253

   254

    class Widget {

   255

        offset = 0;

   256

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

   257

        unsubscribable = false;

   258

        pending_animate = false;

   259

   260

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

   261

            this.element_id = elt_id;

   262

            this.element = id(elt_id);

   263

            this.args = args;

   264

   265

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

   266

            this.indexes_length = this.indexes.length;

   267

   268

            this.enable_expr = enable_expr;

   269

            this.enable_state = true;

   270

            this.enable_displayed_state = true;

   271

            this.enabled_elts = [];

   272

   273

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

   274

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

   275

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

   276

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

   277

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

   278

   279

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

   280

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

   281

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

   282

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

   283

   284

            this.forced_frequency = freq;

   285

            this.clip = true;

   286

        }

   287

   288

        do_init(){

   289

            let forced = this.forced_frequency;

   290

            if(forced !== undefined){

   291

                /*

   292

                once every 10 seconds : 10s

   293

                once per minute : 1m

   294

                once per hour : 1h

   295

                once per day : 1d

   296

                */

   297

                let unit = forced.slice(-1);

   298

                let factor = {

   299

                    "s":1,

   300

                    "m":60,

   301

                    "h":3600,

   302

                    "d":86400}[unit];

   303

   304

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

   305

                                          : Number(forced);

   306

            }

   307

   308

            let init = this.init;

   309

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

   310

                try {

   311

                    init.call(this);

   312

                } catch(err) {

   313

                    console.log(err);

   314

                }

   315

            }

   316

   317

            if(this.enable_expr){

   318

                this.enable_state = false;

   319

                this.enable_displayed_state = false;

   320

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

   321

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

   322

                    if(label!="disabled"){

   323

                        this.enabled_elts.push(child);

   324

                        this.element.removeChild(child);

   325

                    }

   326

                }

   327

            }

   328

        }

   329

   330

        unsub(){

   331

            /* remove subsribers */

   332

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

   333

                /* flush updates pending because of inhibition */

   334

                let inhibition = this.inhibit[i];

   335

                if(inhibition != undefined){

   336

                    clearTimeout(inhibition);

   337

                    this.lastapply[i] = undefined;

   338

                    this.uninhibit(i);

   339

                }

   340

                let deafened = this.deafen[i];

   341

                if(deafened != undefined){

   342

                    clearTimeout(deafened);

   343

                    this.lastdispatch[i] = undefined;

   344

                    this.undeafen(i);

   345

                }

   346

                let index = this.indexes[i];

   347

                if(this.relativeness[i])

   348

                    index += this.offset;

   349

                subscribers(index).delete(this);

   350

            }

   351

            this.offset = 0;

   352

            this.relativeness = undefined;

   353

        }

   354

   355

        sub(new_offset=0, relativeness, container_id){

   356

            this.offset = new_offset;

   357

            this.relativeness = relativeness;

   358

            this.container_id = container_id ;

   359

            /* add this's subsribers */

   360

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

   361

                let index = this.get_variable_index(i);

   362

                if(index == undefined) continue;

   363

                subscribers(index).add(this);

   364

            }

   365

            need_cache_apply.push(this); 

   366

        }

   367

   368

        apply_cache() {

   369

            for(let index in this.indexes){

   370

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

   371

                let realindex = this.get_variable_index(index);

   372

                if(realindex == undefined) continue;

   373

                let cached_val = cache[realindex];

   374

                if(cached_val != undefined)

   375

                    this._dispatch(cached_val, cached_val, index);

   376

            }

   377

        }

   378

   379

        get_variable_index(varnum) {

   380

            let index = this.indexes[varnum];

   381

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

   382

                index = page_local_index(index, this.container_id);

   383

            } else {

   384

                if(this.relativeness[varnum]){

   385

                    index += this.offset;

   386

                }

   387

            }

   388

            return index;

   389

        }

   390

   391

        overshot(new_val, max) {

   392

        }

   393

   394

        undershot(new_val, min) {

   395

        }

   396

   397

        clip_min_max(index, new_val) {

   398

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

   399

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

   400

                let [min,max] = minmax;

   401

                if(new_val < min){

   402

                    this.undershot(new_val, min);

   403

                    return min;

   404

                }

   405

                if(new_val > max){

   406

                    this.overshot(new_val, max);

   407

                    return max;

   408

                }

   409

            }

   410

            return new_val;

   411

        }

   412

   413

        change_hmi_value(index, opstr) {

   414

            let realindex = this.get_variable_index(index);

   415

            if(realindex == undefined) return undefined;

   416

            let old_val = cache[realindex];

   417

            let new_val = eval_operation_string(old_val, opstr);

   418

            if(this.clip)

   419

                new_val = this.clip_min_max(index, new_val);

   420

            return apply_hmi_value(realindex, new_val);

   421

        }

   422

   423

        _apply_hmi_value(index, new_val) {

   424

            let realindex = this.get_variable_index(index);

   425

            if(realindex == undefined) return undefined;

   426

            if(this.clip)

   427

                new_val = this.clip_min_max(index, new_val);

   428

            return apply_hmi_value(realindex, new_val);

   429

        }

   430

   431

        uninhibit(index){

   432

            this.inhibit[index] = undefined;

   433

            let new_val = this.pending[index];

   434

            this.pending[index] = undefined;

   435

            return this.apply_hmi_value(index, new_val);

   436

        }

   437

   438

        apply_hmi_value(index, new_val) {

   439

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

   440

                let now = Date.now();

   441

                let min_interval = 1000/this.frequency;

   442

                let lastapply = this.lastapply[index];

   443

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

   444

                    this.lastapply[index] = now;

   445

                    return this._apply_hmi_value(index, new_val);

   446

                }

   447

                else {

   448

                    let elapsed = now - lastapply;

   449

                    this.pending[index] = new_val;

   450

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

   451

                }

   452

            }

   453

            else {

   454

                this.pending[index] = new_val;

   455

                return new_val;

   456

            }

   457

        }

   458

   459

        new_hmi_value(index, value, oldval) {

   460

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

   461

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

   462

                let refindex = this.get_variable_index(i);

   463

                if(refindex == undefined) continue;

   464

   465

                if(index == refindex) {

   466

                    this._dispatch(value, oldval, i);

   467

                    break;

   468

                }

   469

            }

   470

        }

   471

   472

        undeafen(index){

   473

            this.deafen[index] = undefined;

   474

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

   475

            this.incoming[index] = undefined;

   476

            if(this.dispatch)

   477

                this.dispatch(new_val, old_val, index);

   478

        }

   479

   480

        enable(enabled){

   481

            if(this.enable_state != enabled){

   482

                this.enable_state = enabled;

   483

                this.request_animate();

   484

            }

   485

        }