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

   115

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

   116

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

   117

}

   118

   119

emit "preamble:local-variable-indexes" {

   120

    ||

   121

   122

    let hmi_locals = {};

   123

    var last_remote_index = hmitree_types.length - 1;

   124

    var next_available_index = hmitree_types.length;

   125

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

   126

   127

    const local_defaults = {

   128

    ||

   129

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

   130

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

   131

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

   132

        >     "«path/@value»":

   133

        choose {

   134

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

   135

            otherwise > «arg[1]/@value»

   136

        }

   137

        > \n

   138

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

   139

    }

   140

    ||

   141

    };

   142

   143

    const persistent_locals = new Set([

   144

    ||

   145

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

   146

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

   147

    }

   148

    ||

   149

    ]);

   150

    var persistent_indexes = new Map();

   151

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

   152

    var updates = new Map();

   153

   154

    function page_local_index(varname, pagename){

   155

        let pagevars = hmi_locals[pagename];

   156

        let new_index;

   157

        if(pagevars == undefined){

   158

            new_index = next_available_index++;

   159

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

   160

        } else {

   161

            let result = pagevars[varname];

   162

            if(result != undefined) {

   163

                return result;

   164

            }

   165

   166

            new_index = next_available_index++;

   167

            pagevars[varname] = new_index;

   168

        }

   169

        let defaultval = local_defaults[varname];

   170

        if(defaultval != undefined) {

   171

            cache[new_index] = defaultval; 

   172

            updates.set(new_index, defaultval);

   173

            if(persistent_locals.has(varname))

   174

                persistent_indexes.set(new_index, varname);

   175

        }

   176

        return new_index;

   177

    }

   178

   179

    function hmi_local_index(varname){

   180

        return page_local_index(varname, "HMI_LOCAL");

   181

    }

   182

    ||

   183

}

   184

   185

