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

    18

    optional_labels(*ptr) {

    19

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

    20

        content;

    21

    }

    22

};

    23

    24

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

    25

    type > «@type»

    26

    content;

    27

};

    28

    29

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

    30

    | class `text **clsname` extends Widget{

    31

    content;

    32

    | }

    33

};

    34

    35

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

    36

    param "hmi_element";

    37

    content;

    38

};

    39

    40

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

    41

    param "page_desc";

    42

    content;

    43

};

    44

    45

decl gen_index_xhtml alias - {

    46

    content;

    47

};

    48

    49

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

    50

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

    51

    const "eltid","@id";

    52

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

    53

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

    54

        choose {

    55

            when "not(@index)" {

    56

                choose {

    57

                    when "not(@type)" {

    58

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

    59

                        > undefined

    60

                    }

    61

                    when "@type = 'PAGE_LOCAL'" 

    62

                        > "«@value»"

    63

                    when "@type = 'HMI_LOCAL'" 

    64

                        > hmi_local_index("«@value»")

    65

                    otherwise 

    66

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

    67

                }

    68

            }

    69

            otherwise {

    70

                > «@index»

    71

            }

    72

        }

    73

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

    74

    }

    75

    76

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

    77

        choose {

    78

            when "@min and @max"

    79

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

    80

            otherwise

    81

                > undefined

    82

        }

    83

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

    84

    }

    85

    86

    const "freq" choose {

    87

        when "$widget/@freq"

    88

            > "«$widget/@freq»"

    89

        otherwise

    90

            > undefined

    91

    }

    92

    93

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

    94

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

    95

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

    96

}

    97

    98

emit "preamble:local-variable-indexes" {

    99

    ||

   100

   101

    let hmi_locals = {};

   102

    var last_remote_index = hmitree_types.length - 1;

   103

    var next_available_index = hmitree_types.length;

   104

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

   105

   106

    const local_defaults = {

   107

    ||

   108

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

   109

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

   110

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

   111

        >     "«path/@value»":

   112

        choose {

   113

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

   114

            otherwise > «arg[1]/@value»

   115

        }

   116

        > \n

   117

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

   118

    }

   119

    ||

   120

    };

   121

   122

    const persistent_locals = new Set([

   123

    ||

   124

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

   125

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

   126

    }

   127

    ||

   128

    ]);

   129

    var persistent_indexes = new Map();

   130

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

   131

    var updates = new Map();

   132

   133

    function page_local_index(varname, pagename){

   134

        let pagevars = hmi_locals[pagename];

   135

        let new_index;

   136

        if(pagevars == undefined){

   137

            new_index = next_available_index++;

   138

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

   139

        } else {

   140

            let result = pagevars[varname];

   141

            if(result != undefined) {

   142

                return result;

   143

            }

   144

   145

            new_index = next_available_index++;

   146

            pagevars[varname] = new_index;

   147

        }

   148

        let defaultval = local_defaults[varname];

   149

        if(defaultval != undefined) {

   150

            cache[new_index] = defaultval; 

   151

            updates.set(new_index, defaultval);

   152

            if(persistent_locals.has(varname))

   153

                persistent_indexes.set(new_index, varname);

   154

        }

   155

        return new_index;

   156

    }

   157

   158

    function hmi_local_index(varname){

   159

        return page_local_index(varname, "HMI_LOCAL");

   160

    }

   161

    ||

   162

}

   163

   164

