@wcardinal/wcardinal-ui 0.442.0 → 0.444.0

package/dist/wcardinal-ui.js

@@ -1,5 +1,5 @@
 /*
- Winter Cardinal UI v0.442.0
+ Winter Cardinal UI v0.444.0
  Copyright (C) 2019 Toshiba Corporation
  SPDX-License-Identifier: Apache-2.0
 
@@ -23625,6 +23625,115 @@
         return DCanvasContainer;
     }(DBase));
 
+    var UtilExtractorCanvas = /** @class */ (function () {
+        function UtilExtractorCanvas(width, height) {
+            var element = document.createElement("canvas");
+            this._element = element;
+            var context = this._element.getContext("2d", {
+                willReadFrequently: true
+            });
+            this._context = context;
+            element.width = width;
+            element.height = height;
+        }
+        Object.defineProperty(UtilExtractorCanvas.prototype, "element", {
+            get: function () {
+                var result = this._element;
+                if (result != null) {
+                    return result;
+                }
+                throw new Error("No Element Available");
+            },
+            enumerable: false,
+            configurable: true
+        });
+        UtilExtractorCanvas.prototype.getElement = function () {
+            return this._element;
+        };
+        Object.defineProperty(UtilExtractorCanvas.prototype, "canvas", {
+            get: function () {
+                return this.element;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(UtilExtractorCanvas.prototype, "context", {
+            get: function () {
+                var result = this._context;
+                if (result != null) {
+                    return result;
+                }
+                throw new Error("No Context Available");
+            },
+            enumerable: false,
+            configurable: true
+        });
+        UtilExtractorCanvas.prototype.getContext = function () {
+            return this._context;
+        };
+        Object.defineProperty(UtilExtractorCanvas.prototype, "resolution", {
+            get: function () {
+                return 1;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(UtilExtractorCanvas.prototype, "width", {
+            get: function () {
+                var element = this._element;
+                if (element != null) {
+                    return element.width;
+                }
+                return 0;
+            },
+            set: function (width) {
+                var element = this._element;
+                if (element != null) {
+                    element.width = width;
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(UtilExtractorCanvas.prototype, "height", {
+            get: function () {
+                var element = this._element;
+                if (element != null) {
+                    return element.height;
+                }
+                return 0;
+            },
+            set: function (height) {
+                var element = this._element;
+                if (element != null) {
+                    element.height = height;
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        UtilExtractorCanvas.prototype.clear = function () {
+            var element = this._element;
+            var context = this._context;
+            if (element != null && context != null) {
+                context.setTransform(1, 0, 0, 1, 0, 0);
+                context.clearRect(0, 0, element.width, element.height);
+            }
+        };
+        UtilExtractorCanvas.prototype.resize = function (width, height) {
+            var element = this._element;
+            if (element != null) {
+                element.width = width;
+                element.height = height;
+            }
+        };
+        UtilExtractorCanvas.prototype.destroy = function () {
+            this._context = null;
+            this._element = null;
+        };
+        return UtilExtractorCanvas;
+    }());
+
     /*
      * Copyright (C) 2019 Toshiba Corporation
      * SPDX-License-Identifier: Apache-2.0
@@ -23634,9 +23743,11 @@
         }
         UtilExtractor.toTexture = function (target, resolution, clear, skipUpdateTransform) {
             var scale = target.transform.scale;
+            var width = Math.max(1, Math.ceil(target.width * scale.x));
+            var height = Math.max(1, Math.ceil(target.height * scale.y));
             var result = pixi_js.RenderTexture.create({
-                width: target.width * scale.x,
-                height: target.height * scale.y,
+                width: width,
+                height: height,
                 scaleMode: pixi_js.SCALE_MODES.LINEAR,
                 resolution: resolution
             });
@@ -23648,46 +23759,68 @@
             return result;
         };
         UtilExtractor.toPixels = function (renderTexture, renderer) {
+            var baseTexture = renderTexture.baseTexture;
+            var realWidth = baseTexture.realWidth;
+            var realHeight = baseTexture.realHeight;
             var resolution = renderTexture.resolution;
             var frame = renderTexture.frame;
-            var width = Math.floor(frame.width * resolution);
-            var height = Math.floor(frame.height * resolution);
+            var x0 = Math.floor(frame.x * resolution);
+            var y0 = Math.floor(frame.y * resolution);
+            var x1 = Math.floor((frame.x + frame.width) * resolution);
+            var y1 = Math.floor((frame.y + frame.height) * resolution);
+            var width = Math.min(x1 - x0, realWidth);
+            var height = Math.min(y1 - y0, realHeight);
             var pixels = new Uint8Array(4 * width * height);
-            var oldRenderTexture = renderer.renderTexture.current;
-            renderer.renderTexture.bind(renderTexture);
-            var gl = renderer.gl;
-            gl.readPixels(frame.x * resolution, frame.y * resolution, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
-            renderer.renderTexture.bind(oldRenderTexture);
+            if (0 < width && 0 < height) {
+                var oldRenderTexture = renderer.renderTexture.current;
+                renderer.renderTexture.bind(renderTexture);
+                var gl = renderer.gl;
+                gl.readPixels(x0, y0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+                renderer.renderTexture.bind(oldRenderTexture);
+            }
             return {
                 width: width,
                 height: height,
                 array: pixels
             };
         };
-        UtilExtractor.toCanvas = function (pixels, scale, ignorePremutipliedAlpha) {
+        UtilExtractor.toCanvas = function (pixels, scale, ignorePremutipliedAlpha, result) {
             var width = pixels.width;
             var height = pixels.height;
             var array = pixels.array;
-            var canvasRenderTarget = new pixi_js.utils.CanvasRenderTarget(width, height, 1);
-            var imageData = canvasRenderTarget.context.getImageData(0, 0, width, height);
+            if (result == null) {
+                result = new UtilExtractorCanvas(width, height);
+            }
+            else {
+                result.resize(width, height);
+            }
+            if (width <= 0 || height <= 0) {
+                return result;
+            }
+            var context = result.getContext();
+            var element = result.getElement();
+            if (context == null || element == null) {
+                return result;
+            }
+            var imageData = context.getImageData(0, 0, width, height);
             if (ignorePremutipliedAlpha) {
                 imageData.data.set(array);
             }
             else {
                 pixi_js.Extract.arrayPostDivide(array, imageData.data);
             }
-            canvasRenderTarget.context.putImageData(imageData, 0, 0);
+            context.putImageData(imageData, 0, 0);
             // Scale down
             if (scale != null && scale !== 1) {
-                canvasRenderTarget.context.scale(scale, scale);
-                canvasRenderTarget.context.drawImage(canvasRenderTarget.canvas, 0, 0);
+                context.scale(scale, scale);
+                context.drawImage(element, 0, 0);
                 var scaledWidth = Math.floor(width * scale);
                 var scaledHeight = Math.floor(height * scale);
-                var scaledImageData = canvasRenderTarget.context.getImageData(0, 0, scaledWidth, scaledHeight);
-                canvasRenderTarget.resize(scaledWidth, scaledHeight);
-                canvasRenderTarget.context.putImageData(scaledImageData, 0, 0);
+                var scaledImageData = context.getImageData(0, 0, scaledWidth, scaledHeight);
+                result.resize(scaledWidth, scaledHeight);
+                context.putImageData(scaledImageData, 0, 0);
             }
-            return canvasRenderTarget;
+            return result;
         };
         UtilExtractor.toBase64 = function (canvas, format, quality) {
             return canvas.toDataURL(format, quality);
@@ -23822,8 +23955,15 @@
             // Create a render texture
             var target = options.target;
             var scale = target.transform.scale;
-            var width = Math.floor(target.width * scale.x);
-            var height = Math.floor(target.height * scale.y);
+            var width = Math.ceil(target.width * scale.x);
+            var height = Math.ceil(target.height * scale.y);
+            if (width <= 0 || height <= 0) {
+                return {
+                    width: width,
+                    height: height,
+                    array: new Uint8Array(0)
+                };
+            }
             var resolution = toResolution(options);
             var renderTexture = UtilExtract.WORK_RENDER_TEXTURE;
             if (renderTexture == null) {
@@ -23871,16 +24011,27 @@
             var scale = toScale(pixels, options);
             return UtilExtractor.toCanvas(pixels, scale, ignorePremutipliedAlpha);
         };
+        /**
+         * Extracts Base64 data URL from the target.
+         * This method internally creates a render texture and a canvas render target.
+         * They are used to extract pixels from the target.
+         * To free the allocated render texture and canvas render target, please call {@link destroy()}.
+         *
+         * @param options an extraction options
+         * @returns extracted Base64 data URL
+         */
         UtilExtract.base64 = function (options) {
-            var canvas = this.canvas(options);
-            try {
-                return UtilExtractor.toBase64(canvas.canvas, options.format, options.quality);
-            }
-            finally {
-                if (canvas) {
-                    canvas.destroy();
-                }
+            var _a, _b, _c;
+            var pixels = this.pixels(options);
+            var ignorePremutipliedAlpha = (_b = (_a = options.alpha) === null || _a === void 0 ? void 0 : _a.premultiplied) === null || _b === void 0 ? void 0 : _b.ignore;
+            var scale = toScale(pixels, options);
+            var canvas = ((_c = this.WORK_CANVAS) !== null && _c !== void 0 ? _c : (this.WORK_CANVAS = new UtilExtractorCanvas(pixels.width, pixels.height)));
+            UtilExtractor.toCanvas(pixels, scale, ignorePremutipliedAlpha, canvas);
+            var element = canvas.getElement();
+            if (element != null) {
+                return UtilExtractor.toBase64(element, options.format, options.quality);
             }
+            return "data:,";
         };
         UtilExtract.file = function (options) {
             UtilFileDownloader.downloadUrl(options.filename, this.base64(options));
@@ -23894,6 +24045,11 @@
                 this.WORK_RENDER_TEXTURE = undefined;
                 texture.destroy(true);
             }
+            var canvas = this.WORK_CANVAS;
+            if (canvas != null) {
+                this.WORK_CANVAS = undefined;
+                canvas.destroy();
+            }
         };
         return UtilExtract;
     }());
@@ -34257,8 +34413,16 @@
                             object.alpha = alpha;
                             result = true;
                         }
+                        if (!object.visible) {
+                            object.visible = true;
+                            result = true;
+                        }
                         return result;
                     }
+                    else if (object.visible) {
+                        object.visible = false;
+                        return true;
+                    }
                 }
             }
             return false;
@@ -56008,10 +56172,11 @@
             });
             this._inputAndLabelAlpha = inputAndLabelAlpha;
             // Samples
-            var sampleWidth = (inputWidth - inputLabelWidth - inputMargin) * 0.5;
-            var sampleHeight = inputHeight + inputMargin + inputHeight;
+            var sampleWidth = theme.getSampleWidth();
+            var sampleHeight = theme.getSampleHeight();
             var sampleX = paddingLeft + (mainWidth - inputMargin) * 0.5 + inputMargin;
             var sampleY = inputY + (inputHeight + inputMargin + inputAndLabelAlpha.height - sampleHeight) * 0.5;
+            var sampleMargin = theme.getSampleMargin();
             var sampleCurrentCheckerboardSprite = new pixi_js.Sprite(theme.getSampleCheckerboardOldTexture());
             this._sampleCurrentCheckerboardSprite = sampleCurrentCheckerboardSprite;
             sampleCurrentCheckerboardSprite.x = sampleX;
@@ -56038,7 +56203,7 @@
             this.addChild(sampleCurrentSprite);
             var sampleNewCheckerboardSprite = new pixi_js.Sprite(theme.getSampleCheckerboardNewTexture());
             this._sampleNewCheckerboardSprite = sampleNewCheckerboardSprite;
-            sampleNewCheckerboardSprite.x = sampleX + sampleWidth;
+            sampleNewCheckerboardSprite.x = sampleX + sampleWidth + sampleMargin;
             sampleNewCheckerboardSprite.y = sampleY;
             sampleNewCheckerboardSprite.width = sampleWidth;
             sampleNewCheckerboardSprite.height = sampleHeight;
@@ -56046,7 +56211,7 @@
             this.addChild(sampleNewCheckerboardSprite);
             var sampleNewSprite = new pixi_js.Sprite(theme.getSampleNewTexture());
             this._sampleNewSprite = sampleNewSprite;
-            sampleNewSprite.x = sampleX + sampleWidth;
+            sampleNewSprite.x = sampleX + sampleWidth + sampleMargin;
             sampleNewSprite.y = sampleY;
             sampleNewSprite.tint = this._new.color;
             sampleNewSprite.alpha = this._new.alpha;
@@ -73314,6 +73479,10 @@
          * Cells of a right-most frozen column.
          */
         FROZEN_END: "FROZEN_END",
+        /**
+         * Rows with data
+         */
+        HAS_DATA: "HAS_DATA",
         /**
          * Header cells of sortable columns.
          */
@@ -75523,6 +75692,7 @@
                 // State
                 var rowState = row.state;
                 rowState.lock();
+                rowState.add(DTableState.HAS_DATA);
                 rowState.set(DTableState.SELECTABLE, isRowSelectable);
                 rowState.set(DBaseState.ACTIVE, selection.contains(unmappedIndex));
                 rowState.remove(DBaseState.DISABLED);
@@ -75538,7 +75708,7 @@
                 var rowState = row.state;
                 rowState.lock();
                 rowState.add(DBaseState.DISABLED);
-                rowState.removeAll(DTableState.SELECTABLE, DBaseState.ACTIVE);
+                rowState.removeAll(DTableState.HAS_DATA, DTableState.SELECTABLE, DBaseState.ACTIVE);
                 rowState.unlock();
                 // Data
                 row.unset();
@@ -75551,7 +75721,7 @@
                 var rowState = row.state;
                 rowState.lock();
                 rowState.add(DBaseState.DISABLED);
-                rowState.removeAll(DTableState.SELECTABLE, DBaseState.ACTIVE);
+                rowState.removeAll(DTableState.HAS_DATA, DTableState.SELECTABLE, DBaseState.ACTIVE);
                 rowState.unlock();
                 // Data
                 row.unset();
@@ -80940,6 +81110,7 @@
         UtilGestureTap: UtilGestureTap,
         UtilGesture: UtilGesture,
         UtilExtract: UtilExtract,
+        UtilExtractorCanvas: UtilExtractorCanvas,
         UtilExtractor: UtilExtractor,
         UtilFileDownloader: UtilFileDownloader,
         UtilFileAs: UtilFileAs,