emit "preamble:widget-base-class" {

   186

    ||

   187

    var pending_widget_animates = [];

   188

   189

    function _hide(elt, placeholder){

   190

        if(elt.parentNode != null)

   191

            placeholder.parentNode.removeChild(elt);

   192

    }

   193

    function _show(elt, placeholder){

   194

        placeholder.parentNode.insertBefore(elt, placeholder);

   195

    }

   196

   197

    function set_activation_state(eltsub, state){

   198

        if(eltsub.active_elt != undefined){

   199

            if(eltsub.active_elt_placeholder == undefined){

   200

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

   201

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

   202

            }

   203

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

   204

        }

   205

        if(eltsub.inactive_elt != undefined){

   206

            if(eltsub.inactive_elt_placeholder == undefined){

   207

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

   208

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

   209

            }

   210

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

   211

        }

   212

    }

   213

   214

    function activate_activable(eltsub) {

   215

        set_activation_state(eltsub, true);

   216

    }

   217

   218

    function inactivate_activable(eltsub) {

   219

        set_activation_state(eltsub, false);

   220

    }

   221

   222

    class Widget {

   223

        offset = 0;

   224

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

   225

        unsubscribable = false;

   226

        pending_animate = false;

   227

   229

            this.element_id = elt_id;

   230

            this.element = id(elt_id);

   231

            this.args = args;

   232

            this.indexes = indexes;

   234

            this.minmaxes = minmaxes;

   236

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

   237

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

   238

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

   239

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

   240

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

   241

   242

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

   243

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

   244

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

   245

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

   246

   247

            this.forced_frequency = freq;

   248

            this.clip = true;

   249

        }

   250

   251

        do_init(){

   252

            let forced = this.forced_frequency;

   253

            if(forced !== undefined){

   254

                /*

   255

                once every 10 seconds : 10s

   256

                once per minute : 1m

   257

                once per hour : 1h

   258

                once per day : 1d

   259

                */

   260

                let unit = forced.slice(-1);

   261

                let factor = {

   262

                    "s":1,

   263

                    "m":60,

   264

                    "h":3600,

   265

                    "d":86400}[unit];

   266

   267

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

   268

                                          : Number(forced);

   269

            }

   270

   271

            let init = this.init;

   272

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

   273

                try {

   274

                    init.call(this);

   275

                } catch(err) {

   276

                    console.log(err);

   277

                }

   278

            }

   294

        }

   295

   296

        unsub(){

   297

            /* remove subsribers */

   298

            if(!this.unsubscribable)

   300

                    /* flush updates pending because of inhibition */

   301

                    let inhibition = this.inhibit[i];

   302

                    if(inhibition != undefined){

   303

                        clearTimeout(inhibition);

   304

                        this.lastapply[i] = undefined;

   305

                        this.uninhibit(i);

   306

                    }

   307

                    let deafened = this.deafen[i];

   308

                    if(deafened != undefined){

   309

                        clearTimeout(deafened);

   310

                        this.lastdispatch[i] = undefined;

   311

                        this.undeafen(i);

   312

                    }

   313

                    let index = this.indexes[i];

   314

                    if(this.relativeness[i])

   315

                        index += this.offset;

   316

                    subscribers(index).delete(this);

   317

                }

   318

            this.offset = 0;

   319

            this.relativeness = undefined;

   320

        }

   321

   322

        sub(new_offset=0, relativeness, container_id){

   323

            this.offset = new_offset;

   324

            this.relativeness = relativeness;

   325

            this.container_id = container_id ;

   326

            /* add this's subsribers */

   327

            if(!this.unsubscribable)

   329

                    let index = this.get_variable_index(i);

   330

                    if(index == undefined) continue;

   331

                    subscribers(index).add(this);

   332

                }

   333

            need_cache_apply.push(this); 

   334

        }

   335

   336

        apply_cache() {

   337

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

   338

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

   339

                let realindex = this.get_variable_index(index);

   340

                if(realindex == undefined) continue;

   341

                let cached_val = cache[realindex];

   342

                if(cached_val != undefined)

   343

                    this._dispatch(cached_val, cached_val, index);

   344

            }

   345

        }

   346

   347

        get_variable_index(varnum) {

   348

            let index = this.indexes[varnum];

   349

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

   350

                index = page_local_index(index, this.container_id);

   351

            } else {

   352

                if(this.relativeness[varnum]){

   353

                    index += this.offset;

   354

                }

   355

            }

   356

            return index;

   357

        }

   358

   359

        overshot(new_val, max) {

   360

        }

   361

   362

        undershot(new_val, min) {

   363

        }

   364

   365

        clip_min_max(index, new_val) {

   366

            let minmax = this.minmaxes[index];

   367

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

   368

                let [min,max] = minmax;

   369

                if(new_val < min){

   370

                    this.undershot(new_val, min);

   371

                    return min;

   372

                }

   373

                if(new_val > max){

   374

                    this.overshot(new_val, max);

   375

                    return max;

   376

                }

   377

            }

   378

            return new_val;

   379

        }

   380

   381

        change_hmi_value(index, opstr) {

   382

            let realindex = this.get_variable_index(index);

   383

            if(realindex == undefined) return undefined;

   384

            let old_val = cache[realindex];

   385

            let new_val = eval_operation_string(old_val, opstr);

   386

            if(this.clip)

   387

                new_val = this.clip_min_max(index, new_val);

   388

            return apply_hmi_value(realindex, new_val);

   389

        }

   390

   391

        _apply_hmi_value(index, new_val) {

   392

            let realindex = this.get_variable_index(index);

   393

            if(realindex == undefined) return undefined;

   394

            if(this.clip)

   395

                new_val = this.clip_min_max(index, new_val);

   396

            return apply_hmi_value(realindex, new_val);

   397

        }

   398

   399

        uninhibit(index){

   400

            this.inhibit[index] = undefined;

   401

            let new_val = this.pending[index];

   402

            this.pending[index] = undefined;

   403

            return this.apply_hmi_value(index, new_val);

   404

        }

   405

   406

        apply_hmi_value(index, new_val) {

   407

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

   408

                let now = Date.now();

   409

                let min_interval = 1000/this.frequency;

   410

                let lastapply = this.lastapply[index];

   411

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

   412

                    this.lastapply[index] = now;

   413

                    return this._apply_hmi_value(index, new_val);

   414

                }

   415

                else {

   416

                    let elapsed = now - lastapply;

   417

                    this.pending[index] = new_val;

   418

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

   419

                }

   420

            }

   421

            else {

   422

                this.pending[index] = new_val;

   423

                return new_val;

   424

            }

   425

        }

   426

   427

        new_hmi_value(index, value, oldval) {

   428

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

   430

                let refindex = this.get_variable_index(i);

   431

                if(refindex == undefined) continue;

   432

   433

                if(index == refindex) {

   434

                    this._dispatch(value, oldval, i);

   435

                    break;

   436

                }

   437

            }

   438

        }

   439

   440

        undeafen(index){

   441

            this.deafen[index] = undefined;

   442

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

   443

            this.incoming[index] = undefined;

   444

            this.dispatch(new_val, old_val, index);

   445

        }

   446

   483

        _dispatch(value, oldval, varnum) {

   484

            let dispatch = this.dispatch;