emit "preamble:widget-base-class" {

   165

    ||

   166

    var pending_widget_animates = [];

   167

   168

    class Widget {

   169

        offset = 0;

   170

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

   171

        unsubscribable = false;

   172

        pending_animate = false;

   173

   174

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

   175

            this.element_id = elt_id;

   176

            this.element = id(elt_id);

   177

            this.args = args;

   178

            this.indexes = indexes;

   179

            this.minmaxes = minmaxes;

   180

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

   181

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

   182

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

   183

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

   184

            this.bound_unhinibit = this.unhinibit.bind(this);

   185

            this.forced_frequency = freq;

   186

            this.clip = true;

   187

        }

   188

   189

        do_init(){

   190

            if(widget.forced_frequency !== undefined){

   191

                let s = widget.forced_frequency;

   192

                /*

   193

                once every 10 seconds : 10s

   194

                once per minute : 1m

   195

                once per hour : 1h

   196

                once per day : 1d

   197

                */

   198

                let unit = s.slice(-1);

   199

                let factor = {

   200

                    "s":1,

   201

                    "m":60,

   202

                    "h":3600,

   203

                    "d":86400}[unit];

   204

   205

                widget.frequency = factor ? 1/(factor * Number(s.slice(0,-1)))

   206

                                          : Number(s);

   207

            }

   208

   209

            let init = this.init;

   210

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

   211

                try {

   212

                    init.call(this);

   213

                } catch(err) {

   214

                    console.log(err);

   215

                }

   216

            }

   217

        }

   218

   219

        unsub(){

   220

            /* remove subsribers */

   221

            if(!this.unsubscribable)

   222

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

   223

                    /* flush updates pending because of inhibition */

   224

                    let inhibition = this.inhibit[i];

   225

                    if(inhibition != undefined){

   226

                        clearTimeout(inhibition);

   227

                        this.lastapply[i] = undefined;

   228

                        this.unhinibit(i);

   229

                    }

   230

                    let index = this.indexes[i];

   231

                    if(this.relativeness[i])

   232

                        index += this.offset;

   233

                    subscribers(index).delete(this);

   234

                }

   235

            this.offset = 0;

   236

            this.relativeness = undefined;

   237

        }

   238

   239

        sub(new_offset=0, relativeness, container_id){

   240

            this.offset = new_offset;

   241

            this.relativeness = relativeness;

   242

            this.container_id = container_id ;

   243

            /* add this's subsribers */

   244

            if(!this.unsubscribable)

   245

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

   246

                    let index = this.get_variable_index(i);

   247

                    if(index == undefined) continue;

   248

                    subscribers(index).add(this);

   249

                }

   250

            need_cache_apply.push(this); 

   251

        }

   252

   253

        apply_cache() {

   254

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

   255

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

   256

                let realindex = this.get_variable_index(index);

   257

                if(realindex == undefined) continue;

   258

                let cached_val = cache[realindex];

   259

                if(cached_val != undefined)

   260

                    this._dispatch(cached_val, cached_val, index);

   261

            }

   262

        }

   263

   264

        get_variable_index(varnum) {

   265

            let index = this.indexes[varnum];

   266

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

   267

                index = page_local_index(index, this.container_id);

   268

            } else {

   269

                if(this.relativeness[varnum]){

   270

                    index += this.offset;

   271

                }

   272

            }

   273

            return index;

   274

        }

   275

   276

        overshot(new_val, max) {

   277

        }

   278

   279

        undershot(new_val, min) {

   280

        }

   281

   282

        clip_min_max(index, new_val) {

   283

            let minmax = this.minmaxes[index];

   284

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

   285

                let [min,max] = minmax;

   286

                if(new_val < min){

   287

                    this.undershot(new_val, min);

   288

                    return min;

   289

                }

   290

                if(new_val > max){

   291

                    this.overshot(new_val, max);

   292

                    return max;

   293

                }

   294

            }

   295

            return new_val;

   296

        }

   297

   298

        change_hmi_value(index, opstr) {

   299

            let realindex = this.get_variable_index(index);

   300

            if(realindex == undefined) return undefined;

   301

            let old_val = cache[realindex];

   302

            let new_val = eval_operation_string(old_val, opstr);

   303

            if(this.clip)

   304

                new_val = this.clip_min_max(index, new_val);

   305

            return apply_hmi_value(realindex, new_val);

   306

        }

   307

   308

        _apply_hmi_value(index, new_val) {

   309

            let realindex = this.get_variable_index(index);

   310

            if(realindex == undefined) return undefined;

   311

            if(this.clip)

   312

                new_val = this.clip_min_max(index, new_val);

   313

            return apply_hmi_value(realindex, new_val);

   314

        }

   315

   316

        unhinibit(index){

   317

            this.inhibit[index] = undefined;

   318

            let new_val = this.pending[index];

   319

            this.pending[index] = undefined;

   320

            return this.apply_hmi_value(index, new_val);

   321

        }

   322

   323

        apply_hmi_value(index, new_val) {

   324

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

   325

                let now = Date.now();

   326

                let min_interval = 1000/this.frequency;

   327

                let lastapply = this.lastapply[index];

   328

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

   329

                    this.lastapply[index] = now;

   330

                    return this._apply_hmi_value(index, new_val);

   331

                }

   332

                else {

   333

                    let elapsed = now - lastapply;

   334

                    this.pending[index] = new_val;

   335

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

   336

                }

   337

            }

   338

            else {

   339

                this.pending[index] = new_val;

   340

                return new_val;

   341

            }

   342

        }

   343

   344

        new_hmi_value(index, value, oldval) {

   345

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

   346

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

   347

                let refindex = this.get_variable_index(i);

   348

                if(refindex == undefined) continue;

   349

   350

                if(index == refindex) {

   351

                    this._dispatch(value, oldval, i);

   352

                    break;

   353

                }

   354

            }

   355

        }

   356

   357

        _dispatch(value, oldval, varnum) {

   358

            let dispatch = this.dispatch;

   359

            if(dispatch != undefined){

   360

                try {

   361

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

   362

                } catch(err) {

   363

                    console.log(err);

   364

                }

   365

            }

   366

        }

   367

   368

        _animate(){

   369

            this.animate();

   370

            this.pending_animate = false;

   371

        }

   372

   373

        request_animate(){

   374

            if(!this.pending_animate){

   375

                pending_widget_animates.push(this);

   376

                this.pending_animate = true;

   377

                requestHMIAnimation();

   378

            }

   379

   380

        }

   381

   382

        activate_activable(eltsub) {

   383

            eltsub.inactive.style.display = "none";

   384

            eltsub.active.style.display = "";

   385

        }

   386

   387

        inactivate_activable(eltsub) {

   388

            eltsub.active.style.display = "none";

   389

            eltsub.inactive.style.display = "";

   390

        }

   391

    }

   392

    ||

   393

}

   394

   395

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

   396

   397

