1

// widget_display.ysl2

     2

     3

     4

template "widget[@type='Display']", mode="widget_class"

     5

    ||

     6

    class DisplayWidget extends Widget{

     7

        frequency = 5;

     8

        dispatch(value, oldval, index) {

     9

            this.fields[index] = value;    

    10

            this.request_animate();

    11

        }

    12

    }

    13

    ||

    14

    15

template "widget[@type='Display']", mode="widget_defs" {

    16

    param "hmi_element";

    17

    18

    const "format" optional_labels("format");

    19

    const "has_format","string-length($format)>0";

    20

    value "$format";

    21

    22

    if "$hmi_element[not(self::svg:text)] and not($has_format)"

    23

        error > Display Widget id="«$hmi_element/@id»" must be a svg::text element itself or a group containing a svg:text element labelled "format"

    24

    25

    const "field_initializer" foreach "path" {

    26

        choose{

    27

            when "@type='HMI_STRING'" > ""

    28

            otherwise > 0

    29

        }

    30

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

    31

    }

    32

    |     fields: [«$field_initializer»],

    33

    |     animate: function(){

    34

    choose {

    35

        when "$has_format" {

    36

    |       if(this.format_elt.getAttribute("lang")) {

    37

    |           this.format = svg_text_to_multiline(this.format_elt);

    38

    |           this.format_elt.removeAttribute("lang");

    39

    |       }

    40

    |       let str = vsprintf(this.format,this.fields);

    41

    |       multiline_to_svg_text(this.format_elt, str);

    42

        }

    43

        otherwise {

    44

    |       let str = this.args.length == 1 ? vsprintf(this.args[0],this.fields) : this.fields.join(' ');

    45

    |       multiline_to_svg_text(this.element, str);

    46

        }

    47

    }

    48

    |     },

    49

    |     

    50

    if "$has_format" {

    51

    |     init: function() {

    52

    |       this.format = svg_text_to_multiline(this.format_elt);

    53

    |     },

    54

    }

    55

}

    56

    57

emit "preamble:display"

    58

||

    59

/* https://github.com/alexei/sprintf.js/blob/master/src/sprintf.js */

    60

/* global window, exports, define */

    61

    62

