x4js 1.4.52 → 1.4.53

package/lib/esm/calendar.js

@@ -0,0 +1,244 @@
+/**
+*  ___  ___ __
+*  \  \/  /  / _
+*   \    /  /_| |_
+*   /    \____   _|
+*  /__/\__\   |_|
+*
+* @file calendar.ts
+* @author Etienne Cochard
+*
+* Copyright (c) 2019-2022 R-libre ingenierie
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+* of the Software, and to permit persons to whom the Software is furnished to do so,
+* subject to the following conditions:
+* The above copyright notice and this permission notice shall be included in all copies
+* or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**/
+import { x4document } from './x4dom';
+import { Button } from './button';
+import { Popup } from './popup';
+import { Component, Flex } from './component';
+import { EvChange } from './x4events';
+import { _tr } from './i18n';
+import { Label } from './label';
+import { HLayout, VLayout } from './layout';
+import { date_hash, date_clone, formatIntlDate } from './tools';
+import { Menu, MenuItem } from './menu';
+/**
+ * default calendar control
+ *
+ * fires:
+ * 	EventChange ( value = Date )
+ */
+export class Calendar extends VLayout {
+    m_date;
+    constructor(props) {
+        super(props);
+        this.mapPropEvents(props, 'change');
+        this.m_date = props.date?.clone() ?? new Date();
+    }
+    /** @ignore */
+    render(props) {
+        let month_start = date_clone(this.m_date);
+        month_start.setDate(1);
+        let day = month_start.getDay();
+        if (day == 0) {
+            day = 7;
+        }
+        month_start.setDate(-day + 1 + 1);
+        let dte = date_clone(month_start);
+        let today = this.m_date.hash();
+        let month_end = date_clone(this.m_date);
+        month_end.setDate(1);
+        month_end.setMonth(month_end.getMonth() + 1);
+        month_end.setDate(0);
+        let end_of_month = date_hash(month_end);
+        let rows = [];
+        // month selector
+        let header = new HLayout({
+            cls: 'month-sel',
+            content: [
+                new Label({
+                    cls: 'month',
+                    text: formatIntlDate(this.m_date, 'O'),
+                    dom_events: {
+                        click: () => this._choose('month')
+                    }
+                }),
+                new Label({
+                    cls: 'year',
+                    text: formatIntlDate(this.m_date, 'Y'),
+                    dom_events: {
+                        click: () => this._choose('year')
+                    }
+                }),
+                new Flex(),
+                new Button({ text: '<', click: () => this._next(false) }),
+                new Button({ text: '>', click: () => this._next(true) })
+            ]
+        });
+        rows.push(header);
+        // calendar part
+        let day_names = [];
+        // day names
+        // empty week num
+        day_names.push(new HLayout({
+            cls: 'weeknum cell',
+        }));
+        for (let d = 0; d < 7; d++) {
+            day_names.push(new Label({
+                cls: 'cell',
+                flex: 1,
+                text: _tr.global.day_short[(d + 1) % 7]
+            }));
+        }
+        rows.push(new HLayout({
+            cls: 'week header',
+            content: day_names
+        }));
+        let cmonth = this.m_date.getMonth();
+        // weeks
+        let first = true;
+        while (date_hash(dte) <= end_of_month) {
+            let days = [
+                new HLayout({ cls: 'weeknum cell', content: new Component({ tag: 'span', content: formatIntlDate(dte, 'w') }) })
+            ];
+            // days
+            for (let d = 0; d < 7; d++) {
+                let cls = 'cell day';
+                if (dte.hash() == today) {
+                    cls += ' today';
+                }
+                if (dte.getMonth() != cmonth) {
+                    cls += ' out';
+                }
+                const mkItem = (dte) => {
+                    return new HLayout({
+                        cls,
+                        flex: 1,
+                        content: new Component({
+                            tag: 'span',
+                            content: formatIntlDate(dte, 'd'),
+                        }),
+                        dom_events: {
+                            click: () => this.select(dte)
+                        }
+                    });
+                };
+                days.push(mkItem(dte.clone()));
+                dte.setDate(dte.getDate() + 1);
+                first = false;
+            }
+            rows.push(new HLayout({
+                cls: 'week',
+                flex: 1,
+                content: days
+            }));
+        }
+        this.setContent(rows);
+    }
+    /**
+     * select the given date
+     * @param date
+     */
+    select(date) {
+        this.m_date = date;
+        this.emit('change', EvChange(date));
+        this.update();
+    }
+    /**
+     *
+     */
+    _next(n) {
+        this.m_date.setMonth(this.m_date.getMonth() + (n ? 1 : -1));
+        this.update();
+    }
+    /**
+     *
+     */
+    _choose(type) {
+        let items = [];
+        if (type == 'month') {
+            for (let m = 0; m < 12; m++) {
+                items.push(new MenuItem({
+                    text: _tr.global.month_long[m],
+                    click: () => { this.m_date.setMonth(m); this.update(); }
+                }));
+            }
+        }
+        else if (type == 'year') {
+            let min = this.m_props.minDate?.getFullYear() ?? 1900;
+            let max = this.m_props.maxDate?.getFullYear() ?? 2037;
+            for (let m = min; m < max; m++) {
+                items.push(new MenuItem({
+                    text: '' + m,
+                    click: () => { this.m_date.setFullYear(m); this.update(); }
+                }));
+            }
+        }
+        let menu = new Menu({
+            items
+        });
+        let rc = this.getBoundingRect();
+        menu.displayAt(rc.left, rc.top);
+    }
+    get date() {
+        return this.m_date;
+    }
+    set date(date) {
+        this.m_date = date;
+        this.update();
+    }
+}
+/**
+ * default popup calendar
+ */
+export class PopupCalendar extends Popup {
+    m_cal;
+    constructor(props) {
+        super({ tabIndex: 1 });
+        this.enableMask(false);
+        this.m_cal = new Calendar(props);
+        this.m_cal.addClass('@fit');
+        this.setContent(this.m_cal);
+    }
+    // binded
+    _handleClick = (e) => {
+        if (!this.dom) {
+            return;
+        }
+        let newfocus = e.target;
+        // child of this: ok
+        if (this.dom.contains(newfocus)) {
+            return;
+        }
+        // menu: ok
+        let dest = Component.getElement(newfocus, MenuItem);
+        if (dest) {
+            return;
+        }
+        this.close();
+    };
+    /** @ignore */
+    show(modal) {
+        x4document.addEventListener('mousedown', this._handleClick);
+        super.show(modal);
+    }
+    /** @ignore */
+    close() {
+        x4document.removeEventListener('mousedown', this._handleClick);
+        super.close();
+    }
+}

