Mercurial Mercurial > beremiz / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
svghmi/gen_index_xhtml.xslt
changeset 3362 abcdbef160e9
parent 3358 7478d0c0dc1c
child 3383 a3b8cfd89648
equal deleted inserted replaced
3361:d955f2a3fabf 3362:abcdbef160e9 
  2400 </xsl:text>
 
  2400 </xsl:text>
 
  2401       <xsl:text>respective minimum and maximum value. Otherwise, value is expected to be
 
  2401       <xsl:text>respective minimum and maximum value. Otherwise, value is expected to be
 
  2402 </xsl:text>
 
  2402 </xsl:text>
 
  2403       <xsl:text>in between 0 and 100.
 
  2403       <xsl:text>in between 0 and 100.
 
  2404 </xsl:text>
 
  2404 </xsl:text>
 
  2405       <xsl:text>
 
       
  2406 </xsl:text>
 
       
  2407       <xsl:text>If "value" labeled text is found, then its content is replaced by value.
 
       
  2408 </xsl:text>
 
       
  2409     </longdesc>
 
  2405     </longdesc>
 
  2410     <shortdesc>
 
  2406     <shortdesc>
 
  2411       <xsl:text>Change end angle of Inkscape's arc</xsl:text>
 
  2407       <xsl:text>Change end angle of Inkscape's arc</xsl:text>
 
  2412     </shortdesc>
 
  2408     </shortdesc>
 
       
  2409     <arg name="min" count="optional" accepts="int,real">
 
       
  2410       <xsl:text>minimum value</xsl:text>
 
       
  2411     </arg>
 
       
  2412     <arg name="max" count="optional" accepts="int,real">
 
       
  2413       <xsl:text>maximum value</xsl:text>
 
       
  2414     </arg>
 
  2413     <path name="value" accepts="HMI_INT,HMI_REAL">
 
  2415     <path name="value" accepts="HMI_INT,HMI_REAL">
 
  2414       <xsl:text>Value to display</xsl:text>
 
  2416       <xsl:text>Value to display</xsl:text>
 
  2415     </path>
 
  2417     </path>
 
  2416   </xsl:template>
 
  2418   </xsl:template>
 
  2417   <xsl:template match="widget[@type='CircularBar']" mode="widget_class">
 
  2419   <xsl:template match="widget[@type='CircularBar']" mode="widget_class">
 
  2474     <xsl:text>    }
 
  2476     <xsl:text>    }
 
  2475 </xsl:text>
 
  2477 </xsl:text>
 
  2476     <xsl:text>
 
  2478     <xsl:text>
 
  2477 </xsl:text>
 
  2479 </xsl:text>
 
  2478     <xsl:text>    init() {
 
  2480     <xsl:text>    init() {
 
       
  2481 </xsl:text>
 
       
  2482     <xsl:text>        if(this.args.length &gt;= 2)
 
       
  2483 </xsl:text>
 
       
  2484     <xsl:text>            [this.min, this.max]=this.args;
 
       
  2485 </xsl:text>
 
       
  2486     <xsl:text>
 
  2479 </xsl:text>
 
  2487 </xsl:text>
 
  2480     <xsl:text>        let [start, end, cx, cy, rx, ry] = ["start", "end", "cx", "cy", "rx", "ry"].
 
  2488     <xsl:text>        let [start, end, cx, cy, rx, ry] = ["start", "end", "cx", "cy", "rx", "ry"].
 
  2481 </xsl:text>
 
  2489 </xsl:text>
 
  2482     <xsl:text>            map(tag=&gt;Number(this.path_elt.getAttribute('sodipodi:'+tag)))
 
  2490     <xsl:text>            map(tag=&gt;Number(this.path_elt.getAttribute('sodipodi:'+tag)))
 
  2483 </xsl:text>
 
  2491 </xsl:text>
 
  2523       </xsl:with-param>
 
  2531       </xsl:with-param>
 
  2524     </xsl:call-template>
 
  2532     </xsl:call-template>
 
  2525     <xsl:call-template name="defs_by_labels">
 
  2533     <xsl:call-template name="defs_by_labels">
 
  2526       <xsl:with-param name="hmi_element" select="$hmi_element"/>
 
  2534       <xsl:with-param name="hmi_element" select="$hmi_element"/>
 
  2527       <xsl:with-param name="labels">
 
  2535       <xsl:with-param name="labels">
 
  2528         <xsl:text>value min max</xsl:text>
 
  2536         <xsl:text>min max</xsl:text>
 
  2529       </xsl:with-param>
 
  2537       </xsl:with-param>
 
  2530       <xsl:with-param name="mandatory" select="'no'"/>
 
  2538       <xsl:with-param name="mandatory" select="'no'"/>
 
  2531     </xsl:call-template>
 
  2539     </xsl:call-template>
 
  2532   </xsl:template>
 
  2540   </xsl:template>
 
  2533   <xsl:template match="widget[@type='CircularSlider']" mode="widget_desc">
 
  2541   <xsl:template match="widget[@type='CircularSlider']" mode="widget_desc">
 
  3245       <xsl:text>      this.format = svg_text_to_multiline(this.format_elt);
 
  3253       <xsl:text>      this.format = svg_text_to_multiline(this.format_elt);
 
  3246 </xsl:text>
 
  3254 </xsl:text>
 
  3247       <xsl:text>    },
 
  3255       <xsl:text>    },
 
  3248 </xsl:text>
 
  3256 </xsl:text>
 
  3249     </xsl:if>
 
  3257     </xsl:if>
 
  3250   </xsl:template>
 
       
  3251   <preamble:display/>
 
       
  3252   <xsl:template match="preamble:display">
 
       
  3253     <xsl:text>
 
       
  3254 </xsl:text>
 
       
  3255     <xsl:text>/* </xsl:text>
 
       
  3256     <xsl:value-of select="local-name()"/>
 
       
  3257     <xsl:text> */
 
       
  3258 </xsl:text>
 
       
  3259     <xsl:text>
 
       
  3260 </xsl:text>
 
       
  3261     <xsl:text>/* https://github.com/alexei/sprintf.js/blob/master/src/sprintf.js */
 
       
  3262 </xsl:text>
 
       
  3263     <xsl:text>/* global window, exports, define */
 
       
  3264 </xsl:text>
 
       
  3265     <xsl:text>
 
       
  3266 </xsl:text>
 
       
  3267     <xsl:text>!function() {
 
       
  3268 </xsl:text>
 
       
  3269     <xsl:text>    'use strict'
 
       
  3270 </xsl:text>
 
       
  3271     <xsl:text>
 
       
  3272 </xsl:text>
 
       
  3273     <xsl:text>    var re = {
 
       
  3274 </xsl:text>
 
       
  3275     <xsl:text>        not_string: /[^s]/,
 
       
  3276 </xsl:text>
 
       
  3277     <xsl:text>        not_bool: /[^t]/,
 
       
  3278 </xsl:text>
 
       
  3279     <xsl:text>        not_type: /[^T]/,
 
       
  3280 </xsl:text>
 
       
  3281     <xsl:text>        not_primitive: /[^v]/,
 
       
  3282 </xsl:text>
 
       
  3283     <xsl:text>        number: /[diefg]/,
 
       
  3284 </xsl:text>
 
       
  3285     <xsl:text>        numeric_arg: /[bcdiefguxX]/,
 
       
  3286 </xsl:text>
 
       
  3287     <xsl:text>        json: /[j]/,
 
       
  3288 </xsl:text>
 
       
  3289     <xsl:text>        not_json: /[^j]/,
 
       
  3290 </xsl:text>
 
       
  3291     <xsl:text>        text: /^[^%]+/,
 
       
  3292 </xsl:text>
 
       
  3293     <xsl:text>        modulo: /^%{2}/,
 
       
  3294 </xsl:text>
 
       
  3295     <xsl:text>        placeholder: /^%(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/,
 
       
  3296 </xsl:text>
 
       
  3297     <xsl:text>        key: /^([a-z_][a-z_\d]*)/i,
 
       
  3298 </xsl:text>
 
       
  3299     <xsl:text>        key_access: /^\.([a-z_][a-z_\d]*)/i,
 
       
  3300 </xsl:text>
 
       
  3301     <xsl:text>        index_access: /^\[(\d+)\]/,
 
       
  3302 </xsl:text>
 
       
  3303     <xsl:text>        sign: /^[+-]/
 
       
  3304 </xsl:text>
 
       
  3305     <xsl:text>    }
 
       
  3306 </xsl:text>
 
       
  3307     <xsl:text>
 
       
  3308 </xsl:text>
 
       
  3309     <xsl:text>    function sprintf(key) {
 
       
  3310 </xsl:text>
 
       
  3311     <xsl:text>        // arguments is not an array, but should be fine for this call
 
       
  3312 </xsl:text>
 
       
  3313     <xsl:text>        return sprintf_format(sprintf_parse(key), arguments)
 
       
  3314 </xsl:text>
 
       
  3315     <xsl:text>    }
 
       
  3316 </xsl:text>
 
       
  3317     <xsl:text>
 
       
  3318 </xsl:text>
 
       
  3319     <xsl:text>    function vsprintf(fmt, argv) {
 
       
  3320 </xsl:text>
 
       
  3321     <xsl:text>        return sprintf.apply(null, [fmt].concat(argv || []))
 
       
  3322 </xsl:text>
 
       
  3323     <xsl:text>    }
 
       
  3324 </xsl:text>
 
       
  3325     <xsl:text>
 
       
  3326 </xsl:text>
 
       
  3327     <xsl:text>    function sprintf_format(parse_tree, argv) {
 
       
  3328 </xsl:text>
 
       
  3329     <xsl:text>        var cursor = 1, tree_length = parse_tree.length, arg, output = '', i, k, ph, pad, pad_character, pad_length, is_positive, sign
 
       
  3330 </xsl:text>
 
       
  3331     <xsl:text>        for (i = 0; i &lt; tree_length; i++) {
 
       
  3332 </xsl:text>
 
       
  3333     <xsl:text>            if (typeof parse_tree[i] === 'string') {
 
       
  3334 </xsl:text>
 
       
  3335     <xsl:text>                output += parse_tree[i]
 
       
  3336 </xsl:text>
 
       
  3337     <xsl:text>            }
 
       
  3338 </xsl:text>
 
       
  3339     <xsl:text>            else if (typeof parse_tree[i] === 'object') {
 
       
  3340 </xsl:text>
 
       
  3341     <xsl:text>                ph = parse_tree[i] // convenience purposes only
 
       
  3342 </xsl:text>
 
       
  3343     <xsl:text>                if (ph.keys) { // keyword argument
 
       
  3344 </xsl:text>
 
       
  3345     <xsl:text>                    arg = argv[cursor]
 
       
  3346 </xsl:text>
 
       
  3347     <xsl:text>                    for (k = 0; k &lt; ph.keys.length; k++) {
 
       
  3348 </xsl:text>
 
       
  3349     <xsl:text>                        if (arg == undefined) {
 
       
  3350 </xsl:text>
 
       
  3351     <xsl:text>                            throw new Error(sprintf('[sprintf] Cannot access property "%s" of undefined value "%s"', ph.keys[k], ph.keys[k-1]))
 
       
  3352 </xsl:text>
 
       
  3353     <xsl:text>                        }
 
       
  3354 </xsl:text>
 
       
  3355     <xsl:text>                        arg = arg[ph.keys[k]]
 
       
  3356 </xsl:text>
 
       
  3357     <xsl:text>                    }
 
       
  3358 </xsl:text>
 
       
  3359     <xsl:text>                }
 
       
  3360 </xsl:text>
 
       
  3361     <xsl:text>                else if (ph.param_no) { // positional argument (explicit)
 
       
  3362 </xsl:text>
 
       
  3363     <xsl:text>                    arg = argv[ph.param_no]
 
       
  3364 </xsl:text>
 
       
  3365     <xsl:text>                }
 
       
  3366 </xsl:text>
 
       
  3367     <xsl:text>                else { // positional argument (implicit)
 
       
  3368 </xsl:text>
 
       
  3369     <xsl:text>                    arg = argv[cursor++]
 
       
  3370 </xsl:text>
 
       
  3371     <xsl:text>                }
 
       
  3372 </xsl:text>
 
       
  3373     <xsl:text>
 
       
  3374 </xsl:text>
 
       
  3375     <xsl:text>                if (re.not_type.test(ph.type) &amp;&amp; re.not_primitive.test(ph.type) &amp;&amp; arg instanceof Function) {
 
       
  3376 </xsl:text>
 
       
  3377     <xsl:text>                    arg = arg()
 
       
  3378 </xsl:text>
 
       
  3379     <xsl:text>                }
 
       
  3380 </xsl:text>
 
       
  3381     <xsl:text>
 
       
  3382 </xsl:text>
 
       
  3383     <xsl:text>                if (re.numeric_arg.test(ph.type) &amp;&amp; (typeof arg !== 'number' &amp;&amp; isNaN(arg))) {
 
       
  3384 </xsl:text>
 
       
  3385     <xsl:text>                    throw new TypeError(sprintf('[sprintf] expecting number but found %T', arg))
 
       
  3386 </xsl:text>
 
       
  3387     <xsl:text>                }
 
       
  3388 </xsl:text>
 
       
  3389     <xsl:text>
 
       
  3390 </xsl:text>
 
       
  3391     <xsl:text>                if (re.number.test(ph.type)) {
 
       
  3392 </xsl:text>
 
       
  3393     <xsl:text>                    is_positive = arg &gt;= 0
 
       
  3394 </xsl:text>
 
       
  3395     <xsl:text>                }
 
       
  3396 </xsl:text>
 
       
  3397     <xsl:text>
 
       
  3398 </xsl:text>
 
       
  3399     <xsl:text>                switch (ph.type) {
 
       
  3400 </xsl:text>
 
       
  3401     <xsl:text>                    case 'b':
 
       
  3402 </xsl:text>
 
       
  3403     <xsl:text>                        arg = parseInt(arg, 10).toString(2)
 
       
  3404 </xsl:text>
 
       
  3405     <xsl:text>                        break
 
       
  3406 </xsl:text>
 
       
  3407     <xsl:text>                    case 'c':
 
       
  3408 </xsl:text>
 
       
  3409     <xsl:text>                        arg = String.fromCharCode(parseInt(arg, 10))
 
       
  3410 </xsl:text>
 
       
  3411     <xsl:text>                        break
 
       
  3412 </xsl:text>
 
       
  3413     <xsl:text>                    case 'd':
 
       
  3414 </xsl:text>
 
       
  3415     <xsl:text>                    case 'i':
 
       
  3416 </xsl:text>
 
       
  3417     <xsl:text>                        arg = parseInt(arg, 10)
 
       
  3418 </xsl:text>
 
       
  3419     <xsl:text>                        break
 
       
  3420 </xsl:text>
 
       
  3421     <xsl:text>                    case 'j':
 
       
  3422 </xsl:text>
 
       
  3423     <xsl:text>                        arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0)
 
       
  3424 </xsl:text>
 
       
  3425     <xsl:text>                        break
 
       
  3426 </xsl:text>
 
       
  3427     <xsl:text>                    case 'e':
 
       
  3428 </xsl:text>
 
       
  3429     <xsl:text>                        arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential()
 
       
  3430 </xsl:text>
 
       
  3431     <xsl:text>                        break
 
       
  3432 </xsl:text>
 
       
  3433     <xsl:text>                    case 'f':
 
       
  3434 </xsl:text>
 
       
  3435     <xsl:text>                        arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg)
 
       
  3436 </xsl:text>
 
       
  3437     <xsl:text>                        break
 
       
  3438 </xsl:text>
 
       
  3439     <xsl:text>                    case 'g':
 
       
  3440 </xsl:text>
 
       
  3441     <xsl:text>                        arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg)
 
       
  3442 </xsl:text>
 
       
  3443     <xsl:text>                        break
 
       
  3444 </xsl:text>
 
       
  3445     <xsl:text>                    case 'o':
 
       
  3446 </xsl:text>
 
       
  3447     <xsl:text>                        arg = (parseInt(arg, 10) &gt;&gt;&gt; 0).toString(8)
 
       
  3448 </xsl:text>
 
       
  3449     <xsl:text>                        break
 
       
  3450 </xsl:text>
 
       
  3451     <xsl:text>                    case 's':
 
       
  3452 </xsl:text>
 
       
  3453     <xsl:text>                        arg = String(arg)
 
       
  3454 </xsl:text>
 
       
  3455     <xsl:text>                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
 
       
  3456 </xsl:text>
 
       
  3457     <xsl:text>                        break
 
       
  3458 </xsl:text>
 
       
  3459     <xsl:text>                    case 't':
 
       
  3460 </xsl:text>
 
       
  3461     <xsl:text>                        arg = String(!!arg)
 
       
  3462 </xsl:text>
 
       
  3463     <xsl:text>                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
 
       
  3464 </xsl:text>
 
       
  3465     <xsl:text>                        break
 
       
  3466 </xsl:text>
 
       
  3467     <xsl:text>                    case 'T':
 
       
  3468 </xsl:text>
 
       
  3469     <xsl:text>                        arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase()
 
       
  3470 </xsl:text>
 
       
  3471     <xsl:text>                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
 
       
  3472 </xsl:text>
 
       
  3473     <xsl:text>                        break
 
       
  3474 </xsl:text>
 
       
  3475     <xsl:text>                    case 'u':
 
       
  3476 </xsl:text>
 
       
  3477     <xsl:text>                        arg = parseInt(arg, 10) &gt;&gt;&gt; 0
 
       
  3478 </xsl:text>
 
       
  3479     <xsl:text>                        break
 
       
  3480 </xsl:text>
 
       
  3481     <xsl:text>                    case 'v':
 
       
  3482 </xsl:text>
 
       
  3483     <xsl:text>                        arg = arg.valueOf()
 
       
  3484 </xsl:text>
 
       
  3485     <xsl:text>                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
 
       
  3486 </xsl:text>
 
       
  3487     <xsl:text>                        break
 
       
  3488 </xsl:text>
 
       
  3489     <xsl:text>                    case 'x':
 
       
  3490 </xsl:text>
 
       
  3491     <xsl:text>                        arg = (parseInt(arg, 10) &gt;&gt;&gt; 0).toString(16)
 
       
  3492 </xsl:text>
 
       
  3493     <xsl:text>                        break
 
       
  3494 </xsl:text>
 
       
  3495     <xsl:text>                    case 'X':
 
       
  3496 </xsl:text>
 
       
  3497     <xsl:text>                        arg = (parseInt(arg, 10) &gt;&gt;&gt; 0).toString(16).toUpperCase()
 
       
  3498 </xsl:text>
 
       
  3499     <xsl:text>                        break
 
       
  3500 </xsl:text>
 
       
  3501     <xsl:text>                }
 
       
  3502 </xsl:text>
 
       
  3503     <xsl:text>                if (re.json.test(ph.type)) {
 
       
  3504 </xsl:text>
 
       
  3505     <xsl:text>                    output += arg
 
       
  3506 </xsl:text>
 
       
  3507     <xsl:text>                }
 
       
  3508 </xsl:text>
 
       
  3509     <xsl:text>                else {
 
       
  3510 </xsl:text>
 
       
  3511     <xsl:text>                    if (re.number.test(ph.type) &amp;&amp; (!is_positive || ph.sign)) {
 
       
  3512 </xsl:text>
 
       
  3513     <xsl:text>                        sign = is_positive ? '+' : '-'
 
       
  3514 </xsl:text>
 
       
  3515     <xsl:text>                        arg = arg.toString().replace(re.sign, '')
 
       
  3516 </xsl:text>
 
       
  3517     <xsl:text>                    }
 
       
  3518 </xsl:text>
 
       
  3519     <xsl:text>                    else {
 
       
  3520 </xsl:text>
 
       
  3521     <xsl:text>                        sign = ''
 
       
  3522 </xsl:text>
 
       
  3523     <xsl:text>                    }
 
       
  3524 </xsl:text>
 
       
  3525     <xsl:text>                    pad_character = ph.pad_char ? ph.pad_char === '0' ? '0' : ph.pad_char.charAt(1) : ' '
 
       
  3526 </xsl:text>
 
       
  3527     <xsl:text>                    pad_length = ph.width - (sign + arg).length
 
       
  3528 </xsl:text>
 
       
  3529     <xsl:text>                    pad = ph.width ? (pad_length &gt; 0 ? pad_character.repeat(pad_length) : '') : ''
 
       
  3530 </xsl:text>
 
       
  3531     <xsl:text>                    output += ph.align ? sign + arg + pad : (pad_character === '0' ? sign + pad + arg : pad + sign + arg)
 
       
  3532 </xsl:text>
 
       
  3533     <xsl:text>                }
 
       
  3534 </xsl:text>
 
       
  3535     <xsl:text>            }
 
       
  3536 </xsl:text>
 
       
  3537     <xsl:text>        }
 
       
  3538 </xsl:text>
 
       
  3539     <xsl:text>        return output
 
       
  3540 </xsl:text>
 
       
  3541     <xsl:text>    }
 
       
  3542 </xsl:text>
 
       
  3543     <xsl:text>
 
       
  3544 </xsl:text>
 
       
  3545     <xsl:text>    var sprintf_cache = Object.create(null)
 
       
  3546 </xsl:text>
 
       
  3547     <xsl:text>
 
       
  3548 </xsl:text>
 
       
  3549     <xsl:text>    function sprintf_parse(fmt) {
 
       
  3550 </xsl:text>
 
       
  3551     <xsl:text>        if (sprintf_cache[fmt]) {
 
       
  3552 </xsl:text>
 
       
  3553     <xsl:text>            return sprintf_cache[fmt]
 
       
  3554 </xsl:text>
 
       
  3555     <xsl:text>        }
 
       
  3556 </xsl:text>
 
       
  3557     <xsl:text>
 
       
  3558 </xsl:text>
 
       
  3559     <xsl:text>        var _fmt = fmt, match, parse_tree = [], arg_names = 0
 
       
  3560 </xsl:text>
 
       
  3561     <xsl:text>        while (_fmt) {
 
       
  3562 </xsl:text>
 
       
  3563     <xsl:text>            if ((match = re.text.exec(_fmt)) !== null) {
 
       
  3564 </xsl:text>
 
       
  3565     <xsl:text>                parse_tree.push(match[0])
 
       
  3566 </xsl:text>
 
       
  3567     <xsl:text>            }
 
       
  3568 </xsl:text>
 
       
  3569     <xsl:text>            else if ((match = re.modulo.exec(_fmt)) !== null) {
 
       
  3570 </xsl:text>
 
       
  3571     <xsl:text>                parse_tree.push('%')
 
       
  3572 </xsl:text>
 
       
  3573     <xsl:text>            }
 
       
  3574 </xsl:text>
 
       
  3575     <xsl:text>            else if ((match = re.placeholder.exec(_fmt)) !== null) {
 
       
  3576 </xsl:text>
 
       
  3577     <xsl:text>                if (match[2]) {
 
       
  3578 </xsl:text>
 
       
  3579     <xsl:text>                    arg_names |= 1
 
       
  3580 </xsl:text>
 
       
  3581     <xsl:text>                    var field_list = [], replacement_field = match[2], field_match = []
 
       
  3582 </xsl:text>
 
       
  3583     <xsl:text>                    if ((field_match = re.key.exec(replacement_field)) !== null) {
 
       
  3584 </xsl:text>
 
       
  3585     <xsl:text>                        field_list.push(field_match[1])
 
       
  3586 </xsl:text>
 
       
  3587     <xsl:text>                        while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {
 
       
  3588 </xsl:text>
 
       
  3589     <xsl:text>                            if ((field_match = re.key_access.exec(replacement_field)) !== null) {
 
       
  3590 </xsl:text>
 
       
  3591     <xsl:text>                                field_list.push(field_match[1])
 
       
  3592 </xsl:text>
 
       
  3593     <xsl:text>                            }
 
       
  3594 </xsl:text>
 
       
  3595     <xsl:text>                            else if ((field_match = re.index_access.exec(replacement_field)) !== null) {
 
       
  3596 </xsl:text>
 
       
  3597     <xsl:text>                                field_list.push(field_match[1])
 
       
  3598 </xsl:text>
 
       
  3599     <xsl:text>                            }
 
       
  3600 </xsl:text>
 
       
  3601     <xsl:text>                            else {
 
       
  3602 </xsl:text>
 
       
  3603     <xsl:text>                                throw new SyntaxError('[sprintf] failed to parse named argument key')
 
       
  3604 </xsl:text>
 
       
  3605     <xsl:text>                            }
 
       
  3606 </xsl:text>
 
       
  3607     <xsl:text>                        }
 
       
  3608 </xsl:text>
 
       
  3609     <xsl:text>                    }
 
       
  3610 </xsl:text>
 
       
  3611     <xsl:text>                    else {
 
       
  3612 </xsl:text>
 
       
  3613     <xsl:text>                        throw new SyntaxError('[sprintf] failed to parse named argument key')
 
       
  3614 </xsl:text>
 
       
  3615     <xsl:text>                    }
 
       
  3616 </xsl:text>
 
       
  3617     <xsl:text>                    match[2] = field_list
 
       
  3618 </xsl:text>
 
       
  3619     <xsl:text>                }
 
       
  3620 </xsl:text>
 
       
  3621     <xsl:text>                else {
 
       
  3622 </xsl:text>
 
       
  3623     <xsl:text>                    arg_names |= 2
 
       
  3624 </xsl:text>
 
       
  3625     <xsl:text>                }
 
       
  3626 </xsl:text>
 
       
  3627     <xsl:text>                if (arg_names === 3) {
 
       
  3628 </xsl:text>
 
       
  3629     <xsl:text>                    throw new Error('[sprintf] mixing positional and named placeholders is not (yet) supported')
 
       
  3630 </xsl:text>
 
       
  3631     <xsl:text>                }
 
       
  3632 </xsl:text>
 
       
  3633     <xsl:text>
 
       
  3634 </xsl:text>
 
       
  3635     <xsl:text>                parse_tree.push(
 
       
  3636 </xsl:text>
 
       
  3637     <xsl:text>                    {
 
       
  3638 </xsl:text>
 
       
  3639     <xsl:text>                        placeholder: match[0],
 
       
  3640 </xsl:text>
 
       
  3641     <xsl:text>                        param_no:    match[1],
 
       
  3642 </xsl:text>
 
       
  3643     <xsl:text>                        keys:        match[2],
 
       
  3644 </xsl:text>
 
       
  3645     <xsl:text>                        sign:        match[3],
 
       
  3646 </xsl:text>
 
       
  3647     <xsl:text>                        pad_char:    match[4],
 
       
  3648 </xsl:text>
 
       
  3649     <xsl:text>                        align:       match[5],
 
       
  3650 </xsl:text>
 
       
  3651     <xsl:text>                        width:       match[6],
 
       
  3652 </xsl:text>
 
       
  3653     <xsl:text>                        precision:   match[7],
 
       
  3654 </xsl:text>
 
       
  3655     <xsl:text>                        type:        match[8]
 
       
  3656 </xsl:text>
 
       
  3657     <xsl:text>                    }
 
       
  3658 </xsl:text>
 
       
  3659     <xsl:text>                )
 
       
  3660 </xsl:text>
 
       
  3661     <xsl:text>            }
 
       
  3662 </xsl:text>
 
       
  3663     <xsl:text>            else {
 
       
  3664 </xsl:text>
 
       
  3665     <xsl:text>                throw new SyntaxError('[sprintf] unexpected placeholder')
 
       
  3666 </xsl:text>
 
       
  3667     <xsl:text>            }
 
       
  3668 </xsl:text>
 
       
  3669     <xsl:text>            _fmt = _fmt.substring(match[0].length)
 
       
  3670 </xsl:text>
 
       
  3671     <xsl:text>        }
 
       
  3672 </xsl:text>
 
       
  3673     <xsl:text>        return sprintf_cache[fmt] = parse_tree
 
       
  3674 </xsl:text>
 
       
  3675     <xsl:text>    }
 
       
  3676 </xsl:text>
 
       
  3677     <xsl:text>
 
       
  3678 </xsl:text>
 
       
  3679     <xsl:text>    /**
 
       
  3680 </xsl:text>
 
       
  3681     <xsl:text>     * export to either browser or node.js
 
       
  3682 </xsl:text>
 
       
  3683     <xsl:text>     */
 
       
  3684 </xsl:text>
 
       
  3685     <xsl:text>    /* eslint-disable quote-props */
 
       
  3686 </xsl:text>
 
       
  3687     <xsl:text>    if (typeof exports !== 'undefined') {
 
       
  3688 </xsl:text>
 
       
  3689     <xsl:text>        exports['sprintf'] = sprintf
 
       
  3690 </xsl:text>
 
       
  3691     <xsl:text>        exports['vsprintf'] = vsprintf
 
       
  3692 </xsl:text>
 
       
  3693     <xsl:text>    }
 
       
  3694 </xsl:text>
 
       
  3695     <xsl:text>    if (typeof window !== 'undefined') {
 
       
  3696 </xsl:text>
 
       
  3697     <xsl:text>        window['sprintf'] = sprintf
 
       
  3698 </xsl:text>
 
       
  3699     <xsl:text>        window['vsprintf'] = vsprintf
 
       
  3700 </xsl:text>
 
       
  3701     <xsl:text>
 
       
  3702 </xsl:text>
 
       
  3703     <xsl:text>        if (typeof define === 'function' &amp;&amp; define['amd']) {
 
       
  3704 </xsl:text>
 
       
  3705     <xsl:text>            define(function() {
 
       
  3706 </xsl:text>
 
       
  3707     <xsl:text>                return {
 
       
  3708 </xsl:text>
 
       
  3709     <xsl:text>                    'sprintf': sprintf,
 
       
  3710 </xsl:text>
 
       
  3711     <xsl:text>                    'vsprintf': vsprintf
 
       
  3712 </xsl:text>
 
       
  3713     <xsl:text>                }
 
       
  3714 </xsl:text>
 
       
  3715     <xsl:text>            })
 
       
  3716 </xsl:text>
 
       
  3717     <xsl:text>        }
 
       
  3718 </xsl:text>
 
       
  3719     <xsl:text>    }
 
       
  3720 </xsl:text>
 
       
  3721     <xsl:text>    /* eslint-enable quote-props */
 
       
  3722 </xsl:text>
 
       
  3723     <xsl:text>}(); // eslint-disable-line    
       
  3724 </xsl:text>
 
       
  3725     <xsl:text>
 
       
  3726 </xsl:text>
 
       
  3727   </xsl:template>
 
  3258   </xsl:template>
 
  3728   <xsl:template match="widget[@type='DropDown']" mode="widget_desc">
 
  3259   <xsl:template match="widget[@type='DropDown']" mode="widget_desc">
 
  3729     <type>
 
  3260     <type>
 
  3730       <xsl:value-of select="@type"/>
 
  3261       <xsl:value-of select="@type"/>
 
  3731     </type>
 
  3262     </type>
 
  6144 </xsl:text>
 
  5675 </xsl:text>
 
  6145       <xsl:text>as respective minimum and maximum value. Otherwise, value is expected to be
 
  5676       <xsl:text>as respective minimum and maximum value. Otherwise, value is expected to be
 
  6146 </xsl:text>
 
  5677 </xsl:text>
 
  6147       <xsl:text>in between 0 and 100.
 
  5678       <xsl:text>in between 0 and 100.
 
  6148 </xsl:text>
 
  5679 </xsl:text>
 
  6149       <xsl:text>
 
       
  6150 </xsl:text>
 
       
  6151       <xsl:text>If "value" labeled text is found, then its content is replaced by value.
 
       
  6152 </xsl:text>
 
       
  6153     </longdesc>
 
  5680     </longdesc>
 
  6154     <shortdesc>
 
  5681     <shortdesc>
 
  6155       <xsl:text>Moves "needle" along "range"</xsl:text>
 
  5682       <xsl:text>Moves "needle" along "range"</xsl:text>
 
  6156     </shortdesc>
 
  5683     </shortdesc>
 
  6157     <arg name="min" count="optional" accepts="int,real">
 
  5684     <arg name="min" count="optional" accepts="int,real">
 
  6233       </xsl:with-param>
 
  5760       </xsl:with-param>
 
  6234     </xsl:call-template>
 
  5761     </xsl:call-template>
 
  6235     <xsl:call-template name="defs_by_labels">
 
  5762     <xsl:call-template name="defs_by_labels">
 
  6236       <xsl:with-param name="hmi_element" select="$hmi_element"/>
 
  5763       <xsl:with-param name="hmi_element" select="$hmi_element"/>
 
  6237       <xsl:with-param name="labels">
 
  5764       <xsl:with-param name="labels">
 
  6238         <xsl:text>value min max</xsl:text>
 
  5765         <xsl:text>min max</xsl:text>
 
  6239       </xsl:with-param>
 
  5766       </xsl:with-param>
 
  6240       <xsl:with-param name="mandatory" select="'no'"/>
 
  5767       <xsl:with-param name="mandatory" select="'no'"/>
 
  6241     </xsl:call-template>
 
  5768     </xsl:call-template>
 
  6242   </xsl:template>
 
  5769   </xsl:template>
 
  6243   <xsl:template match="widget[@type='MultiState']" mode="widget_defs">
 
  5770   <xsl:template match="widget[@type='MultiState']" mode="widget_defs">
 
  7988 // Statements that needs to be at the end 
  7515 // Statements that needs to be at the end 
  7989 //
 
  7516 //
 
  7990 //
 
  7517 //
 
  7991 </xsl:text>
 
  7518 </xsl:text>
 
  7992           <xsl:apply-templates select="document('')/*/epilogue:*"/>
 
  7519           <xsl:apply-templates select="document('')/*/epilogue:*"/>
 
       
  7520           <xsl:text>/* https://github.com/alexei/sprintf.js/blob/master/src/sprintf.js */
 
       
  7521 </xsl:text>
 
       
  7522           <xsl:text>/* global window, exports, define */
 
       
  7523 </xsl:text>
 
       
  7524           <xsl:text>
 
       
  7525 </xsl:text>
 
       
  7526           <xsl:text>!function() {
 
       
  7527 </xsl:text>
 
       
  7528           <xsl:text>    'use strict'
 
       
  7529 </xsl:text>
 
       
  7530           <xsl:text>
 
       
  7531 </xsl:text>
 
       
  7532           <xsl:text>    var re = {
 
       
  7533 </xsl:text>
 
       
  7534           <xsl:text>        not_string: /[^s]/,
 
       
  7535 </xsl:text>
 
       
  7536           <xsl:text>        not_bool: /[^t]/,
 
       
  7537 </xsl:text>
 
       
  7538           <xsl:text>        not_type: /[^T]/,
 
       
  7539 </xsl:text>
 
       
  7540           <xsl:text>        not_primitive: /[^v]/,
 
       
  7541 </xsl:text>
 
       
  7542           <xsl:text>        number: /[diefg]/,
 
       
  7543 </xsl:text>
 
       
  7544           <xsl:text>        numeric_arg: /[bcdiefguxX]/,
 
       
  7545 </xsl:text>
 
       
  7546           <xsl:text>        json: /[j]/,
 
       
  7547 </xsl:text>
 
       
  7548           <xsl:text>        not_json: /[^j]/,
 
       
  7549 </xsl:text>
 
       
  7550           <xsl:text>        text: /^[^%]+/,
 
       
  7551 </xsl:text>
 
       
  7552           <xsl:text>        modulo: /^%{2}/,
 
       
  7553 </xsl:text>
 
       
  7554           <xsl:text>        placeholder: /^%(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/,
 
       
  7555 </xsl:text>
 
       
  7556           <xsl:text>        key: /^([a-z_][a-z_\d]*)/i,
 
       
  7557 </xsl:text>
 
       
  7558           <xsl:text>        key_access: /^\.([a-z_][a-z_\d]*)/i,
 
       
  7559 </xsl:text>
 
       
  7560           <xsl:text>        index_access: /^\[(\d+)\]/,
 
       
  7561 </xsl:text>
 
       
  7562           <xsl:text>        sign: /^[+-]/
 
       
  7563 </xsl:text>
 
       
  7564           <xsl:text>    }
 
       
  7565 </xsl:text>
 
       
  7566           <xsl:text>
 
       
  7567 </xsl:text>
 
       
  7568           <xsl:text>    function sprintf(key) {
 
       
  7569 </xsl:text>
 
       
  7570           <xsl:text>        // arguments is not an array, but should be fine for this call
 
       
  7571 </xsl:text>
 
       
  7572           <xsl:text>        return sprintf_format(sprintf_parse(key), arguments)
 
       
  7573 </xsl:text>
 
       
  7574           <xsl:text>    }
 
       
  7575 </xsl:text>
 
       
  7576           <xsl:text>
 
       
  7577 </xsl:text>
 
       
  7578           <xsl:text>    function vsprintf(fmt, argv) {
 
       
  7579 </xsl:text>
 
       
  7580           <xsl:text>        return sprintf.apply(null, [fmt].concat(argv || []))
 
       
  7581 </xsl:text>
 
       
  7582           <xsl:text>    }
 
       
  7583 </xsl:text>
 
       
  7584           <xsl:text>
 
       
  7585 </xsl:text>
 
       
  7586           <xsl:text>    function sprintf_format(parse_tree, argv) {
 
       
  7587 </xsl:text>
 
       
  7588           <xsl:text>        var cursor = 1, tree_length = parse_tree.length, arg, output = '', i, k, ph, pad, pad_character, pad_length, is_positive, sign
 
       
  7589 </xsl:text>
 
       
  7590           <xsl:text>        for (i = 0; i &lt; tree_length; i++) {
 
       
  7591 </xsl:text>
 
       
  7592           <xsl:text>            if (typeof parse_tree[i] === 'string') {
 
       
  7593 </xsl:text>
 
       
  7594           <xsl:text>                output += parse_tree[i]
 
       
  7595 </xsl:text>
 
       
  7596           <xsl:text>            }
 
       
  7597 </xsl:text>
 
       
  7598           <xsl:text>            else if (typeof parse_tree[i] === 'object') {
 
       
  7599 </xsl:text>
 
       
  7600           <xsl:text>                ph = parse_tree[i] // convenience purposes only
 
       
  7601 </xsl:text>
 
       
  7602           <xsl:text>                if (ph.keys) { // keyword argument
 
       
  7603 </xsl:text>
 
       
  7604           <xsl:text>                    arg = argv[cursor]
 
       
  7605 </xsl:text>
 
       
  7606           <xsl:text>                    for (k = 0; k &lt; ph.keys.length; k++) {
 
       
  7607 </xsl:text>
 
       
  7608           <xsl:text>                        if (arg == undefined) {
 
       
  7609 </xsl:text>
 
       
  7610           <xsl:text>                            throw new Error(sprintf('[sprintf] Cannot access property "%s" of undefined value "%s"', ph.keys[k], ph.keys[k-1]))
 
       
  7611 </xsl:text>
 
       
  7612           <xsl:text>                        }
 
       
  7613 </xsl:text>
 
       
  7614           <xsl:text>                        arg = arg[ph.keys[k]]
 
       
  7615 </xsl:text>
 
       
  7616           <xsl:text>                    }
 
       
  7617 </xsl:text>
 
       
  7618           <xsl:text>                }
 
       
  7619 </xsl:text>
 
       
  7620           <xsl:text>                else if (ph.param_no) { // positional argument (explicit)
 
       
  7621 </xsl:text>
 
       
  7622           <xsl:text>                    arg = argv[ph.param_no]
 
       
  7623 </xsl:text>
 
       
  7624           <xsl:text>                }
 
       
  7625 </xsl:text>
 
       
  7626           <xsl:text>                else { // positional argument (implicit)
 
       
  7627 </xsl:text>
 
       
  7628           <xsl:text>                    arg = argv[cursor++]
 
       
  7629 </xsl:text>
 
       
  7630           <xsl:text>                }
 
       
  7631 </xsl:text>
 
       
  7632           <xsl:text>
 
       
  7633 </xsl:text>
 
       
  7634           <xsl:text>                if (re.not_type.test(ph.type) &amp;&amp; re.not_primitive.test(ph.type) &amp;&amp; arg instanceof Function) {
 
       
  7635 </xsl:text>
 
       
  7636           <xsl:text>                    arg = arg()
 
       
  7637 </xsl:text>
 
       
  7638           <xsl:text>                }
 
       
  7639 </xsl:text>
 
       
  7640           <xsl:text>
 
       
  7641 </xsl:text>
 
       
  7642           <xsl:text>                if (re.numeric_arg.test(ph.type) &amp;&amp; (typeof arg !== 'number' &amp;&amp; isNaN(arg))) {
 
       
  7643 </xsl:text>
 
       
  7644           <xsl:text>                    throw new TypeError(sprintf('[sprintf] expecting number but found %T', arg))
 
       
  7645 </xsl:text>
 
       
  7646           <xsl:text>                }
 
       
  7647 </xsl:text>
 
       
  7648           <xsl:text>
 
       
  7649 </xsl:text>
 
       
  7650           <xsl:text>                if (re.number.test(ph.type)) {
 
       
  7651 </xsl:text>
 
       
  7652           <xsl:text>                    is_positive = arg &gt;= 0
 
       
  7653 </xsl:text>
 
       
  7654           <xsl:text>                }
 
       
  7655 </xsl:text>
 
       
  7656           <xsl:text>
 
       
  7657 </xsl:text>
 
       
  7658           <xsl:text>                switch (ph.type) {
 
       
  7659 </xsl:text>
 
       
  7660           <xsl:text>                    case 'b':
 
       
  7661 </xsl:text>
 
       
  7662           <xsl:text>                        arg = parseInt(arg, 10).toString(2)
 
       
  7663 </xsl:text>
 
       
  7664           <xsl:text>                        break
 
       
  7665 </xsl:text>
 
       
  7666           <xsl:text>                    case 'c':
 
       
  7667 </xsl:text>
 
       
  7668           <xsl:text>                        arg = String.fromCharCode(parseInt(arg, 10))
 
       
  7669 </xsl:text>
 
       
  7670           <xsl:text>                        break
 
       
  7671 </xsl:text>
 
       
  7672           <xsl:text>                    case 'd':
 
       
  7673 </xsl:text>
 
       
  7674           <xsl:text>                    case 'i':
 
       
  7675 </xsl:text>
 
       
  7676           <xsl:text>                        arg = parseInt(arg, 10)
 
       
  7677 </xsl:text>
 
       
  7678           <xsl:text>                        break
 
       
  7679 </xsl:text>
 
       
  7680           <xsl:text>                    case 'j':
 
       
  7681 </xsl:text>
 
       
  7682           <xsl:text>                        arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0)
 
       
  7683 </xsl:text>
 
       
  7684           <xsl:text>                        break
 
       
  7685 </xsl:text>
 
       
  7686           <xsl:text>                    case 'e':
 
       
  7687 </xsl:text>
 
       
  7688           <xsl:text>                        arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential()
 
       
  7689 </xsl:text>
 
       
  7690           <xsl:text>                        break
 
       
  7691 </xsl:text>
 
       
  7692           <xsl:text>                    case 'f':
 
       
  7693 </xsl:text>
 
       
  7694           <xsl:text>                        arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg)
 
       
  7695 </xsl:text>
 
       
  7696           <xsl:text>                        break
 
       
  7697 </xsl:text>
 
       
  7698           <xsl:text>                    case 'g':
 
       
  7699 </xsl:text>
 
       
  7700           <xsl:text>                        arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg)
 
       
  7701 </xsl:text>
 
       
  7702           <xsl:text>                        break
 
       
  7703 </xsl:text>
 
       
  7704           <xsl:text>                    case 'o':
 
       
  7705 </xsl:text>
 
       
  7706           <xsl:text>                        arg = (parseInt(arg, 10) &gt;&gt;&gt; 0).toString(8)
 
       
  7707 </xsl:text>
 
       
  7708           <xsl:text>                        break
 
       
  7709 </xsl:text>
 
       
  7710           <xsl:text>                    case 's':
 
       
  7711 </xsl:text>
 
       
  7712           <xsl:text>                        arg = String(arg)
 
       
  7713 </xsl:text>
 
       
  7714           <xsl:text>                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
 
       
  7715 </xsl:text>
 
       
  7716           <xsl:text>                        break
 
       
  7717 </xsl:text>
 
       
  7718           <xsl:text>                    case 't':
 
       
  7719 </xsl:text>
 
       
  7720           <xsl:text>                        arg = String(!!arg)
 
       
  7721 </xsl:text>
 
       
  7722           <xsl:text>                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
 
       
  7723 </xsl:text>
 
       
  7724           <xsl:text>                        break
 
       
  7725 </xsl:text>
 
       
  7726           <xsl:text>                    case 'T':
 
       
  7727 </xsl:text>
 
       
  7728           <xsl:text>                        arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase()
 
       
  7729 </xsl:text>
 
       
  7730           <xsl:text>                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
 
       
  7731 </xsl:text>
 
       
  7732           <xsl:text>                        break
 
       
  7733 </xsl:text>
 
       
  7734           <xsl:text>                    case 'u':
 
       
  7735 </xsl:text>
 
       
  7736           <xsl:text>                        arg = parseInt(arg, 10) &gt;&gt;&gt; 0
 
       
  7737 </xsl:text>
 
       
  7738           <xsl:text>                        break
 
       
  7739 </xsl:text>
 
       
  7740           <xsl:text>                    case 'v':
 
       
  7741 </xsl:text>
 
       
  7742           <xsl:text>                        arg = arg.valueOf()
 
       
  7743 </xsl:text>
 
       
  7744           <xsl:text>                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
 
       
  7745 </xsl:text>
 
       
  7746           <xsl:text>                        break
 
       
  7747 </xsl:text>
 
       
  7748           <xsl:text>                    case 'x':
 
       
  7749 </xsl:text>
 
       
  7750           <xsl:text>                        arg = (parseInt(arg, 10) &gt;&gt;&gt; 0).toString(16)
 
       
  7751 </xsl:text>
 
       
  7752           <xsl:text>                        break
 
       
  7753 </xsl:text>
 
       
  7754           <xsl:text>                    case 'X':
 
       
  7755 </xsl:text>
 
       
  7756           <xsl:text>                        arg = (parseInt(arg, 10) &gt;&gt;&gt; 0).toString(16).toUpperCase()
 
       
  7757 </xsl:text>
 
       
  7758           <xsl:text>                        break
 
       
  7759 </xsl:text>
 
       
  7760           <xsl:text>                }
 
       
  7761 </xsl:text>
 
       
  7762           <xsl:text>                if (re.json.test(ph.type)) {
 
       
  7763 </xsl:text>
 
       
  7764           <xsl:text>                    output += arg
 
       
  7765 </xsl:text>
 
       
  7766           <xsl:text>                }
 
       
  7767 </xsl:text>
 
       
  7768           <xsl:text>                else {
 
       
  7769 </xsl:text>
 
       
  7770           <xsl:text>                    if (re.number.test(ph.type) &amp;&amp; (!is_positive || ph.sign)) {
 
       
  7771 </xsl:text>
 
       
  7772           <xsl:text>                        sign = is_positive ? '+' : '-'
 
       
  7773 </xsl:text>
 
       
  7774           <xsl:text>                        arg = arg.toString().replace(re.sign, '')
 
       
  7775 </xsl:text>
 
       
  7776           <xsl:text>                    }
 
       
  7777 </xsl:text>
 
       
  7778           <xsl:text>                    else {
 
       
  7779 </xsl:text>
 
       
  7780           <xsl:text>                        sign = ''
 
       
  7781 </xsl:text>
 
       
  7782           <xsl:text>                    }
 
       
  7783 </xsl:text>
 
       
  7784           <xsl:text>                    pad_character = ph.pad_char ? ph.pad_char === '0' ? '0' : ph.pad_char.charAt(1) : ' '
 
       
  7785 </xsl:text>
 
       
  7786           <xsl:text>                    pad_length = ph.width - (sign + arg).length
 
       
  7787 </xsl:text>
 
       
  7788           <xsl:text>                    pad = ph.width ? (pad_length &gt; 0 ? pad_character.repeat(pad_length) : '') : ''
 
       
  7789 </xsl:text>
 
       
  7790           <xsl:text>                    output += ph.align ? sign + arg + pad : (pad_character === '0' ? sign + pad + arg : pad + sign + arg)
 
       
  7791 </xsl:text>
 
       
  7792           <xsl:text>                }
 
       
  7793 </xsl:text>
 
       
  7794           <xsl:text>            }
 
       
  7795 </xsl:text>
 
       
  7796           <xsl:text>        }
 
       
  7797 </xsl:text>
 
       
  7798           <xsl:text>        return output
 
       
  7799 </xsl:text>
 
       
  7800           <xsl:text>    }
 
       
  7801 </xsl:text>
 
       
  7802           <xsl:text>
 
       
  7803 </xsl:text>
 
       
  7804           <xsl:text>    var sprintf_cache = Object.create(null)
 
       
  7805 </xsl:text>
 
       
  7806           <xsl:text>
 
       
  7807 </xsl:text>
 
       
  7808           <xsl:text>    function sprintf_parse(fmt) {
 
       
  7809 </xsl:text>
 
       
  7810           <xsl:text>        if (sprintf_cache[fmt]) {
 
       
  7811 </xsl:text>
 
       
  7812           <xsl:text>            return sprintf_cache[fmt]
 
       
  7813 </xsl:text>
 
       
  7814           <xsl:text>        }
 
       
  7815 </xsl:text>
 
       
  7816           <xsl:text>
 
       
  7817 </xsl:text>
 
       
  7818           <xsl:text>        var _fmt = fmt, match, parse_tree = [], arg_names = 0
 
       
  7819 </xsl:text>
 
       
  7820           <xsl:text>        while (_fmt) {
 
       
  7821 </xsl:text>
 
       
  7822           <xsl:text>            if ((match = re.text.exec(_fmt)) !== null) {
 
       
  7823 </xsl:text>
 
       
  7824           <xsl:text>                parse_tree.push(match[0])
 
       
  7825 </xsl:text>
 
       
  7826           <xsl:text>            }
 
       
  7827 </xsl:text>
 
       
  7828           <xsl:text>            else if ((match = re.modulo.exec(_fmt)) !== null) {
 
       
  7829 </xsl:text>
 
       
  7830           <xsl:text>                parse_tree.push('%')
 
       
  7831 </xsl:text>
 
       
  7832           <xsl:text>            }
 
       
  7833 </xsl:text>
 
       
  7834           <xsl:text>            else if ((match = re.placeholder.exec(_fmt)) !== null) {
 
       
  7835 </xsl:text>
 
       
  7836           <xsl:text>                if (match[2]) {
 
       
  7837 </xsl:text>
 
       
  7838           <xsl:text>                    arg_names |= 1
 
       
  7839 </xsl:text>
 
       
  7840           <xsl:text>                    var field_list = [], replacement_field = match[2], field_match = []
 
       
  7841 </xsl:text>
 
       
  7842           <xsl:text>                    if ((field_match = re.key.exec(replacement_field)) !== null) {
 
       
  7843 </xsl:text>
 
       
  7844           <xsl:text>                        field_list.push(field_match[1])
 
       
  7845 </xsl:text>
 
       
  7846           <xsl:text>                        while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {
 
       
  7847 </xsl:text>
 
       
  7848           <xsl:text>                            if ((field_match = re.key_access.exec(replacement_field)) !== null) {
 
       
  7849 </xsl:text>
 
       
  7850           <xsl:text>                                field_list.push(field_match[1])
 
       
  7851 </xsl:text>
 
       
  7852           <xsl:text>                            }
 
       
  7853 </xsl:text>
 
       
  7854           <xsl:text>                            else if ((field_match = re.index_access.exec(replacement_field)) !== null) {
 
       
  7855 </xsl:text>
 
       
  7856           <xsl:text>                                field_list.push(field_match[1])
 
       
  7857 </xsl:text>
 
       
  7858           <xsl:text>                            }
 
       
  7859 </xsl:text>
 
       
  7860           <xsl:text>                            else {
 
       
  7861 </xsl:text>
 
       
  7862           <xsl:text>                                throw new SyntaxError('[sprintf] failed to parse named argument key')
 
       
  7863 </xsl:text>
 
       
  7864           <xsl:text>                            }
 
       
  7865 </xsl:text>
 
       
  7866           <xsl:text>                        }
 
       
  7867 </xsl:text>
 
       
  7868           <xsl:text>                    }
 
       
  7869 </xsl:text>
 
       
  7870           <xsl:text>                    else {
 
       
  7871 </xsl:text>
 
       
  7872           <xsl:text>                        throw new SyntaxError('[sprintf] failed to parse named argument key')
 
       
  7873 </xsl:text>
 
       
  7874           <xsl:text>                    }
 
       
  7875 </xsl:text>
 
       
  7876           <xsl:text>                    match[2] = field_list
 
       
  7877 </xsl:text>
 
       
  7878           <xsl:text>                }
 
       
  7879 </xsl:text>
 
       
  7880           <xsl:text>                else {
 
       
  7881 </xsl:text>
 
       
  7882           <xsl:text>                    arg_names |= 2
 
       
  7883 </xsl:text>
 
       
  7884           <xsl:text>                }
 
       
  7885 </xsl:text>
 
       
  7886           <xsl:text>                if (arg_names === 3) {
 
       
  7887 </xsl:text>
 
       
  7888           <xsl:text>                    throw new Error('[sprintf] mixing positional and named placeholders is not (yet) supported')
 
       
  7889 </xsl:text>
 
       
  7890           <xsl:text>                }
 
       
  7891 </xsl:text>
 
       
  7892           <xsl:text>
 
       
  7893 </xsl:text>
 
       
  7894           <xsl:text>                parse_tree.push(
 
       
  7895 </xsl:text>
 
       
  7896           <xsl:text>                    {
 
       
  7897 </xsl:text>
 
       
  7898           <xsl:text>                        placeholder: match[0],
 
       
  7899 </xsl:text>
 
       
  7900           <xsl:text>                        param_no:    match[1],
 
       
  7901 </xsl:text>
 
       
  7902           <xsl:text>                        keys:        match[2],
 
       
  7903 </xsl:text>
 
       
  7904           <xsl:text>                        sign:        match[3],
 
       
  7905 </xsl:text>
 
       
  7906           <xsl:text>                        pad_char:    match[4],
 
       
  7907 </xsl:text>
 
       
  7908           <xsl:text>                        align:       match[5],
 
       
  7909 </xsl:text>
 
       
  7910           <xsl:text>                        width:       match[6],
 
       
  7911 </xsl:text>
 
       
  7912           <xsl:text>                        precision:   match[7],
 
       
  7913 </xsl:text>
 
       
  7914           <xsl:text>                        type:        match[8]
 
       
  7915 </xsl:text>
 
       
  7916           <xsl:text>                    }
 
       
  7917 </xsl:text>
 
       
  7918           <xsl:text>                )
 
       
  7919 </xsl:text>
 
       
  7920           <xsl:text>            }
 
       
  7921 </xsl:text>
 
       
  7922           <xsl:text>            else {
 
       
  7923 </xsl:text>
 
       
  7924           <xsl:text>                throw new SyntaxError('[sprintf] unexpected placeholder')
 
       
  7925 </xsl:text>
 
       
  7926           <xsl:text>            }
 
       
  7927 </xsl:text>
 
       
  7928           <xsl:text>            _fmt = _fmt.substring(match[0].length)
 
       
  7929 </xsl:text>
 
       
  7930           <xsl:text>        }
 
       
  7931 </xsl:text>
 
       
  7932           <xsl:text>        return sprintf_cache[fmt] = parse_tree
 
       
  7933 </xsl:text>
 
       
  7934           <xsl:text>    }
 
       
  7935 </xsl:text>
 
       
  7936           <xsl:text>
 
       
  7937 </xsl:text>
 
       
  7938           <xsl:text>    /**
 
       
  7939 </xsl:text>
 
       
  7940           <xsl:text>     * export to either browser or node.js
 
       
  7941 </xsl:text>
 
       
  7942           <xsl:text>     */
 
       
  7943 </xsl:text>
 
       
  7944           <xsl:text>    /* eslint-disable quote-props */
 
       
  7945 </xsl:text>
 
       
  7946           <xsl:text>    if (typeof exports !== 'undefined') {
 
       
  7947 </xsl:text>
 
       
  7948           <xsl:text>        exports['sprintf'] = sprintf
 
       
  7949 </xsl:text>
 
       
  7950           <xsl:text>        exports['vsprintf'] = vsprintf
 
       
  7951 </xsl:text>
 
       
  7952           <xsl:text>    }
 
       
  7953 </xsl:text>
 
       
  7954           <xsl:text>    if (typeof window !== 'undefined') {
 
       
  7955 </xsl:text>
 
       
  7956           <xsl:text>        window['sprintf'] = sprintf
 
       
  7957 </xsl:text>
 
       
  7958           <xsl:text>        window['vsprintf'] = vsprintf
 
       
  7959 </xsl:text>
 
       
  7960           <xsl:text>
 
       
  7961 </xsl:text>
 
       
  7962           <xsl:text>        if (typeof define === 'function' &amp;&amp; define['amd']) {
 
       
  7963 </xsl:text>
 
       
  7964           <xsl:text>            define(function() {
 
       
  7965 </xsl:text>
 
       
  7966           <xsl:text>                return {
 
       
  7967 </xsl:text>
 
       
  7968           <xsl:text>                    'sprintf': sprintf,
 
       
  7969 </xsl:text>
 
       
  7970           <xsl:text>                    'vsprintf': vsprintf
 
       
  7971 </xsl:text>
 
       
  7972           <xsl:text>                }
 
       
  7973 </xsl:text>
 
       
  7974           <xsl:text>            })
 
       
  7975 </xsl:text>
 
       
  7976           <xsl:text>        }
 
       
  7977 </xsl:text>
 
       
  7978           <xsl:text>    }
 
       
  7979 </xsl:text>
 
       
  7980           <xsl:text>    /* eslint-enable quote-props */
 
       
  7981 </xsl:text>
 
       
  7982           <xsl:text>}(); // eslint-disable-line    
       
  7983 </xsl:text>
 
  7993           <xsl:text>// svghmi.js
 
  7984           <xsl:text>// svghmi.js
 
  7994 </xsl:text>
 
  7985 </xsl:text>
 
  7995           <xsl:text>
 
  7986           <xsl:text>
 
  7996 </xsl:text>
 
  7987 </xsl:text>
 
  7997           <xsl:text>var need_cache_apply = [];
 
  7988           <xsl:text>var need_cache_apply = [];
beremiz