!function() {

    63

    'use strict'

    64

    65

    var re = {

    66

        not_string: /[^s]/,

    67

        not_bool: /[^t]/,

    68

        not_type: /[^T]/,

    69

        not_primitive: /[^v]/,

    70

        number: /[diefg]/,

    71

        numeric_arg: /[bcdiefguxX]/,

    72

        json: /[j]/,

    73

        not_json: /[^j]/,

    74

        text: /^[^\x25]+/,

    75

        modulo: /^\x25{2}/,

    76

        placeholder: /^\x25(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/,

    77

        key: /^([a-z_][a-z_\d]*)/i,

    78

        key_access: /^\.([a-z_][a-z_\d]*)/i,

    79

        index_access: /^\[(\d+)\]/,

    80

        sign: /^[+-]/

    81

    }

    82

    83

    function sprintf(key) {

    84

        // `arguments` is not an array, but should be fine for this call

    85

        return sprintf_format(sprintf_parse(key), arguments)

    86

    }

    87

    88

    function vsprintf(fmt, argv) {

    89

        return sprintf.apply(null, [fmt].concat(argv || []))

    90

    }

    91

    92

    function sprintf_format(parse_tree, argv) {

    93

        var cursor = 1, tree_length = parse_tree.length, arg, output = '', i, k, ph, pad, pad_character, pad_length, is_positive, sign

    94

        for (i = 0; i < tree_length; i++) {

    95

            if (typeof parse_tree[i] === 'string') {

    96

                output += parse_tree[i]

    97

            }

    98

            else if (typeof parse_tree[i] === 'object') {

    99

                ph = parse_tree[i] // convenience purposes only

   100

                if (ph.keys) { // keyword argument

   101

                    arg = argv[cursor]

   102

                    for (k = 0; k < ph.keys.length; k++) {

   103

                        if (arg == undefined) {

   104

                            throw new Error(sprintf('[sprintf] Cannot access property "%s" of undefined value "%s"', ph.keys[k], ph.keys[k-1]))

   105

                        }

   106

                        arg = arg[ph.keys[k]]

   107

                    }

   108

                }

   109

                else if (ph.param_no) { // positional argument (explicit)

   110

                    arg = argv[ph.param_no]

   111

                }

   112

                else { // positional argument (implicit)

   113

                    arg = argv[cursor++]

   114

                }

   115

   116

                if (re.not_type.test(ph.type) && re.not_primitive.test(ph.type) && arg instanceof Function) {

   117

                    arg = arg()

   118

                }

   119

   120

                if (re.numeric_arg.test(ph.type) && (typeof arg !== 'number' && isNaN(arg))) {

   121

                    throw new TypeError(sprintf('[sprintf] expecting number but found %T', arg))

   122

                }

   123

   124

                if (re.number.test(ph.type)) {

   125

                    is_positive = arg >= 0

   126

                }

   127

   128

                switch (ph.type) {

   129

                    case 'b':

   130

                        arg = parseInt(arg, 10).toString(2)

   131

                        break

   132

                    case 'c':

   133

                        arg = String.fromCharCode(parseInt(arg, 10))

   134

                        break

   135

                    case 'd':

   136

                    case 'i':

   137

                        arg = parseInt(arg, 10)

   138

                        break

   139

                    case 'j':

   140

                        arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0)

   141

                        break

   142

                    case 'e':

   143

                        arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential()

   144

                        break

   145

                    case 'f':

   146

                        arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg)

   147

                        break

   148

                    case 'g':

   149

                        arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg)

   150

                        break

   151

                    case 'o':

   152

                        arg = (parseInt(arg, 10) >>> 0).toString(8)

   153

                        break

   154

                    case 's':

   155

                        arg = String(arg)

   156

                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)

   157

                        break

   158

                    case 't':

   159

                        arg = String(!!arg)

   160

                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)

   161

                        break

   162

                    case 'T':

   163

                        arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase()

   164

                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)

   165

                        break

   166

                    case 'u':

   167

                        arg = parseInt(arg, 10) >>> 0

   168

                        break

   169

                    case 'v':

   170

                        arg = arg.valueOf()

   171

                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)

   172

                        break

   173

                    case 'x':

   174

                        arg = (parseInt(arg, 10) >>> 0).toString(16)

   175

                        break

   176

                    case 'X':

   177

                        arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase()

   178

                        break

   179

                }

   180

                if (re.json.test(ph.type)) {

   181

                    output += arg

   182

                }

   183

                else {

   184

                    if (re.number.test(ph.type) && (!is_positive || ph.sign)) {

   185

                        sign = is_positive ? '+' : '-'

   186

                        arg = arg.toString().replace(re.sign, '')

   187

                    }

   188

                    else {

   189

                        sign = ''

   190

                    }

   191

                    pad_character = ph.pad_char ? ph.pad_char === '0' ? '0' : ph.pad_char.charAt(1) : ' '

   192

                    pad_length = ph.width - (sign + arg).length

   193

                    pad = ph.width ? (pad_length > 0 ? pad_character.repeat(pad_length) : '') : ''

   194

                    output += ph.align ? sign + arg + pad : (pad_character === '0' ? sign + pad + arg : pad + sign + arg)

   195

                }

   196

            }

   197

        }

   198

        return output

   199

    }

   200

   201

    var sprintf_cache = Object.create(null)

   202

   203

    function sprintf_parse(fmt) {

   204

        if (sprintf_cache[fmt]) {

   205

            return sprintf_cache[fmt]

   206

        }

   207

   208

        var _fmt = fmt, match, parse_tree = [], arg_names = 0

   209

        while (_fmt) {

   210

            if ((match = re.text.exec(_fmt)) !== null) {

   211

                parse_tree.push(match[0])

   212

            }

   213

            else if ((match = re.modulo.exec(_fmt)) !== null) {

   214

                parse_tree.push('%')

   215

            }

   216

            else if ((match = re.placeholder.exec(_fmt)) !== null) {

   217

                if (match[2]) {

   218

                    arg_names |= 1

   219

                    var field_list = [], replacement_field = match[2], field_match = []

   220

                    if ((field_match = re.key.exec(replacement_field)) !== null) {

   221

                        field_list.push(field_match[1])

   222

                        while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {

   223

                            if ((field_match = re.key_access.exec(replacement_field)) !== null) {

   224

                                field_list.push(field_match[1])

   225

                            }

   226

                            else if ((field_match = re.index_access.exec(replacement_field)) !== null) {

   227

                                field_list.push(field_match[1])

   228

                            }

   229

                            else {

   230

                                throw new SyntaxError('[sprintf] failed to parse named argument key')

   231

                            }

   232

                        }

   233

                    }

   234

                    else {

   235

                        throw new SyntaxError('[sprintf] failed to parse named argument key')

   236

                    }

   237

                    match[2] = field_list

   238

                }

   239

                else {

   240

                    arg_names |= 2

   241

                }

   242

                if (arg_names === 3) {

   243

                    throw new Error('[sprintf] mixing positional and named placeholders is not (yet) supported')

   244

                }

   245

   246

                parse_tree.push(

   247

                    {

   248

                        placeholder: match[0],

   249

                        param_no:    match[1],

   250

                        keys:        match[2],

   251

                        sign:        match[3],

   252

                        pad_char:    match[4],

   253

                        align:       match[5],

   254

                        width:       match[6],

   255

                        precision:   match[7],

   256

                        type:        match[8]

   257

                    }

   258

                )

   259

            }

   260

            else {

   261

                throw new SyntaxError('[sprintf] unexpected placeholder')

   262

            }

   263

            _fmt = _fmt.substring(match[0].length)

   264

        }

   265

        return sprintf_cache[fmt] = parse_tree

   266

    }

   267

   268

    /**

   269

     * export to either browser or node.js

   270

     */

   271

    /* eslint-disable quote-props */

   272

    if (typeof exports !== 'undefined') {

   273

        exports['sprintf'] = sprintf

   274

        exports['vsprintf'] = vsprintf

   275

    }

   276

    if (typeof window !== 'undefined') {

   277

        window['sprintf'] = sprintf

   278

        window['vsprintf'] = vsprintf

   279

   280

        if (typeof define === 'function' && define['amd']) {

   281

            define(function() {

   282

                return {

   283

                    'sprintf': sprintf,

   284

                    'vsprintf': vsprintf

   285

                }

   286

            })

   287

        }

   288

    }

   289

    /* eslint-enable quote-props */

   290

}(); // eslint-disable-line    

   291

||