package/lib/esm/canvas.js

@@ -0,0 +1,358 @@
+/**
+*  ___  ___ __
+*  \  \/  /  / _
+*   \    /  /_| |_
+*   /    \____   _|
+*  /__/\__\   |_|
+*
+* @file canvas.ts
+* @author Etienne Cochard
+*
+* Copyright (c) 2019-2022 R-libre ingenierie
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+* of the Software, and to permit persons to whom the Software is furnished to do so,
+* subject to the following conditions:
+* The above copyright notice and this permission notice shall be included in all copies
+* or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**/
+import { Component } from './component';
+import { BasicEvent } from './x4events';
+function EvPaint(ctx) {
+    return BasicEvent({ ctx });
+}
+function mkPainter(c2d, w, h) {
+    let cp = c2d;
+    cp.width = w;
+    cp.height = h;
+    cp.smoothLine = smoothLine;
+    cp.smoothLineEx = smoothLineEx;
+    cp.line = line;
+    cp.roundRect = roundRect;
+    cp.calcTextSize = calcTextSize;
+    cp.setFontSize = setFontSize;
+    cp.circle = circle;
+    return cp;
+}
+function smoothLine(points, path = null, move = true) {
+    if (points.length < 2) {
+        return;
+    }
+    if (!path) {
+        path = this;
+    }
+    if (points.length == 2) {
+        if (move !== false) {
+            path.moveTo(points[0].x, points[0].y);
+        }
+        else {
+            path.lineTo(points[0].x, points[0].y);
+        }
+        path.lineTo(points[1].x, points[1].y);
+        return;
+    }
+    function midPointBtw(p1, p2) {
+        return {
+            x: p1.x + (p2.x - p1.x) / 2,
+            y: p1.y + (p2.y - p1.y) / 2
+        };
+    }
+    function getQuadraticXY(t, sx, sy, cp1x, cp1y, ex, ey) {
+        return {
+            x: (1 - t) * (1 - t) * sx + 2 * (1 - t) * t * cp1x + t * t * ex,
+            y: (1 - t) * (1 - t) * sy + 2 * (1 - t) * t * cp1y + t * t * ey
+        };
+    }
+    let p1 = points[0], p2 = points[1], p3 = p1;
+    path.moveTo(p1.x, p1.y);
+    for (let i = 1, len = points.length; i < len; i++) {
+        // we pick the point between pi+1 & pi+2 as the
+        // end point and p1 as our control point
+        let midPoint = midPointBtw(p1, p2);
+        //this.quadraticCurveTo(p1.x, p1.y, midPoint.x, midPoint.y);
+        for (let i = 0; i < 8; i++) {
+            let { x, y } = getQuadraticXY(i / 8, p3.x, p3.y, p1.x, p1.y, midPoint.x, midPoint.y);
+            path.lineTo(x, y);
+        }
+        p1 = points[i];
+        p2 = points[i + 1];
+        p3 = midPoint;
+    }
+    // Draw last line as a straight line while
+    // we wait for the next point to be able to calculate
+    // the bezier control point
+    path.lineTo(p1.x, p1.y);
+}
+function smoothLineEx(_points, tension = 0.5, numOfSeg = 10, path = null, move = true, close = false) {
+    let points = [];
+    //pts = points.slice(0);
+    for (let p = 0, pc = _points.length; p < pc; p++) {
+        points.push(_points[p].x);
+        points.push(_points[p].y);
+    }
+    let pts, i = 1, l = points.length, rPos = 0, rLen = (l - 2) * numOfSeg + 2 + (close ? 2 * numOfSeg : 0), res = new Float32Array(rLen), cache = new Float32Array((numOfSeg + 2) * 4), cachePtr = 4;
+    pts = points.slice(0);
+    if (close) {
+        pts.unshift(points[l - 1]); // insert end point as first point
+        pts.unshift(points[l - 2]);
+        pts.push(points[0], points[1]); // first point as last point
+    }
+    else {
+        pts.unshift(points[1]); // copy 1. point and insert at beginning
+        pts.unshift(points[0]);
+        pts.push(points[l - 2], points[l - 1]); // duplicate end-points
+    }
+    // cache inner-loop calculations as they are based on t alone
+    cache[0] = 1; // 1,0,0,0
+    for (; i < numOfSeg; i++) {
+        var st = i / numOfSeg, st2 = st * st, st3 = st2 * st, st23 = st3 * 2, st32 = st2 * 3;
+        cache[cachePtr++] = st23 - st32 + 1; // c1
+        cache[cachePtr++] = st32 - st23; // c2
+        cache[cachePtr++] = st3 - 2 * st2 + st; // c3
+        cache[cachePtr++] = st3 - st2; // c4
+    }
+    cache[cachePtr] = 1; // 0,1,0,0
+    // calc. points
+    parse(pts, cache, l);
+    if (close) {
+        //l = points.length;
+        pts = [];
+        pts.push(points[l - 4], points[l - 3], points[l - 2], points[l - 1]); // second last and last
+        pts.push(points[0], points[1], points[2], points[3]); // first and second
+        parse(pts, cache, 4);
+    }
+    function parse(pts, cache, l) {
+        for (var i = 2, t; i < l; i += 2) {
+            var pt1 = pts[i], pt2 = pts[i + 1], pt3 = pts[i + 2], pt4 = pts[i + 3], t1x = (pt3 - pts[i - 2]) * tension, t1y = (pt4 - pts[i - 1]) * tension, t2x = (pts[i + 4] - pt1) * tension, t2y = (pts[i + 5] - pt2) * tension;
+            for (t = 0; t < numOfSeg; t++) {
+                var c = t << 2, //t * 4;
+                c1 = cache[c], c2 = cache[c + 1], c3 = cache[c + 2], c4 = cache[c + 3];
+                res[rPos++] = c1 * pt1 + c2 * pt3 + c3 * t1x + c4 * t2x;
+                res[rPos++] = c1 * pt2 + c2 * pt4 + c3 * t1y + c4 * t2y;
+            }
+        }
+    }
+    // add last point
+    l = close ? 0 : points.length - 2;
+    res[rPos++] = points[l];
+    res[rPos] = points[l + 1];
+    if (!path) {
+        path = this;
+    }
+    // add lines to path
+    for (let i = 0, l = res.length; i < l; i += 2) {
+        if (i == 0 && move !== false) {
+            path.moveTo(res[i], res[i + 1]);
+        }
+        else {
+            path.lineTo(res[i], res[i + 1]);
+        }
+    }
+}
+function line(x1, y1, x2, y2, color, lineWidth = 1) {
+    this.save();
+    this.beginPath();
+    this.moveTo(x1, y1);
+    this.lineTo(x2, y2);
+    this.lineWidth = lineWidth;
+    this.strokeStyle = color;
+    this.stroke();
+    this.restore();
+}
+function roundRect(x, y, width, height, radius) {
+    //this.beginPath( );
+    this.moveTo(x + radius, y);
+    this.lineTo(x + width - radius, y);
+    this.quadraticCurveTo(x + width, y, x + width, y + radius);
+    this.lineTo(x + width, y + height - radius);
+    this.quadraticCurveTo(x + width, y + height, x + width - radius, y + height);
+    this.lineTo(x + radius, y + height);
+    this.quadraticCurveTo(x, y + height, x, y + height - radius);
+    this.lineTo(x, y + radius);
+    this.quadraticCurveTo(x, y, x + radius, y);
+    this.closePath();
+}
+function calcTextSize(text, rounded = false) {
+    let fh = this.measureText(text);
+    let lh = fh.fontBoundingBoxAscent + fh.fontBoundingBoxDescent;
+    if (rounded) {
+        return { width: Math.round(fh.width), height: Math.round(lh) };
+    }
+    else {
+        return { width: fh.width, height: lh };
+    }
+}
+function setFontSize(fs) {
+    let fsize = Math.round(fs) + 'px';
+    this.font = this.font.replace(/\d+px/, fsize);
+}
+function circle(x, y, radius) {
+    this.moveTo(x + radius, y);
+    this.arc(x, y, radius, 0, Math.PI * 2);
+}
+/**
+ *
+ */
+//export class CanvasProps extends CProps
+//{
+// low level handlers
+//mousedown?:  (ev: MouseEvent) => any;
+//mousemove?:  (ev: MouseEvent) => any;
+//mouseup?:  (ev: MouseEvent) => any;
+//mouseleave?:  (ev: MouseEvent) => any;
+//mousewheel?: (ev: WheelEvent) => any;
+//click?: (ev: MouseEvent) => any;
+//dblclick?: (ev: MouseEvent) => any;
+//touchstart?: (ev: TouchEvent) => any;
+//touchmove?: (ev: TouchEvent) => any;
+//touchend?: (ev: TouchEvent) => any;
+//keydown?: (ev: KeyboardEvent) => any;
+//keyup?: (ev: KeyboardEvent) => any;
+//}
+/**
+ * Standard Canvas
+ */
+export class Canvas extends Component {
+    m_iwidth = -1;
+    m_iheight = -1;
+    m_scale = 1.0;
+    m_canvas;
+    constructor(props) {
+        super(props);
+        //if( props.mousedown )	{ this.setDomEvent( 'mousedown', props.mousedown ); }
+        //if( props.mousemove )	{ this.setDomEvent( 'mousemove', props.mousemove ); }
+        //if( props.mouseup )		{ this.setDomEvent( 'mouseup', props.mouseup ); }
+        //if( props.mousewheel )	{ this.setDomEvent( 'wheel', props.mousewheel ); }
+        //if( props.mouseleave )	{ this.setDomEvent( 'mouseleave', props.mouseleave ); }
+        //if( props.click )		{ this.setDomEvent( 'click', props.click ); }
+        //if( props.dblclick )	{ this.setDomEvent( 'dblclick', props.dblclick ); }
+        //if( props.touchstart )	{ this.setDomEvent( 'touchstart', props.touchstart ); }
+        //if( props.touchmove )	{ this.setDomEvent( 'touchmove', props.touchmove ); }
+        //if( props.touchend )	{ this.setDomEvent( 'touchend', props.touchend ); }
+        //if( props.keydown )		{ this.setDomEvent( 'keydown', props.keydown ); this.setAttribute( 'tabindex', 0 ); }
+        //if( props.keyup )		{ this.setDomEvent( 'keyup', props.keyup ); this.setAttribute( 'tabindex', 0 ); }
+        //if( props.paint ) 		{ this.onPaint( props.paint ); }
+        this.setDomEvent('sizechange', () => { this._paint(); });
+        this.mapPropEvents(props, 'paint');
+    }
+    /** @ignore */
+    render() {
+        this.m_iwidth = -1;
+        this.m_iheight = -1;
+        this.m_canvas = new Component({
+            tag: 'canvas'
+        });
+        this.setContent(this.m_canvas);
+        //		this.redraw(10);
+    }
+    update(delay = 0) {
+        this.m_iheight = this.m_iwidth = -1;
+        super.update(delay);
+    }
+    /**
+     * scale the whole canvas
+     */
+    scale(scale) {
+        this.m_scale = scale;
+        this.m_iwidth = -1; // force recalc
+        this.redraw();
+    }
+    /**
+     * return the internal canvas
+     */
+    get canvas() {
+        return this.m_canvas;
+    }
+    /**
+     * redraw the canvas (force a paint)
+     */
+    $update_rep = 0;
+    redraw(wait) {
+        if (wait !== undefined) {
+            if (++this.$update_rep >= 20) {
+                this.stopTimer('update');
+                this._paint();
+            }
+            else {
+                this.startTimer('update', wait, false, () => this._paint());
+            }
+        }
+        else {
+            this.stopTimer('update');
+            this._paint();
+        }
+    }
+    /**
+     *
+     */
+    _paint() {
+        this.$update_rep = 0;
+        let dom = this.dom;
+        if (!this.isUserVisible()) {
+            return;
+        }
+        let canvas = this.m_canvas.dom, w = dom.clientWidth, h = dom.clientHeight;
+        let ctx = canvas.getContext('2d');
+        if (w != this.m_iwidth || h != this.m_iheight) {
+            // adjustment for HDPI
+            let devicePixelRatio = window.devicePixelRatio || 1;
+            let backingStoreRatio = ctx.webkitBackingStorePixelRatio ||
+                ctx.mozBackingStorePixelRatio ||
+                ctx.msBackingStorePixelRatio ||
+                ctx.oBackingStorePixelRatio ||
+                ctx.backingStorePixelRatio || 1;
+            let canvas = this.canvas;
+            if (devicePixelRatio !== backingStoreRatio || this.m_scale != 1.0) {
+                let ratio = devicePixelRatio / backingStoreRatio, rw = w * ratio, rh = h * ratio;
+                canvas.setAttribute('width', '' + rw);
+                canvas.setAttribute('height', '' + rh);
+                canvas.setStyleValue('width', w);
+                canvas.setStyleValue('height', h);
+                ratio *= this.m_scale;
+                ctx.scale(ratio, ratio);
+            }
+            else {
+                canvas.setAttribute('width', '' + w);
+                canvas.setAttribute('height', '' + h);
+                canvas.setStyleValue('width', w);
+                canvas.setStyleValue('height', h);
+                ctx.scale(1, 1);
+            }
+            this.m_iwidth = w;
+            this.m_iheight = h;
+        }
+        if (w && h) {
+            let cc = mkPainter(ctx, w, h);
+            if (this.m_props.autoClear) {
+                cc.clearRect(0, 0, w, h);
+            }
+            cc.save();
+            cc.translate(-0.5, -0.5);
+            this.paint(cc);
+            cc.restore();
+        }
+    }
+    paint(ctx) {
+        try {
+            if (this.m_props.painter) {
+                this.m_props.painter(ctx);
+            }
+            else {
+                this.emit('paint', EvPaint(ctx));
+            }
+        }
+        catch (x) {
+            console.assert(false, x);
+        }
+    }
+}