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" {

    73

        choose {

    74

            when "not(@index)" {

    75

                choose {

    76

                    when "not(@type)" {

    77

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

    78

                        > undefined

    79

                    }

    80

                    when "@type = 'PAGE_LOCAL'" 

    81

                        > "«@value»"

    82

                    when "@type = 'HMI_LOCAL'" 

    83

                        > hmi_local_index("«@value»")

    84

                    otherwise 

    85

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

    86

                }

    87

            }

    88

            otherwise {

    89

                > «@index»

    90

            }

    91

        }

   101

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

   102

    }

   103

   104

    const "freq" choose {

   105

        when "$widget/@freq"

   106

            > "«$widget/@freq»"

   107

        otherwise

   108

            > undefined

   109

    }

   110

   113

            > true

   114

        otherwise

   115

            > false

   116

    }

   117

   139

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

   140

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

   141

}

   142

   143

emit "preamble:local-variable-indexes" {

   144

    ||

   145

   146

    let hmi_locals = {};

   147

    var last_remote_index = hmitree_types.length - 1;

   148

    var next_available_index = hmitree_types.length;

   149

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

   150

   151

    const local_defaults = {

   152

    ||

   153

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

   154

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

   155

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

   156

        >     "«path/@value»":

   157

        choose {

   158

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

   159

            otherwise > «arg[1]/@value»

   160

        }

   161

        > \n

   162

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

   163

    }

   164

    ||

   165

    };

   166

   167

    const persistent_locals = new Set([

   168

    ||

   169

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

   170

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

   171

    }

   172

    ||

   173

    ]);

   174

    var persistent_indexes = new Map();

   175

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

   176

    var updates = new Map();

   177

   178

    function page_local_index(varname, pagename){

   179

        let pagevars = hmi_locals[pagename];

   180

        let new_index;

   181

        if(pagevars == undefined){

   182

            new_index = next_available_index++;

   183

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

   184

        } else {

   185

            let result = pagevars[varname];

   186

            if(result != undefined) {

   187

                return result;

   188

            }

   189

   190

            new_index = next_available_index++;

   191

            pagevars[varname] = new_index;

   192

        }

   193

        let defaultval = local_defaults[varname];

   194

        if(defaultval != undefined) {

   195

            cache[new_index] = defaultval; 

   196

            updates.set(new_index, defaultval);

   197

            if(persistent_locals.has(varname))

   198

                persistent_indexes.set(new_index, varname);

   199

        }

   200

        return new_index;

   201

    }

   202

   203

    function hmi_local_index(varname){

   204

        return page_local_index(varname, "HMI_LOCAL");

   205

    }

   206

    ||

   207

}

   208

   209