// Key to filter unique types

   398

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

   399

   400

emit "declarations:hmi-classes" {

   401

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

   402

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

   403

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

   404

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

   405

}

   406

   407

template "widget", mode="widget_class"

   408

||

   409

class «@type»Widget extends Widget{

   410

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

   411

}

   412

||

   413

   414

const "included_ids","$parsed_widgets/widget[not(@type = $excluded_types) and not(@id = $discardable_elements/@id)]/@id";

   415

const "hmi_widgets","$hmi_elements[@id = $included_ids]";

   416

const "result_widgets","$result_svg_ns//*[@id = $hmi_widgets/@id]";

   417

   418

emit "declarations:hmi-elements" {

   419

    | var hmi_widgets = {

   420

    apply "$hmi_widgets", mode="hmi_widgets";

   421

    | }

   422

}

   423

   424

function "defs_by_labels" {

   425

    param "labels","''";

   426

    param "mandatory","'yes'";

   427

    param "subelements","/..";

   428

    param "hmi_element";

   429

    const "widget_type","@type";

   430

    foreach "str:split($labels)" {

   431

        const "absolute", "starts-with(., '/')";

   432

        const "name","substring(.,number($absolute)+1)";

   433

        const "widget","$result_widgets[@id = $hmi_element/@id]";

   434

        const "elt","($widget//*[not($absolute) and @inkscape:label=$name] | $widget/*[$absolute and @inkscape:label=$name])[1]";

   435

        choose {

   436

            when "not($elt/@id)" {

   437

                if "$mandatory='yes'" {

   438

                    error > «$widget_type» widget must have a «$name» element

   439

                }

   440

                // otherwise produce nothing

   441

            }

   442

            otherwise {

   443

                |     «$name»_elt: id("«$elt/@id»"),

   444

                if "$subelements" {

   445

                |     «$name»_sub: {

   446

                    foreach "str:split($subelements)" {

   447

                        const "subname",".";

   448

                        const "subelt","$elt/*[@inkscape:label=$subname][1]";

   449

                        choose {

   450

                            when "not($subelt/@id)" {

   451

                                if "$mandatory='yes'" {

   452

                                    error > «$widget_type» widget must have a «$name»/«$subname» element

   453

                                }

   454

                |         /* missing «$name»/«$subname» element */

   455

                            }

   456

                            otherwise {

   457

                |         "«$subname»": id("«$subelt/@id»")`if "position()!=last()" > ,`

   458

                            }

   459

                        }

   460

                    }

   461

                |     },

   462

                }

   463

            }

   464

        }

   465

    }

   466

}

   467

   468

def "func:escape_quotes" {

   469

    param "txt";

   470

    // have to use a python string to enter escaped quote

   471

    // const "frstln", "string-length($frst)";

   472

    choose {

   473

        when !"contains($txt,'\"')"! {

   474

            result !"concat(substring-before($txt,'\"'),'\\\"',func:escape_quotes(substring-after($txt,'\"')))"!;

   475

        }

   476

        otherwise {

   477

            result "$txt";

   478

        }

   479

    }

   480

}

   481