emit "preamble:widget-base-class" {

   210

    ||

   211

    var pending_widget_animates = [];

   212

   213

    function _hide(elt, placeholder){

   214

        if(elt.parentNode != null)

   215

            placeholder.parentNode.removeChild(elt);

   216

    }

   217

    function _show(elt, placeholder){

   218

        placeholder.parentNode.insertBefore(elt, placeholder);

   219

    }

   220

   221

    function set_activation_state(eltsub, state){

   222

        if(eltsub.active_elt != undefined){

   223

            if(eltsub.active_elt_placeholder == undefined){

   224

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

   225

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

   226

            }

   227

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

   228

        }

   229

        if(eltsub.inactive_elt != undefined){

   230

            if(eltsub.inactive_elt_placeholder == undefined){

   231

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

   232

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

   233

            }

   234

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

   235

        }

   236

    }

   237

   238

    function activate_activable(eltsub) {

   239

        set_activation_state(eltsub, true);

   240

    }

   241

   242

    function inactivate_activable(eltsub) {

   243

        set_activation_state(eltsub, false);

   244

    }

   245

   246

    class Widget {

   247

        offset = 0;

   248

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

   249

        unsubscribable = false;

   250

        pending_animate = false;

   251

   253

            this.element_id = elt_id;

   254

            this.element = id(elt_id);

   255

            this.args = args;

   259

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

   263

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

   264

   268

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

   269

   270

            this.forced_frequency = freq;

   271

            this.clip = true;

   272

        }

   273

   274

        do_init(){

   275

            let forced = this.forced_frequency;

   276

            if(forced !== undefined){

   277

                /*

   278

                once every 10 seconds : 10s

   279

                once per minute : 1m

   280

                once per hour : 1h

   281

                once per day : 1d

   282

                */

   283

                let unit = forced.slice(-1);

   284

                let factor = {

   285

                    "s":1,

   286

                    "m":60,

   287

                    "h":3600,

   288

                    "d":86400}[unit];

   289

   290

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

   291

                                          : Number(forced);

   292

            }

   293

   294

            let init = this.init;

   295

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

   296

                try {

   297

                    init.call(this);

   298

                } catch(err) {

   299

                    console.log(err);

   300

                }

   301

            }

   302

   304

                this.disabled_elt = null;

   305

                this.enabled_elts = [];

   306

                this.enable_state = false;

   307

                this.enable_displayed_state = false;

   308

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

   309

                    if(child.getAttribute("inkscape:label")=="disabled"){

   310

                        this.disabled_elt = child;

   311

                    }else{

   312

                        this.enabled_elts.push(child);

   313

                        this.element.removeChild(child);

   314

                    }

   315

                }

   316

            }

   317

        }

   318

   319

        unsub(){

   320

            /* remove subsribers */

   321

            if(!this.unsubscribable)

   322

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

   323

                    /* flush updates pending because of inhibition */

   324

                    let inhibition = this.inhibit[i];

   325

                    if(inhibition != undefined){

   326

                        clearTimeout(inhibition);

   327

                        this.lastapply[i] = undefined;

   328

                        this.uninhibit(i);

   329

                    }

   330

                    let deafened = this.deafen[i];

   331

                    if(deafened != undefined){

   332

                        clearTimeout(deafened);

   333

                        this.lastdispatch[i] = undefined;

   334

                        this.undeafen(i);

   335

                    }

   336

                    let index = this.indexes[i];

   337

                    if(this.relativeness[i])

   338

                        index += this.offset;

   339

                    subscribers(index).delete(this);

   340

                }

   341

            this.offset = 0;

   342

            this.relativeness = undefined;

   343

        }

   344

   345

        sub(new_offset=0, relativeness, container_id){

   346

            this.offset = new_offset;

   347

            this.relativeness = relativeness;

   348

            this.container_id = container_id ;

   349

            /* add this's subsribers */

   350

            if(!this.unsubscribable)

   351

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

   352

                    let index = this.get_variable_index(i);

   353

                    if(index == undefined) continue;

   354

                    subscribers(index).add(this);

   355

                }

   356

            need_cache_apply.push(this); 

   357

        }

   358

   359

        apply_cache() {

   360

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

   361

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

   362

                let realindex = this.get_variable_index(index);

   363

                if(realindex == undefined) continue;

   364

                let cached_val = cache[realindex];

   365

                if(cached_val != undefined)

   366

                    this._dispatch(cached_val, cached_val, index);

   367

            }

   368

        }

   369

   370

        get_variable_index(varnum) {

   371

            let index = this.indexes[varnum];

   372

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

   373

                index = page_local_index(index, this.container_id);

   374

            } else {

   375

                if(this.relativeness[varnum]){

   376

                    index += this.offset;

   377

                }

   378

            }

   379

            return index;

   380

        }

   381

   382

        overshot(new_val, max) {

   383

        }

   384

   385

        undershot(new_val, min) {

   386

        }

   387

   388

        clip_min_max(index, new_val) {

   390

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

   391

                let [min,max] = minmax;

   392

                if(new_val < min){

   393

                    this.undershot(new_val, min);

   394

                    return min;

   395

                }

   396

                if(new_val > max){

   397

                    this.overshot(new_val, max);

   398

                    return max;

   399

                }

   400

            }

   401

            return new_val;

   402

        }

   403

   404

        change_hmi_value(index, opstr) {

   405

            let realindex = this.get_variable_index(index);

   406

            if(realindex == undefined) return undefined;

   407

            let old_val = cache[realindex];

   408

            let new_val = eval_operation_string(old_val, opstr);

   409

            if(this.clip)

   410

                new_val = this.clip_min_max(index, new_val);

   411

            return apply_hmi_value(realindex, new_val);

   412

        }

   413

   414

        _apply_hmi_value(index, new_val) {

   415

            let realindex = this.get_variable_index(index);

   416

            if(realindex == undefined) return undefined;

   417

            if(this.clip)

   418

                new_val = this.clip_min_max(index, new_val);

   419

            return apply_hmi_value(realindex, new_val);

   420

        }

   421

   422

        uninhibit(index){

   423

            this.inhibit[index] = undefined;

   424

            let new_val = this.pending[index];

   425

            this.pending[index] = undefined;

   426

            return this.apply_hmi_value(index, new_val);

   427

        }

   428

   429

        apply_hmi_value(index, new_val) {

   430

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

   431

                let now = Date.now();

   432

                let min_interval = 1000/this.frequency;

   433

                let lastapply = this.lastapply[index];

   434

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

   435

                    this.lastapply[index] = now;

   436

                    return this._apply_hmi_value(index, new_val);

   437

                }

   438

                else {

   439

                    let elapsed = now - lastapply;

   440

                    this.pending[index] = new_val;

   441

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

   442

                }

   443

            }

   444

            else {

   445

                this.pending[index] = new_val;

   446

                return new_val;

   447

            }

   448

        }

   449

   450

        new_hmi_value(index, value, oldval) {

   451

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

   452

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

   453

                let refindex = this.get_variable_index(i);

   454

                if(refindex == undefined) continue;

   455

   456

                if(index == refindex) {

   457

                    this._dispatch(value, oldval, i);

   458

                    break;

   459

                }

   460

            }

   461

        }

   462

   463

        undeafen(index){

   464

            this.deafen[index] = undefined;

   465

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

   466

            this.incoming[index] = undefined;

   467

            this.dispatch(new_val, old_val, index);

   468

        }

   469

   470

        enable(enabled){

   471

            if(this.enable_state != enabled){

   472

                this.enable_state = enabled;

   473

                this.request_animate();

   474

            }

   475

        }

   476

   477

        animate_enable(){

   478

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

   479

                //show widget

   480

                for(let child of this.enabled_elts){

   481

                    this.element.appendChild(child);

   482

                }

   483

   484

                //hide disabled content