13966 lines
1.6 MiB
13966 lines
1.6 MiB
(function () {
|
|
'use strict';
|
|
|
|
/**
|
|
* Class that represents a PixiJS Theme.
|
|
*
|
|
* @example
|
|
* // Create the theme
|
|
* const yellow = new Theme({
|
|
* fill: 0xfecd2d,
|
|
* fillActive: 0xfe9727,
|
|
* strokeActive: 0xfecd2d,
|
|
* strokeActiveWidth: 4,
|
|
* textStyle: {
|
|
* fill: 0x5ec7f8
|
|
* },
|
|
* textStyleActive: {
|
|
* fill: 0x5954d3
|
|
* },
|
|
* textStyleLarge: {
|
|
* fontSize: 36
|
|
* }
|
|
* })
|
|
*
|
|
* // Create the app and apply the new theme to it
|
|
* const app = new PIXIApp({
|
|
* view: canvas,
|
|
* width: 450,
|
|
* height: 150,
|
|
* theme: yellow
|
|
* }).setup().run()
|
|
*
|
|
* @class
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/theme.html|DocTest}
|
|
*/
|
|
class Theme {
|
|
|
|
/**
|
|
* Creates an instance of a Theme.
|
|
*
|
|
* @constructor
|
|
* @param {object} [opts] - An options object to specify to style and behaviour of the theme.
|
|
* @param {number} [opts.margin=10] - The outer spacing (distance to other objects) from the border.
|
|
* @param {number} [opts.padding=10] - The inner spacing (distance from icon and/or label) to the border.
|
|
* @param {number} [opts.radius=4] - The radius used when drawing a rounded rectangle.
|
|
* @param {number} [opts.fast=0.25] - The duration of time when it has to be fast.
|
|
* @param {number} [opts.normal=0.5] - The duration of time when it has to be normal.
|
|
* @param {number} [opts.slow=1] - The duration of time when it has to be slow.
|
|
* @param {number} [opts.primaryColor=0x5ec7f8] - The primary color of the theme.
|
|
* @param {number} [opts.color1=0x282828] - The first color of the theme. For example used for the background.
|
|
* @param {number} [opts.color2=0xf6f6f6] - The second color of the theme. For example used for the border.
|
|
* @param {number} [opts.fill=color1] - The color of the background as a hex value.
|
|
* @param {number} [opts.fillAlpha=1] - The alpha value of the background.
|
|
* @param {number} [opts.fillActive=color1] - The color of the background when activated.
|
|
* @param {number} [opts.fillActiveAlpha=1] - The alpha value of the background when activated.
|
|
* @param {number} [opts.stroke=color2] - The color of the border as a hex value.
|
|
* @param {number} [opts.strokeWidth=0.6] - The width of the border in pixel.
|
|
* @param {number} [opts.strokeAlpha=1] - The alpha value of the border.
|
|
* @param {number} [opts.strokeActive=color2] - The color of the border when activated.
|
|
* @param {number} [opts.strokeActiveWidth=0.6] - The width of the border in pixel when activated.
|
|
* @param {number} [opts.strokeActiveAlpha=1] - The alpha value of the border when activated.
|
|
* @param {number} [opts.iconColor=color2] - The color of the icon (set by the tint property) as a hex value.
|
|
* @param {number} [opts.iconColorActive=colorPrimary] - The color of the icon when activated.
|
|
* @param {number} [opts.background=color1] - The color of a background for a component (e.g. at the Modal class).
|
|
* @param {object} [opts.textStyle={}] - A textstyle object for the styling of text. See PIXI.TextStyle
|
|
* for possible options. Default object:
|
|
* @param {string} [opts.textStyle.fontFamily="Avenir Next", "Open Sans", "Segoe UI", ...] - The font family.
|
|
* @param {string} [opts.textStyle.fontWeight=400] - The font weight.
|
|
* @param {number} [opts.textStyle.fontSize=16] - The font size.
|
|
* @param {number} [opts.textStyle.fill=color2] - The fill color.
|
|
* @param {number} [opts.textStyle.stroke=color1] - The stroke color.
|
|
* @param {number} [opts.textStyle.strokeThickness=0] - The thickness of the stroke.
|
|
* @param {number} [opts.textStyle.miterLimit=1] - The meter limit.
|
|
* @param {string} [opts.textStyle.lineJoin=round] - The line join.
|
|
* @param {object} [opts.textStyleActive=textStyle + {fill: primaryColor}] - A textstyle object which is used
|
|
* for actived text.
|
|
* @param {object} [opts.textStyleSmall=textStyle + {fontSize: -= 3}] - A textstyle object which is used for
|
|
* small text.
|
|
* @param {object} [opts.textStyleSmallActive=textStyleSmall + {fill: primaryColor}] - A textstyle object which
|
|
* is used for small actived text.
|
|
* @param {object} [opts.textStyleLarge=textStyle + {fontSize: += 3}] - A textstyle object which is used for
|
|
* large text.
|
|
* @param {object} [opts.textStyleLargeActive=textStyleLarge + {fill: primaryColor}] - A textstyle object which
|
|
* is used for large actived text.
|
|
*/
|
|
constructor(opts = {}) {
|
|
|
|
const colorPrimary = opts.primaryColor != null ? opts.primaryColor : 0x5ec7f8; // blue
|
|
const color1 = opts.color1 != null ? opts.color1 : 0x282828; // black
|
|
const color2 = opts.color2 != null ? opts.color2 : 0xf6f6f6; // white
|
|
|
|
this.opts = Object.assign({}, {
|
|
margin: 12,
|
|
padding: 12,
|
|
radius: 4,
|
|
fast: .25,
|
|
normal: .5,
|
|
slow: 1,
|
|
primaryColor: colorPrimary,
|
|
color1: color1,
|
|
color2: color2,
|
|
fill: color1,
|
|
fillAlpha: 1,
|
|
fillActive: color1,
|
|
fillActiveAlpha: 1,
|
|
stroke: color2,
|
|
strokeWidth: .6,
|
|
strokeAlpha: 1,
|
|
strokeActive: color2,
|
|
strokeActiveWidth: .6,
|
|
strokeActiveAlpha: 1,
|
|
iconColor: color2,
|
|
iconColorActive: colorPrimary,
|
|
background: color1
|
|
}, opts);
|
|
|
|
// Set textStyle and variants
|
|
this.opts.textStyle = Object.assign({}, {
|
|
fontFamily: '"Avenir Next", "Open Sans", "Segoe UI", "Roboto", "Helvetica Neue", -apple-system, system-ui, BlinkMacSystemFont, Arial, sans-serif !default',
|
|
fontWeight: '500',
|
|
fontSize: 18,
|
|
fill: color2,
|
|
stroke: color1,
|
|
strokeThickness: 0,
|
|
miterLimit: 1,
|
|
lineJoin: 'round'
|
|
}, this.opts.textStyle);
|
|
this.opts.textStyleSmall = Object.assign({}, this.opts.textStyle, {fontSize: this.opts.textStyle.fontSize - 3}, this.opts.textStyleSmall);
|
|
this.opts.textStyleLarge = Object.assign({}, this.opts.textStyle, {fontSize: this.opts.textStyle.fontSize + 3}, this.opts.textStyleLarge);
|
|
this.opts.textStyleActive = Object.assign({}, this.opts.textStyle, {fill: this.opts.primaryColor}, this.opts.textStyleActive);
|
|
this.opts.textStyleSmallActive = Object.assign({}, this.opts.textStyleSmall, {fill: this.opts.primaryColor}, this.opts.textStyleSmallActive);
|
|
this.opts.textStyleLargeActive = Object.assign({}, this.opts.textStyleLarge, {fill: this.opts.primaryColor}, this.opts.textStyleLargeActive);
|
|
|
|
Object.assign(this, this.opts);
|
|
}
|
|
|
|
/**
|
|
* Factory function
|
|
*
|
|
* @static
|
|
* @param {string} theme=dark - The name of the theme to load.
|
|
* @return {Theme} Returns a newly created Theme object.
|
|
*/
|
|
static fromString(theme) {
|
|
|
|
if (theme && typeof theme === 'object') {
|
|
return theme
|
|
}
|
|
|
|
switch (theme) {
|
|
case 'light':
|
|
return new ThemeLight()
|
|
case 'red':
|
|
return new ThemeRed()
|
|
default:
|
|
return new ThemeDark()
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class that represents a PixiJS ThemeDark.
|
|
*
|
|
* @example
|
|
* // Create the app with a new dark theme
|
|
* const app = new PIXIApp({
|
|
* view: canvas,
|
|
* width: 450,
|
|
* height: 150,
|
|
* theme: new ThemeDark()
|
|
* }).setup().run()
|
|
*
|
|
* @class
|
|
* @extends Theme
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/theme.html|DocTest}
|
|
*/
|
|
class ThemeDark extends Theme {
|
|
|
|
}
|
|
|
|
/**
|
|
* Class that represents a PixiJS ThemeLight.
|
|
* The color1 is set to 0xf6f6f6, color2 to 0x282828.
|
|
*
|
|
* @example
|
|
* // Create the app with a new light theme
|
|
* const app = new PIXIApp({
|
|
* view: canvas,
|
|
* width: 450,
|
|
* height: 150,
|
|
* theme: new ThemeLight()
|
|
* }).setup().run()
|
|
*
|
|
* @class
|
|
* @extends Theme
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/theme.html|DocTest}
|
|
*/
|
|
class ThemeLight extends Theme {
|
|
|
|
/**
|
|
* Creates an instance of a ThemeLight.
|
|
*
|
|
* @constructor
|
|
*/
|
|
constructor() {
|
|
|
|
super({color1: 0xf6f6f6, color2: 0x282828});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class that represents a PixiJS ThemeRed.
|
|
* The primaryColor is set to 0xd92f31.
|
|
*
|
|
* @example
|
|
* // Create the app with a new red theme
|
|
* const app = new PIXIApp({
|
|
* view: canvas,
|
|
* width: 450,
|
|
* height: 150,
|
|
* theme: new ThemeRed()
|
|
* }).setup().run()
|
|
*
|
|
* @class
|
|
* @extends Theme
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/theme.html|DocTest}
|
|
*/
|
|
class ThemeRed extends Theme {
|
|
|
|
/**
|
|
* Creates an instance of a ThemeRed.
|
|
*
|
|
* @constructor
|
|
*/
|
|
constructor() {
|
|
|
|
super({primaryColor: 0xd92f31});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class that represents a PixiJS Progress.
|
|
*
|
|
* @example
|
|
* // Create the progress
|
|
* const progress = new Progress({
|
|
* app: app
|
|
* })
|
|
*
|
|
* // Add the progress to a DisplayObject
|
|
* app.scene.addChild(progress)
|
|
*
|
|
* @class
|
|
* @extends PIXI.Container
|
|
* @see {@link http://pixijs.download/dev/docs/PIXI.Container.html|PIXI.Container}
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/progress.html|DocTest}
|
|
*/
|
|
class Progress extends PIXI.Container {
|
|
|
|
/**
|
|
* Creates an instance of a Progress.
|
|
*
|
|
* @constructor
|
|
* @param {object} [opts] - An options object to specify to style and behaviour of the progress.
|
|
* @param {number} [opts.id=auto generated] - The id of the progress.
|
|
* @param {PIXIApp} [opts.app=window.app] - The app where the progress belongs to.
|
|
* @param {number} [opts.width] - The width of the progress bar. When not set, the width is the size of the app
|
|
* minus 2 * opts.margin.
|
|
* @param {number} [opts.height=2] - The height of the progress bar.
|
|
* @param {string|Theme} [opts.theme=dark] - The theme to use for this progress. Possible values are dark, light, red
|
|
* or a Theme object.
|
|
* @param {number} [opts.margin=100] - The outer spacing to the edges of the app.
|
|
* @param {number} [opts.padding=0] - The inner spacing (distance from icon and/or label) to the border.
|
|
* @param {number} [opts.fill=Theme.fill] - The color of the progress background as a hex value.
|
|
* @param {number} [opts.fillAlpha=Theme.fillAlpha] - The alpha value of the background.
|
|
* @param {number} [opts.fillActive=Theme.primaryColor] - The color of the progress background when activated.
|
|
* @param {number} [opts.fillActiveAlpha=Theme.fillActiveAlpha] - The alpha value of the background when activated.
|
|
* @param {number} [opts.stroke=Theme.stroke] - The color of the border as a hex value.
|
|
* @param {number} [opts.strokeWidth=0] - The width of the border in pixel.
|
|
* @param {number} [opts.strokeAlpha=Theme.strokeAlpha] - The alpha value of the border.
|
|
* @param {number} [opts.strokeActive=Theme.strokeActive] - The color of the border when activated.
|
|
* @param {number} [opts.strokeActiveWidth=0] - The width of the border in pixel when activated.
|
|
* @param {number} [opts.strokeActiveAlpha=Theme.strokeActiveAlpha] - The alpha value of the border when activated.
|
|
* @param {boolean} [opts.background=false] - The alpha value of the border when activated.
|
|
* @param {number} [opts.backgroundFill=Theme.background] - A textstyle object for the styling of the label. See PIXI.TextStyle
|
|
* for possible options.
|
|
* @param {number} [opts.backgroundFillAlpha=1] - A textstyle object for the styling of the label when the
|
|
* progress is activated. See PIXI.TextStyle for possible options.
|
|
* @param {number} [opts.radius=Theme.radius] - The radius of the four corners of the progress (which is a rounded rectangle).
|
|
* @param {boolean} [opts.destroyOnComplete=true] - Should the progress bar destroy itself after reaching 100 %?
|
|
* @param {boolean} [opts.visible=true] - Is the progress initially visible (property visible)?
|
|
*/
|
|
constructor(opts = {}) {
|
|
|
|
super();
|
|
|
|
const theme = Theme.fromString(opts.theme);
|
|
this.theme = theme;
|
|
|
|
this.opts = Object.assign({}, {
|
|
id: PIXI.utils.uid(),
|
|
app: window.app,
|
|
width: null,
|
|
height: 2,
|
|
margin: 100,
|
|
padding: 0,
|
|
fill: theme.fill,
|
|
fillAlpha: theme.fillAlpha,
|
|
fillActive: theme.primaryColor,
|
|
fillActiveAlpha: theme.fillActiveAlpha,
|
|
stroke: theme.stroke,
|
|
strokeWidth: 0,
|
|
strokeAlpha: theme.strokeAlpha,
|
|
strokeActive: theme.strokeActive,
|
|
strokeActiveWidth: 0,
|
|
strokeActiveAlpha: theme.strokeActiveAlpha,
|
|
background: false,
|
|
backgroundFill: theme.background,
|
|
backgroundFillAlpha: 1,
|
|
radius: theme.radius,
|
|
destroyOnComplete: true,
|
|
visible: true
|
|
}, opts);
|
|
|
|
this.id = this.opts.id;
|
|
|
|
this.background = null;
|
|
this.bar = null;
|
|
this.barActive = null;
|
|
|
|
this.alpha = 0;
|
|
|
|
this.visible = this.opts.visible;
|
|
|
|
this._progress = 0;
|
|
|
|
// setup
|
|
//-----------------
|
|
this.setup();
|
|
|
|
// layout
|
|
//-----------------
|
|
this.layout();
|
|
}
|
|
|
|
/**
|
|
* Creates children and instantiates everything.
|
|
*
|
|
* @private
|
|
* @return {Progress} A reference to the progress for chaining.
|
|
*/
|
|
setup() {
|
|
|
|
// interaction
|
|
//-----------------
|
|
this.on('added', e => {
|
|
this.show();
|
|
});
|
|
|
|
// background
|
|
//-----------------
|
|
if (this.opts.background) {
|
|
const background = new PIXI.Graphics();
|
|
this.background = background;
|
|
this.addChild(background);
|
|
}
|
|
|
|
// bar
|
|
//-----------------
|
|
const bar = new PIXI.Graphics();
|
|
this.bar = bar;
|
|
this.addChild(bar);
|
|
|
|
const barActive = new PIXI.Graphics();
|
|
this.barActive = barActive;
|
|
this.bar.addChild(barActive);
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Should be called to refresh the layout of the progress. Can be used after resizing.
|
|
*
|
|
* @return {Progress} A reference to the progress for chaining.
|
|
*/
|
|
layout() {
|
|
|
|
const width = this.opts.app.size.width;
|
|
const height = this.opts.app.size.height;
|
|
|
|
// background
|
|
//-----------------
|
|
if (this.opts.background) {
|
|
this.background.clear();
|
|
this.background.beginFill(this.opts.backgroundFill, this.opts.backgroundFillAlpha);
|
|
this.background.drawRect(0, 0, width, height);
|
|
this.background.endFill();
|
|
}
|
|
|
|
this.draw();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Draws the canvas.
|
|
*
|
|
* @private
|
|
* @return {Progress} A reference to the progress for chaining.
|
|
*/
|
|
draw() {
|
|
|
|
this.bar.clear();
|
|
this.barActive.clear();
|
|
|
|
this.drawBar();
|
|
this.drawBarActive();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Draws the bar.
|
|
*
|
|
* @private
|
|
* @return {Progress} A reference to the progress for chaining.
|
|
*/
|
|
drawBar() {
|
|
|
|
const width = this.opts.app.size.width;
|
|
const height = this.opts.app.size.height;
|
|
|
|
this.radius = this.opts.radius;
|
|
if ((this.radius * 2) > this.opts.height) {
|
|
this.radius = this.opts.height / 2;
|
|
}
|
|
|
|
const wantedWidth = this.opts.width || (width - (2 * this.opts.margin));
|
|
const wantedHeight = this.opts.height;
|
|
|
|
this.bar.lineStyle(this.opts.strokeWidth, this.opts.stroke, this.opts.strokeAlpha);
|
|
this.bar.beginFill(this.opts.fill, this.opts.fillAlpha);
|
|
if (this.radius > 1) {
|
|
this.bar.drawRoundedRect(0, 0, wantedWidth, wantedHeight, this.radius);
|
|
} else {
|
|
this.bar.drawRect(0, 0, wantedWidth, wantedHeight);
|
|
}
|
|
this.bar.endFill();
|
|
|
|
this.bar.x = width / 2 - this.bar.width / 2;
|
|
this.bar.y = height / 2 - this.bar.height / 2;
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Draws the active bar.
|
|
*
|
|
* @private
|
|
* @return {Progress} A reference to the progress for chaining.
|
|
*/
|
|
drawBarActive() {
|
|
|
|
const wantedWidth = this.bar.width - (2 * this.opts.padding);
|
|
const wantedHeight = this.bar.height - (2 * this.opts.padding);
|
|
|
|
const barActiveWidth = wantedWidth * this._progress / 100;
|
|
|
|
this.barActive.lineStyle(this.opts.strokeActiveWidth, this.opts.strokeActive, this.opts.strokeActiveAlpha);
|
|
this.barActive.beginFill(this.opts.fillActive, this.opts.fillActiveAlpha);
|
|
if (barActiveWidth > 0) {
|
|
if (this.radius > 1) {
|
|
this.barActive.drawRoundedRect(0, 0, barActiveWidth, wantedHeight, this.radius);
|
|
} else {
|
|
this.barActive.drawRect(0, 0, barActiveWidth, wantedHeight);
|
|
}
|
|
}
|
|
this.barActive.endFill();
|
|
|
|
this.barActive.x = this.opts.padding;
|
|
this.barActive.y = this.opts.padding;
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Shows the progress (sets his alpha values to 1).
|
|
*
|
|
* @return {Progress} A reference to the progress for chaining.
|
|
*/
|
|
show() {
|
|
TweenLite.to(this, this.theme.fast, {alpha: 1});
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Hides the progress (sets his alpha values to 1).
|
|
*
|
|
* @return {Progress} A reference to the progress for chaining.
|
|
*/
|
|
hide() {
|
|
TweenLite.to(this, this.theme.fast, {alpha: 0, onComplete: () => this.visible = false});
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Gets or sets the progress. Has to be a number between 0 and 100.
|
|
*
|
|
* @member {number}
|
|
*/
|
|
get progress() {
|
|
return this._progress
|
|
}
|
|
set progress(value) {
|
|
|
|
value = Math.round(value);
|
|
|
|
if (value < 0) {
|
|
value = 0;
|
|
}
|
|
|
|
if (value > 100) {
|
|
value = 100;
|
|
}
|
|
|
|
TweenLite.to(this, this.theme.normal, {
|
|
_progress: value,
|
|
onUpdate: () => this.draw(),
|
|
onComplete: () => {
|
|
if (value === 100 && this.opts.destroyOnComplete) {
|
|
TweenLite.to(this, this.theme.fast, {
|
|
alpha: 0,
|
|
onComplete: () => this.destroy({children: true})
|
|
});
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class that represents a PixiJS AbstractPopup.
|
|
* The class is used for various other Popup-like classes
|
|
* like Popup, Message, Tooltip...
|
|
*
|
|
* @class
|
|
* @abstract
|
|
* @extends PIXI.Graphics
|
|
* @see {@link http://pixijs.download/dev/docs/PIXI.Graphics.html|PIXI.Graphics}
|
|
*/
|
|
class AbstractPopup extends PIXI.Graphics {
|
|
|
|
/**
|
|
* Creates an instance of an AbstractPopup (only for internal use).
|
|
*
|
|
* @constructor
|
|
* @param {object} [opts] - An options object to specify to style and behaviour of the popup.
|
|
* @param {number} [opts.id=auto generated] - The id of the popup.
|
|
* @param {number} [opts.x=0] - The x position of the popup. Can be also set after creation with popup.x = 0.
|
|
* @param {number} [opts.y=0] - The y position of the popup. Can be also set after creation with popup.y = 0.
|
|
* @param {string|Theme} [opts.theme=dark] - The theme to use for this popup. Possible values are dark, light, red
|
|
* or a Theme object.
|
|
* @param {string|number|PIXI.Text} [opts.header] - The heading inside the popup as a string, a number (will be
|
|
* converted to a text) or as a PIXI.Text object.
|
|
* @param {string|number|PIXI.DisplayObject} [opts.content] - A text, a number (will be converted to a text) or
|
|
* an PIXI.DisplayObject as the content of the popup.
|
|
* @param {number} [opts.minWidth=320] - The minimum width of the popup.
|
|
* @param {number} [opts.minHeight=130] - The minimum height of the popup.
|
|
* @param {number} [opts.padding=Theme.padding] - The inner spacing (distance from header and content) the the border.
|
|
* @param {number} [opts.fill=Theme.fill] - The color of the button background as a hex value.
|
|
* @param {number} [opts.fillAlpha=Theme.fillAlpha] - The alpha value of the background.
|
|
* @param {number} [opts.stroke=Theme.stroke] - The color of the border as a hex value.
|
|
* @param {number} [opts.strokeWidth=Theme.strokeWidth] - The width of the border in pixel.
|
|
* @param {number} [opts.strokeAlpha=Theme.strokeAlpha] - The alpha value of the border.
|
|
* @param {object} [opts.headerStyle=Theme.textStyleLarge] - A textstyle object for the styling of the header. See PIXI.TextStyle
|
|
* for possible options.
|
|
* @param {object} [opts.textStyle=Theme.textStyleSmall] - A textstyle object for the styling of the text. See PIXI.TextStyle
|
|
* for possible options.
|
|
* @param {number} [opts.radius=Theme.radius] - The radius of the four corners of the popup (which is a rounded rectangle).
|
|
* @param {hiddenCallback} [opts.onHidden] - Executed when the popup gets hidden.
|
|
* @param {boolean} [opts.visible=true] - Is the popup initially visible (property visible)?
|
|
* @param {string} [opts.orientation] - When set to portrait, the popup cannot be displayed in landscape mode. When set
|
|
* to landscape, the popup cannot be displayed in portrait mode.
|
|
*/
|
|
constructor(opts = {}) {
|
|
|
|
super();
|
|
|
|
const theme = Theme.fromString(opts.theme);
|
|
this.theme = theme;
|
|
|
|
this.opts = Object.assign({}, {
|
|
id: PIXI.utils.uid(),
|
|
x: 0,
|
|
y: 0,
|
|
header: null, // null or null
|
|
content: null, // null or String or PIXI.DisplayObject
|
|
minWidth: 320,
|
|
minHeight: 130,
|
|
maxWidth: null,
|
|
padding: theme.padding,
|
|
fill: theme.fill,
|
|
fillAlpha: theme.fillAlpha,
|
|
stroke: theme.stroke,
|
|
strokeWidth: theme.strokeWidth,
|
|
strokeAlpha: theme.strokeAlpha,
|
|
headerStyle: theme.textStyleLarge,
|
|
textStyle: theme.textStyleSmall,
|
|
radius: theme.radius,
|
|
onHidden: null,
|
|
visible: true,
|
|
orientation: null
|
|
}, opts);
|
|
|
|
this.id = this.opts.id;
|
|
|
|
this.headerStyle = new PIXI.TextStyle(this.opts.headerStyle);
|
|
this.textStyle = new PIXI.TextStyle(this.opts.textStyle);
|
|
|
|
if (this.opts.maxWidth) {
|
|
this.headerStyle.wordWrap = true;
|
|
this.headerStyle.wordWrapWidth = this.opts.maxWidth - (2 * this.opts.padding);
|
|
|
|
this.textStyle.wordWrap = true;
|
|
this.textStyle.wordWrapWidth = this.opts.maxWidth - (2 * this.opts.padding);
|
|
}
|
|
|
|
this.alpha = 0;
|
|
this.visible = this.opts.visible;
|
|
|
|
this._header = null;
|
|
this._content = null;
|
|
|
|
// position
|
|
this.x = this.opts.x;
|
|
this.y = this.opts.y;
|
|
|
|
// padding
|
|
this.innerPadding = this.opts.padding * 1.5;
|
|
|
|
// interaction
|
|
//-----------------
|
|
this.interactive = true;
|
|
this.on('added', e => {
|
|
this.show();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Creates the framework and instantiates everything.
|
|
*
|
|
* @private
|
|
* @return {AbstractPopup} A reference to the popup for chaining.
|
|
*/
|
|
setup() {
|
|
|
|
// position
|
|
//-----------------
|
|
this.sy = this.opts.padding;
|
|
|
|
// header
|
|
//-----------------
|
|
if (this.opts.header != null) {
|
|
|
|
let header = null;
|
|
|
|
if (this.opts.header instanceof PIXI.Text) {
|
|
header = this.opts.header;
|
|
} else if (typeof this.opts.header === 'number') {
|
|
header = new PIXI.Text(this.opts.header.toString(), this.headerStyle);
|
|
} else {
|
|
header = new PIXI.Text(this.opts.header, this.headerStyle);
|
|
}
|
|
|
|
header.x = this.opts.padding;
|
|
header.y = this.sy;
|
|
|
|
this.addChild(header);
|
|
|
|
this.sy += header.height;
|
|
|
|
this._header = header;
|
|
}
|
|
|
|
if (this.opts.header && this.opts.content) {
|
|
this.sy += this.innerPadding;
|
|
}
|
|
|
|
// content
|
|
//-----------------
|
|
if (this.opts.content != null) {
|
|
|
|
let content = null;
|
|
|
|
if (typeof this.opts.content === 'string') {
|
|
content = new PIXI.Text(this.opts.content, this.textStyle);
|
|
} else if (typeof this.opts.content === 'number') {
|
|
content = new PIXI.Text(this.opts.content.toString(), this.textStyle);
|
|
} else {
|
|
content = this.opts.content;
|
|
}
|
|
|
|
content.x = this.opts.padding;
|
|
content.y = this.sy;
|
|
|
|
this.sy += content.height;
|
|
|
|
this.addChild(content);
|
|
|
|
this._content = content;
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Should be called to refresh the layout of the popup. Can be used after resizing.
|
|
*
|
|
* @return {AbstractPopup} A reference to the popup for chaining.
|
|
*/
|
|
layout() {
|
|
|
|
// wanted width & wanted height
|
|
//-----------------
|
|
const padding = this.opts.padding;
|
|
const size = this.getInnerSize();
|
|
const width = size.width + (2 * padding);
|
|
const height = size.height + (2 * padding);
|
|
|
|
this.wantedWidth = Math.max(width, this.opts.minWidth);
|
|
this.wantedHeight = Math.max(height, this.opts.minHeight);
|
|
|
|
if (this.opts.maxWidth) {
|
|
this.wantedWidth = Math.min(this.wantedWidth, this.opts.maxWidth);
|
|
}
|
|
|
|
if (this.opts.radius * 2 > this.wantedWidth) {
|
|
this.wantedWidth = this.opts.radius * 2;
|
|
}
|
|
|
|
if (this.opts.radius * 2 > this.wantedHeight) {
|
|
this.wantedHeight = this.opts.radius * 2;
|
|
}
|
|
|
|
switch (this.opts.orientation) {
|
|
case 'portrait':
|
|
if (this.wantedWidth > this.wantedHeight) {
|
|
this.wantedHeight = this.wantedWidth;
|
|
}
|
|
break
|
|
case 'landscape':
|
|
if (this.wantedHeight > this.wantedWidth) {
|
|
this.wantedWidth = this.wantedHeight;
|
|
}
|
|
break
|
|
}
|
|
|
|
this.draw();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Draws the canvas.
|
|
*
|
|
* @private
|
|
* @return {AbstractPopup} A reference to the popup for chaining.
|
|
*/
|
|
draw() {
|
|
|
|
const square = Math.round(this.wantedWidth) === Math.round(this.wantedHeight);
|
|
const diameter = Math.round(this.opts.radius * 2);
|
|
|
|
this.clear();
|
|
this.lineStyle(this.opts.strokeWidth, this.opts.stroke, this.opts.strokeAlpha);
|
|
this.beginFill(this.opts.fill, this.opts.fillAlpha);
|
|
if (square && diameter === this.wantedWidth) {
|
|
this.drawCircle(this.wantedWidth / 2, this.wantedHeight / 2, this.opts.radius);
|
|
} else {
|
|
this.drawRoundedRect(0, 0, this.wantedWidth, this.wantedHeight, this.opts.radius);
|
|
}
|
|
this.endFill();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Calculates the size of the children of the AbstractPopup.
|
|
* Cannot use getBounds() because it is not updated when children
|
|
* are removed.
|
|
*
|
|
* @private
|
|
* @returns {object} An JavaScript object width the keys width and height.
|
|
*/
|
|
getInnerSize() {
|
|
|
|
let width = 0;
|
|
let height = 0;
|
|
|
|
if (this._header) {
|
|
width = this._header.width;
|
|
height = this._header.height;
|
|
}
|
|
|
|
if (this._header && this._content) {
|
|
height += this.innerPadding;
|
|
}
|
|
|
|
if (this._content) {
|
|
width = Math.max(width, this._content.width);
|
|
height += this._content.height;
|
|
}
|
|
|
|
return {width, height}
|
|
}
|
|
|
|
/**
|
|
* Shows the popup (sets his alpha values to 1).
|
|
*
|
|
* @param {callback} [cb] - Executed when show animation was completed.
|
|
* @return {AbstractPopup} A reference to the popup for chaining.
|
|
*/
|
|
show(cb) {
|
|
|
|
TweenLite.to(this, this.theme.fast, {
|
|
alpha: 1,
|
|
onComplete: () => {
|
|
if (cb) {
|
|
cb.call(this);
|
|
}
|
|
}
|
|
});
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Hides the popup (sets his alpha values to 0).
|
|
*
|
|
* @param {callback} [cb] - Executed when hide animation was completed.
|
|
* @return {AbstractPopup} A reference to the popup for chaining.
|
|
*/
|
|
hide(cb) {
|
|
|
|
TweenLite.to(this, this.theme.fast, {
|
|
alpha: 0,
|
|
onComplete: () => {
|
|
this.visible = false;
|
|
if (cb) {
|
|
cb.call(this);
|
|
}
|
|
}
|
|
});
|
|
|
|
if (this.opts.onHidden) {
|
|
this.opts.onHidden.call(this, this);
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Sets or gets the header. The getter always returns a PIXI.Text object. The setter can receive
|
|
* a string, a number or a PIXI.Text object.
|
|
*
|
|
* @member {string|number|PIXI.Text}
|
|
*/
|
|
get header() {
|
|
return this._header
|
|
}
|
|
set header(value) {
|
|
if (this._header) {
|
|
this._header.destroy();
|
|
}
|
|
this.opts.header = value;
|
|
this.setup().layout();
|
|
}
|
|
|
|
/**
|
|
* Sets or gets the content. The getter always returns an PIXI.DisplayObject. The setter can receive
|
|
* a string, a number or a PIXI.DisplayObject.
|
|
*
|
|
* @member {string|number|PIXI.DisplayObject}
|
|
*/
|
|
get content() {
|
|
return this._content
|
|
}
|
|
set content(value) {
|
|
if (this._content) {
|
|
this._content.destroy();
|
|
}
|
|
this.opts.content = value;
|
|
this.setup().layout();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class that represents a PixiJS Tooltip.
|
|
*
|
|
* @example
|
|
* // Create the app
|
|
* const app = new PIXIApp({
|
|
* view: canvas,
|
|
* width: 900,
|
|
* height: 250
|
|
* }).setup().run()
|
|
*
|
|
* // Add an DisplayObject to the app
|
|
* const circle = new PIXI.Graphics()
|
|
* circle.beginFill(0x5251a3)
|
|
* circle.drawCircle(50, 50, 40)
|
|
* app.scene.addChild(circle)
|
|
*
|
|
* const tooltip = new Tooltip({
|
|
* object: circle,
|
|
* container: app.scene,
|
|
* content: 'Das Gesetz ist der Freund des Schwachen.'
|
|
* })
|
|
*
|
|
* @class
|
|
* @extends AbstractPopup
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/tooltip.html|DocTest}
|
|
*/
|
|
class Tooltip extends AbstractPopup {
|
|
|
|
/**
|
|
* Creates an instance of a Tooltip.
|
|
*
|
|
* @constructor
|
|
* @param {object} [opts] - An options object to specify to style and behaviour of the tooltip.
|
|
* @param {number} [opts.minWidth=0] - The minimum width of the tooltip.
|
|
* @param {number} [opts.minHeight=0] - The minimum height of the tooltip.
|
|
* @param {number} [opts.padding=Theme.padding / 2] - The inner spacing of the tooltip.
|
|
* @param {PIXI.DisplayObject} opts.object - The object, where the tooltip should be displayed.
|
|
* @param {PIXI.DisplayObject} [opts.container=object] - The container where the tooltip should be attached to.
|
|
* @param {number} [opts.offsetLeft=8] - The horizontal shift of the tooltip.
|
|
* @param {number} [opts.offsetTop=-8] - The vertical shift of the tooltip.
|
|
* @param {number} [opts.delay=0] - A delay, after which the tooltip should be opened.
|
|
*/
|
|
constructor(opts = {}) {
|
|
|
|
const theme = Theme.fromString(opts.theme);
|
|
|
|
opts = Object.assign({}, {
|
|
minWidth: 0,
|
|
minHeight: 0,
|
|
padding: theme.padding / 2,
|
|
object: null,
|
|
container: null,
|
|
offsetLeft: 8,
|
|
offsetTop: -8,
|
|
delay: 0
|
|
}, opts);
|
|
|
|
opts.container = opts.container || opts.object;
|
|
|
|
super(opts);
|
|
|
|
// setup
|
|
//-----------------
|
|
this.setup();
|
|
|
|
// layout
|
|
//-----------------
|
|
this.layout();
|
|
}
|
|
|
|
/**
|
|
* Creates children and instantiates everything.
|
|
*
|
|
* @private
|
|
* @return {Tooltip} A reference to the tooltip for chaining.
|
|
*/
|
|
setup() {
|
|
|
|
super.setup();
|
|
|
|
// bind events this
|
|
//-----------------
|
|
this.interactive = true;
|
|
|
|
let mouseoverTooltip = false;
|
|
|
|
this.on('mouseover', e => {
|
|
mouseoverTooltip = true;
|
|
});
|
|
|
|
this.on('mouseout', e => {
|
|
mouseoverTooltip = false;
|
|
if (!mouseoverObject) {
|
|
this.hide(() => {
|
|
this.opts.container.removeChild(this);
|
|
});
|
|
}
|
|
});
|
|
|
|
// bind events object
|
|
//-----------------
|
|
const object = this.opts.object;
|
|
object.interactive = true;
|
|
|
|
let mouseoverObject = false;
|
|
|
|
object.on('mouseover', e => {
|
|
|
|
this.timeout = window.setTimeout(() => {
|
|
mouseoverObject = true;
|
|
this.visible = true;
|
|
this.opts.container.addChild(this);
|
|
this.setPosition(e);
|
|
}, this.opts.delay * 1000);
|
|
});
|
|
|
|
object.on('mousemove', e => {
|
|
if (mouseoverObject) {
|
|
this.setPosition(e);
|
|
}
|
|
});
|
|
|
|
object.on('mouseout', e => {
|
|
mouseoverObject = false;
|
|
window.clearTimeout(this.timeout);
|
|
if (!mouseoverTooltip) {
|
|
this.hide(() => {
|
|
this.opts.container.removeChild(this);
|
|
});
|
|
}
|
|
});
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Calculates and sets the position of the tooltip.
|
|
*
|
|
* @private
|
|
* @return {Tooltip} A reference to the tooltip for chaining.
|
|
*/
|
|
setPosition(e) {
|
|
|
|
const position = e.data.getLocalPosition(this.opts.container);
|
|
|
|
this.x = position.x + this.opts.offsetLeft;
|
|
this.y = position.y + this.opts.offsetTop - this.height;
|
|
|
|
return this
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class that represents a PixiJS Badge.
|
|
*
|
|
* @example
|
|
* // Create the app
|
|
* const app = new PIXIApp({
|
|
* view: canvas,
|
|
* width: 900,
|
|
* height: 250
|
|
* }).setup().run()
|
|
*
|
|
* // Add an DisplayObject to the app
|
|
* const circle = new PIXI.Graphics()
|
|
* circle.beginFill(0x5251a3)
|
|
* circle.drawCircle(50, 50, 40)
|
|
* app.scene.addChild(circle)
|
|
*
|
|
* const badge1 = new Badge({
|
|
* object: circle,
|
|
* container: app.scene,
|
|
* content: 'Das Gesetz ist der Freund des Schwachen.'
|
|
* })
|
|
*
|
|
* @class
|
|
* @extends AbstractPopup
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/badge.html|DocTest}
|
|
*/
|
|
class Badge extends AbstractPopup {
|
|
|
|
/**
|
|
* Creates an instance of a Badge.
|
|
*
|
|
* @constructor
|
|
* @param {object} [opts] - An options object to specify to style and behaviour of the badge.
|
|
* @param {number} [opts.minWidth=0] - The minimum width of the badge.
|
|
* @param {number} [opts.minHeight=0] - The minimum height of the badge.
|
|
* @param {number} [opts.padding=Theme.padding / 2] - The inner spacing of the badge.
|
|
* @param {string|object} [opts.tooltip] - A string for the label of the tooltip or an object to configure the tooltip
|
|
* to display.
|
|
*/
|
|
constructor(opts = {}) {
|
|
|
|
const theme = Theme.fromString(opts.theme);
|
|
|
|
opts = Object.assign({}, {
|
|
minWidth: 0,
|
|
minHeight: 0,
|
|
padding: theme.padding / 2,
|
|
tooltip: null
|
|
}, opts);
|
|
|
|
super(opts);
|
|
|
|
this.tooltip = null;
|
|
|
|
// setup
|
|
//-----------------
|
|
this.setup();
|
|
|
|
// layout
|
|
//-----------------
|
|
this.layout();
|
|
}
|
|
|
|
/**
|
|
* Creates children and instantiates everything.
|
|
*
|
|
* @private
|
|
* @override
|
|
* @return {Badge} A reference to the badge for chaining.
|
|
*/
|
|
setup() {
|
|
|
|
super.setup();
|
|
|
|
// tooltip
|
|
//-----------------
|
|
if (this.opts.tooltip) {
|
|
if (typeof this.opts.tooltip === 'string') {
|
|
this.tooltip = new Tooltip({object: this, content: this.opts.tooltip});
|
|
} else {
|
|
this.opts.tooltip = Object.assign({}, {object: this}, this.opts.tooltip);
|
|
this.tooltip = new Tooltip(this.opts.tooltip);
|
|
}
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Should be called to refresh the layout of the badge. Can be used after resizing.
|
|
*
|
|
* @override
|
|
* @return {Badge} A reference to the badge for chaining.
|
|
*/
|
|
layout() {
|
|
|
|
super.layout();
|
|
|
|
this.content.x = this.width / 2 - this.content.width / 2 - this.opts.strokeWidth / 2;
|
|
this.content.y = this.height / 2 - this.content.height / 2 - this.opts.strokeWidth / 2;
|
|
|
|
return this
|
|
}
|
|
}
|
|
|
|
class Events$1 {
|
|
|
|
static stop(event) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
}
|
|
|
|
static extractPoint(event) {
|
|
switch (event.constructor.name) {
|
|
case 'TouchEvent':
|
|
for (let i = 0; i < event.targetTouches.length; i++) {
|
|
let t = event.targetTouches[i];
|
|
return { x: t.clientX, y: t.clientY }
|
|
}
|
|
break
|
|
default:
|
|
return { x: event.clientX, y: event.clientY }
|
|
}
|
|
}
|
|
|
|
static isCaptured(event) {
|
|
if (event.__capturedBy)
|
|
return true
|
|
return false
|
|
}
|
|
|
|
static capturedBy(event, obj) {
|
|
event.__capturedBy = obj;
|
|
}
|
|
|
|
static isMouseDown(event) {
|
|
// Attempts to clone the which attribute of events failed in WebKit. May
|
|
// be this is a bug or a security feature. Workaround: we introduce
|
|
// a mouseDownSubstitute attribute that can be assigned to cloned
|
|
// events after instantiation.
|
|
if (Reflect.has(event, 'mouseDownSubstitute'))
|
|
return event.mouseDownSubstitute
|
|
return event.buttons || event.which
|
|
}
|
|
|
|
static isSimulatedEvent(event) {
|
|
return Reflect.has(event, 'mouseDownSubstitute')
|
|
}
|
|
|
|
static isMouseRightClick(event) {
|
|
return event.buttons || event.which
|
|
}
|
|
|
|
static extractTouches(targets) {
|
|
let touches = [];
|
|
for (let i = 0; i < targets.length; i++) {
|
|
let t = targets[i];
|
|
touches.push({
|
|
targetSelector: this.selector(t.target),
|
|
identifier: t.identifier,
|
|
screenX: t.screenX,
|
|
screenY: t.screenY,
|
|
clientX: t.clientX,
|
|
clientY: t.clientY,
|
|
pageX: t.pageX,
|
|
pageY: t.pageY
|
|
});
|
|
}
|
|
return touches
|
|
}
|
|
|
|
static createTouchList(targets) {
|
|
let touches = [];
|
|
for (let i = 0; i < targets.length; i++) {
|
|
let t = targets[i];
|
|
let touchTarget = document.elementFromPoint(t.pageX, t.pageY);
|
|
let touch = new Touch(undefined, touchTarget, t.identifier,
|
|
t.pageX, t.pageY, t.screenX, t.screenY);
|
|
touches.push(touch);
|
|
}
|
|
return new TouchList(...touches)
|
|
}
|
|
|
|
static extractEvent(timestamp, event) {
|
|
let targetSelector = this.selector(event.target);
|
|
let infos = {
|
|
type: event.type,
|
|
time: timestamp,
|
|
constructor: event.constructor,
|
|
data: {
|
|
targetSelector: targetSelector,
|
|
view: event.view,
|
|
mouseDownSubstitute: event.buttons || event.which, // which cannot be cloned directly
|
|
bubbles: event.bubbles,
|
|
cancelable: event.cancelable,
|
|
screenX: event.screenX,
|
|
screenY: event.screenY,
|
|
clientX: event.clientX,
|
|
clientY: event.clientY,
|
|
layerX: event.layerX,
|
|
layerY: event.layerY,
|
|
pageX: event.pageX,
|
|
pageY: event.pageY,
|
|
ctrlKey: event.ctrlKey,
|
|
altKey: event.altKey,
|
|
shiftKey: event.shiftKey,
|
|
metaKey: event.metaKey
|
|
}
|
|
};
|
|
if (event.type.startsWith('touch')) {
|
|
// On Safari-WebKit the TouchEvent has layerX, layerY coordinates
|
|
let data = infos.data;
|
|
data.targetTouches = this.extractTouches(event.targetTouches);
|
|
data.changedTouches = this.extractTouches(event.changedTouches);
|
|
data.touches = this.extractTouches(event.touches);
|
|
}
|
|
if (event.type.startsWith('pointer')) {
|
|
let data = infos.data;
|
|
data.pointerId = event.pointerId;
|
|
data.pointerType = event.pointerType;
|
|
}
|
|
if (Events$1.debug) {
|
|
Events$1.extracted.push(this.toLine(event));
|
|
}
|
|
return infos
|
|
}
|
|
|
|
static cloneEvent(type, constructor, data) {
|
|
if (type.startsWith('touch')) {
|
|
// We need to find target from layerX, layerY
|
|
//var target = document.querySelector(data.targetSelector)
|
|
// elementFromPoint(data.layerX, data.layerY)
|
|
//data.target = target
|
|
data.targetTouches = this.createTouchList(data.targetTouches);
|
|
data.changedTouches = this.createTouchList(data.changedTouches);
|
|
data.touches = this.createTouchList(data.touches);
|
|
}
|
|
// We need to find target from pageX, pageY which are only
|
|
// available after construction. They seem to getter items.
|
|
|
|
let clone = Reflect.construct(constructor, [type, data]);
|
|
clone.mouseDownSubstitute = data.mouseDownSubstitute;
|
|
return clone
|
|
}
|
|
|
|
static simulateEvent(type, constructor, data) {
|
|
data.target = document.querySelector(data.targetSelector);
|
|
let clone = this.cloneEvent(type, constructor, data);
|
|
if (data.target != null) {
|
|
data.target.dispatchEvent(clone);
|
|
}
|
|
if (Events$1.debug) {
|
|
Events$1.simulated.push(this.toLine(clone));
|
|
}
|
|
}
|
|
|
|
static toLine(event) {
|
|
return `${event.type} #${event.target.id} ${event.clientX} ${event.clientY}`
|
|
let result = event.type;
|
|
let selector = this.selector(event.target);
|
|
result += ' selector: ' + selector;
|
|
if (event.target != document.querySelector(selector))
|
|
console.log('Cannot resolve', selector);
|
|
let keys = ['layerX', 'layerY', 'pageX', 'pageY', 'clientX', 'clientY'];
|
|
for (let key of keys) {
|
|
try {
|
|
result += ' ' + key + ':' + event[key];
|
|
}
|
|
catch (e) {
|
|
console.log('Invalid key: ' + key);
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
static compareExtractedWithSimulated() {
|
|
if (this.extracted.length != this.simulated.length) {
|
|
alert('Unequal length of extracted [' + this.extracted.length +
|
|
'] and simulated events [' + this.simulated.length + '].');
|
|
}
|
|
else {
|
|
for (let i = 0; i < this.extracted.length; i++) {
|
|
var extracted = this.extracted[i];
|
|
var simulated = this.simulated[i];
|
|
if (extracted != simulated) {
|
|
console.log('Events differ:' + extracted + '|' + simulated);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static selector(context) {
|
|
return OptimalSelect.select(context)
|
|
}
|
|
|
|
static reset() {
|
|
this.extracted = [];
|
|
this.simulated = [];
|
|
}
|
|
|
|
static resetSimulated() {
|
|
this.simulated = [];
|
|
}
|
|
|
|
static showExtractedEvents(event) {
|
|
if (!event.shiftKey) {
|
|
return
|
|
}
|
|
if (this.popup == null) {
|
|
let element = document.createElement('div');
|
|
Elements.setStyle(element, {
|
|
position: 'absolute',
|
|
width: '480px',
|
|
height: '640px',
|
|
overflow: 'auto',
|
|
backgroundColor: 'lightgray'
|
|
});
|
|
document.body.appendChild(element);
|
|
this.popup = element;
|
|
}
|
|
this.popup.innerHTML = '';
|
|
for (let line of this.extracted) {
|
|
let div = document.createElement('div');
|
|
div.innerHTML = line;
|
|
this.popup.appendChild(div);
|
|
}
|
|
let div = document.createElement('div');
|
|
div.innerHTML = '------------ Simulated -----------';
|
|
this.popup.appendChild(div);
|
|
for (let line of this.simulated) {
|
|
let div = document.createElement('div');
|
|
div.innerHTML = line;
|
|
this.popup.appendChild(div);
|
|
}
|
|
Elements.setStyle(this.popup,
|
|
{ left: event.clientX + 'px', top: event.clientY + 'px' });
|
|
}
|
|
}
|
|
|
|
Events$1.popup = null;
|
|
Events$1.debug = true;
|
|
Events$1.extracted = [];
|
|
Events$1.simulated = [];
|
|
Events$1.simulationRunning = false;
|
|
|
|
/**
|
|
* Callback for the button action.
|
|
*
|
|
* @callback actionCallback
|
|
* @param {object} event - The event object.
|
|
* @param {Button} button - A reference to the button (also this refers to the button).
|
|
*/
|
|
|
|
/**
|
|
* Callback for the button beforeAction.
|
|
*
|
|
* @callback beforeActionCallback
|
|
* @param {object} event - The event object.
|
|
* @param {Button} button - A reference to the button (also this refers to the button).
|
|
*/
|
|
|
|
/**
|
|
* Callback for the button afterAction.
|
|
*
|
|
* @callback afterActionCallback
|
|
* @param {object} event - The event object.
|
|
* @param {Button} button - A reference to the button (also this refers to the button).
|
|
*/
|
|
|
|
/**
|
|
* Class that represents a PixiJS Button.
|
|
*
|
|
* @example
|
|
* // Create the button
|
|
* const button = new Button({
|
|
* label: 'My Button',
|
|
* action: () => console.log('Button was clicked')
|
|
* })
|
|
*
|
|
* // Add the button to a DisplayObject
|
|
* app.scene.addChild(button)
|
|
*
|
|
* @class
|
|
* @extends PIXI.Container
|
|
* @see {@link http://pixijs.download/dev/docs/PIXI.Container.html|PIXI.Container}
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/button.html|DocTest}
|
|
*/
|
|
class Button extends PIXI.Container {
|
|
|
|
/**
|
|
* Creates an instance of a Button.
|
|
*
|
|
* @constructor
|
|
* @param {object} [opts] - An options object to specify to style and behaviour of the button.
|
|
* @param {number} [opts.id=auto generated] - The id of the button.
|
|
* @param {string} [opts.label] - The label of the button.
|
|
* @param {number} [opts.x=0] - The x position of the button. Can be also set after creation with button.x = 0.
|
|
* @param {number} [opts.y=0] - The y position of the button. Can be also set after creation with button.y = 0.
|
|
* @param {string|Theme} [opts.theme=dark] - The theme to use for this button. Possible values are dark, light, red
|
|
* or a Theme object.
|
|
* @param {number} [opts.minWidth=44] - The minimum width of the button.
|
|
* @param {number} [opts.minHeight=44] - The minimum height of the button.
|
|
* @param {number} [opts.padding=Theme.padding] - The inner spacing (distance from icon and/or label) to the border.
|
|
* @param {string|PIXI.DisplayObject} [opts.icon] - The icon of the button. Can be a predefined one, an URL or an PIXI.DisplayObject.
|
|
* @param {string|PIXI.DisplayObject} [opts.iconActive=icon] - The icon of the button when activated. Can be a predefined one, an URL or an PIXI.DisplayObject.
|
|
* @param {string} [opts.iconPosition=left] - The position of the icon in relation to the label. Can be left or right.
|
|
* @param {number} [opts.iconColor=Theme.iconColor] - The color of the icon (set by the tint property) as a hex value.
|
|
* @param {number} [opts.iconColorActive=Theme.iconColorActive] - The color of the icon when activated.
|
|
* @param {number} [opts.fill=Theme.fill] - The color of the button background as a hex value.
|
|
* @param {number} [opts.fillAlpha=Theme.fillAlpha] - The alpha value of the background.
|
|
* @param {number} [opts.fillActive=Theme.fillActive] - The color of the button background when activated.
|
|
* @param {number} [opts.fillActiveAlpha=Theme.fillActiveAlpha] - The alpha value of the background when activated.
|
|
* @param {number} [opts.stroke=Theme.stroke] - The color of the border as a hex value.
|
|
* @param {number} [opts.strokeWidth=Theme.strokeWidth] - The width of the border in pixel.
|
|
* @param {number} [opts.strokeAlpha=Theme.strokeAlpha] - The alpha value of the border.
|
|
* @param {number} [opts.strokeActive=Theme.strokeActive] - The color of the border when activated.
|
|
* @param {number} [opts.strokeActiveWidth=Theme.strokeActiveWidth] - The width of the border in pixel when activated.
|
|
* @param {number} [opts.strokeActiveAlpha=Theme.strokeActiveAlpha] - The alpha value of the border when activated.
|
|
* @param {object} [opts.textStyle=Theme.textStyle] - A textstyle object for the styling of the label. See PIXI.TextStyle
|
|
* for possible options.
|
|
* @param {number} [opts.textStyleActive=Theme.textStyleActive] - A textstyle object for the styling of the label when the
|
|
* button is activated. See PIXI.TextStyle for possible options.
|
|
* @param {string} [opts.style=default] - A shortcut for styling options. Possible values are default, link.
|
|
* @param {number} [opts.radius=Theme.radius] - The radius of the four corners of the button (which is a rounded rectangle).
|
|
* @param {boolean} [opts.disabled=false] - Is the button disabled? When disabled, the button has a lower alpha value
|
|
* and cannot be clicked (interactive is set to false).
|
|
* @param {boolean} [opts.active=false] - Is the button initially active?
|
|
* @param {actionCallback} [opts.action] - Executed when the button was triggered (by pointerup).
|
|
* @param {beforeActionCallback} [opts.beforeAction] - Executed before the main action is triggered.
|
|
* @param {afterActionCallback} [opts.afterAction] - Executed after the main action was triggered.
|
|
* @param {string} [opts.type=default] - The type of the button. Can be default or checkbox. When the type is
|
|
* checkbox, the active state is toggled automatically.
|
|
* @param {string} [opts.align=center] - The horizontal position of the label and the icon. Possible values are
|
|
* left, center and right. Only affects the style when the minWidth is bigger than the width of the icon and label.
|
|
* @param {string} [opts.verticalAlign=middle] - The vertical position of the label and the icon. Possible values are
|
|
* top, middle and button. Only affects the style when the minHeight is bigger than the height of the icon and label.
|
|
* @param {string|object} [opts.tooltip] - A string for the label of the tooltip or an object to configure the tooltip
|
|
* to display.
|
|
* @param {string|object} [opts.badge] - A string for the label of the badge or an object to configure the badge to display.
|
|
* If the parameter is an object, all badge options can be set plus the following:
|
|
* @param {string} [opts.badge.align=right] - The horizontal alignment of the badge. Possible values: left, center, right
|
|
* @param {string} [opts.badge.verticalAlign=top] - The vertical alignment of the badge. Possible values: top, middle, bottom
|
|
* @param {number} [opts.badge.offsetLeft=0] - The horizontal shift of the badge.
|
|
* @param {number} [opts.badge.offsetTop=0] - The vertical shift of the badge.
|
|
* @param {boolean} [opts.visible=true] - Is the button initially visible (property visible)?
|
|
*/
|
|
constructor(opts = {}) {
|
|
|
|
super();
|
|
|
|
const theme = Theme.fromString(opts.theme);
|
|
this.theme = theme;
|
|
|
|
this.opts = Object.assign({}, {
|
|
id: PIXI.utils.uid(),
|
|
label: null,
|
|
x: 0,
|
|
y: 0,
|
|
minWidth: 44,
|
|
minHeight: 44,
|
|
padding: theme.padding,
|
|
icon: undefined,
|
|
iconActive: undefined,
|
|
iconPosition: 'left',
|
|
iconColor: theme.iconColor,
|
|
iconColorActive: theme.iconColorActive,
|
|
fill: theme.fill,
|
|
fillAlpha: theme.fillAlpha,
|
|
fillActive: theme.fillActive,
|
|
fillActiveAlpha: theme.fillActiveAlpha,
|
|
stroke: theme.stroke,
|
|
strokeWidth: theme.strokeWidth,
|
|
strokeAlpha: theme.strokeAlpha,
|
|
strokeActive: theme.strokeActive,
|
|
strokeActiveWidth: theme.strokeActiveWidth,
|
|
strokeActiveAlpha: theme.strokeActiveAlpha,
|
|
textStyle: theme.textStyle,
|
|
textStyleActive: theme.textStyleActive,
|
|
style: 'default',
|
|
radius: theme.radius,
|
|
disabled: false,
|
|
active: false,
|
|
action: null,
|
|
beforeAction: null,
|
|
afterAction: null,
|
|
type: 'default',
|
|
align: 'center',
|
|
verticalAlign: 'middle',
|
|
tooltip: null,
|
|
badge: null,
|
|
visible: true
|
|
}, opts);
|
|
|
|
this.id = this.opts.id;
|
|
|
|
if (typeof this.opts.icon === 'undefined' && typeof this.opts.iconActive !== 'undefined') {
|
|
this.opts.icon = this.opts.iconActive;
|
|
} else if (typeof this.opts.icon !== 'undefined' && typeof this.opts.iconActive === 'undefined') {
|
|
this.opts.iconActive = this.opts.icon;
|
|
}
|
|
|
|
if (this.opts.style === 'link') {
|
|
Object.assign(this.opts, {strokeAlpha: 0, strokeActiveAlpha: 0, fillAlpha: 0, fillActiveAlpha: 0});
|
|
}
|
|
|
|
this._active = null;
|
|
this._disabled = null;
|
|
|
|
this.iconInactive = null;
|
|
this.iconActive = null;
|
|
this.text = null;
|
|
|
|
this.button = null;
|
|
this.content = null;
|
|
|
|
this.tooltip = null;
|
|
this.badge = null;
|
|
|
|
this.visible = this.opts.visible;
|
|
|
|
// setup
|
|
//-----------------
|
|
this.setup();
|
|
}
|
|
|
|
/**
|
|
* Captures an event to inform InteractionMapper about processed events.
|
|
*
|
|
* @param {event|PIXI.InteractionEvent} event - The PIXI event to capture.
|
|
*/
|
|
capture(event) {
|
|
Events$1.capturedBy(event.data.originalEvent, this);
|
|
}
|
|
|
|
/**
|
|
* Creates children and instantiates everything.
|
|
*
|
|
* @private
|
|
* @return {Button} A reference to the button for chaining.
|
|
*/
|
|
setup() {
|
|
|
|
// Button
|
|
//-----------------
|
|
let button = new PIXI.Graphics();
|
|
this.button = button;
|
|
this.addChild(button);
|
|
|
|
// Content
|
|
//-----------------
|
|
let content = new PIXI.Container();
|
|
this.content = content;
|
|
this.addChild(content);
|
|
|
|
// Text
|
|
//-----------------
|
|
if (this.opts.label) {
|
|
this.text = new PIXI.Text(this.opts.label, this.opts.textStyle);
|
|
}
|
|
|
|
// Icon
|
|
//-----------------
|
|
if (this.opts.icon) {
|
|
this.iconInactive = this.loadIcon(this.opts.icon, this.opts.iconColor);
|
|
}
|
|
|
|
if (this.opts.iconActive) {
|
|
this.iconActive = this.loadIcon(this.opts.iconActive, this.opts.iconColorActive);
|
|
}
|
|
|
|
// interaction
|
|
//-----------------
|
|
this.button.on('pointerover', e => {
|
|
this.capture(e);
|
|
TweenLite.to([this.button, this.content], this.theme.fast, {alpha: .83, overwrite: 'none'});
|
|
});
|
|
|
|
this.button.on('pointermove', e => {
|
|
this.capture(e);
|
|
});
|
|
|
|
this.button.on('pointerout', e => {
|
|
this.capture(e);
|
|
TweenLite.to([this.button, this.content], this.theme.fast, {alpha: 1, overwrite: 'none'});
|
|
});
|
|
|
|
this.button.on('pointerdown', e => {
|
|
//this.capture(e)
|
|
TweenLite.to([this.button, this.content], this.theme.fast, {alpha: .7, overwrite: 'none'});
|
|
});
|
|
|
|
this.button.on('pointerup', e => {
|
|
this.capture(e);
|
|
if (this.opts.beforeAction) {
|
|
this.opts.beforeAction.call(this, e, this);
|
|
}
|
|
|
|
if (this.opts.action) {
|
|
this.opts.action.call(this, e, this);
|
|
}
|
|
|
|
TweenLite.to([this.button, this.content], this.theme.fast, {alpha: .83, overwrite: 'none'});
|
|
|
|
if (this.opts.type === 'checkbox') {
|
|
this.active = !this.active;
|
|
}
|
|
|
|
if (this.opts.afterAction) {
|
|
this.opts.afterAction.call(this, e, this);
|
|
}
|
|
});
|
|
|
|
// disabled
|
|
//-----------------
|
|
this.disabled = this.opts.disabled;
|
|
|
|
// active
|
|
//-----------------
|
|
this.active = this.opts.active; // calls .layout()
|
|
|
|
// tooltip
|
|
//-----------------
|
|
if (this.opts.tooltip) {
|
|
if (typeof this.opts.tooltip === 'string') {
|
|
this.tooltip = new Tooltip({object: this, content: this.opts.tooltip});
|
|
} else {
|
|
this.opts.tooltip = Object.assign({}, {object: this}, this.opts.tooltip);
|
|
this.tooltip = new Tooltip(this.opts.tooltip);
|
|
}
|
|
}
|
|
|
|
// badge
|
|
//-----------------
|
|
if (this.opts.badge) {
|
|
let opts = Object.assign({}, {
|
|
align: 'right',
|
|
verticalAlign: 'top',
|
|
offsetLeft: 0,
|
|
offsetTop: 0
|
|
});
|
|
if (typeof this.opts.badge === 'string') {
|
|
opts = Object.assign(opts, {content: this.opts.badge});
|
|
} else {
|
|
opts = Object.assign(opts, this.opts.badge);
|
|
}
|
|
|
|
const badge = new Badge(opts);
|
|
|
|
switch (opts.align) {
|
|
case 'left':
|
|
badge.x = this.x - badge.width / 2 + opts.offsetLeft;
|
|
break
|
|
case 'center':
|
|
badge.x = this.x + this.width / 2 - badge.width / 2 + opts.offsetLeft;
|
|
break
|
|
case 'right':
|
|
badge.x = this.x + this.width - badge.width / 2 + opts.offsetLeft;
|
|
}
|
|
|
|
switch (opts.verticalAlign) {
|
|
case 'top':
|
|
badge.y = this.y - badge.height / 2 + opts.offsetTop;
|
|
break
|
|
case 'middle':
|
|
badge.y = this.y + this.height / 2 - badge.height / 2 + opts.offsetTop;
|
|
break
|
|
case 'bottom':
|
|
badge.y = this.y + this.height - badge.height / 2 + opts.offsetTop;
|
|
}
|
|
|
|
this.addChild(badge);
|
|
|
|
this.badge = badge;
|
|
}
|
|
|
|
// set position
|
|
//-----------------
|
|
this.position.set(this.opts.x, this.opts.y);
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Should be called to refresh the layout of the button. Can be used after resizing.
|
|
*
|
|
* @return {Button} A reference to the button for chaining.
|
|
*/
|
|
layout() {
|
|
|
|
// Clear content
|
|
//-----------------
|
|
this.removeChild(this.content);
|
|
this.content = new PIXI.Container();
|
|
this.addChild(this.content);
|
|
|
|
// Set the icon
|
|
//-----------------
|
|
let icon = null;
|
|
|
|
if (!this.active && this.iconInactive) {
|
|
icon = this.iconInactive;
|
|
} else if (this.active && this.iconActive) {
|
|
icon = this.iconActive;
|
|
}
|
|
|
|
// Set the text
|
|
//-----------------
|
|
if (this.text) {
|
|
this.text.position.set(0, 0);
|
|
}
|
|
|
|
// Width and Height
|
|
//-----------------
|
|
let width = 0;
|
|
if (icon && this.text) {
|
|
width = icon.width + this.text.width + 3 * this.opts.padding;
|
|
} else if (icon) {
|
|
width = icon.width + 2 * this.opts.padding;
|
|
} else if (this.text) {
|
|
width = this.text.width + 2 * this.opts.padding;
|
|
}
|
|
|
|
if (width < this.opts.minWidth) {
|
|
width = this.opts.minWidth;
|
|
}
|
|
|
|
let height = 0;
|
|
if (icon) {
|
|
height = icon.height + 2 * this.opts.padding;
|
|
} else if (this.text) {
|
|
height = this.text.height + 2 * this.opts.padding;
|
|
}
|
|
|
|
if (height < this.opts.minHeight) {
|
|
height = this.opts.minHeight;
|
|
}
|
|
|
|
this._width = width;
|
|
this._height = height;
|
|
|
|
// Position icon and text
|
|
//-----------------
|
|
if (icon && this.text) {
|
|
if (this.opts.iconPosition === 'right') {
|
|
icon.x = this.text.width + this.opts.padding;
|
|
} else {
|
|
this.text.x = icon.width + this.opts.padding;
|
|
}
|
|
this.content.addChild(icon, this.text);
|
|
} else if (icon) {
|
|
this.content.addChild(icon);
|
|
} else if (this.text) {
|
|
this.content.addChild(this.text);
|
|
}
|
|
|
|
this.layoutInnerContent();
|
|
this.layoutContent();
|
|
|
|
this.icon = icon;
|
|
|
|
// draw
|
|
//-----------------
|
|
this.draw();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Calculates the positions of the content children (icon and/or text).
|
|
*
|
|
* @private
|
|
* @return {Button} A reference to the button for chaining.
|
|
*/
|
|
layoutInnerContent() {
|
|
|
|
for (let child of this.content.children) {
|
|
switch (this.opts.verticalAlign) {
|
|
case 'top':
|
|
child.y = 0;
|
|
break
|
|
case 'middle':
|
|
child.y = this.content.height / 2 - child.height / 2;
|
|
break
|
|
case 'bottom':
|
|
child.y = this.content.height - child.height;
|
|
break
|
|
}
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Sets the horizontal and vertical position of the content.
|
|
* Uses the option keys "align" and "verticalAlign".
|
|
*
|
|
* @private
|
|
* @return {Button} A reference to the button for chaining.
|
|
*/
|
|
layoutContent() {
|
|
|
|
switch (this.opts.align) {
|
|
case 'left':
|
|
this.content.x = this.opts.padding;
|
|
break
|
|
case 'center':
|
|
this.content.x = ((this._width - this.content.width) / 2);
|
|
break
|
|
case 'right':
|
|
this.content.x = this._width - this.opts.padding - this.content.width;
|
|
break
|
|
}
|
|
|
|
switch (this.opts.verticalAlign) {
|
|
case 'top':
|
|
this.content.y = this.opts.padding;
|
|
break
|
|
case 'middle':
|
|
this.content.y = (this._height - this.content.height) / 2;
|
|
break
|
|
case 'bottom':
|
|
this.content.y = this._height - this.opts.padding - this.content.height;
|
|
break
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Draws the canvas.
|
|
*
|
|
* @private
|
|
* @return {Button} A reference to the button for chaining.
|
|
*/
|
|
draw() {
|
|
|
|
this.button.clear();
|
|
if (this.active) {
|
|
this.button.lineStyle(this.opts.strokeActiveWidth, this.opts.strokeActive, this.opts.strokeActiveAlpha);
|
|
this.button.beginFill(this.opts.fillActive, this.opts.fillActiveAlpha);
|
|
} else {
|
|
this.button.lineStyle(this.opts.strokeWidth, this.opts.stroke, this.opts.strokeAlpha);
|
|
this.button.beginFill(this.opts.fill, this.opts.fillAlpha);
|
|
}
|
|
this.button.drawRoundedRect(0, 0, this._width, this._height, this.opts.radius);
|
|
this.button.endFill();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Gets or sets the active state.
|
|
*
|
|
* @member {boolean}
|
|
*/
|
|
get active() {
|
|
return this._active
|
|
}
|
|
set active(value) {
|
|
|
|
this._active = value;
|
|
|
|
if (this._active) {
|
|
if (this.text) {
|
|
this.text.style = this.opts.textStyleActive;
|
|
}
|
|
} else {
|
|
if (this.text) {
|
|
this.text.style = this.opts.textStyle;
|
|
}
|
|
}
|
|
|
|
this.layout();
|
|
}
|
|
|
|
/**
|
|
* Gets or sets the disabled state. When disabled, the button cannot be clicked.
|
|
*
|
|
* @member {boolean}
|
|
*/
|
|
get disabled() {
|
|
return this._disabled
|
|
}
|
|
set disabled(value) {
|
|
|
|
this._disabled = value;
|
|
|
|
if (this._disabled) {
|
|
this.button.interactive = false;
|
|
this.button.buttonMode = false;
|
|
this.button.alpha = .5;
|
|
if (this.icon) {
|
|
this.icon.alpha = .5;
|
|
}
|
|
if (this.text) {
|
|
this.text.alpha = .5;
|
|
}
|
|
} else {
|
|
this.button.interactive = true;
|
|
this.button.buttonMode = true;
|
|
this.button.alpha = 1;
|
|
if (this.icon) {
|
|
this.icon.alpha = 1;
|
|
}
|
|
if (this.text) {
|
|
this.text.alpha = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Shows the button (sets his alpha values to 1).
|
|
*
|
|
* @return {Button} A reference to the button for chaining.
|
|
*/
|
|
show() {
|
|
|
|
this.opts.strokeAlpha = 1;
|
|
this.opts.strokeActiveAlpha = 1;
|
|
this.opts.fillAlpha = 1;
|
|
this.opts.fillActiveAlpha = 1;
|
|
|
|
this.layout();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Hides the button (sets his alpha values to 0).
|
|
*
|
|
* @return {Button} A reference to the button for chaining.
|
|
*/
|
|
hide() {
|
|
|
|
this.opts.strokeAlpha = 0;
|
|
this.opts.strokeActiveAlpha = 0;
|
|
this.opts.fillAlpha = 0;
|
|
this.opts.fillActiveAlpha = 0;
|
|
|
|
this.layout();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Loads an icon
|
|
*
|
|
* @private
|
|
* @param {string|PIXI.DisplayObject} icon - The icon to load.
|
|
* @param {number} color - The color of the icon (if not an PIXI.DisplayObject).
|
|
* @return {PIXI.DisplayObject} Return the icon as an PIXI.DisplayObject.
|
|
*/
|
|
loadIcon(icon, color) {
|
|
|
|
let displayObject = null;
|
|
|
|
if (icon instanceof PIXI.DisplayObject) {
|
|
displayObject = icon;
|
|
} else {
|
|
let size = 17;
|
|
if (this.text) {
|
|
size = this.text.height;
|
|
} else if (this.opts.minHeight) {
|
|
size = this.opts.minHeight - (2 * this.opts.padding);
|
|
}
|
|
|
|
const url = Button.iconIsUrl(icon) ? icon : `../../assets/icons/png/flat/${icon}.png`;
|
|
const iconTexture = PIXI.Texture.fromImage(url, true);
|
|
|
|
const sprite = new PIXI.Sprite(iconTexture);
|
|
sprite.tint = color;
|
|
sprite.width = size;
|
|
sprite.height = size;
|
|
|
|
displayObject = sprite;
|
|
}
|
|
|
|
return displayObject
|
|
}
|
|
|
|
/**
|
|
* Tests if an icon string is an url.
|
|
*
|
|
* @private
|
|
* @static
|
|
* @param {string} url - The url to test.
|
|
* @return {boolean} true if the url is an url to an image.
|
|
*/
|
|
static iconIsUrl(url) {
|
|
return /\.(png|svg|gif|jpg|jpeg|tif|tiff)$/i.test(url)
|
|
}
|
|
|
|
/**
|
|
* Gets or sets the color of the current icon (no matter how the status is). Changing the color, changes
|
|
* the tint property of the icon sprite.
|
|
*
|
|
* @member {number}
|
|
*/
|
|
get iconColor() {
|
|
return this.icon ? this.icon.tint : null
|
|
}
|
|
set iconColor(value) {
|
|
if (this.icon) {
|
|
this.icon.tint = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class that represents a PixiJS ButtonGroup.
|
|
*
|
|
* @example
|
|
* // Create the button group
|
|
* const buttonGroup = new ButtonGroup({
|
|
* buttons: [
|
|
* {label: 'Button 1', action: event => console.log(event)},
|
|
* {label: 'Button 2', action: event => console.log(event)},
|
|
* {label: 'Button 3', action: event => console.log(event)}
|
|
* ],
|
|
* minWidth: 100
|
|
* })
|
|
*
|
|
* // Add the button group to a DisplayObject
|
|
* app.scene.addChild(buttonGroup)
|
|
*
|
|
* @class
|
|
* @extends PIXI.Graphics
|
|
* @see {@link http://pixijs.download/dev/docs/PIXI.Graphics.html|PIXI.Graphics}
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/buttongroup.html|DocTest}
|
|
*/
|
|
class ButtonGroup extends PIXI.Graphics {
|
|
|
|
/**
|
|
* Creates an instance of a ButtonGroup.
|
|
*
|
|
* @constructor
|
|
* @param {object} [opts] - An options object to specify to style and behaviour of the button group.
|
|
* @param {number} [opts.id=auto generated] - The id of the button group.
|
|
* @param {number} [opts.x=0] - The x position of the button group. Can be also set after creation with buttonGroup.x = 0.
|
|
* @param {number} [opts.y=0] - The y position of the button group. Can be also set after creation with buttonGroup.y = 0.
|
|
* @param {object[]} [opts.buttons=[]] - An array of the buttons of the button group. One item of the array (one object)
|
|
* can have exactly the same properties as an Button object when instantiating a Button. If a property of the button group
|
|
* conflicts with a property of a button object, the value from the button object will be used.
|
|
* @param {string|Theme=} [opts.theme=dark] - The theme to use for this button group. Possible values are dark, light, red
|
|
* or a Theme object.
|
|
* @param {number} [opts.minWidth=44] - Button: The minimum width of one button.
|
|
* @param {number} [opts.minHeight=44] - Button: The minimum height of one button.
|
|
* @param {number} [opts.padding=Theme.padding] - Button: The inner spacing (distance from icon and/or label) the the border.
|
|
* @param {number} [opts.margin=Theme.margin] - The outer spacing (distance from one button to the previous/next button).
|
|
* @param {string} [opts.iconPosition=left] - Button: The position of the icon in relation to the label. Can be left or right.
|
|
* @param {number} [opts.iconColor=Theme.iconColor] - Button: The color of the icon (set by the tint property) as a hex value.
|
|
* @param {number} [opts.iconColorActive=Theme.iconColorActive] - Button: The color of the icon when activated.
|
|
* @param {number} [opts.fill=Theme.fill] - Button: The color of the button background as a hex value.
|
|
* @param {number} [opts.fillAlpha=Theme.fillAlpha] - Button: The alpha value of the background.
|
|
* @param {number} [opts.fillActive=Theme.fillActive] - Button: The color of the button background when activated.
|
|
* @param {number} [opts.fillActiveAlpha=Theme.fillActiveAlpha] - Button: The alpha value of the background when activated.
|
|
* @param {number} [opts.stroke=Theme.stroke] - Button: The color of the border as a hex value.
|
|
* @param {number} [opts.strokeWidth=Theme.strokeWidth] - Button: The width of the border in pixel.
|
|
* @param {number} [opts.strokeAlpha=Theme.strokeAlpha] - Button: The alpha value of the border.
|
|
* @param {number} [opts.strokeActive=Theme.strokeActive] - Button: The color of the border when activated.
|
|
* @param {number} [opts.strokeActiveWidth=Theme.strokeActiveWidth] - Button: The width of the border in pixel when activated.
|
|
* @param {number} [opts.strokeActiveAlpha=Theme.strokeActiveAlpha] - Button: The alpha value of the border when activated.
|
|
* @param {object} [opts.textStyle=Theme.textStyle] - Button: A textstyle object for the styling of the label. See PIXI.TextStyle
|
|
* for possible options.
|
|
* @param {number} [opts.textStyleActive=Theme.textStyleActive] - Button: A textstyle object for the styling of the label when the
|
|
* button is activated. See PIXI.TextStyle for possible options.
|
|
* @param {string} [opts.style=default] - A shortcut for styling options. Possible values are default, link.
|
|
* @param {number} [opts.radius=Theme.radius] - Button: The radius of the four corners of the button (which is a rounded rectangle).
|
|
* @param {boolean} [opts.disabled=false] - Is the button group disabled? When disabled, the button group has a lower alpha value
|
|
* and cannot be clicked (interactive of every button is set to false).
|
|
* @param {string} [opts.type=default] - The type of the button group. Can be default, checkbox or radio. When the type is
|
|
* checkbox, the active state is toggled for each button automatically. When the type is radio, only one button can
|
|
* be activated at the same time.
|
|
* @param {string} [opts.orientation=horizontal] - The orientation of the button group. Can be horizontal or vertical.
|
|
* @param {string} [opts.align=center] - Button: The horizontal position of the label and the icon. Possible values are
|
|
* left, center and right. Only affects the style when the minWidth is bigger than the width of the icon and label.
|
|
* @param {string} [opts.verticalAlign=middle] - Button: The vertical position of the label and the icon. Possible values are
|
|
* top, middle and bottom. Only affects the style when the minHeight is bigger than the height of the icon and label.
|
|
* @param {boolean} [opts.visible=true] - Is the button group initially visible (property visible)?
|
|
*/
|
|
constructor(opts = {}) {
|
|
|
|
super();
|
|
|
|
const theme = Theme.fromString(opts.theme);
|
|
this.theme = theme;
|
|
|
|
this.opts = Object.assign({}, {
|
|
id: PIXI.utils.uid(),
|
|
x: 0,
|
|
y: 0,
|
|
buttons: [],
|
|
minWidth: 44,
|
|
minHeight: 44,
|
|
padding: theme.padding,
|
|
margin: theme.margin,
|
|
iconPosition: 'left', // left, right
|
|
iconColor: theme.iconColor,
|
|
iconColorActive: theme.iconColorActive,
|
|
fill: theme.fill,
|
|
fillAlpha: theme.fillAlpha,
|
|
fillActive: theme.fillActive,
|
|
fillActiveAlpha: theme.fillActiveAlpha,
|
|
stroke: theme.stroke,
|
|
strokeWidth: theme.strokeWidth,
|
|
strokeAlpha: theme.strokeAlpha,
|
|
strokeActive: theme.strokeActive,
|
|
strokeActiveWidth: theme.strokeActiveWidth,
|
|
strokeActiveAlpha: theme.strokeActiveAlpha,
|
|
textStyle: theme.textStyle,
|
|
textStyleActive: theme.textStyleActive,
|
|
style: 'default',
|
|
radius: theme.radius,
|
|
disabled: null,
|
|
type: 'default', // default, checkbox, radio
|
|
orientation: 'horizontal',
|
|
align: 'center', // left, center, right
|
|
verticalAlign: 'middle', // top, middle, bottom
|
|
visible: true
|
|
}, opts);
|
|
|
|
this.buttons = [];
|
|
|
|
this._disabled = null;
|
|
|
|
this.visible = this.opts.visible;
|
|
|
|
// setup
|
|
//-----------------
|
|
this.setup();
|
|
|
|
// layout
|
|
//-----------------
|
|
this.layout();
|
|
}
|
|
|
|
/**
|
|
* Creates children and instantiates everything.
|
|
*
|
|
* @private
|
|
* @return {ButtonGroup} A reference to the button group for chaining.
|
|
*/
|
|
setup() {
|
|
|
|
// Buttons
|
|
//-----------------
|
|
let position = 0;
|
|
|
|
for (let it of this.opts.buttons) {
|
|
|
|
delete it.x;
|
|
delete it.y;
|
|
|
|
if (this.opts.orientation === 'horizontal') {
|
|
it.x = position;
|
|
} else {
|
|
it.y = position;
|
|
}
|
|
|
|
it.theme = it.theme || this.opts.theme;
|
|
it.minWidth = it.minWidth || this.opts.minWidth;
|
|
it.minHeight = it.minHeight || this.opts.minHeight;
|
|
it.padding = it.padding || this.opts.padding;
|
|
it.iconPosition = it.iconPosition || this.opts.iconPosition;
|
|
it.iconColor = it.iconColor || this.opts.iconColor;
|
|
it.iconColorActive = it.iconColorActive || this.opts.iconColorActive;
|
|
it.fill = it.fill || this.opts.fill;
|
|
it.fillAlpha = it.fillAlpha || this.opts.fillAlpha;
|
|
it.fillActive = it.fillActive || this.opts.fillActive;
|
|
it.fillActiveAlpha = it.fillActiveAlpha || this.opts.fillActiveAlpha;
|
|
it.stroke = it.stroke || this.opts.stroke;
|
|
it.strokeWidth = it.strokeWidth != null ? it.strokeWidth : this.opts.strokeWidth;
|
|
it.strokeAlpha = it.strokeAlpha != null ? it.strokeAlpha : this.opts.strokeAlpha;
|
|
it.strokeActive = it.strokeActive || this.opts.strokeActive;
|
|
it.strokeActiveWidth = it.strokeActiveWidth != null ? it.strokeActiveWidth : this.opts.strokeActiveWidth;
|
|
it.strokeActiveAlpha = it.strokeActiveAlpha != null ? it.strokeActiveAlpha : this.opts.strokeActiveAlpha;
|
|
it.textStyle = it.textStyle || this.opts.textStyle;
|
|
it.textStyleActive = it.textStyleActive || this.opts.textStyleActive;
|
|
it.style = it.style || this.opts.style;
|
|
it.radius = it.radius != null ? it.radius : this.opts.radius;
|
|
if (!it.type) {
|
|
switch (this.opts.type) {
|
|
case 'checkbox':
|
|
it.type = this.opts.type;
|
|
break
|
|
default:
|
|
it.type = 'default';
|
|
break
|
|
}
|
|
}
|
|
//it.type = it.type || this.opts.type || 'default'
|
|
it.align = it.align || this.opts.align;
|
|
it.verticalAlign = it.verticalAlign || this.opts.verticalAlign;
|
|
it.afterAction = (event, button) => {
|
|
if (this.opts.type === 'radio' && button.opts.type === 'default') {
|
|
this.buttons.forEach(it => {
|
|
if (it.opts.type === 'default') {
|
|
it.active = false;
|
|
}
|
|
});
|
|
|
|
if (button.opts.type === 'default') {
|
|
button.active = true;
|
|
}
|
|
}
|
|
};
|
|
|
|
if (it.tooltip) {
|
|
if (typeof it.tooltip === 'string') {
|
|
it.tooltip = {content: it.tooltip, container: this};
|
|
} else {
|
|
it.tooltip = Object.assign({}, {container: this}, it.tooltip);
|
|
}
|
|
}
|
|
|
|
let button = new Button(it);
|
|
|
|
this.addChild(button);
|
|
this.buttons.push(button);
|
|
|
|
position += (this.opts.orientation === 'horizontal' ? button.width : button.height) + this.opts.margin;
|
|
}
|
|
|
|
if (this.opts.orientation === 'vertical') {
|
|
const maxWidth = this.getMaxButtonWidth();
|
|
|
|
this.buttons.forEach(it => {
|
|
it.opts.minWidth = maxWidth;
|
|
it.layout();
|
|
});
|
|
}
|
|
|
|
// disabled
|
|
//-----------------
|
|
if (this.opts.disabled != null) {
|
|
this.disabled = this.opts.disabled;
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Should be called to refresh the layout of the button group. Can be used after resizing.
|
|
*
|
|
* @return {ButtonGroup} A reference to the button group for chaining.
|
|
*/
|
|
layout() {
|
|
|
|
// set position
|
|
//-----------------
|
|
this.position.set(this.opts.x, this.opts.y);
|
|
|
|
// draw
|
|
//-----------------
|
|
this.draw();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Draws the canvas.
|
|
*
|
|
* @private
|
|
* @return {ButtonGroup} A reference to the button group for chaining.
|
|
*/
|
|
draw() {
|
|
|
|
if (this.opts.margin === 0) {
|
|
|
|
this.buttons.forEach(it => it.hide());
|
|
|
|
this.clear();
|
|
this.lineStyle(this.opts.strokeWidth, this.opts.stroke, this.opts.strokeAlpha);
|
|
this.beginFill(this.opts.fill, this.opts.fillAlpha);
|
|
this.drawRoundedRect(0, 0, this.width, this.height, this.opts.radius);
|
|
|
|
// Draw borders
|
|
this.lineStyle(this.opts.strokeWidth, this.opts.stroke, this.opts.strokeAlpha / 2);
|
|
|
|
this.buttons.forEach((it, i) => {
|
|
if (i > 0) {
|
|
this.moveTo(it.x, it.y);
|
|
|
|
if (this.opts.orientation === 'horizontal') {
|
|
this.lineTo(it.x, it.height);
|
|
} else {
|
|
this.lineTo(it.width, it.y);
|
|
}
|
|
|
|
}
|
|
});
|
|
|
|
this.endFill();
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Gets or sets the disabled state. When disabled, no button of the button group can be clicked.
|
|
*
|
|
* @member {boolean}
|
|
*/
|
|
get disabled() {
|
|
return this._disabled
|
|
}
|
|
|
|
set disabled(value) {
|
|
|
|
this._disabled = value;
|
|
|
|
this.buttons.forEach(it => it.disabled = value);
|
|
}
|
|
|
|
/**
|
|
* Searches all buttons of the button group and returns the maximum width of one button.
|
|
*
|
|
* @private
|
|
* @return {number} The maximum with of a button of the button group.
|
|
*/
|
|
getMaxButtonWidth() {
|
|
|
|
let widths = this.buttons.map(it => it.width);
|
|
|
|
return Math.max(...widths)
|
|
}
|
|
|
|
/**
|
|
* Shows the button group (sets his alpha value to 1).
|
|
*
|
|
* @return {ButtonGroup} A reference to the button group for chaining.
|
|
*/
|
|
show() {
|
|
|
|
this.alpha = 1;
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Hides the button group (sets his alpha value to 0).
|
|
*
|
|
* @return {ButtonGroup} A reference to the button group for chaining.
|
|
*/
|
|
hide() {
|
|
|
|
this.alpha = 0;
|
|
|
|
return this
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class that represents a PixiJS InteractivePopup.
|
|
* The class is used for various other Popup-like classes
|
|
* like Popup, Message...
|
|
*
|
|
* @class
|
|
* @abstract
|
|
* @extends AbstractPopup
|
|
*/
|
|
class InteractivePopup extends AbstractPopup {
|
|
|
|
/**
|
|
* Creates an instance of an InteractivePopup (only for internal use).
|
|
*
|
|
* @constructor
|
|
* @param {object} [opts] - An options object to specify to style and behaviour of the popup.
|
|
* @param {boolean} [opts.closeOnPopup=false] - Should the popup be closed when the user clicks on the popup?
|
|
* @param {boolean} [opts.closeButton=true] - Should a close button be displayed on the upper right corner?
|
|
* @param {object} [opts.button] - A Button object to be display on the lower right corner.
|
|
* @param {object} [opts.buttonGroup] - A ButtonGroup object to be displayed on the lower right corner.
|
|
*/
|
|
constructor(opts = {}) {
|
|
|
|
opts = Object.assign({}, {
|
|
closeOnPopup: false,
|
|
closeButton: true,
|
|
button: null,
|
|
buttonGroup: null
|
|
}, opts);
|
|
|
|
super(opts);
|
|
|
|
this._closeButton = null;
|
|
this._buttons = null;
|
|
|
|
// padding
|
|
this.smallPadding = this.opts.padding / 2;
|
|
|
|
// setup
|
|
//-----------------
|
|
this.setup();
|
|
|
|
// layout
|
|
//-----------------
|
|
this.layout();
|
|
}
|
|
|
|
/**
|
|
* Creates the framework and instantiates everything.
|
|
*
|
|
* @private
|
|
* @return {AbstractPopup} A reference to the popup for chaining.
|
|
*/
|
|
setup() {
|
|
|
|
super.setup();
|
|
|
|
// interaction
|
|
//-----------------
|
|
this.on('pointerup', e => {
|
|
if (this.opts.closeOnPopup) {
|
|
this.hide();
|
|
} else {
|
|
e.stopPropagation();
|
|
}
|
|
});
|
|
|
|
// closeButton
|
|
//-----------------
|
|
if (this.opts.closeButton) {
|
|
let closeButton = PIXI.Sprite.fromImage('../../assets/icons/png/flat/close.png', true);
|
|
closeButton.width = this.headerStyle.fontSize;
|
|
closeButton.height = closeButton.width;
|
|
closeButton.tint = this.theme.color2;
|
|
// This is needed, because the closeButton belongs to the content. The popup must resize with the closeButton.
|
|
if (this._header) {
|
|
closeButton.x = this._header.width + this.innerPadding;
|
|
} else if (this._content) {
|
|
closeButton.x = this._content.width + this.innerPadding;
|
|
}
|
|
|
|
closeButton.interactive = true;
|
|
closeButton.buttonMode = true;
|
|
closeButton.on('pointerdown', e => {
|
|
this.hide();
|
|
});
|
|
|
|
this._closeButton = closeButton;
|
|
this.addChild(closeButton);
|
|
|
|
// maxWidth is set and a closeButton should be displayed
|
|
//-----------------
|
|
if (this.opts.maxWidth) {
|
|
const wordWrapWidth = this.opts.maxWidth - (2 * this.opts.padding) - this.smallPadding - this._closeButton.width;
|
|
if (this._header) {
|
|
this.headerStyle.wordWrapWidth = wordWrapWidth;
|
|
} else if (this._content) {
|
|
this.textStyle.wordWrapWidth = wordWrapWidth;
|
|
}
|
|
}
|
|
}
|
|
|
|
// buttons
|
|
//-----------------
|
|
if (this.opts.button || this.opts.buttonGroup) {
|
|
if (this.opts.button) {
|
|
this._buttons = new Button(Object.assign({textStyle: this.theme.textStyleSmall}, this.opts.button));
|
|
} else {
|
|
this._buttons = new ButtonGroup(Object.assign({textStyle: this.theme.textStyleSmall}, this.opts.buttonGroup));
|
|
}
|
|
this.addChild(this._buttons);
|
|
|
|
this._buttons.y = this.innerPadding + this.sy;
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Should be called to refresh the layout of the popup. Can be used after resizing.
|
|
*
|
|
* @return {AbstractPopup} A reference to the popup for chaining.
|
|
*/
|
|
layout() {
|
|
|
|
super.layout();
|
|
|
|
// closeButton
|
|
//-----------------
|
|
if (this.opts.closeButton) {
|
|
this._closeButton.x = this.wantedWidth - this.smallPadding - this._closeButton.width;
|
|
this._closeButton.y = this.smallPadding;
|
|
}
|
|
|
|
// buttons
|
|
//-----------------
|
|
if (this._buttons) {
|
|
this._buttons.x = this.wantedWidth - this.opts.padding - this._buttons.width;
|
|
this._buttons.y = this.wantedHeight - this.opts.padding - this._buttons.height;
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Calculates the size of the children of the AbstractPopup.
|
|
* Cannot use getBounds() because it is not updated when children
|
|
* are removed.
|
|
*
|
|
* @private
|
|
* @override
|
|
* @returns {object} An JavaScript object width the keys width and height.
|
|
*/
|
|
getInnerSize() {
|
|
|
|
let size = super.getInnerSize();
|
|
|
|
if (this._closeButton) {
|
|
size.width += this.smallPadding + this._closeButton.width;
|
|
}
|
|
|
|
if (this._buttons) {
|
|
size.width = Math.max(size.width, this._buttons.x + this._buttons.width);
|
|
size.height += this.innerPadding + this._buttons.height;
|
|
}
|
|
|
|
return size
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class that represents a PixiJS Popup.
|
|
*
|
|
* @example
|
|
* // Create the popup
|
|
* const popup = new Popup({
|
|
* header: 'Goethe',
|
|
* content: 'Man kann die Erfahrung nicht früh genug machen, wie entbehrlich man in der Welt ist.'
|
|
* })
|
|
*
|
|
* // Add the popup to a DisplayObject
|
|
* app.scene.addChild(popup)
|
|
*
|
|
* @class
|
|
* @extends InteractivePopup
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/popup.html|DocTest}
|
|
*/
|
|
class Popup extends InteractivePopup {
|
|
|
|
/**
|
|
* Creates an instance of a Popup.
|
|
*
|
|
* @constructor
|
|
* @param {object} [opts] - An options object to specify to style and behaviour of the popup.
|
|
* @param {boolean} [opts.closeButton=false] - Should a close button be displayed on the upper right corner?
|
|
* @param {number} [opts.minWidth=0] - The minimum width of the popup.
|
|
* @param {number} [opts.minHeight=0] - The minimum height of the popup.
|
|
*/
|
|
constructor(opts = {}) {
|
|
|
|
opts = Object.assign({}, {
|
|
closeButton: false,
|
|
minWidth: 0,
|
|
minHeight: 0
|
|
}, opts);
|
|
|
|
super(opts);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class that represents a PixiJS Modal.
|
|
*
|
|
* @example
|
|
* // Create the button and the modal when clicked
|
|
* const button = new Button({
|
|
* label: 'Show Modal',
|
|
* action: e => {
|
|
* const modal = new Modal({
|
|
* app: app,
|
|
* header: 'This is the header',
|
|
* content: 'This is the text.'
|
|
* })
|
|
* app.scene.addChild(modal)
|
|
* }
|
|
* })
|
|
*
|
|
* // Add the button to a DisplayObject
|
|
* app.scene.addChild(button)
|
|
*
|
|
* @class
|
|
* @extends PIXI.Container
|
|
* @extends InteractivePopup
|
|
* @see {@link http://pixijs.download/dev/docs/PIXI.Container.html|PIXI.Container}
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/modal.html|DocTest}
|
|
*/
|
|
class Modal extends PIXI.Container {
|
|
|
|
/**
|
|
* Creates an instance of a Modal.
|
|
*
|
|
* @constructor
|
|
* @param {object} [opts] - An options object to specify to style and behaviour of the modal.
|
|
* @param {number} [opts.id=auto generated] - The id of the modal.
|
|
* @param {PIXIApp} [opts.app=window.app] - The app where the modal belongs to.
|
|
* @param {number} [opts.backgroundFill=Theme.background] - The color of the background.
|
|
* @param {number} [opts.backgroundFillAlpha=0.6] - The opacity of the background.
|
|
* @param {boolean} [opts.closeOnBackground=true] - Should the modal be closed when the user clicks the
|
|
* background?
|
|
* @param {boolean} [opts.visible=true] - Is the modal initially visible (property visible)?
|
|
*/
|
|
constructor(opts = {}) {
|
|
|
|
super();
|
|
|
|
const theme = Theme.fromString(opts.theme);
|
|
this.theme = theme;
|
|
|
|
this.opts = Object.assign({}, {
|
|
id: PIXI.utils.uid(),
|
|
app: window.app,
|
|
backgroundFill: theme.background,
|
|
backgroundFillAlpha: .6,
|
|
closeOnBackground: true,
|
|
visible: true
|
|
}, opts);
|
|
|
|
this.id = this.opts.id;
|
|
|
|
this.background = null;
|
|
this.popup = null;
|
|
|
|
this.alpha = 0;
|
|
this.visible = this.opts.visible;
|
|
|
|
// setup
|
|
//-----------------
|
|
this.setup();
|
|
|
|
// layout
|
|
//-----------------
|
|
this.layout();
|
|
}
|
|
|
|
/**
|
|
* Creates children and instantiates everything.
|
|
*
|
|
* @private
|
|
* @return {Modal} A reference to the modal for chaining.
|
|
*/
|
|
setup() {
|
|
|
|
// interaction
|
|
//-----------------
|
|
this.interactive = true;
|
|
this.on('added', e => {
|
|
if (this.visible) {
|
|
this.show();
|
|
}
|
|
});
|
|
|
|
// background
|
|
//-----------------
|
|
let background = new PIXI.Graphics();
|
|
this.background = background;
|
|
this.addChild(this.background);
|
|
|
|
if (this.opts.closeOnBackground) {
|
|
background.interactive = true;
|
|
background.on('pointerup', e => {
|
|
this.hide();
|
|
});
|
|
}
|
|
|
|
// popup
|
|
//-----------------
|
|
const popupOpts = Object.assign({}, this.opts, {
|
|
visible: true,
|
|
onHidden: () => {
|
|
this.hide();
|
|
}
|
|
});
|
|
let popup = new InteractivePopup(popupOpts);
|
|
this.popup = popup;
|
|
this.addChild(popup);
|
|
popup.show();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Should be called to refresh the layout of the modal. Can be used after resizing.
|
|
*
|
|
* @return {Modal} A reference to the modal for chaining.
|
|
*/
|
|
layout() {
|
|
|
|
const width = this.opts.app.size.width;
|
|
const height = this.opts.app.size.height;
|
|
|
|
// background
|
|
//-----------------
|
|
this.background.clear();
|
|
this.background.beginFill(this.opts.backgroundFill, this.opts.backgroundFillAlpha);
|
|
this.background.drawRect(0, 0, width, height);
|
|
this.background.endFill();
|
|
|
|
// position
|
|
this.popup.x = width / 2 - this.popup.width / 2;
|
|
this.popup.y = height / 2 - this.popup.height / 2;
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Shows the modal (sets his alpha values to 1).
|
|
*
|
|
* @return {Modal} A reference to the modal for chaining.
|
|
*/
|
|
show() {
|
|
TweenLite.to(this, this.theme.fast, {alpha: 1, onStart: () => this.visible = true});
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Hides the modal (sets his alpha values to 0).
|
|
*
|
|
* @return {Modal} A reference to the modal for chaining.
|
|
*/
|
|
hide() {
|
|
TweenLite.to(this, this.theme.fast, {alpha: 0, onComplete: () => this.visible = false});
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Sets or gets the header. The getter always returns a PIXI.Text object. The setter can receive
|
|
* a string or a PIXI.Text object.
|
|
*
|
|
* @member {string|PIXI.Text}
|
|
*/
|
|
get header() {
|
|
return this.popup.header
|
|
}
|
|
set header(value) {
|
|
this.opts.header = value;
|
|
this.background.destroy();
|
|
this.popup.destroy();
|
|
this.setup().layout();
|
|
}
|
|
|
|
/**
|
|
* Sets or gets the content. The getter always returns an PIXI.DisplayObject. The setter can receive
|
|
* a string or a PIXI.DisplayObject.
|
|
*
|
|
* @member {string|PIXI.DisplayObject}
|
|
*/
|
|
get content() {
|
|
return this.popup.content
|
|
}
|
|
set content(value) {
|
|
this.opts.content = value;
|
|
this.background.destroy();
|
|
this.popup.destroy();
|
|
this.setup().layout();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class that represents a Message. A message pops up and disappears after a specific amount of time.
|
|
*
|
|
* @example
|
|
* // Create the PixiJS App
|
|
* const app = new PIXIApp({
|
|
* view: canvas,
|
|
* width: 900,
|
|
* height: 250
|
|
* }).setup().run()
|
|
*
|
|
* // Create a button
|
|
* let button = new Button({
|
|
* label: 'Click me',
|
|
* action: e => {
|
|
* const message = new Message({
|
|
* app: app,
|
|
* header: 'Header',
|
|
* content: 'Text.'
|
|
* })
|
|
* app.scene.addChild(message)
|
|
* }
|
|
* })
|
|
*
|
|
* // Add the button to the scene
|
|
* app.scene.addChild(button)
|
|
*
|
|
* @class
|
|
* @extends InteractivePopup
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/message.html|DocTest}
|
|
*/
|
|
class Message extends InteractivePopup {
|
|
|
|
/**
|
|
* Creates an instance of a Message.
|
|
*
|
|
* @constructor
|
|
* @param {object} [opts] - An options object to specify to style and behaviour of the message.
|
|
* @param {PIXIApp} [opts.app=window.app] - The PIXIApp where this message belongs to.
|
|
* @param {boolean} [opts.closeButton=false] - Should a close button be displayed in the upper right corner?
|
|
* @param {number} [opts.minWidth=280] - The minimum width of the message box. Automatically expands with the content.
|
|
* @param {number} [opts.minHeight=100] - The minimum height of the message box. Automatically expands with the content.
|
|
* @param {number} [opts.margin=Theme.margin] - The outer spacing of the message box.
|
|
* @param {string} [opts.align=right] - The horizontal position of the message box relative to the app. Possible
|
|
* values are left, center, right.
|
|
* @param {string} [opts.verticalAlign=top] - The vertical position of the message box relative to the app. Possible
|
|
* values are top, middle, bottom.
|
|
* @param {number} [opts.duration=5] - The duration in seconds when the message box should disappear.
|
|
* @param {boolean} [opts.autoClose=true] - Should the message box be closed automatically?
|
|
* @param {number} [opts.closeDuration=Theme.fast] - The duration in seconds of the closing of the message box.
|
|
*/
|
|
constructor(opts = {}) {
|
|
|
|
const theme = Theme.fromString(opts.theme);
|
|
|
|
opts = Object.assign({}, {
|
|
app: window.app,
|
|
closeButton: false,
|
|
minWidth: 280,
|
|
minHeight: 100,
|
|
margin: theme.margin,
|
|
align: 'right', // left, center, right
|
|
verticalAlign: 'top', // top, middle, bottom
|
|
duration: 5,
|
|
autoClose: true,
|
|
closeDuration: theme.fast
|
|
}, opts);
|
|
|
|
super(opts);
|
|
}
|
|
|
|
/**
|
|
* Relayouts the position of the message box.
|
|
*
|
|
* @return {Message} Returns the message box for chaining.
|
|
*/
|
|
layout() {
|
|
|
|
super.layout();
|
|
|
|
// horizontal
|
|
switch (this.opts.align) {
|
|
case 'left':
|
|
this.x = this.opts.margin;
|
|
break
|
|
case 'center':
|
|
this.x = (this.opts.app.size.width / 2) - (this.width / 2);
|
|
break
|
|
case 'right':
|
|
this.x = this.opts.app.size.width - this.opts.margin - this.width;
|
|
break
|
|
}
|
|
|
|
// vertical
|
|
switch (this.opts.verticalAlign) {
|
|
case 'top':
|
|
this.y = this.opts.margin;
|
|
break
|
|
case 'middle':
|
|
this.y = (this.opts.app.size.height / 2) - (this.height / 2);
|
|
break
|
|
case 'bottom':
|
|
this.y = this.opts.app.size.height - this.opts.margin - this.height;
|
|
break
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Shows the message box.
|
|
*
|
|
* @private
|
|
*/
|
|
show() {
|
|
|
|
super.show();
|
|
|
|
if (this.opts.autoClose) {
|
|
window.setTimeout(() => {
|
|
this.hide();
|
|
}, this.opts.duration * 1000);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* globals WebKitPoint */
|
|
|
|
/** Tests whether an object is empty
|
|
* @param {Object} obj - the object to be tested
|
|
* @return {boolean}
|
|
*/
|
|
function isEmpty(obj) {
|
|
// > isEmpty({})
|
|
// true
|
|
for (let i in obj) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
function lerp(start, stop, amt) {
|
|
return amt * (stop - start) + start
|
|
}
|
|
|
|
|
|
// Returns a function, that, as long as it continues to be invoked, will not
|
|
// be triggered. The function will be called after it stops being called for
|
|
// N milliseconds. If `immediate` is passed, trigger the function on the
|
|
// leading edge, instead of the trailing.
|
|
// Taken from: https://davidwalsh.name/essential-javascript-functions
|
|
function debounce(func, wait, immediate) {
|
|
let timeout;
|
|
return function () {
|
|
let context = this,
|
|
args = arguments;
|
|
let later = function () {
|
|
timeout = null;
|
|
if (!immediate) func.apply(context, args);
|
|
};
|
|
let callNow = immediate && !timeout;
|
|
clearTimeout(timeout);
|
|
timeout = setTimeout(later, wait);
|
|
if (callNow) func.apply(context, args);
|
|
}
|
|
}
|
|
|
|
/** Returns an id that is guaranteed to be unique within the livetime of the
|
|
* application
|
|
* @return {string}
|
|
*/
|
|
let _idGenerator = 0;
|
|
function getId() {
|
|
return 'id' + _idGenerator++
|
|
}
|
|
|
|
class Dates {
|
|
|
|
static create(fullYear, month, day) {
|
|
return new Date(Date.UTC(fullYear, month, day))
|
|
}
|
|
|
|
static daysInMonth(date) {
|
|
return new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate()
|
|
}
|
|
|
|
static startYearRange(date) {
|
|
return new Date(Date.UTC(date.getFullYear() - 1, 11, 31, 23, 59, 59, 999))
|
|
}
|
|
|
|
static endYearRange(date) {
|
|
return new Date(Date.UTC(date.getFullYear() + 1, 0, 1))
|
|
}
|
|
|
|
static prevYear(date, offset = 1) {
|
|
return this.create(date.getFullYear() - offset, 0, 1)
|
|
}
|
|
|
|
static nextYear(date, offset = 1) {
|
|
return this.create(date.getFullYear() + offset, 0, 1)
|
|
}
|
|
|
|
static nextMonth(date) {
|
|
return this.create(date.getFullYear(), date.getMonth() + 1, 1)
|
|
}
|
|
|
|
static nextDay(date) {
|
|
return this.create(
|
|
date.getFullYear(),
|
|
date.getMonth(),
|
|
date.getDate() + 1
|
|
)
|
|
}
|
|
|
|
static nextHour(date) {
|
|
// See http://stackoverflow.com/questions/1050720/adding-hours-to-javascript-date-object
|
|
return new Date(date.getTime() + 60 * 60 * 1000)
|
|
}
|
|
|
|
static nextMinute(date) {
|
|
// See above
|
|
return new Date(date.getTime() + 60 * 1000)
|
|
}
|
|
|
|
static nextSecond(date) {
|
|
// See above
|
|
return new Date(date.getTime() + 1000)
|
|
}
|
|
|
|
static nextMillisecond(date) {
|
|
// See above
|
|
return new Date(date.getTime() + 1)
|
|
}
|
|
|
|
static *iterYears(start, end) {
|
|
let date = this.create(start.getFullYear(), 0, 1);
|
|
while (date <= end) {
|
|
yield date;
|
|
date = this.nextYear(date);
|
|
}
|
|
yield date;
|
|
}
|
|
|
|
static *iterMonths(year, limit = 12) {
|
|
let month = 0;
|
|
while (month < limit) {
|
|
let date = this.create(year.getFullYear(), month, 1);
|
|
yield date;
|
|
month += 1;
|
|
}
|
|
}
|
|
|
|
static *iterMonthsOfYears(years) {
|
|
for (let year of years) {
|
|
for (let month of this.iterMonths(year)) {
|
|
yield month;
|
|
}
|
|
}
|
|
}
|
|
|
|
static *iterDays(month) {
|
|
let day = 1;
|
|
let limit = Dates.daysInMonth(month);
|
|
while (day <= limit) {
|
|
let date = this.create(month.getFullYear(), month.getMonth(), day);
|
|
yield date;
|
|
day += 1;
|
|
}
|
|
}
|
|
|
|
static *iterDaysOfMonths(months) {
|
|
for (let month of months) {
|
|
for (let day of this.iterDays(month)) {
|
|
yield day;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/* Color conversion functions */
|
|
|
|
class Colors {
|
|
// http://stackoverflow.com/questions/5623838/rgb-to-hex-and-hex-to-rgb
|
|
|
|
static rgb2num(red, green, blue) {
|
|
let rgb = blue | (green << 8) | (red << 16);
|
|
return 0x000000 + rgb
|
|
}
|
|
|
|
static rgb2hex(red, green, blue) {
|
|
let rgb = blue | (green << 8) | (red << 16);
|
|
return '#' + (0x1000000 + rgb).toString(16).slice(1)
|
|
}
|
|
|
|
static hex2rgb(hex) {
|
|
// long version
|
|
let r = hex.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
|
|
if (r) {
|
|
return r.slice(1, 4).map(x => {
|
|
return parseInt(x, 16)
|
|
})
|
|
}
|
|
// short version
|
|
r = hex.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/i);
|
|
if (r) {
|
|
return r.slice(1, 4).map(x => {
|
|
return 0x11 * parseInt(x, 16)
|
|
})
|
|
}
|
|
return null
|
|
}
|
|
|
|
static rgb(r, g, b) {
|
|
return { r, g, b }
|
|
}
|
|
|
|
static string2hex(str) {
|
|
return parseInt('0x' + str.slice(1))
|
|
}
|
|
|
|
static lerp(rgb1, rgb2, amount) {
|
|
return {
|
|
r: Math.round(lerp(rgb1.r, rgb2.r, amount)),
|
|
g: Math.round(lerp(rgb1.g, rgb2.g, amount)),
|
|
b: Math.round(lerp(rgb1.b, rgb2.b, amount))
|
|
}
|
|
}
|
|
|
|
static get violet() {
|
|
return Colors.rgb2num(89, 34, 131)
|
|
}
|
|
|
|
static get steelblue() {
|
|
return Colors.rgb2num(0, 130, 164)
|
|
}
|
|
|
|
static get ochre() {
|
|
return Colors.rgb2num(181, 157, 0)
|
|
}
|
|
|
|
static get turquoise() {
|
|
return Colors.rgb2num(34, 164, 131)
|
|
}
|
|
|
|
static get eminence() {
|
|
return Colors.rgb2num(150, 60, 134)
|
|
}
|
|
|
|
static random() {
|
|
let r = Math.round(Math.random() * 255);
|
|
let g = Math.round(Math.random() * 255);
|
|
let b = Math.round(Math.random() * 255);
|
|
return Colors.rgb2num(r, g, b)
|
|
}
|
|
}
|
|
|
|
class Cycle extends Array {
|
|
constructor(...items) {
|
|
super();
|
|
for (let item of items) {
|
|
this.push(item);
|
|
}
|
|
this.index = 0;
|
|
}
|
|
|
|
next() {
|
|
if (this.index == this.length) {
|
|
this.index = 0;
|
|
}
|
|
return this[this.index++]
|
|
}
|
|
|
|
current() {
|
|
if (this.index === this.length) {
|
|
this.index = 0;
|
|
}
|
|
return this[this.index]
|
|
}
|
|
}
|
|
|
|
/** Static methods to compute 2D points with x and y coordinates.
|
|
*/
|
|
class Points {
|
|
static length(a) {
|
|
return Math.sqrt(a.x * a.x + a.y * a.y)
|
|
}
|
|
|
|
static normalize(p) {
|
|
let len = this.length(p);
|
|
return this.multiplyScalar(p, 1 / len)
|
|
}
|
|
|
|
static mean(a, b) {
|
|
return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 }
|
|
}
|
|
|
|
static subtract(a, b) {
|
|
return { x: a.x - b.x, y: a.y - b.y }
|
|
}
|
|
|
|
static multiply(a, b) {
|
|
return { x: a.x * b.x, y: a.y * b.y }
|
|
}
|
|
|
|
static divide(a, b) {
|
|
return { x: a.x / b.x, y: a.y / b.y }
|
|
}
|
|
|
|
static multiplyScalar(a, b) {
|
|
return { x: a.x * b, y: a.y * b }
|
|
}
|
|
|
|
static add(a, b) {
|
|
return { x: a.x + b.x, y: a.y + b.y }
|
|
}
|
|
|
|
static negate(p) {
|
|
return { x: -p.x, y: -p.y }
|
|
}
|
|
|
|
static angle(p1, p2) {
|
|
return Math.atan2(p1.y - p2.y, p1.x - p2.x)
|
|
}
|
|
|
|
static normalizedAngle(p1, p2) {
|
|
return Angle.normalize(this.angle(p1, p2))
|
|
}
|
|
|
|
static normalized2Angle(p1, p2) {
|
|
return Angle.normalize2(this.angle(p1, p2))
|
|
}
|
|
|
|
static arc(p, alpha, radius) {
|
|
return {
|
|
x: p.x + radius * Math.cos(alpha),
|
|
y: p.y + radius * Math.sin(alpha)
|
|
}
|
|
}
|
|
|
|
static distance(a, b) {
|
|
let dx = a.x - b.x;
|
|
let dy = a.y - b.y;
|
|
return Math.sqrt(dx * dx + dy * dy)
|
|
}
|
|
|
|
static fromPageToNode(element, p) {
|
|
// if (window.webkitConvertPointFromPageToNode) {
|
|
// return window.webkitConvertPointFromPageToNode(element,
|
|
// new WebKitPoint(p.x, p.y))
|
|
// }
|
|
return window.convertPointFromPageToNode(element, p.x, p.y)
|
|
}
|
|
|
|
static fromNodeToPage(element, p) {
|
|
// if (window.webkitConvertPointFromNodeToPage) {
|
|
// return window.webkitConvertPointFromNodeToPage(element,
|
|
// new WebKitPoint(p.x, p.y))
|
|
// }
|
|
return window.convertPointFromNodeToPage(element, p.x, p.y)
|
|
}
|
|
}
|
|
|
|
/** Static methods to compute angles.
|
|
*/
|
|
class Angle {
|
|
|
|
static normalize(angle) {
|
|
let TAU = Math.PI * 2.0;
|
|
while (angle > Math.PI) {
|
|
angle -= TAU;
|
|
}
|
|
while (angle < -Math.PI) {
|
|
angle += TAU;
|
|
}
|
|
return angle
|
|
}
|
|
|
|
static normalize2(angle) {
|
|
let TAU = Math.PI * 2.0;
|
|
while (angle > TAU) {
|
|
angle -= TAU;
|
|
}
|
|
while (angle < 0) {
|
|
angle += TAU;
|
|
}
|
|
return angle
|
|
}
|
|
|
|
static normalizeDegree(angle) {
|
|
let full = 360.0;
|
|
while (angle > 180.0) {
|
|
angle -= full;
|
|
}
|
|
while (angle < -180.0) {
|
|
angle += full;
|
|
}
|
|
return angle
|
|
}
|
|
|
|
static normalizedDiff(a, b) {
|
|
return this.normalize(this.diff(a, b))
|
|
}
|
|
|
|
static normalized2Diff(a, b) {
|
|
return this.normalize2(this.diff(a, b))
|
|
}
|
|
|
|
static diff(a, b) {
|
|
return Math.atan2(Math.sin(a - b), Math.cos(a - b))
|
|
}
|
|
|
|
static degree2radian(degree) {
|
|
return Math.PI * degree / 180.0
|
|
}
|
|
|
|
static radian2degree(rad) {
|
|
return 180.0 / Math.PI * rad
|
|
}
|
|
}
|
|
|
|
class Elements$1 {
|
|
static setStyle(element, styles) {
|
|
for (let key in styles) {
|
|
element.style[key] = styles[key];
|
|
}
|
|
}
|
|
|
|
static addClass(element, cssClass) {
|
|
element.classList.add(cssClass);
|
|
}
|
|
|
|
static removeClass(element, cssClass) {
|
|
element.classList.remove(cssClass);
|
|
}
|
|
|
|
static toggleClass(element, cssClass) {
|
|
element.classList.toggle(cssClass);
|
|
}
|
|
|
|
static hasClass(element, cssClass) {
|
|
return element.classList.contains(cssClass)
|
|
}
|
|
}
|
|
|
|
class MapProxy {
|
|
/* This class is needed if we want to use the interaction classes
|
|
in Firefox 45.8 and modern Browsers.
|
|
|
|
A workaround for https://github.com/babel/babel/issues/2334
|
|
*/
|
|
constructor() {
|
|
this.map = new Map();
|
|
}
|
|
|
|
get size() {
|
|
return this.map.size
|
|
}
|
|
|
|
get(key) {
|
|
return this.map.get(key)
|
|
}
|
|
|
|
set(key, value) {
|
|
return this.map.set(key, value)
|
|
}
|
|
|
|
delete(key) {
|
|
return this.map.delete(key)
|
|
}
|
|
|
|
clear() {
|
|
return this.map.clear()
|
|
}
|
|
|
|
has(key) {
|
|
return this.map.has(key)
|
|
}
|
|
|
|
keys() {
|
|
return this.map.keys()
|
|
}
|
|
|
|
values() {
|
|
return this.map.values()
|
|
}
|
|
|
|
entries() {
|
|
return this.map.entries()
|
|
}
|
|
|
|
forEach(func) {
|
|
this.map.forEach(func);
|
|
}
|
|
}
|
|
|
|
/* Based om https://gist.github.com/cwleonard/e124d63238bda7a3cbfa */
|
|
class Polygon {
|
|
/*
|
|
* This is the Polygon constructor. All points are center-relative.
|
|
*/
|
|
constructor(center) {
|
|
this.points = new Array();
|
|
this.center = center;
|
|
}
|
|
|
|
/*
|
|
* Point x and y values should be relative to the center.
|
|
*/
|
|
addPoint(p) {
|
|
this.points.push(p);
|
|
}
|
|
|
|
/*
|
|
* Point x and y values should be absolute coordinates.
|
|
*/
|
|
addAbsolutePoint(p) {
|
|
this.points.push({ x: p.x - this.center.x, y: p.y - this.center.y });
|
|
}
|
|
|
|
/*
|
|
* Returns the number of sides. Equal to the number of vertices.
|
|
*/
|
|
getNumberOfSides() {
|
|
return this.points.length
|
|
}
|
|
|
|
/*
|
|
* rotate the polygon by a number of radians
|
|
*/
|
|
rotate(rads) {
|
|
for (let i = 0; i < this.points.length; i++) {
|
|
let x = this.points[i].x;
|
|
let y = this.points[i].y;
|
|
this.points[i].x = Math.cos(rads) * x - Math.sin(rads) * y;
|
|
this.points[i].y = Math.sin(rads) * x + Math.cos(rads) * y;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The draw function takes as a parameter a Context object from
|
|
* a Canvas element and draws the polygon on it.
|
|
*/
|
|
draw(context, { lineWidth = 2, stroke = '#000000', fill = null } = {}) {
|
|
context.beginPath();
|
|
context.moveTo(
|
|
this.points[0].x + this.center.x,
|
|
this.points[0].y + this.center.y
|
|
);
|
|
for (let i = 1; i < this.points.length; i++) {
|
|
context.lineTo(
|
|
this.points[i].x + this.center.x,
|
|
this.points[i].y + this.center.y
|
|
);
|
|
}
|
|
context.closePath();
|
|
context.lineWidth = lineWidth;
|
|
if (stroke) {
|
|
context.strokeStyle = stroke;
|
|
context.stroke();
|
|
}
|
|
if (fill) {
|
|
context.fillStyle = fill;
|
|
context.fill();
|
|
}
|
|
}
|
|
|
|
absolutePoints() {
|
|
let result = new Array();
|
|
for (let p of this.points) {
|
|
result.push(Points.add(p, this.center));
|
|
}
|
|
return result
|
|
}
|
|
|
|
flatAbsolutePoints() {
|
|
let result = new Array();
|
|
for (let p of this.points) {
|
|
let a = Points.add(p, this.center);
|
|
result.push(a.x);
|
|
result.push(a.y);
|
|
}
|
|
return result
|
|
}
|
|
|
|
/*
|
|
* This function returns true if the given point is inside the polygon,
|
|
* and false otherwise.
|
|
*/
|
|
containsPoint(pnt) {
|
|
let nvert = this.points.length;
|
|
let testx = pnt.x;
|
|
let testy = pnt.y;
|
|
|
|
let vertx = new Array();
|
|
for (let q = 0; q < this.points.length; q++) {
|
|
vertx.push(this.points[q].x + this.center.x);
|
|
}
|
|
|
|
let verty = new Array();
|
|
for (let w = 0; w < this.points.length; w++) {
|
|
verty.push(this.points[w].y + this.center.y);
|
|
}
|
|
|
|
let i,
|
|
j = 0;
|
|
let c = false;
|
|
for (i = 0, j = nvert - 1; i < nvert; j = i++) {
|
|
if (
|
|
verty[i] > testy != verty[j] > testy &&
|
|
testx <
|
|
(vertx[j] - vertx[i]) *
|
|
(testy - verty[i]) /
|
|
(verty[j] - verty[i]) +
|
|
vertx[i]
|
|
)
|
|
c = !c;
|
|
}
|
|
return c
|
|
}
|
|
|
|
multiplyScalar(scale) {
|
|
let center = Points.multiplyScalar(this.center, scale);
|
|
let clone = new Polygon(center);
|
|
for (let p of this.points) {
|
|
clone.addPoint(Points.multiplyScalar(p, scale));
|
|
}
|
|
return clone
|
|
}
|
|
|
|
/*
|
|
* To detect intersection with another Polygon object, this
|
|
* function uses the Separating Axis Theorem. It returns false
|
|
* if there is no intersection, or an object if there is. The object
|
|
* contains 2 fields, overlap and axis. Moving the polygon by overlap
|
|
* on axis will get the polygons out of intersection.
|
|
*/
|
|
intersectsWith(other) {
|
|
let axis = { x: 0, y: 0 };
|
|
let tmp, minA, maxA, minB, maxB;
|
|
let side, i;
|
|
let smallest = null;
|
|
let overlap = 99999999;
|
|
|
|
/* test polygon A's sides */
|
|
for (side = 0; side < this.getNumberOfSides(); side++) {
|
|
/* get the axis that we will project onto */
|
|
if (side == 0) {
|
|
axis.x =
|
|
this.points[this.getNumberOfSides() - 1].y -
|
|
this.points[0].y;
|
|
axis.y =
|
|
this.points[0].x -
|
|
this.points[this.getNumberOfSides() - 1].x;
|
|
} else {
|
|
axis.x = this.points[side - 1].y - this.points[side].y;
|
|
axis.y = this.points[side].x - this.points[side - 1].x;
|
|
}
|
|
|
|
/* normalize the axis */
|
|
tmp = Math.sqrt(axis.x * axis.x + axis.y * axis.y);
|
|
axis.x /= tmp;
|
|
axis.y /= tmp;
|
|
|
|
/* project polygon A onto axis to determine the min/max */
|
|
minA = maxA = this.points[0].x * axis.x + this.points[0].y * axis.y;
|
|
for (i = 1; i < this.getNumberOfSides(); i++) {
|
|
tmp = this.points[i].x * axis.x + this.points[i].y * axis.y;
|
|
if (tmp > maxA) maxA = tmp;
|
|
else if (tmp < minA) minA = tmp;
|
|
}
|
|
/* correct for offset */
|
|
tmp = this.center.x * axis.x + this.center.y * axis.y;
|
|
minA += tmp;
|
|
maxA += tmp;
|
|
|
|
/* project polygon B onto axis to determine the min/max */
|
|
minB = maxB =
|
|
other.points[0].x * axis.x + other.points[0].y * axis.y;
|
|
for (i = 1; i < other.getNumberOfSides(); i++) {
|
|
tmp = other.points[i].x * axis.x + other.points[i].y * axis.y;
|
|
if (tmp > maxB) maxB = tmp;
|
|
else if (tmp < minB) minB = tmp;
|
|
}
|
|
/* correct for offset */
|
|
tmp = other.center.x * axis.x + other.center.y * axis.y;
|
|
minB += tmp;
|
|
maxB += tmp;
|
|
|
|
/* test if lines intersect, if not, return false */
|
|
if (maxA < minB || minA > maxB) {
|
|
return false
|
|
} else {
|
|
let o = maxA > maxB ? maxB - minA : maxA - minB;
|
|
if (o < overlap) {
|
|
overlap = o;
|
|
smallest = { x: axis.x, y: axis.y };
|
|
}
|
|
}
|
|
}
|
|
|
|
/* test polygon B's sides */
|
|
for (side = 0; side < other.getNumberOfSides(); side++) {
|
|
/* get the axis that we will project onto */
|
|
if (side == 0) {
|
|
axis.x =
|
|
other.points[other.getNumberOfSides() - 1].y -
|
|
other.points[0].y;
|
|
axis.y =
|
|
other.points[0].x -
|
|
other.points[other.getNumberOfSides() - 1].x;
|
|
} else {
|
|
axis.x = other.points[side - 1].y - other.points[side].y;
|
|
axis.y = other.points[side].x - other.points[side - 1].x;
|
|
}
|
|
|
|
/* normalize the axis */
|
|
tmp = Math.sqrt(axis.x * axis.x + axis.y * axis.y);
|
|
axis.x /= tmp;
|
|
axis.y /= tmp;
|
|
|
|
/* project polygon A onto axis to determine the min/max */
|
|
minA = maxA = this.points[0].x * axis.x + this.points[0].y * axis.y;
|
|
for (i = 1; i < this.getNumberOfSides(); i++) {
|
|
tmp = this.points[i].x * axis.x + this.points[i].y * axis.y;
|
|
if (tmp > maxA) maxA = tmp;
|
|
else if (tmp < minA) minA = tmp;
|
|
}
|
|
/* correct for offset */
|
|
tmp = this.center.x * axis.x + this.center.y * axis.y;
|
|
minA += tmp;
|
|
maxA += tmp;
|
|
|
|
/* project polygon B onto axis to determine the min/max */
|
|
minB = maxB =
|
|
other.points[0].x * axis.x + other.points[0].y * axis.y;
|
|
for (i = 1; i < other.getNumberOfSides(); i++) {
|
|
tmp = other.points[i].x * axis.x + other.points[i].y * axis.y;
|
|
if (tmp > maxB) maxB = tmp;
|
|
else if (tmp < minB) minB = tmp;
|
|
}
|
|
/* correct for offset */
|
|
tmp = other.center.x * axis.x + other.center.y * axis.y;
|
|
minB += tmp;
|
|
maxB += tmp;
|
|
|
|
/* test if lines intersect, if not, return false */
|
|
if (maxA < minB || minA > maxB) {
|
|
return false
|
|
} else {
|
|
let o = maxA > maxB ? maxB - minA : maxA - minB;
|
|
if (o < overlap) {
|
|
overlap = o;
|
|
smallest = { x: axis.x, y: axis.y };
|
|
}
|
|
}
|
|
}
|
|
return { overlap: overlap + 0.001, axis: smallest }
|
|
}
|
|
|
|
static fromPoints(points) {
|
|
let min = { x: Number.MAX_VALUE, y: Number.MAX_VALUE };
|
|
let max = { x: Number.MIN_VALUE, y: Number.MIN_VALUE };
|
|
for (let p of points) {
|
|
min.x = Math.min(p.x, min.x);
|
|
max.x = Math.max(p.x, max.x);
|
|
min.y = Math.min(p.y, min.y);
|
|
max.y = Math.max(p.y, max.y);
|
|
}
|
|
let center = Points.mean(min, max);
|
|
let polygon = new Polygon(center);
|
|
for (let p of points) {
|
|
polygon.addAbsolutePoint(p);
|
|
}
|
|
return polygon
|
|
}
|
|
}
|
|
|
|
/* global apollo, subscriptions, gql */
|
|
|
|
/**
|
|
* A special InteractionManager for fullscreen apps, which may
|
|
* go beyond the limits of WebGL drawing buffers. On Safari and Chrome
|
|
* the drawing buffers are limited to 4096 in width (Safari) or 4096x4096
|
|
* in total buffer size (Chrome). The original InteractionManager.mapPositionToPoint
|
|
* does not work with these extreme sizes which mainly occur if large
|
|
* retina displays (>= 4K) are used with devicePixelRatio > 1.
|
|
*
|
|
* @private
|
|
* @class
|
|
* @extends PIXI.interaction.InteractionManager
|
|
* @see {@link http://pixijs.download/dev/docs/PIXI.interaction.InteractionManager.html|PIXI.interaction.InteractionManager}
|
|
* @see {@link https://stackoverflow.com/questions/29710696/webgl-drawing-buffer-size-does-not-equal-canvas-size}
|
|
*/
|
|
class FullscreenInteractionManager extends PIXI.interaction.InteractionManager {
|
|
|
|
mapPositionToPoint(point, x, y) {
|
|
let resolution = this.renderer.resolution;
|
|
let extendWidth = 1.0;
|
|
let extendHeight = 1.0;
|
|
let dy = 0;
|
|
let canvas = this.renderer.view;
|
|
let context = canvas.getContext('webgl');
|
|
if (context.drawingBufferWidth < canvas.width ||
|
|
context.drawingBufferHeight < canvas.height) {
|
|
extendWidth = context.drawingBufferWidth / canvas.width;
|
|
extendHeight = context.drawingBufferHeight / canvas.height;
|
|
//dx = wantedWidth - context.drawingBufferWidth
|
|
dy = (canvas.height - context.drawingBufferHeight) / resolution;
|
|
}
|
|
x *= extendWidth;
|
|
y *= extendHeight;
|
|
|
|
super.mapPositionToPoint(point, x, y + dy);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The class PixiApp extends the class PIXI.Application
|
|
* by several functions and makes meaningful pre-assumptions.
|
|
*
|
|
* @example
|
|
* // Create the app
|
|
* const app = new PIXIApp({
|
|
* view: canvas,
|
|
* width: 450,
|
|
* height: 150,
|
|
* fpsLogging: true,
|
|
* theme: 'light',
|
|
* transparent: false
|
|
* }).setup().run()
|
|
*
|
|
* @class
|
|
* @extends PIXI.Application
|
|
* @see {@link http://pixijs.download/dev/docs/PIXI.Application.html|PIXI.Application}
|
|
*/
|
|
class PIXIApp extends PIXI.Application {
|
|
|
|
/**
|
|
* Creates an instance of a PixiApp.
|
|
*
|
|
* @constructor
|
|
* @param {object} [opts={}] - An options object. The following options can be set:
|
|
* @param {number} [opts.width] - The width of the renderer. If no set, the application will run in fullscreen.
|
|
* @param {number} [opts.height] - The height of the renderer. If no set, the application will run in fullscreen.
|
|
* @param {HTMLElement} [opts.view] - The canvas HTML element. If not set, a render-element is added inside the body.
|
|
* @param {boolean} [opts.transparent=true] - Should the render view be transparent?
|
|
* @param {boolean} [opts.antialias=true] - Sets antialias (only applicable in chrome at the moment).
|
|
* @param {number} [opts.resolution=window.devicePixelRatio | 1] - The resolution / device pixel ratio of the renderer, retina would be 2.
|
|
* @param {boolean} [opts.autoResize=true] - Should the canvas-element be resized automatically if the resolution was set?
|
|
* @param {number} [opts.backgroundColor=0x282828] - The color of the background.
|
|
* @param {string|Theme} [opts.theme=dark] - The name of the theme (dark, light, red) or a Theme object to use for styling.
|
|
* @param {boolean} [opts.fpsLogging=false] - If set to true, the current frames per second are displayed in the upper left corner.
|
|
* @param {object} [opts.progress={}] - Can be used to add options to the progress bar. See class Progress for more informations.
|
|
* @param {boolean} [opts.forceCanvas=false] - Prevents selection of WebGL renderer, even if such is present.
|
|
* @param {boolean} [opts.roundPixels=true] - Align PIXI.DisplayObject coordinates to screen resolution.
|
|
* @param {boolean} [opts.monkeyPatchMapping=true] - Monkey patch for canvas fullscreen support on large displays.
|
|
* @param {boolean} [opts.adaptive=true] - Adds Graphics adaptive calculation of quadratic curve and arc subdivision.
|
|
*/
|
|
constructor({
|
|
width = null, height = null, view = null,
|
|
transparent = true, backgroundColor = 0x282828, theme = 'dark',
|
|
antialias = true, resolution = window.devicePixelRatio || 1, autoResize = true,
|
|
fpsLogging = false, progress = {}, forceCanvas = false, roundPixels = true, monkeyPatchMapping = true, adaptive = true,
|
|
graphql = false }) {
|
|
|
|
const fullScreen = !width || !height;
|
|
|
|
if (fullScreen) {
|
|
width = window.innerWidth;
|
|
height = window.innerHeight;
|
|
}
|
|
|
|
super({
|
|
view: view,
|
|
width: width,
|
|
height: height,
|
|
transparent: transparent,
|
|
antialias: antialias,
|
|
resolution: resolution,
|
|
autoResize: autoResize,
|
|
backgroundColor: backgroundColor,
|
|
roundPixels: roundPixels,
|
|
forceCanvas: forceCanvas
|
|
});
|
|
|
|
this.width = width;
|
|
this.height = height;
|
|
this.theme = Theme.fromString(theme);
|
|
this.fpsLogging = fpsLogging;
|
|
this.progressOpts = progress;
|
|
this.fullScreen = fullScreen;
|
|
this.orient = null;
|
|
this.originalMapPositionToPoint = null;
|
|
this.monkeyPatchMapping = monkeyPatchMapping;
|
|
PIXI.Graphics.CURVES.adaptive = adaptive;
|
|
this.graphql = graphql;
|
|
if (fullScreen || autoResize) {
|
|
console.log('App is in fullScreen mode or autoResize mode');
|
|
const resizeDebounced = debounce(event => this.resize(event), 50);
|
|
window.addEventListener('resize', resizeDebounced);
|
|
document.body.addEventListener('orientationchange', this.checkOrientation.bind(this));
|
|
}
|
|
if (monkeyPatchMapping) {
|
|
console.log('Using monkey patched coordinate mapping');
|
|
// Pluggin the specializtion does not work. Monkey patching does
|
|
// this.renderer.plugins.interaction = new FullscreenInteractionManager(this.renderer)
|
|
this.monkeyPatchPixiMapping();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Extra setup method to construct complex scenes, etc...
|
|
* Overwrite this method if you need additonal views and components.
|
|
*
|
|
* @return {PIXIApp} A reference to the PIXIApp for chaining.
|
|
*/
|
|
setup() {
|
|
this.scene = this.sceneFactory();
|
|
this.stage.addChild(this.scene);
|
|
|
|
// fpsLogging
|
|
if (this.fpsLogging) {
|
|
this.addFpsDisplay();
|
|
}
|
|
|
|
// GraphQL
|
|
if (this.graphql && typeof apollo !== 'undefined') {
|
|
|
|
const networkInterface = apollo.createNetworkInterface({
|
|
uri: '/graphql'
|
|
});
|
|
|
|
const wsClient = new subscriptions.SubscriptionClient(`wss://${location.hostname}/subscriptions`, {
|
|
reconnect: true,
|
|
connectionParams: {}
|
|
});
|
|
|
|
const networkInterfaceWithSubscriptions = subscriptions.addGraphQLSubscriptions(
|
|
networkInterface,
|
|
wsClient
|
|
);
|
|
|
|
this.apolloClient = new apollo.ApolloClient({
|
|
networkInterface: networkInterfaceWithSubscriptions
|
|
});
|
|
}
|
|
|
|
// progress
|
|
this._progress = new Progress(Object.assign({ theme: this.theme }, this.progressOpts, { app: this }));
|
|
this._progress.visible = false;
|
|
this.stage.addChild(this._progress);
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Tests whether the width is larger than the height of the application.
|
|
*
|
|
* @return {boolean} Returns true if app is in landscape mode.
|
|
*/
|
|
orientation() {
|
|
return this.width > this.height
|
|
}
|
|
|
|
/**
|
|
* Checks orientation and adapts view size if necessary. Implements a
|
|
* handler for the orientationchange event.
|
|
*
|
|
* @param {event=} - orientationchange event
|
|
*/
|
|
checkOrientation(event) {
|
|
var value = this.orientation();
|
|
if (value != this.orient) {
|
|
setTimeout(100, function () {
|
|
this.orientationChanged(true);
|
|
}.bind(this));
|
|
this.orient = value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called if checkOrientation detects an orientation change event.
|
|
*
|
|
* @param {boolean=} [force=false] - Called if checkOrientation detects an orientation change event.
|
|
*/
|
|
orientationChanged(force = false) {
|
|
if (this.expandRenderer() || force) {
|
|
this.layout();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called after a resize. Empty method but can be overwritten to
|
|
* adapt their layout to the new app size.
|
|
*
|
|
* @param {number} [width] - The width of the app.
|
|
* @param {number} [height] - The height of the app.
|
|
*/
|
|
layout(width, height) {
|
|
|
|
}
|
|
|
|
/**
|
|
* Draws the display tree of the app. Typically this can be delegated
|
|
* to the layout method.
|
|
*
|
|
*/
|
|
draw() {
|
|
this.layout(this.width, this.height);
|
|
}
|
|
|
|
/*
|
|
* Run the application. Override this method with everything
|
|
* that is needed to maintain your App, e.g. setup calls, main loops, etc.
|
|
*
|
|
*/
|
|
run() {
|
|
return this
|
|
}
|
|
|
|
/*
|
|
* Overwrite this factory method if your application needs a special
|
|
* scene object.
|
|
*
|
|
* @returns {PIXI.Container} - A new PIXI Container for use as a scene.
|
|
*/
|
|
sceneFactory() {
|
|
return new PIXI.Container()
|
|
}
|
|
|
|
/**
|
|
* Adds the display of the frames per second to the renderer in the upper left corner.
|
|
*
|
|
* @return {PIXIApp} - Returns the PIXIApp for chaining.
|
|
*/
|
|
addFpsDisplay() {
|
|
const fpsDisplay = new FpsDisplay(this);
|
|
this.stage.addChild(fpsDisplay);
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Returns the size of the renderer as an object with the keys width and height.
|
|
*
|
|
* @readonly
|
|
* @member {object}
|
|
*/
|
|
get size() {
|
|
return { width: this.width, height: this.height }
|
|
}
|
|
|
|
/**
|
|
* Returns the center of the renderer as an object with the keys x and y.
|
|
*
|
|
* @readonly
|
|
* @member {object}
|
|
*/
|
|
get center() {
|
|
return { x: this.width / 2, y: this.height / 2 }
|
|
}
|
|
|
|
/**
|
|
* Resizes the renderer to fit into the window or given width and height.
|
|
*
|
|
* @param {object} [event] - The event.
|
|
* @param {object=} [opts={}] - The event.
|
|
* @param {number} [opts.width=window.innerWidth] - The width of the app to resize to.
|
|
* @param {number} [opts.height=window.innerHeight] - The height of the app to resize to.
|
|
* @return {PIXIApp} - Returns the PIXIApp for chaining.
|
|
*/
|
|
resize(event, { width = window.innerWidth, height = window.innerHeight } = {}) {
|
|
this.width = width;
|
|
this.height = height;
|
|
this.expandRenderer();
|
|
this.layout(width, height);
|
|
//console.log("App.resize", width, height, window.innerWidth, window.innerHeight )
|
|
// if (this.scene) {
|
|
// console.log("gl.drawingBufferWidth", this.renderer.view.getContext('webgl').drawingBufferWidth)
|
|
// console.log("scene", this.scene.scale, this.renderer, this.renderer.autoResize, this.renderer.resolution)
|
|
// }
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* @todo Write the documentation.
|
|
*
|
|
* @private
|
|
*/
|
|
monkeyPatchPixiMapping() {
|
|
if (this.originalMapPositionToPoint === null) {
|
|
let interactionManager = this.renderer.plugins.interaction;
|
|
this.originalMapPositionToPoint = interactionManager.mapPositionToPoint;
|
|
interactionManager.mapPositionToPoint = (point, x, y) => {
|
|
return this.fixedMapPositionToPoint(point, x, y)
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* In some browsers the canvas is distorted if the screen resolution and
|
|
* overall size of the canvas exceeds the internal limits (e.g. 4096 x 4096 pixels).
|
|
* To compensate these distortions we need to fix the mapping to the actual
|
|
* drawing buffer coordinates.
|
|
* @private
|
|
* @param {any} local
|
|
* @param {number} x
|
|
* @param {number} y
|
|
* @return {} interactionManager.mapPositionToPoint
|
|
*/
|
|
fixedMapPositionToPoint(local, x, y) {
|
|
let resolution = this.renderer.resolution;
|
|
let interactionManager = this.renderer.plugins.interaction;
|
|
let extendWidth = 1.0;
|
|
let extendHeight = 1.0;
|
|
let dy = 0;
|
|
let canvas = this.renderer.view;
|
|
let context = canvas.getContext('webgl');
|
|
|
|
if (context !== null && (context.drawingBufferWidth < canvas.width ||
|
|
context.drawingBufferHeight < canvas.height)) {
|
|
extendWidth = context.drawingBufferWidth / canvas.width;
|
|
extendHeight = context.drawingBufferHeight / canvas.height;
|
|
//dx = wantedWidth - context.drawingBufferWidth
|
|
dy = (canvas.height - context.drawingBufferHeight) / resolution;
|
|
}
|
|
x *= extendWidth;
|
|
y *= extendHeight;
|
|
return this.originalMapPositionToPoint.call(interactionManager, local, x, y + dy)
|
|
}
|
|
|
|
/**
|
|
* Expand the renderer step-wise on resize.
|
|
*
|
|
* @param {number} [expand] - The amount of additional space for the renderer [px].
|
|
* @return {boolean} true if the renderer was resized.
|
|
*/
|
|
expandRenderer(expand = 256) {
|
|
let renderer = this.renderer;
|
|
let resolution = this.renderer.resolution;
|
|
let ww = this.width;
|
|
let hh = this.height;
|
|
let sw = this.screen.width;
|
|
let sh = this.screen.height;
|
|
if (ww > sw || hh > sh) {
|
|
//console.log('App.expandRenderer')
|
|
renderer.resize(ww + expand, hh + expand);
|
|
return true
|
|
}
|
|
|
|
renderer.resize(ww, hh);
|
|
return false
|
|
}
|
|
|
|
/**
|
|
* Set the loading progress of the application. If called for the first time, display the progress bar.
|
|
*
|
|
* @param {number} [value] - Should be a value between 0 and 100. If 100, the progress bar will disappear.
|
|
* @return {PIXIApp|Progress} The PixiApp object for chaining or the Progress object when the method was
|
|
* called without a parameter.
|
|
*/
|
|
progress(value) {
|
|
|
|
if (typeof value === 'undefined') {
|
|
return this._progress
|
|
}
|
|
|
|
this._progress.visible = true;
|
|
this._progress.progress = value;
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Opens a new Modal object binded to this app.
|
|
*
|
|
* @param {object} [opts] - An options object for the Modal object.
|
|
* @return {Modal} Returns the Modal object.
|
|
*/
|
|
modal(opts = {}) {
|
|
|
|
let modal = new Modal(Object.assign({ theme: this.theme }, opts, { app: this }));
|
|
this.scene.addChild(modal);
|
|
|
|
return modal
|
|
}
|
|
|
|
/**
|
|
* Opens a new Message object binded to this app.
|
|
*
|
|
* @param {object} [opts] - An options object for the Message object.
|
|
* @return {Message} Returns the Message object.
|
|
*/
|
|
message(opts = {}) {
|
|
|
|
let message = new Message(Object.assign({ theme: this.theme }, opts, { app: this }));
|
|
this.scene.addChild(message);
|
|
|
|
return message
|
|
}
|
|
|
|
/**
|
|
* Loads sprites, e.g. images into the PIXI TextureCache.
|
|
*
|
|
* @param {string|string[]} resources - A String or an Array of urls to the images to load.
|
|
* @param {function} [loaded] - A callback which is executed after all resources has been loaded.
|
|
* Receives one paramter, a Map of sprites where the key is the path of the image which was
|
|
* loaded and the value is the PIXI.Sprite object.
|
|
* @param {object} [opts] - An options object for more specific parameters.
|
|
* @param {boolean} [opts.resolutionDependent=true] - Should the sprites be loaded dependent of the
|
|
* renderer resolution?
|
|
* @param {boolean} [opts.progress=false] - Should a progress bar display the loading status?
|
|
* @return {PIXIApp} The PIXIApp object for chaining.
|
|
*/
|
|
loadSprites(resources, loaded = null, { resolutionDependent = true, progress = false } = {}) {
|
|
|
|
this.loadTextures(resources, textures => {
|
|
|
|
let sprites = new Map();
|
|
|
|
for (let [key, texture] of textures) {
|
|
sprites.set(key, new PIXI.Sprite(texture));
|
|
}
|
|
|
|
if (loaded) {
|
|
loaded.call(this, sprites);
|
|
}
|
|
|
|
}, { resolutionDependent, progress });
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Loads textures, e.g. images into the PIXI TextureCache.
|
|
*
|
|
* @param {string|string[]} resources - A String or an Array of urls to the images to load.
|
|
* @param {function} [loaded] - A callback which is executed after all resources has been loaded.
|
|
* Receives one paramter, a Map of textures where the key is the path of the image which was
|
|
* loaded and the value is the PIXI.Texture object.
|
|
* @param {object} [opts] - An options object for more specific parameters.
|
|
* @param {boolean} [opts.resolutionDependent=true] - Should the textures be loaded dependent of the
|
|
* renderer resolution?
|
|
* @param {boolean} [opts.progress=false] - Should a progress bar display the loading status?
|
|
* @return {PIXIApp} The PIXIApp object for chaining.
|
|
*/
|
|
loadTextures(resources, loaded = null, { resolutionDependent = true, progress = false } = {}) {
|
|
|
|
if (!Array.isArray(resources)) {
|
|
resources = [resources];
|
|
}
|
|
|
|
const loader = this.loader;
|
|
|
|
for (let resource of resources) {
|
|
|
|
if (!loader.resources[resource]) {
|
|
|
|
if (resolutionDependent) {
|
|
let resolution = Math.round(this.renderer.resolution);
|
|
switch (resolution) {
|
|
case 2:
|
|
loader.add(resource, resource.replace(/\.([^.]*)$/, '@2x.$1'));
|
|
break
|
|
case 3:
|
|
loader.add(resource, resource.replace(/\.([^.]*)$/, '@3x.$1'));
|
|
break
|
|
default:
|
|
loader.add(resource);
|
|
break
|
|
}
|
|
} else {
|
|
loader.add(resource);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (progress) {
|
|
loader.on('progress', e => {
|
|
this.progress(e.progress);
|
|
});
|
|
}
|
|
|
|
loader.load((loader, resources) => {
|
|
const textures = new Map();
|
|
|
|
for (let key in resources) {
|
|
textures.set(key, resources[key].texture);
|
|
}
|
|
|
|
if (loaded) {
|
|
loaded.call(this, textures);
|
|
}
|
|
});
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Queries the GraphQL endpoint.
|
|
*
|
|
* @param {string} [query] - The GraphQL query string.
|
|
* @param {object} [opts={}] - An options object. The following options can be set:
|
|
* http://dev.apollodata.com/core/apollo-client-api.html#ApolloClient.query
|
|
* @return {Promise} Returns a Promise which is either resolved with the resulting data or
|
|
* rejected with an error.
|
|
*/
|
|
query(query, opts = {}) {
|
|
|
|
if (typeof query === 'string') {
|
|
opts = Object.assign({}, opts, { query });
|
|
} else {
|
|
opts = Object.assign({}, query);
|
|
}
|
|
|
|
opts.query = opts.query.trim();
|
|
|
|
if (!opts.query.startsWith('query')) {
|
|
if (opts.query.startsWith('{')) {
|
|
opts.query = `query ${opts.query}`;
|
|
} else {
|
|
opts.query = `query {${opts.query}}`;
|
|
}
|
|
}
|
|
|
|
opts.query = gql(opts.query);
|
|
|
|
return this.apolloClient.query(opts)
|
|
}
|
|
|
|
/**
|
|
* Mutate the GraphQL endpoint.
|
|
*
|
|
* @param {string} [mutation] - The GraphQL mutation string.
|
|
* @param {object} [opts={}] - An options object. The following options can be set:
|
|
* http://dev.apollodata.com/core/apollo-client-api.html#ApolloClient.mutate
|
|
* @return {Promise} Returns a Promise which is either resolved with the resulting data or
|
|
* rejected with an error.
|
|
*/
|
|
mutate(mutation, opts = {}) {
|
|
|
|
if (typeof mutation === 'string') {
|
|
opts = Object.assign({}, opts, { mutation });
|
|
} else {
|
|
opts = Object.assign({}, mutation);
|
|
}
|
|
|
|
opts.mutation = opts.mutation.trim();
|
|
|
|
if (!opts.mutation.startsWith('mutation')) {
|
|
if (opts.mutation.startsWith('{')) {
|
|
opts.mutation = `mutation ${opts.mutation}`;
|
|
} else {
|
|
opts.mutation = `mutation {${opts.mutation}}`;
|
|
}
|
|
}
|
|
|
|
opts.mutation = gql(opts.mutation);
|
|
|
|
return this.apolloClient.mutate(opts)
|
|
}
|
|
|
|
/**
|
|
* Subscribe the GraphQL endpoint.
|
|
*
|
|
* @param {string} [subscription] - The GraphQL subscription.
|
|
* @param {object} [opts={}] - An options object. The following options can be set:
|
|
* http://dev.apollodata.com/core/apollo-client-api.html#ApolloClient.query
|
|
* @return {Promise} Returns a Promise which is either resolved with the resulting data or
|
|
* rejected with an error.
|
|
*/
|
|
subscribe(subscription, opts = {}) {
|
|
|
|
if (typeof subscription === 'string') {
|
|
opts = Object.assign({}, opts, { subscription });
|
|
} else {
|
|
opts = Object.assign({}, subscription);
|
|
}
|
|
|
|
opts.subscription = opts.subscription.trim();
|
|
|
|
if (!opts.subscription.startsWith('subscription')) {
|
|
if (opts.subscription.startsWith('{')) {
|
|
opts.subscription = `subscription ${opts.subscription}`;
|
|
} else {
|
|
opts.subscription = `subscription {${opts.subscription}}`;
|
|
}
|
|
}
|
|
|
|
opts.query = gql(opts.subscription);
|
|
|
|
delete opts.subscription;
|
|
|
|
return this.apolloClient.subscribe(opts)
|
|
}
|
|
|
|
/**
|
|
* Supports the page as a global coordinate system and converts browser page coordinates
|
|
* to local DisplayObject coordinates.
|
|
*
|
|
* @param {DisplayObject} displayObject - The PIXI displayObject.
|
|
* @param {number} x - The x coordinate.
|
|
* @param {number} y - The y coordinate.
|
|
*
|
|
* @return {PIXI.Point} Returns a PIXI.Point.
|
|
*/
|
|
|
|
convertPointFromPageToNode(displayObject, x, y) {
|
|
let resolution = this.renderer.resolution;
|
|
console.log("resolution", resolution);
|
|
let pixiGlobal = window.convertPointFromPageToNode(app.view, x, y);
|
|
pixiGlobal.x /= resolution;
|
|
pixiGlobal.y /= resolution;
|
|
return displayObject.toLocal(new PIXI.Point(pixiGlobal.x, pixiGlobal.y))
|
|
}
|
|
|
|
/**
|
|
* Supports the page as a global coordinate system and converts local DisplayObject coordinates
|
|
* to browser page coordinates.
|
|
*
|
|
* @param {DisplayObject} displayObject - The PIXI displayObject.
|
|
* @param {number} x - The x coordinate.
|
|
* @param {number} y - The y coordinate.
|
|
*
|
|
* @return {Point} Returns a DOM Point.
|
|
*/
|
|
|
|
convertPointFromNodeToPage(displayObject, x, y) {
|
|
let resolution = this.renderer.resolution;
|
|
let pixiGlobal = displayObject.toGlobal(new PIXI.Point(x, y));
|
|
pixiGlobal.x *= resolution;
|
|
pixiGlobal.y *= resolution;
|
|
// console.log("app.convertPointFromNodeToPage", pixiGlobal)
|
|
return window.convertPointFromNodeToPage(app.view, pixiGlobal.x, pixiGlobal.y)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The class fpsdisplay shows in the upper left corner
|
|
* of the renderer the current image refresh rate.
|
|
*
|
|
* @private
|
|
* @class
|
|
* @extends PIXI.Graphics
|
|
* @see {@link http://pixijs.download/dev/docs/PIXI.Graphics.html|PIXI.Graphics}
|
|
*/
|
|
class FpsDisplay extends PIXI.Graphics {
|
|
|
|
/**
|
|
* Creates an instance of a FpsDisplay.
|
|
*
|
|
* @constructor
|
|
* @param {PIXIApp} app - The PIXIApp where the frames per second should be displayed.
|
|
*/
|
|
constructor(app) {
|
|
|
|
super();
|
|
|
|
this.app = app;
|
|
|
|
this.lineStyle(3, 0x434f4f, 1)
|
|
.beginFill(0x434f4f, .6)
|
|
.drawRoundedRect(0, 0, 68, 32, 5)
|
|
.endFill()
|
|
.position.set(20, 20);
|
|
|
|
this.text = new PIXI.Text(this.fps, new PIXI.TextStyle({
|
|
fontFamily: 'Arial',
|
|
fontSize: 14,
|
|
fontWeight: 'bold',
|
|
fill: '#f6f6f6',
|
|
stroke: '#434f4f',
|
|
strokeThickness: 3
|
|
}));
|
|
this.text.position.set(6, 6);
|
|
|
|
this.addChild(this.text);
|
|
|
|
this.refreshFps();
|
|
|
|
window.setInterval(this.refreshFps.bind(this), 1000);
|
|
}
|
|
|
|
/**
|
|
* Refreshes fps numer.
|
|
*
|
|
* @return {PIXIApp} Returns the PIXIApp object for chaining.
|
|
*/
|
|
refreshFps() {
|
|
this.text.text = `${(this.app.ticker.FPS).toFixed(1)} fps`;
|
|
|
|
return this
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A Gaussian blur filter. With this filter, you can blur an area of a PIXI.DisplayObject. This cannot
|
|
* be done with the PIXI.filters.BlurFilter (when you use the PIXI.filters.BlurFilter with
|
|
* an filter area, all pixels outside of the area are not displayed). Attention: The area of
|
|
* the filter is always in global scope, NOT relative to the PIXI.DisplayObject the filter
|
|
* is assigned to!
|
|
*
|
|
* @example
|
|
* // Create the app
|
|
* const app = new PIXIApp({
|
|
* view: canvas,
|
|
* width: 480,
|
|
* height: 270,
|
|
* transparent: false
|
|
* }).setup().run()
|
|
*
|
|
* // Add a video sprite
|
|
* const sprite = new PIXI.Sprite(PIXI.Texture.fromVideo("assets/blurfilter.mp4"))
|
|
* sprite.width = app.size.width
|
|
* sprite.height = app.size.height
|
|
* app.scene.addChild(sprite)
|
|
*
|
|
* // Create the filter and assign it to the scene
|
|
* const blurFilter = new BlurFilter(new PIXI.Rectangle(20, 20, 80, 60))
|
|
* app.scene.filters = [blurFilter]
|
|
*
|
|
* @class
|
|
* @extends PIXI.Filter
|
|
* @param {PIXI.Rectangle|PIXI.Circle|PIXI.DisplayObject} shape The area where the blur effect should be applied to. Relative to the
|
|
* canvas, NOT relative to the PIXI.DisplayObject where the blur effect is assigned to!
|
|
* @param {number} [blur=50] The strength of the blur.
|
|
*/
|
|
class BlurFilter extends PIXI.Filter {
|
|
|
|
constructor(shape, blur = 50) {
|
|
super();
|
|
|
|
const normalized = this.normalize(shape);
|
|
|
|
this.tiltShiftXFilter = new TiltShiftXFilter(normalized, blur);
|
|
this.tiltShiftYFilter = new TiltShiftYFilter(normalized, blur);
|
|
}
|
|
|
|
apply(filterManager, input, output) {
|
|
let renderTarget = filterManager.getRenderTarget(true);
|
|
this.tiltShiftXFilter.apply(filterManager, input, renderTarget);
|
|
this.tiltShiftYFilter.apply(filterManager, renderTarget, output);
|
|
filterManager.returnRenderTarget(renderTarget);
|
|
}
|
|
|
|
/**
|
|
* The strength of the blur.
|
|
*
|
|
* @member {number}
|
|
*/
|
|
get blur() {
|
|
return this.tiltShiftXFilter.blur
|
|
}
|
|
set blur(value) {
|
|
this.tiltShiftXFilter.blur = this.tiltShiftYFilter.blur = value;
|
|
}
|
|
|
|
/**
|
|
* The blur shape.
|
|
*
|
|
* @member {PIXI.Rectangle|PIXI.Circle|PIXI.DisplayObject}
|
|
*/
|
|
get shape() {
|
|
return this.tiltShiftXFilter.shape
|
|
}
|
|
set shape(value) {
|
|
this.tiltShiftXFilter.shape = this.tiltShiftYFilter.shape = this.normalize(value);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @private
|
|
* @param {PIXI.Rectangle|PIXI.Circle|PIXI.DisplayObject} value
|
|
* @returns {Object}
|
|
*/
|
|
normalize(value) {
|
|
|
|
let shape = null;
|
|
|
|
if (value instanceof PIXI.Circle) {
|
|
shape = {type: 'circle', x: value.x, y: value.y, r: value.radius};
|
|
} else if (value instanceof PIXI.Rectangle) {
|
|
shape = {type: 'rectangle', x: value.x, y: value.y, width: value.width, height: value.height};
|
|
} else {
|
|
const bounds = value.getBounds();
|
|
shape = {type: 'rectangle', x: bounds.x, y: bounds.y, width: bounds.width, height: bounds.height};
|
|
}
|
|
|
|
return shape
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A TiltShiftAxisFilter.
|
|
*
|
|
* @class
|
|
* @extends PIXI.Filter
|
|
* @abstract
|
|
* @private
|
|
*/
|
|
class TiltShiftAxisFilter extends PIXI.Filter {
|
|
|
|
constructor(shape, blur){
|
|
|
|
const vertex = `
|
|
attribute vec2 aVertexPosition;
|
|
attribute vec2 aTextureCoord;
|
|
|
|
uniform mat3 projectionMatrix;
|
|
|
|
varying vec2 vTextureCoord;
|
|
|
|
void main(void) {
|
|
gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
|
|
vTextureCoord = aTextureCoord;
|
|
}
|
|
`;
|
|
|
|
const fragment = `
|
|
varying vec2 vTextureCoord;
|
|
|
|
uniform vec4 filterArea;
|
|
uniform sampler2D uSampler;
|
|
uniform int shape;
|
|
uniform vec4 rectangle;
|
|
uniform vec3 circle;
|
|
uniform float blur;
|
|
uniform vec2 delta;
|
|
uniform vec2 texSize;
|
|
|
|
float random(vec3 scale, float seed) {
|
|
return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
|
|
}
|
|
|
|
void main(void) {
|
|
// textureCoord to pixelCoord
|
|
vec2 pixelCoord = vTextureCoord * filterArea.xy - vec2(4.0, 4.0); // FIXME: There's a shift of 4 * 4 pixels, don't know why...
|
|
|
|
bool inside = false;
|
|
|
|
if (shape == 1) {
|
|
inside = distance(pixelCoord, circle.xy) <= circle.z;
|
|
} else if (shape == 2) {
|
|
inside = pixelCoord.x >= rectangle.x && pixelCoord.x <= rectangle.z && pixelCoord.y >= rectangle.y && pixelCoord.y <= rectangle.w;
|
|
}
|
|
|
|
if (inside) {
|
|
vec4 color = vec4(0.0);
|
|
float total = 0.0;
|
|
|
|
float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
|
|
|
|
for (float t = -30.0; t <= 30.0; t++) {
|
|
float percent = (t + offset - 0.5) / 30.0;
|
|
float weight = 1.0 - abs(percent);
|
|
vec4 sample = texture2D(uSampler, vTextureCoord + delta / texSize * percent * blur);
|
|
sample.rgb *= sample.a;
|
|
color += sample * weight;
|
|
total += weight;
|
|
}
|
|
|
|
gl_FragColor = color / total;
|
|
gl_FragColor.rgb /= gl_FragColor.a + 0.00001;
|
|
} else {
|
|
gl_FragColor = texture2D(uSampler, vec2(vTextureCoord.s, vTextureCoord.t));
|
|
}
|
|
}
|
|
`;
|
|
|
|
super(vertex, fragment);
|
|
|
|
if (shape.type === 'circle') {
|
|
this.uniforms.shape = 1;
|
|
this.uniforms.circle = [shape.x, shape.y, shape.r];
|
|
} else {
|
|
this.uniforms.shape = 2;
|
|
this.uniforms.rectangle = [shape.x, shape.y, shape.x + shape.width, shape.y + shape.height];
|
|
}
|
|
this.uniforms.blur = blur;
|
|
this.uniforms.delta = new PIXI.Point(0, 0);
|
|
this.uniforms.texSize = new PIXI.Point(480, 270);
|
|
|
|
this.updateDelta();
|
|
}
|
|
|
|
/**
|
|
* The strength of the blur.
|
|
*
|
|
* @member {number}
|
|
* @memberof PIXI.filters.TiltShiftAxisFilter#
|
|
*/
|
|
get blur() {
|
|
return this.uniforms.blur
|
|
}
|
|
set blur(value) {
|
|
this.uniforms.blur = value;
|
|
}
|
|
|
|
/**
|
|
* The blur shape.
|
|
*
|
|
* @member {PIXI.Rectangle}
|
|
* @memberof PIXI.filters.TiltShiftAxisFilter#
|
|
*/
|
|
get shape() {
|
|
if (this.uniforms.shape === 1) {
|
|
const circle = this.uniforms.circle;
|
|
return new PIXI.Circle(circle[0], circle[1], circle[2])
|
|
} else {
|
|
const rectangle = this.uniforms.rectangle;
|
|
return new PIXI.Rectangle(rectangle[0], rectangle[1], rectangle[2], rectangle[3])
|
|
}
|
|
}
|
|
set shape(value) {
|
|
if (value.type === 'circle') {
|
|
this.uniforms.shape = 1;
|
|
this.uniforms.circle = [value.x, value.y, value.r];
|
|
} else {
|
|
this.uniforms.shape = 2;
|
|
this.uniforms.rectangle = [value.x, value.y, value.x + value.width, value.y + value.height];
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A TiltShiftXFilter.
|
|
*
|
|
* @class
|
|
* @extends PIXI.TiltShiftAxisFilter
|
|
* @private
|
|
*/
|
|
class TiltShiftXFilter extends TiltShiftAxisFilter {
|
|
/**
|
|
* Updates the filter delta values.
|
|
*/
|
|
updateDelta() {
|
|
this.uniforms.delta.x = 0.1;
|
|
this.uniforms.delta.y = 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A TiltShiftYFilter.
|
|
*
|
|
* @class
|
|
* @extends PIXI.TiltShiftAxisFilter
|
|
* @private
|
|
*/
|
|
class TiltShiftYFilter extends TiltShiftAxisFilter {
|
|
/**
|
|
* Updates the filter delta values.
|
|
*/
|
|
updateDelta() {
|
|
this.uniforms.delta.x = 0;
|
|
this.uniforms.delta.y = 0.1;
|
|
}
|
|
}
|
|
|
|
// In order to test this interface implementation run jsc interface.js
|
|
|
|
class Interface {
|
|
// Abstract interface that should be extended in interface subclasses.
|
|
// By convention all interfaces should start with an upper 'I'
|
|
|
|
static implementationError(klass) {
|
|
let interfaceKeys = Reflect.ownKeys(this.prototype);
|
|
let classKeys = Reflect.ownKeys(klass.prototype);
|
|
for(let key of interfaceKeys) {
|
|
let interfaceDesc = this.prototype[key];
|
|
let classDesc = klass.prototype[key];
|
|
if (typeof(classDesc) == 'undefined')
|
|
return 'Missing ' + key
|
|
}
|
|
return null
|
|
}
|
|
|
|
static implementedBy(klass) {
|
|
// In the first step only checks whether the methods of this
|
|
// interface are all implemented by the given class
|
|
let error = this.implementationError(klass);
|
|
return error == null
|
|
}
|
|
|
|
// TODO: Specify optional methods
|
|
// static optionalMethods() {
|
|
// return [this.onMouseWheel]
|
|
// }
|
|
}
|
|
|
|
/* globals Hammer, propagating */
|
|
|
|
/** Interaction patterns
|
|
|
|
See interaction.html for explanation
|
|
*/
|
|
|
|
class IInteractionTarget extends Interface {
|
|
capture(event) {
|
|
return typeof true
|
|
}
|
|
|
|
onStart(event, interaction) { }
|
|
onMove(event, interaction) { }
|
|
onEnd(event, interaction) { }
|
|
|
|
onMouseWheel(event) { }
|
|
}
|
|
|
|
class IInteractionMapperTarget extends Interface {
|
|
capture(event) {
|
|
return typeof true
|
|
}
|
|
|
|
findTarget(event, local, global) {
|
|
return IInteractionTarget
|
|
}
|
|
}
|
|
|
|
class PointMap extends MapProxy {
|
|
// Collects touch points, mouse coordinates, etc. as key value pairs.
|
|
// Keys are pointer and touch ids, the special "mouse" key.
|
|
// Values are points, i.e. all objects with numeric x and y properties.
|
|
constructor(points = {}) {
|
|
super();
|
|
for (let key in points) {
|
|
this.set(key, points[key]);
|
|
}
|
|
}
|
|
|
|
toString() {
|
|
let points = [];
|
|
for (let key of this.keys()) {
|
|
let value = this.get(key);
|
|
points.push(`${key}:{x:${value.x}, y:${value.y}}`);
|
|
}
|
|
let attrs = points.join(', ');
|
|
return `[PointMap ${attrs}]`
|
|
}
|
|
|
|
clone() {
|
|
let result = new PointMap();
|
|
for (let key of this.keys()) {
|
|
let value = this.get(key);
|
|
result.set(key, { x: value.x, y: value.y });
|
|
}
|
|
return result
|
|
}
|
|
|
|
keyOf(value) {
|
|
for (let key of this.keys()) {
|
|
let p = this.get(key);
|
|
if (p.x == value.x && p.y == value.y) {
|
|
return key
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
|
|
firstKey() {
|
|
for (let key of this.keys()) {
|
|
return key
|
|
}
|
|
return null
|
|
}
|
|
|
|
first() {
|
|
for (let key of this.keys()) {
|
|
return this.get(key)
|
|
}
|
|
return null
|
|
}
|
|
|
|
farthests() {
|
|
if (this.size == 0) {
|
|
return null
|
|
}
|
|
let pairs = [];
|
|
for (let key of this.keys()) {
|
|
let p = this.get(key);
|
|
p.key = key;
|
|
for (let k of this.keys()) {
|
|
let q = this.get(k);
|
|
q.key = k;
|
|
pairs.push([p, q]);
|
|
}
|
|
}
|
|
let sorted = pairs.sort((a, b) => {
|
|
return Points.distance(b[0], b[1]) - Points.distance(a[0], a[1])
|
|
});
|
|
return sorted[0]
|
|
}
|
|
|
|
mean() {
|
|
if (this.size == 0) {
|
|
return null
|
|
}
|
|
let x = 0.0,
|
|
y = 0.0;
|
|
for (let p of this.values()) {
|
|
x += p.x;
|
|
y += p.y;
|
|
}
|
|
return { x: x / this.size, y: y / this.size }
|
|
}
|
|
}
|
|
|
|
class InteractionDelta {
|
|
constructor(x, y, zoom, rotate, about) {
|
|
this.x = x;
|
|
this.y = y;
|
|
this.zoom = zoom;
|
|
this.rotate = rotate;
|
|
this.about = about;
|
|
}
|
|
|
|
toString() {
|
|
let values = [];
|
|
for (let key of Object.keys(this)) {
|
|
let value = this[key];
|
|
if (key == 'about') {
|
|
values.push(`${key}:{x:${value.x}, y:${value.y}}`);
|
|
} else {
|
|
values.push(`${key}:${value}`);
|
|
}
|
|
}
|
|
let attrs = values.join(', ');
|
|
return `[InteractionDelta ${attrs}]`
|
|
}
|
|
}
|
|
|
|
class InteractionPoints {
|
|
constructor(parent = null) {
|
|
this.parent = parent;
|
|
this.current = new PointMap();
|
|
this.previous = new PointMap();
|
|
this.start = new PointMap();
|
|
this.ended = new PointMap();
|
|
this.timestamps = new Map();
|
|
}
|
|
|
|
moved(key) {
|
|
let current = this.current.get(key);
|
|
let previous = this.previous.get(key);
|
|
return Points.subtract(current, previous)
|
|
}
|
|
|
|
move() {
|
|
let current = this.current.mean();
|
|
let previous = this.previous.mean();
|
|
return Points.subtract(current, previous)
|
|
}
|
|
|
|
/**
|
|
* Computes the delta between previous and current angles. Corrects
|
|
* value that are larger than 45°
|
|
* @param {*} a
|
|
* @param {*} b
|
|
* @returns delta
|
|
*/
|
|
diffAngle(a, b) {
|
|
let alpha = Math.atan2(Math.sin(a - b), Math.cos(a - b));
|
|
if (Math.abs(alpha) > Math.PI / 4) {
|
|
alpha -= Math.PI;
|
|
}
|
|
return alpha
|
|
}
|
|
|
|
/**
|
|
* Computes the delta between interaction points at t and t+1.
|
|
*
|
|
* @returns InteractionDelta
|
|
* @memberof InteractionPoints
|
|
*/
|
|
delta() {
|
|
let csize = this.current.size;
|
|
let psize = this.previous.size;
|
|
if (csize >= 2 && csize == psize) {
|
|
// Reduce to the two farthests points
|
|
let current = this.current.farthests();
|
|
|
|
let c1 = current[0];
|
|
let c2 = current[1];
|
|
|
|
let p1 = this.previous.get(c1.key);
|
|
let p2 = this.previous.get(c2.key);
|
|
|
|
//let p1 = previous[0]
|
|
//let p2 = previous[1]
|
|
|
|
let d1 = Points.subtract(c1, p1);
|
|
let d2 = Points.subtract(c2, p2);
|
|
let cm = Points.mean(c1, c2);
|
|
//let pm = Points.mean(p1, p2)
|
|
// UO: Using the mean lead to jumps between time slices with 3 and 2 fingers
|
|
// We use the mean of deltas instead
|
|
let delta = Points.mean(d1, d2); //Points.subtract(cm, pm)
|
|
let zoom = 1.0;
|
|
let distance1 = Points.distance(p1, p2);
|
|
let distance2 = Points.distance(c1, c2);
|
|
if (distance1 != 0 && distance2 != 0) {
|
|
zoom = distance2 / distance1;
|
|
}
|
|
let currentAngle = Points.angle(c1, c2);
|
|
let previousAngle = Points.angle(p1, p2);
|
|
let alpha = this.diffAngle(currentAngle, previousAngle);
|
|
return new InteractionDelta(delta.x, delta.y, zoom, alpha, cm)
|
|
} else if (csize == 1 && psize == 1 && this.current.firstKey() == this.previous.firstKey()) {
|
|
// We need to ensure that the keys are the same
|
|
let current = this.current.first();
|
|
let previous = this.previous.first();
|
|
let delta = Points.subtract(current, previous);
|
|
return new InteractionDelta(delta.x, delta.y, 1.0, 0.0, current)
|
|
}
|
|
return null
|
|
}
|
|
|
|
started(key, point) {
|
|
this.current.set(key, point);
|
|
this.start.set(key, point);
|
|
this.previous.set(key, point);
|
|
this.timestamps.set(key, performance.now());
|
|
}
|
|
|
|
update(key, point) {
|
|
// Returns true iff the key is new
|
|
this.current.set(key, point);
|
|
if (!this.start.has(key)) {
|
|
this.start.set(key, point);
|
|
this.previous.set(key, point);
|
|
this.timestamps.set(key, performance.now());
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
updatePrevious() {
|
|
for (let key of this.current.keys()) {
|
|
this.previous.set(key, this.current.get(key));
|
|
}
|
|
}
|
|
|
|
stop(key, point) {
|
|
if (this.current.has(key)) {
|
|
this.current.delete(key);
|
|
this.previous.delete(key);
|
|
this.ended.set(key, point);
|
|
}
|
|
}
|
|
|
|
finish(key, point) {
|
|
this.current.delete(key);
|
|
this.previous.delete(key);
|
|
this.start.delete(key);
|
|
this.timestamps.delete(key);
|
|
this.ended.delete(key);
|
|
}
|
|
|
|
isFinished() {
|
|
return this.current.size == 0
|
|
}
|
|
|
|
isNoLongerTwoFinger() {
|
|
return this.previous.size > 1 && this.current.size < 2
|
|
}
|
|
|
|
isTap(key) {
|
|
return this.parent.isTap(key)
|
|
}
|
|
|
|
isDoubleTap(key) {
|
|
return this.parent.isDoubleTap(key)
|
|
}
|
|
|
|
isLongPress(key) {
|
|
return this.parent.isLongPress(key)
|
|
}
|
|
}
|
|
|
|
class Interaction extends InteractionPoints {
|
|
constructor(tapDistance = 10, tapDuration = 250.0, longPressTime = 500.0) {
|
|
super();
|
|
this.tapDistance = tapDistance;
|
|
this.tapCounts = new Map();
|
|
this.tapPositions = new Map();
|
|
this.tapTimestamps = new Map();
|
|
this.tapDuration = tapDuration;
|
|
this.longPressTime = longPressTime;
|
|
this.targets = new Map();
|
|
this.subInteractions = new Map(); // target:Object : InteractionPoints
|
|
}
|
|
|
|
stop(key, point) {
|
|
super.stop(key, point);
|
|
for (let points of this.subInteractions.values()) {
|
|
points.stop(key, point);
|
|
}
|
|
}
|
|
|
|
addTarget(key, target) {
|
|
this.targets.set(key, target);
|
|
this.subInteractions.set(target, new InteractionPoints(this));
|
|
}
|
|
|
|
removeTarget(key) {
|
|
let target = this.targets.get(key);
|
|
this.targets.delete(key);
|
|
// Only remove target if no keys are refering to the target
|
|
let remove = true;
|
|
for (let t of this.targets.values()) {
|
|
if (target === t) {
|
|
remove = false;
|
|
}
|
|
}
|
|
if (remove) {
|
|
this.subInteractions.delete(target);
|
|
}
|
|
}
|
|
|
|
finish(key, point) {
|
|
super.finish(key, point);
|
|
this.removeTarget(key);
|
|
}
|
|
|
|
mapInteraction(points, aspects, mappingFunc) {
|
|
// Map centrally registered points to target interactions
|
|
// Returns an array of [target, updated subInteraction] pairs
|
|
let result = new Map();
|
|
for (let key in points) {
|
|
if (this.targets.has(key)) {
|
|
let target = this.targets.get(key);
|
|
if (this.subInteractions.has(target)) {
|
|
let interaction = this.subInteractions.get(target);
|
|
for (let aspect of aspects) {
|
|
let pointMap = this[aspect];
|
|
let point = pointMap.get(key);
|
|
let mapped = mappingFunc(point, target);
|
|
interaction[aspect].set(key, mapped);
|
|
}
|
|
result.set(target, interaction);
|
|
}
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
registerTap(key, point) {
|
|
if (this.tapCounts.has(key)) {
|
|
let count = this.tapCounts.get(key);
|
|
this.tapCounts.set(key, count+1);
|
|
}
|
|
else {
|
|
this.tapCounts.set(key, 1);
|
|
}
|
|
this.tapPositions.set(key, point);
|
|
this.tapTimestamps.set(key, performance.now());
|
|
}
|
|
|
|
unregisterTap(key) {
|
|
this.tapCounts.delete(key);
|
|
this.tapPositions.delete(key);
|
|
this.tapTimestamps.delete(key);
|
|
}
|
|
|
|
isTap(key) {
|
|
let ended = this.ended.get(key);
|
|
let start = this.start.get(key);
|
|
if (
|
|
start &&
|
|
ended &&
|
|
Points.distance(ended, start) < this.tapDistance
|
|
) {
|
|
let t1 = this.timestamps.get(key);
|
|
let tookLong = performance.now() > t1 + this.longPressTime;
|
|
if (tookLong) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
isDoubleTap(key) {
|
|
let ended = this.ended.get(key);
|
|
if (this.tapCounts.has(key) && this.tapCounts.get(key) > 2) {
|
|
this.unregisterTap(key);
|
|
}
|
|
if (this.tapPositions.has(key)) {
|
|
let pos = this.tapPositions.get(key);
|
|
if (Points.distance(ended, pos) > this.tapDistance) {
|
|
this.unregisterTap(key);
|
|
}
|
|
}
|
|
if (this.tapTimestamps.has(key) && performance.now() > this.tapTimestamps.get(key) + this.tapDuration) {
|
|
//console.log("tap too long")
|
|
this.unregisterTap(key);
|
|
}
|
|
let result = false;
|
|
if (this.isTap(key)) {
|
|
|
|
this.registerTap(key, ended);
|
|
result = this.tapCounts.get(key) == 2;
|
|
}
|
|
else {
|
|
this.unregisterTap(key);
|
|
}
|
|
//console.log("isDoubleTap", this.tapCounts.get(key), result)
|
|
return result
|
|
}
|
|
|
|
isAnyTap() {
|
|
for (let key of this.ended.keys()) {
|
|
if (this.isTap(key)) return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
isLongPress(key) {
|
|
let ended = this.ended.get(key);
|
|
let start = this.start.get(key);
|
|
if (
|
|
start &&
|
|
ended &&
|
|
Points.distance(ended, start) < this.tapDistance
|
|
) {
|
|
let t1 = this.timestamps.get(key);
|
|
let tookLong = performance.now() > t1 + this.longPressTime;
|
|
if (tookLong) {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
return false
|
|
}
|
|
|
|
isAnyLongPress() {
|
|
for (let key of this.ended.keys()) {
|
|
if (this.isLongPress(key)) return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
isStylus(key) {
|
|
return key === 'stylus'
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This class implements the main delegate functionality: All necessary event handlers are registered for the
|
|
* given element. Uses PointerEvents if available or TouchEvents on iOS. The fallback is on mouse events.
|
|
* Collects the events if the interaction target captures the start event (i.e. declares that
|
|
* the target wants the start event as well as all following move and end evcents.)
|
|
*
|
|
* @export
|
|
* @class InteractionDelegate
|
|
*/
|
|
class InteractionDelegate {
|
|
// Long press: http://stackoverflow.com/questions/1930895/how-long-is-the-event-onlongpress-in-the-android
|
|
// Stylus support: https://w3c.github.io/touch-events/
|
|
|
|
/**
|
|
* Creates an instance of InteractionDelegate.
|
|
* @param {any} element
|
|
* @param {any} target
|
|
* @param {any} [{ mouseWheelElement = null, useCapture = true, capturePointerEvents = true, debug = false }={}]
|
|
* @memberof InteractionDelegate
|
|
*/
|
|
constructor(
|
|
element,
|
|
target,
|
|
{ mouseWheelElement = null, useCapture = true, capturePointerEvents = true, cancelOnWindowOut = true, debug = false } = {}
|
|
) {
|
|
this.debug = debug;
|
|
this.interaction = new Interaction();
|
|
this.element = element;
|
|
this.mouseWheelElement = mouseWheelElement || element;
|
|
this.target = target;
|
|
this.useCapture = useCapture;
|
|
this.capturePointerEvents = capturePointerEvents;
|
|
this.cancelOnWindowOut = cancelOnWindowOut;
|
|
this.setupInteraction();
|
|
}
|
|
|
|
setupInteraction() {
|
|
if (this.debug) {
|
|
let error = this.targetInterface.implementationError(
|
|
this.target.constructor
|
|
);
|
|
if (error != null) {
|
|
throw new Error('Expected IInteractionTarget: ' + error)
|
|
}
|
|
}
|
|
this.setupTouchInteraction();
|
|
this.setupMouseWheelInteraction();
|
|
}
|
|
|
|
get targetInterface() {
|
|
return IInteractionTarget
|
|
}
|
|
|
|
setupTouchInteraction() {
|
|
let element = this.element;
|
|
let useCapture = this.useCapture;
|
|
if (window.PointerEvent) {
|
|
if (this.debug) console.log('Pointer API' + window.PointerEvent);
|
|
element.addEventListener(
|
|
'pointerdown',
|
|
e => {
|
|
if (this.debug) console.log('pointerdown', e.pointerId);
|
|
if (this.capture(e)) {
|
|
if (this.capturePointerEvents) {
|
|
try {
|
|
element.setPointerCapture(e.pointerId);
|
|
} catch (e) { }
|
|
}
|
|
this.onStart(e);
|
|
}
|
|
},
|
|
useCapture
|
|
);
|
|
element.addEventListener(
|
|
'pointermove',
|
|
e => {
|
|
if (this.debug) console.log('pointermove', e.pointerId);
|
|
|
|
if (
|
|
e.pointerType == 'touch' ||
|
|
(e.pointerType == 'mouse' && Events$1.isMouseDown(e))
|
|
) {
|
|
// this.capture(e) &&
|
|
if (this.debug)
|
|
console.log('pointermove captured', e.pointerId);
|
|
this.onMove(e);
|
|
}
|
|
},
|
|
useCapture
|
|
);
|
|
element.addEventListener(
|
|
'pointerup',
|
|
e => {
|
|
if (this.debug) console.log('pointerup');
|
|
this.onEnd(e);
|
|
if (this.capturePointerEvents) {
|
|
try {
|
|
element.releasePointerCapture(e.pointerId);
|
|
} catch (e) { }
|
|
}
|
|
},
|
|
useCapture
|
|
);
|
|
element.addEventListener(
|
|
'pointercancel',
|
|
e => {
|
|
if (this.debug) console.log('pointercancel');
|
|
this.onEnd(e);
|
|
if (this.capturePointerEvents)
|
|
element.releasePointerCapture(e.pointerId);
|
|
},
|
|
useCapture
|
|
);
|
|
|
|
if (!this.capturePointerEvents) {
|
|
element.addEventListener(
|
|
'pointerleave',
|
|
e => {
|
|
if (this.debug) console.log('pointerleave');
|
|
if (e.target == element) this.onEnd(e);
|
|
},
|
|
useCapture
|
|
);
|
|
}
|
|
|
|
if (!this.capturePointerEvents) {
|
|
element.addEventListener(
|
|
'pointerout',
|
|
e => {
|
|
if (this.debug) console.log('pointerout');
|
|
if (e.target == element) this.onEnd(e);
|
|
},
|
|
useCapture
|
|
);
|
|
}
|
|
|
|
if (this.cancelOnWindowOut) {
|
|
window.addEventListener(
|
|
'pointerout',
|
|
e => {
|
|
if (e.target == element) {
|
|
this.onEnd(e);
|
|
}
|
|
},
|
|
useCapture);
|
|
}
|
|
|
|
} else if (window.TouchEvent) {
|
|
if (this.debug) console.log('Touch API');
|
|
element.addEventListener(
|
|
'touchstart',
|
|
e => {
|
|
if (this.debug)
|
|
console.log('touchstart', this.touchPoints(e));
|
|
if (this.capture(e)) {
|
|
for (let touch of e.changedTouches) {
|
|
this.onStart(touch);
|
|
}
|
|
}
|
|
},
|
|
useCapture
|
|
);
|
|
element.addEventListener(
|
|
'touchmove',
|
|
e => {
|
|
if (this.debug)
|
|
console.log('touchmove', this.touchPoints(e), e);
|
|
for (let touch of e.changedTouches) {
|
|
this.onMove(touch);
|
|
}
|
|
for (let touch of e.targetTouches) {
|
|
this.onMove(touch);
|
|
}
|
|
},
|
|
useCapture
|
|
);
|
|
element.addEventListener(
|
|
'touchend',
|
|
e => {
|
|
if (this.debug) console.log('touchend', this.touchPoints(e));
|
|
for (let touch of e.changedTouches) {
|
|
this.onEnd(touch);
|
|
}
|
|
},
|
|
useCapture
|
|
);
|
|
element.addEventListener(
|
|
'touchcancel',
|
|
e => {
|
|
if (this.debug)
|
|
console.log(
|
|
'touchcancel',
|
|
e.targetTouches.length,
|
|
e.changedTouches.length
|
|
);
|
|
for (let touch of e.changedTouches) {
|
|
this.onEnd(touch);
|
|
}
|
|
},
|
|
useCapture
|
|
);
|
|
} else {
|
|
if (this.debug) console.log('Mouse API');
|
|
|
|
element.addEventListener(
|
|
'mousedown',
|
|
e => {
|
|
if (this.debug) console.log('mousedown', e);
|
|
if (this.capture(e)) {
|
|
this.onStart(e);
|
|
}
|
|
},
|
|
useCapture
|
|
);
|
|
element.addEventListener(
|
|
'mousemove',
|
|
e => {
|
|
// Dow we only use move events if the mouse is down?
|
|
// HOver effects have to be implemented by other means
|
|
// && Events.isMouseDown(e))
|
|
|
|
if (Events$1.isMouseDown(e)) {
|
|
if (this.debug)
|
|
console.log('mousemove', e);
|
|
this.onMove(e);
|
|
}
|
|
},
|
|
useCapture
|
|
);
|
|
element.addEventListener(
|
|
'mouseup',
|
|
e => {
|
|
if (this.debug) console.log('mouseup', e);
|
|
this.onEnd(e);
|
|
},
|
|
true
|
|
);
|
|
|
|
if (!this.capturePointerEvents) {
|
|
element.addEventListener(
|
|
'mouseout',
|
|
e => {
|
|
if (e.target == element) {
|
|
this.onEnd(e);
|
|
console.warn("Shouldn't happen: mouseout ends interaction");
|
|
}
|
|
|
|
},
|
|
useCapture
|
|
);
|
|
}
|
|
if (this.cancelOnWindowOut) {
|
|
window.addEventListener(
|
|
'mouseout',
|
|
e => {
|
|
if (e.target == element) {
|
|
this.onEnd(e);
|
|
}
|
|
},
|
|
useCapture);
|
|
}
|
|
}
|
|
}
|
|
|
|
isDescendant(parent, child) {
|
|
if (parent == child) return true
|
|
let node = child.parentNode;
|
|
while (node != null) {
|
|
if (node == parent) {
|
|
return true
|
|
}
|
|
node = node.parentNode;
|
|
}
|
|
return false
|
|
}
|
|
|
|
touchPoints(event) {
|
|
let result = [];
|
|
for (let touch of event.changedTouches) {
|
|
result.push(this.extractPoint(touch));
|
|
}
|
|
return result
|
|
}
|
|
|
|
setupMouseWheelInteraction() {
|
|
this.mouseWheelElement.addEventListener(
|
|
'mousewheel',
|
|
this.onMouseWheel.bind(this),
|
|
true
|
|
);
|
|
this.mouseWheelElement.addEventListener(
|
|
'DOMMouseScroll',
|
|
this.onMouseWheel.bind(this),
|
|
true
|
|
);
|
|
}
|
|
|
|
onMouseWheel(event) {
|
|
if (this.capture(event) && this.target.onMouseWheel) {
|
|
this.target.onMouseWheel(event);
|
|
}
|
|
}
|
|
|
|
onStart(event) {
|
|
let extracted = this.extractPoint(event);
|
|
this.startInteraction(event, extracted);
|
|
this.target.onStart(event, this.interaction);
|
|
}
|
|
|
|
onMove(event) {
|
|
let extracted = this.extractPoint(event, 'all');
|
|
this.updateInteraction(event, extracted);
|
|
this.target.onMove(event, this.interaction);
|
|
this.interaction.updatePrevious();
|
|
}
|
|
|
|
onEnd(event) {
|
|
let extracted = this.extractPoint(event, 'changedTouches');
|
|
this.endInteraction(event, extracted);
|
|
this.target.onEnd(event, this.interaction);
|
|
this.finishInteraction(event, extracted);
|
|
}
|
|
|
|
/**
|
|
* Asks the target whether the event should be captured
|
|
*
|
|
* @param {any} event
|
|
* @returns {bool}
|
|
* @memberof InteractionDelegate
|
|
*/
|
|
capture(event) {
|
|
if (Events$1.isCaptured(event)) {
|
|
return false
|
|
}
|
|
let captured = this.target.capture(event);
|
|
return captured
|
|
}
|
|
|
|
getPosition(event) {
|
|
return { x: event.clientX, y: event.clientY }
|
|
}
|
|
|
|
extractPoint(event, touchEventKey = 'all') {
|
|
// 'targetTouches'
|
|
let result = {};
|
|
switch (event.constructor.name) {
|
|
case 'MouseEvent':
|
|
let buttons = event.buttons || event.which;
|
|
if (buttons) result['mouse'] = this.getPosition(event);
|
|
break
|
|
case 'PointerEvent':
|
|
result[event.pointerId.toString()] = this.getPosition(event);
|
|
break
|
|
case 'Touch':
|
|
let id =
|
|
event.touchType === 'stylus'
|
|
? 'stylus'
|
|
: event.identifier.toString();
|
|
result[id] = this.getPosition(event);
|
|
break
|
|
// case 'TouchEvent':
|
|
// // Needs to be observed: Perhaps changedTouches are all we need. If so
|
|
// // we can remove the touchEventKey default parameter
|
|
// if (touchEventKey == 'all') {
|
|
// for(let t of event.targetTouches) {
|
|
// result[t.identifier.toString()] = this.getPosition(t)
|
|
// }
|
|
// for(let t of event.changedTouches) {
|
|
// result[t.identifier.toString()] = this.getPosition(t)
|
|
// }
|
|
// }
|
|
// else {
|
|
// for(let t of event.changedTouches) {
|
|
// result[t.identifier.toString()] = this.getPosition(t)
|
|
// }
|
|
// }
|
|
// break
|
|
default:
|
|
break
|
|
}
|
|
return result
|
|
}
|
|
|
|
interactionStarted(event, key, point) {
|
|
// Callback: can be overwritten
|
|
}
|
|
|
|
interactionEnded(event, key, point) {
|
|
// Callback: can be overwritten
|
|
}
|
|
|
|
interactionFinished(event, key, point) { }
|
|
|
|
startInteraction(event, extracted) {
|
|
for (let key in extracted) {
|
|
let point = extracted[key];
|
|
this.interaction.started(key, point);
|
|
this.interactionStarted(event, key, point);
|
|
}
|
|
}
|
|
|
|
updateInteraction(event, extracted) {
|
|
for (let key in extracted) {
|
|
let point = extracted[key];
|
|
let updated = this.interaction.update(key, point);
|
|
if (updated) {
|
|
console.warn("new pointer in updateInteraction shouldn't happen");
|
|
this.interactionStarted(event, key, point);
|
|
}
|
|
}
|
|
}
|
|
|
|
endInteraction(event, ended) {
|
|
for (let key in ended) {
|
|
let point = ended[key];
|
|
this.interaction.stop(key, point);
|
|
this.interactionEnded(event, key, point);
|
|
}
|
|
}
|
|
|
|
finishInteraction(event, ended) {
|
|
for (let key in ended) {
|
|
let point = ended[key];
|
|
this.interaction.finish(key, point);
|
|
this.interactionFinished(event, key, point);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* A special InteractionDelegate that maps events to specific parts of
|
|
* the interaction target. The InteractionTarget must implement a findTarget
|
|
* method that returns an object implementing the IInteractionTarget interface.
|
|
*
|
|
* If the InteractionTarget also implements a mapPositionToPoint method this
|
|
* is used to map the points to the local coordinate space of the the target.
|
|
*
|
|
* This makes it easier to lookup elements and relate events to local
|
|
* positions.
|
|
*
|
|
* @export
|
|
* @class InteractionMapper
|
|
* @extends {InteractionDelegate}
|
|
*/
|
|
class InteractionMapper$1 extends InteractionDelegate {
|
|
|
|
constructor(
|
|
element,
|
|
target,
|
|
{ tapDistance = 10, longPressTime = 500.0, useCapture = true, mouseWheelElement = null } = {}
|
|
) {
|
|
super(element, target, { tapDistance, useCapture, longPressTime, mouseWheelElement });
|
|
}
|
|
|
|
get targetInterface() {
|
|
return IInteractionMapperTarget
|
|
}
|
|
|
|
mapPositionToPoint(point, element = null) {
|
|
if (this.target.mapPositionToPoint) {
|
|
return this.target.mapPositionToPoint(point, element)
|
|
}
|
|
return point
|
|
}
|
|
|
|
interactionStarted(event, key, point) {
|
|
if (this.target.findTarget) {
|
|
let local = this.mapPositionToPoint(point);
|
|
let found = this.target.findTarget(event, local, point);
|
|
if (found != null) {
|
|
this.interaction.addTarget(key, found);
|
|
}
|
|
}
|
|
}
|
|
|
|
onMouseWheel(event) {
|
|
if (this.capture(event)) {
|
|
if (this.target.findTarget) {
|
|
let point = this.getPosition(event);
|
|
let local = this.mapPositionToPoint(point);
|
|
let found = this.target.findTarget(event, local, point);
|
|
if (found != null && found.onMouseWheel) {
|
|
found.onMouseWheel(event);
|
|
return
|
|
}
|
|
}
|
|
if (this.target.onMouseWheel) {
|
|
this.target.onMouseWheel(event);
|
|
}
|
|
}
|
|
}
|
|
|
|
onStart(event) {
|
|
let extracted = this.extractPoint(event);
|
|
this.startInteraction(event, extracted);
|
|
let mapped = this.interaction.mapInteraction(
|
|
extracted,
|
|
['current', 'start'],
|
|
this.mapPositionToPoint.bind(this)
|
|
);
|
|
for (let [target, interaction] of mapped.entries()) {
|
|
target.onStart(event, interaction);
|
|
}
|
|
}
|
|
|
|
onMove(event) {
|
|
let extracted = this.extractPoint(event, 'all');
|
|
this.updateInteraction(event, extracted);
|
|
let mapped = this.interaction.mapInteraction(
|
|
extracted,
|
|
['current', 'previous'],
|
|
this.mapPositionToPoint.bind(this)
|
|
);
|
|
for (let [target, interaction] of mapped.entries()) {
|
|
target.onMove(event, interaction);
|
|
interaction.updatePrevious();
|
|
}
|
|
this.interaction.updatePrevious();
|
|
}
|
|
|
|
onEnd(event) {
|
|
let extracted = this.extractPoint(event, 'changedTouches');
|
|
this.endInteraction(event, extracted);
|
|
let mapped = this.interaction.mapInteraction(
|
|
extracted,
|
|
['ended'],
|
|
this.mapPositionToPoint.bind(this)
|
|
);
|
|
for (let [target, interaction] of mapped.entries()) {
|
|
target.onEnd(event, interaction);
|
|
}
|
|
this.finishInteraction(event, extracted);
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
* @static
|
|
* @param {string|array} types - An event type, an array of event types or event types seperated by a space sign. The following
|
|
* events are possible:
|
|
* pan, panstart, panmove, panend, pancancel, panleft, panright, panup, pandown
|
|
* pinch, pinchstart, pinchmove, pinchend, pinchcancel, pinchin, pinchout
|
|
* press, pressup
|
|
* rotate, rotatestart, rotatemove, rotateend, rotatecancel
|
|
* swipe, swipeleft, swiperight, swipeup, swipedown
|
|
* tap
|
|
* @param {HTMLElement|HTMLElement[]} elements - An HTML element or an array of HTML elements.
|
|
* @param {function} [cb] - The callback. A function which is executed after the event occurs. Receives the event object as the
|
|
* first paramter
|
|
* @param {object} [opts] - An options object. See the hammer documentation for more details.
|
|
*/
|
|
static on(types, elements, cb, opts = {}) {
|
|
opts = Object.assign({}, {
|
|
|
|
}, opts);
|
|
|
|
if (typeof Hammer === 'undefined') {
|
|
console.error('Hammer.js not found!');
|
|
return this
|
|
}
|
|
|
|
// convert to array
|
|
types = Array.isArray(types) ? types : types.split(/\s/);
|
|
if (elements instanceof NodeList || elements instanceof HTMLCollection) {
|
|
elements = Array.from(elements);
|
|
}
|
|
elements = Array.isArray(elements) ? elements : [elements];
|
|
|
|
for (let i = 0; i < types.length; i++) {
|
|
|
|
const type = types[i].toLowerCase();
|
|
|
|
// list of hammer events
|
|
const useHammer = /^(tap|doubletap|press|pan|swipe|pinch|rotate).*$/.test(type);
|
|
|
|
// if it is a hammer event
|
|
if (useHammer) {
|
|
|
|
for (let j = 0; j < elements.length; j++) {
|
|
|
|
// if(elements[j].tagName == "svg") return false;
|
|
|
|
let hammer = new Hammer(elements[j], opts);
|
|
|
|
if (window.propagating !== 'undefined') {
|
|
hammer = propagating(hammer);
|
|
}
|
|
|
|
// recognizers
|
|
if (type.startsWith('pan')) {
|
|
hammer.get('pan').set(Object.assign({ direction: Hammer.DIRECTION_ALL }, opts));
|
|
} else if (type.startsWith('pinch')) {
|
|
hammer.get('pinch').set(Object.assign({ enable: true }, opts));
|
|
} else if (type.startsWith('press')) {
|
|
hammer.get('press').set(opts);
|
|
} else if (type.startsWith('rotate')) {
|
|
hammer.get('rotate').set(Object.assign({ enable: true }, opts));
|
|
} else if (type.startsWith('swipe')) {
|
|
hammer.get('swipe').set(Object.assign({ direction: Hammer.DIRECTION_ALL }, opts));
|
|
} else if (type.startsWith('tap')) {
|
|
hammer.get('tap').set(opts);
|
|
}
|
|
|
|
hammer.on(type, event => {
|
|
cb(event);
|
|
});
|
|
}
|
|
|
|
} else {
|
|
|
|
for (let j = 0; j < elements.length; j++) {
|
|
Hammer.on(elements[j], type, event => {
|
|
cb(event);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
return this
|
|
}
|
|
}
|
|
|
|
window.InteractionMapper = InteractionMapper$1;
|
|
|
|
/** Report capabilities with guaranteed values.
|
|
*/
|
|
class Capabilities {
|
|
|
|
/** Returns the browser userAgent.
|
|
@return {string}
|
|
*/
|
|
static get userAgent() {
|
|
return navigator.userAgent || 'Unknown Agent'
|
|
}
|
|
|
|
/** Tests whether the app is running on a mobile device.
|
|
Implemented as a readonly attribute.
|
|
@return {boolean}
|
|
*/
|
|
static get isMobile() {
|
|
return (/Mobi/.test(navigator.userAgent))
|
|
}
|
|
|
|
/** Tests whether the app is running on a iOS device.
|
|
Implemented as a readonly attribute.
|
|
@return {boolean}
|
|
*/
|
|
static get isIOS() {
|
|
return (/iPad|iPhone|iPod/.test(navigator.userAgent)) && !window.MSStream
|
|
}
|
|
|
|
/** Tests whether the app is running in a Safari environment.
|
|
See https://stackoverflow.com/questions/7944460/detect-safari-browser
|
|
Implemented as a readonly attribute.
|
|
@return {boolean}
|
|
*/
|
|
static get isSafari() {
|
|
return navigator.vendor && navigator.vendor.indexOf('Apple') > -1 && navigator.userAgent && !navigator.userAgent.match('CriOS')
|
|
}
|
|
|
|
/**
|
|
* Distincts if the app is running inside electron or not.
|
|
*
|
|
* source: https://discuss.atom.io/t/detect-electron-or-web-page-running/33180/3
|
|
*/
|
|
static get isElectron() {
|
|
return typeof process != 'undefined' && process.versions && process.versions.electron !== undefined
|
|
}
|
|
|
|
/** Returns the display resolution. Necessary for retina displays.
|
|
@return {number}
|
|
*/
|
|
static get devicePixelRatio() {
|
|
return window.devicePixelRatio || 1
|
|
}
|
|
|
|
/** Returns true if the device is a multi-touch table. This method is currently not universal usable and not sure!
|
|
@return {boolean}
|
|
*/
|
|
static get isMultiTouchTable() {
|
|
return Capabilities.devicePixelRatio > 2 && Capabilities.isMobile === false && /Windows/i.test(Capabilities.userAgent)
|
|
}
|
|
|
|
/** Returns true if mouse events are supported
|
|
@return {boolean}
|
|
*/
|
|
static supportsMouseEvents() {
|
|
return typeof(window.MouseEvent) != 'undefined'
|
|
}
|
|
|
|
/** Returns true if touch events are supported
|
|
@return {boolean}
|
|
*/
|
|
static supportsTouchEvents() {
|
|
return typeof(window.TouchEvent) != 'undefined'
|
|
}
|
|
|
|
/** Returns true if pointer events are supported
|
|
@return {boolean}
|
|
*/
|
|
static supportsPointerEvents() {
|
|
return typeof(window.PointerEvent) != 'undefined'
|
|
}
|
|
|
|
/** Returns true if DOM templates are supported
|
|
@return {boolean}
|
|
*/
|
|
static supportsTemplate() {
|
|
return 'content' in document.createElement('template');
|
|
}
|
|
}
|
|
|
|
/** Basic tests for Capabilities.
|
|
*/
|
|
class CapabilitiesTests {
|
|
|
|
static testConfirm() {
|
|
let bool = confirm('Please confirm');
|
|
document.getElementById('demo').innerHTML = (bool) ? 'Confirmed' : 'Not confirmed';
|
|
}
|
|
|
|
static testPrompt() {
|
|
let person = prompt('Please enter your name', 'Harry Potter');
|
|
if (person != null) {
|
|
demo.innerHTML =
|
|
'Hello ' + person + '! How are you today?';
|
|
}
|
|
}
|
|
|
|
static testUserAgent() {
|
|
let agent = 'User-agent: ' + Capabilities.userAgent;
|
|
user_agent.innerHTML = agent;
|
|
}
|
|
|
|
static testDevicePixelRatio() {
|
|
let value = 'Device Pixel Ratio: ' + Capabilities.devicePixelRatio;
|
|
device_pixel_ratio.innerHTML = value;
|
|
}
|
|
|
|
static testMultiTouchTable() {
|
|
let value = 'Is the device a multi-touch table? ' + Capabilities.isMultiTouchTable;
|
|
multi_touch_table.innerHTML = value;
|
|
}
|
|
|
|
static testSupportedEvents() {
|
|
let events = [];
|
|
if (Capabilities.supportsMouseEvents()) {
|
|
events.push('MouseEvents');
|
|
}
|
|
if (Capabilities.supportsTouchEvents()) {
|
|
events.push('TouchEvents');
|
|
}
|
|
if (Capabilities.supportsPointerEvents()) {
|
|
events.push('PointerEvents');
|
|
}
|
|
supported_events.innerHTML = 'Supported Events: ' + events.join(', ');
|
|
}
|
|
|
|
static testAll() {
|
|
this.testUserAgent();
|
|
this.testDevicePixelRatio();
|
|
this.testMultiTouchTable();
|
|
this.testSupportedEvents();
|
|
}
|
|
}
|
|
|
|
/* Optional global variables, needed in DocTests. */
|
|
window.Capabilities = Capabilities;
|
|
window.CapabilitiesTests = CapabilitiesTests;
|
|
|
|
/**
|
|
* A base class for scatter specific events.
|
|
*
|
|
* @constructor
|
|
* @param {name} String - The name of the event
|
|
* @param {target} Object - The target of the event
|
|
*/
|
|
class BaseEvent {
|
|
constructor(name, target) {
|
|
this.name = name;
|
|
this.target = target;
|
|
}
|
|
}
|
|
|
|
// Event types
|
|
const START = 'onStart';
|
|
const UPDATE = 'onUpdate';
|
|
const END = 'onEnd';
|
|
|
|
/**
|
|
* A scatter event that describes how the scatter has changed.
|
|
*
|
|
* @constructor
|
|
* @param {target} Object - The target scatter of the event
|
|
* @param {optional} Object - Optional parameter
|
|
*/
|
|
class ScatterEvent extends BaseEvent {
|
|
constructor(
|
|
target,
|
|
{
|
|
translate = { x: 0, y: 0 },
|
|
scale = null,
|
|
rotate = 0,
|
|
about = null,
|
|
fast = false,
|
|
type = null
|
|
} = {}
|
|
) {
|
|
super('scatterTransformed', { target: target });
|
|
this.translate = translate;
|
|
this.scale = scale;
|
|
this.rotate = rotate;
|
|
this.about = about;
|
|
this.fast = fast;
|
|
this.type = type;
|
|
}
|
|
|
|
toString() {
|
|
return (
|
|
"Event('scatterTransformed', scale: " +
|
|
this.scale +
|
|
' about: ' +
|
|
this.about.x +
|
|
', ' +
|
|
this.about.y +
|
|
')'
|
|
)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A scatter resize event that describes how the scatter has changed.
|
|
*
|
|
* @constructor
|
|
* @param {target} Object - The target scatter of the event
|
|
* @param {optional} Object - Optional parameter
|
|
*/
|
|
class ResizeEvent extends BaseEvent {
|
|
constructor(target, { width = 0, height = 0 } = {}) {
|
|
super('scatterResized', { width: width, height: height });
|
|
this.width = width;
|
|
this.height = height;
|
|
}
|
|
|
|
toString() {
|
|
return (
|
|
'Event(scatterResized width: ' +
|
|
this.width +
|
|
'height: ' +
|
|
this.height +
|
|
')'
|
|
)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A abstract base class that implements the throwable behavior of a scatter
|
|
* object.
|
|
*
|
|
* @constructor
|
|
*/
|
|
class Throwable {
|
|
constructor({
|
|
movableX = true,
|
|
movableY = true,
|
|
throwVisibility = 44,
|
|
throwDamping = 0.95,
|
|
autoThrow = true,
|
|
onThrowFinished = null
|
|
} = {}) {
|
|
this.movableX = movableX;
|
|
this.movableY = movableY;
|
|
this.throwVisibility = throwVisibility;
|
|
this.throwDamping = throwDamping;
|
|
this.autoThrow = autoThrow;
|
|
this.velocities = [];
|
|
this.velocity = null;
|
|
this.timestamp = null;
|
|
this.onThrowFinished = onThrowFinished;
|
|
//console.log("onThrowFinished", onThrowFinished)
|
|
}
|
|
|
|
observeVelocity() {
|
|
this.lastframe = performance.now();
|
|
}
|
|
|
|
addVelocity(delta, buffer = 5) {
|
|
let t = performance.now();
|
|
let dt = t - this.lastframe;
|
|
this.lastframe = t;
|
|
if (dt > 0) {
|
|
// Avoid division by zero errors later on
|
|
let velocity = { t: t, dt: dt, dx: delta.x, dy: delta.y };
|
|
this.velocities.push(velocity);
|
|
while (this.velocities.length > buffer) {
|
|
this.velocities.shift();
|
|
}
|
|
}
|
|
}
|
|
|
|
meanVelocity(milliseconds = 30) {
|
|
this.addVelocity({ x: 0, y: 0 });
|
|
let sum = { x: 0, y: 0 };
|
|
let count = 0;
|
|
let t = 0;
|
|
for (let i = this.velocities.length - 1; i > 0; i--) {
|
|
let v = this.velocities[i];
|
|
t += v.dt;
|
|
let nv = { x: v.dx / v.dt, y: v.dy / v.dt };
|
|
sum = Points.add(sum, nv);
|
|
count += 1;
|
|
if (t > milliseconds) {
|
|
break
|
|
}
|
|
}
|
|
if (count === 0) return sum // empty vector
|
|
return Points.multiplyScalar(sum, 1 / count)
|
|
}
|
|
|
|
killAnimation() {
|
|
this.velocity = null;
|
|
this.velocities = [];
|
|
}
|
|
|
|
startThrow() {
|
|
this.velocity = this.meanVelocity();
|
|
if (this.velocity != null) {
|
|
// Call next velocity to ansure that specializations
|
|
// that use keepOnStage are called
|
|
this.velocity = this.nextVelocity(this.velocity);
|
|
if (this.autoThrow) this.animateThrow(performance.now());
|
|
} else {
|
|
this.onDragComplete();
|
|
}
|
|
}
|
|
|
|
animateThrow(time) {
|
|
if (this.velocity != null) {
|
|
let t = performance.now();
|
|
let dt = t - this.lastframe;
|
|
this.lastframe = t;
|
|
// console.log("animateThrow", dt)
|
|
let next = this.nextVelocity(this.velocity);
|
|
let prevLength = Points.length(this.velocity);
|
|
let nextLength = Points.length(next);
|
|
if (nextLength > prevLength) {
|
|
let factor = nextLength / prevLength;
|
|
next = Points.multiplyScalar(next, 1 / factor);
|
|
console.log('Prevent acceleration', factor, this.velocity, next);
|
|
}
|
|
this.velocity = next;
|
|
let d = Points.multiplyScalar(this.velocity, dt);
|
|
this._move(d);
|
|
|
|
this.onDragUpdate(d);
|
|
if (dt == 0 || this.needsAnimation()) {
|
|
requestAnimationFrame(this.animateThrow.bind(this));
|
|
return
|
|
} else {
|
|
if (this.isOutside()) {
|
|
requestAnimationFrame(this.animateThrow.bind(this));
|
|
return
|
|
}
|
|
}
|
|
}
|
|
this.onDragComplete();
|
|
if (this.onThrowFinished != null) {
|
|
this.onThrowFinished();
|
|
}
|
|
}
|
|
|
|
needsAnimation() {
|
|
if (this.velocity == null) {
|
|
return false
|
|
}
|
|
return Points.length(this.velocity) > 0.01
|
|
}
|
|
|
|
nextVelocity(velocity) {
|
|
// Must be overwritten: computes the changed velocity. Implement
|
|
// damping, collison detection, etc. here
|
|
let next = Points.multiplyScalar(velocity, this.throwDamping);
|
|
return {
|
|
x: (this.movableX) ? next.x : 0,
|
|
y: (this.movableY) ? next.y : 0
|
|
}
|
|
}
|
|
|
|
_move(delta) {
|
|
// Overwrite if necessary
|
|
}
|
|
|
|
onDragComplete() {
|
|
// Overwrite if necessary
|
|
}
|
|
|
|
onDragUpdate(delta) {
|
|
// Overwrite if necessary
|
|
}
|
|
}
|
|
|
|
class AbstractScatter extends Throwable {
|
|
constructor({
|
|
minScale = 0.1,
|
|
maxScale = 1.0,
|
|
startScale = 1.0,
|
|
autoBringToFront = true,
|
|
autoThrow = true,
|
|
translatable = true,
|
|
scalable = true,
|
|
rotatable = true,
|
|
resizable = false,
|
|
movableX = true,
|
|
movableY = true,
|
|
throwVisibility = 44,
|
|
throwDamping = 0.95,
|
|
overdoScaling = 1,
|
|
mouseZoomFactor = 1.1,
|
|
rotationDegrees = null,
|
|
rotation = null,
|
|
onTransform = null,
|
|
interactive = true,
|
|
onClose = null,
|
|
onThrowFinished = null,
|
|
scaleAutoClose = false,
|
|
scaleCloseThreshold = 0.10,
|
|
scaleCloseBuffer = 0.05
|
|
} = {}) {
|
|
if (rotationDegrees != null && rotation != null) {
|
|
throw new Error('Use rotationDegrees or rotation but not both')
|
|
} else if (rotation != null) {
|
|
rotationDegrees = Angle.radian2degree(rotation);
|
|
} else if (rotationDegrees == null) {
|
|
rotationDegrees = 0;
|
|
}
|
|
super({
|
|
movableX,
|
|
movableY,
|
|
throwVisibility,
|
|
throwDamping,
|
|
autoThrow,
|
|
onThrowFinished
|
|
});
|
|
|
|
/**
|
|
* Closes the card when the minScale is reached and the
|
|
* card is released. Card can be saved by scaling it up again.
|
|
*/
|
|
this.scaleAutoClose = scaleAutoClose;
|
|
this.scaleCloseThreshold = scaleCloseThreshold;
|
|
this.scaleCloseBuffer = scaleCloseBuffer;
|
|
this.scaleAutoCloseTimeout = null;
|
|
|
|
this.interactive = interactive;
|
|
this.startRotationDegrees = rotationDegrees;
|
|
this.startScale = startScale; // Needed to reset object
|
|
this.minScale = minScale;
|
|
this.maxScale = maxScale;
|
|
this.overdoScaling = overdoScaling;
|
|
this.translatable = translatable;
|
|
if (!translatable) {
|
|
this.movableX = false;
|
|
this.movableY = false;
|
|
}
|
|
this.scalable = scalable;
|
|
this.rotatable = rotatable;
|
|
this.resizable = resizable;
|
|
this.mouseZoomFactor = mouseZoomFactor;
|
|
this.autoBringToFront = autoBringToFront;
|
|
this.dragging = false;
|
|
this.onTransform = onTransform != null ? [onTransform] : null;
|
|
this.onClose = onClose != null ? [onClose] : null;
|
|
}
|
|
|
|
addCloseEventCallback(callback) {
|
|
if (this.onClose == null) {
|
|
this.onClose = [];
|
|
}
|
|
this.onClose.push(callback);
|
|
}
|
|
|
|
addTransformEventCallback(callback) {
|
|
if (this.onTransform == null) {
|
|
this.onTransform = [];
|
|
}
|
|
this.onTransform.push(callback);
|
|
}
|
|
|
|
startGesture(interaction) {
|
|
this.bringToFront();
|
|
this.killAnimation();
|
|
this.observeVelocity();
|
|
return true
|
|
}
|
|
|
|
close() {
|
|
if (this.onClose) {
|
|
this.onClose.forEach(callback => callback(this));
|
|
}
|
|
}
|
|
|
|
gesture(interaction) {
|
|
let delta = interaction.delta();
|
|
//console.log("gesture", delta)
|
|
if (delta != null) {
|
|
this.addVelocity(delta);
|
|
this.transform(delta, delta.zoom, delta.rotate, delta.about);
|
|
if (delta.zoom != 1) this.interactionAnchor = delta.about;
|
|
}
|
|
}
|
|
|
|
get polygon() {
|
|
let w2 = this.width * this.scale / 2;
|
|
let h2 = this.height * this.scale / 2;
|
|
let center = this.center;
|
|
let polygon = new Polygon(center);
|
|
polygon.addPoint({ x: -w2, y: -h2 });
|
|
polygon.addPoint({ x: w2, y: -h2 });
|
|
polygon.addPoint({ x: w2, y: h2 });
|
|
polygon.addPoint({ x: -w2, y: h2 });
|
|
polygon.rotate(this.rotation);
|
|
return polygon
|
|
}
|
|
|
|
isOutside() {
|
|
let stagePolygon = this.containerPolygon;
|
|
if (stagePolygon == null)
|
|
return false
|
|
let polygon = this.polygon;
|
|
if (polygon == null)
|
|
return false
|
|
let result = stagePolygon.intersectsWith(polygon);
|
|
return result === false || result.overlap < this.throwVisibility
|
|
}
|
|
|
|
recenter() {
|
|
// Return a small vector that guarantees that the scatter is moving
|
|
// towards the center of the stage
|
|
let center = this.center;
|
|
let target = this.container.center;
|
|
let delta = Points.subtract(target, center);
|
|
return Points.normalize(delta)
|
|
}
|
|
|
|
nextVelocity(velocity) {
|
|
return this.keepOnStage(velocity)
|
|
}
|
|
|
|
bouncing() {
|
|
// Implements the bouncing behavior of the scatter. Moves the scatter
|
|
// to the center of the stage if the scatter is outside the stage or
|
|
// not within the limits of the throwVisibility.
|
|
|
|
let stagePolygon = this.containerPolygon;
|
|
let polygon = this.polygon;
|
|
let result = stagePolygon.intersectsWith(polygon);
|
|
if (result === false || result.overlap < this.throwVisibility) {
|
|
let cv = this.recenter();
|
|
let recentered = false;
|
|
while (result === false || result.overlap < this.throwVisibility) {
|
|
polygon.center.x += cv.x;
|
|
polygon.center.y += cv.y;
|
|
this._move(cv);
|
|
result = stagePolygon.intersectsWith(polygon);
|
|
recentered = true;
|
|
}
|
|
return recentered
|
|
}
|
|
return false
|
|
}
|
|
|
|
keepOnStage(velocity, collision = 0.5) {
|
|
let stagePolygon = this.containerPolygon;
|
|
if (!stagePolygon) return
|
|
let polygon = this.polygon;
|
|
let bounced = this.bouncing();
|
|
if (bounced) {
|
|
let stage = this.containerBounds;
|
|
let x = this.center.x;
|
|
let y = this.center.y;
|
|
let dx = this.movableX ? velocity.x : 0;
|
|
let dy = this.movableY ? velocity.y : 0;
|
|
let factor = this.throwDamping;
|
|
// if (recentered) {
|
|
if (x < 0) {
|
|
dx = -dx;
|
|
factor = collision;
|
|
}
|
|
if (x > stage.width) {
|
|
dx = -dx;
|
|
factor = collision;
|
|
}
|
|
if (y < 0) {
|
|
dy = -dy;
|
|
factor = collision;
|
|
}
|
|
if (y > stage.height) {
|
|
dy = -dy;
|
|
factor = collision;
|
|
}
|
|
// }
|
|
return Points.multiplyScalar({ x: dx, y: dy }, factor)
|
|
}
|
|
return super.nextVelocity(velocity)
|
|
}
|
|
|
|
endGesture(interaction) {
|
|
this.startThrow();
|
|
this._checkAutoClose();
|
|
}
|
|
|
|
_checkAutoClose() {
|
|
if (this.scaleAutoClose)
|
|
if (this.scale < this.minScale + this.scaleCloseThreshold - this.scaleCloseBuffer) {
|
|
this.zoom(this.minScale, { animate: 0.2, onComplete: this.close.bind(this) });
|
|
} else if (this.scale < this.minScale + this.scaleCloseThreshold) {
|
|
this.zoom(this.minScale + this.scaleCloseThreshold, { animate: 0.4 });
|
|
}
|
|
}
|
|
|
|
rotateDegrees(degrees, anchor) {
|
|
let rad = Angle.degree2radian(degrees);
|
|
this.rotate(rad, anchor);
|
|
}
|
|
|
|
rotate(rad, anchor) {
|
|
this.transform({ x: 0, y: 0 }, 1.0, rad, anchor);
|
|
}
|
|
|
|
move(d, { animate = 0 } = {}) {
|
|
if (this.translatable) {
|
|
if (animate > 0) {
|
|
let startPos = this.position;
|
|
TweenLite.to(this, animate, {
|
|
x: '+=' + d.x,
|
|
y: '+=' + d.y,
|
|
/* scale: scale, uo: not defined, why was this here? */
|
|
onUpdate: e => {
|
|
let p = this.position;
|
|
let dx = p.x - startPos.x;
|
|
let dy = p.x - startPos.y;
|
|
this.onMoved(dx, dy);
|
|
}
|
|
});
|
|
} else {
|
|
this._move(d);
|
|
this.onMoved(d.x, d.y);
|
|
}
|
|
}
|
|
}
|
|
|
|
moveTo(p, { animate = 0 } = {}) {
|
|
let c = this.origin;
|
|
let delta = Points.subtract(p, c);
|
|
this.move(delta, { animate: animate });
|
|
}
|
|
|
|
centerAt(p, { animate = 0 } = {}) {
|
|
let c = this.center;
|
|
let delta = Points.subtract(p, c);
|
|
this.move(delta, { animate: animate });
|
|
}
|
|
|
|
zoom(
|
|
scale,
|
|
{
|
|
animate = 0,
|
|
about = null,
|
|
delay = 0,
|
|
x = null,
|
|
y = null,
|
|
onComplete = null
|
|
} = {}
|
|
) {
|
|
let anchor = about || this.center;
|
|
if (scale != this.scale) {
|
|
if (animate > 0) {
|
|
TweenLite.to(this, animate, {
|
|
scale: scale,
|
|
delay: delay,
|
|
onComplete: onComplete,
|
|
onUpdate: this.onZoomed.bind(this)
|
|
});
|
|
} else {
|
|
this.scale = scale;
|
|
this.onZoomed(anchor);
|
|
}
|
|
}
|
|
}
|
|
|
|
_move(delta) {
|
|
this.x += this.movableX ? delta.x : 0;
|
|
this.y += this.movableX ? delta.y : 0;
|
|
}
|
|
|
|
transform(translate, zoom, rotate, anchor) {
|
|
let delta = {
|
|
x: this.movableX ? translate.x : 0,
|
|
y: this.movableY ? translate.y : 0
|
|
};
|
|
if (this.resizable) var vzoom = zoom;
|
|
if (!this.translatable) delta = { x: 0, y: 0 };
|
|
if (!this.rotatable) rotate = 0;
|
|
if (!this.scalable) zoom = 1.0;
|
|
if (zoom == 1.0 && rotate == 0) {
|
|
this._move(delta);
|
|
if (this.onTransform != null) {
|
|
let event = new ScatterEvent(this, {
|
|
translate: delta,
|
|
scale: this.scale,
|
|
rotate: 0,
|
|
about: anchor,
|
|
fast: false,
|
|
type: UPDATE
|
|
});
|
|
this.onTransform.forEach(function (f) {
|
|
f(event);
|
|
});
|
|
}
|
|
return
|
|
}
|
|
let origin = this.rotationOrigin;
|
|
let beta = Points.angle(origin, anchor);
|
|
let distance = Points.distance(origin, anchor);
|
|
let { scale: newScale, zoom: thresholdedZoom } = this.calculateScale(zoom);
|
|
|
|
let newOrigin = Points.arc(anchor, beta + rotate, distance * thresholdedZoom);
|
|
let extra = Points.subtract(newOrigin, origin);
|
|
let offset = Points.subtract(anchor, origin);
|
|
this._move(offset);
|
|
this.scale = newScale;
|
|
this.rotation += rotate;
|
|
offset = Points.negate(offset);
|
|
offset = Points.add(offset, extra);
|
|
offset = Points.add(offset, translate);
|
|
this._move(offset);
|
|
|
|
delta.x += extra.x;
|
|
delta.y += extra.y;
|
|
if (this.onTransform != null) {
|
|
let event = new ScatterEvent(this, {
|
|
translate: delta,
|
|
scale: newScale,
|
|
rotate: rotate,
|
|
about: anchor
|
|
});
|
|
this.onTransform.forEach(function (f) {
|
|
f(event);
|
|
});
|
|
}
|
|
if (this.resizable) {
|
|
this.resizeAfterTransform(vzoom);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* For a given zoom, a new scale is calculated, taking
|
|
* min and max scale into account.
|
|
*
|
|
* @param {number} zoom - The zoom factor, to scale the object with.
|
|
* @returns {object} - Returns an object containing the a value for a valid scale and the corrected zoom factor.
|
|
*/
|
|
calculateScale(zoom) {
|
|
let scale = this.scale * zoom;
|
|
|
|
let minScale = this.minScale / this.overdoScaling;
|
|
let maxScale = this.maxScale * this.overdoScaling;
|
|
if (scale < minScale) {
|
|
scale = minScale;
|
|
zoom = scale / this.scale;
|
|
}
|
|
if (scale > maxScale) {
|
|
scale = maxScale;
|
|
zoom = scale / this.scale;
|
|
}
|
|
|
|
if (this.scaleAutoClose)
|
|
this._updateTransparency();
|
|
|
|
return { zoom, scale }
|
|
}
|
|
|
|
_updateTransparency() {
|
|
if (this.scale < this.minScale + this.scaleCloseThreshold) {
|
|
let transparency = this.calculateScaleTransparency();
|
|
this.element.style.opacity = transparency;
|
|
} else this.element.style.opacity = 1;
|
|
}
|
|
|
|
calculateScaleTransparency() {
|
|
let transparency = (this.scale - this.minScale) / this.scaleCloseThreshold;
|
|
transparency = (transparency > 1) ? 1 : (transparency < 0) ? 0 : transparency;
|
|
return transparency
|
|
}
|
|
|
|
resizeAfterTransform(zoom) {
|
|
// Overwrite this in subclasses.
|
|
}
|
|
|
|
validScale(scale) {
|
|
scale = Math.max(scale, this.minScale);
|
|
scale = Math.min(scale, this.maxScale);
|
|
return scale
|
|
}
|
|
|
|
animateZoomBounce(dt = 1) {
|
|
if (this.zoomAnchor != null) {
|
|
let zoom = 1;
|
|
let amount = Math.min(0.01, 0.3 * dt / 100000.0);
|
|
if (this.scale < this.minScale) zoom = 1 + amount;
|
|
if (this.scale > this.maxScale) zoom = 1 - amount;
|
|
if (zoom != 1) {
|
|
this.transform({ x: 0, y: 0 }, zoom, 0, this.zoomAnchor);
|
|
requestAnimationFrame(dt => {
|
|
this.animateZoomBounce(dt);
|
|
});
|
|
return
|
|
}
|
|
this.zoomAnchor = null;
|
|
}
|
|
}
|
|
|
|
checkScaling(about, delay = 0) {
|
|
this.zoomAnchor = about;
|
|
clearTimeout(this.animateZoomBounce.bind(this));
|
|
setTimeout(this.animateZoomBounce.bind(this), delay);
|
|
}
|
|
|
|
onMouseWheel(event) {
|
|
if (event.claimedByScatter) {
|
|
if (event.claimedByScatter != this) return
|
|
}
|
|
this.killAnimation();
|
|
this.targetScale = null;
|
|
let direction = event.detail < 0 || event.wheelDelta > 0;
|
|
let globalPoint = { x: event.clientX, y: event.clientY };
|
|
let centerPoint = this.mapPositionToContainerPoint(globalPoint);
|
|
if (event.shiftKey) {
|
|
let degrees = direction ? 5 : -5;
|
|
let rad = Angle.degree2radian(degrees);
|
|
return this.transform({ x: 0, y: 0 }, 1.0, rad, centerPoint)
|
|
}
|
|
const zoomFactor = this.mouseZoomFactor;
|
|
let zoom = direction ? zoomFactor : 1 / zoomFactor;
|
|
this.transform({ x: 0, y: 0 }, zoom, 0, centerPoint);
|
|
this.checkScaling(centerPoint, 200);
|
|
|
|
if (this.scaleAutoClose) {
|
|
if (this.scale <= this.minScale + this.scaleCloseThreshold) {
|
|
|
|
if (this.scaleAutoCloseTimeout) clearTimeout(this.scaleAutoCloseTimeout);
|
|
this.scaleAutoCloseTimeout = setTimeout(() => {
|
|
this._checkAutoClose();
|
|
}, 600);
|
|
}
|
|
this._updateTransparency();
|
|
}
|
|
//
|
|
// if (this.onTransform != null) {
|
|
// let event = new ScatterEvent(this, {
|
|
// translate: {x: 0, y: 0},
|
|
// scale: this.scale,
|
|
// rotate: 0,
|
|
// about: null,
|
|
// fast: false,
|
|
// type: ZOOM
|
|
// })
|
|
// this.onTransform.forEach(function(f) {
|
|
// f(event)
|
|
// })
|
|
// }
|
|
}
|
|
|
|
onStart(event, interaction) {
|
|
|
|
if (this.startGesture(interaction)) {
|
|
this.dragging = true;
|
|
this.interactionAnchor = null;
|
|
}
|
|
if (this.onTransform != null) {
|
|
let event = new ScatterEvent(this, {
|
|
translate: { x: 0, y: 0 },
|
|
scale: this.scale,
|
|
rotate: 0,
|
|
about: null,
|
|
fast: false,
|
|
type: START
|
|
});
|
|
this.onTransform.forEach(function (f) {
|
|
f(event);
|
|
});
|
|
}
|
|
}
|
|
|
|
onMove(event, interaction) {
|
|
/** As long as mouseout && mouseleave interrupt we cannot be sure that
|
|
* dragging remains correct.
|
|
*/
|
|
if (this.dragging) {
|
|
this.gesture(interaction);
|
|
}
|
|
}
|
|
|
|
onEnd(event, interaction) {
|
|
//console.log("Scatter.onEnd", this.dragging)
|
|
if (interaction.isFinished()) {
|
|
this.endGesture(interaction);
|
|
this.dragging = false;
|
|
for (let key of interaction.ended.keys()) {
|
|
if (interaction.isTap(key)) {
|
|
let point = interaction.ended.get(key);
|
|
this.onTap(event, interaction, point);
|
|
}
|
|
}
|
|
if (this.onTransform != null) {
|
|
let event = new ScatterEvent(this, {
|
|
translate: { x: 0, y: 0 },
|
|
scale: this.scale,
|
|
rotate: 0,
|
|
about: null,
|
|
fast: false,
|
|
type: END
|
|
});
|
|
this.onTransform.forEach(function (f) {
|
|
f(event);
|
|
});
|
|
}
|
|
}
|
|
let about = this.interactionAnchor;
|
|
if (about != null) {
|
|
this.checkScaling(about, 100);
|
|
}
|
|
}
|
|
|
|
onTap(event, interaction, point) { }
|
|
|
|
onDragUpdate(delta) {
|
|
if (this.onTransform != null) {
|
|
let event = new ScatterEvent(this, {
|
|
fast: true,
|
|
translate: delta,
|
|
scale: this.scale,
|
|
about: this.currentAbout,
|
|
type: null
|
|
});
|
|
this.onTransform.forEach(function (f) {
|
|
f(event);
|
|
});
|
|
}
|
|
}
|
|
|
|
onDragComplete() {
|
|
if (this.onTransform) {
|
|
let event = new ScatterEvent(this, {
|
|
scale: this.scale,
|
|
about: this.currentAbout,
|
|
fast: false,
|
|
type: null
|
|
});
|
|
this.onTransform.forEach(function (f) {
|
|
f(event);
|
|
});
|
|
}
|
|
}
|
|
|
|
onMoved(dx, dy, about) {
|
|
if (this.onTransform != null) {
|
|
let event = new ScatterEvent(this, {
|
|
translate: { x: dx, y: dy },
|
|
about: about,
|
|
fast: true,
|
|
type: null
|
|
});
|
|
this.onTransform.forEach(function (f) {
|
|
f(event);
|
|
});
|
|
}
|
|
}
|
|
|
|
onResizing() {
|
|
if (this.onTransform != null) {
|
|
let event = new ScatterEvent(this, {
|
|
scale: this.scale,
|
|
fast: false,
|
|
type: null
|
|
});
|
|
this.onTransform.forEach(function (f) {
|
|
f(event);
|
|
});
|
|
}
|
|
}
|
|
|
|
onZoomed(about) {
|
|
|
|
if (this.scaleAutoClose)
|
|
this._updateTransparency();
|
|
|
|
if (this.onTransform != null) {
|
|
let event = new ScatterEvent(this, {
|
|
scale: this.scale,
|
|
about: about,
|
|
fast: false,
|
|
type: null
|
|
});
|
|
this.onTransform.forEach(function (f) {
|
|
f(event);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
class DOMScatter extends AbstractScatter {
|
|
constructor(
|
|
element,
|
|
container,
|
|
{
|
|
startScale = 1.0,
|
|
minScale = 0.1,
|
|
maxScale = 1.0,
|
|
overdoScaling = 1.5,
|
|
autoBringToFront = true,
|
|
translatable = true,
|
|
scalable = true,
|
|
rotatable = true,
|
|
movableX = true,
|
|
movableY = true,
|
|
rotationDegrees = null,
|
|
rotation = null,
|
|
onTransform = null,
|
|
transformOrigin = 'center center',
|
|
// extras which are in part needed
|
|
x = 0,
|
|
y = 0,
|
|
width = null, // required
|
|
height = null, // required
|
|
resizable = false,
|
|
simulateClick = false,
|
|
verbose = true,
|
|
onResize = null,
|
|
touchAction = 'none',
|
|
throwVisibility = 44,
|
|
throwDamping = 0.95,
|
|
autoThrow = true,
|
|
scaleAutoClose = false,
|
|
onClose = null,
|
|
scaleCloseThreshold = 0.10,
|
|
scaleCloseBuffer = 0.05
|
|
} = {}
|
|
) {
|
|
super({
|
|
minScale,
|
|
maxScale,
|
|
startScale,
|
|
overdoScaling,
|
|
autoBringToFront,
|
|
translatable,
|
|
scalable,
|
|
rotatable,
|
|
movableX,
|
|
movableY,
|
|
resizable,
|
|
rotationDegrees,
|
|
rotation,
|
|
onTransform,
|
|
throwVisibility,
|
|
throwDamping,
|
|
autoThrow,
|
|
scaleAutoClose,
|
|
scaleCloseThreshold,
|
|
scaleCloseBuffer,
|
|
onClose
|
|
});
|
|
if (container == null || width == null || height == null) {
|
|
throw new Error('Invalid value: null')
|
|
}
|
|
element.scatter = this;
|
|
this.element = element;
|
|
this.x = x;
|
|
this.y = y;
|
|
this.oldX = 0;
|
|
this.oldY = 0;
|
|
this.meanX = x;
|
|
this.meanY = y;
|
|
this.width = width;
|
|
this.height = height;
|
|
this.throwVisibility = Math.min(width, height, throwVisibility);
|
|
this.container = container;
|
|
this.simulateClick = simulateClick;
|
|
this.scale = startScale;
|
|
this.rotationDegrees = this.startRotationDegrees;
|
|
this.transformOrigin = transformOrigin;
|
|
this.initialValues = {
|
|
x: x,
|
|
y: y,
|
|
width: width,
|
|
height: height,
|
|
scale: startScale,
|
|
rotation: this.startRotationDegrees,
|
|
transformOrigin: transformOrigin
|
|
};
|
|
|
|
|
|
// For tweenlite we need initial values in _gsTransform
|
|
TweenLite.set(element, this.initialValues);
|
|
this.onResize = onResize;
|
|
this.verbose = verbose;
|
|
if (touchAction !== null) {
|
|
Elements$1.setStyle(element, { touchAction });
|
|
}
|
|
this.resizeButton = null;
|
|
if (resizable) {
|
|
let button = document.createElement("div");
|
|
button.style.position = "absolute";
|
|
button.style.right = "0px";
|
|
button.style.bottom = "0px";
|
|
button.style.width = "50px";
|
|
button.style.height = "50px";
|
|
// button.style.borderRadius = "100% 0px 0px 0px";
|
|
// button.style.background = this.element.style.backgroundColor
|
|
button.className = "interactiveElement";
|
|
this.element.appendChild(button);
|
|
|
|
button.addEventListener('pointerdown', (e) => {
|
|
this.startResize(e);
|
|
});
|
|
|
|
button.addEventListener('pointermove', (e) => {
|
|
this.resize(e);
|
|
});
|
|
|
|
button.addEventListener('pointerup', (e) => {
|
|
this.stopResize(e);
|
|
});
|
|
this.resizeButton = button;
|
|
}
|
|
container.add(this);
|
|
}
|
|
|
|
/** Returns geometry data as object. **/
|
|
getState() {
|
|
return {
|
|
scale: this.scale,
|
|
x: this.x,
|
|
y: this.y,
|
|
rotation: this.rotation
|
|
}
|
|
}
|
|
|
|
close() {
|
|
super.close();
|
|
let parent = this.element.parentNode;
|
|
if (parent) parent.removeChild(this.element);
|
|
}
|
|
|
|
get rotationOrigin() {
|
|
return this.center
|
|
}
|
|
|
|
get x() {
|
|
return this._x
|
|
}
|
|
|
|
get y() {
|
|
return this._y
|
|
}
|
|
|
|
set x(value) {
|
|
this._x = value;
|
|
TweenLite.set(this.element, { x: value });
|
|
}
|
|
|
|
set y(value) {
|
|
this._y = value;
|
|
TweenLite.set(this.element, { y: value });
|
|
}
|
|
|
|
get position() {
|
|
let transform = this.element._gsTransform;
|
|
let x = transform.x;
|
|
let y = transform.y;
|
|
return { x, y }
|
|
}
|
|
|
|
get origin() {
|
|
let p = this.fromNodeToPage(0, 0);
|
|
return Points.fromPageToNode(this.container.element, p)
|
|
}
|
|
|
|
get bounds() {
|
|
let stage = this.container.element.getBoundingClientRect();
|
|
let rect = this.element.getBoundingClientRect();
|
|
return {
|
|
top: rect.top - stage.top,
|
|
left: rect.left - stage.left,
|
|
width: rect.width,
|
|
height: rect.height
|
|
}
|
|
}
|
|
|
|
get center() {
|
|
let r = this.bounds;
|
|
let w2 = r.width / 2;
|
|
let h2 = r.height / 2;
|
|
// if (this.resizable) {
|
|
// w2 *= this.scale
|
|
// h2 *= this.scale
|
|
// }
|
|
var x = r.left + w2;
|
|
var y = r.top + h2;
|
|
return { x, y }
|
|
}
|
|
|
|
set rotation(radians) {
|
|
let rad = radians; // Angle.normalize(radians)
|
|
let degrees = Angle.radian2degree(rad);
|
|
TweenLite.set(this.element, { rotation: degrees });
|
|
this._rotation = rad;
|
|
}
|
|
|
|
set rotationDegrees(degrees) {
|
|
let deg = degrees; // Angle.normalizeDegree(degrees)
|
|
TweenLite.set(this.element, { rotation: deg });
|
|
this._rotation = Angle.degree2radian(deg);
|
|
}
|
|
|
|
get rotation() {
|
|
return this._rotation
|
|
}
|
|
|
|
get rotationDegrees() {
|
|
return this._rotation
|
|
}
|
|
|
|
set scale(scale) {
|
|
TweenLite.set(this.element, {
|
|
scale: scale,
|
|
transformOrigin: this.transformOrigin
|
|
});
|
|
this._scale = scale;
|
|
}
|
|
|
|
get scale() {
|
|
return this._scale
|
|
}
|
|
|
|
get containerBounds() {
|
|
return this.container.bounds
|
|
}
|
|
|
|
get containerPolygon() {
|
|
return this.container.polygon
|
|
}
|
|
|
|
mapPositionToContainerPoint(point) {
|
|
return this.container.mapPositionToPoint(point)
|
|
}
|
|
|
|
capture(event) {
|
|
return true
|
|
}
|
|
|
|
reset() {
|
|
TweenLite.set(this.element, this.initialValues);
|
|
}
|
|
|
|
hide() {
|
|
TweenLite.to(this.element, 0.1, {
|
|
display: 'none',
|
|
onComplete: e => {
|
|
this.element.parentNode.removeChild(this.element);
|
|
}
|
|
});
|
|
}
|
|
|
|
show() {
|
|
TweenLite.set(this.element, { display: 'block' });
|
|
}
|
|
|
|
showAt(p, rotationDegrees) {
|
|
TweenLite.set(this.element, {
|
|
display: 'block',
|
|
x: p.x,
|
|
y: p.y,
|
|
rotation: rotationDegrees,
|
|
transformOrigin: this.transformOrigin
|
|
});
|
|
}
|
|
|
|
bringToFront() {
|
|
// this.element.parentNode.appendChild(this.element)
|
|
// uo: On Chome and Electon appendChild leads to flicker
|
|
TweenLite.set(this.element, { zIndex: DOMScatter.zIndex++ });
|
|
}
|
|
|
|
toggleVideo(element) {
|
|
if (element.paused) {
|
|
element.play();
|
|
} else {
|
|
element.pause();
|
|
}
|
|
}
|
|
|
|
onTap(event, interaction, point) {
|
|
if (this.simulateClick) {
|
|
let p = Points.fromPageToNode(this.element, point);
|
|
let iframe = this.element.querySelector('iframe');
|
|
if (iframe) {
|
|
let doc = iframe.contentWindow.document;
|
|
let element = doc.elementFromPoint(p.x, p.y);
|
|
if (element == null) {
|
|
return
|
|
}
|
|
switch (element.tagName) {
|
|
case 'VIDEO':
|
|
console.log(element.currentSrc);
|
|
if (PopupMenu) {
|
|
PopupMenu.open(
|
|
{
|
|
Fullscreen: () =>
|
|
window.open(element.currentSrc),
|
|
Play: () => element.play()
|
|
},
|
|
{ x, y }
|
|
);
|
|
} else {
|
|
this.toggleVideo(element);
|
|
}
|
|
break
|
|
default:
|
|
element.click();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
isDescendant(parent, child) {
|
|
let node = child.parentNode;
|
|
while (node != null) {
|
|
if (node == parent) {
|
|
return true
|
|
}
|
|
node = node.parentNode;
|
|
}
|
|
return false
|
|
}
|
|
|
|
fromPageToNode(x, y) {
|
|
return Points.fromPageToNode(this.element, { x, y })
|
|
}
|
|
|
|
fromNodeToPage(x, y) {
|
|
return Points.fromNodeToPage(this.element, { x, y })
|
|
}
|
|
|
|
_move(delta) {
|
|
// UO: We need to keep TweenLite's _gsTransform and the private
|
|
// _x and _y attributes aligned
|
|
let x = this.element._gsTransform.x;
|
|
let y = this.element._gsTransform.y;
|
|
if (this.movableX) {
|
|
x += delta.x;
|
|
}
|
|
if (this.movableY) {
|
|
y += delta.y;
|
|
}
|
|
this._x = x;
|
|
this._y = y;
|
|
TweenLite.set(this.element, { x: x, y: y });
|
|
}
|
|
|
|
resizeAfterTransform(zoom) {
|
|
// let w = this.width * this.scale
|
|
// let h = this.height * this.scale
|
|
// TweenLite.set(this.element, { width: w, height: h })
|
|
if (this.onResize) {
|
|
let event = new ResizeEvent(this, { width: w, height: h });
|
|
this.onResize(event);
|
|
}
|
|
if (this.resizeButton != null) ;
|
|
}
|
|
|
|
startResize(e) {
|
|
e.preventDefault();
|
|
let event = new CustomEvent('resizeStarted');
|
|
|
|
let oldPostition = { x: $(this.element).position().left, y: $(this.element).position().top };
|
|
this.bringToFront();
|
|
|
|
this.element.style.transformOrigin = "0% 0%";
|
|
|
|
let newPostition = { x: $(this.element).position().left, y: $(this.element).position().top };
|
|
|
|
let offset = Points.subtract(oldPostition, newPostition);
|
|
|
|
this.oldX = e.clientX;
|
|
this.oldY = e.clientY;
|
|
|
|
e.target.setAttribute('resizing', "true");
|
|
e.target.setPointerCapture(e.pointerId);
|
|
|
|
TweenLite.to(this.element, 0, { css: { left: "+=" + offset.x + "px" } });
|
|
TweenLite.to(this.element, 0, { css: { top: "+=" + offset.y + "px" } });
|
|
|
|
this.element.dispatchEvent(event);
|
|
}
|
|
|
|
resize(e) {
|
|
e.preventDefault();
|
|
|
|
let rotation = Angle.radian2degree(this.rotation);
|
|
rotation = (rotation + 360) % 360;
|
|
let event = new CustomEvent('resized');
|
|
if (e.target.getAttribute('resizing') == "true") {
|
|
|
|
let deltaX = (e.clientX - this.oldX);
|
|
let deltaY = (e.clientY - this.oldY);
|
|
|
|
let r = Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2));
|
|
let phi = Angle.radian2degree(Math.atan2(deltaX, deltaY));
|
|
|
|
phi = ((phi) + 630) % 360;
|
|
let rot = ((rotation + 90) + 630) % 360;
|
|
|
|
let diffAngle = ((0 + rot) + 360) % 360;
|
|
let phiCorrected = (phi + diffAngle + 360) % 360;
|
|
|
|
let resizeW = r * Math.cos(Angle.degree2radian(phiCorrected));
|
|
let resizeH = -r * Math.sin(Angle.degree2radian(phiCorrected));
|
|
|
|
if (this.element.offsetWidth + resizeW / this.scale > this.width * 0.3 && this.element.offsetHeight + resizeH / this.scale > this.height * 0.3) TweenLite.to(this.element, 0, { width: this.element.offsetWidth + resizeW / this.scale, height: this.element.offsetHeight + resizeH / this.scale });
|
|
|
|
this.oldX = e.clientX;
|
|
this.oldY = e.clientY;
|
|
this.onResizing();
|
|
|
|
this.element.dispatchEvent(event);
|
|
}
|
|
}
|
|
|
|
stopResize(e) {
|
|
e.preventDefault();
|
|
|
|
let event = new CustomEvent('resizeEnded');
|
|
let oldPostition = { x: $(this.element).position().left, y: $(this.element).position().top };
|
|
this.element.style.transformOrigin = "50% 50%";
|
|
let newPostition = { x: $(this.element).position().left, y: $(this.element).position().top };
|
|
let offset = Points.subtract(oldPostition, newPostition);
|
|
|
|
TweenLite.to(this.element, 0, { css: { left: "+=" + offset.x + "px" } });
|
|
TweenLite.to(this.element, 0, { css: { top: "+=" + offset.y + "px" } });
|
|
|
|
e.target.setAttribute('resizing', "false");
|
|
|
|
this.element.dispatchEvent(event);
|
|
}
|
|
}
|
|
|
|
DOMScatter.zIndex = 1000;
|
|
|
|
class CardLoader {
|
|
constructor(
|
|
src,
|
|
{
|
|
x = 0,
|
|
y = 0,
|
|
width = 1000,
|
|
height = 800,
|
|
maxWidth = null,
|
|
maxHeight = null,
|
|
scale = 1,
|
|
minScale = 0.5,
|
|
maxScale = 1.5,
|
|
rotation = 0
|
|
} = {}
|
|
) {
|
|
this.src = src;
|
|
this.x = x;
|
|
this.y = y;
|
|
this.scale = scale;
|
|
this.rotation = 0;
|
|
this.maxScale = maxScale;
|
|
this.minScale = minScale;
|
|
this.wantedWidth = width;
|
|
this.wantedHeight = height;
|
|
this.maxWidth = maxWidth != null ? maxWidth : window.innerWidth;
|
|
this.maxHeight = maxHeight != null ? maxHeight : window.innerHeight;
|
|
this.addedNode = null;
|
|
console.log({
|
|
|
|
width,
|
|
height,
|
|
maxWidth,
|
|
maxHeight,
|
|
|
|
});
|
|
}
|
|
|
|
unload() {
|
|
if (this.addedNode) {
|
|
this.addedNode.remove();
|
|
this.addedNode = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
class DOMFlip {
|
|
constructor(
|
|
domScatterContainer,
|
|
flipTemplate,
|
|
frontLoader,
|
|
backLoader,
|
|
{
|
|
closeOnMinScale = false,
|
|
flipDuration = 1,
|
|
fadeDuration = 0.2,
|
|
overdoScaling = 1,
|
|
autoLoad = false,
|
|
center = null,
|
|
preloadBack = false,
|
|
translatable = true,
|
|
scalable = true,
|
|
rotatable = true,
|
|
onFront = null,
|
|
onBack = null,
|
|
onClose = null,
|
|
onUpdate = null,
|
|
onRemoved = null,
|
|
onLoaded = null
|
|
} = {}
|
|
) {
|
|
this.domScatterContainer = domScatterContainer;
|
|
this.id = getId();
|
|
this.flipDuration = flipDuration;
|
|
this.fadeDuration = fadeDuration;
|
|
this.closeOnMinScale = closeOnMinScale;
|
|
this.flipTemplate = flipTemplate;
|
|
this.frontLoader = frontLoader;
|
|
this.backLoader = backLoader;
|
|
this.translatable = translatable;
|
|
this.scalable = scalable;
|
|
this.rotatable = rotatable;
|
|
this.onFrontFlipped = onFront;
|
|
this.onBackFlipped = onBack;
|
|
this.onClose = onClose;
|
|
this.onRemoved = onRemoved;
|
|
this.onUpdate = onUpdate;
|
|
this.onLoaded = onLoaded;
|
|
this.center = center;
|
|
this.preloadBack = preloadBack;
|
|
this.overdoScaling = overdoScaling;
|
|
if (autoLoad) {
|
|
this.load();
|
|
}
|
|
}
|
|
|
|
load() {
|
|
return new Promise((resolve, reject) => {
|
|
let t = this.flipTemplate;
|
|
let dom = this.domScatterContainer.element;
|
|
let wrapper = t.content.querySelector('.flipWrapper');
|
|
wrapper.id = this.id;
|
|
let clone = document.importNode(t.content, true);
|
|
dom.appendChild(clone);
|
|
// We cannot use the document fragment itself because it
|
|
// is not part of the main dom tree. After the appendChild
|
|
// call we can access the new dom element by id
|
|
this.cardWrapper = dom.querySelector('#' + this.id);
|
|
let front = this.cardWrapper.querySelector('.front');
|
|
this.frontLoader.load(front).then(loader => {
|
|
this.frontLoaded(loader).then((obj) => {
|
|
if (this.onLoaded) this.onLoaded();
|
|
resolve(this);
|
|
});
|
|
});
|
|
})
|
|
}
|
|
|
|
frontLoaded(loader) {
|
|
return new Promise((resolve, reject) => {
|
|
let scatter = new DOMScatter(
|
|
this.cardWrapper,
|
|
this.domScatterContainer,
|
|
{
|
|
x: loader.x,
|
|
y: loader.y,
|
|
startScale: loader.scale,
|
|
scale: loader.scale,
|
|
maxScale: loader.maxScale,
|
|
minScale: loader.minScale,
|
|
width: loader.wantedWidth,
|
|
height: loader.wantedHeight,
|
|
rotation: loader.rotation,
|
|
translatable: this.translatable,
|
|
scalable: this.scalable,
|
|
rotatable: this.rotatable,
|
|
overdoScaling: this.overdoScaling
|
|
}
|
|
);
|
|
|
|
if (this.center) {
|
|
scatter.centerAt(this.center);
|
|
}
|
|
|
|
if (this.closeOnMinScale) {
|
|
|
|
const removeOnMinScale = function () {
|
|
if (scatter.scale <= scatter.minScale) {
|
|
this.flippable.close();
|
|
|
|
// 'Disable' overdoscaling to avoid weird jumps on close.
|
|
scatter.minScale /= scatter.overdoScaling;
|
|
scatter.overdoScaling = 1;
|
|
|
|
//Remove callback
|
|
if (scatter.onTransform) {
|
|
let callbackIdx = scatter.onTransform.indexOf(removeOnMinScale);
|
|
scatter.onTransform.splice(callbackIdx, 1);
|
|
}
|
|
}
|
|
|
|
}.bind(this);
|
|
|
|
|
|
|
|
scatter.addTransformEventCallback(removeOnMinScale);
|
|
}
|
|
|
|
let flippable = new DOMFlippable(this.cardWrapper, scatter, this);
|
|
let back = this.cardWrapper.querySelector('.back');
|
|
|
|
if (this.preloadBack) {
|
|
this.backLoader.load(back).then(loader => {
|
|
this.setupFlippable(flippable, loader);
|
|
});
|
|
}
|
|
this.flippable = flippable;
|
|
resolve(this);
|
|
})
|
|
}
|
|
|
|
centerAt(p) {
|
|
this.center = p;
|
|
this.flippable.centerAt(p);
|
|
}
|
|
|
|
zoom(scale) {
|
|
this.flippable.zoom(scale);
|
|
}
|
|
|
|
setupFlippable(flippable, loader) {
|
|
flippable.wantedWidth = loader.wantedWidth;
|
|
flippable.wantedHeight = loader.wantedHeight;
|
|
flippable.wantedScale = loader.scale;
|
|
flippable.minScale = loader.minScale;
|
|
flippable.maxScale = loader.maxScale;
|
|
flippable.scaleButtons();
|
|
}
|
|
|
|
start({ targetCenter = null } = {}) {
|
|
console.log('DOMFlip.start', targetCenter);
|
|
if (this.preloadBack) this.flippable.start({ duration: this.flipDuration, targetCenter });
|
|
else {
|
|
let back = this.cardWrapper.querySelector('.back');
|
|
let flippable = this.flippable;
|
|
this.backLoader.load(back).then(loader => {
|
|
this.setupFlippable(flippable, loader);
|
|
flippable.start({ duration: this.flipDuration, targetCenter });
|
|
});
|
|
}
|
|
}
|
|
|
|
fadeOutAndRemove() {
|
|
TweenLite.to(this.cardWrapper, this.fadeDuration, {
|
|
opacity: 0,
|
|
onComplete: () => {
|
|
this.cardWrapper.remove();
|
|
}
|
|
});
|
|
}
|
|
|
|
closed() {
|
|
this.unload();
|
|
}
|
|
|
|
unload() {
|
|
if (!this.preloadBack) {
|
|
this.backLoader.unload();
|
|
}
|
|
}
|
|
}
|
|
|
|
class DOMFlippable {
|
|
constructor(element, scatter, flip) {
|
|
// Set log to console.log or a custom log function
|
|
// define data structures to store our touchpoints in
|
|
|
|
this.element = element;
|
|
this.flip = flip;
|
|
this.card = element.querySelector('.flipCard');
|
|
this.front = element.querySelector('.front');
|
|
this.back = element.querySelector('.back');
|
|
this.flipped = false;
|
|
this.scatter = scatter;
|
|
this.onFrontFlipped = flip.onFrontFlipped;
|
|
this.onBackFlipped = flip.onBackFlipped;
|
|
this.onClose = flip.onClose;
|
|
this.onRemoved = flip.onRemoved;
|
|
this.onUpdate = flip.onUpdate;
|
|
|
|
this.flipDuration = flip.flipDuration;
|
|
this.fadeDuration = flip.fadeDuration;
|
|
scatter.addTransformEventCallback(this.scatterTransformed.bind(this));
|
|
console.log('lib.DOMFlippable', 5000);
|
|
TweenLite.set(this.element, { perspective: 5000 });
|
|
TweenLite.set(this.card, { transformStyle: 'preserve-3d' });
|
|
TweenLite.set(this.back, { rotationY: -180 });
|
|
TweenLite.set([this.back, this.front], {
|
|
backfaceVisibility: 'hidden',
|
|
perspective: 5000
|
|
});
|
|
TweenLite.set(this.front, { visibility: 'visible' });
|
|
this.infoBtn = element.querySelector('.infoBtn');
|
|
this.backBtn = element.querySelector('.backBtn');
|
|
this.closeBtn = element.querySelector('.closeBtn');
|
|
/* Buttons are not guaranteed to exist. */
|
|
if (this.infoBtn) {
|
|
InteractionMapper$1.on('tap', this.infoBtn, event => this.flip.start());
|
|
|
|
this.enable(this.infoBtn);
|
|
}
|
|
if (this.backBtn) {
|
|
InteractionMapper$1.on('tap', this.backBtn, event => this.start());
|
|
}
|
|
if (this.closeBtn) {
|
|
InteractionMapper$1.on('tap', this.closeBtn, event => this.close());
|
|
this.enable(this.closeBtn);
|
|
}
|
|
this.scaleButtons();
|
|
this.bringToFront();
|
|
}
|
|
|
|
close() {
|
|
this.disable(this.infoBtn);
|
|
this.disable(this.closeBtn);
|
|
if (this.onClose) {
|
|
this.onClose(this);
|
|
this.flip.closed();
|
|
} else {
|
|
this.scatter.zoom(0.1, {
|
|
animate: this.fadeDuration,
|
|
onComplete: () => {
|
|
this.element.remove();
|
|
this.flip.closed();
|
|
if (this.onRemoved) {
|
|
this.onRemoved.call(this);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
showFront() {
|
|
TweenLite.set(this.front, { visibility: 'visible' });
|
|
}
|
|
|
|
centerAt(p) {
|
|
this.scatter.centerAt(p);
|
|
}
|
|
|
|
zoom(scale) {
|
|
this.scatter.zoom(scale);
|
|
}
|
|
|
|
get buttonScale() {
|
|
let iscale = 1.0;
|
|
|
|
if (this.scatter != null) {
|
|
let scale = this.scatter.scale || 1;
|
|
iscale = 1.0 / scale;
|
|
}
|
|
return iscale
|
|
}
|
|
|
|
scaleButtons() {
|
|
//This also works for svgs.
|
|
// if (this.infoBtn)
|
|
// this.infoBtn.style.transform = "scale(" + this.buttonScale + ")"
|
|
|
|
// if (this.backBtn)
|
|
// this.backBtn.style.transform = "scale(" + this.buttonScale + ")"
|
|
|
|
// if (this.closeBtn)
|
|
// this.closeBtn.style.transform = "scale(" + this.buttonScale + ")"
|
|
|
|
console.log(this.buttonScale);
|
|
//// This did not work with svgs!
|
|
TweenLite.set([this.infoBtn, this.backBtn, this.closeBtn], {
|
|
scale: this.buttonScale
|
|
});
|
|
}
|
|
|
|
bringToFront() {
|
|
this.scatter.bringToFront();
|
|
TweenLite.set(this.element, { zIndex: DOMScatter.zIndex++ });
|
|
}
|
|
|
|
clickInfo() {
|
|
this.bringToFront();
|
|
this.infoBtn.click();
|
|
}
|
|
|
|
scatterTransformed(event) {
|
|
this.scaleButtons();
|
|
}
|
|
|
|
targetRotation(alpha) {
|
|
let ortho = 90;
|
|
let rest = alpha % ortho;
|
|
let delta = 0.0;
|
|
if (rest > ortho / 2.0) {
|
|
delta = ortho - rest;
|
|
} else {
|
|
delta = -rest;
|
|
}
|
|
return delta
|
|
}
|
|
|
|
infoValues(info) {
|
|
let startX = this.element._gsTransform.x;
|
|
let startY = this.element._gsTransform.y;
|
|
let startAngle = this.element._gsTransform.rotation;
|
|
let startScale = this.element._gsTransform.scaleX;
|
|
let w = this.element.style.width;
|
|
let h = this.element.style.height;
|
|
console.log(info, startX, startY, startAngle, startScale, w, h);
|
|
}
|
|
|
|
show(element, duration = 0, alpha = 1) {
|
|
if (element) {
|
|
TweenLite.to(element, duration, { autoAlpha: alpha }); // visibility: 'visible', display: 'initial'})
|
|
}
|
|
}
|
|
|
|
hide(element, duration = 0, alpha = 0) {
|
|
if (element) {
|
|
TweenLite.to(element, duration, { autoAlpha: alpha }); // {visibility: 'hidden', display: 'none'})
|
|
}
|
|
}
|
|
|
|
|
|
|
|
enable(button) {
|
|
this.show(button, this.fadeDuration);
|
|
if (button) {
|
|
TweenLite.set(button, { pointerEvents: 'auto' });
|
|
}
|
|
}
|
|
|
|
disable(button) {
|
|
this.hide(button, this.fadeDuration);
|
|
if (button) {
|
|
TweenLite.set(button, { pointerEvents: 'none' });
|
|
}
|
|
}
|
|
|
|
start({ targetCenter = null } = {}) {
|
|
this.bringToFront();
|
|
if (!this.flipped) {
|
|
this.startX = this.element._gsTransform.x;
|
|
this.startY = this.element._gsTransform.y;
|
|
this.startAngle = this.element._gsTransform.rotation;
|
|
this.startScale = this.element._gsTransform.scaleX;
|
|
this.startWidth = this.element.style.width;
|
|
this.startHeight = this.element.style.height;
|
|
this.scatterStartWidth = this.scatter.width;
|
|
this.scatterStartHeight = this.scatter.height;
|
|
this.show(this.back);
|
|
this.disable(this.infoBtn);
|
|
this.disable(this.closeBtn);
|
|
} else {
|
|
this.show(this.front, this.fadeDuration);
|
|
this.disable(this.backBtn);
|
|
}
|
|
let { scalable, translatable, rotatable } = this.scatter;
|
|
this.saved = { scalable, translatable, rotatable };
|
|
this.scatter.scalable = false;
|
|
this.scatter.translatable = false;
|
|
this.scatter.rotatable = false;
|
|
this.scatter.killAnimation();
|
|
|
|
this.flipped = !this.flipped;
|
|
let targetY = this.flipped ? 180 : 0;
|
|
let targetZ = this.flipped
|
|
? this.startAngle + this.targetRotation(this.startAngle)
|
|
: this.startAngle;
|
|
let targetScale = this.flipped ? this.wantedScale : this.startScale;
|
|
let w = this.flipped ? this.wantedWidth : this.startWidth;
|
|
let h = this.flipped ? this.wantedHeight : this.startHeight;
|
|
let dw = this.wantedWidth - this.scatter.width;
|
|
let dh = this.wantedHeight - this.scatter.height;
|
|
let tc = targetCenter;
|
|
let xx = tc != null ? tc.x - w / 2 : this.startX - dw / 2;
|
|
let yy = tc != null ? tc.y - h / 2 : this.startY - dh / 2;
|
|
let x = this.flipped ? xx : this.startX;
|
|
let y = this.flipped ? yy : this.startY;
|
|
|
|
console.log("DOMFlippable.start", this.flipped, targetCenter, x, y, this.saved);
|
|
let onUpdate = this.onUpdate !== null ? () => this.onUpdate(this) : null;
|
|
console.log(this.flipDuration);
|
|
TweenLite.to(this.card, this.flipDuration, {
|
|
rotationY: targetY,
|
|
ease: Power1.easeOut,
|
|
transformOrigin: '50% 50%',
|
|
onUpdate,
|
|
onComplete: e => {
|
|
if (this.flipped) {
|
|
//this.hide(this.front)
|
|
this.enable(this.backBtn);
|
|
this.show(this.backBtn);
|
|
|
|
if (this.onFrontFlipped) {
|
|
this.onFrontFlipped(this);
|
|
}
|
|
} else {
|
|
|
|
if (this.onBackFlipped == null) {
|
|
this.enable(this.infoBtn, this.fadeDuration);
|
|
this.enable(this.closeBtn, this.fadeDuration);
|
|
} else {
|
|
this.onBackFlipped(this);
|
|
}
|
|
this.flip.unload();
|
|
}
|
|
this.scatter.scale = targetScale;
|
|
this.scaleButtons();
|
|
this.scatter.rotationDegrees = targetZ;
|
|
this.scatter.width = this.flipped ? w : this.scatterStartWidth;
|
|
this.scatter.height = this.flipped ? h : this.scatterStartHeight;
|
|
|
|
let { scalable, translatable, rotatable } = this.saved;
|
|
this.scatter.scalable = scalable;
|
|
this.scatter.translatable = translatable;
|
|
this.scatter.rotatable = rotatable;
|
|
},
|
|
force3D: true
|
|
});
|
|
|
|
// See https://greensock.com/forums/topic/7997-rotate-the-shortest-way/
|
|
TweenLite.to(this.element, this.flipDuration / 2, {
|
|
scale: targetScale,
|
|
ease: Power1.easeOut,
|
|
rotationZ: targetZ + '_short',
|
|
transformOrigin: '50% 50%',
|
|
width: w,
|
|
height: h,
|
|
x: x,
|
|
y: y,
|
|
onComplete: e => {
|
|
if (this.flipped) {
|
|
this.hide(this.front);
|
|
// this.hide(this.infoBtn)
|
|
} else {
|
|
this.hide(this.back);
|
|
// this.show(this.infoBtn)
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
const deepZoomTileCache = new Map();
|
|
|
|
|
|
/** The current Tile implementation simply uses PIXI.Sprites.
|
|
*
|
|
* BTW: PIXI.extras.TilingSprite is not appropriate. It should be used for
|
|
* repeating patterns.
|
|
**/
|
|
class Tile extends PIXI.Sprite {
|
|
constructor(texture, url) {
|
|
super(texture);
|
|
this.url = url;
|
|
this.register(url);
|
|
}
|
|
|
|
static fromImage(imageId, crossorigin, scaleMode) {
|
|
return new Tile(PIXI.Texture.fromImage(imageId, crossorigin, scaleMode), imageId)
|
|
}
|
|
|
|
/**
|
|
* Registers the tile in the global reference counter for textures
|
|
*
|
|
* @param {*} url
|
|
* @param {boolean} [debug=false]
|
|
* @memberof Tile
|
|
*/
|
|
register(url, debug = false) {
|
|
if (deepZoomTileCache.has(url)) {
|
|
let tiles = deepZoomTileCache.get(url);
|
|
tiles.add(this);
|
|
if (debug) console.log("Tile.register", url, tiles.size);
|
|
}
|
|
else {
|
|
deepZoomTileCache.set(url, new Set([this]));
|
|
if (debug) console.log("Tile.register", url, 1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unregisters the rile in the global reference counter for textures
|
|
*
|
|
* @returns {number} The number of how often a texture is used.
|
|
* @memberof Tile
|
|
*/
|
|
unregister() {
|
|
let tiles = deepZoomTileCache.get(this.url);
|
|
tiles.delete(this);
|
|
if (tiles.size == 0) {
|
|
deepZoomTileCache.delete(this.url);
|
|
}
|
|
return tiles.size
|
|
}
|
|
|
|
/**
|
|
* Destroys this sprite and optionally its texture and children
|
|
*
|
|
* @param {*} options Part of the PIXI API, but ignored in the implementation
|
|
* @memberof Tile
|
|
*/
|
|
destroy(options, debug = false) {
|
|
if (this.parent != null) ;
|
|
let count = this.unregister();
|
|
if (count <= 0) {
|
|
let opts = { children: true, texture: true, baseTexture: true };
|
|
super.destroy(opts);
|
|
if (debug) console.log("Tile.destroy", deepZoomTileCache.size, opts);
|
|
}
|
|
else {
|
|
let opts = { children: true, texture: false, baseTexture: false };
|
|
if (debug) console.log("Tile.destroy", deepZoomTileCache.size, opts);
|
|
super.destroy(opts);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A Tile Loader component that can be plugged into a Tiles Layer.
|
|
*/
|
|
class TileLoader {
|
|
constructor(tiles) {
|
|
this.debug = false;
|
|
this.tiles = tiles;
|
|
this.setup();
|
|
}
|
|
|
|
/** Setup collections and instance vars. */
|
|
setup() {
|
|
this.map = new Map(); // Map {url : [ col, row]}
|
|
this.loading = new Set(); // Set url
|
|
this.loaded = new Map(); // Map {url : sprite }
|
|
this.loadQueue = [];
|
|
}
|
|
|
|
/** Schedules a tile url for loading. The loading itself must be triggered
|
|
by a call to loadOneTile or loadAll
|
|
|
|
* @param {String} url - the url of the texture / tile
|
|
* @param {Number} col - the tile col
|
|
* @param {Number} row - the tile row
|
|
**/
|
|
schedule(url, col, row) {
|
|
if (this.loaded.has(url)) return false
|
|
if (this.loading.has(url)) return false
|
|
this.map.set(url, [col, row]);
|
|
this.loading.add(url);
|
|
this.loadQueue.push(url);
|
|
return true
|
|
}
|
|
|
|
unschedule(url) {
|
|
if (this.loaded.has(url)) this.loaded.delete(url);
|
|
if (this.loading.has(url)) this.loading.delete(url);
|
|
this.loadQueue = this.loadQueue.filter(item => item != url);
|
|
}
|
|
|
|
/** Cancels loading by clearing the load queue **/
|
|
cancel() {
|
|
this.loadQueue = [];
|
|
this.loading.clear();
|
|
}
|
|
|
|
/** Destroys alls collections. **/
|
|
destroy() {
|
|
this.setup();
|
|
}
|
|
|
|
/** Private method. Informs the tile layer about a texture for a given url.
|
|
* Creates the sprite for the loaded texture and informs the tile layer.
|
|
* @param {String} url - the url
|
|
* @param {Object} texture - the loaded resource
|
|
**/
|
|
_textureAvailable(url, col, row, texture) {
|
|
let tile = this.loaded.get(url);
|
|
if (tile != null) {
|
|
console.warn("Tile already loaded");
|
|
tile.unregister();
|
|
}
|
|
tile = new Tile(texture, url);
|
|
this.loaded.set(url, tile);
|
|
this.tiles.tileAvailable(tile, col, row, url);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Uses the PIXI Loader but can be replaced with othe loaders implementing
|
|
* the public methods without underscore.
|
|
* Calls the Tiles.tileAvailable method if the texture is available.
|
|
**/
|
|
class PIXITileLoader extends TileLoader {
|
|
|
|
constructor(tiles, compression) {
|
|
super(tiles);
|
|
this.destroyed = false;
|
|
this.loader = new PIXI.loaders.Loader();
|
|
this.loader.on('load', this._onLoaded.bind(this));
|
|
this.loader.on('error', this._onError.bind(this));
|
|
if (compression) {
|
|
this.loader.pre(PIXI.compressedTextures.imageParser());
|
|
}
|
|
}
|
|
|
|
schedule(url, col, row) {
|
|
// Overwritten schedule to avoid BaseTexture and Texture already loaded errors.
|
|
if (this.loaded.has(url)) return false
|
|
if (this.loading.has(url)) return false
|
|
|
|
if (deepZoomTileCache.has(url)) {
|
|
let tiles = deepZoomTileCache.get(url);
|
|
for (let tile of tiles.values()) {
|
|
//console.log("Reusing cached texture", tile.parent)
|
|
let texture = tile.texture;
|
|
this._textureAvailable(url, col, row, texture);
|
|
return false
|
|
}
|
|
}
|
|
|
|
let texture = PIXI.utils.TextureCache[url];
|
|
if (texture) {
|
|
if (this.debug) console.log('Texture already loaded', texture);
|
|
this._textureAvailable(url, col, row, texture);
|
|
return false
|
|
}
|
|
let base = PIXI.utils.BaseTextureCache[url];
|
|
if (base) {
|
|
if (this.debug) console.log('BaseTexture already loaded', base);
|
|
let texture = new PIXI.Texture(base);
|
|
this._textureAvailable(url, col, row, texture);
|
|
return false
|
|
}
|
|
return super.schedule(url, col, row)
|
|
}
|
|
|
|
/** Load one and only one of the scheduled tiles **/
|
|
loadOneTile() {
|
|
if (this.destroyed)
|
|
return
|
|
this._loadOneTile();
|
|
}
|
|
|
|
/** Load all scheduled tiles **/
|
|
loadAll() {
|
|
if (this.destroyed)
|
|
return
|
|
this._loadAllTiles();
|
|
}
|
|
|
|
/** Destroys the loader completly **/
|
|
destroy() {
|
|
this.destroyed = true;
|
|
super.destroy();
|
|
try {
|
|
this.loader.reset();
|
|
} catch (error) {
|
|
console.warn("Error while resetting loader", error);
|
|
}
|
|
}
|
|
|
|
_onError(loader, error) {
|
|
console.warn('Cannot load', error);
|
|
}
|
|
|
|
/** Private method. Called by the PIXI loader after each successfull
|
|
* loading of a single tile.
|
|
* Creates the sprite for the loaded texture and informs the tile layer.
|
|
* @param {Object} loader - the loader instance
|
|
* @param {Object} resource - the loaded resource with url and texture attr
|
|
**/
|
|
_onLoaded(loader, resource) {
|
|
if (this.destroyed) {
|
|
let texture = resource.texture;
|
|
let destroyBase = !deepZoomTileCache.has(resource.url);
|
|
texture.destroy(destroyBase);
|
|
console.warn("Received resource after destroy", texture);
|
|
return
|
|
}
|
|
try {
|
|
let [col, row] = this.map.get(resource.url);
|
|
this._textureAvailable(resource.url, col, row, resource.texture);
|
|
}
|
|
catch (err) {
|
|
console.warn("Texture unavailable: " + err.message);
|
|
}
|
|
}
|
|
|
|
/** Private method: loads one tile from the queue. **/
|
|
_loadOneTile(retry = 1) {
|
|
//console.log("_loadOneTile")
|
|
if (this.destroyed) {
|
|
//console.warn("_loadOneTile after destroy")
|
|
return
|
|
}
|
|
if (this.loader.loading) {
|
|
setTimeout(() => {
|
|
this._loadOneTile();
|
|
}, retry);
|
|
return
|
|
}
|
|
if (this.loadQueue.length > 0) {
|
|
let url = this.loadQueue.pop();
|
|
this.loader.add(url, url);
|
|
this.loader.load();
|
|
}
|
|
}
|
|
|
|
/** Private method: loads all tiles from the queue in batches. Batches are
|
|
helpfull to avoid loading tiles that are no longer needed because the
|
|
user has already zoomed to a different level.**/
|
|
_loadAllTiles(batchSize = 8, retry = 16) {
|
|
if (this.destroyed) {
|
|
return
|
|
}
|
|
if (this.loadQueue.length > 0) {
|
|
if (this.loader.loading) {
|
|
//console.log("Loader busy", this.loadQueue.length)
|
|
setTimeout(() => {
|
|
this._loadAllTiles();
|
|
}, retry);
|
|
return
|
|
}
|
|
let i = 0;
|
|
let urls = [];
|
|
while (i < batchSize && this.loadQueue.length > 0) {
|
|
let url = this.loadQueue.pop();
|
|
if (!this.loaded.has(url)) {
|
|
let resource = this.loader.resources[url];
|
|
if (resource) {
|
|
console.log("Resource already added", url);
|
|
}
|
|
else {
|
|
urls.push(url);
|
|
i += 1;
|
|
}
|
|
}
|
|
}
|
|
this.loader.add(urls).load(() => {
|
|
this._loadAllTiles();
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Uses Workers but can be replaced with other loaders implementing
|
|
* the public methods without underscore.
|
|
* Calls the Tiles.tileAvailable method if the texture is available.
|
|
**/
|
|
class WorkerTileLoader extends TileLoader {
|
|
|
|
constructor(tiles) {
|
|
super(tiles);
|
|
let worker = this.worker = new Worker("../../lib/pixi/deepzoom/tileloader.js");
|
|
worker.onmessage = (event) => {
|
|
if (event.data.success) {
|
|
let { url, col, row, buffer } = event.data;
|
|
//console.log("WorkerTileLoader.loaded", url, buffer)
|
|
let CompressedImage = PIXI.compressedTextures.CompressedImage;
|
|
let compressed = CompressedImage.loadFromArrayBuffer(buffer, url);
|
|
let base = new PIXI.BaseTexture(compressed);
|
|
let texture = new PIXI.Texture(base);
|
|
this._textureAvailable(url, col, row, texture);
|
|
}
|
|
};
|
|
}
|
|
|
|
loadOne() {
|
|
if (this.loadQueue.length > 0) {
|
|
let url = this.loadQueue.pop();
|
|
let [col, row] = this.map.get(url);
|
|
let tile = [col, row, url];
|
|
this.worker.postMessage({ command: "load", tiles: [tile] });
|
|
}
|
|
}
|
|
|
|
loadAll() {
|
|
let tiles = [];
|
|
while (this.loadQueue.length > 0) {
|
|
let url = this.loadQueue.pop();
|
|
let [col, row] = this.map.get(url);
|
|
tiles.push([col, row, url]);
|
|
}
|
|
this.worker.postMessage({ command: "load", tiles });
|
|
}
|
|
|
|
cancel() {
|
|
super.cancel();
|
|
this.worker.postMessage({ command: "abort" });
|
|
}
|
|
|
|
destroy() {
|
|
this.worker.postMessage({ command: "abort" });
|
|
this.worker.terminate();
|
|
this.worker = null;
|
|
super.destroy();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A layer of tiles that represents a zoom level of a DeepZoomImage as a grid
|
|
* of sprites.
|
|
* @constructor
|
|
* @param {number} level - the zoom level of the tile layer
|
|
* @param {DeepZoomImage} view - the zoomable image the layer belongs to
|
|
* @param {number} scale - the scale of the tile layer
|
|
* @param {number} cols - the number of columns of the layer
|
|
* @param {number} rows - the number of rows of the layer
|
|
* @param {number} width - the width of the layer in pixel
|
|
* @param {number} height - the height of the layer in pixel
|
|
* @param {number} tileSize - the size of a single tile in pixel
|
|
* @param {number} overlap - the overlap of the tiles in pixel
|
|
* @param {number} fadeInTime - time needed to fade in tiles if TweenLite is set
|
|
**/
|
|
class Tiles extends PIXI.Container {
|
|
constructor(
|
|
level,
|
|
view,
|
|
scale,
|
|
cols,
|
|
rows,
|
|
width,
|
|
height,
|
|
tileSize,
|
|
overlap,
|
|
fadeInTime = 0.33
|
|
) {
|
|
super();
|
|
this.debug = false;
|
|
this.showGrid = false;
|
|
this.view = view;
|
|
this.level = level;
|
|
this.cols = cols;
|
|
this.rows = rows;
|
|
this.pixelWidth = width;
|
|
this.pixelHeight = height;
|
|
this.tileSize = tileSize;
|
|
this.overlap = overlap;
|
|
this.needed = new Map(); // url as key, [col, row] as value
|
|
this.requested = new Set();
|
|
this.available = new Map();
|
|
this.scale.set(scale, scale);
|
|
this.tileScale = scale;
|
|
this.fadeInTime = fadeInTime;
|
|
this.keep = false;
|
|
if (this.view.preferWorker && view.info.compression.length > 0)
|
|
this.loader = new WorkerTileLoader(this);
|
|
else
|
|
this.loader = new PIXITileLoader(this, view.info.compression);
|
|
this.interactive = false;
|
|
this._highlight = null;
|
|
|
|
this._info = null;
|
|
|
|
this._centerPoint = null;
|
|
this._boundsRect = null;
|
|
|
|
this.infoColor = Colors.random();
|
|
this.pprint();
|
|
this.destroyed = false;
|
|
}
|
|
|
|
|
|
|
|
/** Tests whether all tiles are loaded. **/
|
|
isComplete() {
|
|
return this.cols * this.rows === this.children.length
|
|
}
|
|
|
|
/** Returns the highligh graphics layer for debugging purposes.
|
|
**/
|
|
get highlight() {
|
|
if (this._highlight == null) {
|
|
let graphics = new PIXI.Graphics();
|
|
graphics.beginFill(0xffff00, 0.1);
|
|
graphics.lineStyle(2, 0xffff00);
|
|
graphics.drawRect(1, 1, this.tileSize - 2, this.tileSize - 2);
|
|
graphics.endFill();
|
|
graphics.interactive = false;
|
|
this._highlight = graphics;
|
|
}
|
|
return this._highlight
|
|
}
|
|
|
|
/** Returns the highligh graphics layer for debugging purposes.
|
|
**/
|
|
get info() {
|
|
if (this._info == null) {
|
|
let graphics = new PIXI.Graphics();
|
|
graphics.lineStyle(4, 0xff0000);
|
|
graphics.interactive = false;
|
|
this._info = graphics;
|
|
this.addChild(this._info);
|
|
}
|
|
return this._info
|
|
}
|
|
|
|
/** Helper method pretty printing debug information. **/
|
|
pprint() {
|
|
if (this.debug)
|
|
console.log(
|
|
'Tiles level: ' +
|
|
this.level +
|
|
' scale: ' +
|
|
this.scale.x +
|
|
' cols: ' +
|
|
this.cols +
|
|
' rows: ' +
|
|
this.rows +
|
|
' w: ' +
|
|
this.pixelWidth +
|
|
' h: ' +
|
|
this.pixelHeight +
|
|
' tsize:' +
|
|
this.tileSize
|
|
);
|
|
}
|
|
|
|
/** Computes the tile position and obeys the overlap.
|
|
* @param {number} col - The column of the tile
|
|
* @param {number} row - The row of the tile
|
|
* @returns {PIXI.Point} obj
|
|
**/
|
|
tilePosition(col, row) {
|
|
let x = col * this.tileSize;
|
|
let y = row * this.tileSize;
|
|
let overlap = this.overlap;
|
|
if (col != 0) {
|
|
x -= overlap;
|
|
}
|
|
if (row != 0) {
|
|
y -= overlap;
|
|
}
|
|
return new PIXI.Point(x, y)
|
|
}
|
|
|
|
/** Computes the tile size without overlap
|
|
* @param {number} col - The column of the tile
|
|
* @param {number} row - The row of the tile
|
|
* @returns {PIXI.Point} obj
|
|
**/
|
|
tileDimensions(col, row) {
|
|
let w = this.tileSize;
|
|
let h = this.tileSize;
|
|
let pos = this.tilePosition(col, row);
|
|
if (col == this.cols - 1) {
|
|
w = this.pixelWidth - pos.x;
|
|
}
|
|
if (row == this.rows - 1) {
|
|
h = this.pixelHeight - pos.y;
|
|
}
|
|
return new PIXI.Point(w, h)
|
|
}
|
|
|
|
/** Method to support debugging. Highlights the specified tile at col, row **/
|
|
highlightTile(col, row) {
|
|
if (col > -1 && row > -1 && col < this.cols && row < this.rows) {
|
|
let graphics = this.highlight;
|
|
let dim = this.tileDimensions(col, row);
|
|
graphics.position = this.tilePosition(col, row);
|
|
graphics.clear();
|
|
graphics.beginFill(0xff00ff, 0.1);
|
|
graphics.lineStyle(2, 0xffff00);
|
|
graphics.drawRect(1, 1, dim.x - 2, dim.y - 2);
|
|
graphics.endFill();
|
|
this.addChild(this.highlight);
|
|
} else {
|
|
this.removeChild(this.highlight);
|
|
}
|
|
}
|
|
|
|
/** Loads the tiles for the given urls and adds the tiles as sprites.
|
|
* @param {array} urlpos - An array of URL, pos pairs
|
|
* @param {boolean} onlyone - Loads only on tile at a time if true
|
|
**/
|
|
loadTiles(urlpos, onlyone, refCol, refRow) {
|
|
if (this.showGrid) {
|
|
this.highlightTile(refCol, refRow);
|
|
}
|
|
urlpos.forEach(d => {
|
|
let [url, col, row] = d;
|
|
if (this.loader.schedule(url, col, row)) {
|
|
if (onlyone) {
|
|
return this.loader.loadOneTile()
|
|
}
|
|
}
|
|
});
|
|
this.loader.loadAll();
|
|
}
|
|
|
|
/** Private method: add a red border to a tile for debugging purposes. **/
|
|
_addTileBorder(tile, col, row) {
|
|
let dim = this.tileDimensions(col, row);
|
|
let graphics = new PIXI.Graphics();
|
|
graphics.beginFill(0, 0);
|
|
graphics.lineStyle(2, 0xff0000);
|
|
graphics.drawRect(1, 1, dim.x - 2, dim.y - 2);
|
|
graphics.endFill();
|
|
tile.addChild(graphics);
|
|
}
|
|
|
|
/** Adds a tile. **/
|
|
addTile(tile, col, row, url) {
|
|
if (this.available.has(url)) {
|
|
console.warn('Trying to add available tile');
|
|
return
|
|
}
|
|
this.addChildAt(tile, 0);
|
|
this.available.set(url, tile);
|
|
if (this.destroyed) {
|
|
console.warn('Adding to destroyed tiles layer');
|
|
}
|
|
// this._addTileBorder(tile, col, row)
|
|
}
|
|
|
|
/** Called by the loader after each successfull loading of a single tile.
|
|
* Adds the sprite to the tile layer.
|
|
* @param {Object} tile - the loaded tile sprite
|
|
* @param {Number} col - the col position
|
|
* @param {Number} row - the rowposition
|
|
**/
|
|
tileAvailable(tile, col, row, url) {
|
|
let pos = this.tilePosition(col, row);
|
|
if (this.showGrid) {
|
|
this._addTileBorder(tile, col, row);
|
|
}
|
|
tile.position = pos;
|
|
tile.interactive = false;
|
|
if (TweenLite) {
|
|
tile.alpha = 0;
|
|
TweenLite.to(tile, this.fadeInTime, { alpha: this.alpha });
|
|
}
|
|
this.addTile(tile, col, row, url);
|
|
}
|
|
|
|
/** Destroys the tiles layer and destroys the loader. Async load calls are
|
|
* cancelled.
|
|
**/
|
|
destroy() {
|
|
this.destroyed = true;
|
|
this.loader.destroy();
|
|
super.destroy({ children: true }); // Calls destroyChildren
|
|
this.available.clear();
|
|
this.requested.clear();
|
|
this.needed.clear();
|
|
}
|
|
|
|
destroyTile(url, tile) {
|
|
this.loader.unschedule(url);
|
|
this.removeChild(tile);
|
|
tile.destroy();
|
|
this.available.delete(url);
|
|
}
|
|
|
|
destroyTileByUrl(url) {
|
|
if (this.available.has(url)) {
|
|
let tile = this.available.get(url);
|
|
this.destroyTile(url, tile);
|
|
}
|
|
}
|
|
|
|
/* Destroys the tiles which are not with the bounds of the app to free
|
|
* memory.
|
|
**/
|
|
destroyTiles(quadTrees) {
|
|
let count = 0;
|
|
for (let [url, tile] of this.available.entries()) {
|
|
if (!quadTrees.has(url)) {
|
|
this.destroyTile(url, tile);
|
|
count += 1;
|
|
}
|
|
}
|
|
if (count && this.debug)
|
|
console.log('destroyTiles', this.level, count);
|
|
}
|
|
|
|
destroyUnneededTiles() {
|
|
let count = 0;
|
|
for (let [url, tile] of this.available.entries()) {
|
|
if (!this.needed.has(url)) {
|
|
this.destroyTile(url, tile);
|
|
count += 1;
|
|
}
|
|
}
|
|
if (count && this.debug)
|
|
console.log('destroyUnneededTiles', this.level, count);
|
|
}
|
|
|
|
highlightInfos() {
|
|
let graphics = this.info;
|
|
let color = this.infoColor;
|
|
graphics.clear();
|
|
graphics.lineStyle(2, color);
|
|
for (let [col, row] of this.needed.values()) {
|
|
let dim = this.tileDimensions(col, row);
|
|
let pos = this.tilePosition(col, row);
|
|
graphics.beginFill(color, 0.2);
|
|
graphics.drawRect(pos.x + 1, pos.y + 1, dim.x - 2, dim.y - 2);
|
|
graphics.endFill();
|
|
}
|
|
let r = this._boundsRect;
|
|
if (r != null) {
|
|
graphics.lineStyle(20, color);
|
|
graphics.drawRect(r.x, r.y, r.width, r.height);
|
|
graphics.moveTo(r.x, r.y);
|
|
graphics.lineTo(r.x + r.width, r.y + r.height);
|
|
|
|
graphics.moveTo(r.x, r.y + r.height);
|
|
graphics.lineTo(r.x + r.width, r.y);
|
|
}
|
|
|
|
let p = this._centerPoint;
|
|
if (p != null) {
|
|
graphics.drawCircle(p.x, p.y, 20);
|
|
}
|
|
}
|
|
|
|
tintTiles(quadTrees) {
|
|
for (let [url, tile] of this.available.entries()) {
|
|
if (!quadTrees.has(url)) tile.tint = 0xff0000;
|
|
}
|
|
}
|
|
|
|
untintTiles() {
|
|
for (let [url, tile] of this.available.entries()) {
|
|
tile.tint = 0xffffff;
|
|
}
|
|
}
|
|
}
|
|
|
|
function isEven(n) {
|
|
return n % 2 == 0
|
|
}
|
|
|
|
|
|
function printTileCacheInfos() {
|
|
let references = new Map();
|
|
let multiples = 0;
|
|
for (let [url, tiles] of deepZoomTileCache.entries()) {
|
|
let count = tiles.size;
|
|
references.set(url, count);
|
|
if (count > 1) {
|
|
multiples += 1;
|
|
}
|
|
}
|
|
console.log({ multiples, references });
|
|
}
|
|
/**
|
|
* A utility class that holds information typically provided by DZI files, i.e.
|
|
* height and width of the overall image, overlap, and image type.
|
|
*
|
|
* @constructor
|
|
* @param {obj} attrs - A JSON-Object holding the listed keys and values
|
|
* @example
|
|
* {
|
|
* "tileSize": 1024,
|
|
* "format": "jpeg",
|
|
* "overlap": 1,
|
|
* "height": 4794,
|
|
* "width": 4095,
|
|
* "clip": { "minLevel": 12, "maxLevel": 20, "startCol": 301436, "startRow": 354060 },
|
|
* // optional: minLevel and maxLevel define the level bounds
|
|
* // startCol: first col at maxLevel
|
|
* // startRow: first row at maxLevel
|
|
* "path": "var/Vermeer/Vermeer_files",
|
|
* "type": "dzi", // optional: dzi (default) or map
|
|
* "urlTileTemplate": "{path}/{level}/{column}/{row}.{format}"
|
|
* // optional: {path}/{level}/{column}_{row}.{format} (default) or
|
|
* // a template String with the format of the URL
|
|
* }
|
|
*/
|
|
class DeepZoomInfo {
|
|
constructor(attrs) {
|
|
for (let key in attrs) {
|
|
this[key] = attrs[key];
|
|
}
|
|
this.maxLevel = 0; // The highest level number, typically corresponds to the
|
|
// number in the file system for the folder with tiles
|
|
this.clip = this.clip || null; // e.g. { level: 12, col: 301436, row: 354060 }
|
|
this.type = this.type || 'dzi';
|
|
this.urlTileTemplate =
|
|
this.urlTileTemplate || '{path}/{level}/{column}_{row}.{format}';
|
|
this.setupDimensions();
|
|
}
|
|
|
|
/* Computes the needed number of layers from the width and height
|
|
* of the image. Note that this includes the level 0, i.e. 0 ... 4
|
|
* means that 5 levels exist.
|
|
**/
|
|
numLevels() {
|
|
let maxDimension = Math.max(this.width, this.height);
|
|
let boundary = this.type === 'dzi' ? 1 : this.tileSize;
|
|
let numLevels = 0;
|
|
while (maxDimension >= boundary) {
|
|
maxDimension /= 2;
|
|
numLevels++;
|
|
}
|
|
return numLevels
|
|
}
|
|
|
|
/** Computes the scale at the given level.
|
|
* @param {number} level - The level of the wanted layer
|
|
* @returns {number} scale
|
|
**/
|
|
getScale(level) {
|
|
let scale = 1;
|
|
if (this.type === 'dzi') {
|
|
scale = Math.pow(0.5, this.maxLevel - level + 1);
|
|
} else {
|
|
scale = Math.pow(0.5, this.maxLevel - level);
|
|
}
|
|
return scale
|
|
}
|
|
|
|
/** Computes the scaled width and height of the given level.
|
|
* @param {number} level - The level of the wanted layer
|
|
* @returns {array} size - The width and height
|
|
**/
|
|
getDimensions(level) {
|
|
let scale = this.getScale(level);
|
|
let w = Math.ceil(this.width * scale);
|
|
let h = Math.ceil(this.height * scale);
|
|
return [w, h]
|
|
}
|
|
|
|
/** Computes the number of cols and rows of tiles.
|
|
* @param {number} level - The level of the wanted layer
|
|
* @returns {array} size - The cols and rows
|
|
**/
|
|
getNumTiles(level) {
|
|
let dim = this.getDimensions(level);
|
|
let cols = Math.ceil(dim[0] / this.tileSize);
|
|
let rows = Math.ceil(dim[1] / this.tileSize);
|
|
if (this.clip) {
|
|
let rest = this.rests[level];
|
|
if (rest) {
|
|
if (rest.restCol) {
|
|
cols += 1;
|
|
}
|
|
if (rest.restRows) {
|
|
rows += 1;
|
|
}
|
|
}
|
|
}
|
|
return [cols, rows]
|
|
}
|
|
|
|
setupDimensions(loadBaseImage = false) {
|
|
/** Setup instance variables and load the base image, i.e. the largest
|
|
image that can be represented as a single tile.
|
|
@private
|
|
**/
|
|
let ww = this.width;
|
|
let hh = this.height;
|
|
let scale = 1.0;
|
|
let level = 0;
|
|
let single = 0;
|
|
const tsize = this.tileSize;
|
|
|
|
if (this.clip) {
|
|
this.baseLevel = this.clip.minLevel;
|
|
this.maxLevel = this.clip.maxLevel;
|
|
this.baseImage = null;
|
|
this.size = this.getDimensions(this.baseLevel);
|
|
this.offsets = {};
|
|
this.rests = {};
|
|
let startCol = this.clip.startCol;
|
|
let startRow = this.clip.startRow;
|
|
let floatStartCol = startCol;
|
|
let floatStartRow = startRow;
|
|
for (let i = this.maxLevel; i >= this.baseLevel; i--) {
|
|
this.offsets[i] = { startCol, startRow };
|
|
let restCol = floatStartCol % 1;
|
|
let restRow = floatStartRow % 1;
|
|
this.rests[i] = { restCol, restRow };
|
|
startCol = Math.floor(startCol / 2);
|
|
startRow = Math.floor(startRow / 2);
|
|
floatStartCol /= 2;
|
|
floatStartRow /= 2;
|
|
}
|
|
} else {
|
|
const boundary = this.type === 'dzi' ? 1.0 : tsize;
|
|
while (ww > boundary && hh > boundary) {
|
|
if (ww >= tsize && hh >= tsize) {
|
|
single += 1;
|
|
}
|
|
scale = scale / 2.0;
|
|
ww = Math.ceil(this.width * scale);
|
|
hh = Math.ceil(this.height * scale);
|
|
level += 1;
|
|
}
|
|
this.baseLevel = level - single;
|
|
this.maxLevel = this.numLevels() - 1;
|
|
this.baseURL = this.urlForTile(this.baseLevel, 0, 0, false);
|
|
|
|
if (loadBaseImage) {
|
|
this.imageForURL(this.baseURL, e => {
|
|
this.size = [e.target.naturalWidth, e.target.naturalHeight];
|
|
this.baseImage = e.target;
|
|
});
|
|
} else {
|
|
this.baseImage = null;
|
|
this.size = this.getDimensions(this.baseLevel);
|
|
}
|
|
}
|
|
}
|
|
|
|
get maxLoadableLevel() {
|
|
if (this.clip) {
|
|
return this.maxLevel
|
|
}
|
|
return this.type === 'dzi' ? this.maxLevel : this.maxLevel
|
|
}
|
|
|
|
/** Computes the url for the given level, column and and row.
|
|
* @param {number} level - The level of the wanted layer
|
|
* @param {number} column - The column of the tile
|
|
* @param {number} row - The row of the tile
|
|
* @returns {string} url
|
|
**/
|
|
urlForTile(level, column, row, compressed = true) {
|
|
let format = this.format;
|
|
if (compressed && this.compression) {
|
|
let supported = Capabilities.isIOS ? 'pvr' : 'dds';
|
|
if (this.compression.indexOf(supported) >= 0) {
|
|
format = supported;
|
|
}
|
|
}
|
|
if (this.clip) {
|
|
let offset = this.offsets[level];
|
|
if (offset) {
|
|
let { startCol, startRow } = offset;
|
|
column += startCol;
|
|
row += startRow;
|
|
}
|
|
}
|
|
let url = this.urlTileTemplate
|
|
.replace(/\{path\}/g, this.path)
|
|
.replace(/\{level\}/g, level)
|
|
.replace(/\{row\}/g, row)
|
|
.replace(/\{column\}/g, column)
|
|
.replace(/\{format\}/g, format);
|
|
return url
|
|
}
|
|
|
|
/** Loads the image for the given url and executes a callback function
|
|
on completion.
|
|
* @param {string} url - The url of the tile
|
|
* @param {function} complete - The callback function
|
|
* @returns {Image} obj
|
|
**/
|
|
imageForURL(url, complete) {
|
|
let img = new Image();
|
|
img.onload = complete.bind(this);
|
|
img.src = url;
|
|
return img
|
|
}
|
|
|
|
/** Computes the columns and rows as well as scaled width and height.
|
|
* @param {number} level - The level of the wanted layer
|
|
* @returns {array} [cols, rows, width, height]
|
|
**/
|
|
dimensions(level) {
|
|
let dim = this.getDimensions(level);
|
|
let tiles = this.getNumTiles(level);
|
|
return [tiles[0], tiles[1], dim[0], dim[1]]
|
|
}
|
|
|
|
test() {
|
|
//console.log("w=" + this.width + " h=" + this.height + " maxlevel=" + this.maxLevel + " base=" + this.baseLevel)
|
|
for (let i = 0; i <= this.maxLevel; i++) {
|
|
console.log(
|
|
' ' +
|
|
i +
|
|
' -> ' +
|
|
this.getScale(i) +
|
|
' [' +
|
|
this.dimensions(i) +
|
|
']'
|
|
);
|
|
}
|
|
console.log(this.urlForTile(this.baseLevel, 0, 0));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A utility class that describes a quad tree of tiles. Each tile on a given
|
|
* level has up to four corresponding tiles on the next level. A TileQuadNode
|
|
* uses the attributes nw (i.e. northwest), ne, sw, se to link to the
|
|
* quad nodes on the next level. The previous attributes links to the quad
|
|
* one level below that holds the given quad as nw, ne, sw, or se.
|
|
* We use this node class because we need a representation of tiles that are
|
|
* needed but not loaded yet to compute tiles which can be abandoned to reduce
|
|
* the memory pressure.
|
|
*
|
|
* @constructor
|
|
* @param {level} Number - The level the quad node belongs to
|
|
* @param {col} Number - The col of the quad
|
|
* @param {row} Number - The level the quad node belongs to
|
|
* @param {url} String - The level the quad node belongs to
|
|
*/
|
|
class TileQuadNode {
|
|
constructor(level, col, row, url) {
|
|
this.level = level;
|
|
this.col = col;
|
|
this.row = row;
|
|
this.url = url;
|
|
this.nw = null;
|
|
this.ne = null;
|
|
this.sw = null;
|
|
this.se = null;
|
|
this.previous = null;
|
|
}
|
|
|
|
/** Return True if this node has no successors and can be used as
|
|
an indicator of tiles to free.
|
|
**/
|
|
noQuads() {
|
|
if (this.previous === null) return false
|
|
return (
|
|
this.nw === null &&
|
|
this.ne === null &&
|
|
this.sw === null &&
|
|
this.se === null
|
|
)
|
|
}
|
|
|
|
/** Unlink the given quad node
|
|
|
|
* @param {node} TileQuadNode - The TileQuadNode to remove
|
|
**/
|
|
unlink(node) {
|
|
if (this.nw === node) this.nw = null;
|
|
if (this.ne === node) this.ne = null;
|
|
if (this.sw === node) this.sw = null;
|
|
if (this.se === node) this.se = null;
|
|
}
|
|
|
|
/** Link this quad node to the given previous node. Use the north
|
|
* and west flags to address nw, ne, sw, and se.
|
|
|
|
* @param {node} TileQuadNode - The TileQuadNode to remove
|
|
* @param {north} Boolean - Link to north (true) or south (false)
|
|
* @param {west} Boolean - Link to west (true) or east (false)
|
|
**/
|
|
link(north, west, previous) {
|
|
this.previous = previous;
|
|
if (north) {
|
|
if (west) {
|
|
previous.nw = this;
|
|
} else {
|
|
previous.ne = this;
|
|
}
|
|
} else {
|
|
if (west) {
|
|
previous.sw = this;
|
|
} else {
|
|
previous.se = this;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* The main class of a deeply zoomable image that is represented by a hierarchy
|
|
* of tile layers for each zoom level. This gives the user the impression that
|
|
* even huge pictures (up to gigapixel-images) can be zoomed instantaneously,
|
|
* since the tiles at smaller levels are scaled immediately and overloaded by
|
|
* more detailed tiles at the larger level as fast as possible.
|
|
|
|
* @constructor
|
|
* @param {DeepZoomInfo} deepZoomInfo - Information extracted from a JSON-Object
|
|
*/
|
|
class DeepZoomImage extends PIXI.Container {
|
|
constructor(
|
|
deepZoomInfo,
|
|
{
|
|
debug = false,
|
|
shadow = false,
|
|
center = false,
|
|
world = null, // Defines the world bounds the images lives in
|
|
highResolution = true,
|
|
autoLoadTiles = true,
|
|
preferWorker = false,
|
|
minimumLevel = 0,
|
|
alpha = 1,
|
|
app = window.app
|
|
} = {}
|
|
) {
|
|
super();
|
|
this.app = app;
|
|
this.debug = debug;
|
|
this.shadow = shadow;
|
|
this.world = world;
|
|
this.preferWorker = preferWorker;
|
|
this.resolution = highResolution
|
|
? Math.round(window.devicePixelRatio)
|
|
: 1;
|
|
this.alpha = alpha;
|
|
this.fastLoads = 0;
|
|
this.autoLoadTiles = autoLoadTiles;
|
|
this.minimumLevel = minimumLevel;
|
|
this.quadTrees = new Map(); // url as keys, TileQuadNodes as values
|
|
this.setup(deepZoomInfo, center);
|
|
}
|
|
|
|
get point() {
|
|
if (this._point == null) {
|
|
let graphics = new PIXI.Graphics();
|
|
graphics.lineStyle(2, 0x00ff00);
|
|
graphics.drawCircle(0, 0, 2);
|
|
graphics.interactive = false;
|
|
this._point = graphics;
|
|
}
|
|
return this._point
|
|
}
|
|
|
|
/** Reads the DeepZoomInfo object and initializes all tile layers.
|
|
* Called by the constructor.
|
|
* Creates the sprite for the loaded texture and add the sprite to the tile
|
|
* layer.
|
|
* @param {Object} deepZoomInfo - the DeepZoomInfo instance
|
|
* @param {boolean} center - If true ensures that the pivot is set to the center
|
|
**/
|
|
setup(deepZoomInfo, center) {
|
|
this.info = deepZoomInfo;
|
|
this.interactive = true;
|
|
this.tileLayers = {};
|
|
|
|
this._foreground = null;
|
|
this.tileContainer = new PIXI.Container();
|
|
this.tileContainer.interactive = false;
|
|
|
|
let [w, h] = this.baseSize;
|
|
if (this.shadow) {
|
|
this.filters = [new PIXI.filters.DropShadowFilter(45, 3)];
|
|
}
|
|
this.addChild(this.tileContainer);
|
|
|
|
if (deepZoomInfo.clip) {
|
|
let mask = new PIXI.Graphics();
|
|
mask.beginFill(1, 1);
|
|
mask.drawRect(0, 0, w, h);
|
|
mask.endFill();
|
|
this.mask = mask;
|
|
mask.alpha = 0;
|
|
this.addChild(mask);
|
|
this.minimumLevel = deepZoomInfo.baseLevel;
|
|
}
|
|
this.currentLevel = Math.max(this.minimumLevel, deepZoomInfo.baseLevel);
|
|
console.log("autoLoadTiles", this.autoLoadTiles);
|
|
if (this.autoLoadTiles) {
|
|
this.setupTiles(center);
|
|
}
|
|
}
|
|
|
|
/** Default setup method for tiles. Loads all tiles of the current level.
|
|
Can be overwritten in subclasses.
|
|
@param {boolean} center - If true ensures that the pivot is set to the center
|
|
**/
|
|
setupTiles(center = false) {
|
|
// First load background tile
|
|
let tiles = this.ensureAllTiles(this.currentLevel);
|
|
if (center) {
|
|
this.pivot.set(w / 2, h / 2);
|
|
}
|
|
let scaleLevel = this.levelForScale(1);
|
|
this.ensureAllTiles(scaleLevel);
|
|
}
|
|
|
|
removeTileQuadNode(level, col, row, url) {
|
|
if (this.quadTrees.has(url)) {
|
|
let quad = this.quadTrees.get(url);
|
|
this.tileQuadRemoved(quad);
|
|
this.quadTrees.delete(url);
|
|
}
|
|
}
|
|
|
|
addTileQuadNode(level, col, row, url) {
|
|
if (this.quadTrees.has(url)) return this.quadTrees.get(url)
|
|
let quad = new TileQuadNode(level, col, row, url);
|
|
this.quadTrees.set(url, quad);
|
|
this.tileQuadAdded(quad);
|
|
return quad
|
|
}
|
|
|
|
tileQuadRemoved(quad) {
|
|
let below = quad.previous;
|
|
// if (this.debug) console.log("tileQuadRemoved", quad)
|
|
if (below) {
|
|
below.unlink(quad);
|
|
if (below.noQuads()) {
|
|
if (this.debug) console.log('Removed tile below');
|
|
let levelBelow = quad.level - 1;
|
|
if (levelBelow < this.minimumLevel) return
|
|
let c = Math.floor(quad.col / 2);
|
|
let r = Math.floor(quad.row / 2);
|
|
let urlBelow = this.info.urlForTile(levelBelow, c, r);
|
|
if (this.quadTrees.has(urlBelow)) {
|
|
this.removeTileQuadNode(levelBelow, c, r, urlBelow);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
tileQuadAdded(quad) {
|
|
let levelBelow = quad.level - 1;
|
|
if (levelBelow < this.minimumLevel) return
|
|
//if (this.debug) console.log("tileQuadAdded", quad)
|
|
let c = Math.floor(quad.col / 2);
|
|
let r = Math.floor(quad.row / 2);
|
|
let urlBelow = this.info.urlForTile(levelBelow, c, r);
|
|
let below = null;
|
|
if (!this.quadTrees.has(urlBelow)) {
|
|
below = this.addTileQuadNode(levelBelow, c, r, urlBelow);
|
|
quad.link(isEven(quad.row), isEven(quad.col), below);
|
|
}
|
|
}
|
|
|
|
/** Returns the tile layer level that corresponds to the given scale.
|
|
* @param {number} scale - the scale factor
|
|
**/
|
|
levelForScale(scale) {
|
|
let level = Math.round(Math.log2(scale * this.resolution)); // Math.floor(Math.log2(event.scale))+1
|
|
let newLevel = this.info.baseLevel + Math.max(level, 0);
|
|
return Math.min(newLevel, this.info.maxLoadableLevel)
|
|
}
|
|
|
|
/** Returns the tile layer level that corresponds to the given scale.
|
|
* @param {number} scale - the scale factor
|
|
**/
|
|
levelAndAlphaForScale(scale) {
|
|
let value = Math.log2(scale * this.resolution);
|
|
let level = Math.round(value);
|
|
let newLevel = this.info.baseLevel + Math.max(level, 0);
|
|
|
|
return { level: Math.min(newLevel, this.info.maxLoadableLevel), alpha: value - level }
|
|
}
|
|
|
|
/** Adds a tile layer to the DeepZoomImage.
|
|
* @param {string} key - the access key
|
|
* @param {Tiles} tiles - the tile layer object
|
|
**/
|
|
addTiles(key, tiles) {
|
|
if (key in this.tileLayers) {
|
|
console.warn('Tiles already availabl', key);
|
|
}
|
|
this.tileContainer.addChild(tiles);
|
|
this.tileLayers[key] = tiles;
|
|
}
|
|
|
|
destroyTiles(key) {
|
|
let tiles = this.tileLayers[key];
|
|
this.tileContainer.removeChild(tiles);
|
|
tiles.destroy();
|
|
delete this.tileLayers[key];
|
|
}
|
|
|
|
/** Getter for PIXI.Container foreground layer.
|
|
* Adds a PIXI.Container if necessary.
|
|
**/
|
|
get foreground() {
|
|
if (this._foreground == null) {
|
|
this._foreground = new PIXI.Container();
|
|
this.addChild(this._foreground);
|
|
}
|
|
return this._foreground
|
|
}
|
|
|
|
/** Getter for the DeepZoomInfo base level size.
|
|
**/
|
|
get baseSize() {
|
|
return this.info.getDimensions(this.info.baseLevel)
|
|
}
|
|
|
|
/** Getter for the current scaled size in pixels.
|
|
**/
|
|
get pixelSize() {
|
|
let [w, h] = this.baseSize;
|
|
return [w * this.scale.x, h * this.scale.y]
|
|
}
|
|
|
|
/** Getter for the max scale factor.
|
|
**/
|
|
get maxScale() {
|
|
let delta = this.info.maxLevel - this.info.baseLevel;
|
|
return Math.pow(2, delta) / this.resolution * 2
|
|
}
|
|
|
|
/** Getter for the current width.
|
|
**/
|
|
get width() {
|
|
return this.pixelSize[0]
|
|
}
|
|
|
|
/** Getter for the current height.
|
|
**/
|
|
get height() {
|
|
return this.pixelSize[1]
|
|
}
|
|
|
|
|
|
/* Overrides PIXI.Container.hitArea()
|
|
* Allows to optimize the hit testing. Container with hit areas are directly
|
|
* hit tested without consideration of children.
|
|
*/
|
|
get hitArea() {
|
|
// Defining the hitArea resulted hitting the scatter in masked area
|
|
// when a mask was used (@Tüsch[submaps]). Removing the hitArea() altogether
|
|
// broke the interaction in other projects (@googleart).
|
|
// Fix: When masked, the hitArea is ignored by returning null.
|
|
// TODO: test if childs are hittested, without setting interactiveChildren.
|
|
// Opel, 03-05-2018
|
|
if (this.mask) {
|
|
return null
|
|
}
|
|
return this
|
|
}
|
|
|
|
/* Overrides PIXI.Container.contains()
|
|
* Allows to optimize the hit testing.
|
|
*/
|
|
contains(x, y) {
|
|
let [w, h] = this.baseSize;
|
|
return x >= 0 && x <= w && y >= 0 && y <= h
|
|
}
|
|
|
|
/** Overrides PIXI.Container._calculateBounds()
|
|
* Only considers the base size and reduces the calculation to a single
|
|
* rect.
|
|
*/
|
|
_calculateBounds() {
|
|
let [w, h] = this.baseSize;
|
|
this._bounds.addFrame(this.transform, 0, 0, w, h);
|
|
}
|
|
|
|
/** Overrides PIXI.Container.calculateBounds()
|
|
* Skips the children and only considers the deep zoom base size. Calls
|
|
* the also overwritten _calculateBounds method.
|
|
*/
|
|
calculateBounds() {
|
|
this._bounds.clear();
|
|
this._calculateBounds();
|
|
this._lastBoundsID = this._boundsID;
|
|
}
|
|
|
|
/** Returns a single sprite that can be used a thumbnail representation of
|
|
* large images.
|
|
* @return {Sprite} sprite - A sprite with a single tile texture
|
|
*/
|
|
thumbnail() {
|
|
return new PIXI.Sprite.fromImage(this.info.baseURL)
|
|
}
|
|
|
|
/** Returns a list of all tiles of a given level.
|
|
* @param {Tiles} tiles - the grid of tiles
|
|
* @param {number} level - The zoom level of the grid
|
|
* @return {Array[]} - An array of [url, col, row] arrays
|
|
**/
|
|
allTiles(tiles, level) {
|
|
let result = [];
|
|
for (let col = 0; col < tiles.cols; col++) {
|
|
for (let row = 0; row < tiles.rows; row++) {
|
|
let url = this.info.urlForTile(level, col, row);
|
|
result.push([url, col, row]);
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
worldBounds() {
|
|
let viewBounds = this.app.scene.bounds;
|
|
// Using getBounds extends visible scope after loading tiles and leads
|
|
// to excessive loading
|
|
if (this.world != null) {
|
|
let bounds = this.world.bounds;
|
|
let x = Math.max(-bounds.width, bounds.x);
|
|
let y = Math.max(-bounds.height, bounds.y);
|
|
let width = Math.min(viewBounds.width, bounds.width);
|
|
let height = Math.min(viewBounds.height, bounds.height);
|
|
//console.log("worldBounds new", { x, y, width, height })
|
|
return { x, y, width, height }
|
|
}
|
|
//console.log("worldBounds old", viewBounds)
|
|
return viewBounds
|
|
}
|
|
|
|
/** Loads all tiles that are needed to fill the app bounds.
|
|
* @param {Tiles} tiles - the grid of tiles
|
|
* @param {number} level - The zoom level of the grid
|
|
* @param {boolean} debug
|
|
* @return {Array[]} - An array of [url, col, row] arrays
|
|
*/
|
|
neededTiles(tiles, level, debug = false) {
|
|
let needed = [];
|
|
let tsize = tiles.tileSize;
|
|
let worldBounds = this.worldBounds();
|
|
let maxWidth = worldBounds.width;
|
|
let maxHeight = worldBounds.height;
|
|
|
|
let pointInWindow = new PIXI.Point();
|
|
let worldTopLeft = new PIXI.Point(worldBounds.x, worldBounds.y);
|
|
let worldBottomRight = new PIXI.Point(worldBounds.x + maxWidth, worldBounds.y + maxHeight);
|
|
let worldCenter = new PIXI.Point(worldBounds.x + maxWidth / 2, worldBounds.y + maxHeight / 2);
|
|
let tilesCenter = tiles.toLocal(worldCenter);
|
|
|
|
let topLeft = tiles.toLocal(worldTopLeft);
|
|
let bottomRight = tiles.toLocal(worldBottomRight);
|
|
tiles._centerPoint = tilesCenter;
|
|
let bounds = new PIXI.Rectangle(
|
|
topLeft.x,
|
|
topLeft.y,
|
|
bottomRight.x - topLeft.x,
|
|
bottomRight.y - topLeft.y);
|
|
|
|
tiles._boundsRect = bounds;
|
|
|
|
/* UO: we need a toLocal call here since the transform may need an update
|
|
which is guaranteed by the toLocal method. */
|
|
let centerCol = Math.floor(tilesCenter.x / tsize);
|
|
let centerRow = Math.floor(tilesCenter.y / tsize);
|
|
|
|
// Expand because we want to test for included centers
|
|
bounds.x -= tsize / 2;
|
|
bounds.y -= tsize / 2;
|
|
bounds.width += tsize;
|
|
bounds.height += tsize;
|
|
|
|
try {
|
|
let maxTilesWidth = Math.ceil(maxWidth / tsize);
|
|
let maxTilesHeight = Math.ceil(maxHeight / tsize);
|
|
|
|
maxTilesWidth += 2;
|
|
maxTilesHeight += 2;
|
|
|
|
let startCol = Math.max(0, centerCol - maxTilesWidth);
|
|
let endCol = Math.min(tiles.cols, centerCol + maxTilesWidth);
|
|
|
|
let startRow = Math.max(0, centerRow - maxTilesHeight);
|
|
let endRow = Math.min(tiles.rows, centerRow + maxTilesHeight);
|
|
|
|
for (let col = startCol; col < endCol; col++) {
|
|
let cx = (col + 0.5) * tsize;
|
|
for (let row = startRow; row < endRow; row++) {
|
|
let cy = (row + 0.5) * tsize;
|
|
let tileCenter = new PIXI.Point(cx, cy);
|
|
if (bounds.contains(tileCenter.x, tileCenter.y)) {
|
|
let url = this.info.urlForTile(level, col, row);
|
|
needed.push([url, col, row]);
|
|
}
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.warn(error.message);
|
|
}
|
|
return { centerCol, centerRow, needed }
|
|
}
|
|
|
|
|
|
|
|
|
|
/** Returns all changed tiles for a given level.
|
|
* @param {Tiles} tiles - the grid of tiles
|
|
* @param {number} level - The zoom level of the grid
|
|
* @return {object} - An object with the keys added and removed which values are [url, col, row] arrays
|
|
*/
|
|
changedTiles(tiles, level) {
|
|
if (this.debug) console.time('changedTiles');
|
|
let changed = { added: [], removed: [] };
|
|
let newNeeded = new Map();
|
|
let { centerCol, centerRow, needed } = this.neededTiles(tiles, level);
|
|
needed.forEach(d => {
|
|
let [url, col, row] = d;
|
|
newNeeded.set(url, [col, row]);
|
|
if (!tiles.requested.has(url)) {
|
|
changed.added.push(d);
|
|
}
|
|
});
|
|
for (let url of tiles.needed.keys()) {
|
|
if (!newNeeded.has(url)) {
|
|
let [col, row] = tiles.needed.get(url);
|
|
changed.removed.push([url, col, row]);
|
|
}
|
|
}
|
|
tiles.needed = newNeeded;
|
|
if (this.debug) console.log(newNeeded);
|
|
if (this.debug) console.timeEnd('changedTiles');
|
|
return { centerCol, centerRow, changed }
|
|
}
|
|
|
|
/** Populates all tiles for a given level.
|
|
* @param {Tiles} tiles - the grid of tiles
|
|
* @param {number} level - The zoom level of the grid
|
|
*/
|
|
populateAllTiles(tiles, level) {
|
|
let all = this.allTiles(tiles, level);
|
|
for (let [url, col, row] of all) {
|
|
this.addTileQuadNode(level, col, row, url);
|
|
}
|
|
tiles.loadTiles(all, false, 0, 0);
|
|
}
|
|
|
|
/** Loads all tiles that are needed to fill the browser window.
|
|
* If the optional about parameter is provided (as a point with col as x,
|
|
* and row as y attr) the tiles are sorted by the distance to this point.
|
|
*
|
|
* @param {Tiles} tiles - the grid of tiles
|
|
* @param {number} level - The zoom level of the grid
|
|
* Optional parameter:
|
|
* @param {boolean} onlyone - if true only one tile is loaded
|
|
* @param {PIXI.Point} about - point of interaction
|
|
*/
|
|
populateTiles(tiles, level, { onlyone = false, about = null } = {}) {
|
|
if (tiles.isComplete())
|
|
return
|
|
let referenceCol = -1;
|
|
let referenceRow = -1;
|
|
let { centerCol, centerRow, changed } = this.changedTiles(tiles, level);
|
|
if (about != null) {
|
|
// We want to load tiles in the focus of the user first, therefore
|
|
// we sort according to the distance of the focus of interaction
|
|
let refPoint = this.toLocal(about);
|
|
let scaledTileSize = tiles.tileSize * tiles.tileScale;
|
|
referenceCol = Math.floor(refPoint.x / scaledTileSize);
|
|
referenceRow = Math.floor(refPoint.y / scaledTileSize);
|
|
}
|
|
else {
|
|
referenceCol = centerCol;
|
|
referenceRow = centerRow;
|
|
}
|
|
referenceCol = centerCol;
|
|
referenceRow = centerRow;
|
|
|
|
let removed = changed.removed;
|
|
for (let [url, col, row] of removed) {
|
|
this.removeTileQuadNode(level, col, row, url);
|
|
}
|
|
let added = changed.added;
|
|
if (added.length == 0) return
|
|
for (let [url, col, row] of added) {
|
|
this.addTileQuadNode(level, col, row, url);
|
|
}
|
|
let ref = new PIXI.Point(referenceCol, referenceRow);
|
|
// Note: The array must be sorted in a way that the nearest tiles
|
|
// are at the end of the array since the load queue uses Array.push
|
|
// Array.pop
|
|
added.sort((a, b) => {
|
|
let aa = new PIXI.Point(a[1], a[2]);
|
|
let bb = new PIXI.Point(b[1], b[2]);
|
|
let da = Points.distance(aa, ref);
|
|
let db = Points.distance(bb, ref);
|
|
return db - da
|
|
});
|
|
tiles.loadTiles(added, onlyone, referenceCol, referenceRow);
|
|
}
|
|
|
|
/** Private method: creates all tiles for a given level.
|
|
* @param {number} level - The zoom level of the grid
|
|
* @return {Tiles} - tiles
|
|
*/
|
|
_createTiles(key, level) {
|
|
let [cols, rows, w, h] = this.info.dimensions(level);
|
|
let increasedLevels = level - this.info.baseLevel;
|
|
let invScale = Math.pow(0.5, increasedLevels);
|
|
let tiles = new Tiles(
|
|
level,
|
|
this,
|
|
invScale,
|
|
cols,
|
|
rows,
|
|
w,
|
|
h,
|
|
this.info.tileSize,
|
|
this.info.overlap
|
|
);
|
|
this.addTiles(key, tiles);
|
|
if (this.info.clip) {
|
|
let rest = this.info.rests[level];
|
|
if (rest) {
|
|
let x = rest.restCol * this.info.tileSize * invScale;
|
|
let y = rest.restRow * this.info.tileSize * invScale;
|
|
tiles.x = -x;
|
|
tiles.y = -y;
|
|
}
|
|
}
|
|
return tiles
|
|
}
|
|
|
|
/** Ensures that all needed tiles of a given level are loaded. Creates
|
|
* a new Tiles layer if necessary
|
|
* @param {number} level - The zoom level of the grid
|
|
* @return {Tiles} tiles
|
|
*/
|
|
ensureTiles(level, about) {
|
|
let key = level.toString();
|
|
if (key in this.tileLayers) {
|
|
let tiles = this.tileLayers[key];
|
|
this.populateTiles(tiles, level, { about: about });
|
|
return tiles
|
|
}
|
|
let tiles = this._createTiles(key, level);
|
|
this.populateTiles(tiles, level, { about: about });
|
|
//console.log("ensureTiles", level)
|
|
return tiles
|
|
}
|
|
|
|
untintTiles(level) {
|
|
let key = level.toString();
|
|
if (key in this.tileLayers) {
|
|
let tiles = this.tileLayers[key];
|
|
}
|
|
}
|
|
|
|
/** Ensures that all tiles of a given level are loaded.
|
|
* @param {number} level - The zoom level of the grid
|
|
*/
|
|
ensureAllTiles(level) {
|
|
let key = level.toString();
|
|
if (key in this.tileLayers) {
|
|
let tiles = this.tileLayers[key];
|
|
this.populateAllTiles(tiles, level);
|
|
tiles.keep = true;
|
|
return
|
|
}
|
|
let tiles = this._createTiles(key, level);
|
|
this.populateAllTiles(tiles, level);
|
|
tiles.keep = true;
|
|
return tiles
|
|
}
|
|
|
|
hideTilesAboveLevel(level) {
|
|
Object.keys(this.tileLayers).forEach(key => {
|
|
let tiles = this.tileLayers[key];
|
|
if (tiles.level > level) {
|
|
tiles.visible = false;
|
|
}
|
|
});
|
|
}
|
|
|
|
/** Destroys all tiles above a given level to ensure that the memory can
|
|
* be reused.
|
|
* @param {number} level - The zoom level of the grid
|
|
*/
|
|
destroyTilesAboveLevel(level) {
|
|
Object.keys(this.tileLayers).forEach(key => {
|
|
let tiles = this.tileLayers[key];
|
|
if (tiles.level > level && !tiles.keep) {
|
|
for (let url of tiles.available.keys()) {
|
|
let quad = this.quadTrees.get(url);
|
|
if (quad) this.removeTileQuadNode(quad);
|
|
}
|
|
this.destroyTiles(key);
|
|
}
|
|
});
|
|
}
|
|
|
|
destroyAllTiles() {
|
|
Object.keys(this.tileLayers).forEach(key => {
|
|
this.destroyTiles(key);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Tint tiles in all layers that are no longer needed
|
|
*
|
|
* @memberof DeepZoomImage
|
|
*/
|
|
tintObsoleteTiles() {
|
|
Object.keys(this.tileLayers).forEach(key => {
|
|
let tiles = this.tileLayers[key];
|
|
tiles.untintTiles();
|
|
if (!tiles.keep) {
|
|
tiles.tintObsoleteTiles();
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
/**
|
|
* Destroy tiles in all layers that are no longer needed
|
|
*
|
|
* @memberof DeepZoomImage
|
|
*/
|
|
destroyUnneededTiles() {
|
|
Object.keys(this.tileLayers).forEach(key => {
|
|
let tiles = this.tileLayers[key];
|
|
if (!tiles.keep) {
|
|
tiles.destroyUnneededTiles();
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Destroy tiles in all layers that are no longer needed
|
|
*
|
|
* @memberof DeepZoomImage
|
|
*/
|
|
destroyObsoleteTiles() {
|
|
Object.keys(this.tileLayers).forEach(key => {
|
|
let tiles = this.tileLayers[key];
|
|
if (!tiles.keep) {
|
|
tiles.destroyObsoleteTiles();
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Destroy tiles in all layers that are not part of the
|
|
* visible quadTrees
|
|
*
|
|
* @memberof DeepZoomImage
|
|
*/
|
|
destroyTiles() {
|
|
Object.keys(this.tileLayers).forEach(key => {
|
|
let tiles = this.tileLayers[key];
|
|
if (!tiles.keep) {
|
|
tiles.destroyTiles(this.quadTrees);
|
|
}
|
|
});
|
|
}
|
|
|
|
/* Tint all tiles
|
|
* @param {number} level - The zoom level of the grid
|
|
*/
|
|
tintTilesBelowLevel(level) {
|
|
Object.keys(this.tileLayers).forEach(key => {
|
|
let tiles = this.tileLayers[key];
|
|
if (tiles.level < level) {
|
|
tiles.tintTiles(this.quadTrees);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Ensure that the given tiles layer is the topmost one and visible.
|
|
* @param {*} tiles
|
|
*/
|
|
bringTilesToFront(tiles) {
|
|
this.tileContainer.addChild(tiles);
|
|
tiles.visible = true;
|
|
}
|
|
|
|
/** A callback function that can be used by a Scatter view to inform
|
|
* the zoomable image that it has been moved, rotated or scaled, and should
|
|
* load tiles accordingly.
|
|
* @param {PIXI.Point} translated - the movement of the scatter
|
|
* @param {number} scale - the zoom factor
|
|
* @param {PIXI.Point} about - the anchor point of the zoom
|
|
* @param {boolean} fast - informs the callback to return as fast as possible,
|
|
* i.e. after loading a single tile
|
|
* @param {boolean} debug - log debug infos
|
|
*/
|
|
transformed(event) {
|
|
let key = this.currentLevel.toString();
|
|
let currentTiles = this.tileLayers[key];
|
|
if (typeof currentTiles == 'undefined') {
|
|
return
|
|
}
|
|
if (event.fast) {
|
|
this.fastLoads += 1;
|
|
this.populateTiles(currentTiles, this.currentLevel, {
|
|
onlyone: false,
|
|
about: event.about
|
|
});
|
|
if (this.fastLoads == 3) {
|
|
this.fastLoads = 0;
|
|
}
|
|
else {
|
|
return
|
|
}
|
|
}
|
|
if (event.scale == null) {
|
|
this.ensureTiles(this.currentLevel, event.about);
|
|
return
|
|
}
|
|
|
|
let level = this.levelForScale(event.scale);
|
|
let newLevel = Math.max(level, this.minimumLevel);
|
|
if (newLevel != this.currentLevel) {
|
|
if (!currentTiles.keep) {
|
|
currentTiles.loader.cancel();
|
|
}
|
|
this.hideTilesAboveLevel(newLevel);
|
|
currentTiles = this.ensureTiles(newLevel, event.about);
|
|
this.currentLevel = newLevel;
|
|
} else {
|
|
this.ensureTiles(this.currentLevel, event.about);
|
|
}
|
|
this.bringTilesToFront(currentTiles);
|
|
if (this._foreground) {
|
|
this.addChild(this._foreground);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*Activates the textures on the DeepZoomImage.
|
|
*
|
|
* @memberof DeepZoomImage
|
|
*/
|
|
activate() {
|
|
this.destroyTilesAboveLevel(this.currentLevel);
|
|
this.ensureTiles(this.currentLevel, null);
|
|
//console.log("Activate Textures!", this.currentLevel)
|
|
}
|
|
|
|
/**
|
|
*Dectivates the textures on the DeepZoomImage.
|
|
*
|
|
* @memberof DeepZoomImage
|
|
*/
|
|
deactivate() {
|
|
this.destroyAllTiles();
|
|
Object.keys(this.tileLayers).forEach(key => {
|
|
this.destroyTiles(key);
|
|
});
|
|
this.tileContainer.destroy({ children: true });
|
|
printTileCacheInfos();
|
|
}
|
|
|
|
throwFinished() {
|
|
console.log("throwFinished");
|
|
let key = this.currentLevel.toString();
|
|
let currentTiles = this.tileLayers[key];
|
|
if (typeof currentTiles == 'undefined') {
|
|
return
|
|
}
|
|
|
|
this.ensureTiles(this.currentLevel);
|
|
// let all = new Set()
|
|
// for (let tile of currentTiles.children) {
|
|
// all.add(tile.url)
|
|
// }
|
|
// let { centerCol, centerRow, needed } = this.neededTiles(currentTiles, this.currentLevel)
|
|
// for (let [url, col, row] of needed) {
|
|
// all.delete(url)
|
|
// }
|
|
// for (let url of all) {
|
|
// currentTiles.destroyTileByUrl(url)
|
|
// }
|
|
// currentTiles.loader.loader.reset()
|
|
}
|
|
}
|
|
|
|
let globalScatterLoaderCanvas = null;
|
|
|
|
class ScatterLoader extends CardLoader {
|
|
|
|
get scatter() {
|
|
return this.src
|
|
}
|
|
|
|
unscaledSize() {
|
|
let displayObject = this.scatter.displayObject;
|
|
let w = displayObject.width;
|
|
let h = displayObject.height;
|
|
return [w / displayObject.scale.x, h / displayObject.scale.y]
|
|
}
|
|
|
|
scaledSize() {
|
|
let displayObject = this.scatter.displayObject;
|
|
let w = displayObject.width;
|
|
let h = displayObject.height;
|
|
return [w, h]
|
|
}
|
|
|
|
cloneScatterImage() {
|
|
let w = this.scatter.width;
|
|
let h = this.scatter.height;
|
|
let isSprite = this.scatter.displayObject instanceof PIXI.Sprite;
|
|
let isDeepZoom = this.scatter.displayObject instanceof DeepZoomImage;
|
|
let resolution = app.renderer.resolution;
|
|
if (isSprite) {
|
|
w = this.scatter.displayObject.texture.width;
|
|
h = this.scatter.displayObject.texture.height;
|
|
}
|
|
else if (isDeepZoom) {
|
|
let [ww, hh] = this.scatter.displayObject.baseSize;
|
|
w = ww;
|
|
h = hh;
|
|
}
|
|
if (globalScatterLoaderCanvas === null) {
|
|
globalScatterLoaderCanvas = document.createElement('canvas');
|
|
}
|
|
let canvas = globalScatterLoaderCanvas;
|
|
canvas.width = w;
|
|
canvas.height = h;
|
|
let renderer = new PIXI.WebGLRenderer(w, h, {
|
|
view: canvas,
|
|
resolution: resolution});
|
|
|
|
let displayObject = this.scatter.displayObject;
|
|
let x = displayObject.x;
|
|
let y = displayObject.y;
|
|
let rot = displayObject.rotation;
|
|
let sx = displayObject.scale.x;
|
|
let sy = displayObject.scale.y;
|
|
displayObject.rotation = 0;
|
|
// The Safari WebGLRenderer wants everything flipped
|
|
// See https://github.com/pixijs/pixi.js/issues/2283
|
|
displayObject.x = 0;
|
|
if (Capabilities.isSafari) {
|
|
displayObject.y = h;
|
|
displayObject.scale.set(1, -1); // sx, -sy)
|
|
}
|
|
else {
|
|
displayObject.y = 0;
|
|
displayObject.scale.set(1, 1);
|
|
}
|
|
if (isSprite) {
|
|
displayObject.width = w;
|
|
displayObject.height = h;
|
|
}
|
|
renderer.render(displayObject);
|
|
displayObject.rotation = rot;
|
|
displayObject.x = x;
|
|
displayObject.y = y;
|
|
displayObject.scale.set(sx, sy);
|
|
|
|
let url = canvas.toDataURL();
|
|
return [x, y, w, h, url]
|
|
}
|
|
|
|
load(domNode) {
|
|
return new Promise((resolve, reject) => {
|
|
let isImage = domNode instanceof HTMLImageElement;
|
|
let isSprite = this.scatter.displayObject instanceof PIXI.Sprite;
|
|
let image = (isImage) ? domNode : document.createElement("img");
|
|
let [x, y, w, h, cloneURL] = this.cloneScatterImage();
|
|
let [ww, hh] = this.unscaledSize();
|
|
image.onload = (e) => {
|
|
if (!isImage)
|
|
domNode.appendChild(image);
|
|
this.x = x;
|
|
this.y = y;
|
|
this.wantedWidth = ww;
|
|
this.wantedHeight = hh;
|
|
this.scale = 1;
|
|
this.rotation = this.scatter.rotation;
|
|
resolve(this);
|
|
};
|
|
image.onerror = (e) => {
|
|
reject(this);
|
|
};
|
|
image.src = cloneURL;
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
class FlipEffect {
|
|
|
|
constructor(scatter, domScatterContainer, flipTemplate, backLoader) {
|
|
this.flipped = false;
|
|
this.scatter = scatter;
|
|
this.backLoader = backLoader;
|
|
this.scatterLoader = new ScatterLoader(scatter);
|
|
this.domFlip = new DOMFlip(domScatterContainer, flipTemplate,
|
|
this.scatterLoader,
|
|
backLoader, {
|
|
onBack: this.backCardClosed.bind(this)
|
|
});
|
|
this.setupInfoButton();
|
|
}
|
|
|
|
startFlip() {
|
|
let center = this.flipCenter();
|
|
let loader = this.backLoader;
|
|
this.domFlip.load().then((domFlip) => {
|
|
this.scatter.displayObject.visible = false;
|
|
domFlip.centerAt(center);
|
|
domFlip.zoom(this.scatter.scale);
|
|
let target = this.constraintFlipCenter(center, loader);
|
|
console.log("FlipEffect.startFlip", target, loader);
|
|
domFlip.start({targetCenter: target});
|
|
});
|
|
}
|
|
|
|
unscaledSize() {
|
|
return this.scatterLoader.unscaledSize()
|
|
}
|
|
|
|
flipCenter() {
|
|
let isSprite = this.scatter.displayObject instanceof PIXI.Sprite;
|
|
let resolution = (isSprite) ? app.renderer.resolution : 1;
|
|
let center = this.scatter.center;
|
|
let canvas = app.renderer.view;
|
|
let domNode = this.domFlip.domScatterContainer.element;
|
|
let page = window.convertPointFromNodeToPage(canvas,
|
|
center.x*resolution,
|
|
center.y*resolution);
|
|
let local = window.convertPointFromPageToNode(domNode, page.x, page.y);
|
|
return local
|
|
}
|
|
|
|
constraintFlipCenter(center, loader) {
|
|
let w = loader.wantedWidth;
|
|
let h = loader.wantedHeight;
|
|
console.log("constraintFlipCenter", w, h);
|
|
let canvas = app.renderer.view;
|
|
let x = center.x;
|
|
let y = center.y;
|
|
if (x < w/2)
|
|
x = w/2;
|
|
if (y < h/2)
|
|
y = h/2;
|
|
if (x > canvas.width)
|
|
x = canvas.width - w/2;
|
|
if (y > canvas.height)
|
|
y = canvas.height - h/2;
|
|
return { x, y }
|
|
}
|
|
|
|
setupInfoButton() {
|
|
let iscale = 1.0 / this.scatter.scale;
|
|
this.infoBtn = new PIXI.Graphics();
|
|
this.infoBtn.beginFill(0x333333);
|
|
this.infoBtn.lineStyle(4, 0xFFFFFF);
|
|
this.infoBtn.drawCircle(0, 0, 22);
|
|
this.infoBtn.endFill();
|
|
|
|
this.infoBtn.beginFill(0xFFFFFF);
|
|
this.infoBtn.lineStyle(0);
|
|
this.infoBtn.drawCircle(0, -8, 4);
|
|
this.infoBtn.endFill();
|
|
|
|
this.infoBtn.lineStyle(6, 0xFFFFFF);
|
|
this.infoBtn.moveTo(0, -2);
|
|
this.infoBtn.lineTo(0, 14);
|
|
this.infoBtn.endFill();
|
|
|
|
this.infoBtn.on('click', (e) => { this.infoSelected(); });
|
|
this.infoBtn.on('tap', (e) => { this.infoSelected(); });
|
|
|
|
this.infoBtn.interactive = true;
|
|
this.infoBtn.width = 44;
|
|
this.infoBtn.height = 44;
|
|
this.infoBtn.pivot.x = 30;
|
|
this.infoBtn.pivot.y = 30;
|
|
|
|
let displayObject = this.scatter.displayObject;
|
|
let [w, h] = this.unscaledSize();
|
|
this.infoBtn.position = new PIXI.Point(w, h);
|
|
if (displayObject.foreground) {
|
|
this.infoBtn.scale.x = iscale;
|
|
this.infoBtn.scale.y = iscale;
|
|
displayObject.foreground.addChild(this.infoBtn);
|
|
}
|
|
else {
|
|
displayObject.addChild(this.infoBtn);
|
|
}
|
|
|
|
this.scatter.addTransformEventCallback(e => {
|
|
let displayObject = this.scatter.displayObject;
|
|
if (displayObject.foreground) {
|
|
if (e.scale) {
|
|
let iscale = 1.0 / e.scale;
|
|
this.infoBtn.scale.x = iscale;
|
|
this.infoBtn.scale.y = iscale;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
setupButton(url) {
|
|
let svgImage = new Image();
|
|
let canvas = document.createElement('canvas');
|
|
canvas.width = 88 * 4;
|
|
canvas.height = 44 * 4;
|
|
svgImage.onload = e => {
|
|
let displayObject = this.scatter.displayObject;
|
|
canvas.getContext ('2d').drawImage(svgImage, 0, 0,
|
|
canvas.width, canvas.height);
|
|
let texure = new PIXI.Texture(new PIXI.BaseTexture(canvas));
|
|
this.infoBtn = new PIXI.Sprite(texure);
|
|
this.infoBtn.anchor.set(0.5, 0.5);
|
|
if (displayObject.foreground) {
|
|
displayObject.foreground.addChild(this.infoBtn);
|
|
}
|
|
else {
|
|
displayObject.addChild(this.infoBtn);
|
|
}
|
|
this.infoBtn.scale.set(0.5, 0.5);
|
|
|
|
let [w, h] = this.unscaledSize();
|
|
this.infoBtn.position = new PIXI.Point(w, h);
|
|
this.infoBtn.interactive = true;
|
|
this.infoBtn.updateTransform();
|
|
this.infoBtn.on('click', (e) => { this.infoSelected(); });
|
|
this.infoBtn.on('tap', (e) => { this.infoSelected(); });
|
|
};
|
|
svgImage.src = url;
|
|
}
|
|
|
|
infoSelected() {
|
|
this.startFlip();
|
|
}
|
|
|
|
backSelected() {
|
|
this.domFlip.start();
|
|
}
|
|
|
|
backCardClosed() {
|
|
/*** The flip effect should now be in it's initial state again. All
|
|
memory should be freed. ***/
|
|
let displayObject = this.scatter.displayObject;
|
|
displayObject.visible = true;
|
|
this.domFlip.fadeOutAndRemove();
|
|
this.flipped = false;
|
|
}
|
|
|
|
targetRotation(alpha) {
|
|
let ortho = 90;
|
|
let rest = alpha % ortho;
|
|
let delta = 0.0;
|
|
if (rest > (ortho / 2.0)) {
|
|
delta = ortho - rest;
|
|
}
|
|
else {
|
|
delta = -rest;
|
|
}
|
|
return delta
|
|
}
|
|
}
|
|
|
|
/* globals Power2, Sine */
|
|
/*eslint no-console: ["error", { allow: ["log", "info", "error"] }]*/
|
|
|
|
/**
|
|
* Callback for the flippable onStart function.
|
|
*
|
|
* @callback onStartCallback
|
|
* @param {Flippable} flippable - A reference to the flippable (also this refers to the flippable).
|
|
*/
|
|
|
|
/**
|
|
* Callback for the flippable onUpdate function.
|
|
*
|
|
* @callback onUpdateCallback
|
|
* @param {Flippable} flippable - A reference to the flippable (also this refers to the flippable).
|
|
*/
|
|
|
|
/**
|
|
* Callback for the flippable onComplete function.
|
|
*
|
|
* @callback onCompleteCallback
|
|
* @param {Flippable} flippable - A reference to the flippable (also this refers to the flippable).
|
|
*/
|
|
|
|
/**
|
|
* Class that represents a PixiJS Flippable.
|
|
*
|
|
* @example
|
|
* const front = PIXI.Sprite.fromImage('./assets/front.jpg')
|
|
* const back = PIXI.Sprite.fromImage('./assets/back.jpg')
|
|
* app.scene.addChild(front)
|
|
*
|
|
* // Create the flippable
|
|
* const flippable = new Flippable(front, back, app.renderer)
|
|
*
|
|
* front.interactive = true
|
|
* front.on('click', event => flippable.toggle())
|
|
*
|
|
* @class
|
|
* @extends PIXI.projection.Camera3d
|
|
* @see {@link https://github.com/pixijs/pixi-projection|PixiJS Projection}
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/flippable.html|DocTest}
|
|
*/
|
|
class Flippable extends PIXI.projection.Camera3d {
|
|
|
|
/**
|
|
* Creates an instance of a Flippable.
|
|
*
|
|
* @constructor
|
|
* @param {PIXI.DisplayObject} front - The object to show initially. Should have been added to the scene.
|
|
* @param {PIXI.DisplayObject} back - The object to show on the backside. Should have not been added to the scene.
|
|
* @param {PIXI.WebGLRenderer|PIXI.CanvasRenderer} renderer - The renderer of the application.
|
|
* @param {object} [opts] - An options object which can contain the following properties.
|
|
* @param {number} [opts.duration=1] - The duration of the flip animation in seconds.
|
|
* @param {GSAP.Ease} [opts.ease=Power2.easeOut] - The ease of the flip animation.
|
|
* @param {boolean} [opts.shadow=false] - Should be a shadow been display during the animation?
|
|
* @param {numer} [opts.eulerX=0] - The shift of the x-axis during the animation.
|
|
* @param {numer} [opts.eulerY=0] - The shift of the y-axis during the animation.
|
|
* @param {GSAP.Ease} [opts.eulerEase=Sine.easeOut] - The ease of the shift.
|
|
* @param {boolean} [opts.useBackTransforms=false] - When set to true, the flip animation also animates to the transform parameters of the back-object.
|
|
* @param {GSAP.Ease} [opts.transformEase=Power2.easeOut] - The ease of the transform.
|
|
* @param {numer} [opts.focus=800] - The value of the focus of the 3D camera (see pixi-projection).
|
|
* @param {numer} [opts.near=10] - The near value of the 3D camera (see pixi-projection).
|
|
* @param {numer} [opts.far=10000] - The far value of the 3D camera (see pixi-projection).
|
|
* @param {boolean} [opts.orthographic=false] - Should the flip animation be an orthographic animation?
|
|
* @param {function} [opts.onStart=null] - A callback executed on start of the flip animation.
|
|
* @param {function} [opts.onUpdate=null] - A callback executed on each step of the flip animation.
|
|
* @param {function} [opts.onComplete=null] - A callback executed when the flip animation is finished.
|
|
*/
|
|
constructor(front, back, renderer, opts = {}) {
|
|
|
|
super();
|
|
|
|
this.opts = Object.assign({}, {
|
|
front,
|
|
back,
|
|
renderer,
|
|
duration: 1,
|
|
ease: Power2.easeOut,
|
|
shadow: false,
|
|
eulerX: 0,
|
|
eulerY: 0,
|
|
eulerEase: Sine.easeOut,
|
|
useBackTransforms: false,
|
|
transformEase: Power2.easeOut,
|
|
focus: 800,
|
|
near: 10,
|
|
far: 10000,
|
|
orthographic: false
|
|
}, opts);
|
|
|
|
// planes
|
|
//--------------------
|
|
this.setPlanes(this.opts.focus, this.opts.near, this.opts.far, this.opts.orthographic);
|
|
|
|
// flipped
|
|
//--------------------
|
|
this._flipped = false;
|
|
|
|
// objects
|
|
//--------------------
|
|
this.objects = {};
|
|
|
|
// setup
|
|
//--------------------
|
|
this.setup();
|
|
}
|
|
|
|
/**
|
|
* Creates children and instantiates everything.
|
|
*
|
|
* @private
|
|
* @return {Flippable} A reference to the flippable for chaining.
|
|
*/
|
|
setup() {
|
|
|
|
const scale = .5;
|
|
|
|
// filters
|
|
//--------------------
|
|
const blurFilter = new PIXI.filters.BlurFilter();
|
|
blurFilter.blur = 0.2;
|
|
this.objects.blurFilter = blurFilter;
|
|
|
|
// outer
|
|
//--------------------
|
|
const outer = new PIXI.projection.Container3d();
|
|
outer.scale3d.set(scale);
|
|
this.addChild(outer);
|
|
this.objects.outer = outer;
|
|
|
|
// shadow
|
|
//--------------------
|
|
const shadow = new PIXI.projection.Sprite3d(PIXI.Texture.fromImage('../../assets/images/shadow.png'));
|
|
shadow.renderable = false;
|
|
shadow.anchor.set(0.5);
|
|
shadow.scale3d.set(.98);
|
|
shadow.alpha = 0.7;
|
|
shadow.filters = [blurFilter];
|
|
shadow.visible = this.opts.shadow;
|
|
outer.addChild(shadow);
|
|
this.objects.shadow = shadow;
|
|
|
|
// inner
|
|
//--------------------
|
|
const inner = new PIXI.projection.Container3d();
|
|
inner.euler.y = Math.PI;
|
|
outer.addChild(inner);
|
|
this.objects.inner = inner;
|
|
|
|
// front
|
|
//--------------------
|
|
const front = new PIXI.projection.Sprite3d(PIXI.Texture.EMPTY);
|
|
front.scale.set(-1 / scale, 1 / scale);
|
|
front.renderable = true;
|
|
front.anchor.set(.5);
|
|
inner.addChild(front);
|
|
this.objects.front = front;
|
|
|
|
// back
|
|
//--------------------
|
|
const back = new PIXI.projection.Sprite3d(PIXI.Texture.EMPTY);
|
|
back.scale.set(1 / scale, 1 / scale);
|
|
back.renderable = false;
|
|
back.anchor.set(.5);
|
|
inner.addChild(back);
|
|
this.objects.back = back;
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Gets or sets the flipped state.
|
|
*
|
|
* @member {boolean}
|
|
*/
|
|
get flipped() {
|
|
return this._flipped
|
|
}
|
|
set flipped(toBack) {
|
|
|
|
this._flipped = toBack;
|
|
|
|
// references
|
|
//--------------------
|
|
const front = this.objects.front;
|
|
const back = this.objects.back;
|
|
const inner = this.objects.inner;
|
|
const shadow = this.objects.shadow;
|
|
const blurFilter = this.objects.blurFilter;
|
|
|
|
const half = this.opts.duration / 2;
|
|
const ease = this.opts.eulerEase;
|
|
|
|
const fromObject = toBack ? this.opts.front : this.opts.back;
|
|
const toObject = toBack ? this.opts.back : this.opts.front;
|
|
|
|
// set textures for virtual front and virtual back
|
|
//--------------------
|
|
front.texture = this.generateTexture(this.opts.front);
|
|
back.texture = this.generateTexture(this.opts.back);
|
|
|
|
// switch objects and set params for virtual objects
|
|
//--------------------
|
|
const fromCenter = this.anchorToCenter(fromObject);
|
|
const toCenter = this.anchorToCenter(toObject);
|
|
|
|
// from values
|
|
//--------------------
|
|
this.x = fromCenter.x;
|
|
this.y = fromCenter.y;
|
|
front.width = fromObject.width * 2;
|
|
front.height = fromObject.height * 2;
|
|
back.width = fromObject.width * 2;
|
|
back.height = fromObject.height * 2;
|
|
this.rotation = fromObject.rotation;
|
|
this.skew.x = fromObject.skew.x;
|
|
this.skew.y = fromObject.skew.y;
|
|
|
|
// calculate to values
|
|
//--------------------
|
|
const to = {
|
|
x: this.opts.useBackTransforms ? toCenter.x : fromCenter.x,
|
|
y: this.opts.useBackTransforms ? toCenter.y : fromCenter.y,
|
|
anchorX: this.opts.useBackTransforms ? toObject.x : fromObject.x,
|
|
anchorY: this.opts.useBackTransforms ? toObject.y : fromObject.y,
|
|
width: this.opts.useBackTransforms ? toObject.width * 2 : fromObject.width * 2,
|
|
height: this.opts.useBackTransforms ? toObject.height * 2 : fromObject.height * 2,
|
|
rotation: this.opts.useBackTransforms ? toObject.rotation : fromObject.rotation,
|
|
skewX: this.opts.useBackTransforms ? toObject.skew.x : fromObject.skew.x,
|
|
skewY: this.opts.useBackTransforms ? toObject.skew.y : fromObject.skew.y
|
|
};
|
|
|
|
// set toObject end values
|
|
//--------------------
|
|
toObject.x = to.anchorX;
|
|
toObject.y = to.anchorY;
|
|
toObject.width = to.width / 2;
|
|
toObject.height = to.height / 2;
|
|
toObject.rotation = to.rotation;
|
|
toObject.skew.x = to.skewX;
|
|
toObject.skew.y = to.skewY;
|
|
|
|
// flip
|
|
//--------------------
|
|
TweenLite.to(inner.euler, this.opts.duration, {
|
|
y: toBack ? 0 : Math.PI,
|
|
ease: this.opts.ease,
|
|
onStart: () => {
|
|
this.switchDisplayObject(fromObject, this);
|
|
shadow.renderable = true;
|
|
if (this.opts.onStart) {
|
|
this.opts.onStart(this, this);
|
|
}
|
|
},
|
|
onUpdate: () => {
|
|
this.layout();
|
|
if (this.opts.onUpdate) {
|
|
this.opts.onUpdate(this, this);
|
|
}
|
|
},
|
|
onComplete: () => {
|
|
this.switchDisplayObject(this, toObject);
|
|
shadow.renderable = false;
|
|
if (this.opts.onComplete) {
|
|
this.opts.onComplete(this, this);
|
|
}
|
|
}
|
|
});
|
|
|
|
// x & y
|
|
//--------------------
|
|
TweenLite.to(this, this.opts.duration, {
|
|
x: to.x,
|
|
y: to.y,
|
|
ease: this.opts.transformEase
|
|
});
|
|
|
|
// width & height
|
|
//--------------------
|
|
TweenLite.to([front, back], this.opts.duration, {
|
|
width: to.width,
|
|
height: to.height,
|
|
ease: this.opts.transformEase
|
|
});
|
|
|
|
// rotation
|
|
//--------------------
|
|
TweenLite.to(this, this.opts.duration, {
|
|
directionalRotation: {
|
|
rotation: `${to.rotation}_short`,
|
|
useRadians: true
|
|
},
|
|
ease: this.opts.transformEase
|
|
});
|
|
|
|
// skewX & skewY
|
|
//--------------------
|
|
TweenLite.to(this.skew, this.opts.duration, {
|
|
x: to.skewX,
|
|
y: to.skewY,
|
|
ease: this.opts.transformEase
|
|
});
|
|
|
|
// camera
|
|
//--------------------
|
|
new TimelineMax()
|
|
.to(this.euler, half, {x: this.opts.eulerX, y: this.opts.eulerY, ease})
|
|
.to(this.euler, half, {x: 0, y: 0, ease});
|
|
|
|
// shadow
|
|
//--------------------
|
|
new TimelineMax()
|
|
.to(shadow, half, {alpha: .3, ease})
|
|
.to(shadow, half, {alpha: .7, ease});
|
|
|
|
// blurfilter
|
|
//--------------------
|
|
new TimelineMax()
|
|
.to(blurFilter, half, {blur: 6, ease})
|
|
.to(blurFilter, half, {blur: .2, ease});
|
|
}
|
|
|
|
/**
|
|
* Should be called to refresh the layout of the camera.
|
|
*
|
|
* @return {Flippable} A reference to the flippable for chaining.
|
|
*/
|
|
layout() {
|
|
|
|
const front = this.objects.front;
|
|
const back = this.objects.back;
|
|
const shadow = this.objects.shadow;
|
|
const inner = this.objects.inner;
|
|
|
|
inner.position3d.z = -Math.sin(inner.euler.y) * front.texture.baseTexture.width * 2;
|
|
|
|
//this.objects.shadow.euler = this.objects.inner.euler
|
|
shadow.euler.x = -inner.euler.x;
|
|
shadow.euler.y = -inner.euler.y;
|
|
|
|
if (this.frontSideInFront) {
|
|
front.renderable = true;
|
|
back.renderable = false;
|
|
shadow.width = front.width;
|
|
shadow.height = front.height;
|
|
} else {
|
|
front.renderable = false;
|
|
back.renderable = true;
|
|
shadow.width = back.width;
|
|
shadow.height = back.height;
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Toggles the flippable. Switches the sides.
|
|
*
|
|
* @private
|
|
* @return {Flippable} A reference to the flippable for chaining.
|
|
*/
|
|
toggle() {
|
|
this.flipped = !this.flipped;
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Gets the alignment state. true if the front side is in front, false otherwise.
|
|
*
|
|
* @member {boolean}
|
|
*/
|
|
get frontSideInFront() {
|
|
return !this.objects.inner.isFrontFace()
|
|
}
|
|
|
|
/**
|
|
* Calculates the center point of an PIXI.DisplayObject.
|
|
*
|
|
* @private
|
|
* @param {PIXI.DisplayObject} displayObject - The DisplayObject from which to calculate the center.
|
|
* @return {object} Return an object with x and y.
|
|
*/
|
|
anchorToCenter(displayObject) {
|
|
const bounds = displayObject.getBounds();
|
|
return {
|
|
x: bounds.x + bounds.width / 2,
|
|
y: bounds.y + bounds.height / 2
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates children and instantiates everything.
|
|
*
|
|
* @private
|
|
* @param {PIXI.DisplayObject} displayObject - The DisplayObject from which to generate the texture.
|
|
* @return {PIXI.Texture} The generated PIXI.Texture.
|
|
*/
|
|
generateTexture(displayObject) {
|
|
|
|
// renderTexture
|
|
//--------------------
|
|
const renderTexture = PIXI.RenderTexture.create(displayObject.width, displayObject.height);
|
|
|
|
// save position
|
|
const transform = [displayObject.x, displayObject.y, displayObject.scale.x, displayObject.scale.y, displayObject.rotation, displayObject.skew.x, displayObject.skew.y, displayObject.pivot.x, displayObject.pivot.y];
|
|
|
|
displayObject.position.set(0, 0);
|
|
displayObject.skew.set(0, 0);
|
|
displayObject.rotation = 0;
|
|
|
|
// render
|
|
//--------------------
|
|
this.opts.renderer.render(displayObject, renderTexture);
|
|
|
|
// restore position
|
|
displayObject.setTransform(...transform);
|
|
|
|
return renderTexture
|
|
}
|
|
|
|
/**
|
|
* Removed the first DisplayObject and adds the second one at the exactly same position.
|
|
*
|
|
* @private
|
|
* @param {PIXI.DisplayObject} first - The old DisplayObject.
|
|
* @param {PIXI.DisplayObject} second - The new DisplayObject.
|
|
* @return {Flippable} A reference to the flippable for chaining.
|
|
*/
|
|
switchDisplayObject(first, second) {
|
|
if (first && second && first.parent) {
|
|
const parent = first.parent;
|
|
const index = parent.getChildIndex(first);
|
|
parent.addChildAt(second, index);
|
|
parent.removeChild(first);
|
|
}
|
|
|
|
return this
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
class Popover extends PIXI.Graphics {
|
|
|
|
constructor({title = null, text = null, x = 0, y = 0, placement = 'top', width = 250, titleStyle = {}, textStyle = {fontSize: '1.6em'}} = {}) {
|
|
super();
|
|
|
|
this.opts = {title, text, x, y, placement, width, titleStyle, textStyle};
|
|
|
|
this.padding = 12;
|
|
|
|
let style = {
|
|
fontFamily: 'Arial',
|
|
fontSize: '2em',
|
|
stroke: '#f6f6f6',
|
|
strokeThickness: 3,
|
|
wordWrap: true,
|
|
wordWrapWidth: width - (this.padding * 2)
|
|
};
|
|
|
|
this.titleTextStyle = new PIXI.TextStyle(Object.assign({}, style, titleStyle));
|
|
this.textTextStyle = new PIXI.TextStyle(Object.assign({}, style, textStyle));
|
|
|
|
if (title || text) {
|
|
this.setup();
|
|
this.draw();
|
|
this.positioning();
|
|
}
|
|
}
|
|
|
|
setup() {
|
|
this.removeChildren();
|
|
|
|
if (this.opts.title) {
|
|
this.titleText = new PIXI.Text(this.opts.title, this.titleTextStyle);
|
|
this.titleText.position.set(this.padding, this.padding);
|
|
this.addChild(this.titleText);
|
|
}
|
|
|
|
this.titleY = this.titleText ? this.titleText.y : 0;
|
|
this.titleHeight = this.titleText ? this.titleText.height : 0;
|
|
|
|
if (this.opts.text) {
|
|
this.textText = new PIXI.Text(this.opts.text, this.textTextStyle);
|
|
this.textText.position.set(this.padding, this.titleY + this.titleHeight + this.padding);
|
|
this.addChild(this.textText);
|
|
}
|
|
|
|
this.textY = this.textText ? this.textText.y : 0;
|
|
this.textHeight = this.textText ? this.textText.height : 0;
|
|
}
|
|
|
|
close() {
|
|
this.parent.removeChild(this);
|
|
}
|
|
|
|
draw() {
|
|
this.clear();
|
|
this.beginFill(0xffffff, 1);
|
|
this.lineStyle(1, 0x282828, .5);
|
|
|
|
// Draw rounded rectangle
|
|
const height = this.height + this.padding;
|
|
this.drawRoundedRect(0, 0, this.opts.width, height, 8);
|
|
|
|
// Draw anchor
|
|
this.drawAnchor(this.opts.placement);
|
|
|
|
// Draw title background
|
|
if (this.opts.title) {
|
|
this.lineStyle(0);
|
|
this.beginFill(0xf7f7f7, 1);
|
|
let x = 1;
|
|
let y = this.titleText.x + this.titleText.height + (this.padding / 2);
|
|
this.moveTo(x, y);
|
|
y = 9;
|
|
this.lineTo(x, y);
|
|
this.quadraticCurveTo(x, y - 8, x + 8, y - 8);
|
|
x += this.opts.width - 7;
|
|
y -= 8;
|
|
this.lineTo(x, y);
|
|
this.quadraticCurveTo(x + 5, y, x + 5, y + 8);
|
|
x += 5;
|
|
y += this.titleText.x + this.titleText.height + (this.padding / 2);
|
|
this.lineTo(x, y);
|
|
if (this.opts.text) {
|
|
x = 1;
|
|
this.lineTo(x, y);
|
|
} else {
|
|
this.quadraticCurveTo(x, y, x - 5, y + 4);
|
|
x = 6;
|
|
y += 4;
|
|
this.lineTo(x, y);
|
|
this.quadraticCurveTo(x, y, x - 5, y - 4);
|
|
}
|
|
}
|
|
|
|
this.endFill();
|
|
}
|
|
|
|
drawAnchor(placement) {
|
|
|
|
let x = 0;
|
|
let y = 0;
|
|
|
|
switch (placement) {
|
|
case 'bottom':
|
|
if (this.opts.title) {
|
|
this.beginFill(0xf7f7f7, 1);
|
|
}
|
|
x = (this.width / 2) - 10;
|
|
y = 1;
|
|
this.moveTo(x, y);
|
|
x += 10;
|
|
y -= 10;
|
|
this.lineTo(x, y);
|
|
x += 10;
|
|
y += 10;
|
|
this.lineTo(x, y);
|
|
break
|
|
case 'right':
|
|
x = 1;
|
|
y = (this.height / 2) - 10;
|
|
if (this.titleY + this.titleHeight > y) {
|
|
this.beginFill(0xf7f7f7, 1);
|
|
}
|
|
this.moveTo(x, y);
|
|
x -= 10;
|
|
y += 10;
|
|
this.lineTo(x, y);
|
|
x += 10;
|
|
y += 10;
|
|
this.lineTo(x, y);
|
|
break
|
|
case 'left':
|
|
x = this.width - 2;
|
|
y = (this.height / 2) - 10;
|
|
if (this.titleY + this.titleHeight > y) {
|
|
this.beginFill(0xf7f7f7, 1);
|
|
}
|
|
this.moveTo(x, y);
|
|
x += 10;
|
|
y += 10;
|
|
this.lineTo(x, y);
|
|
x -= 10;
|
|
y += 10;
|
|
this.lineTo(x, y);
|
|
break
|
|
default:
|
|
x = (this.width / 2) - 10;
|
|
y = this.height - 2;
|
|
this.moveTo(x, y);
|
|
x += 10;
|
|
y += 10;
|
|
this.lineTo(x, y);
|
|
x += 10;
|
|
y -= 10;
|
|
this.lineTo(x, y);
|
|
break
|
|
}
|
|
}
|
|
|
|
positioning() {
|
|
|
|
const x = this.opts.x;
|
|
const y = this.opts.y;
|
|
|
|
switch (this.opts.placement) {
|
|
case 'bottom':
|
|
this.position.set(x - (this.width / 2), y + 10);
|
|
break
|
|
case 'right':
|
|
this.position.set(x, y - (this.height / 2));
|
|
break
|
|
case 'left':
|
|
this.position.set(x - this.width, y - (this.height / 2));
|
|
break
|
|
default:
|
|
this.position.set(x - (this.width / 2), y - this.height);
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
/** A container for scatter objects, which uses a single InteractionMapper
|
|
* for all children. This reduces the number of registered event handlers
|
|
* and covers the common use case that multiple objects are scattered
|
|
* on the same level.
|
|
*/
|
|
class ScatterContainer extends PIXI.Graphics {
|
|
|
|
/**
|
|
* @constructor
|
|
* @param {PIXI.Renderer} renderer - PIXI renderer, needed for hit testing
|
|
* @param {Bool} stopEvents - Whether events should be stopped or propagated
|
|
* @param {Bool} claimEvents - Whether events should be marked as claimed
|
|
* if findTarget return as non-null value.
|
|
* @param {PIXI.Container} container - A container for the scatter
|
|
* @param {Bool} showBounds - Show bounds for debugging purposes.
|
|
* @param {Bool} showTouches - Show touches and pointer for debugging purposes.
|
|
* @param {Color} backgroundColor - Set background color if specified.
|
|
* @param {PIXIApp} app - Needed if showBounds is true to register
|
|
* update handler.
|
|
*/
|
|
constructor(renderer, {
|
|
stopEvents = true,
|
|
claimEvents = true,
|
|
container = null,
|
|
showBounds = false,
|
|
showPolygon = false,
|
|
showTouches = false,
|
|
backgroundColor = null,
|
|
app = window.app
|
|
} = {}) {
|
|
super();
|
|
this.container = container;
|
|
if (this.container)
|
|
this.containerDimensions = {
|
|
x: this.container.width,
|
|
y: this.container.height
|
|
};
|
|
this.backgroundWidth = null;
|
|
this.backgroundHeight = null;
|
|
this.app = app;
|
|
this.renderer = renderer;
|
|
this.stopEvents = stopEvents;
|
|
this.claimEvents = claimEvents;
|
|
this.delegate = new InteractionMapper$1(this.eventReceiver, this);
|
|
this.showBounds = showBounds;
|
|
this.showTouches = showTouches;
|
|
this.showPolygon = showPolygon;
|
|
this.backgroundColor = backgroundColor;
|
|
if (showBounds || showTouches || showPolygon) {
|
|
//console.log("Show TOUCHES!!!")
|
|
this.app.ticker.add((delta) => this.update(delta), this);
|
|
}
|
|
if (backgroundColor) {
|
|
this.updateBackground();
|
|
}
|
|
}
|
|
|
|
updateBackground() {
|
|
this.clear();
|
|
let rect = this.bounds;
|
|
this.beginFill(this.backgroundColor, 1);
|
|
this.drawRect(0, 0, rect.width, rect.height);
|
|
this.endFill();
|
|
}
|
|
|
|
get eventReceiver() {
|
|
return this.renderer.plugins.interaction.interactionDOMElement
|
|
}
|
|
|
|
get bounds() {
|
|
let x = 0;
|
|
let y = 0;
|
|
// @container: We need to call the constant values, as the container
|
|
// gets resized, when a child moves outside the original boundaries.
|
|
let w = (this.container) ? this.containerDimensions.x : (this.backgroundWidth || this.app.width);
|
|
let h = (this.container) ? this.containerDimensions.y : (this.backgroundHeight || this.app.height);
|
|
|
|
if (this.app.fullscreen && this.app.monkeyPatchMapping) {
|
|
let fixed = this.mapPositionToPoint({ x: w, y: 0 });
|
|
if (fixed.x < w) {
|
|
w = fixed.x;
|
|
}
|
|
if (fixed.y > 0) {
|
|
y += fixed.y;
|
|
h -= fixed.y;
|
|
}
|
|
}
|
|
return new PIXI.Rectangle(x, y, w, h)
|
|
}
|
|
|
|
get center() {
|
|
let r = this.bounds;
|
|
return { x: r.width / 2, y: r.height / 2 }
|
|
}
|
|
|
|
get polygon() {
|
|
let r = this.bounds;
|
|
let w2 = r.width / 2;
|
|
let h2 = r.height / 2;
|
|
let center = { x: w2, y: h2 };
|
|
let polygon = new Polygon(center);
|
|
polygon.addPoint({ x: -w2, y: -h2 });
|
|
polygon.addPoint({ x: w2, y: -h2 });
|
|
polygon.addPoint({ x: w2, y: h2 });
|
|
polygon.addPoint({ x: -w2, y: h2 });
|
|
return polygon
|
|
}
|
|
|
|
update(dt) {
|
|
this.clear();
|
|
this.lineStyle(1, 0x0000FF);
|
|
if (this.showBounds) {
|
|
for (let child of this.children) {
|
|
if (child.scatter) {
|
|
//let {x, y, width, height} = child.scatter.throwBounds()
|
|
// new PIXI.Rectangle(x, y, width, height)
|
|
this.drawShape(child.scatter.bounds);
|
|
let center = child.scatter.center;
|
|
this.drawCircle(center.x, center.y, 4);
|
|
this.drawCircle(child.scatter.x, child.scatter.y, 4);
|
|
}
|
|
}
|
|
this.lineStyle(2, 0x0000FF);
|
|
this.drawShape(this.bounds);
|
|
}
|
|
if (this.showPolygon) {
|
|
this.lineStyle(2, 0xFF0000);
|
|
for (let child of this.children) {
|
|
if (child.scatter) {
|
|
let polygon = child.scatter.polygon;
|
|
let shape = new PIXI.Polygon(polygon.flatAbsolutePoints());
|
|
shape.close();
|
|
this.drawShape(shape);
|
|
}
|
|
}
|
|
}
|
|
if (this.showTouches) {
|
|
let current = this.delegate.interaction.current;
|
|
for (let [key, point] of current.entries()) {
|
|
let local = this.mapPositionToPoint(point);
|
|
this.drawCircle(local.x, local.y, 12);
|
|
}
|
|
}
|
|
}
|
|
|
|
capture(event) {
|
|
if (this.stopEvents)
|
|
Events$1.stop(event);
|
|
return true
|
|
}
|
|
|
|
fakeInteractionEvent(point, key) {
|
|
return { data: { global: point, key: key } }
|
|
}
|
|
|
|
findHitScatter(data, displayObject, hit) {
|
|
// if (hit) {
|
|
// console.log("findHitScatter", displayObject)
|
|
// }
|
|
if (hit && this.hitScatter === null && typeof (displayObject) != undefined) {
|
|
this.hitScatter = (displayObject.scatter) ? displayObject.scatter : null;
|
|
}
|
|
}
|
|
|
|
mapPositionToPoint(point, element = null) {
|
|
// In case of nested scatters we get an additional parameter that
|
|
// contains the found scatter
|
|
let local = new PIXI.Point();
|
|
let interactionManager = this.renderer.plugins.interaction;
|
|
interactionManager.mapPositionToPoint(local, point.x, point.y);
|
|
if (element instanceof DisplayObjectScatter && element.displayObject.parent != null) {
|
|
return element.displayObject.parent.toLocal(local)
|
|
}
|
|
return local
|
|
}
|
|
|
|
/**
|
|
* New method hitTest implemented (in InteractionManager, since 4.5.0).
|
|
* See https://github.com/pixijs/pixi.js/pull/3878
|
|
*/
|
|
findTarget(event, local, global) {
|
|
if (event.claimedByScatter) {
|
|
return null
|
|
}
|
|
this.hitScatter = null;
|
|
let interactionManager = this.renderer.plugins.interaction;
|
|
let fakeEvent = this.fakeInteractionEvent(local);
|
|
interactionManager.processInteractive(fakeEvent,
|
|
this,
|
|
this.findHitScatter.bind(this), true);
|
|
if (this.claimEvents)
|
|
event.claimedByScatter = this.hitScatter;
|
|
return this.hitScatter
|
|
}
|
|
|
|
findTargetNew(event, local, global) {
|
|
// UO: still problematic. Does not find non interactive elements
|
|
// which are needed for some stylus applications
|
|
if (event.claimedByScatter) {
|
|
return null
|
|
}
|
|
this.hitScatter = null;
|
|
let interactionManager = this.renderer.plugins.interaction;
|
|
let displayObject = interactionManager.hitTest(local, this);
|
|
if (displayObject != null && displayObject.scatter != null)
|
|
this.hitScatter = displayObject.scatter;
|
|
if (this.claimEvents)
|
|
event.claimedByScatter = this.hitScatter;
|
|
return this.hitScatter
|
|
}
|
|
|
|
|
|
onStart(event, interaction) {
|
|
|
|
}
|
|
|
|
onMove(event, interaction) {
|
|
|
|
}
|
|
|
|
onEnd(event, interaction) {
|
|
for (let key of interaction.ended.keys()) {
|
|
let point = interaction.ended.get(key);
|
|
if (interaction.isLongPress(key)) {
|
|
this.onLongPress(key, point);
|
|
}
|
|
if (interaction.isTap(key)) {
|
|
this.onTap(key, point);
|
|
}
|
|
}
|
|
}
|
|
|
|
onTap(key, point) {
|
|
console.info('ScatterContainer.onTap');
|
|
}
|
|
|
|
onLongPress(key, point) {
|
|
console.info('ScatterContainer.onLongPress');
|
|
}
|
|
|
|
bringToFront(displayObject) {
|
|
this.addChild(displayObject);
|
|
}
|
|
|
|
layout(width, height) {
|
|
this.backgroundWidth = width;
|
|
this.backgroundHeight = height;
|
|
if (this.backgroundColor) {
|
|
this.updateBackground();
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
/** A wrapper for child elements of a ScatterContainer. Can be used
|
|
* to combine scattered objects with non-scattered objects. Any
|
|
* PIXI.DisplayObject can be wrapped.
|
|
*/
|
|
class DisplayObjectScatter extends AbstractScatter {
|
|
|
|
constructor(displayObject, renderer,
|
|
{ x = null, y = null,
|
|
minScale = 0.1,
|
|
maxScale = 1.0,
|
|
startScale = 1.0,
|
|
autoBringToFront = true,
|
|
translatable = true, scalable = true, rotatable = true, resizable = false,
|
|
movableX = true,
|
|
movableY = true,
|
|
throwVisibility = 44,
|
|
throwDamping = 0.95,
|
|
autoThrow = true,
|
|
rotationDegrees = null,
|
|
rotation = null,
|
|
overdoScaling = 1.5,
|
|
onTransform = null,
|
|
onThrowFinished = null } = {}) {
|
|
// For the simulation of named parameters,
|
|
// see: http://exploringjs.com/es6/ch_parameter-handling.html
|
|
super({
|
|
overdoScaling,
|
|
minScale, maxScale,
|
|
startScale,
|
|
autoBringToFront,
|
|
translatable, scalable, rotatable, resizable,
|
|
movableX, movableY, throwVisibility, throwDamping,
|
|
autoThrow,
|
|
onThrowFinished,
|
|
rotationDegrees, rotation,
|
|
onTransform
|
|
});
|
|
this.displayObject = displayObject;
|
|
this.displayObject.scatter = this;
|
|
this.renderer = renderer;
|
|
this.scale = startScale;
|
|
this.rotationDegrees = this.startRotationDegrees;
|
|
|
|
// Only set x and y if they are specified.
|
|
// Otherwise the displayobject gets corrupted.
|
|
if (x != null) this.x = x;
|
|
if (y != null) this.y = y;
|
|
}
|
|
|
|
getWorldScatter() {
|
|
return this
|
|
}
|
|
|
|
/** Returns geometry data as object. **/
|
|
getState() {
|
|
return {
|
|
scale: this.scale,
|
|
x: this.x,
|
|
y: this.y,
|
|
rotation: this.rotation
|
|
}
|
|
}
|
|
|
|
setup() {
|
|
this.setupMouseWheelInteraction();
|
|
}
|
|
|
|
roundPixel(value) {
|
|
// UO: Should be obsolete because Renderer supports roundPixels by default
|
|
return value
|
|
let res = this.renderer.resolution;
|
|
return Math.round(value * res) / res
|
|
}
|
|
|
|
get container() {
|
|
// return this.displayObject.parent
|
|
let obj = this.displayObject;
|
|
while (obj.parent != null && !(obj.parent instanceof ScatterContainer))
|
|
obj = obj.parent;
|
|
return obj.parent
|
|
}
|
|
|
|
get x() {
|
|
return this.position.x
|
|
}
|
|
|
|
set x(value) {
|
|
this.position.x = value;
|
|
}
|
|
|
|
get y() {
|
|
return this.position.y
|
|
}
|
|
|
|
set y(value) {
|
|
this.position.y = value;
|
|
}
|
|
|
|
get polygon() {
|
|
let polygon = new Polygon(this.center);
|
|
let w2 = this.width / 2;
|
|
let h2 = this.height / 2;
|
|
polygon.addPoint({ x: -w2, y: -h2 });
|
|
polygon.addPoint({ x: w2, y: -h2 });
|
|
polygon.addPoint({ x: w2, y: h2 });
|
|
polygon.addPoint({ x: -w2, y: h2 });
|
|
polygon.rotate(this.rotation);
|
|
return polygon
|
|
}
|
|
|
|
get containerBounds() {
|
|
return this.container.bounds
|
|
}
|
|
|
|
get containerPolygon() {
|
|
let container = this.container;
|
|
if (container == null) return null
|
|
return container.polygon
|
|
}
|
|
|
|
get position() {
|
|
return this.displayObject.position
|
|
}
|
|
|
|
set position(value) {
|
|
this.displayObject.position = value;
|
|
}
|
|
|
|
get scale() {
|
|
return this.displayObject.scale.x
|
|
}
|
|
|
|
set scale(value) {
|
|
this.displayObject.scale.x = value;
|
|
this.displayObject.scale.y = value;
|
|
}
|
|
|
|
get width() {
|
|
return this.displayObject.width
|
|
}
|
|
|
|
get height() {
|
|
return this.displayObject.height
|
|
}
|
|
|
|
get bounds() {
|
|
return this.displayObject.getBounds()
|
|
}
|
|
|
|
get pivot() {
|
|
return this.displayObject.pivot
|
|
}
|
|
|
|
get rotation() {
|
|
return this.displayObject.rotation
|
|
}
|
|
|
|
set rotation(value) {
|
|
this.displayObject.rotation = value;
|
|
}
|
|
|
|
get rotationDegrees() {
|
|
return Angle.radian2degree(this.displayObject.rotation)
|
|
}
|
|
|
|
set rotationDegrees(value) {
|
|
this.displayObject.rotation = Angle.degree2radian(value);
|
|
}
|
|
|
|
get center() {
|
|
let w2 = this.width / 2;
|
|
let h2 = this.height / 2;
|
|
let dist = Math.sqrt(w2 * w2 + h2 * h2);
|
|
let angle = Points.angle({ x: w2, y: h2 }, { x: 0, y: 0 });
|
|
let p = this.displayObject.x;
|
|
let c = Points.arc(this.position, this.rotation + angle, dist);
|
|
return c // Points.subtract(c, this.pivot)
|
|
}
|
|
|
|
get rotationOrigin() {
|
|
// In PIXI the default rotation and scale origin is the position
|
|
return this.position // Points.add(this.position, this.pivot)
|
|
}
|
|
|
|
mapPositionToContainerPoint(point) {
|
|
// UO: We need the coordinates related to this scatter in case
|
|
// of nested scatters
|
|
if (this.container != null)
|
|
return this.container.mapPositionToPoint(point, this)
|
|
return point
|
|
}
|
|
|
|
capture(event) {
|
|
return true
|
|
}
|
|
|
|
bringToFront() {
|
|
if (this.autoBringToFront) {
|
|
if (this.displayObject.parent instanceof ScatterContainer) {
|
|
let scatterContainer = this.displayObject.parent;
|
|
scatterContainer.bringToFront(this.displayObject);
|
|
} else if (this.displayObject.parent != null && this.displayObject.parent.scatter) {
|
|
this.displayObject.parent.scatter.toFront(this.displayObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
toFront(displayObject) {
|
|
this.displayObject.addChild(displayObject);
|
|
}
|
|
|
|
validScale(scale) {
|
|
scale = Math.max(scale, this.minScale);
|
|
scale = Math.min(scale, this.maxScale);
|
|
return scale
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
class Command extends PIXI.Graphics {
|
|
/*** Abstract base class for record, play, and stop commands. ***/
|
|
constructor(tools, selectedColor, shape) {
|
|
super();
|
|
this.tools = tools;
|
|
this.shape = shape;
|
|
this.selected = false;
|
|
this.disabled = false;
|
|
this.selectedColor = selectedColor;
|
|
this.draw();
|
|
this.setup();
|
|
}
|
|
|
|
setup() {
|
|
}
|
|
|
|
draw() {
|
|
this.clear();
|
|
var color = (this.selected) ? this.selectedColor : 0xFFFFFF;
|
|
this.lineStyle(0);
|
|
this.beginFill(color, 1);
|
|
this.drawShape(this.shape);
|
|
this.endFill();
|
|
}
|
|
|
|
select() {
|
|
this.selected = true;
|
|
this.draw();
|
|
}
|
|
|
|
deselect() {
|
|
this.selected = false;
|
|
this.draw();
|
|
}
|
|
|
|
toggle() {
|
|
this.selected = !this.selected;
|
|
this.draw();
|
|
}
|
|
|
|
stop() {
|
|
this.selected = false;
|
|
this.draw();
|
|
}
|
|
}
|
|
|
|
class RecordCommand extends Command {
|
|
/*** Records events for later replay. ***/
|
|
setup() {
|
|
this.recorder = new EventRecorder();
|
|
}
|
|
|
|
toggle() {
|
|
super.toggle();
|
|
if (!this.selected) {
|
|
this.recorder.stopRecording();
|
|
}
|
|
}
|
|
|
|
recordEvent(event) {
|
|
this.recorder.record(event);
|
|
}
|
|
|
|
normalize(value, limit) {
|
|
return value / limit
|
|
}
|
|
|
|
normalizeX(value) {
|
|
return this.normalize(value, window.innerWidth)
|
|
}
|
|
|
|
normalizeY(value) {
|
|
return this.normalize(value, window.innerHeight)
|
|
}
|
|
|
|
whileNotStopped() {
|
|
return this.tools.play.selected
|
|
}
|
|
|
|
startReplay() {
|
|
let whileCondition = this.whileNotStopped.bind(this);
|
|
this.recorder.startReplay(whileCondition, () => this.tools.play.stop());
|
|
}
|
|
}
|
|
|
|
class PlayCommand extends Command {
|
|
/*** Plays recorded events. ***/
|
|
toggle() {
|
|
super.toggle();
|
|
if (this.selected && this.tools.record.recorder.recorded.length > 0) {
|
|
this.tools.startReplay();
|
|
}
|
|
}
|
|
}
|
|
|
|
class StopCommand extends Command {
|
|
/*** Stops recording and playing. ***/
|
|
toggle() {
|
|
super.toggle();
|
|
this.tools.record.stop();
|
|
this.tools.play.stop();
|
|
setTimeout(this.deselect.bind(this), 500);
|
|
}
|
|
}
|
|
|
|
class RecorderTools extends PIXI.Container {
|
|
|
|
constructor(renderer) {
|
|
super(renderer);
|
|
this.renderer = renderer;
|
|
this.setupToolbar();
|
|
this.replayRate = 100.0;
|
|
this.onReset = null;
|
|
this.touchGraphics = new PIXI.Graphics();
|
|
this.showTouches();
|
|
}
|
|
|
|
setup(container) {
|
|
// Since this delegate might shadow another delegate, we mus avoid
|
|
// capturing PointerEvents.
|
|
this.delegate = new InteractionMapper(container, this, { capturePointerEvents: false });
|
|
}
|
|
|
|
findTarget(event, local, global) {
|
|
return this
|
|
}
|
|
|
|
setupToolbar() {
|
|
this.toolbar = new PIXI.Graphics();
|
|
this.record = new RecordCommand(this, 0xCC0000, new PIXI.Circle(0, 0, 16));
|
|
this.play = new PlayCommand(this, 0x0000CC, new PIXI.Polygon(0, 16,
|
|
32, 16 + 16,
|
|
0, 16 + 32,
|
|
0, 16));
|
|
this.stop = new StopCommand(this, 0x0000CC,
|
|
new PIXI.Rectangle(0, 0, 32, 32));
|
|
this.toolbar.addChild(this.record).position.set(44, 48);
|
|
this.toolbar.addChild(this.play).position.set(44 + 44, 16);
|
|
this.toolbar.addChild(this.stop).position.set(44 + 44 + 44 + 16, 32);
|
|
this.updateToolbar();
|
|
this.addChild(this.toolbar);
|
|
}
|
|
|
|
updateToolbar() {
|
|
var graphics = this.toolbar;
|
|
graphics.clear();
|
|
graphics.beginFill(0x000000, 0.5);
|
|
graphics.lineStyle(2, 0xFFFFFF, 1);
|
|
graphics.drawRoundedRect(16, 16, 44 * 4 + 8, 64, 8);
|
|
graphics.endFill();
|
|
}
|
|
|
|
onMouseWheel(event) {
|
|
console.log('onMouseWheel missing');
|
|
}
|
|
|
|
onPress(point) {
|
|
if (this.record.containsPoint(point)) {
|
|
this.record.toggle();
|
|
}
|
|
if (this.play.containsPoint(point)) {
|
|
this.play.toggle();
|
|
}
|
|
if (this.stop.containsPoint(point)) {
|
|
this.stop.toggle();
|
|
if (this.onReset) {
|
|
this.onReset();
|
|
}
|
|
}
|
|
}
|
|
|
|
mapPositionToPoint(point) {
|
|
let local = new PIXI.Point();
|
|
this.renderer.plugins.interaction.mapPositionToPoint(local, point.x, point.y);
|
|
return local
|
|
}
|
|
|
|
extractLocal(event) {
|
|
return this.mapPositionToPoint(Events.extractPoint(event))
|
|
}
|
|
|
|
capture(event) {
|
|
if (typeof event.mouseDownSubstitute != 'undefined')
|
|
return false
|
|
return true
|
|
}
|
|
|
|
startReplay() {
|
|
if (this.onReset) {
|
|
this.onReset();
|
|
}
|
|
this.record.startReplay();
|
|
}
|
|
|
|
showTouches() {
|
|
this.addChild(this.touchGraphics);
|
|
}
|
|
|
|
recordEvent(event) {
|
|
if (this.record.selected) {
|
|
this.record.recordEvent(event);
|
|
}
|
|
}
|
|
|
|
onStart(event, interaction) {
|
|
let local = this.extractLocal(event);
|
|
if (!this.toolbar.containsPoint(local)) {
|
|
this.recordEvent(event);
|
|
this.updateTouchGraphics(interaction);
|
|
}
|
|
}
|
|
|
|
onMove(event, interaction) {
|
|
let local = this.extractLocal(event);
|
|
if (!this.toolbar.containsPoint(local)) {
|
|
this.recordEvent(event);
|
|
this.updateTouchGraphics(interaction);
|
|
}
|
|
}
|
|
|
|
onEnd(event, interaction) {
|
|
let local = this.extractLocal(event);
|
|
if (this.toolbar.containsPoint(local)) {
|
|
this.onPress(local);
|
|
}
|
|
else {
|
|
this.recordEvent(event);
|
|
this.updateTouchGraphics(interaction);
|
|
}
|
|
}
|
|
|
|
updateTouchGraphics(interaction) {
|
|
let current = interaction.current;
|
|
let graphics = this.touchGraphics;
|
|
if (graphics != null) {
|
|
graphics.clear();
|
|
for (let key of current.keys()) {
|
|
if (interaction.ended.has(key)) {
|
|
continue
|
|
}
|
|
let p = current.get(key);
|
|
if (key == 'mouse') {
|
|
graphics.beginFill(0xCC0000, 0.5);
|
|
} else {
|
|
graphics.beginFill(0xCCCCCC, 0.5);
|
|
}
|
|
graphics.drawCircle(p.x, p.y, 20);
|
|
}
|
|
graphics.endFill();
|
|
}
|
|
}
|
|
}
|
|
|
|
class AppTest extends PIXIApp {
|
|
|
|
constructor(canvas, container) {
|
|
super({ view: canvas, backgroundColor: 0x000000 });
|
|
this.container = container;
|
|
}
|
|
|
|
sceneFactory() {
|
|
return new RecorderTools(this.renderer)
|
|
}
|
|
|
|
setup() {
|
|
super.setup();
|
|
this.scene.setup(this.container);
|
|
}
|
|
|
|
run(reset = null) {
|
|
this.scene.onReset = reset;
|
|
console.log('Running AppTest');
|
|
return this
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Defines usefull default text styles.
|
|
*/
|
|
class FontInfo {
|
|
|
|
static get small() {
|
|
return app.theme.textStyleSmall
|
|
}
|
|
|
|
static get normal() {
|
|
return app.theme.textStyle
|
|
}
|
|
|
|
static get centered() {
|
|
return Object.assign({}, app.theme.textStyle, { align: 'center' })
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Static methods to support hyphenation of lines.
|
|
*
|
|
* @class Hypenate
|
|
*/
|
|
class Hypenate {
|
|
|
|
static splitPart(part) {
|
|
let parts = part.split('-');
|
|
if (parts.length == 1)
|
|
return [part]
|
|
let result = [];
|
|
let last = parts.pop();
|
|
for (let p of parts) {
|
|
result.push(p + '-');
|
|
}
|
|
result.push(last);
|
|
return result.filter(p => p.length > 0)
|
|
}
|
|
|
|
static splitWord(word) {
|
|
if (typeof (language) == 'undefined') {
|
|
if (word.indexOf('-') > -1) {
|
|
return word.split('-')
|
|
}
|
|
return [word]
|
|
}
|
|
let parts = language.hyphenate(word);
|
|
let result = [];
|
|
for (let part of parts) {
|
|
for (let splitted of this.splitPart(part)) {
|
|
result.push(splitted);
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
static abbreviateLine(label, style, width) {
|
|
const pixiStyle = new PIXI.TextStyle(style);
|
|
let metrics = PIXI.TextMetrics.measureText(label, pixiStyle);
|
|
while(metrics.width > width && label.length > 3) {
|
|
label = label.slice(0, label.length-1);
|
|
metrics = PIXI.TextMetrics.measureText(label, pixiStyle);
|
|
}
|
|
label = label.slice(0, label.length-1);
|
|
return label + '…'
|
|
}
|
|
|
|
static splitLine(line, pixiStyle, width, space, minus) {
|
|
let x = 0;
|
|
let result = '';
|
|
let words = line.split(' ');
|
|
for (let word of words) {
|
|
let wordMetrics = PIXI.TextMetrics.measureText(word, pixiStyle);
|
|
if (x + wordMetrics.width >= width) {
|
|
let parts = this.splitWord(word);
|
|
let newWord = '';
|
|
if (parts.length == 1) {
|
|
newWord += '\n' + word + ' ';
|
|
x = wordMetrics.width + space.width;
|
|
}
|
|
else {
|
|
let first = true;
|
|
let lastPart = '';
|
|
for (let part of parts) {
|
|
let partMetrics = PIXI.TextMetrics.measureText(part, pixiStyle);
|
|
if (x + partMetrics.width + space.width > width) {
|
|
newWord += ((first || lastPart.endsWith('-')) ? '\n' : '-\n') + part;
|
|
x = partMetrics.width;
|
|
}
|
|
else {
|
|
newWord += part;
|
|
x += partMetrics.width;
|
|
}
|
|
lastPart = part;
|
|
first = false;
|
|
}
|
|
x += space.width;
|
|
}
|
|
result += newWord + ' ';
|
|
}
|
|
else {
|
|
result += word + ' ';
|
|
x += wordMetrics.width + space.width;
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Main method and entry point for text hyphenation
|
|
*
|
|
* @static
|
|
* @param {*} text
|
|
* @param {*} style
|
|
* @param {*} width
|
|
* @returns
|
|
* @memberof Hypenate
|
|
*/
|
|
static splitLines(text, style, width) {
|
|
const pixiStyle = new PIXI.TextStyle(style);
|
|
const lines = text.split('\n');
|
|
const space = PIXI.TextMetrics.measureText(' ', pixiStyle);
|
|
const minus = PIXI.TextMetrics.measureText('-', pixiStyle);
|
|
let result = [];
|
|
for (let line of lines) {
|
|
result.push(this.splitLine(line, pixiStyle, width, space, minus));
|
|
}
|
|
return result.join('\n')
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A specialization of the PIXI.Graphics class that allows to
|
|
* resuse and place labels across different layout variants
|
|
*
|
|
* @export
|
|
* @class LabeledGraphics
|
|
* @extends {PIXI.Graphics}
|
|
*/
|
|
class LabeledGraphics extends PIXI.Graphics {
|
|
|
|
/**
|
|
* Creates an instance of LabeledGraphics and defines a local label cache.
|
|
*
|
|
* @memberof LabeledGraphics
|
|
*/
|
|
constructor() {
|
|
super();
|
|
this.labels = new Map();
|
|
}
|
|
|
|
_createText(label, fontInfo) {
|
|
return new PIXI.Text(label, fontInfo)
|
|
}
|
|
|
|
|
|
/**
|
|
* Main additional method. Ensures that a text object is created that is cached
|
|
* under the given key.
|
|
*
|
|
* @param {*} key - The cache key
|
|
* @param {*} label - The label to show
|
|
* @param {*} [attrs={}] - Defines attributes of the text object.
|
|
* align: 'right', 'left', or 'center'
|
|
* justify: 'top', 'bottom', or 'center'
|
|
* maxLines: {integer} truncates the text and adds ellipsis
|
|
* maxHeight: {number} truncates text that needs more space and adds ellipsis
|
|
* maxWidth: {number} word wraps text using hyphenation if possible
|
|
* @param {*} [fontInfo=FontInfo.normal] - Defines PIXI.TextStyle attributes
|
|
* @returns {PIXI.Text} instance
|
|
* @memberof LabeledGraphics
|
|
*/
|
|
ensureLabel(key, label, attrs = {}, fontInfo = FontInfo.normal) {
|
|
|
|
if (attrs.maxWidth && attrs.maxLines == 1) {
|
|
label = Hypenate.abbreviateLine(label, fontInfo, attrs.maxWidth);
|
|
}
|
|
else {
|
|
if (attrs.maxWidth) {
|
|
label = Hypenate.splitLines(label, fontInfo, attrs.maxWidth);
|
|
}
|
|
if (attrs.maxLines) {
|
|
label = this.truncateLabel(label, fontInfo, attrs.maxLines);
|
|
}
|
|
if (attrs.maxHeight) {
|
|
let styleInfo = new PIXI.TextStyle(fontInfo);
|
|
let metrics = PIXI.TextMetrics.measureText(label, styleInfo);
|
|
let maxLines = Math.max(attrs.maxHeight / metrics.lineHeight, 1);
|
|
label = this.truncateLabel(label, fontInfo, maxLines);
|
|
}
|
|
}
|
|
|
|
if (!this.labels.has(key)) {
|
|
let text = this._createText(label, fontInfo);
|
|
this.labels.set(key, text);
|
|
this.addChild(text);
|
|
}
|
|
let text = this.labels.get(key);
|
|
for (let k in attrs) {
|
|
text[k] = attrs[k];
|
|
}
|
|
if (label != text.text)
|
|
text.text = label;
|
|
// We do not follow the flexbox jargon and use align for x and justify for y axis
|
|
// This deviation is needed to ensure backward compatability
|
|
switch (attrs.justify || null) {
|
|
case 'top':
|
|
text.anchor.y = 0;
|
|
break
|
|
case 'bottom':
|
|
text.anchor.x = 1;
|
|
break
|
|
default:
|
|
text.anchor.y = 0.5;
|
|
break
|
|
}
|
|
switch (attrs.align) {
|
|
case 'right':
|
|
text.anchor.x = 1;
|
|
break
|
|
case 'center':
|
|
text.anchor.x = 0.5;
|
|
break
|
|
default:
|
|
text.anchor.x = 0;
|
|
break
|
|
}
|
|
text.visible = true;
|
|
return text
|
|
}
|
|
|
|
/**
|
|
* Private method that truncates the text and adds an ellipsis if there are more lines
|
|
* than wanted
|
|
*
|
|
* @param {*} text
|
|
* @param {*} style
|
|
* @param {*} [maxLines=Infinity]
|
|
* @returns
|
|
* @memberof LabeledGraphics
|
|
*/
|
|
truncateLabel(text, style, maxLines = Infinity) {
|
|
if (maxLines === Infinity) {
|
|
return text
|
|
}
|
|
const { wordWrapWidth } = style;
|
|
const pixiStyle = new PIXI.TextStyle(style);
|
|
const { lines } = PIXI.TextMetrics.measureText(text, pixiStyle);
|
|
let newText = text;
|
|
if (lines.length > maxLines) {
|
|
const truncatedLines = lines.slice(0, maxLines);
|
|
const lastLine = truncatedLines[truncatedLines.length - 1];
|
|
const words = lastLine.split(' ');
|
|
const wordMetrics = PIXI.TextMetrics.measureText(`\u00A0\n...\n${words.join('\n')}`, pixiStyle);
|
|
const [spaceLength, dotsLength, ...wordLengths] = wordMetrics.lineWidths;
|
|
const { text: newLastLine } = wordLengths.reduce((data, wordLength, i) => {
|
|
if (data.length + wordLength + spaceLength >= wordWrapWidth) {
|
|
return { ...data, length: wordWrapWidth }
|
|
}
|
|
return {
|
|
text: `${data.text}${i > 0 ? ' ' : ''}${words[i]}`,
|
|
length: data.length + wordLength + spaceLength,
|
|
};
|
|
}, { text: '', length: dotsLength });
|
|
truncatedLines[truncatedLines.length - 1] = `${newLastLine}...`;
|
|
newText = truncatedLines.join('\n');
|
|
}
|
|
return newText
|
|
}
|
|
|
|
/**
|
|
* Returns the label for the given key.
|
|
*
|
|
* @param {*} key
|
|
* @returns
|
|
* @memberof LabeledGraphics
|
|
*/
|
|
getLabel(key) {
|
|
return this.labels.get(key)
|
|
}
|
|
|
|
/**
|
|
* Hides the label with the given key.
|
|
* @param {*} key
|
|
* @memberof LabeledGraphics
|
|
*/
|
|
hideLabel(key) {
|
|
let label = this.labels.get(key);
|
|
if (label) {
|
|
label.visible = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes the label with the given key.
|
|
* @param {*} key
|
|
* @memberof LabeledGraphics
|
|
*/
|
|
removeLabel(key) {
|
|
let label = this.labels.get(key);
|
|
this.labels.delete(key);
|
|
label.destroy();
|
|
}
|
|
|
|
|
|
/**
|
|
* Ensures that labels are hidden on clear.
|
|
*
|
|
* @memberof LabeledGraphics
|
|
*/
|
|
clear() {
|
|
super.clear();
|
|
for (let key of this.labels.keys()) {
|
|
this.hideLabel(key);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Logs debugging infos
|
|
*
|
|
* @memberof LabeledGraphics
|
|
*/
|
|
debugInfos() {
|
|
console.log({ size: this.labels.size, labels: this.labels });
|
|
}
|
|
}
|
|
|
|
|
|
const labelCache = new Map();
|
|
|
|
function getTexture(label, fontInfo = FontInfo.normal) {
|
|
let key = label + fontInfo.fontFamily + fontInfo.fontSize;
|
|
|
|
if (labelCache.has(key)) {
|
|
return labelCache.get(key)
|
|
}
|
|
let expandedFont = Object.assign({}, fontInfo);
|
|
expandedFont.fontSize *= window.devicePixelRatio;
|
|
let text = new PIXI.Text(label, expandedFont);
|
|
text.updateText();
|
|
labelCache.set(key, text.texture);
|
|
return text.texture
|
|
}
|
|
|
|
class SpriteLabel extends PIXI.Sprite {
|
|
|
|
constructor(label, fontInfo) {
|
|
let texture = getTexture(label, fontInfo);
|
|
super(texture);
|
|
this.label = label;
|
|
this.fontInfo = fontInfo;
|
|
this.scale.set(0.8 / window.devicePixelRatio);
|
|
}
|
|
|
|
set text(label) {
|
|
this.label = label;
|
|
this.texture = getTexture(label, this.fontInfo);
|
|
}
|
|
|
|
get text() {
|
|
return this.label
|
|
}
|
|
}
|
|
|
|
class BitmapLabeledGraphics extends LabeledGraphics {
|
|
|
|
_createText(label, fontInfo) {
|
|
let texture = getTexture(label, fontInfo);
|
|
return new SpriteLabel(texture)
|
|
}
|
|
|
|
}
|
|
|
|
class Ticks {
|
|
|
|
get reservedPrefixes() {
|
|
return ['decade', 'year', 'month', 'day', 'hour', 'minute', 'second']
|
|
}
|
|
|
|
get minWidth() {
|
|
return 10
|
|
}
|
|
|
|
format(available) {
|
|
return { year: '2-digit', timeZone: 'UTC' }
|
|
}
|
|
|
|
get minLabelWidth() {
|
|
return 44
|
|
}
|
|
|
|
get formatKey() {
|
|
return this.key
|
|
}
|
|
|
|
dateKey(date) {
|
|
return this.key + date.getFullYear()
|
|
}
|
|
|
|
*iter(start, end) {
|
|
let date = this.iterStart(start);
|
|
while (date <= end) {
|
|
yield date;
|
|
date = this.next(date);
|
|
}
|
|
yield date;
|
|
}
|
|
|
|
*iterRanges(range) {
|
|
for (let date of this.iter(range.start, range.end)) {
|
|
let next = this.next(date);
|
|
yield { start: date, end: next };
|
|
}
|
|
}
|
|
|
|
selectedRange(timeline, info) {
|
|
let first = null;
|
|
let last = null;
|
|
let visibleFirst = null;
|
|
let visibleLast = null;
|
|
let units = 0;
|
|
for (let { start, end } of this.iterRanges(info)) {
|
|
if (timeline.visibleRange(start, end)) {
|
|
if (first == null) {
|
|
first = start;
|
|
}
|
|
last = end;
|
|
}
|
|
if (timeline.visibleDate(start) && timeline.visibleDate(end)) {
|
|
units += 1;
|
|
if (visibleFirst == null) {
|
|
visibleFirst = start;
|
|
}
|
|
visibleLast = end;
|
|
}
|
|
}
|
|
if (first == null)
|
|
return info
|
|
return { start: first, end: last, visibleStart: visibleFirst, visibleEnd: visibleLast, units: units }
|
|
}
|
|
|
|
drawTick(timeline, x, y, date) {
|
|
let visible = date > timeline.start && date < timeline.end;
|
|
if (!visible)
|
|
return false
|
|
timeline.drawTick(x);
|
|
return true
|
|
}
|
|
|
|
toLocaleString(date, format) {
|
|
return date.toLocaleDateString('de', format)
|
|
}
|
|
|
|
draw(timeline, range, width, height, available, format, nextFormat, level) {
|
|
let first = null;
|
|
let last = null;
|
|
let keyedFormat = (format) ? format[this.formatKey] : null;
|
|
let keyedNextFormat = (nextFormat) ? nextFormat[this.formatKey] : null;
|
|
let redundant = (nextFormat) ? this.formatKey in nextFormat : false;
|
|
let fullyRedundant = keyedFormat != null && keyedFormat == keyedNextFormat;
|
|
let y = timeline.getY();
|
|
|
|
for (let { start, end } of this.iterRanges(range)) {
|
|
let x = timeline.toX(start);
|
|
let xx = x;
|
|
let yy = y + timeline.tickLabelOffset(-1);
|
|
if (this.drawTick(timeline, x, y, start) && format) {
|
|
let key = this.dateKey(start);
|
|
let text = this.toLocaleString(start, format);
|
|
let align = 'center';
|
|
let downTick = false;
|
|
if (nextFormat) {
|
|
yy = y + timeline.tickLabelOffset(-1, 1);
|
|
align = 'left';
|
|
timeline.drawTick(x, 4.2);
|
|
let nextX = timeline.toX(end) - 100;
|
|
if (x < 0 && nextX > -100 && !redundant) {
|
|
xx = Math.min(4, nextX);
|
|
}
|
|
else {
|
|
xx -= 2;
|
|
}
|
|
downTick = true;
|
|
}
|
|
else if (level > 0) {
|
|
xx = x + available / 2;
|
|
}
|
|
else {
|
|
downTick = true;
|
|
}
|
|
if (!fullyRedundant) {
|
|
timeline.ensureLabel(key, text,
|
|
{ x: xx, y: yy, align },
|
|
FontInfo.small);
|
|
}
|
|
if (downTick) timeline.drawTick(x, -1);
|
|
}
|
|
if (timeline.visibleRange(start, end)) {
|
|
if (first == null)
|
|
first = start;
|
|
last = end;
|
|
}
|
|
}
|
|
if (first == null)
|
|
return null
|
|
return { start: first, end: last }
|
|
}
|
|
}
|
|
|
|
class DecadeTicks extends Ticks {
|
|
|
|
get milliseconds() {
|
|
return 10 * 365 * 24 * 60 * 60 * 1000
|
|
}
|
|
|
|
format(available) {
|
|
return { year: 'numeric', timeZone: 'UTC' }
|
|
}
|
|
|
|
selection(timeline, dates, selected) {
|
|
return dates
|
|
}
|
|
|
|
get key() {
|
|
return 'decade'
|
|
}
|
|
|
|
get formatKey() {
|
|
return 'year'
|
|
}
|
|
|
|
iterStart(start) {
|
|
let modulo = start.getFullYear() % 10;
|
|
let year = start.getFullYear() - modulo;
|
|
return Dates.create(year, 0, 1)
|
|
}
|
|
|
|
next(decade) {
|
|
return Dates.nextYear(decade, 10)
|
|
}
|
|
}
|
|
|
|
class YearTicks extends Ticks {
|
|
|
|
get milliseconds() {
|
|
return 365 * 24 * 60 * 60 * 1000
|
|
}
|
|
|
|
format(available) {
|
|
if (available < 44)
|
|
return { year: '2-digit', timeZone: 'UTC' }
|
|
return { year: 'numeric', timeZone: 'UTC' }
|
|
}
|
|
|
|
get minLabelWidth() {
|
|
return 22
|
|
}
|
|
|
|
get key() {
|
|
return 'year'
|
|
}
|
|
|
|
iterStart(start) {
|
|
return Dates.create(start.getFullYear(), 0, 1)
|
|
}
|
|
|
|
next(year) {
|
|
return Dates.nextYear(year)
|
|
}
|
|
}
|
|
|
|
class MonthTicks extends Ticks {
|
|
|
|
get milliseconds() {
|
|
return (365 / 12) * 24 * 60 * 60 * 1000
|
|
}
|
|
|
|
format(available) {
|
|
let format = { month: 'narrow', timeZone: 'UTC' };
|
|
if (available > 44)
|
|
format.month = 'short';
|
|
if (available > 66)
|
|
format.year = '2-digit';
|
|
if (available > 100) {
|
|
format.month = 'long';
|
|
format.year = 'numeric';
|
|
}
|
|
return format
|
|
}
|
|
|
|
get minLabelWidth() {
|
|
return 32
|
|
}
|
|
|
|
get key() {
|
|
return 'month'
|
|
}
|
|
|
|
dateKey(date) {
|
|
return this.key + date.getFullYear() + date.getMonth()
|
|
}
|
|
|
|
iterStart(start) {
|
|
return Dates.create(start.getFullYear(), start.getMonth(), 1)
|
|
}
|
|
|
|
next(month) {
|
|
return Dates.nextMonth(month)
|
|
}
|
|
}
|
|
|
|
class DayTicks extends Ticks {
|
|
|
|
get milliseconds() {
|
|
return 24 * 60 * 60 * 1000
|
|
}
|
|
|
|
format(available) {
|
|
let format = { day: 'numeric', timeZone: 'UTC' };
|
|
if (available > 44)
|
|
format.month = 'short';
|
|
if (available > 100) {
|
|
format.month = 'long';
|
|
format.year = '2-digit';
|
|
}
|
|
if (available > 150) {
|
|
format.weekday = 'short';
|
|
}
|
|
if (available > 200) {
|
|
format.year = 'numeric';
|
|
format.weekday = 'long';
|
|
}
|
|
return format
|
|
}
|
|
|
|
get key() {
|
|
return 'day'
|
|
}
|
|
|
|
dateKey(date) {
|
|
return this.key + date.getFullYear() + date.getMonth() + date.getDate()
|
|
}
|
|
|
|
iterStart(start) {
|
|
return Dates.create(start.getFullYear(), start.getMonth(), start.getDate())
|
|
}
|
|
|
|
next(date) {
|
|
return Dates.nextDay(date)
|
|
}
|
|
}
|
|
|
|
class TimeTicks {
|
|
|
|
constructor(...ticks) {
|
|
this.ticks = ticks;
|
|
}
|
|
|
|
selectedRange(timeline) {
|
|
let info = { start: timeline.start, end: timeline.end, units: 0 };
|
|
for (let ticks of this.ticks) {
|
|
info = ticks.selectedRange(timeline, info);
|
|
if (info.units > 1) {
|
|
timeline.selection = [info.visibleStart, info.visibleEnd];
|
|
return
|
|
}
|
|
}
|
|
timeline.selection = [info.start, info.end];
|
|
}
|
|
|
|
draw(timeline, width, height) {
|
|
let range = timeline;
|
|
let start = timeline.toX(range.start);
|
|
let end = timeline.toX(range.end);
|
|
let size = end - start;
|
|
let duration = timeline.end - timeline.start;
|
|
let formats = new Map();
|
|
let nextFormats = new Map();
|
|
let availables = new Map();
|
|
let previous = null;
|
|
let visible = [];
|
|
for (let ticks of this.ticks) {
|
|
let amount = ticks.milliseconds / duration;
|
|
let available = amount * size;
|
|
availables.set(ticks, available);
|
|
if (available < ticks.minWidth)
|
|
break
|
|
formats.set(ticks, (available < ticks.minLabelWidth) ? null : ticks.format(available));
|
|
nextFormats.set(previous, formats.get(ticks));
|
|
previous = ticks;
|
|
visible.push(ticks);
|
|
}
|
|
let level = 0;
|
|
for (let ticks of visible) {
|
|
if (range == null)
|
|
return
|
|
range = ticks.draw(timeline, range, width, height,
|
|
availables.get(ticks),
|
|
formats.get(ticks),
|
|
nextFormats.get(ticks), level);
|
|
level += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
class ColorRanges {
|
|
|
|
constructor(label, color, ranges) {
|
|
this.label = label;
|
|
this.color = color;
|
|
this.ranges = ranges;
|
|
}
|
|
|
|
draw(timeline, width, height, size = 12) {
|
|
let minimum = 1 / Capabilities.devicePixelRatio;
|
|
let h2 = size;
|
|
timeline.lineStyle(size, this.color);
|
|
for (let range of this.ranges) {
|
|
if (range.to === null) {
|
|
range.to = Dates.nextDay(range.from);
|
|
}
|
|
let start = timeline.toX(range.from);
|
|
let end = timeline.toX(range.to);
|
|
if (end < start + minimum) {
|
|
end = start + minimum;
|
|
}
|
|
timeline.moveTo(start, h2);
|
|
timeline.lineTo(end, h2);
|
|
}
|
|
}
|
|
}
|
|
|
|
class Timeline extends BitmapLabeledGraphics {
|
|
|
|
constructor(width, height, { ticks = null,
|
|
baseLine = 0.5, showRange = true } = {}) {
|
|
super();
|
|
this.wantedWidth = width;
|
|
this.wantedHeight = height;
|
|
this.extraLeft = 0;
|
|
this.extraRight = 0;
|
|
this.inset = 5;
|
|
this.showRange = showRange;
|
|
this.baseLine = baseLine;
|
|
this.tickHeight = 4;
|
|
this.zoom = 1;
|
|
this.minZoom = 1;
|
|
this.maxZoom = 12000;
|
|
this.scroll = 0;
|
|
this.deltas = [];
|
|
this.labelDates = [];
|
|
this.colorRanges = [];
|
|
this.rangeColors = new Cycle(Colors.eminence,
|
|
Colors.steelblue,
|
|
Colors.ochre,
|
|
Colors.turquoise);
|
|
this.callbacks = [];
|
|
this.onTapCallbacks = [];
|
|
this.onDoubleTapCallbacks = [];
|
|
this.onLongPressCallbacks = [];
|
|
this.progress = null;
|
|
this.start = null;
|
|
this.end = null;
|
|
this.selection = null;
|
|
this.autoScroll = false;
|
|
this.direction = -1;
|
|
this.timeticks = ticks || new TimeTicks(new DecadeTicks(),
|
|
new YearTicks(),
|
|
new MonthTicks(),
|
|
new DayTicks());
|
|
this.labelPrefix = '__';
|
|
}
|
|
|
|
updateSelection() {
|
|
if (this.visibleDate(this.start) && this.visibleDate(this.end)) {
|
|
this.selection = [this.start, this.end];
|
|
}
|
|
else {
|
|
this.timeticks.selectedRange(this);
|
|
}
|
|
|
|
return this.selection
|
|
}
|
|
|
|
addCallback(callback) {
|
|
this.callbacks.push(callback);
|
|
}
|
|
|
|
addTabCallback(callback) {
|
|
this.onTapCallbacks.push(callback);
|
|
}
|
|
|
|
addDoubleTapCallback(callback) {
|
|
this.onDoubleTapCallbacks.push(callback);
|
|
}
|
|
|
|
addLongPressCallback(callback) {
|
|
this.onLongPressCallbacks.push(callback);
|
|
}
|
|
|
|
addLabels(labels) {
|
|
this.labelDates = labels;
|
|
}
|
|
|
|
range(start, end) {
|
|
this.start = start;
|
|
this.end = end;
|
|
}
|
|
|
|
draw(width, height) {
|
|
this.wantedWidth = width;
|
|
this.wantedHeight = height;
|
|
this.redraw();
|
|
}
|
|
|
|
updateColorRanges(w, h) {
|
|
let xx = w - this.inset;
|
|
let size = FontInfo.small.fontSize;
|
|
let yy = h - size;
|
|
for (let i = this.colorRanges.length - 1; i >= 0; i--) {
|
|
let cr = this.colorRanges[i];
|
|
let label = cr.label;
|
|
cr.draw(this, w, h);
|
|
let current = this.ensureLabel('colorRange:' + label, label,
|
|
{ x: xx, y: yy, align: 'right' }, FontInfo.small);
|
|
let r = current.getBounds();
|
|
xx -= r.width + 16;
|
|
|
|
this.lineStyle(size, cr.color);
|
|
this.moveTo(xx, yy);
|
|
this.lineTo(xx + size, yy);
|
|
xx -= size + 4;
|
|
}
|
|
}
|
|
|
|
drawSelectedRamge(selected) {
|
|
this.lineStyle(2, app.theme.primaryColor);
|
|
let start = this.toX(selected[0]);
|
|
let end = this.toX(selected[1]);
|
|
this.moveTo(start, 0);
|
|
this.lineTo(end, 0);
|
|
this.drawTick(start, -1.5, 0);
|
|
this.drawTick(end, -1.5, 0);
|
|
}
|
|
|
|
redraw() {
|
|
this.clear();
|
|
let h = this.wantedHeight;
|
|
let w = this.wantedWidth;
|
|
let y = this.getY();
|
|
this.prepareLabels();
|
|
this.updateColorRanges(w, h);
|
|
|
|
this.lineStyle(2, 0xFFFFFF);
|
|
if (this.start != null && this.end != null) {
|
|
this.moveTo(this.toX(this.start), y);
|
|
this.lineTo(this.toX(this.end), y);
|
|
this.updateTicksAndLabels(w, h);
|
|
this.updateSelection();
|
|
let selected = this.selection;
|
|
if (selected[0] != this.start && selected[1] != this.end) {
|
|
if (this.showRange)
|
|
this.drawSelectedRamge(selected);
|
|
}
|
|
for (let callback of this.callbacks) {
|
|
callback(this.scroll, this.zoom, this.selection);
|
|
}
|
|
}
|
|
else {
|
|
this.moveTo(this.inset, y);
|
|
this.lineTo(w - this.inset, y);
|
|
}
|
|
|
|
if (this.progress != null && this.progress < 1) {
|
|
this.lineStyle(2, 0xCCCCFF);
|
|
this.moveTo(this.inset, y);
|
|
this.lineTo((w - this.inset) * this.progress, y);
|
|
}
|
|
}
|
|
|
|
totalWidth(bounded = false) {
|
|
let w = this.wantedWidth - (2 * this.inset);
|
|
return w * this.validZoom(this.zoom, bounded)
|
|
}
|
|
|
|
validZoom(zoom, bounded = true) {
|
|
let overshoot = (bounded) ? 1.0 : 2.0;
|
|
zoom = Math.max(zoom, this.minZoom / overshoot);
|
|
zoom = Math.min(zoom, this.maxZoom * overshoot);
|
|
return zoom
|
|
}
|
|
|
|
getY() {
|
|
return this.wantedHeight * this.baseLine
|
|
}
|
|
|
|
toX(date) {
|
|
let total = this.end - this.start;
|
|
let offset = this.inset + this.scroll;
|
|
let width = this.totalWidth();
|
|
let delta = date - this.start;
|
|
let ratio = delta / total;
|
|
return offset + ratio * width
|
|
}
|
|
|
|
fromX(value) {
|
|
let total = this.end - this.start;
|
|
let offset = this.inset + this.scroll;
|
|
let width = this.totalWidth();
|
|
let ratio = (value - offset) / width;
|
|
let time = this.start.getTime() + total * ratio;
|
|
let date = new Date(time);
|
|
return date
|
|
}
|
|
|
|
drawTick(x, direction = 1, y = null) {
|
|
if (y == null) {
|
|
y = this.getY();
|
|
}
|
|
this.moveTo(x, y);
|
|
this.lineTo(x, y - (this.tickHeight * direction * this.direction));
|
|
}
|
|
|
|
prepareLabels() {
|
|
for (let key of this.labels.keys()) {
|
|
if (!key.startsWith(this.labelPrefix))
|
|
this.labels.get(key).visible = false;
|
|
}
|
|
}
|
|
|
|
updateTicksAndLabels(width, height) {
|
|
this.drawTick(this.toX(this.start));
|
|
this.drawTick(this.toX(this.end));
|
|
this.timeticks.draw(this, width, height);
|
|
this.updateLabels(width, height);
|
|
}
|
|
|
|
visibleDate(date, offset = 0) {
|
|
if (date >= this.start && date <= this.end) {
|
|
let x = this.toX(date) + offset;
|
|
return (x > 0 && x < this.wantedWidth)
|
|
}
|
|
return false
|
|
}
|
|
|
|
visibleRange(start, end) {
|
|
let x = this.toX(start);
|
|
if (x > this.wantedWidth)
|
|
return false
|
|
x = this.toX(end);
|
|
if (x < 0)
|
|
return false
|
|
return true
|
|
}
|
|
|
|
tickLabelOffset(direction = 1, level = 0) {
|
|
let fs = FontInfo.small.fontSize;
|
|
let dh = fs + (level * (fs + 2));
|
|
return this.direction * direction * dh
|
|
}
|
|
|
|
updateLabels(width, height) {
|
|
let h2 = height / 2;
|
|
if (this.labelDates) {
|
|
let last = null;
|
|
let y = h2 + this.tickLabelOffset();
|
|
for (let i = this.labelDates.length - 1; i >= 0; i--) {
|
|
let [label, date] = this.labelDates[i];
|
|
let align = 'center'; // (last == null) ? 'right' : 'left'
|
|
let x = this.toX(date);
|
|
let current = this.ensureLabel(this.labelPrefix + label, label,
|
|
{
|
|
x: x, y: y,
|
|
align
|
|
},
|
|
FontInfo.small);
|
|
let r = current.getBounds();
|
|
current.visible = !(last != null && r.x + r.width > last.x);
|
|
if (current.visible) {
|
|
this.drawTick(x, -1);
|
|
last = r;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
let start = this.start.toLocaleDateString('de', { year: 'numeric', month: 'numeric', day: 'numeric' });
|
|
let end = this.end.toLocaleDateString('de', { year: 'numeric', month: 'numeric', day: 'numeric' });
|
|
this.ensureLabel(this.labelPrefix + 'start', start, { x: this.toX(this.start), y: h2 });
|
|
this.ensureLabel(this.labelPrefix + 'end', end, { x: this.toX(this.end), y: h2, align: 'right' });
|
|
}
|
|
}
|
|
|
|
onZoom(zoom, anchor) {
|
|
let date = this.fromX(anchor.x);
|
|
let newZoom = this.validZoom(this.zoom * zoom, false);
|
|
this.zoom = newZoom;
|
|
let newX = this.toX(date);
|
|
this.scroll += anchor.x - newX;
|
|
}
|
|
|
|
onStart(event, interaction) {
|
|
this.killTweens();
|
|
this.deltas = [];
|
|
this.validScroll();
|
|
ThrowPropsPlugin.track(this, 'delta');
|
|
}
|
|
|
|
onMove(event, interaction) {
|
|
let delta = interaction.delta();
|
|
this.scroll += delta.x;
|
|
while (this.deltas.length > 10) {
|
|
this.deltas.pop(0);
|
|
}
|
|
this.deltas.push(delta.x);
|
|
if (interaction.current.size > 1) {
|
|
this.onZoom(delta.zoom, delta.about);
|
|
}
|
|
this.redraw();
|
|
}
|
|
|
|
onEnd(event, interaction) {
|
|
let vel = ThrowPropsPlugin.getVelocity(this, 'delta');
|
|
ThrowPropsPlugin.untrack(this);
|
|
|
|
this.killTweens();
|
|
this.redraw();
|
|
let delta = 0;
|
|
for (let d of this.deltas) {
|
|
delta += d;
|
|
}
|
|
if (this.deltas.length > 0) {
|
|
delta /= this.deltas.length;
|
|
}
|
|
this.autoScroll = true;
|
|
let anchor = interaction.current.mean();
|
|
this.keepInBounds(delta, anchor);
|
|
|
|
for(let key of interaction.ended.keys()) {
|
|
if (interaction.isDoubleTap(key)) {
|
|
this.onDoubleTap(event, interaction, key);
|
|
}
|
|
else if (interaction.isTap(key)) {
|
|
this.onTap(event, interaction, key);
|
|
}
|
|
else if (interaction.isLongPress(key)) {
|
|
this.onLongPress(event, interaction, key);
|
|
}
|
|
}
|
|
}
|
|
|
|
onLongPress(event, interaction, key) {
|
|
for(let callback of this.onLongPressCallbacks) {
|
|
callback(event, interaction, key);
|
|
}
|
|
}
|
|
|
|
onTap(event, interaction, key) {
|
|
for(let callback of this.onTapCallbacks) {
|
|
callback(event, interaction, key);
|
|
}
|
|
}
|
|
|
|
onDoubleTap(event, interaction, key) {
|
|
for(let callback of this.onDoubleTapCallbacks) {
|
|
callback(event, interaction, key);
|
|
}
|
|
}
|
|
|
|
_scrollMinimum(bounded) {
|
|
let total = this.totalWidth(bounded);
|
|
return -total + this.wantedWidth - 2 * this.inset
|
|
}
|
|
|
|
_scrollMaximum(bounded) {
|
|
let total = this.totalWidth(bounded);
|
|
let limit = this.wantedWidth;
|
|
if (total > limit)
|
|
return 0
|
|
let w = limit - 2 * this.inset;
|
|
return (w - total) / 2
|
|
}
|
|
|
|
scrollMinimum(bounded) {
|
|
return this._scrollMinimum(bounded) - this.extraRight
|
|
}
|
|
|
|
scrollMaximum(bounded) {
|
|
return this._scrollMaximum(bounded) + this.extraLeft
|
|
}
|
|
|
|
killTweens() {
|
|
TweenLite.killTweensOf(this);
|
|
this.autoScroll = false;
|
|
}
|
|
|
|
|
|
validScroll(bounded = true) {
|
|
let minimum = this.scrollMinimum(bounded);
|
|
let maximum = this.scrollMaximum(bounded);
|
|
if (this.scroll < minimum) {
|
|
this.scroll = minimum;
|
|
}
|
|
if (this.scroll > maximum) {
|
|
this.scroll = maximum;
|
|
}
|
|
}
|
|
|
|
keepInBounds(delta, anchor) {
|
|
let bounded = true;
|
|
let minimum = this.scrollMinimum(bounded);
|
|
let maximum = this.scrollMaximum(bounded);
|
|
let tweens = {};
|
|
if (this.zoom > this.maxZoom) {
|
|
tweens.zoom = this.maxZoom;
|
|
let date = this.fromX(anchor.x);
|
|
let oldZoom = this.zoom;
|
|
this.zoom = this.maxZoom;
|
|
let newX = this.toX(date);
|
|
tweens.scroll = this.scroll + anchor.x - newX;
|
|
this.zoom = oldZoom;
|
|
}
|
|
else {
|
|
if (this.zoom < this.minZoom) {
|
|
tweens.zoom = this.minZoom;
|
|
}
|
|
if (this.scroll > maximum) {
|
|
tweens.scroll = maximum;
|
|
}
|
|
if (this.scroll < minimum) {
|
|
tweens.scroll = minimum;
|
|
}
|
|
}
|
|
if (!isEmpty(tweens)) {
|
|
tweens.onUpdate = () => { this.redraw(); };
|
|
TweenLite.to(this, 0.5, tweens).delay(0.1);
|
|
return
|
|
}
|
|
this.scroll += delta;
|
|
delta *= 0.985;
|
|
this.redraw();
|
|
if (Math.abs(delta) > 1 && this.autoScroll) {
|
|
setTimeout(() => this.keepInBounds(delta, anchor), 1000 / 100);
|
|
}
|
|
}
|
|
|
|
onMouseWheel(event) {
|
|
this.killTweens();
|
|
let direction = event.detail < 0 || event.wheelDelta > 0;
|
|
let anchor = { x: event.clientX, y: event.clientY };
|
|
const zoomFactor = 1.5;
|
|
this.onZoom((direction) ? zoomFactor : 1 / zoomFactor, anchor);
|
|
this.redraw();
|
|
this.keepInBounds(0, anchor);
|
|
}
|
|
|
|
showRanges(ranges, label = "Untitled", color = null) {
|
|
for (let cr of this.colorRanges) {
|
|
if (cr.label == label)
|
|
return
|
|
}
|
|
while (this.colorRanges.length >= this.rangeColors.length) {
|
|
this.colorRanges.shift();
|
|
}
|
|
this.colorRanges.push(new ColorRanges(label, color, ranges));
|
|
this.redraw();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Callback for the slider action onStart.
|
|
*
|
|
* @callback onStartCallback
|
|
* @param {object} event - The event object.
|
|
* @param {Slider} slider - A reference to the slider (also this refers to the slider).
|
|
*/
|
|
|
|
/**
|
|
* Callback for the slider action onUpdate.
|
|
*
|
|
* @callback onUpdateCallback
|
|
* @param {object} event - The event object.
|
|
* @param {Slider} slider - A reference to the slider (also this refers to the slider).
|
|
*/
|
|
|
|
/**
|
|
* Callback for the slider action onComplete.
|
|
*
|
|
* @callback onCompleteCallback
|
|
* @param {object} event - The event object.
|
|
* @param {Slider} slider - A reference to the slider (also this refers to the slider).
|
|
*/
|
|
|
|
/**
|
|
* Class that represents a PixiJS Slider.
|
|
*
|
|
* @example
|
|
* // Create the app
|
|
* const app = new PIXIApp({
|
|
* view: canvas,
|
|
* width: 900,
|
|
* height: 250
|
|
* }).setup().run()
|
|
*
|
|
* // Create the slider
|
|
* const slider = new Slider({
|
|
* x: 10,
|
|
* y: 20
|
|
* })
|
|
*
|
|
* // Add the slider to a DisplayObject
|
|
* app.scene.addChild(slider)
|
|
*
|
|
* @class
|
|
* @extends PIXI.Container
|
|
* @see {@link http://pixijs.download/dev/docs/PIXI.Container.html|PIXI.Container}
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/slider.html|DocTest}
|
|
*/
|
|
class Slider extends PIXI.Container {
|
|
|
|
/**
|
|
* Creates an instance of a Slider.
|
|
*
|
|
* @constructor
|
|
* @param {object} [opts] - An options object to specify to style and behaviour of the slider.
|
|
* @param {number} [opts.id=auto generated] - The id of the slider.
|
|
* @param {number} [opts.x=0] - The x position of the slider. Can be also set after creation with slider.x = 0.
|
|
* @param {number} [opts.y=0] - The y position of the slider. Can be also set after creation with slider.y = 0.
|
|
* @param {string|Theme} [opts.theme=dark] - The theme to use for this slider. Possible values are dark, light, red
|
|
* or a Theme object.
|
|
* @param {number} [opts.width=250] - The width of the slider.
|
|
* @param {number} [opts.height=2] - The height of the slider.
|
|
* @param {PIXI.DisplayObject} [opts.container=window.app|object] - The container where the slider events should be attached to.
|
|
* @param {number} [opts.fill=Theme.fill] - The color of the slider background as a hex value.
|
|
* @param {number} [opts.fillAlpha=Theme.fillAlpha] - The alpha value of the background.
|
|
* @param {number} [opts.stroke=Theme.stroke] - The color of the border as a hex value.
|
|
* @param {number} [opts.strokeWidth=Theme.strokeWidth] - The width of the border in pixel.
|
|
* @param {number} [opts.strokeAlpha=Theme.strokeAlpha] - The alpha value of the border.
|
|
* @param {number} [opts.controlFill=Theme.stroke] - The color of the slider control background as a hex value.
|
|
* @param {number} [opts.controlFillAlpha=Theme.strokeAlpha] - The alpha value of the background.
|
|
* @param {number} [opts.controlStroke=Theme.stroke] - The color of the border as a hex value.
|
|
* @param {number} [opts.controlStrokeWidth=Theme.strokeWidth * 0.8] - The width of the border in pixel.
|
|
* @param {number} [opts.controlStrokeAlpha=Theme.strokeAlpha] - The alpha value of the border.
|
|
* @param {number} [opts.controlRadius=16] - The radius of the slider control.
|
|
* @param {boolean} [opts.disabled=false] - Is the slider disabled? When disabled, the slider has a lower alpha value
|
|
* and cannot be clicked (interactive is set to false).
|
|
* @param {onStartCallback} [opts.onStart] - Executed when the slider control starts to move.
|
|
* @param {onUpdateCallback} [opts.onUpdate] - Executed when the slider control is moved.
|
|
* @param {onCompleteCallback} [opts.onComplete] - Executed when the slider control was dropped.
|
|
* @param {string|object} [opts.tooltip] - A string for the label of the tooltip or an object to configure the tooltip
|
|
* to display.
|
|
* @param {boolean} [opts.visible=true] - Is the slider initially visible (property visible)?
|
|
*/
|
|
constructor(opts = {}) {
|
|
|
|
super();
|
|
|
|
const theme = Theme.fromString(opts.theme);
|
|
this.theme = theme;
|
|
|
|
this.opts = Object.assign({}, {
|
|
id: PIXI.utils.uid(),
|
|
x: 0,
|
|
y: 0,
|
|
width: 250,
|
|
height: 2,
|
|
container: null,
|
|
fill: theme.fill,
|
|
fillAlpha: theme.fillAlpha,
|
|
stroke: theme.stroke,
|
|
strokeWidth: theme.strokeWidth,
|
|
strokeAlpha: theme.strokeAlpha,
|
|
controlFill: theme.fill,
|
|
controlFillAlpha: .5,
|
|
controlStroke: theme.primaryColor,
|
|
controlStrokeWidth: 2,
|
|
controlStrokeAlpha: theme.strokeAlpha,
|
|
controlRadius: 16,
|
|
orientation: 'horizontal',
|
|
min: 0,
|
|
max: 100,
|
|
value: 0,
|
|
disabled: false,
|
|
onStart: null,
|
|
onUpdate: null,
|
|
onComplete: null,
|
|
tooltip: null,
|
|
visible: true
|
|
}, opts);
|
|
|
|
this.opts.container = this.opts.container || this;
|
|
|
|
// Validation
|
|
//-----------------
|
|
if (this.opts.height > this.opts.width) {
|
|
this.opts.height = this.opts.width;
|
|
}
|
|
|
|
if (this.opts.value < this.opts.min) {
|
|
this.opts.value = this.opts.min;
|
|
}
|
|
|
|
if (this.opts.value > this.opts.max) {
|
|
this.opts.value = this.opts.max;
|
|
}
|
|
|
|
// Properties
|
|
//-----------------
|
|
this.id = this.opts.id;
|
|
this.radius = this.opts.height / 2;
|
|
|
|
this._value = this.opts.value;
|
|
this._disabled = null;
|
|
|
|
this.sliderObj = null;
|
|
this.control = null;
|
|
this.tooltip = null;
|
|
|
|
this.visible = this.opts.visible;
|
|
|
|
// setup
|
|
//-----------------
|
|
this.setup();
|
|
|
|
// layout
|
|
//-----------------
|
|
this.layout();
|
|
}
|
|
|
|
/**
|
|
* Creates children and instantiates everything.
|
|
*
|
|
* @private
|
|
* @return {Slider} A reference to the slider for chaining.
|
|
*/
|
|
setup() {
|
|
|
|
// Container events
|
|
//-----------------
|
|
const container = this.opts.container;
|
|
|
|
this.on('pointermove', e => {
|
|
if (this.control.dragging) {
|
|
const moveX = this.control.event.data.getLocalPosition(this.control.parent).x;
|
|
this._value = this.pixelToValue(moveX - this.control.delta - this.opts.controlRadius);
|
|
let x = this.valueToPixel(this._value) + this.opts.controlRadius;
|
|
this.control.x = x;
|
|
|
|
if (this.opts.onUpdate) {
|
|
this.opts.onUpdate.call(this, e, this);
|
|
}
|
|
}
|
|
});
|
|
|
|
if (container instanceof Element) {
|
|
container.addEventListener('pointerup', e => this.onEnd(e), false);
|
|
container.addEventListener('pointercancel', e => this.onEnd(e), false);
|
|
container.addEventListener('pointerleave', e => this.onEnd(e), false);
|
|
container.addEventListener('pointerout', e => this.onEnd(e), false);
|
|
container.addEventListener('mouseup', e => this.onEnd(e), false);
|
|
container.addEventListener('mousecancel', e => this.onEnd(e), false);
|
|
container.addEventListener('mouseleave', e => this.onEnd(e), false);
|
|
container.addEventListener('mouseout', e => this.onEnd(e), false);
|
|
} else {
|
|
container.interactive = true;
|
|
container.on('pointerup', e => this.onEnd(e));
|
|
container.on('pointercancel', e => this.onEnd(e));
|
|
container.on('pointerleave', e => this.onEnd(e));
|
|
container.on('pointerout', e => this.onEnd(e));
|
|
}
|
|
|
|
// Slider
|
|
//-----------------
|
|
let sliderObj = new PIXI.Graphics();
|
|
this.sliderObj = sliderObj;
|
|
this.addChild(sliderObj);
|
|
|
|
// Control
|
|
//-----------------
|
|
let control = new PIXI.Graphics();
|
|
control.x = this.opts.controlRadius + this.valueToPixel(this.opts.value);
|
|
control.y = this.opts.controlRadius;
|
|
|
|
// pointerdown on the control for dragndrop
|
|
control.on('pointerdown', e => {
|
|
control.event = e;
|
|
control.delta = e.data.getLocalPosition(this.control).x;
|
|
control.dragging = true;
|
|
|
|
if (this.opts.onStart) {
|
|
this.opts.onStart.call(this, e, this);
|
|
}
|
|
});
|
|
|
|
this.control = control;
|
|
|
|
this.addChild(this.control);
|
|
|
|
// interaction
|
|
//-----------------
|
|
this.sliderObj.on('pointerover', e => {
|
|
TweenLite.to(this.control, this.theme.fast, {alpha: .83});
|
|
});
|
|
|
|
this.sliderObj.on('pointerout', e => {
|
|
TweenLite.to(this.control, this.theme.fast, {alpha: 1});
|
|
});
|
|
|
|
this.sliderObj.on('pointerdown', e => {
|
|
this.sliderObj.pointerdowned = true;
|
|
TweenLite.to(this.control, this.theme.fast, {alpha: .7});
|
|
});
|
|
|
|
// Click on the slider bar
|
|
this.sliderObj.on('pointerup', e => {
|
|
if (this.sliderObj.pointerdowned) {
|
|
this.sliderObj.pointerdowned = false;
|
|
const position = e.data.getLocalPosition(this.control.parent);
|
|
this.value = this.pixelToValue(position.x - this.opts.controlRadius);
|
|
TweenLite.to(this.control, this.theme.fast, {alpha: .83});
|
|
}
|
|
});
|
|
|
|
// disabled
|
|
//-----------------
|
|
this.disabled = this.opts.disabled;
|
|
|
|
// tooltip
|
|
//-----------------
|
|
if (this.opts.tooltip) {
|
|
if (typeof this.opts.tooltip === 'string') {
|
|
this.tooltip = new Tooltip({
|
|
object: this,
|
|
content: this.opts.tooltip
|
|
});
|
|
} else {
|
|
this.opts.tooltip.object = this;
|
|
this.tooltip = new Tooltip(this.opts.tooltip);
|
|
}
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Should be called to refresh the layout of the slider. Can be used after resizing.
|
|
*
|
|
* @return {Slider} A reference to the slider for chaining.
|
|
*/
|
|
layout() {
|
|
|
|
// set position
|
|
//-----------------
|
|
this.position.set(this.opts.x, this.opts.y);
|
|
|
|
// draw
|
|
//-----------------
|
|
this.draw();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Draws the slider to the canvas.
|
|
*
|
|
* @private
|
|
* @return {Slider} A reference to the slider for chaining.
|
|
*/
|
|
draw() {
|
|
|
|
const r = this.radius;
|
|
const cr = this.opts.controlRadius;
|
|
const w = this.opts.width;
|
|
const h = this.opts.height;
|
|
const x = cr + r;
|
|
const y = cr + r - h;
|
|
|
|
this.sliderObj.clear();
|
|
this.sliderObj.beginFill(0xffffff, 0);
|
|
this.sliderObj.drawRect(0, 0, x + w + cr, cr * 2);
|
|
this.sliderObj.lineStyle(this.opts.strokeWidth, this.opts.stroke, this.opts.strokeAlpha);
|
|
this.sliderObj.beginFill(this.opts.fill, this.opts.fillAlpha);
|
|
this.sliderObj.moveTo(x, y);
|
|
this.sliderObj.lineTo(x + w, y);
|
|
this.sliderObj.arcTo(x + w + r, y, x + w + r, y + r, r);
|
|
this.sliderObj.lineTo(x + w + r, y + r + 1); // BUGFIX: If not specified, there is a small area without a stroke.
|
|
this.sliderObj.arcTo(x + w + r, y + h, x + w, y + h, r);
|
|
this.sliderObj.lineTo(x, y + h);
|
|
this.sliderObj.arcTo(x - r, y + h, x - r, y + r, r);
|
|
this.sliderObj.arcTo(x - r, y, x, y, r);
|
|
this.sliderObj.endFill();
|
|
|
|
// Draw control
|
|
this.control.clear();
|
|
this.control.lineStyle(this.opts.controlStrokeWidth, this.opts.controlStroke, this.opts.controlStrokeAlpha);
|
|
this.control.beginFill(this.opts.controlFill, this.opts.controlFillAlpha);
|
|
this.control.drawCircle(0, 0, cr - 1);
|
|
this.control.beginFill(this.opts.controlStroke, this.opts.controlStrokeAlpha);
|
|
this.control.drawCircle(0, 0, cr / 6);
|
|
this.control.endFill();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Executed, when the slider control movement ended.
|
|
*
|
|
* @private
|
|
* @return {Slider} A reference to the slider for chaining.
|
|
*/
|
|
onEnd(e) {
|
|
|
|
if (this.control.dragging) {
|
|
this.control.event = null;
|
|
this.control.dragging = false;
|
|
if (this.opts.onComplete) {
|
|
this.opts.onComplete.call(this, e, this);
|
|
}
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Calculates the value for a given pixel.
|
|
*
|
|
* @private
|
|
* @param {number} value
|
|
* @returns {number} The calucalted pixel.
|
|
*/
|
|
valueToPixel(value) {
|
|
if (value < this.opts.min) {
|
|
value = this.opts.min;
|
|
} else if (value > this.opts.max) {
|
|
value = this.opts.max;
|
|
}
|
|
return this.opts.width * (value - this.opts.min) / (this.opts.max - this.opts.min)
|
|
}
|
|
|
|
/**
|
|
* Calculates the pixel for a given value.
|
|
*
|
|
* @private
|
|
* @param {number} pixel
|
|
* @returns {number} The calucalted value.
|
|
*/
|
|
pixelToValue(pixel) {
|
|
if (pixel < 0) {
|
|
pixel = 0;
|
|
} else if (pixel > this.opts.width) {
|
|
pixel = this.opts.width;
|
|
}
|
|
return this.opts.min + ((this.opts.max - this.opts.min) * pixel / this.opts.width)
|
|
}
|
|
|
|
/**
|
|
* Gets or sets the value.
|
|
*
|
|
* @member {number}
|
|
*/
|
|
get value() {
|
|
return Math.round(this._value)
|
|
}
|
|
set value(value) {
|
|
if (value < this.opts.min) {
|
|
value = this.opts.min;
|
|
} else if (value > this.opts.max) {
|
|
value = this.opts.max;
|
|
}
|
|
this._value = value;
|
|
|
|
const x = this.valueToPixel(value) + this.opts.controlRadius;
|
|
|
|
TweenLite.to(this.control, this.theme.fast, {x});
|
|
}
|
|
|
|
/**
|
|
* Gets or sets the disabled state. When disabled, the slider cannot be clicked.
|
|
*
|
|
* @member {boolean}
|
|
*/
|
|
get disabled() {
|
|
return this._disabled
|
|
}
|
|
set disabled(value) {
|
|
|
|
this._disabled = value;
|
|
|
|
if (this._disabled) {
|
|
this.interactive = false;
|
|
this.sliderObj.interactive = false;
|
|
this.control.interactive = false;
|
|
this.control.buttonMode = false;
|
|
this.alpha = .5;
|
|
} else {
|
|
this.interactive = true;
|
|
this.sliderObj.interactive = true;
|
|
this.control.interactive = true;
|
|
this.control.buttonMode = true;
|
|
this.alpha = 1;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Shows the slider (sets his alpha values to 1).
|
|
*
|
|
* @return {Slider} A reference to the slider for chaining.
|
|
*/
|
|
show() {
|
|
|
|
this.opts.strokeAlpha = 1;
|
|
this.opts.fillAlpha = 1;
|
|
this.opts.controlStrokeAlpha = 1;
|
|
this.opts.controlFillAlpha = 1;
|
|
|
|
this.layout();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Hides the slider (sets his alpha values to 1).
|
|
*
|
|
* @return {Slider} A reference to the slider for chaining.
|
|
*/
|
|
hide() {
|
|
|
|
this.opts.strokeAlpha = 0;
|
|
this.opts.fillAlpha = 0;
|
|
this.opts.controlStrokeAlpha = 0;
|
|
this.opts.controlFillAlpha = 0;
|
|
|
|
this.layout();
|
|
|
|
return this
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Callback for the switch action.
|
|
*
|
|
* @callback actionCallback
|
|
* @param {object} event - The event object.
|
|
* @param {Switch} switch - A reference to the switch (also this refers to the switch).
|
|
*/
|
|
|
|
/**
|
|
* Callback for the switch action.
|
|
*
|
|
* @callback actionActiveCallback
|
|
* @param {object} event - The event object.
|
|
* @param {Switch} switch - A reference to the switch (also this refers to the switch).
|
|
*/
|
|
|
|
/**
|
|
* Callback for the switch beforeAction.
|
|
*
|
|
* @callback beforeActionCallback
|
|
* @param {object} event - The event object.
|
|
* @param {Switch} switch - A reference to the switch (also this refers to the switch).
|
|
*/
|
|
|
|
/**
|
|
* Callback for the switch afterAction.
|
|
*
|
|
* @callback afterActionCallback
|
|
* @param {object} event - The event object.
|
|
* @param {Switch} switch - A reference to the switch (also this refers to the switch).
|
|
*/
|
|
|
|
/**
|
|
* Class that represents a PixiJS Switch.
|
|
*
|
|
* @example
|
|
* // Create the app
|
|
* const app = new PIXIApp({
|
|
* view: canvas,
|
|
* width: 900,
|
|
* height: 250
|
|
* }).setup().run()
|
|
*
|
|
* // Create the switch
|
|
* const switch1 = new Switch({
|
|
* x: 10,
|
|
* y: 20
|
|
* })
|
|
*
|
|
* // Add the switch to a DisplayObject
|
|
* app.scene.addChild(switch1)
|
|
*
|
|
* @class
|
|
* @extends PIXI.Container
|
|
* @see {@link http://pixijs.download/dev/docs/PIXI.Container.html|PIXI.Container}
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/switch.html|DocTest}
|
|
*/
|
|
class Switch extends PIXI.Container {
|
|
|
|
/**
|
|
* Creates an instance of a Switch.
|
|
*
|
|
* @constructor
|
|
* @param {object} [opts] - An options object to specify to style and behaviour of the switch.
|
|
* @param {number} [opts.id=auto generated] - The id of the switch.
|
|
* @param {number} [opts.x=0] - The x position of the switch. Can be also set after creation with switch.x = 0.
|
|
* @param {number} [opts.y=0] - The y position of the switch. Can be also set after creation with switch.y = 0.
|
|
* @param {string|Theme} [opts.theme=dark] - The theme to use for this switch. Possible values are dark, light, red
|
|
* or a Theme object.
|
|
* @param {number} [opts.width=44] - The width of the switch.
|
|
* @param {number} [opts.height=28] - The height of the switch.
|
|
* @param {number} [opts.fill=Theme.fill] - The color of the switch background as a hex value.
|
|
* @param {number} [opts.fillAlpha=Theme.fillAlpha] - The alpha value of the background.
|
|
* @param {number} [opts.fillActive=Theme.fillActive] - The color of the switch background when activated.
|
|
* @param {number} [opts.fillActiveAlpha=Theme.fillActiveAlpha] - The alpha value of the background when activated.
|
|
* @param {number} [opts.stroke=Theme.stroke] - The color of the border as a hex value.
|
|
* @param {number} [opts.strokeWidth=Theme.strokeWidth] - The width of the border in pixel.
|
|
* @param {number} [opts.strokeAlpha=Theme.strokeAlpha] - The alpha value of the border.
|
|
* @param {number} [opts.strokeActive=Theme.strokeActive] - The color of the border when activated.
|
|
* @param {number} [opts.strokeActiveWidth=Theme.strokeActiveWidth] - The width of the border in pixel when activated.
|
|
* @param {number} [opts.strokeActiveAlpha=Theme.strokeActiveAlpha] - The alpha value of the border when activated.
|
|
* @param {number} [opts.controlFill=Theme.stroke] - The color of the switch control background as a hex value.
|
|
* @param {number} [opts.controlFillAlpha=Theme.strokeAlpha] - The alpha value of the background.
|
|
* @param {number} [opts.controlFillActive=Theme.stroke] - The color of the switch control background when activated.
|
|
* @param {number} [opts.controlFillActiveAlpha=Theme.strokeAlpha] - The alpha value of the background when activated.
|
|
* @param {number} [opts.controlStroke=Theme.stroke] - The color of the border as a hex value.
|
|
* @param {number} [opts.controlStrokeWidth=Theme.strokeWidth * 0.8] - The width of the border in pixel.
|
|
* @param {number} [opts.controlStrokeAlpha=Theme.strokeAlpha] - The alpha value of the border.
|
|
* @param {number} [opts.controlStrokeActive=Theme.stroke] - The color of the border when activated.
|
|
* @param {number} [opts.controlStrokeActiveWidth=Theme.strokeActiveWidth * 0.8] - The width of the border in pixel when activated.
|
|
* @param {number} [opts.controlStrokeActiveAlpha=Theme.strokeActiveAlpha] - The alpha value of the border when activated.
|
|
* @param {number} [opts.duration=Theme.fast] - The duration of the animation when the switch gets activated in seconds.
|
|
* @param {number} [opts.durationActive=Theme.fast] - The duration of the animation when the switch gets deactivated in seconds.
|
|
* @param {boolean} [opts.disabled=false] - Is the switch disabled? When disabled, the switch has a lower alpha value
|
|
* and cannot be clicked (interactive is set to false).
|
|
* @param {boolean} [opts.active=false] - Is the button initially active?
|
|
* @param {actionCallback} [opts.action] - Executed when the switch was triggered in inactive state (by pointerup).
|
|
* @param {actionActiveCallback} [opts.actionActive] - Executed when the button was triggered in active state (by pointerup).
|
|
* @param {beforeActionCallback} [opts.beforeAction] - Executed before an action is triggered.
|
|
* @param {afterActionCallback} [opts.afterAction] - Executed after an action was triggered.
|
|
* @param {string|object} [opts.tooltip] - A string for the label of the tooltip or an object to configure the tooltip
|
|
* to display.
|
|
* @param {boolean} [opts.visible=true] - Is the switch initially visible (property visible)?
|
|
*/
|
|
constructor(opts = {}) {
|
|
|
|
super();
|
|
|
|
const theme = Theme.fromString(opts.theme);
|
|
this.theme = theme;
|
|
|
|
this.opts = Object.assign({}, {
|
|
id: PIXI.utils.uid(),
|
|
x: 0,
|
|
y: 0,
|
|
width: 44,
|
|
height: 28,
|
|
fill: theme.fill,
|
|
fillAlpha: theme.fillAlpha,
|
|
fillActive: theme.primaryColor,
|
|
fillActiveAlpha: theme.fillActiveAlpha,
|
|
stroke: theme.stroke,
|
|
strokeWidth: theme.strokeWidth,
|
|
strokeAlpha: theme.strokeAlpha,
|
|
strokeActive: theme.primaryColor,
|
|
strokeActiveWidth: theme.strokeActiveWidth,
|
|
strokeActiveAlpha: theme.strokeActiveAlpha,
|
|
controlFill: theme.stroke,
|
|
controlFillAlpha: theme.strokeAlpha,
|
|
controlFillActive: theme.stroke,
|
|
controlFillActiveAlpha: theme.strokeAlpha,
|
|
controlStroke: theme.stroke,
|
|
controlStrokeWidth: theme.strokeWidth * .8,
|
|
controlStrokeAlpha: theme.strokeAlpha,
|
|
controlStrokeActive: theme.stroke,
|
|
controlStrokeActiveWidth: theme.strokeActiveWidth * .8,
|
|
controlStrokeActiveAlpha: theme.strokeActiveAlpha,
|
|
duration: theme.fast,
|
|
durationActive: theme.fast,
|
|
disabled: false,
|
|
active: false,
|
|
action: null,
|
|
actionActive: null,
|
|
beforeAction: null,
|
|
afterAction: null,
|
|
tooltip: null,
|
|
visible: true
|
|
}, opts);
|
|
|
|
this.opts.controlRadius = this.opts.controlRadius || (this.opts.height / 2);
|
|
this.opts.controlRadiusActive = this.opts.controlRadiusActive || this.opts.controlRadius;
|
|
|
|
// Validation
|
|
//-----------------
|
|
if (this.opts.height > this.opts.width) {
|
|
this.opts.height = this.opts.width;
|
|
}
|
|
|
|
// Properties
|
|
//-----------------
|
|
this.id = this.opts.id;
|
|
this.radius = this.opts.height / 2;
|
|
|
|
this._active = null;
|
|
this._disabled = null;
|
|
|
|
this.switchObj = null;
|
|
this.control = null;
|
|
this.tooltip = null;
|
|
|
|
this.visible = this.opts.visible;
|
|
|
|
// animated
|
|
//-----------------
|
|
this.tempAnimated = {
|
|
fill: this.opts.fill,
|
|
fillAlpha: this.opts.fillAlpha,
|
|
stroke: this.opts.stroke,
|
|
strokeWidth: this.opts.strokeWidth,
|
|
strokeAlpha: this.opts.strokeAlpha,
|
|
controlFill: this.opts.controlFill,
|
|
controlFillAlpha: this.opts.controlFillAlpha,
|
|
controlStroke: this.opts.controlStroke,
|
|
controlStrokeWidth: this.opts.controlStrokeWidth,
|
|
controlStrokeAlpha: this.opts.controlStrokeAlpha,
|
|
controlRadius: this.opts.controlRadius
|
|
};
|
|
|
|
// setup
|
|
//-----------------
|
|
this.setup();
|
|
|
|
// layout
|
|
//-----------------
|
|
this.layout();
|
|
}
|
|
|
|
/**
|
|
* Creates children and instantiates everything.
|
|
*
|
|
* @private
|
|
* @return {Switch} A reference to the switch for chaining.
|
|
*/
|
|
setup() {
|
|
|
|
// Switch
|
|
//-----------------
|
|
let switchObj = new PIXI.Graphics();
|
|
this.switchObj = switchObj;
|
|
this.addChild(switchObj);
|
|
|
|
// Control
|
|
//-----------------
|
|
this.xInactive = this.opts.controlRadius;
|
|
this.xActive = this.opts.width - this.opts.controlRadiusActive;
|
|
|
|
let control = new PIXI.Graphics();
|
|
control.x = this.opts.active ? this.xActive : this.xInactive;
|
|
control.y = this.opts.height / 2;
|
|
|
|
this.control = control;
|
|
|
|
this.addChild(this.control);
|
|
|
|
// interaction
|
|
//-----------------
|
|
this.switchObj.on('pointerover', e => {
|
|
TweenLite.to(this.control, this.theme.fast, {alpha: .83});
|
|
});
|
|
|
|
this.switchObj.on('pointerout', e => {
|
|
TweenLite.to(this.control, this.theme.fast, {alpha: 1});
|
|
});
|
|
|
|
this.switchObj.on('pointerdown', e => {
|
|
TweenLite.to(this.control, this.theme.fast, {alpha: .7});
|
|
});
|
|
|
|
this.switchObj.on('pointerup', e => {
|
|
|
|
if (this.opts.beforeAction) {
|
|
this.opts.beforeAction.call(this, e, this);
|
|
}
|
|
|
|
this.active = !this.active;
|
|
|
|
if (this.active) {
|
|
if (this.opts.action) {
|
|
this.opts.action.call(this, e, this);
|
|
}
|
|
} else {
|
|
if (this.opts.actionActive) {
|
|
this.opts.actionActive.call(this, e, this);
|
|
}
|
|
}
|
|
|
|
TweenLite.to(this.control, this.theme.fast, {alpha: .83});
|
|
|
|
if (this.opts.afterAction) {
|
|
this.opts.afterAction.call(this, e, this);
|
|
}
|
|
});
|
|
|
|
// disabled
|
|
//-----------------
|
|
this.disabled = this.opts.disabled;
|
|
|
|
// active
|
|
//-----------------
|
|
this.active = this.opts.active;
|
|
|
|
// tooltip
|
|
//-----------------
|
|
if (this.opts.tooltip) {
|
|
if (typeof this.opts.tooltip === 'string') {
|
|
this.tooltip = new Tooltip({
|
|
object: this,
|
|
content: this.opts.tooltip
|
|
});
|
|
} else {
|
|
this.opts.tooltip.object = this;
|
|
this.tooltip = new Tooltip(this.opts.tooltip);
|
|
}
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Should be called to refresh the layout of the switch. Can be used after resizing.
|
|
*
|
|
* @return {Switch} A reference to the switch for chaining.
|
|
*/
|
|
layout() {
|
|
|
|
// set position
|
|
//-----------------
|
|
this.position.set(this.opts.x, this.opts.y);
|
|
|
|
// draw
|
|
//-----------------
|
|
this.draw();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Draws the switch to the canvas.
|
|
*
|
|
* @private
|
|
* @return {Switch} A reference to the switch for chaining.
|
|
*/
|
|
draw() {
|
|
|
|
this.switchObj.clear();
|
|
if (this.active) {
|
|
this.switchObj.lineStyle(this.opts.strokeActiveWidth, this.opts.strokeActive, this.opts.strokeActiveAlpha);
|
|
this.switchObj.beginFill(this.opts.fillActive, this.opts.fillActiveAlpha);
|
|
} else {
|
|
this.switchObj.lineStyle(this.opts.strokeWidth, this.opts.stroke, this.opts.strokeAlpha);
|
|
this.switchObj.beginFill(this.opts.fill, this.opts.fillAlpha);
|
|
}
|
|
this.switchObj.moveTo(this.radius, 0);
|
|
this.switchObj.lineTo(this.opts.width - this.radius, 0);
|
|
this.switchObj.arcTo(this.opts.width, 0, this.opts.width, this.radius, this.radius);
|
|
this.switchObj.lineTo(this.opts.width, this.radius + 1); // BUGFIX: If not specified, there is a small area without a stroke.
|
|
this.switchObj.arcTo(this.opts.width, this.opts.height, this.opts.width - this.radius, this.opts.height, this.radius);
|
|
this.switchObj.lineTo(this.radius, this.opts.height);
|
|
this.switchObj.arcTo(0, this.opts.height, 0, this.radius, this.radius);
|
|
this.switchObj.arcTo(0, 0, this.radius, 0, this.radius);
|
|
this.switchObj.endFill();
|
|
|
|
// Draw control
|
|
this.control.clear();
|
|
if (this.active) {
|
|
this.control.lineStyle(this.opts.controlStrokeActiveWidth, this.opts.controlStrokeActive, this.opts.controlStrokeActiveAlpha);
|
|
this.control.beginFill(this.opts.controlFillActive, this.opts.controlFillActiveAlpha);
|
|
this.control.drawCircle(0, 0, this.opts.controlRadiusActive - 1);
|
|
} else {
|
|
this.control.lineStyle(this.opts.controlStrokeWidth, this.opts.controlStroke, this.opts.controlStrokeAlpha);
|
|
this.control.beginFill(this.opts.controlFill, this.opts.controlFillAlpha);
|
|
this.control.drawCircle(0, 0, this.opts.controlRadius - 1);
|
|
}
|
|
this.control.endFill();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Draws the animation.
|
|
*
|
|
* @private
|
|
* @return {Switch} A reference to the switch for chaining.
|
|
*/
|
|
drawAnimated() {
|
|
|
|
this.switchObj.clear();
|
|
this.switchObj.lineStyle(this.tempAnimated.strokeWidth, this.tempAnimated.stroke, this.tempAnimated.strokeAlpha);
|
|
this.switchObj.beginFill(this.tempAnimated.fill, this.tempAnimated.fillAlpha);
|
|
this.switchObj.moveTo(this.radius, 0);
|
|
this.switchObj.lineTo(this.opts.width - this.radius, 0);
|
|
this.switchObj.arcTo(this.opts.width, 0, this.opts.width, this.radius, this.radius);
|
|
this.switchObj.lineTo(this.opts.width, this.radius + 1); // BUGFIX: If not specified, there is a small area without a stroke.
|
|
this.switchObj.arcTo(this.opts.width, this.opts.height, this.opts.width - this.radius, this.opts.height, this.radius);
|
|
this.switchObj.lineTo(this.radius, this.opts.height);
|
|
this.switchObj.arcTo(0, this.opts.height, 0, this.radius, this.radius);
|
|
this.switchObj.arcTo(0, 0, this.radius, 0, this.radius);
|
|
this.switchObj.endFill();
|
|
|
|
this.control.clear();
|
|
this.control.lineStyle(this.tempAnimated.controlStrokeWidth, this.tempAnimated.controlStroke, this.tempAnimated.controlStrokeAlpha);
|
|
this.control.beginFill(this.tempAnimated.controlFill, this.tempAnimated.controlFillAlpha);
|
|
this.control.drawCircle(0, 0, this.tempAnimated.controlRadius - 1);
|
|
this.control.endFill();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Gets or sets the active state.
|
|
*
|
|
* @member {boolean}
|
|
*/
|
|
get active() {
|
|
return this._active
|
|
}
|
|
|
|
set active(value) {
|
|
|
|
this._active = value;
|
|
|
|
if (this._active) {
|
|
|
|
TweenLite.to(this.control, this.opts.duration, {x: this.xActive});
|
|
TweenLite.to(this.tempAnimated, this.opts.duration, {
|
|
colorProps: {
|
|
fill: this.opts.fillActive,
|
|
stroke: this.opts.strokeActive,
|
|
controlFill: this.opts.controlFillActive,
|
|
controlStroke: this.opts.controlStrokeActive,
|
|
format: 'number'
|
|
},
|
|
fillAlpha: this.opts.fillActiveAlpha,
|
|
strokeWidth: this.opts.strokeActiveWidth,
|
|
strokeAlpha: this.opts.strokeActiveAlpha,
|
|
controlFillAlpha: this.opts.controlFillActiveAlpha,
|
|
controlStrokeWidth: this.opts.controlStrokeActiveWidth,
|
|
controlStrokeAlpha: this.opts.controlStrokeActiveAlpha,
|
|
controlRadius: this.opts.controlRadiusActive,
|
|
onUpdate: () => this.drawAnimated(),
|
|
onComplete: () => this.draw()
|
|
});
|
|
|
|
|
|
} else {
|
|
TweenLite.to(this.control, this.opts.durationActive, {x: this.xInactive});
|
|
TweenLite.to(this.tempAnimated, this.opts.durationActive, {
|
|
colorProps: {
|
|
fill: this.opts.fill,
|
|
stroke: this.opts.stroke,
|
|
controlFill: this.opts.controlFill,
|
|
controlStroke: this.opts.controlStroke,
|
|
format: 'number'
|
|
},
|
|
fillAlpha: this.opts.fillAlpha,
|
|
strokeWidth: this.opts.strokeWidth,
|
|
strokeAlpha: this.opts.strokeAlpha,
|
|
controlFillAlpha: this.opts.controlFillAlpha,
|
|
controlStrokeWidth: this.opts.controlStrokeWidth,
|
|
controlStrokeAlpha: this.opts.controlStrokeAlpha,
|
|
controlRadius: this.opts.controlRadius,
|
|
onUpdate: () => this.drawAnimated(),
|
|
onComplete: () => this.draw()
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets or sets the disabled state. When disabled, the switch cannot be clicked.
|
|
*
|
|
* @member {boolean}
|
|
*/
|
|
get disabled() {
|
|
return this._disabled
|
|
}
|
|
|
|
set disabled(value) {
|
|
|
|
this._disabled = value;
|
|
|
|
if (this._disabled) {
|
|
this.switchObj.interactive = false;
|
|
this.switchObj.buttonMode = false;
|
|
this.switchObj.alpha = .5;
|
|
this.control.alpha = .5;
|
|
} else {
|
|
this.switchObj.interactive = true;
|
|
this.switchObj.buttonMode = true;
|
|
this.switchObj.alpha = 1;
|
|
this.control.alpha = 1;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Shows the switch (sets his alpha values to 1).
|
|
*
|
|
* @return {Switch} A reference to the switch for chaining.
|
|
*/
|
|
show() {
|
|
|
|
this.opts.strokeAlpha = 1;
|
|
this.opts.strokeActiveAlpha = 1;
|
|
this.opts.fillAlpha = 1;
|
|
this.opts.fillActiveAlpha = 1;
|
|
this.opts.controlStrokeAlpha = 1;
|
|
this.opts.controlStrokeActiveAlpha = 1;
|
|
this.opts.controlFillAlpha = 1;
|
|
this.opts.controlFillActiveAlpha = 1;
|
|
|
|
this.layout();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Hides the switch (sets his alpha values to 1).
|
|
*
|
|
* @return {Switch} A reference to the switch for chaining.
|
|
*/
|
|
hide() {
|
|
|
|
this.opts.strokeAlpha = 0;
|
|
this.opts.strokeActiveAlpha = 0;
|
|
this.opts.fillAlpha = 0;
|
|
this.opts.fillActiveAlpha = 0;
|
|
this.opts.controlStrokeAlpha = 0;
|
|
this.opts.controlStrokeActiveAlpha = 0;
|
|
this.opts.controlFillAlpha = 0;
|
|
this.opts.controlFillActiveAlpha = 0;
|
|
|
|
this.layout();
|
|
|
|
return this
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class that represents a PixiJS PopupMenu.
|
|
*
|
|
* @example
|
|
* // Create the button and the modal when clicked
|
|
* const button = new Button({
|
|
* label: 'Show PopupMenu',
|
|
* action: e => {
|
|
* const popupmenu = new PopupMenu({
|
|
* items: [
|
|
* {label: 'Save', action: () => alert('Saved')},
|
|
* {label: 'Edit', action: () => alert('Edited')},
|
|
* {label: 'Delete', action: () => alert('Deleted')}
|
|
* ]
|
|
* })
|
|
* app.scene.addChild(popupmenu)
|
|
* }
|
|
* })
|
|
*
|
|
* // Add the button to a DisplayObject
|
|
* app.scene.addChild(button)
|
|
*
|
|
* @class
|
|
* @extends Popup
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/popupmenu.html|DocTest}
|
|
*/
|
|
class PopupMenu$1 extends Popup {
|
|
|
|
/**
|
|
* Creates an instance of a PopupMenu.
|
|
*
|
|
* @constructor
|
|
* @param {object} [opts] - An options object to specify to style and behaviour of the modal.
|
|
* @param {object[]} [opts.items=[]] - A list of the menu items. Each item must be of type object.
|
|
* If an object has a label property, a PIXI.Text object is created (using the textStyle property).
|
|
* If an object hasn't a label property, it must contain a content property which has to be a
|
|
* PIXI.DisplayObject.
|
|
* @param {number} [opts.margin=Theme.margin / 2] - The app where the modal belongs to.
|
|
* @param {object} [opts.textStyle=Theme.textStyle] - The color of the background.
|
|
* @param {boolean} [opts.closeOnPopup=true] - The opacity of the background.
|
|
*/
|
|
constructor(opts = {}) {
|
|
|
|
const theme = Theme.fromString(opts.theme);
|
|
|
|
opts = Object.assign({}, {
|
|
items: [],
|
|
margin: theme.margin / 2,
|
|
textStyle: theme.textStyle,
|
|
closeOnPopup: true
|
|
}, opts);
|
|
|
|
super(opts);
|
|
}
|
|
|
|
/**
|
|
* Creates children and instantiates everything.
|
|
*
|
|
* @private
|
|
* @return {PopupMenu} A reference to the popupmenu for chaining.
|
|
*/
|
|
setup() {
|
|
|
|
// content
|
|
//-----------------
|
|
const content = new PIXI.Container();
|
|
|
|
let y = 0;
|
|
for (let item of this.opts.items) {
|
|
|
|
let object = null;
|
|
|
|
if (item.label) {
|
|
object = new PIXI.Text(item.label, item.textStyle || this.opts.textStyle);
|
|
} else {
|
|
object = item.content;
|
|
}
|
|
|
|
object.y = y;
|
|
|
|
if (item.action) {
|
|
if (item.disabled) {
|
|
object.alpha = .5;
|
|
} else {
|
|
object.interactive = true;
|
|
object.buttonMode = true;
|
|
}
|
|
object.on('pointerover', e => {
|
|
TweenLite.to(object, this.theme.fast, {alpha: .83, overwrite: 'none'});
|
|
});
|
|
object.on('pointerout', e => {
|
|
TweenLite.to(object, this.theme.fast, {alpha: 1, overwrite: 'none'});
|
|
});
|
|
object.on('pointerup', e => {
|
|
item.action.call(object, e, object);
|
|
if (this.opts.closeOnAction) {
|
|
this.hide();
|
|
}
|
|
});
|
|
}
|
|
|
|
content.addChild(object);
|
|
|
|
y += object.height + this.opts.margin;
|
|
}
|
|
|
|
this.opts.content = content;
|
|
|
|
super.setup();
|
|
}
|
|
}
|
|
|
|
/* global Quad */
|
|
|
|
/**
|
|
* Class that represents a PixiJS Volatile.
|
|
*
|
|
* @example
|
|
* const app = new PIXIApp({
|
|
* view: canvas,
|
|
* width: 900,
|
|
* height: 250
|
|
* }).setup().run()
|
|
*
|
|
* const button = new Button({
|
|
* label: 'Volatile!',
|
|
* action: () => {
|
|
* new Volatile({
|
|
* object: button,
|
|
* direction: 'right',
|
|
* destroyOnComplete: false
|
|
* })
|
|
* }
|
|
* })
|
|
*
|
|
* app.scene.addChild(button)
|
|
*
|
|
* @class
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/volatile.html|DocTest}
|
|
*/
|
|
class Volatile {
|
|
|
|
/**
|
|
* Creates an instance of a Volatile.
|
|
*
|
|
* @constructor
|
|
* @param {object} [opts] - An options object to specify to style and behaviour of the modal.
|
|
* @param {number} [opts.id=auto generated] - The id of the tooltip.
|
|
* @param {PIXI.DisplayObject|PIXI.DisplayObject[]} opts.object - The object where the volatile should be applied to.
|
|
* @param {string} [opts.direction=top] - The animation direction. Possible values: top, right, bottom, left.
|
|
* @param {function} [opts.onStart] - A function which is executed when the volatile animation starts.
|
|
* @param {function} [opts.onComplete] - A function which is executed when the volatile animation finishes.
|
|
* @param {number} [opts.distance=160] - The animation distance.
|
|
* @param {number} [opts.duration=1.5] - The duration of the animation in seconds.
|
|
* @param {object} [opts.ease=Quad.easeOut] - The easing of the animation, see {@link https://greensock.com/docs/Easing}
|
|
* @param {boolean} [opts.destroyOnComplete=true] - Should the object be destroyed after the volatile animation?
|
|
*/
|
|
constructor(opts = {}) {
|
|
|
|
const theme = Theme.fromString(opts.theme);
|
|
this.theme = theme;
|
|
|
|
this.opts = Object.assign({}, {
|
|
id: PIXI.utils.uid(),
|
|
object: null,
|
|
direction: 'top', // top, right, bottom, left
|
|
onStart: null,
|
|
onComplete: null,
|
|
distance: 160,
|
|
duration: 1.5,
|
|
ease: Quad.easeOut,
|
|
destroyOnComplete: true
|
|
}, opts);
|
|
|
|
this.id = this.opts.id;
|
|
|
|
if (!Array.isArray(this.opts.object)) {
|
|
this.opts.object = [this.opts.object];
|
|
}
|
|
|
|
this.objects = this.opts.object;
|
|
|
|
// setup
|
|
//-----------------
|
|
this.setup();
|
|
|
|
// layout
|
|
//-----------------
|
|
this.layout();
|
|
|
|
// run
|
|
//-----------------
|
|
this.run();
|
|
}
|
|
|
|
/**
|
|
* Creates children and instantiates everything.
|
|
*
|
|
* @private
|
|
* @return {Volatile} A reference to the volatile for chaining.
|
|
*/
|
|
setup() {
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Should be called to refresh the layout of the volatile. Can be used after resizing.
|
|
*
|
|
* @return {Volatile} A reference to the volatile for chaining.
|
|
*/
|
|
layout() {
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Starts the volatile animation.
|
|
*
|
|
* @private
|
|
* @return {Volatile} A reference to the volatile for chaining.
|
|
*/
|
|
run() {
|
|
|
|
for (let object of this.objects) {
|
|
|
|
let x = object.x;
|
|
let y = object.y;
|
|
|
|
switch (this.opts.direction) {
|
|
case 'top':
|
|
y -= this.opts.distance;
|
|
break
|
|
case 'right':
|
|
x += this.opts.distance;
|
|
break
|
|
case 'bottom':
|
|
y += this.opts.distance;
|
|
break
|
|
case 'left':
|
|
x -= this.opts.distance;
|
|
break
|
|
}
|
|
|
|
TweenLite.to(object, this.opts.duration, {
|
|
x,
|
|
y,
|
|
alpha: 0,
|
|
ease: this.opts.ease,
|
|
overwrite: 'all',
|
|
onStart: () => {
|
|
if (this.opts.onStart) {
|
|
this.opts.onStart.call(object, object);
|
|
}
|
|
},
|
|
onComplete: () => {
|
|
|
|
if (this.opts.onComplete) {
|
|
this.opts.onComplete.call(object, object);
|
|
}
|
|
|
|
if (this.opts.destroyOnComplete) {
|
|
object.destroy({children: true});
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
return this
|
|
}
|
|
}
|
|
|
|
/* globals */
|
|
|
|
/**
|
|
* Class that represents a PixiJS List.
|
|
*
|
|
* @example
|
|
* const elephant1 = PIXI.Sprite.fromImage('./assets/elephant-1.jpg')
|
|
* const elephant2 = PIXI.Sprite.fromImage('./assets/elephant-2.jpg')
|
|
*
|
|
* // Create the list
|
|
* const list = new List([elephant1, elephant2])
|
|
*
|
|
* app.scene.addChild(list)
|
|
*
|
|
* @class
|
|
* @extends PIXI.Container
|
|
* @see {@link http://pixijs.download/dev/docs/PIXI.Container.html|PixiJS Container}
|
|
* @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/list.html|DocTest}
|
|
*/
|
|
class List extends PIXI.Container {
|
|
|
|
/**
|
|
* Creates an instance of a Flippable.
|
|
*
|
|
* @constructor
|
|
* @param {PIXI.DisplayObject[]} items - An array of PIXI.DisplayObjects.
|
|
* @param {object} [opts] - An options object which can contain the following properties.
|
|
* @param {number} [opts.width] - The width of the list. If the items are larger than this width, the overflow
|
|
* will be hidden.
|
|
* @param {number} [opts.height] - The height of the list. If the items are larger than this height, the overflow
|
|
* will be hidden.
|
|
* @param {number} [opts.padding=10] - The inner spacing (distance from one item to the previous/next item).
|
|
* @param {number} [opts.margin=10] - The outer spacing (distance from one item to the border).
|
|
* @param {string} [opts.orientation=vertical] - The orientation of the button group. Can be horizontal or vertical.
|
|
* @param {string} [opts.align=left] - The horizontal position of the items. Possible values are
|
|
* left, center and right.
|
|
* @param {string} [opts.verticalAlign=middle] - The vertical position of the items. Possible values are
|
|
* top, middle and bottom.
|
|
*/
|
|
constructor(items = [], opts = {}) {
|
|
|
|
super();
|
|
|
|
this.opts = Object.assign({}, {
|
|
padding: 10,
|
|
margin: 10,
|
|
orientation: 'vertical',
|
|
align: 'left',
|
|
verticalAlign: 'middle',
|
|
width: null,
|
|
height: null
|
|
}, opts);
|
|
|
|
this.__items = items;
|
|
this.__dragging = false;
|
|
|
|
// setup
|
|
//--------------------
|
|
this.setup();
|
|
}
|
|
|
|
/**
|
|
* Creates children and instantiates everything.
|
|
*
|
|
* @private
|
|
* @return {List} A reference to the list for chaining.
|
|
*/
|
|
setup() {
|
|
|
|
// inner container
|
|
//--------------------
|
|
const container = new PIXI.Container();
|
|
this.addChild(container);
|
|
this.container = container;
|
|
|
|
// mask
|
|
//--------------------
|
|
const mask = new PIXI.Graphics();
|
|
this.addChild(mask);
|
|
this.__mask = mask;
|
|
|
|
// add items
|
|
//--------------------
|
|
for(let item of this.__items) {
|
|
container.addChild(item);
|
|
}
|
|
|
|
// interaction
|
|
//--------------------
|
|
this.interactive = this.opts.width || this.opts.height;
|
|
this.on('pointerdown', this.onStart.bind(this));
|
|
this.on('pointermove', this.onMove.bind(this));
|
|
this.on('pointerup', this.onEnd.bind(this));
|
|
this.on('pointercancel', this.onEnd.bind(this));
|
|
this.on('pointerout', this.onEnd.bind(this));
|
|
this.on('pointerupoutside', this.onEnd.bind(this));
|
|
|
|
this.layout();
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Replaces the existing items and relayouts the list.
|
|
*
|
|
* @param {PIXI.DisplayObject[]} items - An array of PIXI.DisplayObjects.
|
|
* @return {List} A reference to the list for chaining.
|
|
*/
|
|
setItems(items) {
|
|
this.container.removeChildren();
|
|
this.__items = items;
|
|
for(let item of this.__items) {
|
|
this.container.addChild(item);
|
|
}
|
|
this.layout();
|
|
}
|
|
|
|
/**
|
|
* Should be called to refresh the layout of the list (the width or the height).
|
|
*
|
|
* @return {List} A reference to the list for chaining.
|
|
*/
|
|
layout() {
|
|
|
|
const margin = this.opts.margin;
|
|
|
|
let x = margin;
|
|
let y = margin;
|
|
|
|
for (let item of this.__items) {
|
|
|
|
item.x = x;
|
|
item.y = y;
|
|
|
|
if (this.opts.orientation === 'vertical') {
|
|
y += item.height + this.opts.padding;
|
|
} else {
|
|
x += item.width + this.opts.padding;
|
|
}
|
|
}
|
|
|
|
// vertical
|
|
//--------------------
|
|
if (this.opts.orientation === 'vertical') {
|
|
switch (this.opts.align) {
|
|
case 'center':
|
|
this.__items.forEach(it => it.x = margin + this.width / 2 - it.width / 2);
|
|
break
|
|
case 'right':
|
|
this.__items.forEach(it => it.x = margin + this.width - it.width);
|
|
break
|
|
default:
|
|
this.__items.forEach(it => it.x = margin);
|
|
break
|
|
}
|
|
|
|
if (this.opts.height) {
|
|
const mask = this.__mask;
|
|
mask.clear();
|
|
mask.beginFill(0x000);
|
|
mask.drawRect(0, 0, this.width + 2 * margin, this.opts.height);
|
|
this.mask = mask;
|
|
|
|
this.interactive = this.innerHeight > this.opts.height;
|
|
}
|
|
}
|
|
|
|
// horizontal
|
|
//--------------------
|
|
if (this.opts.orientation === 'horizontal') {
|
|
switch (this.opts.verticalAlign) {
|
|
case 'top':
|
|
this.__items.forEach(it => it.y = margin);
|
|
break
|
|
case 'bottom':
|
|
this.__items.forEach(it => it.y = margin + this.height - it.height);
|
|
break
|
|
default:
|
|
this.__items.forEach(it => it.y = margin + this.height / 2 - it.height / 2);
|
|
break
|
|
}
|
|
|
|
if (this.opts.width) {
|
|
const mask = this.__mask;
|
|
mask.clear();
|
|
mask.beginFill(0x000);
|
|
mask.drawRect(0, 0, this.opts.width, this.height + 2 * margin);
|
|
this.mask = mask;
|
|
|
|
this.interactive = this.innerWidth > this.opts.width;
|
|
}
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
get innerWidth() {
|
|
|
|
let size = 0;
|
|
|
|
this.__items.forEach(it => size += it.width);
|
|
size += this.opts.padding * (this.__items.length - 1);
|
|
size += 2 * this.opts.margin;
|
|
|
|
return size
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
get innerHeight() {
|
|
|
|
let size = 0;
|
|
|
|
this.__items.forEach(it => size += it.height);
|
|
size += this.opts.padding * (this.__items.length - 1);
|
|
size += 2 * this.opts.margin;
|
|
|
|
return size
|
|
}
|
|
|
|
/**
|
|
* Resizes the list.
|
|
*
|
|
* @param {number} widthOrHeight - The new width (if orientation is horizontal) or height (if orientation is vertical) of the list.
|
|
*/
|
|
resize(widthOrHeight) {
|
|
|
|
if (this.opts.orientation === 'horizontal') {
|
|
this.opts.width = widthOrHeight;
|
|
} else {
|
|
this.opts.height = widthOrHeight;
|
|
}
|
|
|
|
this.layout();
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @private
|
|
* @param {*} event
|
|
*/
|
|
onStart(event) {
|
|
|
|
this.__dragging = true;
|
|
|
|
this.capture(event);
|
|
|
|
this.__delta = {
|
|
x: this.container.position.x - event.data.global.x,
|
|
y: this.container.position.y - event.data.global.y
|
|
};
|
|
|
|
TweenLite.killTweensOf(this.container.position, {x: true, y: true});
|
|
ThrowPropsPlugin.track(this.container.position, 'x,y');
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @private
|
|
* @param {*} event
|
|
*/
|
|
onMove(event) {
|
|
|
|
if (this.__dragging) {
|
|
|
|
this.capture(event);
|
|
|
|
if (this.opts.orientation === 'horizontal') {
|
|
this.container.position.x = event.data.global.x + this.__delta.x;
|
|
} else {
|
|
this.container.position.y = event.data.global.y + this.__delta.y;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @private
|
|
* @param {*} event
|
|
*/
|
|
onEnd(event) {
|
|
|
|
if (this.__dragging) {
|
|
this.__dragging = false;
|
|
|
|
this.capture(event);
|
|
|
|
const throwProps = {};
|
|
|
|
if (this.opts.orientation === 'horizontal') {
|
|
let min = this.opts.width - this.innerWidth;
|
|
min = min > 0 ? 0 : min;
|
|
throwProps.x = {
|
|
velocity: 'auto',
|
|
min,
|
|
max: 0
|
|
};
|
|
} else {
|
|
let min = this.opts.height - this.innerHeight;
|
|
min = min > 0 ? 0 : min;
|
|
throwProps.y = {
|
|
velocity: 'auto',
|
|
min,
|
|
max: 0
|
|
};
|
|
}
|
|
|
|
ThrowPropsPlugin.to(this.container.position, {
|
|
throwProps,
|
|
ease: Strong.easeOut,
|
|
onComplete: () => ThrowPropsPlugin.untrack(this.container.position)
|
|
}, .8, .4);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Captures an event to inform InteractionMapper about processed events.
|
|
*
|
|
* @param {event|PIXI.InteractionEvent} event - The PIXI event to capture.
|
|
*/
|
|
capture(event) {
|
|
Events$1.capturedBy(event.data.originalEvent, this);
|
|
}
|
|
}
|
|
|
|
/* Needed to ensure that rollup.js includes class definitions and the classes
|
|
are visible inside doctests.
|
|
*/
|
|
window.PIXIApp = PIXIApp;
|
|
window.BlurFilter = BlurFilter;
|
|
window.FlipEffect = FlipEffect;
|
|
window.Flippable = Flippable;
|
|
window.DeepZoomInfo = DeepZoomInfo;
|
|
window.DeepZoomImage = DeepZoomImage;
|
|
window.Popover = Popover;
|
|
window.ScatterContainer = ScatterContainer;
|
|
window.DisplayObjectScatter = DisplayObjectScatter;
|
|
window.Command = Command;
|
|
window.RecorderTools = RecorderTools;
|
|
window.Timeline = Timeline;
|
|
window.AppTest = AppTest;
|
|
window.Theme = Theme;
|
|
window.Button = Button;
|
|
window.ButtonGroup = ButtonGroup;
|
|
window.Slider = Slider;
|
|
window.Switch = Switch;
|
|
window.Popup = Popup;
|
|
window.PopupMenu = PopupMenu$1;
|
|
window.Modal = Modal;
|
|
window.Volatile = Volatile;
|
|
window.Message = Message;
|
|
window.Tooltip = Tooltip;
|
|
window.Badge = Badge;
|
|
window.Progress = Progress;
|
|
window.List = List;
|
|
window.LabeledGraphics = LabeledGraphics;
|
|
window.FontInfo = FontInfo;
|
|
|
|
}());
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"all.js","sources":["theme.js","progress.js","abstractpopup.js","tooltip.js","badge.js","../events.js","button.js","buttongroup.js","popup.js","modal.js","message.js","../utils.js","app.js","blurfilter.js","../interface.js","../interaction.js","../capabilities.js","../scatter.js","../flippable.js","deepzoom/tile.js","deepzoom/loader.js","deepzoom/tiles.js","deepzoom/image.js","flipeffect.js","flippable.js","popover.js","scatter.js","test.js","labeledgraphics.js","timeline.js","slider.js","switch.js","popupmenu.js","volatile.js","list.js","bundle.js"],"sourcesContent":["/**\n * Class that represents a PixiJS Theme.\n *\n * @example\n * // Create the theme\n * const yellow = new Theme({\n *     fill: 0xfecd2d,\n *     fillActive: 0xfe9727,\n *     strokeActive: 0xfecd2d,\n *     strokeActiveWidth: 4,\n *     textStyle: {\n *         fill: 0x5ec7f8\n *     },\n *     textStyleActive: {\n *         fill: 0x5954d3\n *     },\n *     textStyleLarge: {\n *         fontSize: 36\n *     }\n * })\n *\n * // Create the app and apply the new theme to it\n * const app = new PIXIApp({\n *     view: canvas,\n *     width: 450,\n *     height: 150,\n *     theme: yellow\n * }).setup().run()\n *\n * @class\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/theme.html|DocTest}\n */\nexport default class Theme {\n\n    /**\n     * Creates an instance of a Theme.\n     *\n     * @constructor\n     * @param {object} [opts] - An options object to specify to style and behaviour of the theme.\n     * @param {number} [opts.margin=10] - The outer spacing (distance to other objects) from the border.\n     * @param {number} [opts.padding=10] - The inner spacing (distance from icon and/or label) to the border.\n     * @param {number} [opts.radius=4] - The radius used when drawing a rounded rectangle.\n     * @param {number} [opts.fast=0.25] - The duration of time when it has to be fast.\n     * @param {number} [opts.normal=0.5] - The duration of time when it has to be normal.\n     * @param {number} [opts.slow=1] - The duration of time when it has to be slow.\n     * @param {number} [opts.primaryColor=0x5ec7f8] - The primary color of the theme.\n     * @param {number} [opts.color1=0x282828] - The first color of the theme. For example used for the background.\n     * @param {number} [opts.color2=0xf6f6f6] - The second color of the theme. For example used for the border.\n     * @param {number} [opts.fill=color1] - The color of the background as a hex value.\n     * @param {number} [opts.fillAlpha=1] - The alpha value of the background.\n     * @param {number} [opts.fillActive=color1] - The color of the background when activated.\n     * @param {number} [opts.fillActiveAlpha=1] - The alpha value of the background when activated.\n     * @param {number} [opts.stroke=color2] - The color of the border as a hex value.\n     * @param {number} [opts.strokeWidth=0.6] - The width of the border in pixel.\n     * @param {number} [opts.strokeAlpha=1] - The alpha value of the border.\n     * @param {number} [opts.strokeActive=color2] - The color of the border when activated.\n     * @param {number} [opts.strokeActiveWidth=0.6] - The width of the border in pixel when activated.\n     * @param {number} [opts.strokeActiveAlpha=1] - The alpha value of the border when activated.\n     * @param {number} [opts.iconColor=color2] - The color of the icon (set by the tint property) as a hex value.\n     * @param {number} [opts.iconColorActive=colorPrimary] - The color of the icon when activated.\n     * @param {number} [opts.background=color1] - The color of a background for a component (e.g. at the Modal class).\n     * @param {object} [opts.textStyle={}] - A textstyle object for the styling of text. See PIXI.TextStyle\n     *     for possible options. Default object:\n     * @param {string} [opts.textStyle.fontFamily=\"Avenir Next\", \"Open Sans\", \"Segoe UI\", ...] - The font family.\n     * @param {string} [opts.textStyle.fontWeight=400] - The font weight.\n     * @param {number} [opts.textStyle.fontSize=16] - The font size.\n     * @param {number} [opts.textStyle.fill=color2] - The fill color.\n     * @param {number} [opts.textStyle.stroke=color1] - The stroke color.\n     * @param {number} [opts.textStyle.strokeThickness=0] - The thickness of the stroke.\n     * @param {number} [opts.textStyle.miterLimit=1] - The meter limit.\n     * @param {string} [opts.textStyle.lineJoin=round] - The line join.\n     * @param {object} [opts.textStyleActive=textStyle + {fill: primaryColor}] - A textstyle object which is used\n     *     for actived text.\n     * @param {object} [opts.textStyleSmall=textStyle + {fontSize: -= 3}] - A textstyle object which is used for\n     *     small text.\n     * @param {object} [opts.textStyleSmallActive=textStyleSmall + {fill: primaryColor}] - A textstyle object which\n     *     is used for small actived text.\n     * @param {object} [opts.textStyleLarge=textStyle + {fontSize: += 3}] - A textstyle object which is used for\n     *     large text.\n     * @param {object} [opts.textStyleLargeActive=textStyleLarge + {fill: primaryColor}] - A textstyle object which\n     *     is used for large actived text.\n     */\n    constructor(opts = {}) {\n\n        const colorPrimary = opts.primaryColor != null ? opts.primaryColor : 0x5ec7f8               // blue\n        const color1 = opts.color1 != null ? opts.color1 : 0x282828                                 // black\n        const color2 = opts.color2 != null ? opts.color2 : 0xf6f6f6                                 // white\n\n        this.opts = Object.assign({}, {\n            margin: 12,\n            padding: 12,\n            radius: 4,\n            fast: .25,\n            normal: .5,\n            slow: 1,\n            primaryColor: colorPrimary,\n            color1: color1,\n            color2: color2,\n            fill: color1,\n            fillAlpha: 1,\n            fillActive: color1,\n            fillActiveAlpha: 1,\n            stroke: color2,\n            strokeWidth: .6,\n            strokeAlpha: 1,\n            strokeActive: color2,\n            strokeActiveWidth: .6,\n            strokeActiveAlpha: 1,\n            iconColor: color2,\n            iconColorActive: colorPrimary,\n            background: color1\n        }, opts)\n\n        // Set textStyle and variants\n        this.opts.textStyle = Object.assign({}, {\n            fontFamily: '\"Avenir Next\", \"Open Sans\", \"Segoe UI\", \"Roboto\", \"Helvetica Neue\", -apple-system, system-ui, BlinkMacSystemFont, Arial, sans-serif !default',\n            fontWeight: '500',\n            fontSize: 18,\n            fill: color2,\n            stroke: color1,\n            strokeThickness: 0,\n            miterLimit: 1,\n            lineJoin: 'round'\n        }, this.opts.textStyle)\n        this.opts.textStyleSmall = Object.assign({}, this.opts.textStyle, {fontSize: this.opts.textStyle.fontSize - 3}, this.opts.textStyleSmall)\n        this.opts.textStyleLarge = Object.assign({}, this.opts.textStyle, {fontSize: this.opts.textStyle.fontSize + 3}, this.opts.textStyleLarge)\n        this.opts.textStyleActive = Object.assign({}, this.opts.textStyle, {fill: this.opts.primaryColor}, this.opts.textStyleActive)\n        this.opts.textStyleSmallActive = Object.assign({}, this.opts.textStyleSmall, {fill: this.opts.primaryColor}, this.opts.textStyleSmallActive)\n        this.opts.textStyleLargeActive = Object.assign({}, this.opts.textStyleLarge, {fill: this.opts.primaryColor}, this.opts.textStyleLargeActive)\n\n        Object.assign(this, this.opts)\n    }\n\n    /**\n     * Factory function\n     *\n     * @static\n     * @param {string} theme=dark - The name of the theme to load.\n     * @return {Theme} Returns a newly created Theme object.\n     */\n    static fromString(theme) {\n\n        if (theme && typeof theme === 'object') {\n            return theme\n        }\n\n        switch (theme) {\n            case 'light':\n                return new ThemeLight()\n            case 'red':\n                return new ThemeRed()\n            default:\n                return new ThemeDark()\n        }\n    }\n}\n\n/**\n * Class that represents a PixiJS ThemeDark.\n *\n * @example\n * // Create the app with a new dark theme\n * const app = new PIXIApp({\n *     view: canvas,\n *     width: 450,\n *     height: 150,\n *     theme: new ThemeDark()\n * }).setup().run()\n *\n * @class\n * @extends Theme\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/theme.html|DocTest}\n */\nexport class ThemeDark extends Theme {\n\n}\n\n/**\n * Class that represents a PixiJS ThemeLight.\n * The color1 is set to 0xf6f6f6, color2 to 0x282828.\n *\n * @example\n * // Create the app with a new light theme\n * const app = new PIXIApp({\n *     view: canvas,\n *     width: 450,\n *     height: 150,\n *     theme: new ThemeLight()\n * }).setup().run()\n *\n * @class\n * @extends Theme\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/theme.html|DocTest}\n */\nexport class ThemeLight extends Theme {\n\n    /**\n     * Creates an instance of a ThemeLight.\n     *\n     * @constructor\n     */\n    constructor() {\n\n        super({color1: 0xf6f6f6, color2: 0x282828})\n    }\n}\n\n/**\n * Class that represents a PixiJS ThemeRed.\n * The primaryColor is set to 0xd92f31.\n *\n * @example\n * // Create the app with a new red theme\n * const app = new PIXIApp({\n *     view: canvas,\n *     width: 450,\n *     height: 150,\n *     theme: new ThemeRed()\n * }).setup().run()\n *\n * @class\n * @extends Theme\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/theme.html|DocTest}\n */\nexport class ThemeRed extends Theme {\n\n    /**\n     * Creates an instance of a ThemeRed.\n     *\n     * @constructor\n     */\n    constructor() {\n\n        super({primaryColor: 0xd92f31})\n    }\n}\n","import Theme from './theme.js'\n\n/**\n * Class that represents a PixiJS Progress.\n * \n * @example\n * // Create the progress\n * const progress = new Progress({\n *     app: app\n * })\n *\n * // Add the progress to a DisplayObject\n * app.scene.addChild(progress)\n *\n * @class\n * @extends PIXI.Container\n * @see {@link http://pixijs.download/dev/docs/PIXI.Container.html|PIXI.Container}\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/progress.html|DocTest}\n */\nexport default class Progress extends PIXI.Container {\n    \n    /**\n     * Creates an instance of a Progress.\n     * \n     * @constructor\n     * @param {object} [opts] - An options object to specify to style and behaviour of the progress.\n     * @param {number} [opts.id=auto generated] - The id of the progress.\n     * @param {PIXIApp} [opts.app=window.app] - The app where the progress belongs to.\n     * @param {number} [opts.width] - The width of the progress bar. When not set, the width is the size of the app\n     *     minus 2 * opts.margin.\n     * @param {number} [opts.height=2] - The height of the progress bar.\n     * @param {string|Theme} [opts.theme=dark] - The theme to use for this progress. Possible values are dark, light, red\n     *     or a Theme object.\n     * @param {number} [opts.margin=100] - The outer spacing to the edges of the app.\n     * @param {number} [opts.padding=0] - The inner spacing (distance from icon and/or label) to the border.\n     * @param {number} [opts.fill=Theme.fill] - The color of the progress background as a hex value.\n     * @param {number} [opts.fillAlpha=Theme.fillAlpha] - The alpha value of the background.\n     * @param {number} [opts.fillActive=Theme.primaryColor] - The color of the progress background when activated.\n     * @param {number} [opts.fillActiveAlpha=Theme.fillActiveAlpha] - The alpha value of the background when activated.\n     * @param {number} [opts.stroke=Theme.stroke] - The color of the border as a hex value.\n     * @param {number} [opts.strokeWidth=0] - The width of the border in pixel.\n     * @param {number} [opts.strokeAlpha=Theme.strokeAlpha] - The alpha value of the border.\n     * @param {number} [opts.strokeActive=Theme.strokeActive] - The color of the border when activated.\n     * @param {number} [opts.strokeActiveWidth=0] - The width of the border in pixel when activated.\n     * @param {number} [opts.strokeActiveAlpha=Theme.strokeActiveAlpha] - The alpha value of the border when activated.\n     * @param {boolean} [opts.background=false] - The alpha value of the border when activated.\n     * @param {number} [opts.backgroundFill=Theme.background] - A textstyle object for the styling of the label. See PIXI.TextStyle\n     *     for possible options.\n     * @param {number} [opts.backgroundFillAlpha=1] - A textstyle object for the styling of the label when the\n     *     progress is activated. See PIXI.TextStyle for possible options.\n     * @param {number} [opts.radius=Theme.radius] - The radius of the four corners of the progress (which is a rounded rectangle).\n     * @param {boolean} [opts.destroyOnComplete=true] - Should the progress bar destroy itself after reaching 100 %?\n     * @param {boolean} [opts.visible=true] - Is the progress initially visible (property visible)?\n     */\n    constructor(opts = {}) {\n\n        super()\n        \n        const theme = Theme.fromString(opts.theme)\n        this.theme = theme\n\n        this.opts = Object.assign({}, {\n            id: PIXI.utils.uid(),\n            app: window.app,\n            width: null,\n            height: 2,\n            margin: 100,\n            padding: 0,\n            fill: theme.fill,\n            fillAlpha: theme.fillAlpha,\n            fillActive: theme.primaryColor,\n            fillActiveAlpha: theme.fillActiveAlpha,\n            stroke: theme.stroke,\n            strokeWidth: 0,\n            strokeAlpha: theme.strokeAlpha,\n            strokeActive: theme.strokeActive,\n            strokeActiveWidth: 0,\n            strokeActiveAlpha: theme.strokeActiveAlpha,\n            background: false,\n            backgroundFill: theme.background,\n            backgroundFillAlpha: 1,\n            radius: theme.radius,\n            destroyOnComplete: true,\n            visible: true\n        }, opts)\n\n        this.id = this.opts.id\n\n        this.background = null\n        this.bar = null\n        this.barActive = null\n\n        this.alpha = 0\n        \n        this.visible = this.opts.visible\n\n        this._progress = 0\n\n        // setup\n        //-----------------\n        this.setup()\n\n        // layout\n        //-----------------\n        this.layout()\n    }\n    \n    /**\n     * Creates children and instantiates everything.\n     * \n     * @private\n     * @return {Progress} A reference to the progress for chaining.\n     */\n    setup() {\n\n        // interaction\n        //-----------------\n        this.on('added', e => {\n            this.show()\n        })\n\n        // background\n        //-----------------\n        if (this.opts.background) {\n            const background = new PIXI.Graphics()\n            this.background = background\n            this.addChild(background)\n        }\n\n        // bar\n        //-----------------\n        const bar = new PIXI.Graphics()\n        this.bar = bar\n        this.addChild(bar)\n\n        const barActive = new PIXI.Graphics()\n        this.barActive = barActive\n        this.bar.addChild(barActive)\n\n        return this\n    }\n    \n    /**\n     * Should be called to refresh the layout of the progress. Can be used after resizing.\n     * \n     * @return {Progress} A reference to the progress for chaining.\n     */\n    layout() {\n\n        const width = this.opts.app.size.width\n        const height = this.opts.app.size.height\n\n        // background\n        //-----------------\n        if (this.opts.background) {\n            this.background.clear()\n            this.background.beginFill(this.opts.backgroundFill, this.opts.backgroundFillAlpha)\n            this.background.drawRect(0, 0, width, height)\n            this.background.endFill()\n        }\n\n        this.draw()\n\n        return this\n    }\n    \n    /**\n     * Draws the canvas.\n     * \n     * @private\n     * @return {Progress} A reference to the progress for chaining.\n     */\n    draw() {\n\n        this.bar.clear()\n        this.barActive.clear()\n\n        this.drawBar()\n        this.drawBarActive()\n\n        return this\n    }\n    \n    /**\n     * Draws the bar.\n     * \n     * @private\n     * @return {Progress} A reference to the progress for chaining.\n     */\n    drawBar() {\n\n        const width = this.opts.app.size.width\n        const height = this.opts.app.size.height\n\n        this.radius = this.opts.radius\n        if ((this.radius * 2) > this.opts.height) {\n            this.radius = this.opts.height / 2\n        }\n\n        const wantedWidth = this.opts.width || (width - (2 * this.opts.margin))\n        const wantedHeight = this.opts.height\n\n        this.bar.lineStyle(this.opts.strokeWidth, this.opts.stroke, this.opts.strokeAlpha)\n        this.bar.beginFill(this.opts.fill, this.opts.fillAlpha)\n        if (this.radius > 1) {\n            this.bar.drawRoundedRect(0, 0, wantedWidth, wantedHeight, this.radius)\n        } else {\n            this.bar.drawRect(0, 0, wantedWidth, wantedHeight)\n        }\n        this.bar.endFill()\n        \n        this.bar.x = width / 2 - this.bar.width / 2\n        this.bar.y = height / 2 - this.bar.height / 2\n\n        return this\n    }\n    \n    /**\n     * Draws the active bar.\n     * \n     * @private\n     * @return {Progress} A reference to the progress for chaining.\n     */\n    drawBarActive() {\n\n        const wantedWidth = this.bar.width - (2 * this.opts.padding)\n        const wantedHeight = this.bar.height - (2 * this.opts.padding)\n        \n        const barActiveWidth = wantedWidth * this._progress / 100\n\n        this.barActive.lineStyle(this.opts.strokeActiveWidth, this.opts.strokeActive, this.opts.strokeActiveAlpha)\n        this.barActive.beginFill(this.opts.fillActive, this.opts.fillActiveAlpha)\n        if (barActiveWidth > 0) {\n            if (this.radius > 1) {\n                this.barActive.drawRoundedRect(0, 0, barActiveWidth, wantedHeight, this.radius)\n            } else {\n                this.barActive.drawRect(0, 0, barActiveWidth, wantedHeight)\n            }\n        }\n        this.barActive.endFill()\n\n        this.barActive.x = this.opts.padding\n        this.barActive.y = this.opts.padding\n\n        return this\n    }\n    \n    /**\n     * Shows the progress (sets his alpha values to 1).\n     * \n     * @return {Progress} A reference to the progress for chaining.\n     */\n    show() {\n        TweenLite.to(this, this.theme.fast, {alpha: 1})\n\n        return this\n    }\n    \n    /**\n     * Hides the progress (sets his alpha values to 1).\n     * \n     * @return {Progress} A reference to the progress for chaining.\n     */\n    hide() {\n        TweenLite.to(this, this.theme.fast, {alpha: 0, onComplete: () => this.visible = false})\n\n        return this\n    }\n    \n    /**\n     * Gets or sets the progress. Has to be a number between 0 and 100.\n     * \n     * @member {number}\n     */\n    get progress() {\n        return this._progress\n    }\n    set progress(value) {\n\n        value = Math.round(value)\n\n        if (value < 0) {\n            value = 0\n        }\n\n        if (value > 100) {\n            value = 100\n        }\n\n        TweenLite.to(this, this.theme.normal, {\n            _progress: value,\n            onUpdate: () => this.draw(),\n            onComplete: () => {\n                if (value === 100 && this.opts.destroyOnComplete) {\n                    TweenLite.to(this, this.theme.fast, {\n                        alpha: 0,\n                        onComplete: () => this.destroy({children: true})\n                    })\n                }\n            }\n        })\n    }\n}\n","import Theme from './theme.js'\n\n/**\n * Class that represents a PixiJS AbstractPopup.\n * The class is used for various other Popup-like classes\n * like Popup, Message, Tooltip...\n *\n * @class\n * @abstract\n * @extends PIXI.Graphics\n * @see {@link http://pixijs.download/dev/docs/PIXI.Graphics.html|PIXI.Graphics}\n */\nexport default class AbstractPopup extends PIXI.Graphics {\n    \n    /**\n     * Creates an instance of an AbstractPopup (only for internal use).\n     * \n     * @constructor\n     * @param {object} [opts] - An options object to specify to style and behaviour of the popup.\n     * @param {number} [opts.id=auto generated] - The id of the popup.\n     * @param {number} [opts.x=0] - The x position of the popup. Can be also set after creation with popup.x = 0.\n     * @param {number} [opts.y=0] - The y position of the popup. Can be also set after creation with popup.y = 0.\n     * @param {string|Theme} [opts.theme=dark] - The theme to use for this popup. Possible values are dark, light, red\n     *     or a Theme object.\n     * @param {string|number|PIXI.Text} [opts.header] - The heading inside the popup as a string, a number (will be\n     *     converted to a text) or as a PIXI.Text object.\n     * @param {string|number|PIXI.DisplayObject} [opts.content] - A text, a number (will be converted to a text) or\n     *     an PIXI.DisplayObject as the content of the popup.\n     * @param {number} [opts.minWidth=320] - The minimum width of the popup.\n     * @param {number} [opts.minHeight=130] - The minimum height of the popup.\n     * @param {number} [opts.padding=Theme.padding] - The inner spacing (distance from header and content) the the border.\n     * @param {number} [opts.fill=Theme.fill] - The color of the button background as a hex value.\n     * @param {number} [opts.fillAlpha=Theme.fillAlpha] - The alpha value of the background.\n     * @param {number} [opts.stroke=Theme.stroke] - The color of the border as a hex value.\n     * @param {number} [opts.strokeWidth=Theme.strokeWidth] - The width of the border in pixel.\n     * @param {number} [opts.strokeAlpha=Theme.strokeAlpha] - The alpha value of the border.\n     * @param {object} [opts.headerStyle=Theme.textStyleLarge] - A textstyle object for the styling of the header. See PIXI.TextStyle\n     *     for possible options.\n     * @param {object} [opts.textStyle=Theme.textStyleSmall] - A textstyle object for the styling of the text. See PIXI.TextStyle\n     *     for possible options.\n     * @param {number} [opts.radius=Theme.radius] - The radius of the four corners of the popup (which is a rounded rectangle).\n     * @param {hiddenCallback} [opts.onHidden] - Executed when the popup gets hidden.\n     * @param {boolean} [opts.visible=true] - Is the popup initially visible (property visible)?\n     * @param {string} [opts.orientation] - When set to portrait, the popup cannot be displayed in landscape mode. When set\n     *     to landscape, the popup cannot be displayed in portrait mode.\n     */\n    constructor(opts = {}) {\n\n        super()\n        \n        const theme = Theme.fromString(opts.theme)\n        this.theme = theme\n\n        this.opts = Object.assign({}, {\n            id: PIXI.utils.uid(),\n            x: 0,\n            y: 0,\n            header: null,                       // null or null\n            content: null,                      // null or String or PIXI.DisplayObject\n            minWidth: 320,\n            minHeight: 130,\n            maxWidth: null,\n            padding: theme.padding,\n            fill: theme.fill,\n            fillAlpha: theme.fillAlpha,\n            stroke: theme.stroke,\n            strokeWidth: theme.strokeWidth,\n            strokeAlpha: theme.strokeAlpha,\n            headerStyle: theme.textStyleLarge,\n            textStyle: theme.textStyleSmall,\n            radius: theme.radius,\n            onHidden: null,\n            visible: true,\n            orientation: null\n        }, opts)\n\n        this.id = this.opts.id\n\n        this.headerStyle = new PIXI.TextStyle(this.opts.headerStyle)\n        this.textStyle = new PIXI.TextStyle(this.opts.textStyle)\n\n        if (this.opts.maxWidth) {\n            this.headerStyle.wordWrap = true\n            this.headerStyle.wordWrapWidth = this.opts.maxWidth - (2 * this.opts.padding)\n\n            this.textStyle.wordWrap = true\n            this.textStyle.wordWrapWidth = this.opts.maxWidth - (2 * this.opts.padding)\n        }\n\n        this.alpha = 0\n        this.visible = this.opts.visible\n\n        this._header = null\n        this._content = null\n\n        // position\n        this.x = this.opts.x\n        this.y = this.opts.y\n\n        // padding\n        this.innerPadding = this.opts.padding * 1.5\n        \n        // interaction\n        //-----------------\n        this.interactive = true\n        this.on('added', e => {\n            this.show()\n        })\n    }\n    \n    /**\n     * Creates the framework and instantiates everything.\n     * \n     * @private\n     * @return {AbstractPopup} A reference to the popup for chaining.\n     */\n    setup() {\n\n        // position\n        //-----------------\n        this.sy = this.opts.padding\n\n        // header\n        //-----------------\n        if (this.opts.header != null) {\n\n            let header = null\n\n            if (this.opts.header instanceof PIXI.Text) {\n                header = this.opts.header\n            } else if (typeof this.opts.header === 'number') {\n                header =  new PIXI.Text(this.opts.header.toString(), this.headerStyle)\n            } else {\n                header =  new PIXI.Text(this.opts.header, this.headerStyle)\n            }\n\n            header.x = this.opts.padding\n            header.y = this.sy\n\n            this.addChild(header)\n\n            this.sy += header.height\n\n            this._header = header\n        }\n\n        if (this.opts.header && this.opts.content) {\n            this.sy += this.innerPadding\n        }\n\n        // content\n        //-----------------\n        if (this.opts.content != null) {\n\n            let content = null\n\n            if (typeof this.opts.content === 'string') {\n                content = new PIXI.Text(this.opts.content, this.textStyle)\n            } else if (typeof this.opts.content === 'number') {\n                content = new PIXI.Text(this.opts.content.toString(), this.textStyle)\n            } else {\n                content = this.opts.content\n            }\n\n            content.x = this.opts.padding\n            content.y = this.sy\n\n            this.sy += content.height\n\n            this.addChild(content)\n\n            this._content = content\n        }\n\n        return this\n    }\n    \n    /**\n     * Should be called to refresh the layout of the popup. Can be used after resizing.\n     * \n     * @return {AbstractPopup} A reference to the popup for chaining.\n     */\n    layout() {\n        \n        // wanted width & wanted height\n        //-----------------\n        const padding = this.opts.padding\n        const size = this.getInnerSize()\n        const width = size.width + (2 * padding)\n        const height = size.height + (2 * padding)\n\n        this.wantedWidth = Math.max(width, this.opts.minWidth)\n        this.wantedHeight = Math.max(height, this.opts.minHeight)\n        \n        if (this.opts.maxWidth) {\n            this.wantedWidth = Math.min(this.wantedWidth, this.opts.maxWidth)\n        }\n\n        if (this.opts.radius * 2 > this.wantedWidth) {\n            this.wantedWidth = this.opts.radius * 2\n        }\n\n        if (this.opts.radius * 2 > this.wantedHeight) {\n            this.wantedHeight = this.opts.radius * 2\n        }\n\n        switch (this.opts.orientation) {\n            case 'portrait':\n                if (this.wantedWidth > this.wantedHeight) {\n                    this.wantedHeight = this.wantedWidth\n                }\n                break\n            case 'landscape':\n                if (this.wantedHeight > this.wantedWidth) {\n                    this.wantedWidth = this.wantedHeight\n                }\n                break\n        }\n\n        this.draw()\n\n        return this\n    }\n    \n    /**\n     * Draws the canvas.\n     * \n     * @private\n     * @return {AbstractPopup} A reference to the popup for chaining.\n     */\n    draw() {\n\n        const square = Math.round(this.wantedWidth) === Math.round(this.wantedHeight)\n        const diameter = Math.round(this.opts.radius * 2)\n\n        this.clear()\n        this.lineStyle(this.opts.strokeWidth, this.opts.stroke, this.opts.strokeAlpha)\n        this.beginFill(this.opts.fill, this.opts.fillAlpha)\n        if (square && diameter === this.wantedWidth) {\n            this.drawCircle(this.wantedWidth / 2, this.wantedHeight / 2, this.opts.radius)\n        } else {\n            this.drawRoundedRect(0, 0, this.wantedWidth, this.wantedHeight, this.opts.radius)\n        }\n        this.endFill()\n\n        return this\n    }\n    \n    /**\n     * Calculates the size of the children of the AbstractPopup.\n     * Cannot use getBounds() because it is not updated when children\n     * are removed.\n     * \n     * @private\n     * @returns {object} An JavaScript object width the keys width and height.\n     */\n    getInnerSize() {\n\n        let width = 0\n        let height = 0\n\n        if (this._header) {\n            width = this._header.width\n            height = this._header.height\n        }\n\n        if (this._header && this._content) {\n            height += this.innerPadding\n        }\n\n        if (this._content) {\n            width = Math.max(width, this._content.width)\n            height += this._content.height\n        }\n\n        return {width, height}\n    }\n    \n    /**\n     * Shows the popup (sets his alpha values to 1).\n     * \n     * @param {callback} [cb] - Executed when show animation was completed.\n     * @return {AbstractPopup} A reference to the popup for chaining.\n     */\n    show(cb) {\n\n        TweenLite.to(this, this.theme.fast, {\n            alpha: 1,\n            onComplete: () => {\n                if (cb) {\n                    cb.call(this)\n                }\n            }\n        })\n\n        return this\n    }\n    \n    /**\n     * Hides the popup (sets his alpha values to 0).\n     * \n     * @param {callback} [cb] - Executed when hide animation was completed.\n     * @return {AbstractPopup} A reference to the popup for chaining.\n     */\n    hide(cb) {\n\n        TweenLite.to(this, this.theme.fast, {\n            alpha: 0,\n            onComplete: () => {\n                this.visible = false\n                if (cb) {\n                    cb.call(this)\n                }\n            }\n        })\n\n        if (this.opts.onHidden) {\n            this.opts.onHidden.call(this, this)\n        }\n\n        return this\n    }\n\n    /**\n     * Sets or gets the header. The getter always returns a PIXI.Text object. The setter can receive\n     * a string, a number or a PIXI.Text object.\n     * \n     * @member {string|number|PIXI.Text}\n     */\n    get header() {\n        return this._header\n    }\n    set header(value) {\n        if (this._header) {\n            this._header.destroy()\n        }\n        this.opts.header = value\n        this.setup().layout()\n    }\n    \n    /**\n     * Sets or gets the content. The getter always returns an PIXI.DisplayObject. The setter can receive\n     * a string, a number or a PIXI.DisplayObject.\n     * \n     * @member {string|number|PIXI.DisplayObject}\n     */\n    get content() {\n        return this._content\n    }\n    set content(value) {\n        if (this._content) {\n            this._content.destroy()\n        }\n        this.opts.content = value\n        this.setup().layout()\n    }\n}\n","import Theme from './theme.js'\nimport AbstractPopup from './abstractpopup.js'\n\n/**\n * Class that represents a PixiJS Tooltip.\n * \n * @example\n * // Create the app\n * const app = new PIXIApp({\n *     view: canvas,\n *     width: 900,\n *     height: 250\n * }).setup().run()\n * \n * // Add an DisplayObject to the app\n * const circle = new PIXI.Graphics()\n * circle.beginFill(0x5251a3)\n * circle.drawCircle(50, 50, 40)\n * app.scene.addChild(circle)\n * \n * const tooltip = new Tooltip({\n *     object: circle,\n *     container: app.scene,\n *     content: 'Das Gesetz ist der Freund des Schwachen.'\n * })\n *\n * @class\n * @extends AbstractPopup\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/tooltip.html|DocTest}\n */\nexport default class Tooltip extends AbstractPopup {\n    \n    /**\n     * Creates an instance of a Tooltip.\n     * \n     * @constructor\n     * @param {object} [opts] - An options object to specify to style and behaviour of the tooltip.\n     * @param {number} [opts.minWidth=0] - The minimum width of the tooltip.\n     * @param {number} [opts.minHeight=0] - The minimum height of the tooltip.\n     * @param {number} [opts.padding=Theme.padding / 2] - The inner spacing of the tooltip.\n     * @param {PIXI.DisplayObject} opts.object - The object, where the tooltip should be displayed.\n     * @param {PIXI.DisplayObject} [opts.container=object] - The container where the tooltip should be attached to.\n     * @param {number} [opts.offsetLeft=8] - The horizontal shift of the tooltip.\n     * @param {number} [opts.offsetTop=-8] - The vertical shift of the tooltip.\n     * @param {number} [opts.delay=0] - A delay, after which the tooltip should be opened.\n     */\n    constructor(opts = {}) {\n        \n        const theme = Theme.fromString(opts.theme)\n        \n        opts = Object.assign({}, {\n            minWidth: 0,\n            minHeight: 0,\n            padding: theme.padding / 2,\n            object: null,\n            container: null,\n            offsetLeft: 8,\n            offsetTop: -8,\n            delay: 0\n        }, opts)\n\n        opts.container = opts.container || opts.object\n\n        super(opts)\n\n        // setup\n        //-----------------\n        this.setup()\n\n        // layout\n        //-----------------\n        this.layout()\n    }\n    \n    /**\n     * Creates children and instantiates everything.\n     * \n     * @private\n     * @return {Tooltip} A reference to the tooltip for chaining.\n     */\n    setup() {\n\n        super.setup()\n\n        // bind events this\n        //-----------------\n        this.interactive = true\n\n        let mouseoverTooltip = false\n        \n        this.on('mouseover', e => {\n            mouseoverTooltip = true\n        })\n\n        this.on('mouseout', e => {\n            mouseoverTooltip = false\n            if (!mouseoverObject) {\n                this.hide(() => {\n                    this.opts.container.removeChild(this)\n                })\n            }\n        })\n        \n        // bind events object\n        //-----------------\n        const object = this.opts.object\n        object.interactive = true\n\n        let mouseoverObject = false\n\n        object.on('mouseover', e => {\n\n            this.timeout = window.setTimeout(() => {\n                mouseoverObject = true\n                this.visible = true\n                this.opts.container.addChild(this)\n                this.setPosition(e)\n            }, this.opts.delay * 1000)\n        })\n\n        object.on('mousemove', e => {\n            if (mouseoverObject) {\n                this.setPosition(e)\n            }\n        })\n\n        object.on('mouseout', e => {\n            mouseoverObject = false\n            window.clearTimeout(this.timeout)\n            if (!mouseoverTooltip) {\n                this.hide(() => {\n                    this.opts.container.removeChild(this)\n                })\n            }\n        })\n\n        return this\n    }\n    \n    /**\n     * Calculates and sets the position of the tooltip.\n     * \n     * @private\n     * @return {Tooltip} A reference to the tooltip for chaining.\n     */\n    setPosition(e) {\n\n        const position = e.data.getLocalPosition(this.opts.container)\n\n        this.x = position.x + this.opts.offsetLeft\n        this.y = position.y + this.opts.offsetTop - this.height\n\n        return this\n    }\n}\n","import Theme from './theme.js'\nimport AbstractPopup from './abstractpopup.js'\nimport Tooltip from './tooltip.js'\n\n/**\n * Class that represents a PixiJS Badge.\n * \n * @example\n * // Create the app\n * const app = new PIXIApp({\n *     view: canvas,\n *     width: 900,\n *     height: 250\n * }).setup().run()\n * \n * // Add an DisplayObject to the app\n * const circle = new PIXI.Graphics()\n * circle.beginFill(0x5251a3)\n * circle.drawCircle(50, 50, 40)\n * app.scene.addChild(circle)\n * \n * const badge1 = new Badge({\n *     object: circle,\n *     container: app.scene,\n *     content: 'Das Gesetz ist der Freund des Schwachen.'\n * })\n *\n * @class\n * @extends AbstractPopup\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/badge.html|DocTest}\n */\nexport default class Badge extends AbstractPopup {\n    \n    /**\n     * Creates an instance of a Badge.\n     * \n     * @constructor\n     * @param {object} [opts] - An options object to specify to style and behaviour of the badge.\n     * @param {number} [opts.minWidth=0] - The minimum width of the badge.\n     * @param {number} [opts.minHeight=0] - The minimum height of the badge.\n     * @param {number} [opts.padding=Theme.padding / 2] - The inner spacing of the badge.\n     * @param {string|object} [opts.tooltip] - A string for the label of the tooltip or an object to configure the tooltip\n     *     to display.\n     */\n    constructor(opts = {}) {\n        \n        const theme = Theme.fromString(opts.theme)\n        \n        opts = Object.assign({}, {\n            minWidth: 0,\n            minHeight: 0,\n            padding: theme.padding / 2,\n            tooltip: null\n        }, opts)\n\n        super(opts)\n\n        this.tooltip = null\n\n        // setup\n        //-----------------\n        this.setup()\n\n        // layout\n        //-----------------\n        this.layout()\n    }\n    \n    /**\n     * Creates children and instantiates everything.\n     *\n     * @private\n     * @override\n     * @return {Badge} A reference to the badge for chaining.\n     */\n    setup() {\n\n        super.setup()\n\n        // tooltip\n        //-----------------\n        if (this.opts.tooltip) {\n            if (typeof this.opts.tooltip === 'string') {\n                this.tooltip = new Tooltip({object: this, content: this.opts.tooltip})\n            } else {\n                this.opts.tooltip = Object.assign({}, {object: this}, this.opts.tooltip)\n                this.tooltip = new Tooltip(this.opts.tooltip)\n            }\n        }\n\n        return this\n    }\n    \n    /**\n     * Should be called to refresh the layout of the badge. Can be used after resizing.\n     * \n     * @override\n     * @return {Badge} A reference to the badge for chaining.\n     */\n    layout() {\n\n        super.layout()\n\n        this.content.x = this.width / 2 - this.content.width / 2 - this.opts.strokeWidth / 2\n        this.content.y = this.height / 2 - this.content.height / 2 - this.opts.strokeWidth / 2\n\n        return this\n    }\n}\n","\nexport default class Events {\n\n    static stop(event) {\n        event.preventDefault()\n        event.stopPropagation()\n    }\n\n    static extractPoint(event) {\n        switch (event.constructor.name) {\n            case 'TouchEvent':\n                for (let i = 0; i < event.targetTouches.length; i++) {\n                    let t = event.targetTouches[i]\n                    return { x: t.clientX, y: t.clientY }\n                }\n                break\n            default:\n                return { x: event.clientX, y: event.clientY }\n        }\n    }\n\n    static isCaptured(event) {\n        if (event.__capturedBy)\n            return true\n        return false\n    }\n\n    static capturedBy(event, obj) {\n        event.__capturedBy = obj\n    }\n\n    static isMouseDown(event) {\n        // Attempts to clone the which attribute of events failed in WebKit. May\n        // be this is a bug or a security feature. Workaround: we introduce\n        // a mouseDownSubstitute attribute that can be assigned to cloned\n        // events after instantiation.\n        if (Reflect.has(event, 'mouseDownSubstitute'))\n            return event.mouseDownSubstitute\n        return event.buttons || event.which\n    }\n\n    static isSimulatedEvent(event) {\n        return Reflect.has(event, 'mouseDownSubstitute')\n    }\n\n    static isMouseRightClick(event) {\n        return event.buttons || event.which\n    }\n\n    static extractTouches(targets) {\n        let touches = []\n        for (let i = 0; i < targets.length; i++) {\n            let t = targets[i]\n            touches.push({\n                targetSelector: this.selector(t.target),\n                identifier: t.identifier,\n                screenX: t.screenX,\n                screenY: t.screenY,\n                clientX: t.clientX,\n                clientY: t.clientY,\n                pageX: t.pageX,\n                pageY: t.pageY\n            })\n        }\n        return touches\n    }\n\n    static createTouchList(targets) {\n        let touches = []\n        for (let i = 0; i < targets.length; i++) {\n            let t = targets[i]\n            let touchTarget = document.elementFromPoint(t.pageX, t.pageY)\n            let touch = new Touch(undefined, touchTarget, t.identifier,\n                t.pageX, t.pageY, t.screenX, t.screenY)\n            touches.push(touch)\n        }\n        return new TouchList(...touches)\n    }\n\n    static extractEvent(timestamp, event) {\n        let targetSelector = this.selector(event.target)\n        let infos = {\n            type: event.type,\n            time: timestamp,\n            constructor: event.constructor,\n            data: {\n                targetSelector: targetSelector,\n                view: event.view,\n                mouseDownSubstitute: event.buttons || event.which, // which cannot be cloned directly\n                bubbles: event.bubbles,\n                cancelable: event.cancelable,\n                screenX: event.screenX,\n                screenY: event.screenY,\n                clientX: event.clientX,\n                clientY: event.clientY,\n                layerX: event.layerX,\n                layerY: event.layerY,\n                pageX: event.pageX,\n                pageY: event.pageY,\n                ctrlKey: event.ctrlKey,\n                altKey: event.altKey,\n                shiftKey: event.shiftKey,\n                metaKey: event.metaKey\n            }\n        }\n        if (event.type.startsWith('touch')) {\n            // On Safari-WebKit the TouchEvent has layerX, layerY coordinates\n            let data = infos.data\n            data.targetTouches = this.extractTouches(event.targetTouches)\n            data.changedTouches = this.extractTouches(event.changedTouches)\n            data.touches = this.extractTouches(event.touches)\n        }\n        if (event.type.startsWith('pointer')) {\n            let data = infos.data\n            data.pointerId = event.pointerId\n            data.pointerType = event.pointerType\n        }\n        if (Events.debug) {\n            Events.extracted.push(this.toLine(event))\n        }\n        return infos\n    }\n\n    static cloneEvent(type, constructor, data) {\n        if (type.startsWith('touch')) {\n            // We need to find target from layerX, layerY\n            //var target = document.querySelector(data.targetSelector)\n            // elementFromPoint(data.layerX, data.layerY)\n            //data.target = target\n            data.targetTouches = this.createTouchList(data.targetTouches)\n            data.changedTouches = this.createTouchList(data.changedTouches)\n            data.touches = this.createTouchList(data.touches)\n        }\n        // We need to find target from pageX, pageY which are only\n        // available after construction. They seem to getter items.\n\n        let clone = Reflect.construct(constructor, [type, data])\n        clone.mouseDownSubstitute = data.mouseDownSubstitute\n        return clone\n    }\n\n    static simulateEvent(type, constructor, data) {\n        data.target = document.querySelector(data.targetSelector)\n        let clone = this.cloneEvent(type, constructor, data)\n        if (data.target != null) {\n            data.target.dispatchEvent(clone)\n        }\n        if (Events.debug) {\n            Events.simulated.push(this.toLine(clone))\n        }\n    }\n\n    static toLine(event) {\n        return `${event.type} #${event.target.id} ${event.clientX} ${event.clientY}`\n        let result = event.type\n        let selector = this.selector(event.target)\n        result += ' selector: ' + selector\n        if (event.target != document.querySelector(selector))\n            console.log('Cannot resolve', selector)\n        let keys = ['layerX', 'layerY', 'pageX', 'pageY', 'clientX', 'clientY']\n        for (let key of keys) {\n            try {\n                result += ' ' + key + ':' + event[key]\n            }\n            catch (e) {\n                console.log('Invalid key: ' + key)\n            }\n        }\n        return result\n    }\n\n    static compareExtractedWithSimulated() {\n        var diffs = 0\n        if (this.extracted.length != this.simulated.length) {\n            alert('Unequal length of extracted [' + this.extracted.length +\n                '] and simulated events [' + this.simulated.length + '].')\n            diffs += 1\n        }\n        else {\n            for (let i = 0; i < this.extracted.length; i++) {\n                var extracted = this.extracted[i]\n                var simulated = this.simulated[i]\n                if (extracted != simulated) {\n                    console.log('Events differ:' + extracted + '|' + simulated)\n                    diffs += 1\n                }\n            }\n        }\n    }\n\n    static selector(context) {\n        return OptimalSelect.select(context)\n    }\n\n    static reset() {\n        this.extracted = []\n        this.simulated = []\n    }\n\n    static resetSimulated() {\n        this.simulated = []\n    }\n\n    static showExtractedEvents(event) {\n        if (!event.shiftKey) {\n            return\n        }\n        if (this.popup == null) {\n            let element = document.createElement('div')\n            Elements.setStyle(element, {\n                position: 'absolute',\n                width: '480px',\n                height: '640px',\n                overflow: 'auto',\n                backgroundColor: 'lightgray'\n            })\n            document.body.appendChild(element)\n            this.popup = element\n        }\n        this.popup.innerHTML = ''\n        for (let line of this.extracted) {\n            let div = document.createElement('div')\n            div.innerHTML = line\n            this.popup.appendChild(div)\n        }\n        let div = document.createElement('div')\n        div.innerHTML = '------------ Simulated -----------'\n        this.popup.appendChild(div)\n        for (let line of this.simulated) {\n            let div = document.createElement('div')\n            div.innerHTML = line\n            this.popup.appendChild(div)\n        }\n        Elements.setStyle(this.popup,\n            { left: event.clientX + 'px', top: event.clientY + 'px' })\n    }\n}\n\nEvents.popup = null\nEvents.debug = true\nEvents.extracted = []\nEvents.simulated = []\nEvents.simulationRunning = false\n\nexport class EventRecorder {\n\n    constructor() {\n        this.recording = []\n        this.recorded = []\n        this.step = 0\n    }\n\n    record(event) {\n        let length = this.recording.length\n        if (length == 0) {\n            this.startTime = event.timeStamp\n            Events.reset()\n        }\n        else {\n            let last = this.recording[length - 1]\n            if (event.timeStamp < last.time) {\n                console.log('warning: wrong temporal order')\n            }\n        }\n        let t = event.timeStamp - this.startTime\n        this.recording.push(Events.extractEvent(t, event))\n    }\n\n    stopRecording() {\n        this.recorded = this.recording\n        this.recording = []\n        console.log('Recorded ' + this.recorded.length + ' events')\n    }\n\n    startReplay(whileCondition = null, onComplete = null) {\n        this.step = 0\n        Events.resetSimulated()\n        console.log('Start replay')\n        Events.simulationRunning = true\n        this.replay(whileCondition, onComplete)\n    }\n\n    replay(whileCondition = null, onComplete = null) {\n        if (this.step < this.recorded.length) {\n            let { type, time, constructor, data } = this.recorded[this.step]\n            Events.simulateEvent(type, constructor, data)\n            \n            this.step += 1\n            let dt = 0\n            if (this.step < this.recorded.length) {\n                var next = this.recorded[this.step]\n                dt = next.time - time\n                if (dt < 0) {\n                    console.log('warning: wrong temporal order')\n                }\n            }\n            if (whileCondition == null || whileCondition()) {\n                let delta = Math.round(dt)\n                setTimeout(() => this.replay(whileCondition, onComplete), delta)\n            }\n        }\n        else {\n            console.log('Played ' + this.step + ' events' + onComplete)\n            Events.simulationRunning = false\n            if (onComplete != null) {\n                onComplete()\n            }\n            //Events.compareExtractedWithSimulated()\n        }\n    }\n}\n\n","import Theme from './theme.js'\nimport Tooltip from './tooltip.js'\nimport Badge from './badge.js'\nimport Events from '../events.js'\n\n/**\n * Callback for the button action.\n *\n * @callback actionCallback\n * @param {object} event - The event object.\n * @param {Button} button - A reference to the button (also this refers to the button).\n */\n\n/**\n * Callback for the button beforeAction.\n *\n * @callback beforeActionCallback\n * @param {object} event - The event object.\n * @param {Button} button - A reference to the button (also this refers to the button).\n */\n\n/**\n * Callback for the button afterAction.\n *\n * @callback afterActionCallback\n * @param {object} event - The event object.\n * @param {Button} button - A reference to the button (also this refers to the button).\n */\n\n/**\n * Class that represents a PixiJS Button.\n *\n * @example\n * // Create the button\n * const button = new Button({\n *     label: 'My Button',\n *     action: () => console.log('Button was clicked')\n * })\n *\n * // Add the button to a DisplayObject\n * app.scene.addChild(button)\n *\n * @class\n * @extends PIXI.Container\n * @see {@link http://pixijs.download/dev/docs/PIXI.Container.html|PIXI.Container}\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/button.html|DocTest}\n */\nexport default class Button extends PIXI.Container {\n\n    /**\n     * Creates an instance of a Button.\n     *\n     * @constructor\n     * @param {object} [opts] - An options object to specify to style and behaviour of the button.\n     * @param {number} [opts.id=auto generated] - The id of the button.\n     * @param {string} [opts.label] - The label of the button.\n     * @param {number} [opts.x=0] - The x position of the button. Can be also set after creation with button.x = 0.\n     * @param {number} [opts.y=0] - The y position of the button. Can be also set after creation with button.y = 0.\n     * @param {string|Theme} [opts.theme=dark] - The theme to use for this button. Possible values are dark, light, red\n     *     or a Theme object.\n     * @param {number} [opts.minWidth=44] - The minimum width of the button.\n     * @param {number} [opts.minHeight=44] - The minimum height of the button.\n     * @param {number} [opts.padding=Theme.padding] - The inner spacing (distance from icon and/or label) to the border.\n     * @param {string|PIXI.DisplayObject} [opts.icon] - The icon of the button. Can be a predefined one, an URL or an PIXI.DisplayObject.\n     * @param {string|PIXI.DisplayObject} [opts.iconActive=icon] - The icon of the button when activated. Can be a predefined one, an URL or an PIXI.DisplayObject.\n     * @param {string} [opts.iconPosition=left] - The position of the icon in relation to the label. Can be left or right.\n     * @param {number} [opts.iconColor=Theme.iconColor] - The color of the icon (set by the tint property) as a hex value.\n     * @param {number} [opts.iconColorActive=Theme.iconColorActive] - The color of the icon when activated.\n     * @param {number} [opts.fill=Theme.fill] - The color of the button background as a hex value.\n     * @param {number} [opts.fillAlpha=Theme.fillAlpha] - The alpha value of the background.\n     * @param {number} [opts.fillActive=Theme.fillActive] - The color of the button background when activated.\n     * @param {number} [opts.fillActiveAlpha=Theme.fillActiveAlpha] - The alpha value of the background when activated.\n     * @param {number} [opts.stroke=Theme.stroke] - The color of the border as a hex value.\n     * @param {number} [opts.strokeWidth=Theme.strokeWidth] - The width of the border in pixel.\n     * @param {number} [opts.strokeAlpha=Theme.strokeAlpha] - The alpha value of the border.\n     * @param {number} [opts.strokeActive=Theme.strokeActive] - The color of the border when activated.\n     * @param {number} [opts.strokeActiveWidth=Theme.strokeActiveWidth] - The width of the border in pixel when activated.\n     * @param {number} [opts.strokeActiveAlpha=Theme.strokeActiveAlpha] - The alpha value of the border when activated.\n     * @param {object} [opts.textStyle=Theme.textStyle] - A textstyle object for the styling of the label. See PIXI.TextStyle\n     *     for possible options.\n     * @param {number} [opts.textStyleActive=Theme.textStyleActive] - A textstyle object for the styling of the label when the\n     *     button is activated. See PIXI.TextStyle for possible options.\n     * @param {string} [opts.style=default] - A shortcut for styling options. Possible values are default, link.\n     * @param {number} [opts.radius=Theme.radius] - The radius of the four corners of the button (which is a rounded rectangle).\n     * @param {boolean} [opts.disabled=false] - Is the button disabled? When disabled, the button has a lower alpha value\n     *     and cannot be clicked (interactive is set to false).\n     * @param {boolean} [opts.active=false] - Is the button initially active?\n     * @param {actionCallback} [opts.action] - Executed when the button was triggered (by pointerup).\n     * @param {beforeActionCallback} [opts.beforeAction] - Executed before the main action is triggered.\n     * @param {afterActionCallback} [opts.afterAction] - Executed after the main action was triggered.\n     * @param {string} [opts.type=default] - The type of the button. Can be default or checkbox. When the type is\n     *     checkbox, the active state is toggled automatically.\n     * @param {string} [opts.align=center] - The horizontal position of the label and the icon. Possible values are\n     *     left, center and right. Only affects the style when the minWidth is bigger than the width of the icon and label.\n     * @param {string} [opts.verticalAlign=middle] - The vertical position of the label and the icon. Possible values are\n     *     top, middle and button. Only affects the style when the minHeight is bigger than the height of the icon and label.\n     * @param {string|object} [opts.tooltip] - A string for the label of the tooltip or an object to configure the tooltip\n     *     to display.\n     * @param {string|object} [opts.badge] - A string for the label of the badge or an object to configure the badge to display.\n     *     If the parameter is an object, all badge options can be set plus the following:\n     * @param {string} [opts.badge.align=right] - The horizontal alignment of the badge. Possible values: left, center, right\n     * @param {string} [opts.badge.verticalAlign=top] - The vertical alignment of the badge. Possible values: top, middle, bottom\n     * @param {number} [opts.badge.offsetLeft=0] - The horizontal shift of the badge.\n     * @param {number} [opts.badge.offsetTop=0] - The vertical shift of the badge.\n     * @param {boolean} [opts.visible=true] - Is the button initially visible (property visible)?\n     */\n    constructor(opts = {}) {\n\n        super()\n\n        const theme = Theme.fromString(opts.theme)\n        this.theme = theme\n\n        this.opts = Object.assign({}, {\n            id: PIXI.utils.uid(),\n            label: null,\n            x: 0,\n            y: 0,\n            minWidth: 44,\n            minHeight: 44,\n            padding: theme.padding,\n            icon: undefined,\n            iconActive: undefined,\n            iconPosition: 'left',\n            iconColor: theme.iconColor,\n            iconColorActive: theme.iconColorActive,\n            fill: theme.fill,\n            fillAlpha: theme.fillAlpha,\n            fillActive: theme.fillActive,\n            fillActiveAlpha: theme.fillActiveAlpha,\n            stroke: theme.stroke,\n            strokeWidth: theme.strokeWidth,\n            strokeAlpha: theme.strokeAlpha,\n            strokeActive: theme.strokeActive,\n            strokeActiveWidth: theme.strokeActiveWidth,\n            strokeActiveAlpha: theme.strokeActiveAlpha,\n            textStyle: theme.textStyle,\n            textStyleActive: theme.textStyleActive,\n            style: 'default',\n            radius: theme.radius,\n            disabled: false,\n            active: false,\n            action: null,\n            beforeAction: null,\n            afterAction: null,\n            type: 'default',\n            align: 'center',\n            verticalAlign: 'middle',\n            tooltip: null,\n            badge: null,\n            visible: true\n        }, opts)\n\n        this.id = this.opts.id\n\n        if (typeof this.opts.icon === 'undefined' && typeof this.opts.iconActive !== 'undefined') {\n            this.opts.icon = this.opts.iconActive\n        } else if (typeof this.opts.icon !== 'undefined' && typeof this.opts.iconActive === 'undefined') {\n            this.opts.iconActive = this.opts.icon\n        }\n\n        if (this.opts.style === 'link') {\n            Object.assign(this.opts, {strokeAlpha: 0, strokeActiveAlpha: 0, fillAlpha: 0, fillActiveAlpha: 0})\n        }\n\n        this._active = null\n        this._disabled = null\n\n        this.iconInactive = null\n        this.iconActive = null\n        this.text = null\n\n        this.button = null\n        this.content = null\n\n        this.tooltip = null\n        this.badge = null\n\n        this.visible = this.opts.visible\n\n        // setup\n        //-----------------\n        this.setup()\n    }\n\n    /**\n     * Captures an event to inform InteractionMapper about processed events.\n     *\n     * @param {event|PIXI.InteractionEvent} event - The PIXI event to capture.\n     */\n    capture(event) {\n        Events.capturedBy(event.data.originalEvent, this)\n    }\n\n    /**\n     * Creates children and instantiates everything.\n     *\n     * @private\n     * @return {Button} A reference to the button for chaining.\n     */\n    setup() {\n\n        // Button\n        //-----------------\n        let button = new PIXI.Graphics()\n        this.button = button\n        this.addChild(button)\n\n        // Content\n        //-----------------\n        let content = new PIXI.Container()\n        this.content = content\n        this.addChild(content)\n\n        // Text\n        //-----------------\n        if (this.opts.label) {\n            this.text = new PIXI.Text(this.opts.label, this.opts.textStyle)\n        }\n\n        // Icon\n        //-----------------\n        if (this.opts.icon) {\n            this.iconInactive = this.loadIcon(this.opts.icon, this.opts.iconColor)\n        }\n\n        if (this.opts.iconActive) {\n            this.iconActive = this.loadIcon(this.opts.iconActive, this.opts.iconColorActive)\n        }\n\n        // interaction\n        //-----------------\n        this.button.on('pointerover', e => {\n            this.capture(e)\n            TweenLite.to([this.button, this.content], this.theme.fast, {alpha: .83, overwrite: 'none'})\n        })\n\n        this.button.on('pointermove', e => {\n            this.capture(e)\n        })\n\n        this.button.on('pointerout', e => {\n            this.capture(e)\n            TweenLite.to([this.button, this.content], this.theme.fast, {alpha: 1, overwrite: 'none'})\n        })\n\n        this.button.on('pointerdown', e => {\n            //this.capture(e)\n            TweenLite.to([this.button, this.content], this.theme.fast, {alpha: .7, overwrite: 'none'})\n        })\n\n        this.button.on('pointerup', e => {\n            this.capture(e)\n            if (this.opts.beforeAction) {\n                this.opts.beforeAction.call(this, e, this)\n            }\n\n            if (this.opts.action) {\n                this.opts.action.call(this, e, this)\n            }\n\n            TweenLite.to([this.button, this.content], this.theme.fast, {alpha: .83, overwrite: 'none'})\n\n            if (this.opts.type === 'checkbox') {\n                this.active = !this.active\n            }\n\n            if (this.opts.afterAction) {\n                this.opts.afterAction.call(this, e, this)\n            }\n        })\n\n        // disabled\n        //-----------------\n        this.disabled = this.opts.disabled\n\n        // active\n        //-----------------\n        this.active = this.opts.active      // calls .layout()\n\n        // tooltip\n        //-----------------\n        if (this.opts.tooltip) {\n            if (typeof this.opts.tooltip === 'string') {\n                this.tooltip = new Tooltip({object: this, content: this.opts.tooltip})\n            } else {\n                this.opts.tooltip = Object.assign({}, {object: this}, this.opts.tooltip)\n                this.tooltip = new Tooltip(this.opts.tooltip)\n            }\n        }\n\n        // badge\n        //-----------------\n        if (this.opts.badge) {\n            let opts = Object.assign({}, {\n                align: 'right',\n                verticalAlign: 'top',\n                offsetLeft: 0,\n                offsetTop: 0\n            })\n            if (typeof this.opts.badge === 'string') {\n                opts = Object.assign(opts, {content: this.opts.badge})\n            } else {\n                opts = Object.assign(opts, this.opts.badge)\n            }\n\n            const badge = new Badge(opts)\n\n            switch (opts.align) {\n                case 'left':\n                    badge.x = this.x - badge.width / 2 + opts.offsetLeft\n                    break\n                case 'center':\n                    badge.x = this.x + this.width / 2 - badge.width / 2 + opts.offsetLeft\n                    break\n                case 'right':\n                    badge.x = this.x + this.width - badge.width / 2 + opts.offsetLeft\n            }\n\n            switch (opts.verticalAlign) {\n                case 'top':\n                    badge.y = this.y - badge.height / 2 + opts.offsetTop\n                    break\n                case 'middle':\n                    badge.y = this.y + this.height / 2 - badge.height / 2 + opts.offsetTop\n                    break\n                case 'bottom':\n                    badge.y = this.y + this.height - badge.height / 2 + opts.offsetTop\n            }\n\n            this.addChild(badge)\n\n            this.badge = badge\n        }\n\n        // set position\n        //-----------------\n        this.position.set(this.opts.x, this.opts.y)\n\n        return this\n    }\n\n    /**\n     * Should be called to refresh the layout of the button. Can be used after resizing.\n     *\n     * @return {Button} A reference to the button for chaining.\n     */\n    layout() {\n\n        // Clear content\n        //-----------------\n        this.removeChild(this.content)\n        this.content = new PIXI.Container()\n        this.addChild(this.content)\n\n        // Set the icon\n        //-----------------\n        let icon = null\n\n        if (!this.active && this.iconInactive) {\n            icon = this.iconInactive\n        } else if (this.active && this.iconActive) {\n            icon = this.iconActive\n        }\n\n        // Set the text\n        //-----------------\n        if (this.text) {\n            this.text.position.set(0, 0)\n        }\n\n        // Width and Height\n        //-----------------\n        let width = 0\n        if (icon && this.text) {\n            width = icon.width + this.text.width + 3 * this.opts.padding\n        } else if (icon) {\n            width = icon.width + 2 * this.opts.padding\n        } else if (this.text) {\n            width = this.text.width + 2 * this.opts.padding\n        }\n\n        if (width < this.opts.minWidth) {\n            width = this.opts.minWidth\n        }\n\n        let height = 0\n        if (icon) {\n            height = icon.height + 2 * this.opts.padding\n        } else if (this.text) {\n            height = this.text.height + 2 * this.opts.padding\n        }\n\n        if (height < this.opts.minHeight) {\n            height = this.opts.minHeight\n        }\n\n        this._width = width\n        this._height = height\n\n        // Position icon and text\n        //-----------------\n        if (icon && this.text) {\n            if (this.opts.iconPosition === 'right') {\n                icon.x = this.text.width + this.opts.padding\n            } else {\n                this.text.x = icon.width + this.opts.padding\n            }\n            this.content.addChild(icon, this.text)\n        } else if (icon) {\n            this.content.addChild(icon)\n        } else if (this.text) {\n            this.content.addChild(this.text)\n        }\n\n        this.layoutInnerContent()\n        this.layoutContent()\n\n        this.icon = icon\n\n        // draw\n        //-----------------\n        this.draw()\n\n        return this\n    }\n\n    /**\n     * Calculates the positions of the content children (icon and/or text).\n     *\n     * @private\n     * @return {Button} A reference to the button for chaining.\n     */\n    layoutInnerContent() {\n\n        for (let child of this.content.children) {\n            switch (this.opts.verticalAlign) {\n                case 'top':\n                    child.y = 0\n                    break\n                case 'middle':\n                    child.y = this.content.height / 2 - child.height / 2\n                    break\n                case 'bottom':\n                    child.y = this.content.height - child.height\n                    break\n            }\n        }\n\n        return this\n    }\n\n    /**\n     * Sets the horizontal and vertical position of the content.\n     * Uses the option keys \"align\" and \"verticalAlign\".\n     *\n     * @private\n     * @return {Button} A reference to the button for chaining.\n     */\n    layoutContent() {\n\n        switch (this.opts.align) {\n            case 'left':\n                this.content.x = this.opts.padding\n                break\n            case 'center':\n                this.content.x = ((this._width - this.content.width) / 2)\n                break\n            case 'right':\n                this.content.x = this._width - this.opts.padding - this.content.width\n                break\n        }\n\n        switch (this.opts.verticalAlign) {\n            case 'top':\n                this.content.y = this.opts.padding\n                break\n            case 'middle':\n                this.content.y = (this._height - this.content.height) / 2\n                break\n            case 'bottom':\n                this.content.y = this._height - this.opts.padding - this.content.height\n                break\n        }\n\n        return this\n    }\n\n    /**\n     * Draws the canvas.\n     *\n     * @private\n     * @return {Button} A reference to the button for chaining.\n     */\n    draw() {\n\n        this.button.clear()\n        if (this.active) {\n            this.button.lineStyle(this.opts.strokeActiveWidth, this.opts.strokeActive, this.opts.strokeActiveAlpha)\n            this.button.beginFill(this.opts.fillActive, this.opts.fillActiveAlpha)\n        } else {\n            this.button.lineStyle(this.opts.strokeWidth, this.opts.stroke, this.opts.strokeAlpha)\n            this.button.beginFill(this.opts.fill, this.opts.fillAlpha)\n        }\n        this.button.drawRoundedRect(0, 0, this._width, this._height, this.opts.radius)\n        this.button.endFill()\n\n        return this\n    }\n\n    /**\n     * Gets or sets the active state.\n     *\n     * @member {boolean}\n     */\n    get active() {\n        return this._active\n    }\n    set active(value) {\n\n        this._active = value\n\n        if (this._active) {\n            if (this.text) {\n                this.text.style = this.opts.textStyleActive\n            }\n        } else {\n            if (this.text) {\n                this.text.style = this.opts.textStyle\n            }\n        }\n\n        this.layout()\n    }\n\n    /**\n     * Gets or sets the disabled state. When disabled, the button cannot be clicked.\n     *\n     * @member {boolean}\n     */\n    get disabled() {\n        return this._disabled\n    }\n    set disabled(value) {\n\n        this._disabled = value\n\n        if (this._disabled) {\n            this.button.interactive = false\n            this.button.buttonMode = false\n            this.button.alpha = .5\n            if (this.icon) {\n                this.icon.alpha = .5\n            }\n            if (this.text) {\n                this.text.alpha = .5\n            }\n        } else {\n            this.button.interactive = true\n            this.button.buttonMode = true\n            this.button.alpha = 1\n            if (this.icon) {\n                this.icon.alpha = 1\n            }\n            if (this.text) {\n                this.text.alpha = 1\n            }\n        }\n    }\n\n    /**\n     * Shows the button (sets his alpha values to 1).\n     *\n     * @return {Button} A reference to the button for chaining.\n     */\n    show() {\n\n        this.opts.strokeAlpha = 1\n        this.opts.strokeActiveAlpha = 1\n        this.opts.fillAlpha = 1\n        this.opts.fillActiveAlpha = 1\n\n        this.layout()\n\n        return this\n    }\n\n    /**\n     * Hides the button (sets his alpha values to 0).\n     *\n     * @return {Button} A reference to the button for chaining.\n     */\n    hide() {\n\n        this.opts.strokeAlpha = 0\n        this.opts.strokeActiveAlpha = 0\n        this.opts.fillAlpha = 0\n        this.opts.fillActiveAlpha = 0\n\n        this.layout()\n\n        return this\n    }\n\n    /**\n     * Loads an icon\n     *\n     * @private\n     * @param {string|PIXI.DisplayObject} icon - The icon to load.\n     * @param {number} color - The color of the icon (if not an PIXI.DisplayObject).\n     * @return {PIXI.DisplayObject} Return the icon as an PIXI.DisplayObject.\n     */\n    loadIcon(icon, color) {\n\n        let displayObject = null\n\n        if (icon instanceof PIXI.DisplayObject) {\n            displayObject = icon\n        } else {\n            let size = 17\n            if (this.text) {\n                size = this.text.height\n            } else if (this.opts.minHeight) {\n                size = this.opts.minHeight - (2 * this.opts.padding)\n            }\n\n            const url = Button.iconIsUrl(icon) ? icon : `../../assets/icons/png/flat/${icon}.png`\n            const iconTexture = PIXI.Texture.fromImage(url, true)\n\n            const sprite = new PIXI.Sprite(iconTexture)\n            sprite.tint = color\n            sprite.width = size\n            sprite.height = size\n\n            displayObject = sprite\n        }\n\n        return displayObject\n    }\n\n    /**\n     * Tests if an icon string is an url.\n     *\n     * @private\n     * @static\n     * @param {string} url - The url to test.\n     * @return {boolean} true if the url is an url to an image.\n     */\n    static iconIsUrl(url) {\n        return /\\.(png|svg|gif|jpg|jpeg|tif|tiff)$/i.test(url)\n    }\n\n    /**\n     * Gets or sets the color of the current icon (no matter how the status is). Changing the color, changes\n     * the tint property of the icon sprite.\n     *\n     * @member {number}\n     */\n    get iconColor() {\n        return this.icon ? this.icon.tint : null\n    }\n    set iconColor(value) {\n        if (this.icon) {\n            this.icon.tint = value\n        }\n    }\n}\n","import Theme from './theme.js'\nimport Button from './button.js'\n\n/**\n * Class that represents a PixiJS ButtonGroup.\n * \n * @example\n * // Create the button group\n * const buttonGroup = new ButtonGroup({\n *     buttons: [\n *         {label: 'Button 1', action: event => console.log(event)},\n *         {label: 'Button 2', action: event => console.log(event)},\n *         {label: 'Button 3', action: event => console.log(event)}\n *     ],\n *     minWidth: 100\n * })\n *\n * // Add the button group to a DisplayObject\n * app.scene.addChild(buttonGroup)\n *\n * @class\n * @extends PIXI.Graphics\n * @see {@link http://pixijs.download/dev/docs/PIXI.Graphics.html|PIXI.Graphics}\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/buttongroup.html|DocTest}\n */\nexport default class ButtonGroup extends PIXI.Graphics {\n\n    /**\n     * Creates an instance of a ButtonGroup.\n     * \n     * @constructor\n     * @param {object} [opts] - An options object to specify to style and behaviour of the button group.\n     * @param {number} [opts.id=auto generated] - The id of the button group.\n     * @param {number} [opts.x=0] - The x position of the button group. Can be also set after creation with buttonGroup.x = 0.\n     * @param {number} [opts.y=0] - The y position of the button group. Can be also set after creation with buttonGroup.y = 0.\n     * @param {object[]} [opts.buttons=[]] - An array of the buttons of the button group. One item of the array (one object)\n     *     can have exactly the same properties as an Button object when instantiating a Button. If a property of the button group\n     *     conflicts with a property of a button object, the value from the button object will be used.\n     * @param {string|Theme=} [opts.theme=dark] - The theme to use for this button group. Possible values are dark, light, red\n     *     or a Theme object.\n     * @param {number} [opts.minWidth=44] - Button: The minimum width of one button.\n     * @param {number} [opts.minHeight=44] - Button: The minimum height of one button.\n     * @param {number} [opts.padding=Theme.padding] - Button: The inner spacing (distance from icon and/or label) the the border.\n     * @param {number} [opts.margin=Theme.margin] - The outer spacing (distance from one button to the previous/next button).\n     * @param {string} [opts.iconPosition=left] - Button: The position of the icon in relation to the label. Can be left or right.\n     * @param {number} [opts.iconColor=Theme.iconColor] - Button: The color of the icon (set by the tint property) as a hex value.\n     * @param {number} [opts.iconColorActive=Theme.iconColorActive] - Button: The color of the icon when activated.\n     * @param {number} [opts.fill=Theme.fill] - Button: The color of the button background as a hex value.\n     * @param {number} [opts.fillAlpha=Theme.fillAlpha] - Button: The alpha value of the background.\n     * @param {number} [opts.fillActive=Theme.fillActive] - Button: The color of the button background when activated.\n     * @param {number} [opts.fillActiveAlpha=Theme.fillActiveAlpha] - Button: The alpha value of the background when activated.\n     * @param {number} [opts.stroke=Theme.stroke] - Button: The color of the border as a hex value.\n     * @param {number} [opts.strokeWidth=Theme.strokeWidth] - Button: The width of the border in pixel.\n     * @param {number} [opts.strokeAlpha=Theme.strokeAlpha] - Button: The alpha value of the border.\n     * @param {number} [opts.strokeActive=Theme.strokeActive] - Button: The color of the border when activated.\n     * @param {number} [opts.strokeActiveWidth=Theme.strokeActiveWidth] - Button: The width of the border in pixel when activated.\n     * @param {number} [opts.strokeActiveAlpha=Theme.strokeActiveAlpha] - Button: The alpha value of the border when activated.\n     * @param {object} [opts.textStyle=Theme.textStyle] - Button: A textstyle object for the styling of the label. See PIXI.TextStyle\n     *     for possible options.\n     * @param {number} [opts.textStyleActive=Theme.textStyleActive] - Button: A textstyle object for the styling of the label when the\n     *     button is activated. See PIXI.TextStyle for possible options.\n     * @param {string} [opts.style=default] - A shortcut for styling options. Possible values are default, link.\n     * @param {number} [opts.radius=Theme.radius] - Button: The radius of the four corners of the button (which is a rounded rectangle).\n     * @param {boolean} [opts.disabled=false] - Is the button group disabled? When disabled, the button group has a lower alpha value\n     *     and cannot be clicked (interactive of every button is set to false).\n     * @param {string} [opts.type=default] - The type of the button group. Can be default, checkbox or radio. When the type is\n     *     checkbox, the active state is toggled for each button automatically. When the type is radio, only one button can\n     *     be activated at the same time.\n     * @param {string} [opts.orientation=horizontal] - The orientation of the button group. Can be horizontal or vertical.\n     * @param {string} [opts.align=center] - Button: The horizontal position of the label and the icon. Possible values are\n     *     left, center and right. Only affects the style when the minWidth is bigger than the width of the icon and label.\n     * @param {string} [opts.verticalAlign=middle] - Button: The vertical position of the label and the icon. Possible values are\n     *     top, middle and bottom. Only affects the style when the minHeight is bigger than the height of the icon and label.\n     * @param {boolean} [opts.visible=true] - Is the button group initially visible (property visible)?\n     */\n    constructor(opts = {}) {\n\n        super()\n        \n        const theme = Theme.fromString(opts.theme)\n        this.theme = theme\n\n        this.opts = Object.assign({}, {\n            id: PIXI.utils.uid(),\n            x: 0,\n            y: 0,\n            buttons: [],\n            minWidth: 44,\n            minHeight: 44,\n            padding: theme.padding,\n            margin: theme.margin,\n            iconPosition: 'left',             // left, right\n            iconColor: theme.iconColor,\n            iconColorActive: theme.iconColorActive,\n            fill: theme.fill,\n            fillAlpha: theme.fillAlpha,\n            fillActive: theme.fillActive,\n            fillActiveAlpha: theme.fillActiveAlpha,\n            stroke: theme.stroke,\n            strokeWidth: theme.strokeWidth,\n            strokeAlpha: theme.strokeAlpha,\n            strokeActive: theme.strokeActive,\n            strokeActiveWidth: theme.strokeActiveWidth,\n            strokeActiveAlpha: theme.strokeActiveAlpha,\n            textStyle: theme.textStyle,\n            textStyleActive: theme.textStyleActive,\n            style: 'default',\n            radius: theme.radius,\n            disabled: null,\n            type: 'default',                   // default, checkbox, radio\n            orientation: 'horizontal',\n            align: 'center',                   // left, center, right\n            verticalAlign: 'middle',           // top, middle, bottom\n            visible: true\n        }, opts)\n\n        this.buttons = []\n\n        this._disabled = null\n        \n        this.visible = this.opts.visible\n\n        // setup\n        //-----------------\n        this.setup()\n\n        // layout\n        //-----------------\n        this.layout()\n    }\n    \n    /**\n     * Creates children and instantiates everything.\n     * \n     * @private\n     * @return {ButtonGroup} A reference to the button group for chaining.\n     */\n    setup() {\n\n        // Buttons\n        //-----------------\n        let position = 0\n\n        for (let it of this.opts.buttons) {\n\n            delete it.x\n            delete it.y\n\n            if (this.opts.orientation === 'horizontal') {\n                it.x = position\n            } else {\n                it.y = position\n            }\n\n            it.theme = it.theme || this.opts.theme\n            it.minWidth = it.minWidth || this.opts.minWidth\n            it.minHeight = it.minHeight || this.opts.minHeight\n            it.padding = it.padding || this.opts.padding\n            it.iconPosition = it.iconPosition || this.opts.iconPosition\n            it.iconColor = it.iconColor || this.opts.iconColor\n            it.iconColorActive = it.iconColorActive || this.opts.iconColorActive\n            it.fill = it.fill || this.opts.fill\n            it.fillAlpha = it.fillAlpha || this.opts.fillAlpha\n            it.fillActive = it.fillActive || this.opts.fillActive\n            it.fillActiveAlpha = it.fillActiveAlpha || this.opts.fillActiveAlpha\n            it.stroke = it.stroke || this.opts.stroke\n            it.strokeWidth = it.strokeWidth != null ? it.strokeWidth : this.opts.strokeWidth\n            it.strokeAlpha = it.strokeAlpha != null ? it.strokeAlpha : this.opts.strokeAlpha\n            it.strokeActive = it.strokeActive || this.opts.strokeActive\n            it.strokeActiveWidth = it.strokeActiveWidth != null ? it.strokeActiveWidth : this.opts.strokeActiveWidth\n            it.strokeActiveAlpha = it.strokeActiveAlpha != null ? it.strokeActiveAlpha : this.opts.strokeActiveAlpha\n            it.textStyle = it.textStyle || this.opts.textStyle\n            it.textStyleActive = it.textStyleActive || this.opts.textStyleActive\n            it.style = it.style || this.opts.style\n            it.radius = it.radius != null ? it.radius : this.opts.radius\n            if (!it.type) {\n                switch (this.opts.type) {\n                    case 'checkbox':\n                        it.type = this.opts.type\n                        break\n                    default:\n                        it.type = 'default'\n                        break\n                }\n            }\n            //it.type = it.type || this.opts.type || 'default'\n            it.align = it.align || this.opts.align\n            it.verticalAlign = it.verticalAlign || this.opts.verticalAlign\n            it.afterAction = (event, button) => {\n                if (this.opts.type === 'radio' && button.opts.type === 'default') {\n                    this.buttons.forEach(it => {\n                        if (it.opts.type === 'default') {\n                            it.active = false\n                        }\n                    })\n\n                    if (button.opts.type === 'default') {\n                        button.active = true\n                    }\n                }\n            }\n\n            if (it.tooltip) {\n                if (typeof it.tooltip === 'string') {\n                    it.tooltip = {content: it.tooltip, container: this}\n                } else {\n                    it.tooltip = Object.assign({}, {container: this}, it.tooltip)\n                }\n            }\n            \n            let button = new Button(it)\n\n            this.addChild(button)\n            this.buttons.push(button)\n\n            position += (this.opts.orientation === 'horizontal' ? button.width : button.height) + this.opts.margin\n        }\n\n        if (this.opts.orientation === 'vertical') {\n            const maxWidth = this.getMaxButtonWidth()\n\n            this.buttons.forEach(it => {\n                it.opts.minWidth = maxWidth\n                it.layout()\n            })\n        }\n\n        // disabled\n        //-----------------\n        if (this.opts.disabled != null) {\n            this.disabled = this.opts.disabled\n        }\n\n        return this\n    }\n    \n    /**\n     * Should be called to refresh the layout of the button group. Can be used after resizing.\n     * \n     * @return {ButtonGroup} A reference to the button group for chaining.\n     */\n    layout() {\n        \n        // set position\n        //-----------------\n        this.position.set(this.opts.x, this.opts.y)\n\n        // draw\n        //-----------------\n        this.draw()\n\n        return this\n    }\n    \n    /**\n     * Draws the canvas.\n     * \n     * @private\n     * @return {ButtonGroup} A reference to the button group for chaining.\n     */\n    draw() {\n\n        if (this.opts.margin === 0) {\n\n            this.buttons.forEach(it => it.hide())\n\n            this.clear()\n            this.lineStyle(this.opts.strokeWidth, this.opts.stroke, this.opts.strokeAlpha)\n            this.beginFill(this.opts.fill, this.opts.fillAlpha)\n            this.drawRoundedRect(0, 0, this.width, this.height, this.opts.radius)\n\n            // Draw borders\n            this.lineStyle(this.opts.strokeWidth, this.opts.stroke, this.opts.strokeAlpha / 2)\n\n            this.buttons.forEach((it, i) => {\n                if (i > 0) {\n                    this.moveTo(it.x, it.y)\n\n                    if (this.opts.orientation === 'horizontal') {\n                        this.lineTo(it.x, it.height)\n                    } else {\n                        this.lineTo(it.width, it.y)\n                    }\n                    \n                }\n            })\n\n            this.endFill()\n        }\n\n        return this\n    }\n    \n    /**\n     * Gets or sets the disabled state. When disabled, no button of the button group can be clicked.\n     * \n     * @member {boolean}\n     */\n    get disabled() {\n        return this._disabled\n    }\n\n    set disabled(value) {\n\n        this._disabled = value\n\n        this.buttons.forEach(it => it.disabled = value)\n    }\n    \n    /**\n     * Searches all buttons of the button group and returns the maximum width of one button.\n     * \n     * @private\n     * @return {number} The maximum with of a button of the button group.\n     */\n    getMaxButtonWidth() {\n\n        let widths = this.buttons.map(it => it.width)\n\n        return Math.max(...widths)\n    }\n    \n    /**\n     * Shows the button group (sets his alpha value to 1).\n     * \n     * @return {ButtonGroup} A reference to the button group for chaining.\n     */\n    show() {\n\n        this.alpha = 1\n\n        return this\n    }\n\n    /**\n     * Hides the button group (sets his alpha value to 0).\n     * \n     * @return {ButtonGroup} A reference to the button group for chaining.\n     */\n    hide() {\n\n        this.alpha = 0\n\n        return this\n    }\n}\n","import AbstractPopup from './abstractpopup.js'\nimport Button from './button.js'\nimport ButtonGroup from './buttongroup.js'\n\n/**\n * Class that represents a PixiJS InteractivePopup.\n * The class is used for various other Popup-like classes\n * like Popup, Message...\n *\n * @class\n * @abstract\n * @extends AbstractPopup\n */\nexport class InteractivePopup extends AbstractPopup {\n\n    /**\n     * Creates an instance of an InteractivePopup (only for internal use).\n     *\n     * @constructor\n     * @param {object} [opts] - An options object to specify to style and behaviour of the popup.\n     * @param {boolean} [opts.closeOnPopup=false] - Should the popup be closed when the user clicks on the popup?\n     * @param {boolean} [opts.closeButton=true] - Should a close button be displayed on the upper right corner?\n     * @param {object} [opts.button] - A Button object to be display on the lower right corner.\n     * @param {object} [opts.buttonGroup] - A ButtonGroup object to be displayed on the lower right corner.\n     */\n    constructor(opts = {}) {\n\n        opts = Object.assign({}, {\n            closeOnPopup: false,\n            closeButton: true,\n            button: null,\n            buttonGroup: null\n        }, opts)\n\n        super(opts)\n\n        this._closeButton = null\n        this._buttons = null\n\n        // padding\n        this.smallPadding = this.opts.padding / 2\n\n        // setup\n        //-----------------\n        this.setup()\n\n        // layout\n        //-----------------\n        this.layout()\n    }\n\n    /**\n     * Creates the framework and instantiates everything.\n     *\n     * @private\n     * @return {AbstractPopup} A reference to the popup for chaining.\n     */\n    setup() {\n\n        super.setup()\n\n        // interaction\n        //-----------------\n        this.on('pointerup', e => {\n            if (this.opts.closeOnPopup) {\n                this.hide()\n            } else {\n                e.stopPropagation()\n            }\n        })\n\n        // closeButton\n        //-----------------\n        if (this.opts.closeButton) {\n            let closeButton = PIXI.Sprite.fromImage('../../assets/icons/png/flat/close.png', true)\n            closeButton.width = this.headerStyle.fontSize\n            closeButton.height = closeButton.width\n            closeButton.tint = this.theme.color2\n            // This is needed, because the closeButton belongs to the content. The popup must resize with the closeButton.\n            if (this._header) {\n                closeButton.x = this._header.width + this.innerPadding\n            } else if (this._content) {\n                closeButton.x = this._content.width + this.innerPadding\n            }\n\n            closeButton.interactive = true\n            closeButton.buttonMode = true\n            closeButton.on('pointerdown', e => {\n                this.hide()\n            })\n\n            this._closeButton = closeButton\n            this.addChild(closeButton)\n\n            // maxWidth is set and a closeButton should be displayed\n            //-----------------\n            if (this.opts.maxWidth) {\n                const wordWrapWidth = this.opts.maxWidth - (2 * this.opts.padding) - this.smallPadding - this._closeButton.width\n                if (this._header) {\n                    this.headerStyle.wordWrapWidth = wordWrapWidth\n                } else if (this._content) {\n                    this.textStyle.wordWrapWidth = wordWrapWidth\n                }\n            }\n        }\n\n        // buttons\n        //-----------------\n        if (this.opts.button || this.opts.buttonGroup) {\n            if (this.opts.button) {\n                this._buttons = new Button(Object.assign({textStyle: this.theme.textStyleSmall}, this.opts.button))\n            } else {\n                this._buttons = new ButtonGroup(Object.assign({textStyle: this.theme.textStyleSmall}, this.opts.buttonGroup))\n            }\n            this.addChild(this._buttons)\n\n            this._buttons.y = this.innerPadding + this.sy\n        }\n\n        return this\n    }\n\n    /**\n     * Should be called to refresh the layout of the popup. Can be used after resizing.\n     *\n     * @return {AbstractPopup} A reference to the popup for chaining.\n     */\n    layout() {\n\n        super.layout()\n        \n        // closeButton\n        //-----------------\n        if (this.opts.closeButton) {\n            this._closeButton.x = this.wantedWidth - this.smallPadding - this._closeButton.width\n            this._closeButton.y = this.smallPadding\n        }\n\n        // buttons\n        //-----------------\n        if (this._buttons) {\n            this._buttons.x = this.wantedWidth - this.opts.padding - this._buttons.width\n            this._buttons.y = this.wantedHeight - this.opts.padding - this._buttons.height\n        }\n\n        return this\n    }\n\n    /**\n     * Calculates the size of the children of the AbstractPopup.\n     * Cannot use getBounds() because it is not updated when children\n     * are removed.\n     * \n     * @private\n     * @override\n     * @returns {object} An JavaScript object width the keys width and height.\n     */\n    getInnerSize() {\n\n        let size = super.getInnerSize()\n\n        if (this._closeButton) {\n            size.width += this.smallPadding + this._closeButton.width\n        }\n\n        if (this._buttons) {\n            size.width = Math.max(size.width, this._buttons.x + this._buttons.width)\n            size.height += this.innerPadding + this._buttons.height\n        }\n\n        return size\n    }\n}\n\n/**\n * Class that represents a PixiJS Popup.\n *\n * @example\n * // Create the popup\n * const popup = new Popup({\n *     header: 'Goethe',\n *     content: 'Man kann die Erfahrung nicht früh genug machen, wie entbehrlich man in der Welt ist.'\n * })\n *\n * // Add the popup to a DisplayObject\n * app.scene.addChild(popup)\n *\n * @class\n * @extends InteractivePopup\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/popup.html|DocTest}\n */\nexport default class Popup extends InteractivePopup {\n\n    /**\n     * Creates an instance of a Popup.\n     *\n     * @constructor\n     * @param {object} [opts] - An options object to specify to style and behaviour of the popup.\n     * @param {boolean} [opts.closeButton=false] - Should a close button be displayed on the upper right corner?\n     * @param {number} [opts.minWidth=0] - The minimum width of the popup.\n     * @param {number} [opts.minHeight=0] - The minimum height of the popup.\n     */\n    constructor(opts = {}) {\n\n        opts = Object.assign({}, {\n            closeButton: false,\n            minWidth: 0,\n            minHeight: 0\n        }, opts)\n\n        super(opts)\n    }\n}\n","import Theme from './theme.js'\nimport {InteractivePopup} from './popup.js'\n\n/**\n * Class that represents a PixiJS Modal.\n * \n * @example\n * // Create the button and the modal when clicked\n * const button = new Button({\n *     label: 'Show Modal',\n *     action: e => {\n *         const modal = new Modal({\n *             app: app,\n *             header: 'This is the header',\n *             content: 'This is the text.'\n *         })\n *         app.scene.addChild(modal)\n *     }\n * })\n *\n * // Add the button to a DisplayObject\n * app.scene.addChild(button)\n *\n * @class\n * @extends PIXI.Container\n * @extends InteractivePopup\n * @see {@link http://pixijs.download/dev/docs/PIXI.Container.html|PIXI.Container}\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/modal.html|DocTest}\n */\nexport default class Modal extends PIXI.Container {\n\n    /**\n     * Creates an instance of a Modal.\n     * \n     * @constructor\n     * @param {object} [opts] - An options object to specify to style and behaviour of the modal.\n     * @param {number} [opts.id=auto generated] - The id of the modal.\n     * @param {PIXIApp} [opts.app=window.app] - The app where the modal belongs to.\n     * @param {number} [opts.backgroundFill=Theme.background] - The color of the background.\n     * @param {number} [opts.backgroundFillAlpha=0.6] - The opacity of the background.\n     * @param {boolean} [opts.closeOnBackground=true] - Should the modal be closed when the user clicks the\n     *     background?\n     * @param {boolean} [opts.visible=true] - Is the modal initially visible (property visible)?\n     */\n    constructor(opts = {}) {\n\n        super()\n        \n        const theme = Theme.fromString(opts.theme)\n        this.theme = theme\n\n        this.opts = Object.assign({}, {\n            id: PIXI.utils.uid(),\n            app: window.app,\n            backgroundFill: theme.background,\n            backgroundFillAlpha: .6,\n            closeOnBackground: true,\n            visible: true\n        }, opts)\n\n        this.id = this.opts.id\n\n        this.background = null\n        this.popup = null\n\n        this.alpha = 0\n        this.visible = this.opts.visible\n\n        // setup\n        //-----------------\n        this.setup()\n\n        // layout\n        //-----------------\n        this.layout()\n    }\n    \n    /**\n     * Creates children and instantiates everything.\n     * \n     * @private\n     * @return {Modal} A reference to the modal for chaining.\n     */\n    setup() {\n\n        // interaction\n        //-----------------\n        this.interactive = true\n        this.on('added', e => {\n            if (this.visible) {\n                this.show()\n            }\n        })\n\n        // background\n        //-----------------\n        let background = new PIXI.Graphics()\n        this.background = background\n        this.addChild(this.background)\n\n        if (this.opts.closeOnBackground) {\n            background.interactive = true\n            background.on('pointerup', e => {\n                this.hide()\n            })\n        }\n\n        // popup\n        //-----------------\n        const popupOpts = Object.assign({}, this.opts, {\n            visible: true,\n            onHidden: () => {\n                this.hide()\n            }\n        })\n        let popup = new InteractivePopup(popupOpts)\n        this.popup = popup\n        this.addChild(popup)\n        popup.show()\n\n        return this\n    }\n    \n    /**\n     * Should be called to refresh the layout of the modal. Can be used after resizing.\n     * \n     * @return {Modal} A reference to the modal for chaining.\n     */\n    layout() {\n\n        const width = this.opts.app.size.width\n        const height = this.opts.app.size.height\n\n        // background\n        //-----------------\n        this.background.clear()\n        this.background.beginFill(this.opts.backgroundFill, this.opts.backgroundFillAlpha)\n        this.background.drawRect(0, 0, width, height)\n        this.background.endFill()\n\n        // position\n        this.popup.x = width / 2 - this.popup.width / 2\n        this.popup.y = height / 2 - this.popup.height / 2\n\n        return this\n    }\n    \n    /**\n     * Shows the modal (sets his alpha values to 1).\n     * \n     * @return {Modal} A reference to the modal for chaining.\n     */\n    show() {\n        TweenLite.to(this, this.theme.fast, {alpha: 1, onStart: () => this.visible = true})\n\n        return this\n    }\n    \n    /**\n     * Hides the modal (sets his alpha values to 0).\n     * \n     * @return {Modal} A reference to the modal for chaining.\n     */\n    hide() {\n        TweenLite.to(this, this.theme.fast, {alpha: 0, onComplete: () => this.visible = false})\n\n        return this\n    }\n    \n    /**\n     * Sets or gets the header. The getter always returns a PIXI.Text object. The setter can receive\n     * a string or a PIXI.Text object.\n     * \n     * @member {string|PIXI.Text}\n     */\n    get header() {\n        return this.popup.header\n    }\n    set header(value) {\n        this.opts.header = value\n        this.background.destroy()\n        this.popup.destroy()\n        this.setup().layout()\n    }\n    \n    /**\n     * Sets or gets the content. The getter always returns an PIXI.DisplayObject. The setter can receive\n     * a string or a PIXI.DisplayObject.\n     * \n     * @member {string|PIXI.DisplayObject}\n     */\n    get content() {\n        return this.popup.content\n    }\n    set content(value) {\n        this.opts.content = value\n        this.background.destroy()\n        this.popup.destroy()\n        this.setup().layout()\n    }\n}\n","import Theme from './theme.js'\nimport {InteractivePopup} from './popup.js'\n\n/**\n * Class that represents a Message. A message pops up and disappears after a specific amount of time.\n * \n * @example\n * // Create the PixiJS App\n * const app = new PIXIApp({\n *     view: canvas,\n *     width: 900,\n *     height: 250\n * }).setup().run()\n * \n * // Create a button\n * let button = new Button({\n *     label: 'Click me',\n *     action: e => {\n *         const message = new Message({\n *             app: app,\n *             header: 'Header',\n *             content: 'Text.'\n *         })\n *         app.scene.addChild(message)\n *     }\n * })\n * \n * // Add the button to the scene\n * app.scene.addChild(button)\n *\n * @class\n * @extends InteractivePopup\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/message.html|DocTest}\n */\nexport default class Message extends InteractivePopup {\n\n    /**\n     * Creates an instance of a Message.\n     * \n     * @constructor\n     * @param {object} [opts] - An options object to specify to style and behaviour of the message.\n     * @param {PIXIApp} [opts.app=window.app] - The PIXIApp where this message belongs to.\n     * @param {boolean} [opts.closeButton=false] - Should a close button be displayed in the upper right corner?\n     * @param {number} [opts.minWidth=280] - The minimum width of the message box. Automatically expands with the content.\n     * @param {number} [opts.minHeight=100] - The minimum height of the message box. Automatically expands with the content.\n     * @param {number} [opts.margin=Theme.margin] - The outer spacing of the message box.\n     * @param {string} [opts.align=right] - The horizontal position of the message box relative to the app. Possible\n     *     values are left, center, right.\n     * @param {string} [opts.verticalAlign=top] - The vertical position of the message box relative to the app. Possible\n     *     values are top, middle, bottom.\n     * @param {number} [opts.duration=5] - The duration in seconds when the message box should disappear.\n     * @param {boolean} [opts.autoClose=true] - Should the message box be closed automatically?\n     * @param {number} [opts.closeDuration=Theme.fast] - The duration in seconds of the closing of the message box.\n     */\n    constructor(opts = {}) {\n        \n        const theme = Theme.fromString(opts.theme)\n\n        opts = Object.assign({}, {\n            app: window.app,\n            closeButton: false,\n            minWidth: 280,\n            minHeight: 100,\n            margin: theme.margin,\n            align: 'right',                     // left, center, right\n            verticalAlign: 'top',               // top, middle, bottom\n            duration: 5,\n            autoClose: true,\n            closeDuration: theme.fast\n        }, opts)\n\n        super(opts)\n    }\n\n    /**\n     * Relayouts the position of the message box.\n     * \n     * @return {Message} Returns the message box for chaining.\n     */\n    layout() {\n\n        super.layout()\n\n        // horizontal\n        switch (this.opts.align) {\n            case 'left':\n                this.x = this.opts.margin\n                break\n            case 'center':\n                this.x = (this.opts.app.size.width / 2) - (this.width / 2)\n                break\n            case 'right':\n                this.x = this.opts.app.size.width - this.opts.margin - this.width\n                break\n        }\n\n        // vertical\n        switch (this.opts.verticalAlign) {\n            case 'top':\n                this.y = this.opts.margin\n                break\n            case 'middle':\n                this.y = (this.opts.app.size.height / 2) - (this.height / 2)\n                break\n            case 'bottom':\n                this.y = this.opts.app.size.height - this.opts.margin - this.height\n                break\n        }\n    }\n\n    /**\n     * Shows the message box.\n     * \n     * @private\n     */\n    show() {\n\n        super.show()\n\n        if (this.opts.autoClose) {\n            window.setTimeout(() => {\n                this.hide()\n            }, this.opts.duration * 1000)\n        }\n    }\n}\n","/* globals WebKitPoint */\n\n/** Tests whether an object is empty\n * @param {Object} obj - the object to be tested\n * @return {boolean}\n */\nexport function isEmpty(obj) {\n    // > isEmpty({})\n    // true\n    for (let i in obj) {\n        return false\n    }\n    return true\n}\n\n/** Returns a universal unique id\n * @return {string}\n * See https://stackoverflow.com/questions/105034/create-guid-uuid-in-javascript/21963136#21963136\n */\nexport function uuid() {\n    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {\n        let r = (Math.random() * 16) | 0,\n            v = c == 'x' ? r : (r & 0x3) | 0x8\n        return v.toString(16)\n    })\n}\n\nexport function lerp(start, stop, amt) {\n    return amt * (stop - start) + start\n}\n\nexport function sample(population, k) {\n    /*\n        From https://stackoverflow.com/questions/19269545/how-to-get-n-no-elements-randomly-from-an-array/38571132\n        \n        Chooses k unique random elements from a population sequence or set.\n\n        Returns a new list containing elements from the population while\n        leaving the original population unchanged.  The resulting list is\n        in selection order so that all sub-slices will also be valid random\n        samples.  This allows raffle winners (the sample) to be partitioned\n        into grand prize and second place winners (the subslices).\n\n        Members of the population need not be hashable or unique.  If the\n        population contains repeats, then each occurrence is a possible\n        selection in the sample.\n\n        To choose a sample in a range of integers, use range as an argument.\n        This is especially fast and space efficient for sampling from a\n        large population:   sample(range(10000000), 60)\n\n        Sampling without replacement entails tracking either potential\n        selections (the pool) in a list or previous selections in a set.\n\n        When the number of selections is small compared to the\n        population, then tracking selections is efficient, requiring\n        only a small set and an occasional reselection.  For\n        a larger number of selections, the pool tracking method is\n        preferred since the list takes less space than the\n        set and it doesn't suffer from frequent reselections.\n    */\n\n    if (!Array.isArray(population))\n        throw new TypeError(\"Population must be an array.\")\n    let n = population.length\n    if (k < 0 || k > n)\n        throw new RangeError(\"Sample larger than population or is negative\")\n\n    let result = new Array(k)\n    let setsize = 21   // size of a small set minus size of an empty list\n\n    if (k > 5)\n        setsize += Math.pow(4, Math.ceil(Math.log(k * 3, 4)))\n\n    if (n <= setsize) {\n        // An n-length list is smaller than a k-length set\n        let pool = population.slice()\n        for (let i = 0; i < k; i++) {          // invariant:  non-selected at [0,n-i)\n            let j = Math.random() * (n - i) | 0\n            result[i] = pool[j]\n            pool[j] = pool[n - i - 1]       // move non-selected item into vacancy\n        }\n    } else {\n        let selected = new Set()\n        for (let i = 0; i < k; i++) {\n            let j = Math.random() * (n - i) | 0\n            while (selected.has(j)) {\n                j = Math.random() * (n - i) | 0\n            }\n            selected.add(j)\n            result[i] = population[j]\n        }\n    }\n\n    return result\n}\n\n\n// Returns a function, that, as long as it continues to be invoked, will not\n// be triggered. The function will be called after it stops being called for\n// N milliseconds. If `immediate` is passed, trigger the function on the\n// leading edge, instead of the trailing.\n// Taken from: https://davidwalsh.name/essential-javascript-functions\nexport function debounce(func, wait, immediate) {\n    let timeout\n    return function () {\n        let context = this,\n            args = arguments\n        let later = function () {\n            timeout = null\n            if (!immediate) func.apply(context, args)\n        }\n        let callNow = immediate && !timeout\n        clearTimeout(timeout)\n        timeout = setTimeout(later, wait)\n        if (callNow) func.apply(context, args)\n    }\n}\n\n/** Returns an id that is guaranteed to be unique within the livetime of the\n * application\n * @return {string}\n */\nlet _idGenerator = 0\nexport function getId() {\n    return 'id' + _idGenerator++\n}\n\nexport function randomInt(min = 0, max = 100) {\n    return Math.floor(Math.random() * (max - min + 1) + min)\n}\n\nexport function randomFloat(min = 0.0, max = 1.0) {\n    return Math.random() * (max - min) + min\n}\n\nexport class Dates {\n\n    static create(fullYear, month, day) {\n        return new Date(Date.UTC(fullYear, month, day))\n    }\n\n    static daysInMonth(date) {\n        return new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate()\n    }\n\n    static startYearRange(date) {\n        return new Date(Date.UTC(date.getFullYear() - 1, 11, 31, 23, 59, 59, 999))\n    }\n\n    static endYearRange(date) {\n        return new Date(Date.UTC(date.getFullYear() + 1, 0, 1))\n    }\n\n    static prevYear(date, offset = 1) {\n        return this.create(date.getFullYear() - offset, 0, 1)\n    }\n\n    static nextYear(date, offset = 1) {\n        return this.create(date.getFullYear() + offset, 0, 1)\n    }\n\n    static nextMonth(date) {\n        return this.create(date.getFullYear(), date.getMonth() + 1, 1)\n    }\n\n    static nextDay(date) {\n        return this.create(\n            date.getFullYear(),\n            date.getMonth(),\n            date.getDate() + 1\n        )\n    }\n\n    static nextHour(date) {\n        // See http://stackoverflow.com/questions/1050720/adding-hours-to-javascript-date-object\n        return new Date(date.getTime() + 60 * 60 * 1000)\n    }\n\n    static nextMinute(date) {\n        // See above\n        return new Date(date.getTime() + 60 * 1000)\n    }\n\n    static nextSecond(date) {\n        // See above\n        return new Date(date.getTime() + 1000)\n    }\n\n    static nextMillisecond(date) {\n        // See above\n        return new Date(date.getTime() + 1)\n    }\n\n    static *iterYears(start, end) {\n        let date = this.create(start.getFullYear(), 0, 1)\n        while (date <= end) {\n            yield date\n            date = this.nextYear(date)\n        }\n        yield date\n    }\n\n    static *iterMonths(year, limit = 12) {\n        let month = 0\n        while (month < limit) {\n            let date = this.create(year.getFullYear(), month, 1)\n            yield date\n            month += 1\n        }\n    }\n\n    static *iterMonthsOfYears(years) {\n        for (let year of years) {\n            for (let month of this.iterMonths(year)) {\n                yield month\n            }\n        }\n    }\n\n    static *iterDays(month) {\n        let day = 1\n        let limit = Dates.daysInMonth(month)\n        while (day <= limit) {\n            let date = this.create(month.getFullYear(), month.getMonth(), day)\n            yield date\n            day += 1\n        }\n    }\n\n    static *iterDaysOfMonths(months) {\n        for (let month of months) {\n            for (let day of this.iterDays(month)) {\n                yield day\n            }\n        }\n    }\n}\n/* Color conversion functions */\n\nexport class Colors {\n    // http://stackoverflow.com/questions/5623838/rgb-to-hex-and-hex-to-rgb\n\n    static rgb2num(red, green, blue) {\n        let rgb = blue | (green << 8) | (red << 16)\n        return 0x000000 + rgb\n    }\n\n    static rgb2hex(red, green, blue) {\n        let rgb = blue | (green << 8) | (red << 16)\n        return '#' + (0x1000000 + rgb).toString(16).slice(1)\n    }\n\n    static hex2rgb(hex) {\n        // long version\n        let r = hex.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i)\n        if (r) {\n            return r.slice(1, 4).map(x => {\n                return parseInt(x, 16)\n            })\n        }\n        // short version\n        r = hex.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/i)\n        if (r) {\n            return r.slice(1, 4).map(x => {\n                return 0x11 * parseInt(x, 16)\n            })\n        }\n        return null\n    }\n\n    static rgb(r, g, b) {\n        return { r, g, b }\n    }\n\n    static string2hex(str) {\n        return parseInt('0x' + str.slice(1))\n    }\n\n    static lerp(rgb1, rgb2, amount) {\n        return {\n            r: Math.round(lerp(rgb1.r, rgb2.r, amount)),\n            g: Math.round(lerp(rgb1.g, rgb2.g, amount)),\n            b: Math.round(lerp(rgb1.b, rgb2.b, amount))\n        }\n    }\n\n    static get violet() {\n        return Colors.rgb2num(89, 34, 131)\n    }\n\n    static get steelblue() {\n        return Colors.rgb2num(0, 130, 164)\n    }\n\n    static get ochre() {\n        return Colors.rgb2num(181, 157, 0)\n    }\n\n    static get turquoise() {\n        return Colors.rgb2num(34, 164, 131)\n    }\n\n    static get eminence() {\n        return Colors.rgb2num(150, 60, 134)\n    }\n\n    static random() {\n        let r = Math.round(Math.random() * 255)\n        let g = Math.round(Math.random() * 255)\n        let b = Math.round(Math.random() * 255)\n        return Colors.rgb2num(r, g, b)\n    }\n}\n\nexport class Cycle extends Array {\n    constructor(...items) {\n        super()\n        for (let item of items) {\n            this.push(item)\n        }\n        this.index = 0\n    }\n\n    next() {\n        if (this.index == this.length) {\n            this.index = 0\n        }\n        return this[this.index++]\n    }\n\n    current() {\n        if (this.index === this.length) {\n            this.index = 0\n        }\n        return this[this.index]\n    }\n}\n\n/** Static methods to compute 2D points with x and y coordinates.\n */\nexport class Points {\n    static length(a) {\n        return Math.sqrt(a.x * a.x + a.y * a.y)\n    }\n\n    static normalize(p) {\n        let len = this.length(p)\n        return this.multiplyScalar(p, 1 / len)\n    }\n\n    static mean(a, b) {\n        return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 }\n    }\n\n    static subtract(a, b) {\n        return { x: a.x - b.x, y: a.y - b.y }\n    }\n\n    static multiply(a, b) {\n        return { x: a.x * b.x, y: a.y * b.y }\n    }\n\n    static divide(a, b) {\n        return { x: a.x / b.x, y: a.y / b.y }\n    }\n\n    static multiplyScalar(a, b) {\n        return { x: a.x * b, y: a.y * b }\n    }\n\n    static add(a, b) {\n        return { x: a.x + b.x, y: a.y + b.y }\n    }\n\n    static negate(p) {\n        return { x: -p.x, y: -p.y }\n    }\n\n    static angle(p1, p2) {\n        return Math.atan2(p1.y - p2.y, p1.x - p2.x)\n    }\n\n    static normalizedAngle(p1, p2) {\n        return Angle.normalize(this.angle(p1, p2))\n    }\n\n    static normalized2Angle(p1, p2) {\n        return Angle.normalize2(this.angle(p1, p2))\n    }\n\n    static arc(p, alpha, radius) {\n        return {\n            x: p.x + radius * Math.cos(alpha),\n            y: p.y + radius * Math.sin(alpha)\n        }\n    }\n\n    static distance(a, b) {\n        let dx = a.x - b.x\n        let dy = a.y - b.y\n        return Math.sqrt(dx * dx + dy * dy)\n    }\n\n    static fromPageToNode(element, p) {\n        //    if (window.webkitConvertPointFromPageToNode) {\n        //             return window.webkitConvertPointFromPageToNode(element,\n        //                                                     new WebKitPoint(p.x, p.y))\n        //         }\n        return window.convertPointFromPageToNode(element, p.x, p.y)\n    }\n\n    static fromNodeToPage(element, p) {\n        //  if (window.webkitConvertPointFromNodeToPage) {\n        //             return window.webkitConvertPointFromNodeToPage(element,\n        //                                                     new WebKitPoint(p.x, p.y))\n        //         }\n        return window.convertPointFromNodeToPage(element, p.x, p.y)\n    }\n}\n\n/**\n * A helper class for common set operations.\n *\n * @export\n * @class Sets\n */\nexport class Sets {\n\n    /**\n     * Returns the intersection of all sets\n     * https://stackoverflow.com/questions/31930894/javascript-set-data-structure-intersect\n     * @static\n     * @param {*} sets\n     * @returns\n     * @memberof Sets\n     */\n    static intersect(...sets) {\n        if (!sets.length) return new Set()\n        const i = sets.reduce((m, s, i) => s.size < sets[m].size ? i : m, 0)\n        const [smallest] = sets.splice(i, 1)\n        const res = new Set()\n        for (let val of smallest)\n            if (sets.every(s => s.has(val)))\n                res.add(val)\n        return res\n    }\n\n    /**\n     * Returns the union of all sets\n     *\n     * @static\n     * @param {*} sets\n     * @returns\n     * @memberof Sets\n     */\n    static union(...sets) {\n        let result = new Set()\n        for (let set of sets) {\n            for (let m of set) {\n                result.add(m)\n            }\n        }\n        return result\n    }\n\n    /**\n     * Returns the difference of the given sets. Starts with the first set and removing all elements of the following sets.\n     *\n     * @static\n     * @param {*} set\n     * @param {*} sets\n     * @returns\n     * @memberof Sets\n     */\n    static difference(set, ...sets) {\n        let result = new Set()\n        for (let m of set) {\n            result.add(m)\n        }\n        for (let s of sets) {\n            for (let m of s) {\n                result.delete(m)\n            }\n        }\n        return result\n    }\n}\n\n/** Static methods to compute angles.\n */\nexport class Angle {\n\n    static normalize(angle) {\n        let TAU = Math.PI * 2.0\n        while (angle > Math.PI) {\n            angle -= TAU\n        }\n        while (angle < -Math.PI) {\n            angle += TAU\n        }\n        return angle\n    }\n\n    static normalize2(angle) {\n        let TAU = Math.PI * 2.0\n        while (angle > TAU) {\n            angle -= TAU\n        }\n        while (angle < 0) {\n            angle += TAU\n        }\n        return angle\n    }\n\n    static normalizeDegree(angle) {\n        let full = 360.0\n        while (angle > 180.0) {\n            angle -= full\n        }\n        while (angle < -180.0) {\n            angle += full\n        }\n        return angle\n    }\n\n    static normalizedDiff(a, b) {\n        return this.normalize(this.diff(a, b))\n    }\n\n    static normalized2Diff(a, b) {\n        return this.normalize2(this.diff(a, b))\n    }\n\n    static diff(a, b) {\n        return Math.atan2(Math.sin(a - b), Math.cos(a - b))\n    }\n\n    static degree2radian(degree) {\n        return Math.PI * degree / 180.0\n    }\n\n    static radian2degree(rad) {\n        return 180.0 / Math.PI * rad\n    }\n}\n\nexport class Elements {\n    static setStyle(element, styles) {\n        for (let key in styles) {\n            element.style[key] = styles[key]\n        }\n    }\n\n    static addClass(element, cssClass) {\n        element.classList.add(cssClass)\n    }\n\n    static removeClass(element, cssClass) {\n        element.classList.remove(cssClass)\n    }\n\n    static toggleClass(element, cssClass) {\n        element.classList.toggle(cssClass)\n    }\n\n    static hasClass(element, cssClass) {\n        return element.classList.contains(cssClass)\n    }\n}\n\nexport class MapProxy {\n    /* This class is needed if we want to use the interaction classes\n    in Firefox 45.8 and modern Browsers.\n\n    A workaround for https://github.com/babel/babel/issues/2334\n  */\n    constructor() {\n        this.map = new Map()\n    }\n\n    get size() {\n        return this.map.size\n    }\n\n    get(key) {\n        return this.map.get(key)\n    }\n\n    set(key, value) {\n        return this.map.set(key, value)\n    }\n\n    delete(key) {\n        return this.map.delete(key)\n    }\n\n    clear() {\n        return this.map.clear()\n    }\n\n    has(key) {\n        return this.map.has(key)\n    }\n\n    keys() {\n        return this.map.keys()\n    }\n\n    values() {\n        return this.map.values()\n    }\n\n    entries() {\n        return this.map.entries()\n    }\n\n    forEach(func) {\n        this.map.forEach(func)\n    }\n}\n\n/* Based om https://gist.github.com/cwleonard/e124d63238bda7a3cbfa */\nexport class Polygon {\n    /*\n     *  This is the Polygon constructor. All points are center-relative.\n     */\n    constructor(center) {\n        this.points = new Array()\n        this.center = center\n    }\n\n    /*\n     *  Point x and y values should be relative to the center.\n     */\n    addPoint(p) {\n        this.points.push(p)\n    }\n\n    /*\n     *  Point x and y values should be absolute coordinates.\n     */\n    addAbsolutePoint(p) {\n        this.points.push({ x: p.x - this.center.x, y: p.y - this.center.y })\n    }\n\n    /*\n     * Returns the number of sides. Equal to the number of vertices.\n     */\n    getNumberOfSides() {\n        return this.points.length\n    }\n\n    /*\n     * rotate the polygon by a number of radians\n     */\n    rotate(rads) {\n        for (let i = 0; i < this.points.length; i++) {\n            let x = this.points[i].x\n            let y = this.points[i].y\n            this.points[i].x = Math.cos(rads) * x - Math.sin(rads) * y\n            this.points[i].y = Math.sin(rads) * x + Math.cos(rads) * y\n        }\n    }\n\n    /*\n     *  The draw function takes as a parameter a Context object from\n     *  a Canvas element and draws the polygon on it.\n     */\n    draw(context, { lineWidth = 2, stroke = '#000000', fill = null } = {}) {\n        context.beginPath()\n        context.moveTo(\n            this.points[0].x + this.center.x,\n            this.points[0].y + this.center.y\n        )\n        for (let i = 1; i < this.points.length; i++) {\n            context.lineTo(\n                this.points[i].x + this.center.x,\n                this.points[i].y + this.center.y\n            )\n        }\n        context.closePath()\n        context.lineWidth = lineWidth\n        if (stroke) {\n            context.strokeStyle = stroke\n            context.stroke()\n        }\n        if (fill) {\n            context.fillStyle = fill\n            context.fill()\n        }\n    }\n\n    absolutePoints() {\n        let result = new Array()\n        for (let p of this.points) {\n            result.push(Points.add(p, this.center))\n        }\n        return result\n    }\n\n    flatAbsolutePoints() {\n        let result = new Array()\n        for (let p of this.points) {\n            let a = Points.add(p, this.center)\n            result.push(a.x)\n            result.push(a.y)\n        }\n        return result\n    }\n\n    /*\n     *  This function returns true if the given point is inside the polygon,\n     *  and false otherwise.\n     */\n    containsPoint(pnt) {\n        let nvert = this.points.length\n        let testx = pnt.x\n        let testy = pnt.y\n\n        let vertx = new Array()\n        for (let q = 0; q < this.points.length; q++) {\n            vertx.push(this.points[q].x + this.center.x)\n        }\n\n        let verty = new Array()\n        for (let w = 0; w < this.points.length; w++) {\n            verty.push(this.points[w].y + this.center.y)\n        }\n\n        let i,\n            j = 0\n        let c = false\n        for (i = 0, j = nvert - 1; i < nvert; j = i++) {\n            if (\n                verty[i] > testy != verty[j] > testy &&\n                testx <\n                (vertx[j] - vertx[i]) *\n                (testy - verty[i]) /\n                (verty[j] - verty[i]) +\n                vertx[i]\n            )\n                c = !c\n        }\n        return c\n    }\n\n    multiplyScalar(scale) {\n        let center = Points.multiplyScalar(this.center, scale)\n        let clone = new Polygon(center)\n        for (let p of this.points) {\n            clone.addPoint(Points.multiplyScalar(p, scale))\n        }\n        return clone\n    }\n\n    /*\n     *  To detect intersection with another Polygon object, this\n     *  function uses the Separating Axis Theorem. It returns false\n     *  if there is no intersection, or an object if there is. The object\n     *  contains 2 fields, overlap and axis. Moving the polygon by overlap\n     *  on axis will get the polygons out of intersection.\n     */\n    intersectsWith(other) {\n        let axis = { x: 0, y: 0 }\n        let tmp, minA, maxA, minB, maxB\n        let side, i\n        let smallest = null\n        let overlap = 99999999\n\n        /* test polygon A's sides */\n        for (side = 0; side < this.getNumberOfSides(); side++) {\n            /* get the axis that we will project onto */\n            if (side == 0) {\n                axis.x =\n                    this.points[this.getNumberOfSides() - 1].y -\n                    this.points[0].y\n                axis.y =\n                    this.points[0].x -\n                    this.points[this.getNumberOfSides() - 1].x\n            } else {\n                axis.x = this.points[side - 1].y - this.points[side].y\n                axis.y = this.points[side].x - this.points[side - 1].x\n            }\n\n            /* normalize the axis */\n            tmp = Math.sqrt(axis.x * axis.x + axis.y * axis.y)\n            axis.x /= tmp\n            axis.y /= tmp\n\n            /* project polygon A onto axis to determine the min/max */\n            minA = maxA = this.points[0].x * axis.x + this.points[0].y * axis.y\n            for (i = 1; i < this.getNumberOfSides(); i++) {\n                tmp = this.points[i].x * axis.x + this.points[i].y * axis.y\n                if (tmp > maxA) maxA = tmp\n                else if (tmp < minA) minA = tmp\n            }\n            /* correct for offset */\n            tmp = this.center.x * axis.x + this.center.y * axis.y\n            minA += tmp\n            maxA += tmp\n\n            /* project polygon B onto axis to determine the min/max */\n            minB = maxB =\n                other.points[0].x * axis.x + other.points[0].y * axis.y\n            for (i = 1; i < other.getNumberOfSides(); i++) {\n                tmp = other.points[i].x * axis.x + other.points[i].y * axis.y\n                if (tmp > maxB) maxB = tmp\n                else if (tmp < minB) minB = tmp\n            }\n            /* correct for offset */\n            tmp = other.center.x * axis.x + other.center.y * axis.y\n            minB += tmp\n            maxB += tmp\n\n            /* test if lines intersect, if not, return false */\n            if (maxA < minB || minA > maxB) {\n                return false\n            } else {\n                let o = maxA > maxB ? maxB - minA : maxA - minB\n                if (o < overlap) {\n                    overlap = o\n                    smallest = { x: axis.x, y: axis.y }\n                }\n            }\n        }\n\n        /* test polygon B's sides */\n        for (side = 0; side < other.getNumberOfSides(); side++) {\n            /* get the axis that we will project onto */\n            if (side == 0) {\n                axis.x =\n                    other.points[other.getNumberOfSides() - 1].y -\n                    other.points[0].y\n                axis.y =\n                    other.points[0].x -\n                    other.points[other.getNumberOfSides() - 1].x\n            } else {\n                axis.x = other.points[side - 1].y - other.points[side].y\n                axis.y = other.points[side].x - other.points[side - 1].x\n            }\n\n            /* normalize the axis */\n            tmp = Math.sqrt(axis.x * axis.x + axis.y * axis.y)\n            axis.x /= tmp\n            axis.y /= tmp\n\n            /* project polygon A onto axis to determine the min/max */\n            minA = maxA = this.points[0].x * axis.x + this.points[0].y * axis.y\n            for (i = 1; i < this.getNumberOfSides(); i++) {\n                tmp = this.points[i].x * axis.x + this.points[i].y * axis.y\n                if (tmp > maxA) maxA = tmp\n                else if (tmp < minA) minA = tmp\n            }\n            /* correct for offset */\n            tmp = this.center.x * axis.x + this.center.y * axis.y\n            minA += tmp\n            maxA += tmp\n\n            /* project polygon B onto axis to determine the min/max */\n            minB = maxB =\n                other.points[0].x * axis.x + other.points[0].y * axis.y\n            for (i = 1; i < other.getNumberOfSides(); i++) {\n                tmp = other.points[i].x * axis.x + other.points[i].y * axis.y\n                if (tmp > maxB) maxB = tmp\n                else if (tmp < minB) minB = tmp\n            }\n            /* correct for offset */\n            tmp = other.center.x * axis.x + other.center.y * axis.y\n            minB += tmp\n            maxB += tmp\n\n            /* test if lines intersect, if not, return false */\n            if (maxA < minB || minA > maxB) {\n                return false\n            } else {\n                let o = maxA > maxB ? maxB - minA : maxA - minB\n                if (o < overlap) {\n                    overlap = o\n                    smallest = { x: axis.x, y: axis.y }\n                }\n            }\n        }\n        return { overlap: overlap + 0.001, axis: smallest }\n    }\n\n    static fromPoints(points) {\n        let min = { x: Number.MAX_VALUE, y: Number.MAX_VALUE }\n        let max = { x: Number.MIN_VALUE, y: Number.MIN_VALUE }\n        for (let p of points) {\n            min.x = Math.min(p.x, min.x)\n            max.x = Math.max(p.x, max.x)\n            min.y = Math.min(p.y, min.y)\n            max.y = Math.max(p.y, max.y)\n        }\n        let center = Points.mean(min, max)\n        let polygon = new Polygon(center)\n        for (let p of points) {\n            polygon.addAbsolutePoint(p)\n        }\n        return polygon\n    }\n}\n\n\n/**\n * Util functions to deal with DOMRects.\n */\nexport class Rect {\n\n\n    /**\n     * Test if a given point is contained by the provided Rect.\n     *\n     * @static\n     * @param {DOMRect} rect - Rectangle to check the collision with.\n     * @param {Point} point - Point that should be tested.\n     * @returns {boolean} - True if point is inside of rect, otherwise false.\n     * @memberof Rect\n     */\n    static contains(rect, point) {\n        return (point.x > rect.left &&\n            point.x < rect.x + rect.right\n            && point.y > rect.top && point.y < rect.bottom)\n    }\n\n\n    /**\n     *Returns the position of an rect as point object.\n     *\n     * @static\n     * @param {Rect} rect - The rectangle we want to get the position from.\n     * @returns {Point} - Returns the position as Point.\n     * @memberof Rect\n     */\n    static getPosition(rect) {\n        return { x: rect.x, y: rect.y }\n    }\n}\n\n/** String utility functions */\n\nexport class Strings {\n\n    static toUpperCaseFirstChar(str) {\n        return str.substr(0, 1).toUpperCase() + str.substr(1)\n    }\n\n    static toLowerCaseFirstChar(str) {\n        return str.substr(0, 1).toLowerCase() + str.substr(1)\n    }\n\n    static toUpperCaseEachWord(str, delim = ' ') {\n        return str.split(delim).map((v) => v.toUpperCaseFirstChar()).join(delim)\n    }\n\n    static toLowerCaseEachWord(str, delim = ' ') {\n        return str.split(delim).map((v) => v.toLowerCaseFirstChar()).join(delim)\n    }\n\n}\n\n\n\n","/* global apollo, subscriptions, gql */\n\nimport Theme from './theme.js'\nimport Progress from './progress.js'\nimport Modal from './modal.js'\nimport Message from './message.js'\nimport {debounce} from '../utils.js'\n\n/**\n * A special InteractionManager for fullscreen apps, which may\n * go beyond the limits of WebGL drawing buffers. On Safari and Chrome\n * the drawing buffers are limited to 4096 in width (Safari) or 4096x4096\n * in total buffer size (Chrome). The original InteractionManager.mapPositionToPoint\n * does not work with these extreme sizes which mainly occur if large\n * retina displays (>= 4K) are used with devicePixelRatio > 1.\n *\n * @private\n * @class\n * @extends PIXI.interaction.InteractionManager\n * @see {@link http://pixijs.download/dev/docs/PIXI.interaction.InteractionManager.html|PIXI.interaction.InteractionManager}\n * @see {@link https://stackoverflow.com/questions/29710696/webgl-drawing-buffer-size-does-not-equal-canvas-size}\n */\nclass FullscreenInteractionManager extends PIXI.interaction.InteractionManager {\n\n    mapPositionToPoint(point, x, y) {\n        let resolution = this.renderer.resolution\n        let extendWidth = 1.0\n        let extendHeight = 1.0\n        let dy = 0\n        let canvas = this.renderer.view\n        let context = canvas.getContext('webgl')\n        if (context.drawingBufferWidth < canvas.width ||\n            context.drawingBufferHeight < canvas.height) {\n            extendWidth = context.drawingBufferWidth / canvas.width\n            extendHeight = context.drawingBufferHeight / canvas.height\n            //dx = wantedWidth - context.drawingBufferWidth\n            dy = (canvas.height - context.drawingBufferHeight) / resolution\n        }\n        x *= extendWidth\n        y *= extendHeight\n\n        super.mapPositionToPoint(point, x, y + dy)\n    }\n}\n\n/**\n * The class PixiApp extends the class PIXI.Application\n * by several functions and makes meaningful pre-assumptions.\n *\n * @example\n * // Create the app\n * const app = new PIXIApp({\n *     view: canvas,\n *     width: 450,\n *     height: 150,\n *     fpsLogging: true,\n *     theme: 'light',\n *     transparent: false\n * }).setup().run()\n *\n * @class\n * @extends PIXI.Application\n * @see {@link http://pixijs.download/dev/docs/PIXI.Application.html|PIXI.Application}\n */\nexport default class PIXIApp extends PIXI.Application {\n\n    /**\n     * Creates an instance of a PixiApp.\n     *\n     * @constructor\n     * @param {object} [opts={}] - An options object. The following options can be set:\n     * @param {number} [opts.width] - The width of the renderer. If no set, the application will run in fullscreen.\n     * @param {number} [opts.height] - The height of the renderer. If no set, the application will run in fullscreen.\n     * @param {HTMLElement} [opts.view] - The canvas HTML element. If not set, a render-element is added inside the body.\n     * @param {boolean} [opts.transparent=true] - Should the render view be transparent?\n     * @param {boolean} [opts.antialias=true] - Sets antialias (only applicable in chrome at the moment).\n     * @param {number} [opts.resolution=window.devicePixelRatio | 1] - The resolution / device pixel ratio of the renderer, retina would be 2.\n     * @param {boolean} [opts.autoResize=true] - Should the canvas-element be resized automatically if the resolution was set?\n     * @param {number} [opts.backgroundColor=0x282828] - The color of the background.\n     * @param {string|Theme} [opts.theme=dark] - The name of the theme (dark, light, red) or a Theme object to use for styling.\n     * @param {boolean} [opts.fpsLogging=false] - If set to true, the current frames per second are displayed in the upper left corner.\n     * @param {object} [opts.progress={}] - Can be used to add options to the progress bar. See class Progress for more informations.\n     * @param {boolean} [opts.forceCanvas=false] - Prevents selection of WebGL renderer, even if such is present.\n     * @param {boolean} [opts.roundPixels=true] - Align PIXI.DisplayObject coordinates to screen resolution.\n     * @param {boolean} [opts.monkeyPatchMapping=true] - Monkey patch for canvas fullscreen support on large displays.\n     * @param {boolean} [opts.adaptive=true] - Adds Graphics adaptive calculation of quadratic curve and arc subdivision.\n     */\n    constructor({\n        width = null, height = null, view = null,\n        transparent = true, backgroundColor = 0x282828, theme = 'dark',\n        antialias = true, resolution = window.devicePixelRatio || 1, autoResize = true,\n        fpsLogging = false, progress = {}, forceCanvas = false, roundPixels = true, monkeyPatchMapping = true, adaptive = true,\n        graphql = false }) {\n\n        const fullScreen = !width || !height\n\n        if (fullScreen) {\n            width = window.innerWidth\n            height = window.innerHeight\n        }\n\n        super({\n            view: view,\n            width: width,\n            height: height,\n            transparent: transparent,\n            antialias: antialias,\n            resolution: resolution,\n            autoResize: autoResize,\n            backgroundColor: backgroundColor,\n            roundPixels: roundPixels,\n            forceCanvas: forceCanvas\n        })\n\n        this.width = width\n        this.height = height\n        this.theme = Theme.fromString(theme)\n        this.fpsLogging = fpsLogging\n        this.progressOpts = progress\n        this.fullScreen = fullScreen\n        this.orient = null\n        this.originalMapPositionToPoint = null\n        this.monkeyPatchMapping = monkeyPatchMapping\n        PIXI.Graphics.CURVES.adaptive = adaptive\n        this.graphql = graphql\n        if (fullScreen || autoResize) {\n            console.log('App is in fullScreen mode or autoResize mode')\n            const resizeDebounced = debounce(event => this.resize(event), 50)\n            window.addEventListener('resize', resizeDebounced)\n            document.body.addEventListener('orientationchange', this.checkOrientation.bind(this))\n        }\n        if (monkeyPatchMapping) {\n            console.log('Using monkey patched coordinate mapping')\n            // Pluggin the specializtion does not work. Monkey patching does\n            // this.renderer.plugins.interaction = new FullscreenInteractionManager(this.renderer)\n            this.monkeyPatchPixiMapping()\n        }\n    }\n\n    /**\n     * Extra setup method to construct complex scenes, etc...\n     * Overwrite this method if you need additonal views and components.\n     *\n     * @return {PIXIApp} A reference to the PIXIApp for chaining.\n     */\n    setup() {\n        this.scene = this.sceneFactory()\n        this.stage.addChild(this.scene)\n\n        // fpsLogging\n        if (this.fpsLogging) {\n            this.addFpsDisplay()\n        }\n\n        // GraphQL\n        if (this.graphql && typeof apollo !== 'undefined') {\n\n            const networkInterface = apollo.createNetworkInterface({\n                uri: '/graphql'\n            })\n\n            const wsClient = new subscriptions.SubscriptionClient(`wss://${location.hostname}/subscriptions`, {\n                reconnect: true,\n                connectionParams: {}\n            })\n\n            const networkInterfaceWithSubscriptions = subscriptions.addGraphQLSubscriptions(\n                networkInterface,\n                wsClient\n            )\n\n            this.apolloClient = new apollo.ApolloClient({\n                networkInterface: networkInterfaceWithSubscriptions\n            })\n        }\n\n        // progress\n        this._progress = new Progress(Object.assign({ theme: this.theme }, this.progressOpts, { app: this }))\n        this._progress.visible = false\n        this.stage.addChild(this._progress)\n\n        return this\n    }\n\n    /**\n     * Tests whether the width is larger than the height of the application.\n     *\n     * @return {boolean} Returns true if app is in landscape mode.\n     */\n    orientation() {\n        return this.width > this.height\n    }\n\n    /**\n     * Checks orientation and adapts view size if necessary. Implements a\n     * handler for the orientationchange event.\n     *\n     * @param {event=} - orientationchange event\n     */\n    checkOrientation(event) {\n        var value = this.orientation()\n        if (value != this.orient) {\n            setTimeout(100, function () {\n                this.orientationChanged(true)\n            }.bind(this))\n            this.orient = value\n        }\n    }\n\n    /**\n     * Called if checkOrientation detects an orientation change event.\n     *\n     * @param {boolean=} [force=false] - Called if checkOrientation detects an orientation change event.\n     */\n    orientationChanged(force = false) {\n        if (this.expandRenderer() || force) {\n            this.layout()\n        }\n    }\n\n    /**\n     * Called after a resize. Empty method but can be overwritten to\n     * adapt their layout to the new app size.\n     *\n     * @param {number} [width] - The width of the app.\n     * @param {number} [height] - The height of the app.\n     */\n    layout(width, height) {\n\n    }\n\n    /**\n     * Draws the display tree of the app. Typically this can be delegated\n     * to the layout method.\n     *\n     */\n    draw() {\n        this.layout(this.width, this.height)\n    }\n\n    /*\n     * Run the application. Override this method with everything\n     * that is needed to maintain your App, e.g. setup calls, main loops, etc.\n     *\n     */\n    run() {\n        return this\n    }\n\n    /*\n     * Overwrite this factory method if your application needs a special\n     * scene object.\n     *\n     * @returns {PIXI.Container} - A new PIXI Container for use as a scene.\n     */\n    sceneFactory() {\n        return new PIXI.Container()\n    }\n\n    /**\n     * Adds the display of the frames per second to the renderer in the upper left corner.\n     *\n     * @return {PIXIApp} - Returns the PIXIApp for chaining.\n     */\n    addFpsDisplay() {\n        const fpsDisplay = new FpsDisplay(this)\n        this.stage.addChild(fpsDisplay)\n\n        return this\n    }\n\n    /**\n     * Returns the size of the renderer as an object with the keys width and height.\n     *\n     * @readonly\n     * @member {object}\n     */\n    get size() {\n        return { width: this.width, height: this.height }\n    }\n\n    /**\n     * Returns the center of the renderer as an object with the keys x and y.\n     *\n     * @readonly\n     * @member {object}\n     */\n    get center() {\n        return { x: this.width / 2, y: this.height / 2 }\n    }\n\n    /**\n     * Resizes the renderer to fit into the window or given width and height.\n     *\n     * @param {object} [event] - The event.\n     * @param {object=} [opts={}] - The event.\n     * @param {number} [opts.width=window.innerWidth] - The width of the app to resize to.\n     * @param {number} [opts.height=window.innerHeight] - The height of the app to resize to.\n     * @return {PIXIApp} - Returns the PIXIApp for chaining.\n     */\n    resize(event, { width = window.innerWidth, height = window.innerHeight } = {}) {\n        this.width = width\n        this.height = height\n        this.expandRenderer()\n        this.layout(width, height)\n        //console.log(\"App.resize\", width, height, window.innerWidth, window.innerHeight )\n        // if (this.scene) {\n        // console.log(\"gl.drawingBufferWidth\", this.renderer.view.getContext('webgl').drawingBufferWidth)\n        // console.log(\"scene\", this.scene.scale, this.renderer, this.renderer.autoResize, this.renderer.resolution)\n        // }\n        return this\n    }\n\n    /**\n     * @todo Write the documentation.\n     *\n     * @private\n     */\n    monkeyPatchPixiMapping() {\n        if (this.originalMapPositionToPoint === null) {\n            let interactionManager = this.renderer.plugins.interaction\n            this.originalMapPositionToPoint = interactionManager.mapPositionToPoint\n            interactionManager.mapPositionToPoint = (point, x, y) => {\n                return this.fixedMapPositionToPoint(point, x, y)\n            }\n        }\n    }\n\n    /**\n     * In some browsers the canvas is distorted if the screen resolution and \n     * overall size of the canvas exceeds the internal limits (e.g. 4096 x 4096 pixels).\n     * To compensate these distortions we need to fix the mapping to the actual\n     * drawing buffer coordinates.\n     * @private\n     * @param {any} local\n     * @param {number} x\n     * @param {number} y\n     * @return {} interactionManager.mapPositionToPoint\n     */\n    fixedMapPositionToPoint(local, x, y) {\n        let resolution = this.renderer.resolution\n        let interactionManager = this.renderer.plugins.interaction\n        let extendWidth = 1.0\n        let extendHeight = 1.0\n        let dy = 0\n        let canvas = this.renderer.view\n        let context = canvas.getContext('webgl')\n\n        if (context !== null && (context.drawingBufferWidth < canvas.width ||\n            context.drawingBufferHeight < canvas.height)) {\n            extendWidth = context.drawingBufferWidth / canvas.width\n            extendHeight = context.drawingBufferHeight / canvas.height\n            //dx = wantedWidth - context.drawingBufferWidth\n            dy = (canvas.height - context.drawingBufferHeight) / resolution\n        }\n        x *= extendWidth\n        y *= extendHeight\n        return this.originalMapPositionToPoint.call(interactionManager, local, x, y + dy)\n    }\n\n    /**\n     * Expand the renderer step-wise on resize.\n     *\n     * @param {number} [expand] - The amount of additional space for the renderer [px].\n     * @return {boolean} true if the renderer was resized.\n     */\n    expandRenderer(expand = 256) {\n        let renderer = this.renderer\n        let resolution = this.renderer.resolution\n        let ww = this.width\n        let hh = this.height\n        let sw = this.screen.width\n        let sh = this.screen.height\n        if (ww > sw || hh > sh) {\n            //console.log('App.expandRenderer')\n            renderer.resize(ww + expand, hh + expand)\n            return true\n        }\n\n        renderer.resize(ww, hh)\n        return false\n    }\n\n    /**\n     * Set the loading progress of the application. If called for the first time, display the progress bar.\n     *\n     * @param {number} [value] - Should be a value between 0 and 100. If 100, the progress bar will disappear.\n     * @return {PIXIApp|Progress} The PixiApp object for chaining or the Progress object when the method was\n     *     called without a parameter.\n     */\n    progress(value) {\n\n        if (typeof value === 'undefined') {\n            return this._progress\n        }\n\n        this._progress.visible = true\n        this._progress.progress = value\n\n        return this\n    }\n\n    /**\n     * Opens a new Modal object binded to this app.\n     *\n     * @param {object} [opts] - An options object for the Modal object.\n     * @return {Modal} Returns the Modal object.\n     */\n    modal(opts = {}) {\n\n        let modal = new Modal(Object.assign({ theme: this.theme }, opts, { app: this }))\n        this.scene.addChild(modal)\n\n        return modal\n    }\n\n    /**\n     * Opens a new Message object binded to this app.\n     *\n     * @param {object} [opts] - An options object for the Message object.\n     * @return {Message} Returns the Message object.\n     */\n    message(opts = {}) {\n\n        let message = new Message(Object.assign({ theme: this.theme }, opts, { app: this }))\n        this.scene.addChild(message)\n\n        return message\n    }\n\n    /**\n     * Loads sprites, e.g. images into the PIXI TextureCache.\n     *\n     * @param {string|string[]} resources - A String or an Array of urls to the images to load.\n     * @param {function} [loaded] - A callback which is executed after all resources has been loaded.\n     *     Receives one paramter, a Map of sprites where the key is the path of the image which was\n     *     loaded and the value is the PIXI.Sprite object.\n     * @param {object} [opts] - An options object for more specific parameters.\n     * @param {boolean} [opts.resolutionDependent=true] - Should the sprites be loaded dependent of the\n     *     renderer resolution?\n     * @param {boolean} [opts.progress=false] - Should a progress bar display the loading status?\n     * @return {PIXIApp} The PIXIApp object for chaining.\n     */\n    loadSprites(resources, loaded = null, { resolutionDependent = true, progress = false } = {}) {\n\n        this.loadTextures(resources, textures => {\n\n            let sprites = new Map()\n\n            for (let [key, texture] of textures) {\n                sprites.set(key, new PIXI.Sprite(texture))\n            }\n\n            if (loaded) {\n                loaded.call(this, sprites)\n            }\n\n        }, { resolutionDependent, progress })\n\n        return this\n    }\n\n    /**\n     * Loads textures, e.g. images into the PIXI TextureCache.\n     *\n     * @param {string|string[]} resources - A String or an Array of urls to the images to load.\n     * @param {function} [loaded] - A callback which is executed after all resources has been loaded.\n     *     Receives one paramter, a Map of textures where the key is the path of the image which was\n     *     loaded and the value is the PIXI.Texture object.\n     * @param {object} [opts] - An options object for more specific parameters.\n     * @param {boolean} [opts.resolutionDependent=true] - Should the textures be loaded dependent of the\n     *     renderer resolution?\n     * @param {boolean} [opts.progress=false] - Should a progress bar display the loading status?\n     * @return {PIXIApp} The PIXIApp object for chaining.\n     */\n    loadTextures(resources, loaded = null, { resolutionDependent = true, progress = false } = {}) {\n\n        if (!Array.isArray(resources)) {\n            resources = [resources]\n        }\n\n        const loader = this.loader\n\n        for (let resource of resources) {\n\n            if (!loader.resources[resource]) {\n\n                if (resolutionDependent) {\n                    let resolution = Math.round(this.renderer.resolution)\n                    switch (resolution) {\n                        case 2:\n                            loader.add(resource, resource.replace(/\\.([^.]*)$/, '@2x.$1'))\n                            break\n                        case 3:\n                            loader.add(resource, resource.replace(/\\.([^.]*)$/, '@3x.$1'))\n                            break\n                        default:\n                            loader.add(resource)\n                            break\n                    }\n                } else {\n                    loader.add(resource)\n                }\n            }\n        }\n\n        if (progress) {\n            loader.on('progress', e => {\n                this.progress(e.progress)\n            })\n        }\n\n        loader.load((loader, resources) => {\n            const textures = new Map()\n\n            for (let key in resources) {\n                textures.set(key, resources[key].texture)\n            }\n\n            if (loaded) {\n                loaded.call(this, textures)\n            }\n        })\n\n        return this\n    }\n\n    /**\n     * Queries the GraphQL endpoint.\n     *\n     * @param {string} [query] - The GraphQL query string.\n     * @param {object} [opts={}] - An options object. The following options can be set:\n     *     http://dev.apollodata.com/core/apollo-client-api.html#ApolloClient.query\n     * @return {Promise} Returns a Promise which is either resolved with the resulting data or\n     *     rejected with an error.\n     */\n    query(query, opts = {}) {\n\n        if (typeof query === 'string') {\n            opts = Object.assign({}, opts, { query })\n        } else {\n            opts = Object.assign({}, query)\n        }\n\n        opts.query = opts.query.trim()\n\n        if (!opts.query.startsWith('query')) {\n            if (opts.query.startsWith('{')) {\n                opts.query = `query ${opts.query}`\n            } else {\n                opts.query = `query {${opts.query}}`\n            }\n        }\n\n        opts.query = gql(opts.query)\n\n        return this.apolloClient.query(opts)\n    }\n\n    /**\n     * Mutate the GraphQL endpoint.\n     *\n     * @param {string} [mutation] - The GraphQL mutation string.\n     * @param {object} [opts={}] - An options object. The following options can be set:\n     *     http://dev.apollodata.com/core/apollo-client-api.html#ApolloClient.mutate\n     * @return {Promise} Returns a Promise which is either resolved with the resulting data or\n     *     rejected with an error.\n     */\n    mutate(mutation, opts = {}) {\n\n        if (typeof mutation === 'string') {\n            opts = Object.assign({}, opts, { mutation })\n        } else {\n            opts = Object.assign({}, mutation)\n        }\n\n        opts.mutation = opts.mutation.trim()\n\n        if (!opts.mutation.startsWith('mutation')) {\n            if (opts.mutation.startsWith('{')) {\n                opts.mutation = `mutation ${opts.mutation}`\n            } else {\n                opts.mutation = `mutation {${opts.mutation}}`\n            }\n        }\n\n        opts.mutation = gql(opts.mutation)\n\n        return this.apolloClient.mutate(opts)\n    }\n\n    /**\n     * Subscribe the GraphQL endpoint.\n     *\n     * @param {string} [subscription] - The GraphQL subscription.\n     * @param {object} [opts={}] - An options object. The following options can be set:\n     *     http://dev.apollodata.com/core/apollo-client-api.html#ApolloClient.query\n     * @return {Promise} Returns a Promise which is either resolved with the resulting data or\n     *     rejected with an error.\n     */\n    subscribe(subscription, opts = {}) {\n\n        if (typeof subscription === 'string') {\n            opts = Object.assign({}, opts, { subscription })\n        } else {\n            opts = Object.assign({}, subscription)\n        }\n\n        opts.subscription = opts.subscription.trim()\n\n        if (!opts.subscription.startsWith('subscription')) {\n            if (opts.subscription.startsWith('{')) {\n                opts.subscription = `subscription ${opts.subscription}`\n            } else {\n                opts.subscription = `subscription {${opts.subscription}}`\n            }\n        }\n\n        opts.query = gql(opts.subscription)\n\n        delete opts.subscription\n\n        return this.apolloClient.subscribe(opts)\n    }\n\n    /**\n     * Supports the page as a global coordinate system and converts browser page coordinates\n     * to local DisplayObject coordinates.\n     *\n     * @param {DisplayObject} displayObject - The PIXI displayObject.\n     * @param {number} x - The x coordinate.\n     * @param {number} y - The y coordinate.\n     *  \n     * @return {PIXI.Point} Returns a PIXI.Point.\n     */\n\n    convertPointFromPageToNode(displayObject, x, y) {\n        let resolution = this.renderer.resolution\n        console.log(\"resolution\", resolution)\n        let pixiGlobal = window.convertPointFromPageToNode(app.view, x, y)\n        pixiGlobal.x /= resolution\n        pixiGlobal.y /= resolution\n        return displayObject.toLocal(new PIXI.Point(pixiGlobal.x, pixiGlobal.y))\n    }\n\n    /**\n     * Supports the page as a global coordinate system and converts local DisplayObject coordinates\n     * to browser page coordinates.\n     *\n     * @param {DisplayObject} displayObject - The PIXI displayObject.\n     * @param {number} x - The x coordinate.\n     * @param {number} y - The y coordinate.\n     *  \n     * @return {Point} Returns a DOM Point.\n     */\n\n    convertPointFromNodeToPage(displayObject, x, y) {\n        let resolution = this.renderer.resolution\n        let pixiGlobal = displayObject.toGlobal(new PIXI.Point(x, y))\n        pixiGlobal.x *= resolution\n        pixiGlobal.y *= resolution\n        // console.log(\"app.convertPointFromNodeToPage\", pixiGlobal)\n        return window.convertPointFromNodeToPage(app.view, pixiGlobal.x, pixiGlobal.y)\n    }\n}\n\n/**\n * The class fpsdisplay shows in the upper left corner\n * of the renderer the current image refresh rate.\n *\n * @private\n * @class\n * @extends PIXI.Graphics\n * @see {@link http://pixijs.download/dev/docs/PIXI.Graphics.html|PIXI.Graphics}\n */\nclass FpsDisplay extends PIXI.Graphics {\n\n    /**\n     * Creates an instance of a FpsDisplay.\n     *\n     * @constructor\n     * @param {PIXIApp} app - The PIXIApp where the frames per second should be displayed.\n     */\n    constructor(app) {\n\n        super()\n\n        this.app = app\n\n        this.lineStyle(3, 0x434f4f, 1)\n            .beginFill(0x434f4f, .6)\n            .drawRoundedRect(0, 0, 68, 32, 5)\n            .endFill()\n            .position.set(20, 20)\n\n        this.text = new PIXI.Text(this.fps, new PIXI.TextStyle({\n            fontFamily: 'Arial',\n            fontSize: 14,\n            fontWeight: 'bold',\n            fill: '#f6f6f6',\n            stroke: '#434f4f',\n            strokeThickness: 3\n        }))\n        this.text.position.set(6, 6)\n\n        this.addChild(this.text)\n\n        this.refreshFps()\n\n        window.setInterval(this.refreshFps.bind(this), 1000)\n    }\n\n    /**\n     * Refreshes fps numer.\n     *\n     * @return {PIXIApp} Returns the PIXIApp object for chaining.\n     */\n    refreshFps() {\n        this.text.text = `${(this.app.ticker.FPS).toFixed(1)} fps`\n\n        return this\n    }\n}\n","/**\n * A Gaussian blur filter. With this filter, you can blur an area of a PIXI.DisplayObject. This cannot\n * be done with the PIXI.filters.BlurFilter (when you use the PIXI.filters.BlurFilter with\n * an filter area, all pixels outside of the area are not displayed). Attention: The area of\n * the filter is always in global scope, NOT relative to the PIXI.DisplayObject the filter\n * is assigned to!\n *\n * @example\n * // Create the app\n * const app = new PIXIApp({\n *     view: canvas,\n *     width: 480,\n *     height: 270,\n *     transparent: false\n * }).setup().run()\n * \n * // Add a video sprite\n * const sprite = new PIXI.Sprite(PIXI.Texture.fromVideo(\"assets/blurfilter.mp4\"))\n * sprite.width = app.size.width\n * sprite.height = app.size.height\n * app.scene.addChild(sprite)\n * \n * // Create the filter and assign it to the scene\n * const blurFilter = new BlurFilter(new PIXI.Rectangle(20, 20, 80, 60))\n * app.scene.filters = [blurFilter]\n * \n * @class\n * @extends PIXI.Filter\n * @param {PIXI.Rectangle|PIXI.Circle|PIXI.DisplayObject} shape The area where the blur effect should be applied to. Relative to the\n *     canvas, NOT relative to the PIXI.DisplayObject where the blur effect is assigned to!\n * @param {number} [blur=50] The strength of the blur.\n */\nexport default class BlurFilter extends PIXI.Filter {\n    \n    constructor(shape, blur = 50) {\n        super()\n\n        const normalized = this.normalize(shape)\n\n        this.tiltShiftXFilter = new TiltShiftXFilter(normalized, blur)\n        this.tiltShiftYFilter = new TiltShiftYFilter(normalized, blur)\n    }\n\n    apply(filterManager, input, output) {\n        let renderTarget = filterManager.getRenderTarget(true)\n        this.tiltShiftXFilter.apply(filterManager, input, renderTarget)\n        this.tiltShiftYFilter.apply(filterManager, renderTarget, output)\n        filterManager.returnRenderTarget(renderTarget)\n    }\n\n    /**\n     * The strength of the blur.\n     *\n     * @member {number}\n     */\n    get blur() {\n        return this.tiltShiftXFilter.blur\n    }\n    set blur(value) {\n        this.tiltShiftXFilter.blur = this.tiltShiftYFilter.blur = value\n    }\n    \n    /**\n     * The blur shape.\n     *\n     * @member {PIXI.Rectangle|PIXI.Circle|PIXI.DisplayObject}\n     */\n    get shape() {\n        return this.tiltShiftXFilter.shape\n    }\n    set shape(value) {\n        this.tiltShiftXFilter.shape = this.tiltShiftYFilter.shape = this.normalize(value)\n    }\n\n    /**\n     * \n     * @private\n     * @param {PIXI.Rectangle|PIXI.Circle|PIXI.DisplayObject} value\n     * @returns {Object}\n     */\n    normalize(value) {\n\n        let shape = null\n\n        if (value instanceof PIXI.Circle) {\n            shape = {type: 'circle', x: value.x, y: value.y, r: value.radius}\n        } else if (value instanceof PIXI.Rectangle) {\n            shape = {type: 'rectangle', x: value.x, y: value.y, width: value.width, height: value.height}\n        } else {\n            const bounds = value.getBounds()\n            shape = {type: 'rectangle', x: bounds.x, y: bounds.y, width: bounds.width, height: bounds.height}\n        }\n\n        return shape\n    }\n}\n\n/**\n * A TiltShiftAxisFilter.\n *\n * @class\n * @extends PIXI.Filter\n * @abstract\n * @private\n */\nclass TiltShiftAxisFilter extends PIXI.Filter {\n\n    constructor(shape, blur){\n\n        const vertex = `\n            attribute vec2 aVertexPosition;\n            attribute vec2 aTextureCoord;\n\n            uniform mat3 projectionMatrix;\n\n            varying vec2 vTextureCoord;\n\n            void main(void) {\n                gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n                vTextureCoord = aTextureCoord;\n            }\n        `\n\n        const fragment = `\n            varying vec2 vTextureCoord;\n\n            uniform vec4 filterArea;\n            uniform sampler2D uSampler;\n            uniform int shape;\n            uniform vec4 rectangle;\n            uniform vec3 circle;\n            uniform float blur;\n            uniform vec2 delta;\n            uniform vec2 texSize;\n\n            float random(vec3 scale, float seed) {\n                return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n            }\n\n            void main(void) {\n                // textureCoord to pixelCoord\n                vec2 pixelCoord = vTextureCoord * filterArea.xy - vec2(4.0, 4.0);   // FIXME: There's a shift of 4 * 4 pixels, don't know why...\n\n                bool inside = false;\n\n                if (shape == 1) {\n                    inside = distance(pixelCoord, circle.xy) <= circle.z;\n                } else if (shape == 2) {\n                    inside = pixelCoord.x >= rectangle.x && pixelCoord.x <= rectangle.z && pixelCoord.y >= rectangle.y && pixelCoord.y <= rectangle.w;\n                }\n\n                if (inside) {\n                    vec4 color = vec4(0.0);\n                    float total = 0.0;\n\n                    float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n                    for (float t = -30.0; t <= 30.0; t++) {\n                        float percent = (t + offset - 0.5) / 30.0;\n                        float weight = 1.0 - abs(percent);\n                        vec4 sample = texture2D(uSampler, vTextureCoord + delta / texSize * percent * blur);\n                        sample.rgb *= sample.a;\n                        color += sample * weight;\n                        total += weight;\n                    }\n\n                    gl_FragColor = color / total;\n                    gl_FragColor.rgb /= gl_FragColor.a + 0.00001;\n                } else {\n                    gl_FragColor = texture2D(uSampler, vec2(vTextureCoord.s, vTextureCoord.t));\n                }\n            }\n        `\n\n        super(vertex, fragment)\n        \n        if (shape.type === 'circle') {\n            this.uniforms.shape = 1\n            this.uniforms.circle = [shape.x, shape.y, shape.r]\n        } else {\n            this.uniforms.shape = 2\n            this.uniforms.rectangle = [shape.x, shape.y, shape.x + shape.width, shape.y + shape.height]\n        }\n        this.uniforms.blur = blur\n        this.uniforms.delta = new PIXI.Point(0, 0)\n        this.uniforms.texSize = new PIXI.Point(480, 270)\n\n        this.updateDelta()\n    }\n\n    /**\n     * The strength of the blur.\n     *\n     * @member {number}\n     * @memberof PIXI.filters.TiltShiftAxisFilter#\n     */\n    get blur() {\n        return this.uniforms.blur\n    }\n    set blur(value) {\n        this.uniforms.blur = value\n    }\n    \n    /**\n     * The blur shape.\n     *\n     * @member {PIXI.Rectangle}\n     * @memberof PIXI.filters.TiltShiftAxisFilter#\n     */\n    get shape() {\n        if (this.uniforms.shape === 1) {\n            const circle = this.uniforms.circle\n            return new PIXI.Circle(circle[0], circle[1], circle[2])\n        } else {\n            const rectangle = this.uniforms.rectangle\n            return new PIXI.Rectangle(rectangle[0], rectangle[1], rectangle[2], rectangle[3])\n        }\n    }\n    set shape(value) {\n        if (value.type === 'circle') {\n            this.uniforms.shape = 1\n            this.uniforms.circle = [value.x, value.y, value.r]\n        } else {\n            this.uniforms.shape = 2\n            this.uniforms.rectangle = [value.x, value.y, value.x + value.width, value.y + value.height]\n        }\n    }\n}\n\n/**\n * A TiltShiftXFilter.\n *\n * @class\n * @extends PIXI.TiltShiftAxisFilter\n * @private\n */\nclass TiltShiftXFilter extends TiltShiftAxisFilter {\n    /**\n     * Updates the filter delta values.\n     */\n    updateDelta() {\n        this.uniforms.delta.x = 0.1\n        this.uniforms.delta.y = 0\n    }\n}\n\n/**\n * A TiltShiftYFilter.\n *\n * @class\n * @extends PIXI.TiltShiftAxisFilter\n * @private\n */\nclass TiltShiftYFilter extends TiltShiftAxisFilter {\n    /**\n     * Updates the filter delta values.\n     */\n    updateDelta() {\n        this.uniforms.delta.x = 0\n        this.uniforms.delta.y = 0.1\n    }\n}\n\n","// In order to test this interface implementation run jsc interface.js\n\nexport default class Interface {\n    // Abstract interface that should be extended in interface subclasses.\n    // By convention all interfaces should start with an upper 'I'\n\n    static implementationError(klass) {\n        let interfaceKeys = Reflect.ownKeys(this.prototype)\n        let classKeys = Reflect.ownKeys(klass.prototype)\n        for(let key of interfaceKeys) {\n            let interfaceDesc = this.prototype[key]\n            let classDesc = klass.prototype[key]\n            if (typeof(classDesc) == 'undefined')\n                return 'Missing ' + key\n        }\n        return null\n    }\n\n    static implementedBy(klass) {\n        // In the first step only checks whether the methods of this\n        // interface are all implemented by the given class\n        let error = this.implementationError(klass)\n        return error == null\n    }\n\n        // TODO: Specify optional methods\n//     static optionalMethods() {\n//         return [this.onMouseWheel]\n//     }\n}\n","/* globals Hammer, propagating */\n/*eslint no-console: [\"error\", { allow: [\"log\", \"warn\", \"info\", \"error\"] }]*/\n\nimport Interface from './interface.js'\nimport { Points, Angle, MapProxy } from './utils.js'\nimport Events from './events.js'\n\n/** Interaction patterns\n\n    See interaction.html for explanation\n*/\n\nexport class IInteractionTarget extends Interface {\n    capture(event) {\n        return typeof true\n    }\n\n    onStart(event, interaction) { }\n    onMove(event, interaction) { }\n    onEnd(event, interaction) { }\n\n    onMouseWheel(event) { }\n}\n\nexport class IInteractionMapperTarget extends Interface {\n    capture(event) {\n        return typeof true\n    }\n\n    findTarget(event, local, global) {\n        return IInteractionTarget\n    }\n}\n\nexport class PointMap extends MapProxy {\n    // Collects touch points, mouse coordinates, etc. as key value pairs.\n    // Keys are pointer and touch ids, the special \"mouse\" key.\n    // Values are points, i.e. all objects with numeric x and y properties.\n    constructor(points = {}) {\n        super()\n        for (let key in points) {\n            this.set(key, points[key])\n        }\n    }\n\n    toString() {\n        let points = []\n        for (let key of this.keys()) {\n            let value = this.get(key)\n            points.push(`${key}:{x:${value.x}, y:${value.y}}`)\n        }\n        let attrs = points.join(', ')\n        return `[PointMap ${attrs}]`\n    }\n\n    clone() {\n        let result = new PointMap()\n        for (let key of this.keys()) {\n            let value = this.get(key)\n            result.set(key, { x: value.x, y: value.y })\n        }\n        return result\n    }\n\n    keyOf(value) {\n        for (let key of this.keys()) {\n            let p = this.get(key)\n            if (p.x == value.x && p.y == value.y) {\n                return key\n            }\n        }\n        return null\n    }\n\n    firstKey() {\n        for (let key of this.keys()) {\n            return key\n        }\n        return null\n    }\n\n    first() {\n        for (let key of this.keys()) {\n            return this.get(key)\n        }\n        return null\n    }\n\n    farthests() {\n        if (this.size == 0) {\n            return null\n        }\n        let pairs = []\n        for (let key of this.keys()) {\n            let p = this.get(key)\n            p.key = key\n            for (let k of this.keys()) {\n                let q = this.get(k)\n                q.key = k\n                pairs.push([p, q])\n            }\n        }\n        let sorted = pairs.sort((a, b) => {\n            return Points.distance(b[0], b[1]) - Points.distance(a[0], a[1])\n        })\n        return sorted[0]\n    }\n\n    mean() {\n        if (this.size == 0) {\n            return null\n        }\n        let x = 0.0,\n            y = 0.0\n        for (let p of this.values()) {\n            x += p.x\n            y += p.y\n        }\n        return { x: x / this.size, y: y / this.size }\n    }\n}\n\nexport class InteractionDelta {\n    constructor(x, y, zoom, rotate, about) {\n        this.x = x\n        this.y = y\n        this.zoom = zoom\n        this.rotate = rotate\n        this.about = about\n    }\n\n    toString() {\n        let values = []\n        for (let key of Object.keys(this)) {\n            let value = this[key]\n            if (key == 'about') {\n                values.push(`${key}:{x:${value.x}, y:${value.y}}`)\n            } else {\n                values.push(`${key}:${value}`)\n            }\n        }\n        let attrs = values.join(', ')\n        return `[InteractionDelta ${attrs}]`\n    }\n}\n\nexport class InteractionPoints {\n    constructor(parent = null) {\n        this.parent = parent\n        this.current = new PointMap()\n        this.previous = new PointMap()\n        this.start = new PointMap()\n        this.ended = new PointMap()\n        this.timestamps = new Map()\n    }\n\n    moved(key) {\n        let current = this.current.get(key)\n        let previous = this.previous.get(key)\n        return Points.subtract(current, previous)\n    }\n\n    move() {\n        let current = this.current.mean()\n        let previous = this.previous.mean()\n        return Points.subtract(current, previous)\n    }\n\n    /**\n     * Computes the delta between previous and current angles. Corrects\n     * value that are larger than 45°\n     * @param {*} a\n     * @param {*} b\n     * @returns delta\n     */\n    diffAngle(a, b) {\n        let alpha = Math.atan2(Math.sin(a - b), Math.cos(a - b))\n        if (Math.abs(alpha) > Math.PI / 4) {\n            alpha -= Math.PI\n        }\n        return alpha\n    }\n\n    /**\n     * Computes the delta between interaction points at t and t+1.\n     *\n     * @returns InteractionDelta\n     * @memberof InteractionPoints\n     */\n    delta() {\n        let csize = this.current.size\n        let psize = this.previous.size\n        if (csize >= 2 && csize == psize) {\n            // Reduce to the two farthests points\n            let current = this.current.farthests()\n\n            let c1 = current[0]\n            let c2 = current[1]\n\n            let p1 = this.previous.get(c1.key)\n            let p2 = this.previous.get(c2.key)\n\n            //let p1 = previous[0]\n            //let p2 = previous[1]\n\n            let d1 = Points.subtract(c1, p1)\n            let d2 = Points.subtract(c2, p2)\n            let cm = Points.mean(c1, c2)\n            //let pm = Points.mean(p1, p2)\n            // UO: Using the mean lead to jumps between time slices with 3 and 2 fingers\n            // We use the mean of deltas instead\n            let delta = Points.mean(d1, d2) //Points.subtract(cm, pm)\n            let zoom = 1.0\n            let distance1 = Points.distance(p1, p2)\n            let distance2 = Points.distance(c1, c2)\n            if (distance1 != 0 && distance2 != 0) {\n                zoom = distance2 / distance1\n            }\n            let currentAngle = Points.angle(c1, c2)\n            let previousAngle = Points.angle(p1, p2)\n            let alpha = this.diffAngle(currentAngle, previousAngle)\n            return new InteractionDelta(delta.x, delta.y, zoom, alpha, cm)\n        } else if (csize == 1 && psize == 1 && this.current.firstKey() == this.previous.firstKey()) {\n            // We need to ensure that the keys are the same\n            let current = this.current.first()\n            let previous = this.previous.first()\n            let delta = Points.subtract(current, previous)\n            return new InteractionDelta(delta.x, delta.y, 1.0, 0.0, current)\n        }\n        return null\n    }\n\n    started(key, point) {\n        this.current.set(key, point)\n        this.start.set(key, point)\n        this.previous.set(key, point)\n        this.timestamps.set(key, performance.now())\n    }\n\n    update(key, point) {\n        // Returns true iff the key is new\n        this.current.set(key, point)\n        if (!this.start.has(key)) {\n            this.start.set(key, point)\n            this.previous.set(key, point)\n            this.timestamps.set(key, performance.now())\n            return true\n        }\n        return false\n    }\n\n    updatePrevious() {\n        for (let key of this.current.keys()) {\n            this.previous.set(key, this.current.get(key))\n        }\n    }\n\n    stop(key, point) {\n        if (this.current.has(key)) {\n            this.current.delete(key)\n            this.previous.delete(key)\n            this.ended.set(key, point)\n        }\n    }\n\n    finish(key, point) {\n        this.current.delete(key)\n        this.previous.delete(key)\n        this.start.delete(key)\n        this.timestamps.delete(key)\n        this.ended.delete(key)\n    }\n\n    isFinished() {\n        return this.current.size == 0\n    }\n\n    isNoLongerTwoFinger() {\n        return this.previous.size > 1 && this.current.size < 2\n    }\n\n    isTap(key) {\n        return this.parent.isTap(key)\n    }\n\n    isDoubleTap(key) {\n        return this.parent.isDoubleTap(key)\n    }\n\n    isLongPress(key) {\n        return this.parent.isLongPress(key)\n    }\n}\n\nexport class Interaction extends InteractionPoints {\n    constructor(tapDistance = 10, tapDuration = 250.0, longPressTime = 500.0) {\n        super()\n        this.tapDistance = tapDistance\n        this.tapCounts = new Map()\n        this.tapPositions = new Map()\n        this.tapTimestamps = new Map()\n        this.tapDuration = tapDuration\n        this.longPressTime = longPressTime\n        this.targets = new Map()\n        this.subInteractions = new Map() // target:Object : InteractionPoints\n    }\n\n    stop(key, point) {\n        super.stop(key, point)\n        for (let points of this.subInteractions.values()) {\n            points.stop(key, point)\n        }\n    }\n\n    addTarget(key, target) {\n        this.targets.set(key, target)\n        this.subInteractions.set(target, new InteractionPoints(this))\n    }\n\n    removeTarget(key) {\n        let target = this.targets.get(key)\n        this.targets.delete(key)\n        // Only remove target if no keys are refering to the target\n        let remove = true\n        for (let t of this.targets.values()) {\n            if (target === t) {\n                remove = false\n            }\n        }\n        if (remove) {\n            this.subInteractions.delete(target)\n        }\n    }\n\n    finish(key, point) {\n        super.finish(key, point)\n        this.removeTarget(key)\n    }\n\n    mapInteraction(points, aspects, mappingFunc) {\n        // Map centrally registered points to target interactions\n        // Returns an array of [target, updated subInteraction] pairs\n        let result = new Map()\n        for (let key in points) {\n            if (this.targets.has(key)) {\n                let target = this.targets.get(key)\n                if (this.subInteractions.has(target)) {\n                    let interaction = this.subInteractions.get(target)\n                    for (let aspect of aspects) {\n                        let pointMap = this[aspect]\n                        let point = pointMap.get(key)\n                        let mapped = mappingFunc(point, target)\n                        interaction[aspect].set(key, mapped)\n                    }\n                    result.set(target, interaction)\n                }\n            }\n        }\n        return result\n    }\n\n    registerTap(key, point) {\n        if (this.tapCounts.has(key)) {\n            let count = this.tapCounts.get(key)\n            this.tapCounts.set(key, count+1)\n        }\n        else {\n            this.tapCounts.set(key, 1)\n        }\n        this.tapPositions.set(key, point)\n        this.tapTimestamps.set(key, performance.now())\n    }\n\n    unregisterTap(key) {\n        this.tapCounts.delete(key)\n        this.tapPositions.delete(key)\n        this.tapTimestamps.delete(key)\n    }\n\n    isTap(key) {\n        let ended = this.ended.get(key)\n        let start = this.start.get(key)\n        if (\n            start &&\n            ended &&\n            Points.distance(ended, start) < this.tapDistance\n        ) {\n            let t1 = this.timestamps.get(key)\n            let tookLong = performance.now() > t1 + this.longPressTime\n            if (tookLong) {\n                return false\n            }\n            return true\n        }\n        return false\n    }\n\n    isDoubleTap(key) {\n        let ended = this.ended.get(key)\n        if (this.tapCounts.has(key) && this.tapCounts.get(key) > 2) {\n            this.unregisterTap(key)\n        }\n        if (this.tapPositions.has(key)) {\n            let pos = this.tapPositions.get(key)\n            if (Points.distance(ended, pos) > this.tapDistance) {\n                this.unregisterTap(key)\n            }\n        }\n        if (this.tapTimestamps.has(key) && performance.now() > this.tapTimestamps.get(key) + this.tapDuration) {\n            //console.log(\"tap too long\")\n            this.unregisterTap(key)\n        }\n        let result = false\n        if (this.isTap(key)) {\n            \n            this.registerTap(key, ended)\n            result = this.tapCounts.get(key) == 2\n        }\n        else {\n            this.unregisterTap(key)\n        }\n        //console.log(\"isDoubleTap\", this.tapCounts.get(key), result)\n        return result\n    }\n\n    isAnyTap() {\n        for (let key of this.ended.keys()) {\n            if (this.isTap(key)) return true\n        }\n        return false\n    }\n\n    isLongPress(key) {\n        let ended = this.ended.get(key)\n        let start = this.start.get(key)\n        if (\n            start &&\n            ended &&\n            Points.distance(ended, start) < this.tapDistance\n        ) {\n            let t1 = this.timestamps.get(key)\n            let tookLong = performance.now() > t1 + this.longPressTime\n            if (tookLong) {\n                return true\n            }\n            return false\n        }\n        return false\n    }\n\n    isAnyLongPress() {\n        for (let key of this.ended.keys()) {\n            if (this.isLongPress(key)) return true\n        }\n        return false\n    }\n\n    isStylus(key) {\n        return key === 'stylus'\n    }\n}\n\n/**\n * This class implements the main delegate functionality: All necessary event handlers are registered for the\n * given element. Uses PointerEvents if available or TouchEvents on iOS. The fallback is on mouse events.\n * Collects the events if the interaction target captures the start event (i.e. declares that\n * the target wants the start event as well as all following move and end evcents.)\n *\n * @export\n * @class InteractionDelegate\n */\nexport class InteractionDelegate {\n    // Long press: http://stackoverflow.com/questions/1930895/how-long-is-the-event-onlongpress-in-the-android\n    // Stylus support: https://w3c.github.io/touch-events/\n\n    /**\n     * Creates an instance of InteractionDelegate.\n     * @param {any} element\n     * @param {any} target\n     * @param {any} [{ mouseWheelElement = null, useCapture = true, capturePointerEvents = true, debug = false }={}]\n     * @memberof InteractionDelegate\n     */\n    constructor(\n        element,\n        target,\n        { mouseWheelElement = null, useCapture = true, capturePointerEvents = true, cancelOnWindowOut = true, debug = false } = {}\n    ) {\n        this.debug = debug\n        this.interaction = new Interaction()\n        this.element = element\n        this.mouseWheelElement = mouseWheelElement || element\n        this.target = target\n        this.useCapture = useCapture\n        this.capturePointerEvents = capturePointerEvents\n        this.cancelOnWindowOut = cancelOnWindowOut\n        this.setupInteraction()\n    }\n\n    setupInteraction() {\n        if (this.debug) {\n            let error = this.targetInterface.implementationError(\n                this.target.constructor\n            )\n            if (error != null) {\n                throw new Error('Expected IInteractionTarget: ' + error)\n            }\n        }\n        this.setupTouchInteraction()\n        this.setupMouseWheelInteraction()\n    }\n\n    get targetInterface() {\n        return IInteractionTarget\n    }\n\n    setupTouchInteraction() {\n        let element = this.element\n        let useCapture = this.useCapture\n        if (window.PointerEvent) {\n            if (this.debug) console.log('Pointer API' + window.PointerEvent)\n            element.addEventListener(\n                'pointerdown',\n                e => {\n                    if (this.debug) console.log('pointerdown', e.pointerId)\n                    if (this.capture(e)) {\n                        if (this.capturePointerEvents) {\n                            try {\n                                element.setPointerCapture(e.pointerId)\n                            } catch (e) { }\n                        }\n                        this.onStart(e)\n                    }\n                },\n                useCapture\n            )\n            element.addEventListener(\n                'pointermove',\n                e => {\n                    if (this.debug) console.log('pointermove', e.pointerId)\n\n                    if (\n                        e.pointerType == 'touch' ||\n                        (e.pointerType == 'mouse' && Events.isMouseDown(e))\n                    ) {\n                        // this.capture(e) &&\n                        if (this.debug)\n                            console.log('pointermove captured', e.pointerId)\n                        this.onMove(e)\n                    }\n                },\n                useCapture\n            )\n            element.addEventListener(\n                'pointerup',\n                e => {\n                    if (this.debug) console.log('pointerup')\n                    this.onEnd(e)\n                    if (this.capturePointerEvents) {\n                        try {\n                            element.releasePointerCapture(e.pointerId)\n                        } catch (e) { }\n                    }\n                },\n                useCapture\n            )\n            element.addEventListener(\n                'pointercancel',\n                e => {\n                    if (this.debug) console.log('pointercancel')\n                    this.onEnd(e)\n                    if (this.capturePointerEvents)\n                        element.releasePointerCapture(e.pointerId)\n                },\n                useCapture\n            )\n\n            if (!this.capturePointerEvents) {\n                element.addEventListener(\n                    'pointerleave',\n                    e => {\n                        if (this.debug) console.log('pointerleave')\n                        if (e.target == element) this.onEnd(e)\n                    },\n                    useCapture\n                )\n            }\n\n            if (!this.capturePointerEvents) {\n                element.addEventListener(\n                    'pointerout',\n                    e => {\n                        if (this.debug) console.log('pointerout')\n                        if (e.target == element) this.onEnd(e)\n                    },\n                    useCapture\n                )\n            }\n\n            if (this.cancelOnWindowOut) {\n                window.addEventListener(\n                    'pointerout',\n                    e => {\n                        if (e.target == element) {\n                            this.onEnd(e)\n                        }\n                    },\n                    useCapture)\n            }\n\n        } else if (window.TouchEvent) {\n            if (this.debug) console.log('Touch API')\n            element.addEventListener(\n                'touchstart',\n                e => {\n                    if (this.debug)\n                        console.log('touchstart', this.touchPoints(e))\n                    if (this.capture(e)) {\n                        for (let touch of e.changedTouches) {\n                            this.onStart(touch)\n                        }\n                    }\n                },\n                useCapture\n            )\n            element.addEventListener(\n                'touchmove',\n                e => {\n                    if (this.debug)\n                        console.log('touchmove', this.touchPoints(e), e)\n                    for (let touch of e.changedTouches) {\n                        this.onMove(touch)\n                    }\n                    for (let touch of e.targetTouches) {\n                        this.onMove(touch)\n                    }\n                },\n                useCapture\n            )\n            element.addEventListener(\n                'touchend',\n                e => {\n                    if (this.debug) console.log('touchend', this.touchPoints(e))\n                    for (let touch of e.changedTouches) {\n                        this.onEnd(touch)\n                    }\n                },\n                useCapture\n            )\n            element.addEventListener(\n                'touchcancel',\n                e => {\n                    if (this.debug)\n                        console.log(\n                            'touchcancel',\n                            e.targetTouches.length,\n                            e.changedTouches.length\n                        )\n                    for (let touch of e.changedTouches) {\n                        this.onEnd(touch)\n                    }\n                },\n                useCapture\n            )\n        } else {\n            if (this.debug) console.log('Mouse API')\n\n            element.addEventListener(\n                'mousedown',\n                e => {\n                    if (this.debug) console.log('mousedown', e)\n                    if (this.capture(e)) {\n                        this.onStart(e)\n                    }\n                },\n                useCapture\n            )\n            element.addEventListener(\n                'mousemove',\n                e => {\n                    // Dow we only use move events if the mouse is down?\n                    // HOver effects have to be implemented by other means\n                    // && Events.isMouseDown(e))\n\n                    if (Events.isMouseDown(e)) {\n                        if (this.debug)\n                            console.log('mousemove', e)\n                        this.onMove(e)\n                    }\n                },\n                useCapture\n            )\n            element.addEventListener(\n                'mouseup',\n                e => {\n                    if (this.debug) console.log('mouseup', e)\n                    this.onEnd(e)\n                },\n                true\n            )\n\n            if (!this.capturePointerEvents) {\n                element.addEventListener(\n                    'mouseout',\n                    e => {\n                        if (e.target == element) {\n                            this.onEnd(e)\n                            console.warn(\"Shouldn't happen: mouseout ends interaction\")\n                        }\n\n                    },\n                    useCapture\n                )\n            }\n            if (this.cancelOnWindowOut) {\n                window.addEventListener(\n                    'mouseout',\n                    e => {\n                        if (e.target == element) {\n                            this.onEnd(e)\n                        }\n                    },\n                    useCapture)\n            }\n        }\n    }\n\n    isDescendant(parent, child) {\n        if (parent == child) return true\n        let node = child.parentNode\n        while (node != null) {\n            if (node == parent) {\n                return true\n            }\n            node = node.parentNode\n        }\n        return false\n    }\n\n    touchPoints(event) {\n        let result = []\n        for (let touch of event.changedTouches) {\n            result.push(this.extractPoint(touch))\n        }\n        return result\n    }\n\n    setupMouseWheelInteraction() {\n        this.mouseWheelElement.addEventListener(\n            'mousewheel',\n            this.onMouseWheel.bind(this),\n            true\n        )\n        this.mouseWheelElement.addEventListener(\n            'DOMMouseScroll',\n            this.onMouseWheel.bind(this),\n            true\n        )\n    }\n\n    onMouseWheel(event) {\n        if (this.capture(event) && this.target.onMouseWheel) {\n            this.target.onMouseWheel(event)\n        } else {\n            //console.warn('Target has no onMouseWheel callback')\n        }\n    }\n\n    onStart(event) {\n        let extracted = this.extractPoint(event)\n        this.startInteraction(event, extracted)\n        this.target.onStart(event, this.interaction)\n    }\n\n    onMove(event) {\n        let extracted = this.extractPoint(event, 'all')\n        this.updateInteraction(event, extracted)\n        this.target.onMove(event, this.interaction)\n        this.interaction.updatePrevious()\n    }\n\n    onEnd(event) {\n        let extracted = this.extractPoint(event, 'changedTouches')\n        this.endInteraction(event, extracted)\n        this.target.onEnd(event, this.interaction)\n        this.finishInteraction(event, extracted)\n    }\n\n    /**\n     * Asks the target whether the event should be captured\n     *\n     * @param {any} event\n     * @returns {bool}\n     * @memberof InteractionDelegate\n     */\n    capture(event) {\n        if (Events.isCaptured(event)) {\n            return false\n        }\n        let captured = this.target.capture(event)\n        return captured\n    }\n\n    getPosition(event) {\n        return { x: event.clientX, y: event.clientY }\n    }\n\n    extractPoint(event, touchEventKey = 'all') {\n        // 'targetTouches'\n        let result = {}\n        switch (event.constructor.name) {\n            case 'MouseEvent':\n                let buttons = event.buttons || event.which\n                if (buttons) result['mouse'] = this.getPosition(event)\n                break\n            case 'PointerEvent':\n                result[event.pointerId.toString()] = this.getPosition(event)\n                break\n            case 'Touch':\n                let id =\n                    event.touchType === 'stylus'\n                        ? 'stylus'\n                        : event.identifier.toString()\n                result[id] = this.getPosition(event)\n                break\n            //             case 'TouchEvent':\n            //                 // Needs to be observed: Perhaps changedTouches are all we need. If so\n            //                 // we can remove the touchEventKey default parameter\n            //                 if (touchEventKey == 'all') {\n            //                     for(let t of event.targetTouches) {\n            //                         result[t.identifier.toString()] = this.getPosition(t)\n            //                     }\n            //                     for(let t of event.changedTouches) {\n            //                         result[t.identifier.toString()] = this.getPosition(t)\n            //                     }\n            //                 }\n            //                 else {\n            //                     for(let t of event.changedTouches) {\n            //                         result[t.identifier.toString()] = this.getPosition(t)\n            //                     }\n            //                 }\n            //                 break\n            default:\n                break\n        }\n        return result\n    }\n\n    interactionStarted(event, key, point) {\n        // Callback: can be overwritten\n    }\n\n    interactionEnded(event, key, point) {\n        // Callback: can be overwritten\n    }\n\n    interactionFinished(event, key, point) { }\n\n    startInteraction(event, extracted) {\n        for (let key in extracted) {\n            let point = extracted[key]\n            this.interaction.started(key, point)\n            this.interactionStarted(event, key, point)\n        }\n    }\n\n    updateInteraction(event, extracted) {\n        for (let key in extracted) {\n            let point = extracted[key]\n            let updated = this.interaction.update(key, point)\n            if (updated) {\n                console.warn(\"new pointer in updateInteraction shouldn't happen\")\n                this.interactionStarted(event, key, point)\n            }\n        }\n    }\n\n    endInteraction(event, ended) {\n        for (let key in ended) {\n            let point = ended[key]\n            this.interaction.stop(key, point)\n            this.interactionEnded(event, key, point)\n        }\n    }\n\n    finishInteraction(event, ended) {\n        for (let key in ended) {\n            let point = ended[key]\n            this.interaction.finish(key, point)\n            this.interactionFinished(event, key, point)\n        }\n    }\n}\n/**\n * A special InteractionDelegate that maps events to specific parts of\n * the interaction target. The InteractionTarget must implement a findTarget\n * method that returns an object implementing the IInteractionTarget interface.\n *\n * If the InteractionTarget also implements a mapPositionToPoint method this\n * is used to map the points to the local coordinate space of the the target.\n *\n * This makes it easier to lookup elements and relate events to local\n * positions.\n *\n * @export\n * @class InteractionMapper\n * @extends {InteractionDelegate}\n */\nexport class InteractionMapper extends InteractionDelegate {\n\n    constructor(\n        element,\n        target,\n        { tapDistance = 10, longPressTime = 500.0, useCapture = true, mouseWheelElement = null } = {}\n    ) {\n        super(element, target, { tapDistance, useCapture, longPressTime, mouseWheelElement })\n    }\n\n    get targetInterface() {\n        return IInteractionMapperTarget\n    }\n\n    mapPositionToPoint(point, element = null) {\n        if (this.target.mapPositionToPoint) {\n            return this.target.mapPositionToPoint(point, element)\n        }\n        return point\n    }\n\n    interactionStarted(event, key, point) {\n        if (this.target.findTarget) {\n            let local = this.mapPositionToPoint(point)\n            let found = this.target.findTarget(event, local, point)\n            if (found != null) {\n                this.interaction.addTarget(key, found)\n            }\n        }\n    }\n\n    onMouseWheel(event) {\n        if (this.capture(event)) {\n            if (this.target.findTarget) {\n                let point = this.getPosition(event)\n                let local = this.mapPositionToPoint(point)\n                let found = this.target.findTarget(event, local, point)\n                if (found != null && found.onMouseWheel) {\n                    found.onMouseWheel(event)\n                    return\n                }\n            }\n            if (this.target.onMouseWheel) {\n                this.target.onMouseWheel(event)\n            } else {\n                //console.warn('Target has no onMouseWheel callback', this.target)\n            }\n        }\n    }\n\n    onStart(event) {\n        let extracted = this.extractPoint(event)\n        this.startInteraction(event, extracted)\n        let mapped = this.interaction.mapInteraction(\n            extracted,\n            ['current', 'start'],\n            this.mapPositionToPoint.bind(this)\n        )\n        for (let [target, interaction] of mapped.entries()) {\n            target.onStart(event, interaction)\n        }\n    }\n\n    onMove(event) {\n        let extracted = this.extractPoint(event, 'all')\n        this.updateInteraction(event, extracted)\n        let mapped = this.interaction.mapInteraction(\n            extracted,\n            ['current', 'previous'],\n            this.mapPositionToPoint.bind(this)\n        )\n        for (let [target, interaction] of mapped.entries()) {\n            target.onMove(event, interaction)\n            interaction.updatePrevious()\n        }\n        this.interaction.updatePrevious()\n    }\n\n    onEnd(event) {\n        let extracted = this.extractPoint(event, 'changedTouches')\n        this.endInteraction(event, extracted)\n        let mapped = this.interaction.mapInteraction(\n            extracted,\n            ['ended'],\n            this.mapPositionToPoint.bind(this)\n        )\n        for (let [target, interaction] of mapped.entries()) {\n            target.onEnd(event, interaction)\n        }\n        this.finishInteraction(event, extracted)\n    }\n\n    /**\n     *\n     *\n     * @static\n     * @param {string|array} types - An event type, an array of event types or event types seperated by a space sign. The following\n     *     events are possible:\n     *         pan, panstart, panmove, panend, pancancel, panleft, panright, panup, pandown\n     *         pinch, pinchstart, pinchmove, pinchend, pinchcancel, pinchin, pinchout\n     *         press, pressup\n     *         rotate, rotatestart, rotatemove, rotateend, rotatecancel\n     *         swipe, swipeleft, swiperight, swipeup, swipedown\n     *         tap\n     * @param {HTMLElement|HTMLElement[]} elements - An HTML element or an array of HTML elements.\n     * @param {function} [cb] - The callback. A function which is executed after the event occurs. Receives the event object as the\n     *     first paramter\n     * @param {object} [opts] - An options object. See the hammer documentation for more details.\n     */\n    static on(types, elements, cb, opts = {}) {\n        opts = Object.assign({}, {\n\n        }, opts)\n\n        if (typeof Hammer === 'undefined') {\n            console.error('Hammer.js not found!')\n            return this\n        }\n\n        // convert to array\n        types = Array.isArray(types) ? types : types.split(/\\s/)\n        if (elements instanceof NodeList || elements instanceof HTMLCollection) {\n            elements = Array.from(elements)\n        }\n        elements = Array.isArray(elements) ? elements : [elements]\n\n        for (let i = 0; i < types.length; i++) {\n\n            const type = types[i].toLowerCase()\n\n            // list of hammer events\n            const useHammer = /^(tap|doubletap|press|pan|swipe|pinch|rotate).*$/.test(type)\n\n            // if it is a hammer event\n            if (useHammer) {\n\n                for (let j = 0; j < elements.length; j++) {\n\n                    // if(elements[j].tagName == \"svg\") return false;\n\n                    let hammer = new Hammer(elements[j], opts)\n\n                    if (window.propagating !== 'undefined') {\n                        hammer = propagating(hammer)\n                    }\n\n                    // recognizers\n                    if (type.startsWith('pan')) {\n                        hammer.get('pan').set(Object.assign({ direction: Hammer.DIRECTION_ALL }, opts))\n                    } else if (type.startsWith('pinch')) {\n                        hammer.get('pinch').set(Object.assign({ enable: true }, opts))\n                    } else if (type.startsWith('press')) {\n                        hammer.get('press').set(opts)\n                    } else if (type.startsWith('rotate')) {\n                        hammer.get('rotate').set(Object.assign({ enable: true }, opts))\n                    } else if (type.startsWith('swipe')) {\n                        hammer.get('swipe').set(Object.assign({ direction: Hammer.DIRECTION_ALL }, opts))\n                    } else if (type.startsWith('tap')) {\n                        hammer.get('tap').set(opts)\n                    }\n\n                    hammer.on(type, event => {\n                        cb(event)\n                    })\n                }\n\n            } else {\n\n                for (let j = 0; j < elements.length; j++) {\n                    Hammer.on(elements[j], type, event => {\n                        cb(event)\n                    })\n                }\n            }\n        }\n\n        return this\n    }\n}\n\nwindow.InteractionMapper = InteractionMapper\n","/** Report capabilities with guaranteed values.\n */\nexport class Capabilities {\n\n    /** Returns the browser userAgent.\n    @return {string}\n    */\n    static get userAgent() {\n        return navigator.userAgent || 'Unknown Agent'\n    }\n\n    /** Tests whether the app is running on a mobile device.\n    Implemented as a readonly attribute.\n    @return {boolean}\n    */\n    static get isMobile() {\n        return (/Mobi/.test(navigator.userAgent))\n    }\n\n    /** Tests whether the app is running on a iOS device.\n    Implemented as a readonly attribute.\n    @return {boolean}\n    */\n    static get isIOS() {\n        return (/iPad|iPhone|iPod/.test(navigator.userAgent)) && !window.MSStream\n    }\n\n    /** Tests whether the app is running in a Safari environment.\n    See https://stackoverflow.com/questions/7944460/detect-safari-browser\n    Implemented as a readonly attribute.\n    @return {boolean}\n    */\n    static get isSafari() {\n        return navigator.vendor && navigator.vendor.indexOf('Apple') > -1 && navigator.userAgent && !navigator.userAgent.match('CriOS')\n    }\n\n    /**\n     * Distincts if the app is running inside electron or not.\n     * \n     * source: https://discuss.atom.io/t/detect-electron-or-web-page-running/33180/3\n     */\n    static get isElectron() {\n        return typeof process != 'undefined' && process.versions && process.versions.electron !== undefined\n    }\n\n    /** Returns the display resolution. Necessary for retina displays.\n    @return {number}\n    */\n    static get devicePixelRatio() {\n        return window.devicePixelRatio || 1\n    }\n\n    /** Returns true if the device is a multi-touch table. This method is currently not universal usable and not sure!\n    @return {boolean}\n    */\n    static get isMultiTouchTable() {\n        return Capabilities.devicePixelRatio > 2 && Capabilities.isMobile === false && /Windows/i.test(Capabilities.userAgent)\n    }\n\n    /** Returns true if mouse events are supported\n    @return {boolean}\n    */\n    static supportsMouseEvents() {\n        return typeof(window.MouseEvent) != 'undefined'\n    }\n\n    /** Returns true if touch events are supported\n    @return {boolean}\n    */\n    static supportsTouchEvents() {\n        return typeof(window.TouchEvent) != 'undefined'\n    }\n\n    /** Returns true if pointer events are supported\n    @return {boolean}\n    */\n    static supportsPointerEvents() {\n        return typeof(window.PointerEvent) != 'undefined'\n    }\n\n    /** Returns true if DOM templates are supported\n    @return {boolean}\n    */\n    static supportsTemplate() {\n        return 'content' in document.createElement('template');\n    }\n}\n\n/** Basic tests for Capabilities.\n */\nexport class CapabilitiesTests {\n\n    static testConfirm() {\n        let bool = confirm('Please confirm')\n        document.getElementById('demo').innerHTML = (bool) ? 'Confirmed' : 'Not confirmed'\n    }\n\n    static testPrompt() {\n        let person = prompt('Please enter your name', 'Harry Potter')\n        if (person != null) {\n            demo.innerHTML =\n            'Hello ' + person + '! How are you today?'\n        }\n    }\n\n    static testUserAgent() {\n        let agent = 'User-agent: ' + Capabilities.userAgent\n        user_agent.innerHTML = agent\n    }\n\n    static testDevicePixelRatio() {\n        let value = 'Device Pixel Ratio: ' + Capabilities.devicePixelRatio\n        device_pixel_ratio.innerHTML = value\n    }\n\n    static testMultiTouchTable() {\n        let value = 'Is the device a multi-touch table? ' + Capabilities.isMultiTouchTable\n        multi_touch_table.innerHTML = value\n    }\n\n    static testSupportedEvents() {\n        let events = []\n        if (Capabilities.supportsMouseEvents()) {\n            events.push('MouseEvents')\n        }\n        if (Capabilities.supportsTouchEvents()) {\n            events.push('TouchEvents')\n        }\n        if (Capabilities.supportsPointerEvents()) {\n            events.push('PointerEvents')\n        }\n        supported_events.innerHTML = 'Supported Events: ' + events.join(', ')\n    }\n\n    static testAll() {\n        this.testUserAgent()\n        this.testDevicePixelRatio()\n        this.testMultiTouchTable()\n        this.testSupportedEvents()\n    }\n}\n\n/* Optional global variables, needed in DocTests. */\nwindow.Capabilities = Capabilities\nwindow.CapabilitiesTests = CapabilitiesTests\n","import { Points, Polygon, Angle, Elements } from './utils.js'\nimport Events from './events.js'\nimport { InteractionMapper } from './interaction.js'\nimport { Capabilities } from './capabilities.js'\n\n/**\n * A base class for scatter specific events.\n *\n * @constructor\n * @param {name} String - The name of the event\n * @param {target} Object - The target of the event\n */\nexport class BaseEvent {\n    constructor(name, target) {\n        this.name = name\n        this.target = target\n    }\n}\n\n// Event types\nconst START = 'onStart'\nconst UPDATE = 'onUpdate'\nconst END = 'onEnd'\nconst ZOOM = 'onZoom'\nconst MOVE = 'onMove'\n\n/**\n * A scatter event that describes how the scatter has changed.\n *\n * @constructor\n * @param {target} Object - The target scatter of the event\n * @param {optional} Object - Optional parameter\n */\nexport class ScatterEvent extends BaseEvent {\n    constructor(\n        target,\n        {\n            translate = { x: 0, y: 0 },\n            scale = null,\n            rotate = 0,\n            about = null,\n            fast = false,\n            type = null\n        } = {}\n    ) {\n        super('scatterTransformed', { target: target })\n        this.translate = translate\n        this.scale = scale\n        this.rotate = rotate\n        this.about = about\n        this.fast = fast\n        this.type = type\n    }\n\n    toString() {\n        return (\n            \"Event('scatterTransformed', scale: \" +\n            this.scale +\n            ' about: ' +\n            this.about.x +\n            ', ' +\n            this.about.y +\n            ')'\n        )\n    }\n}\n\n/**\n * A scatter resize event that describes how the scatter has changed.\n *\n * @constructor\n * @param {target} Object - The target scatter of the event\n * @param {optional} Object - Optional parameter\n */\nexport class ResizeEvent extends BaseEvent {\n    constructor(target, { width = 0, height = 0 } = {}) {\n        super('scatterResized', { width: width, height: height })\n        this.width = width\n        this.height = height\n    }\n\n    toString() {\n        return (\n            'Event(scatterResized width: ' +\n            this.width +\n            'height: ' +\n            this.height +\n            ')'\n        )\n    }\n}\n\n/**\n * A abstract base class that implements the throwable behavior of a scatter\n * object.\n *\n * @constructor\n */\nclass Throwable {\n    constructor({\n        movableX = true,\n        movableY = true,\n        throwVisibility = 44,\n        throwDamping = 0.95,\n        autoThrow = true,\n        onThrowFinished = null\n    } = {}) {\n        this.movableX = movableX\n        this.movableY = movableY\n        this.throwVisibility = throwVisibility\n        this.throwDamping = throwDamping\n        this.autoThrow = autoThrow\n        this.velocities = []\n        this.velocity = null\n        this.timestamp = null\n        this.onThrowFinished = onThrowFinished\n        //console.log(\"onThrowFinished\", onThrowFinished)\n    }\n\n    observeVelocity() {\n        this.lastframe = performance.now()\n    }\n\n    addVelocity(delta, buffer = 5) {\n        let t = performance.now()\n        let dt = t - this.lastframe\n        this.lastframe = t\n        if (dt > 0) {\n            // Avoid division by zero errors later on\n            let velocity = { t: t, dt: dt, dx: delta.x, dy: delta.y }\n            this.velocities.push(velocity)\n            while (this.velocities.length > buffer) {\n                this.velocities.shift()\n            }\n        }\n    }\n\n    meanVelocity(milliseconds = 30) {\n        this.addVelocity({ x: 0, y: 0 })\n        let sum = { x: 0, y: 0 }\n        let count = 0\n        let t = 0\n        for (let i = this.velocities.length - 1; i > 0; i--) {\n            let v = this.velocities[i]\n            t += v.dt\n            let nv = { x: v.dx / v.dt, y: v.dy / v.dt }\n            sum = Points.add(sum, nv)\n            count += 1\n            if (t > milliseconds) {\n                break\n            }\n        }\n        if (count === 0) return sum // empty vector\n        return Points.multiplyScalar(sum, 1 / count)\n    }\n\n    killAnimation() {\n        this.velocity = null\n        this.velocities = []\n    }\n\n    startThrow() {\n        this.velocity = this.meanVelocity()\n        if (this.velocity != null) {\n            // Call next velocity to ansure that specializations\n            // that use keepOnStage are called\n            this.velocity = this.nextVelocity(this.velocity)\n            if (this.autoThrow) this.animateThrow(performance.now())\n        } else {\n            this.onDragComplete()\n        }\n    }\n\n    animateThrow(time) {\n        if (this.velocity != null) {\n            let t = performance.now()\n            let dt = t - this.lastframe\n            this.lastframe = t\n            // console.log(\"animateThrow\", dt)\n            let next = this.nextVelocity(this.velocity)\n            let prevLength = Points.length(this.velocity)\n            let nextLength = Points.length(next)\n            if (nextLength > prevLength) {\n                let factor = nextLength / prevLength\n                next = Points.multiplyScalar(next, 1 / factor)\n                console.log('Prevent acceleration', factor, this.velocity, next)\n            }\n            this.velocity = next\n            let d = Points.multiplyScalar(this.velocity, dt)\n            this._move(d)\n\n            this.onDragUpdate(d)\n            if (dt == 0 || this.needsAnimation()) {\n                requestAnimationFrame(this.animateThrow.bind(this))\n                return\n            } else {\n                if (this.isOutside()) {\n                    requestAnimationFrame(this.animateThrow.bind(this))\n                    return\n                }\n            }\n        }\n        this.onDragComplete()\n        if (this.onThrowFinished != null) {\n            this.onThrowFinished()\n        }\n    }\n\n    needsAnimation() {\n        if (this.velocity == null) {\n            return false\n        }\n        return Points.length(this.velocity) > 0.01\n    }\n\n    nextVelocity(velocity) {\n        // Must be overwritten: computes the changed velocity. Implement\n        // damping, collison detection, etc. here\n        let next = Points.multiplyScalar(velocity, this.throwDamping)\n        return {\n            x: (this.movableX) ? next.x : 0,\n            y: (this.movableY) ? next.y : 0\n        }\n    }\n\n    _move(delta) {\n        // Overwrite if necessary\n    }\n\n    onDragComplete() {\n        // Overwrite if necessary\n    }\n\n    onDragUpdate(delta) {\n        // Overwrite if necessary\n    }\n}\n\nexport class AbstractScatter extends Throwable {\n    constructor({\n        minScale = 0.1,\n        maxScale = 1.0,\n        startScale = 1.0,\n        autoBringToFront = true,\n        autoThrow = true,\n        translatable = true,\n        scalable = true,\n        rotatable = true,\n        resizable = false,\n        movableX = true,\n        movableY = true,\n        throwVisibility = 44,\n        throwDamping = 0.95,\n        overdoScaling = 1,\n        mouseZoomFactor = 1.1,\n        rotationDegrees = null,\n        rotation = null,\n        onTransform = null,\n        interactive = true,\n        onClose = null,\n        onThrowFinished = null,\n        scaleAutoClose = false,\n        scaleCloseThreshold = 0.10,\n        scaleCloseBuffer = 0.05\n    } = {}) {\n        if (rotationDegrees != null && rotation != null) {\n            throw new Error('Use rotationDegrees or rotation but not both')\n        } else if (rotation != null) {\n            rotationDegrees = Angle.radian2degree(rotation)\n        } else if (rotationDegrees == null) {\n            rotationDegrees = 0\n        }\n        super({\n            movableX,\n            movableY,\n            throwVisibility,\n            throwDamping,\n            autoThrow,\n            onThrowFinished\n        })\n\n        /**\n         * Closes the card when the minScale is reached and the \n         * card is released. Card can be saved by scaling it up again.\n         */\n        this.scaleAutoClose = scaleAutoClose\n        this.scaleCloseThreshold = scaleCloseThreshold\n        this.scaleCloseBuffer = scaleCloseBuffer\n        this.scaleAutoCloseTimeout = null\n\n        this.interactive = interactive\n        this.startRotationDegrees = rotationDegrees\n        this.startScale = startScale // Needed to reset object\n        this.minScale = minScale\n        this.maxScale = maxScale\n        this.overdoScaling = overdoScaling\n        this.translatable = translatable\n        if (!translatable) {\n            this.movableX = false\n            this.movableY = false\n        }\n        this.scalable = scalable\n        this.rotatable = rotatable\n        this.resizable = resizable\n        this.mouseZoomFactor = mouseZoomFactor\n        this.autoBringToFront = autoBringToFront\n        this.dragging = false\n        this.onTransform = onTransform != null ? [onTransform] : null\n        this.onClose = onClose != null ? [onClose] : null\n    }\n\n    addCloseEventCallback(callback) {\n        if (this.onClose == null) {\n            this.onClose = []\n        }\n        this.onClose.push(callback)\n    }\n\n    addTransformEventCallback(callback) {\n        if (this.onTransform == null) {\n            this.onTransform = []\n        }\n        this.onTransform.push(callback)\n    }\n\n    startGesture(interaction) {\n        this.bringToFront()\n        this.killAnimation()\n        this.observeVelocity()\n        return true\n    }\n\n    close() {\n        if (this.onClose) {\n            this.onClose.forEach(callback => callback(this))\n        }\n    }\n\n    gesture(interaction) {\n        let delta = interaction.delta()\n        //console.log(\"gesture\", delta)\n        if (delta != null) {\n            this.addVelocity(delta)\n            this.transform(delta, delta.zoom, delta.rotate, delta.about)\n            if (delta.zoom != 1) this.interactionAnchor = delta.about\n        }\n    }\n\n    get polygon() {\n        let w2 = this.width * this.scale / 2\n        let h2 = this.height * this.scale / 2\n        let center = this.center\n        let polygon = new Polygon(center)\n        polygon.addPoint({ x: -w2, y: -h2 })\n        polygon.addPoint({ x: w2, y: -h2 })\n        polygon.addPoint({ x: w2, y: h2 })\n        polygon.addPoint({ x: -w2, y: h2 })\n        polygon.rotate(this.rotation)\n        return polygon\n    }\n\n    isOutside() {\n        let stagePolygon = this.containerPolygon\n        if (stagePolygon == null)\n            return false\n        let polygon = this.polygon\n        if (polygon == null)\n            return false\n        let result = stagePolygon.intersectsWith(polygon)\n        return result === false || result.overlap < this.throwVisibility\n    }\n\n    recenter() {\n        // Return a small vector that guarantees that the scatter is moving\n        // towards the center of the stage\n        let center = this.center\n        let target = this.container.center\n        let delta = Points.subtract(target, center)\n        return Points.normalize(delta)\n    }\n\n    nextVelocity(velocity) {\n        return this.keepOnStage(velocity)\n    }\n\n    bouncing() {\n        // Implements the bouncing behavior of the scatter. Moves the scatter\n        // to the center of the stage if the scatter is outside the stage or\n        // not within the limits of the throwVisibility.\n\n        let stagePolygon = this.containerPolygon\n        let polygon = this.polygon\n        let result = stagePolygon.intersectsWith(polygon)\n        if (result === false || result.overlap < this.throwVisibility) {\n            let cv = this.recenter()\n            let recentered = false\n            while (result === false || result.overlap < this.throwVisibility) {\n                polygon.center.x += cv.x\n                polygon.center.y += cv.y\n                this._move(cv)\n                result = stagePolygon.intersectsWith(polygon)\n                recentered = true\n            }\n            return recentered\n        }\n        return false\n    }\n\n    keepOnStage(velocity, collision = 0.5) {\n        let stagePolygon = this.containerPolygon\n        if (!stagePolygon) return\n        let polygon = this.polygon\n        let bounced = this.bouncing()\n        if (bounced) {\n            let stage = this.containerBounds\n            let x = this.center.x\n            let y = this.center.y\n            let dx = this.movableX ? velocity.x : 0\n            let dy = this.movableY ? velocity.y : 0\n            let factor = this.throwDamping\n            // if (recentered) {\n            if (x < 0) {\n                dx = -dx\n                factor = collision\n            }\n            if (x > stage.width) {\n                dx = -dx\n                factor = collision\n            }\n            if (y < 0) {\n                dy = -dy\n                factor = collision\n            }\n            if (y > stage.height) {\n                dy = -dy\n                factor = collision\n            }\n            // }\n            return Points.multiplyScalar({ x: dx, y: dy }, factor)\n        }\n        return super.nextVelocity(velocity)\n    }\n\n    endGesture(interaction) {\n        this.startThrow()\n        this._checkAutoClose()\n    }\n\n    _checkAutoClose() {\n        if (this.scaleAutoClose)\n            if (this.scale < this.minScale + this.scaleCloseThreshold - this.scaleCloseBuffer) {\n                this.zoom(this.minScale, { animate: 0.2, onComplete: this.close.bind(this) })\n            } else if (this.scale < this.minScale + this.scaleCloseThreshold) {\n                this.zoom(this.minScale + this.scaleCloseThreshold, { animate: 0.4 })\n            }\n    }\n\n    rotateDegrees(degrees, anchor) {\n        let rad = Angle.degree2radian(degrees)\n        this.rotate(rad, anchor)\n    }\n\n    rotate(rad, anchor) {\n        this.transform({ x: 0, y: 0 }, 1.0, rad, anchor)\n    }\n\n    move(d, { animate = 0 } = {}) {\n        if (this.translatable) {\n            if (animate > 0) {\n                let startPos = this.position\n                TweenLite.to(this, animate, {\n                    x: '+=' + d.x,\n                    y: '+=' + d.y,\n                    /* scale: scale, uo: not defined, why was this here? */\n                    onUpdate: e => {\n                        let p = this.position\n                        let dx = p.x - startPos.x\n                        let dy = p.x - startPos.y\n                        this.onMoved(dx, dy)\n                    }\n                })\n            } else {\n                this._move(d)\n                this.onMoved(d.x, d.y)\n            }\n        }\n    }\n\n    moveTo(p, { animate = 0 } = {}) {\n        let c = this.origin\n        let delta = Points.subtract(p, c)\n        this.move(delta, { animate: animate })\n    }\n\n    centerAt(p, { animate = 0 } = {}) {\n        let c = this.center\n        let delta = Points.subtract(p, c)\n        this.move(delta, { animate: animate })\n    }\n\n    zoom(\n        scale,\n        {\n            animate = 0,\n            about = null,\n            delay = 0,\n            x = null,\n            y = null,\n            onComplete = null\n        } = {}\n    ) {\n        let anchor = about || this.center\n        if (scale != this.scale) {\n            if (animate > 0) {\n                TweenLite.to(this, animate, {\n                    scale: scale,\n                    delay: delay,\n                    onComplete: onComplete,\n                    onUpdate: this.onZoomed.bind(this)\n                })\n            } else {\n                this.scale = scale\n                this.onZoomed(anchor)\n            }\n        }\n    }\n\n    _move(delta) {\n        this.x += this.movableX ? delta.x : 0\n        this.y += this.movableX ? delta.y : 0\n    }\n\n    transform(translate, zoom, rotate, anchor) {\n        let delta = {\n            x: this.movableX ? translate.x : 0,\n            y: this.movableY ? translate.y : 0\n        }\n        if (this.resizable) var vzoom = zoom\n        if (!this.translatable) delta = { x: 0, y: 0 }\n        if (!this.rotatable) rotate = 0\n        if (!this.scalable) zoom = 1.0\n        if (zoom == 1.0 && rotate == 0) {\n            this._move(delta)\n            if (this.onTransform != null) {\n                let event = new ScatterEvent(this, {\n                    translate: delta,\n                    scale: this.scale,\n                    rotate: 0,\n                    about: anchor,\n                    fast: false,\n                    type: UPDATE\n                })\n                this.onTransform.forEach(function (f) {\n                    f(event)\n                })\n            }\n            return\n        }\n        let origin = this.rotationOrigin\n        let beta = Points.angle(origin, anchor)\n        let distance = Points.distance(origin, anchor)\n        let { scale: newScale, zoom: thresholdedZoom } = this.calculateScale(zoom)\n\n        let newOrigin = Points.arc(anchor, beta + rotate, distance * thresholdedZoom)\n        let extra = Points.subtract(newOrigin, origin)\n        let offset = Points.subtract(anchor, origin)\n        this._move(offset)\n        this.scale = newScale\n        this.rotation += rotate\n        offset = Points.negate(offset)\n        offset = Points.add(offset, extra)\n        offset = Points.add(offset, translate)\n        this._move(offset)\n\n        delta.x += extra.x\n        delta.y += extra.y\n        if (this.onTransform != null) {\n            let event = new ScatterEvent(this, {\n                translate: delta,\n                scale: newScale,\n                rotate: rotate,\n                about: anchor\n            })\n            this.onTransform.forEach(function (f) {\n                f(event)\n            })\n        }\n        if (this.resizable) {\n            this.resizeAfterTransform(vzoom)\n        }\n    }\n\n    /**\n     * For a given zoom, a new scale is calculated, taking\n     * min and max scale into account.\n     * \n     * @param {number} zoom - The zoom factor, to scale the object with.\n     * @returns {object} - Returns an object containing the a value for a valid scale and the corrected zoom factor.\n     */\n    calculateScale(zoom) {\n        let scale = this.scale * zoom\n\n        let minScale = this.minScale / this.overdoScaling\n        let maxScale = this.maxScale * this.overdoScaling\n        if (scale < minScale) {\n            scale = minScale\n            zoom = scale / this.scale\n        }\n        if (scale > maxScale) {\n            scale = maxScale\n            zoom = scale / this.scale\n        }\n\n        if (this.scaleAutoClose)\n            this._updateTransparency()\n\n        return { zoom, scale }\n    }\n\n    _updateTransparency() {\n        if (this.scale < this.minScale + this.scaleCloseThreshold) {\n            let transparency = this.calculateScaleTransparency()\n            this.element.style.opacity = transparency\n        } else this.element.style.opacity = 1\n    }\n\n    calculateScaleTransparency() {\n        let transparency = (this.scale - this.minScale) / this.scaleCloseThreshold\n        transparency = (transparency > 1) ? 1 : (transparency < 0) ? 0 : transparency\n        return transparency\n    }\n\n    resizeAfterTransform(zoom) {\n        // Overwrite this in subclasses.\n    }\n\n    validScale(scale) {\n        scale = Math.max(scale, this.minScale)\n        scale = Math.min(scale, this.maxScale)\n        return scale\n    }\n\n    animateZoomBounce(dt = 1) {\n        if (this.zoomAnchor != null) {\n            let zoom = 1\n            let amount = Math.min(0.01, 0.3 * dt / 100000.0)\n            if (this.scale < this.minScale) zoom = 1 + amount\n            if (this.scale > this.maxScale) zoom = 1 - amount\n            if (zoom != 1) {\n                this.transform({ x: 0, y: 0 }, zoom, 0, this.zoomAnchor)\n                requestAnimationFrame(dt => {\n                    this.animateZoomBounce(dt)\n                })\n                return\n            }\n            this.zoomAnchor = null\n        }\n    }\n\n    checkScaling(about, delay = 0) {\n        this.zoomAnchor = about\n        clearTimeout(this.animateZoomBounce.bind(this))\n        setTimeout(this.animateZoomBounce.bind(this), delay)\n    }\n\n    onMouseWheel(event) {\n        if (event.claimedByScatter) {\n            if (event.claimedByScatter != this) return\n        }\n        this.killAnimation()\n        this.targetScale = null\n        let direction = event.detail < 0 || event.wheelDelta > 0\n        let globalPoint = { x: event.clientX, y: event.clientY }\n        let centerPoint = this.mapPositionToContainerPoint(globalPoint)\n        if (event.shiftKey) {\n            let degrees = direction ? 5 : -5\n            let rad = Angle.degree2radian(degrees)\n            return this.transform({ x: 0, y: 0 }, 1.0, rad, centerPoint)\n        }\n        const zoomFactor = this.mouseZoomFactor\n        let zoom = direction ? zoomFactor : 1 / zoomFactor\n        this.transform({ x: 0, y: 0 }, zoom, 0, centerPoint)\n        this.checkScaling(centerPoint, 200)\n\n        if (this.scaleAutoClose) {\n            if (this.scale <= this.minScale + this.scaleCloseThreshold) {\n\n                if (this.scaleAutoCloseTimeout) clearTimeout(this.scaleAutoCloseTimeout)\n                this.scaleAutoCloseTimeout = setTimeout(() => {\n                    this._checkAutoClose()\n                }, 600)\n            }\n            this._updateTransparency()\n        }\n        //\n        //         if (this.onTransform != null) {\n        //             let event = new ScatterEvent(this, {\n        //                 translate: {x: 0, y: 0},\n        //                 scale: this.scale,\n        //                 rotate: 0,\n        //                 about: null,\n        //                 fast: false,\n        //                 type: ZOOM\n        //             })\n        //             this.onTransform.forEach(function(f) {\n        //                 f(event)\n        //             })\n        //         }\n    }\n\n    onStart(event, interaction) {\n\n        if (this.startGesture(interaction)) {\n            this.dragging = true\n            this.interactionAnchor = null\n        }\n        if (this.onTransform != null) {\n            let event = new ScatterEvent(this, {\n                translate: { x: 0, y: 0 },\n                scale: this.scale,\n                rotate: 0,\n                about: null,\n                fast: false,\n                type: START\n            })\n            this.onTransform.forEach(function (f) {\n                f(event)\n            })\n        }\n    }\n\n    onMove(event, interaction) {\n        /** As long as mouseout && mouseleave interrupt we cannot be sure that\n         * dragging remains correct.\n         */\n        if (this.dragging) {\n            this.gesture(interaction)\n        }\n    }\n\n    onEnd(event, interaction) {\n        //console.log(\"Scatter.onEnd\", this.dragging)\n        if (interaction.isFinished()) {\n            this.endGesture(interaction)\n            this.dragging = false\n            for (let key of interaction.ended.keys()) {\n                if (interaction.isTap(key)) {\n                    let point = interaction.ended.get(key)\n                    this.onTap(event, interaction, point)\n                }\n            }\n            if (this.onTransform != null) {\n                let event = new ScatterEvent(this, {\n                    translate: { x: 0, y: 0 },\n                    scale: this.scale,\n                    rotate: 0,\n                    about: null,\n                    fast: false,\n                    type: END\n                })\n                this.onTransform.forEach(function (f) {\n                    f(event)\n                })\n            }\n        }\n        let about = this.interactionAnchor\n        if (about != null) {\n            this.checkScaling(about, 100)\n        }\n    }\n\n    onTap(event, interaction, point) { }\n\n    onDragUpdate(delta) {\n        if (this.onTransform != null) {\n            let event = new ScatterEvent(this, {\n                fast: true,\n                translate: delta,\n                scale: this.scale,\n                about: this.currentAbout,\n                type: null\n            })\n            this.onTransform.forEach(function (f) {\n                f(event)\n            })\n        }\n    }\n\n    onDragComplete() {\n        if (this.onTransform) {\n            let event = new ScatterEvent(this, {\n                scale: this.scale,\n                about: this.currentAbout,\n                fast: false,\n                type: null\n            })\n            this.onTransform.forEach(function (f) {\n                f(event)\n            })\n        }\n    }\n\n    onMoved(dx, dy, about) {\n        if (this.onTransform != null) {\n            let event = new ScatterEvent(this, {\n                translate: { x: dx, y: dy },\n                about: about,\n                fast: true,\n                type: null\n            })\n            this.onTransform.forEach(function (f) {\n                f(event)\n            })\n        }\n    }\n\n    onResizing() {\n        if (this.onTransform != null) {\n            let event = new ScatterEvent(this, {\n                scale: this.scale,\n                fast: false,\n                type: null\n            });\n            this.onTransform.forEach(function (f) {\n                f(event);\n            });\n        }\n    }\n\n    onZoomed(about) {\n\n        if (this.scaleAutoClose)\n            this._updateTransparency()\n\n        if (this.onTransform != null) {\n            let event = new ScatterEvent(this, {\n                scale: this.scale,\n                about: about,\n                fast: false,\n                type: null\n            })\n            this.onTransform.forEach(function (f) {\n                f(event)\n            })\n        }\n    }\n}\n\n/** A container for scatter objects, which uses a single InteractionMapper\n * for all children. This reduces the number of registered event handlers\n * and covers the common use case that multiple objects are scattered\n * on the same level.\n */\nexport class DOMScatterContainer {\n    /**\n     * @constructor\n     * @param {DOM node} element - DOM element that receives events\n     * @param {Bool} stopEvents -  Whether events should be stopped or propagated\n     * @param {Bool} claimEvents - Whether events should be marked as claimed\n     *                             if findTarget return as non-null value.\n     * @param {String} [touchAction=none] - CSS to set touch action style, needed to prevent\n     *                              pointer cancel events. Use null if the\n     *                              the touch action should not be set.\n     */\n    constructor(\n        element,\n        { stopEvents = 'auto', claimEvents = true, useCapture = true, touchAction = 'none' } = {}\n    ) {\n        this.onCapture = null\n        this.element = element\n        if (stopEvents === 'auto') {\n            if (Capabilities.isSafari) {\n                document.addEventListener(\n                    'touchmove',\n                    event => this.preventPinch(event),\n                    false\n                )\n                stopEvents = false\n            } else {\n                stopEvents = true\n            }\n        }\n        this.stopEvents = stopEvents\n        this.claimEvents = claimEvents\n        if (touchAction !== null) {\n            Elements.setStyle(element, { touchAction })\n        }\n        this.scatter = new Map()\n        this.delegate = new InteractionMapper(element, this, {\n            useCapture,\n            mouseWheelElement: window\n        })\n\n        if (typeof debugCanvas !== 'undefined') {\n            requestAnimationFrame(dt => {\n                this.showTouches(dt)\n            })\n        }\n    }\n\n    showTouches(dt) {\n        let resolution = window.devicePixelRatio\n        let canvas = debugCanvas\n        let current = this.delegate.interaction.current\n        let context = canvas.getContext('2d')\n        let radius = 20 * resolution\n        context.clearRect(0, 0, canvas.width, canvas.height)\n        context.fillStyle = 'rgba(0, 0, 0, 0.3)'\n        context.lineWidth = 2\n        context.strokeStyle = '#003300'\n        for (let [key, point] of current.entries()) {\n            let local = point\n            context.beginPath()\n            context.arc(\n                local.x * resolution,\n                local.y * resolution,\n                radius,\n                0,\n                2 * Math.PI,\n                false\n            )\n            context.fill()\n            context.stroke()\n        }\n        requestAnimationFrame(dt => {\n            this.showTouches(dt)\n        })\n    }\n\n    preventPinch(event) {\n        event = event.originalEvent || event\n        if (event.scale !== 1) {\n            event.preventDefault()\n        }\n    }\n\n    add(scatter) {\n        this.scatter.set(scatter.element, scatter)\n    }\n\n    capture(event) {\n        if (this.onCapture) {\n            return this.onCapture(event)\n        }\n        if (event.target == this.element && this.stopEvents) {\n            Events.stop(event)\n        }\n        return true\n    }\n\n    mapPositionToPoint(point) {\n        return Points.fromPageToNode(this.element, point)\n    }\n\n    isDescendant(parent, child, clickable = false) {\n        if (parent == child) return true\n        let node = child.parentNode\n        while (node != null) {\n            if (!clickable && node.onclick) {\n                return false\n            }\n            if (node == parent) {\n                return true\n            }\n            node = node.parentNode\n        }\n        return false\n    }\n\n    findTarget(event, local, global) {\n        /*** Note that elementFromPoint works with clientX, clientY, not pageX, pageY\n        The important point is that event should not be used, since the TouchEvent\n        points are hidden in sub objects.\n        ***/\n        let found = document.elementFromPoint(global.x, global.y)\n        for (let target of this.scatter.values()) {\n            if (target.interactive && this.isDescendant(target.element, found)) {\n                if (this.stopEvents) Events.stop(event)\n                if (this.claimEvents) event.claimedByScatter = target\n                return target\n            }\n        }\n        return null\n    }\n\n    get center() {\n        let r = this.bounds\n        let w2 = r.width / 2\n        let h2 = r.height / 2\n        return { x: w2, y: h2 }\n    }\n\n    get bounds() {\n        return this.element.getBoundingClientRect()\n    }\n\n    get polygon() {\n        let r = this.bounds\n        let w2 = r.width / 2\n        let h2 = r.height / 2\n        let center = { x: w2, y: h2 }\n        let polygon = new Polygon(center)\n        polygon.addPoint({ x: -w2, y: -h2 })\n        polygon.addPoint({ x: w2, y: -h2 })\n        polygon.addPoint({ x: w2, y: h2 })\n        polygon.addPoint({ x: -w2, y: h2 })\n        return polygon\n    }\n}\n\n\nexport class DOMScatter extends AbstractScatter {\n    constructor(\n        element,\n        container,\n        {\n            startScale = 1.0,\n            minScale = 0.1,\n            maxScale = 1.0,\n            overdoScaling = 1.5,\n            autoBringToFront = true,\n            translatable = true,\n            scalable = true,\n            rotatable = true,\n            movableX = true,\n            movableY = true,\n            rotationDegrees = null,\n            rotation = null,\n            onTransform = null,\n            transformOrigin = 'center center',\n            // extras which are in part needed\n            x = 0,\n            y = 0,\n            width = null, // required\n            height = null,  // required\n            resizable = false,\n            simulateClick = false,\n            verbose = true,\n            onResize = null,\n            touchAction = 'none',\n            throwVisibility = 44,\n            throwDamping = 0.95,\n            autoThrow = true,\n            scaleAutoClose = false,\n            onClose = null,\n            scaleCloseThreshold = 0.10,\n            scaleCloseBuffer = 0.05\n        } = {}\n    ) {\n        super({\n            minScale,\n            maxScale,\n            startScale,\n            overdoScaling,\n            autoBringToFront,\n            translatable,\n            scalable,\n            rotatable,\n            movableX,\n            movableY,\n            resizable,\n            rotationDegrees,\n            rotation,\n            onTransform,\n            throwVisibility,\n            throwDamping,\n            autoThrow,\n            scaleAutoClose,\n            scaleCloseThreshold,\n            scaleCloseBuffer,\n            onClose\n        })\n        if (container == null || width == null || height == null) {\n            throw new Error('Invalid value: null')\n        }\n        element.scatter = this\n        this.element = element\n        this.x = x\n        this.y = y\n        this.oldX = 0\n        this.oldY = 0\n        this.meanX = x\n        this.meanY = y\n        this.width = width\n        this.height = height\n        this.throwVisibility = Math.min(width, height, throwVisibility)\n        this.container = container\n        this.simulateClick = simulateClick\n        this.scale = startScale\n        this.rotationDegrees = this.startRotationDegrees\n        this.transformOrigin = transformOrigin\n        this.initialValues = {\n            x: x,\n            y: y,\n            width: width,\n            height: height,\n            scale: startScale,\n            rotation: this.startRotationDegrees,\n            transformOrigin: transformOrigin\n        }\n\n\n        // For tweenlite we need initial values in _gsTransform\n        TweenLite.set(element, this.initialValues)\n        this.onResize = onResize\n        this.verbose = verbose\n        if (touchAction !== null) {\n            Elements.setStyle(element, { touchAction })\n        }\n        this.resizeButton = null\n        if (resizable) {\n            let button = document.createElement(\"div\")\n            button.style.position = \"absolute\"\n            button.style.right = \"0px\"\n            button.style.bottom = \"0px\"\n            button.style.width = \"50px\";\n            button.style.height = \"50px\";\n            // button.style.borderRadius = \"100% 0px 0px 0px\";\n            // button.style.background = this.element.style.backgroundColor\n            button.className = \"interactiveElement\"\n            this.element.appendChild(button)\n\n            button.addEventListener('pointerdown', (e) => {\n                this.startResize(e)\n            })\n\n            button.addEventListener('pointermove', (e) => {\n                this.resize(e)\n            })\n\n            button.addEventListener('pointerup', (e) => {\n                this.stopResize(e)\n            })\n            this.resizeButton = button\n        }\n        container.add(this)\n    }\n\n    /** Returns geometry data as object. **/\n    getState() {\n        return {\n            scale: this.scale,\n            x: this.x,\n            y: this.y,\n            rotation: this.rotation\n        }\n    }\n\n    close() {\n        super.close()\n        let parent = this.element.parentNode\n        if (parent) parent.removeChild(this.element)\n    }\n\n    get rotationOrigin() {\n        return this.center\n    }\n\n    get x() {\n        return this._x\n    }\n\n    get y() {\n        return this._y\n    }\n\n    set x(value) {\n        this._x = value\n        TweenLite.set(this.element, { x: value })\n    }\n\n    set y(value) {\n        this._y = value\n        TweenLite.set(this.element, { y: value })\n    }\n\n    get position() {\n        let transform = this.element._gsTransform\n        let x = transform.x\n        let y = transform.y\n        return { x, y }\n    }\n\n    get origin() {\n        let p = this.fromNodeToPage(0, 0)\n        return Points.fromPageToNode(this.container.element, p)\n    }\n\n    get bounds() {\n        let stage = this.container.element.getBoundingClientRect()\n        let rect = this.element.getBoundingClientRect()\n        return {\n            top: rect.top - stage.top,\n            left: rect.left - stage.left,\n            width: rect.width,\n            height: rect.height\n        }\n    }\n\n    get center() {\n        let r = this.bounds\n        let w2 = r.width / 2\n        let h2 = r.height / 2\n        //   if (this.resizable) {\n        //             w2 *= this.scale\n        //             h2 *= this.scale\n        //         }\n        var x = r.left + w2\n        var y = r.top + h2\n        return { x, y }\n    }\n\n    set rotation(radians) {\n        let rad = radians // Angle.normalize(radians)\n        let degrees = Angle.radian2degree(rad)\n        TweenLite.set(this.element, { rotation: degrees })\n        this._rotation = rad\n    }\n\n    set rotationDegrees(degrees) {\n        let deg = degrees // Angle.normalizeDegree(degrees)\n        TweenLite.set(this.element, { rotation: deg })\n        this._rotation = Angle.degree2radian(deg)\n    }\n\n    get rotation() {\n        return this._rotation\n    }\n\n    get rotationDegrees() {\n        return this._rotation\n    }\n\n    set scale(scale) {\n        TweenLite.set(this.element, {\n            scale: scale,\n            transformOrigin: this.transformOrigin\n        })\n        this._scale = scale\n    }\n\n    get scale() {\n        return this._scale\n    }\n\n    get containerBounds() {\n        return this.container.bounds\n    }\n\n    get containerPolygon() {\n        return this.container.polygon\n    }\n\n    mapPositionToContainerPoint(point) {\n        return this.container.mapPositionToPoint(point)\n    }\n\n    capture(event) {\n        return true\n    }\n\n    reset() {\n        TweenLite.set(this.element, this.initialValues)\n    }\n\n    hide() {\n        TweenLite.to(this.element, 0.1, {\n            display: 'none',\n            onComplete: e => {\n                this.element.parentNode.removeChild(this.element)\n            }\n        })\n    }\n\n    show() {\n        TweenLite.set(this.element, { display: 'block' })\n    }\n\n    showAt(p, rotationDegrees) {\n        TweenLite.set(this.element, {\n            display: 'block',\n            x: p.x,\n            y: p.y,\n            rotation: rotationDegrees,\n            transformOrigin: this.transformOrigin\n        })\n    }\n\n    bringToFront() {\n        // this.element.parentNode.appendChild(this.element)\n        // uo: On Chome and Electon appendChild leads to flicker\n        TweenLite.set(this.element, { zIndex: DOMScatter.zIndex++ })\n    }\n\n    toggleVideo(element) {\n        if (element.paused) {\n            element.play()\n        } else {\n            element.pause()\n        }\n    }\n\n    onTap(event, interaction, point) {\n        if (this.simulateClick) {\n            let p = Points.fromPageToNode(this.element, point)\n            let iframe = this.element.querySelector('iframe')\n            if (iframe) {\n                let doc = iframe.contentWindow.document\n                let element = doc.elementFromPoint(p.x, p.y)\n                if (element == null) {\n                    return\n                }\n                switch (element.tagName) {\n                    case 'VIDEO':\n                        console.log(element.currentSrc)\n                        if (PopupMenu) {\n                            PopupMenu.open(\n                                {\n                                    Fullscreen: () =>\n                                        window.open(element.currentSrc),\n                                    Play: () => element.play()\n                                },\n                                { x, y }\n                            )\n                        } else {\n                            this.toggleVideo(element)\n                        }\n                        break\n                    default:\n                        element.click()\n                }\n            }\n        }\n    }\n\n    isDescendant(parent, child) {\n        let node = child.parentNode\n        while (node != null) {\n            if (node == parent) {\n                return true\n            }\n            node = node.parentNode\n        }\n        return false\n    }\n\n    fromPageToNode(x, y) {\n        return Points.fromPageToNode(this.element, { x, y })\n    }\n\n    fromNodeToPage(x, y) {\n        return Points.fromNodeToPage(this.element, { x, y })\n    }\n\n    _move(delta) {\n        // UO: We need to keep TweenLite's _gsTransform and the private\n        // _x and _y attributes aligned\n        let x = this.element._gsTransform.x\n        let y = this.element._gsTransform.y\n        if (this.movableX) {\n            x += delta.x\n        }\n        if (this.movableY) {\n            y += delta.y\n        }\n        this._x = x\n        this._y = y\n        TweenLite.set(this.element, { x: x, y: y })\n    }\n\n    resizeAfterTransform(zoom) {\n        //  let w = this.width * this.scale\n        //         let h = this.height * this.scale\n        //         TweenLite.set(this.element, { width: w, height: h })\n        if (this.onResize) {\n            let event = new ResizeEvent(this, { width: w, height: h })\n            this.onResize(event)\n        }\n        if (this.resizeButton != null) {\n            // this.resizeButton.style.width = 50/this.scale+\"px\"\n            // this.resizeButton.style.height = 50/this.scale+\"px\"\n        }\n    }\n\n    startResize(e) {\n        e.preventDefault()\n        let event = new CustomEvent('resizeStarted')\n\n        let oldPostition = { x: $(this.element).position().left, y: $(this.element).position().top }\n        this.bringToFront()\n\n        this.element.style.transformOrigin = \"0% 0%\"\n\n        let newPostition = { x: $(this.element).position().left, y: $(this.element).position().top }\n\n        let offset = Points.subtract(oldPostition, newPostition)\n\n        this.oldX = e.clientX\n        this.oldY = e.clientY\n\n        e.target.setAttribute('resizing', \"true\")\n        e.target.setPointerCapture(e.pointerId)\n\n        TweenLite.to(this.element, 0, { css: { left: \"+=\" + offset.x + \"px\" } })\n        TweenLite.to(this.element, 0, { css: { top: \"+=\" + offset.y + \"px\" } })\n\n        this.element.dispatchEvent(event);\n    }\n\n    resize(e) {\n        e.preventDefault()\n\n        let rotation = Angle.radian2degree(this.rotation)\n        rotation = (rotation + 360) % 360\n        let event = new CustomEvent('resized')\n        if (e.target.getAttribute('resizing') == \"true\") {\n\n            let deltaX = (e.clientX - this.oldX)\n            let deltaY = (e.clientY - this.oldY)\n\n            let r = Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2))\n            let phi = Angle.radian2degree(Math.atan2(deltaX, deltaY))\n\n            phi = ((phi) + 630) % 360\n            let rot = ((rotation + 90) + 630) % 360\n\n            let diffAngle = ((0 + rot) + 360) % 360\n            let phiCorrected = (phi + diffAngle + 360) % 360\n\n            let resizeW = r * Math.cos(Angle.degree2radian(phiCorrected))\n            let resizeH = -r * Math.sin(Angle.degree2radian(phiCorrected))\n\n            if (this.element.offsetWidth + resizeW / this.scale > this.width * 0.3 && this.element.offsetHeight + resizeH / this.scale > this.height * 0.3) TweenLite.to(this.element, 0, { width: this.element.offsetWidth + resizeW / this.scale, height: this.element.offsetHeight + resizeH / this.scale });\n\n            this.oldX = e.clientX\n            this.oldY = e.clientY\n            this.onResizing()\n\n            this.element.dispatchEvent(event);\n        }\n    }\n\n    stopResize(e) {\n        e.preventDefault()\n\n        let event = new CustomEvent('resizeEnded')\n        let oldPostition = { x: $(this.element).position().left, y: $(this.element).position().top }\n        this.element.style.transformOrigin = \"50% 50%\"\n        let newPostition = { x: $(this.element).position().left, y: $(this.element).position().top }\n        let offset = Points.subtract(oldPostition, newPostition)\n\n        TweenLite.to(this.element, 0, { css: { left: \"+=\" + offset.x + \"px\" } })\n        TweenLite.to(this.element, 0, { css: { top: \"+=\" + offset.y + \"px\" } })\n\n        e.target.setAttribute('resizing', \"false\")\n\n        this.element.dispatchEvent(event);\n    }\n}\n\nDOMScatter.zIndex = 1000\n","import { getId } from './utils.js'\nimport { DOMScatter } from './scatter.js'\nimport { InteractionMapper } from './interaction.js'\n\nexport class CardLoader {\n    constructor(\n        src,\n        {\n            x = 0,\n            y = 0,\n            width = 1000,\n            height = 800,\n            maxWidth = null,\n            maxHeight = null,\n            scale = 1,\n            minScale = 0.5,\n            maxScale = 1.5,\n            rotation = 0\n        } = {}\n    ) {\n        this.src = src\n        this.x = x\n        this.y = y\n        this.scale = scale\n        this.rotation = 0\n        this.maxScale = maxScale\n        this.minScale = minScale\n        this.wantedWidth = width\n        this.wantedHeight = height\n        this.maxWidth = maxWidth != null ? maxWidth : window.innerWidth\n        this.maxHeight = maxHeight != null ? maxHeight : window.innerHeight\n        this.addedNode = null\n        console.log({\n         \n            width,\n            height,\n            maxWidth,\n            maxHeight,\n           \n        })\n    }\n\n    unload() {\n        if (this.addedNode) {\n            this.addedNode.remove()\n            this.addedNode = null\n        }\n    }\n}\n\nexport class PDFLoader extends CardLoader {\n    constructor(src, { width = 1640, height = 800, scale = 1 } = {}) {\n        super(src, { width, height, scale })\n        if (typeof PDFJS == 'undefined') {\n            alert('PDF.js needed')\n        }\n    }\n\n    load(domNode) {\n        return new Promise((resolve, reject) => {\n            PDFJS.getDocument(this.src).then(pdf => {\n                pdf.getPage(1).then(page => {\n                    let scale = this.scale * app.renderer.resolution\n                    let invScale = 1 / scale\n                    let viewport = page.getViewport(scale)\n\n                    // Prepare canvas using PDF page dimensions.\n                    let canvas = document.createElement('canvas')\n                    let context = canvas.getContext('2d')\n                    canvas.height = viewport.height\n                    canvas.width = viewport.width\n\n                    // Render PDF page into canvas context.\n                    let renderContext = {\n                        canvasContext: context,\n                        viewport: viewport\n                    }\n                    page.render(renderContext)\n                    domNode.appendChild(canvas)\n                    this.wantedWidth = canvas.width\n                    this.wantedHeight = canvas.height\n                    this.scale = invScale\n                    this.addedNode = canvas\n                    resolve(this)\n                })\n            })\n        })\n    }\n}\n\nexport class ImageLoader extends CardLoader {\n    load(domNode) {\n        return new Promise((resolve, reject) => {\n            let isImage = domNode instanceof HTMLImageElement\n            let image = isImage ? domNode : document.createElement('img')\n            image.onload = e => {\n                if (!isImage) {\n                    domNode.appendChild(image)\n                    this.addedNode = image\n                }\n                this.wantedWidth = image.naturalWidth\n                this.wantedHeight = image.naturalHeight\n\n                let scaleW = this.maxWidth / image.naturalWidth\n                let scaleH = this.maxHeight / image.naturalHeight\n                this.scale = Math.min(this.maxScale, Math.min(scaleW, scaleH))\n                image.setAttribute('draggable', false)\n                image.width = image.naturalWidth\n                image.height = image.naturalHeight\n                resolve(this)\n            }\n            image.onerror = e => {\n                reject(this)\n            }\n            image.src = this.src\n        })\n    }\n}\n\nexport class FrameLoader extends CardLoader {\n    load(domNode) {\n        return new Promise((resolve, reject) => {\n            let isFrame = domNode instanceof HTMLIFrameElement\n            let iframe = isFrame ? domNode : document.createElement('iframe')\n            console.log('FrameLoader.load', isFrame, iframe, this.src)\n            iframe.frameBorder = 0\n            iframe.style.scrolling = false\n            iframe.width = this.wantedWidth\n            iframe.height = this.wantedHeight\n            if (!isFrame) {\n                // Unlike img onload is only triggered if the iframe is part of the DOM tree\n                domNode.appendChild(iframe)\n                this.addedNode = iframe\n            }\n            iframe.onload = e => {\n                resolve(this)\n            }\n            iframe.onerror = e => {\n                reject(this)\n            }\n            iframe.src = this.src\n        })\n    }\n}\n\nexport class HTMLLoader extends CardLoader {\n    load(domNode) {\n        return new Promise((resolve, reject) => {\n            let xhr = new XMLHttpRequest()\n            xhr.open('GET', this.src, false)\n            xhr.onload = e => {\n                domNode.innerHTML = xhr.response\n                this.addedNode = domNode.firstElementChild\n                let { width, height } = this.size(this.addedNode)\n                console.log(\"HTMLLoader.load\", { added: this.addedNode, width, height })\n                if (width)\n                    this.wantedWidth = width || this.wantedWidth\n                if (height)\n                    this.wantedHeight = height || this.wantedHeight\n                resolve(this)\n            }\n            xhr.onerror = e => {\n                reject(this)\n            }\n            xhr.send()\n        })\n    }\n\n    /**\n     * Tries to determine the size of the addedNode.\n     * Checks for explicit width and height style attributes.\n     * \n     * Overwrite this method if you want to extract values from other infos.\n     *\n     * @returns { width: int, height: int }\n     * @memberof HTMLLoader\n     */\n    size(node) {\n        let width = parseInt(node.style.width) || null\n        let height = parseInt(node.style.height) || null\n        return { width, height }\n    }\n}\n\nexport class DOMFlip {\n    constructor(\n        domScatterContainer,\n        flipTemplate,\n        frontLoader,\n        backLoader,\n        {\n            closeOnMinScale = false,\n            flipDuration = 1,\n            fadeDuration = 0.2,\n            overdoScaling = 1,\n            autoLoad = false,\n            center = null,\n            preloadBack = false,\n            translatable = true,\n            scalable = true,\n            rotatable = true,\n            onFront = null,\n            onBack = null,\n            onClose = null,\n            onUpdate = null,\n            onRemoved = null,\n            onLoaded = null\n        } = {}\n    ) {\n        this.domScatterContainer = domScatterContainer\n        this.id = getId()\n        this.flipDuration = flipDuration\n        this.fadeDuration = fadeDuration\n        this.closeOnMinScale = closeOnMinScale\n        this.flipTemplate = flipTemplate\n        this.frontLoader = frontLoader\n        this.backLoader = backLoader\n        this.translatable = translatable\n        this.scalable = scalable\n        this.rotatable = rotatable\n        this.onFrontFlipped = onFront\n        this.onBackFlipped = onBack\n        this.onClose = onClose\n        this.onRemoved = onRemoved\n        this.onUpdate = onUpdate\n        this.onLoaded = onLoaded\n        this.center = center\n        this.preloadBack = preloadBack\n        this.overdoScaling = overdoScaling\n        if (autoLoad) {\n            this.load()\n        }\n    }\n\n    load() {\n        return new Promise((resolve, reject) => {\n            let t = this.flipTemplate\n            let dom = this.domScatterContainer.element\n            let wrapper = t.content.querySelector('.flipWrapper')\n            wrapper.id = this.id\n            let clone = document.importNode(t.content, true)\n            dom.appendChild(clone)\n            // We cannot use the document fragment itself because it\n            // is not part of the main dom tree. After the appendChild\n            // call we can access the new dom element by id\n            this.cardWrapper = dom.querySelector('#' + this.id)\n            let front = this.cardWrapper.querySelector('.front')\n            this.frontLoader.load(front).then(loader => {\n                this.frontLoaded(loader).then((obj) => {\n                    if (this.onLoaded) this.onLoaded()\n                    resolve(this)\n                })\n            })\n        })\n    }\n\n    frontLoaded(loader) {\n        return new Promise((resolve, reject) => {\n            let scatter = new DOMScatter(\n                this.cardWrapper,\n                this.domScatterContainer,\n                {\n                    x: loader.x,\n                    y: loader.y,\n                    startScale: loader.scale,\n                    scale: loader.scale,\n                    maxScale: loader.maxScale,\n                    minScale: loader.minScale,\n                    width: loader.wantedWidth,\n                    height: loader.wantedHeight,\n                    rotation: loader.rotation,\n                    translatable: this.translatable,\n                    scalable: this.scalable,\n                    rotatable: this.rotatable,\n                    overdoScaling: this.overdoScaling\n                }\n            )\n\n            if (this.center) {\n                scatter.centerAt(this.center)\n            }\n\n            if (this.closeOnMinScale) {\n\n                const removeOnMinScale = function () {\n                    if (scatter.scale <= scatter.minScale) {\n                        this.flippable.close()\n\n                        // 'Disable' overdoscaling to avoid weird jumps on close.\n                        scatter.minScale /= scatter.overdoScaling\n                        scatter.overdoScaling = 1\n\n                        //Remove callback\n                        if (scatter.onTransform) {\n                            let callbackIdx = scatter.onTransform.indexOf(removeOnMinScale)\n                            scatter.onTransform.splice(callbackIdx, 1)\n                        }\n                    }\n\n                }.bind(this)\n\n\n\n                scatter.addTransformEventCallback(removeOnMinScale)\n            }\n\n            let flippable = new DOMFlippable(this.cardWrapper, scatter, this)\n            let back = this.cardWrapper.querySelector('.back')\n\n            if (this.preloadBack) {\n                this.backLoader.load(back).then(loader => {\n                    this.setupFlippable(flippable, loader)\n                })\n            }\n            this.flippable = flippable\n            resolve(this)\n        })\n    }\n\n    centerAt(p) {\n        this.center = p\n        this.flippable.centerAt(p)\n    }\n\n    zoom(scale) {\n        this.flippable.zoom(scale)\n    }\n\n    setupFlippable(flippable, loader) {\n        flippable.wantedWidth = loader.wantedWidth\n        flippable.wantedHeight = loader.wantedHeight\n        flippable.wantedScale = loader.scale\n        flippable.minScale = loader.minScale\n        flippable.maxScale = loader.maxScale\n        flippable.scaleButtons()\n    }\n\n    start({ targetCenter = null } = {}) {\n        console.log('DOMFlip.start', targetCenter)\n        if (this.preloadBack) this.flippable.start({ duration: this.flipDuration, targetCenter })\n        else {\n            let back = this.cardWrapper.querySelector('.back')\n            let flippable = this.flippable\n            this.backLoader.load(back).then(loader => {\n                this.setupFlippable(flippable, loader)\n                flippable.start({ duration: this.flipDuration, targetCenter })\n            })\n        }\n    }\n\n    fadeOutAndRemove() {\n        TweenLite.to(this.cardWrapper, this.fadeDuration, {\n            opacity: 0,\n            onComplete: () => {\n                this.cardWrapper.remove()\n            }\n        })\n    }\n\n    closed() {\n        this.unload()\n    }\n\n    unload() {\n        if (!this.preloadBack) {\n            this.backLoader.unload()\n        }\n    }\n}\n\nexport class DOMFlippable {\n    constructor(element, scatter, flip) {\n        // Set log to console.log or a custom log function\n        // define data structures to store our touchpoints in\n\n        this.element = element\n        this.flip = flip\n        this.card = element.querySelector('.flipCard')\n        this.front = element.querySelector('.front')\n        this.back = element.querySelector('.back')\n        this.flipped = false\n        this.scatter = scatter\n        this.onFrontFlipped = flip.onFrontFlipped\n        this.onBackFlipped = flip.onBackFlipped\n        this.onClose = flip.onClose\n        this.onRemoved = flip.onRemoved\n        this.onUpdate = flip.onUpdate\n\n        this.flipDuration = flip.flipDuration\n        this.fadeDuration = flip.fadeDuration\n        scatter.addTransformEventCallback(this.scatterTransformed.bind(this))\n        console.log('lib.DOMFlippable', 5000)\n        TweenLite.set(this.element, { perspective: 5000 })\n        TweenLite.set(this.card, { transformStyle: 'preserve-3d' })\n        TweenLite.set(this.back, { rotationY: -180 })\n        TweenLite.set([this.back, this.front], {\n            backfaceVisibility: 'hidden',\n            perspective: 5000\n        })\n        TweenLite.set(this.front, { visibility: 'visible' })\n        this.infoBtn = element.querySelector('.infoBtn')\n        this.backBtn = element.querySelector('.backBtn')\n        this.closeBtn = element.querySelector('.closeBtn')\n        /* Buttons are not guaranteed to exist. */\n        if (this.infoBtn) {\n            InteractionMapper.on('tap', this.infoBtn, event => this.flip.start())\n\n            this.enable(this.infoBtn)\n        }\n        if (this.backBtn) {\n            InteractionMapper.on('tap', this.backBtn, event => this.start())\n        }\n        if (this.closeBtn) {\n            InteractionMapper.on('tap', this.closeBtn, event => this.close())\n            this.enable(this.closeBtn)\n        }\n        this.scaleButtons()\n        this.bringToFront()\n    }\n\n    close() {\n        this.disable(this.infoBtn)\n        this.disable(this.closeBtn)\n        if (this.onClose) {\n            this.onClose(this)\n            this.flip.closed()\n        } else {\n            this.scatter.zoom(0.1, {\n                animate: this.fadeDuration,\n                onComplete: () => {\n                    this.element.remove()\n                    this.flip.closed()\n                    if (this.onRemoved) {\n                        this.onRemoved.call(this)\n                    }\n                }\n            })\n        }\n    }\n\n    showFront() {\n        TweenLite.set(this.front, { visibility: 'visible' })\n    }\n\n    centerAt(p) {\n        this.scatter.centerAt(p)\n    }\n\n    zoom(scale) {\n        this.scatter.zoom(scale)\n    }\n\n    get buttonScale() {\n        let iscale = 1.0\n\n        if (this.scatter != null) {\n            let scale = this.scatter.scale || 1\n            iscale = 1.0 / scale\n        }\n        return iscale\n    }\n\n    scaleButtons() {\n        //This also works for svgs.\n        // if (this.infoBtn)\n        //     this.infoBtn.style.transform = \"scale(\" + this.buttonScale + \")\"\n\n        // if (this.backBtn)\n        //     this.backBtn.style.transform = \"scale(\" + this.buttonScale + \")\"\n\n        // if (this.closeBtn)\n        //     this.closeBtn.style.transform = \"scale(\" + this.buttonScale + \")\"\n\n        console.log(this.buttonScale)\n        //// This did not work with svgs!\n        TweenLite.set([this.infoBtn, this.backBtn, this.closeBtn], {\n            scale: this.buttonScale\n        })\n    }\n\n    bringToFront() {\n        this.scatter.bringToFront()\n        TweenLite.set(this.element, { zIndex: DOMScatter.zIndex++ })\n    }\n\n    clickInfo() {\n        this.bringToFront()\n        this.infoBtn.click()\n    }\n\n    scatterTransformed(event) {\n        this.scaleButtons()\n    }\n\n    targetRotation(alpha) {\n        let ortho = 90\n        let rest = alpha % ortho\n        let delta = 0.0\n        if (rest > ortho / 2.0) {\n            delta = ortho - rest\n        } else {\n            delta = -rest\n        }\n        return delta\n    }\n\n    infoValues(info) {\n        let startX = this.element._gsTransform.x\n        let startY = this.element._gsTransform.y\n        let startAngle = this.element._gsTransform.rotation\n        let startScale = this.element._gsTransform.scaleX\n        let w = this.element.style.width\n        let h = this.element.style.height\n        console.log(info, startX, startY, startAngle, startScale, w, h)\n    }\n\n    show(element, duration = 0, alpha = 1) {\n        if (element) {\n            TweenLite.to(element, duration, { autoAlpha: alpha }) // visibility: 'visible', display: 'initial'})\n        }\n    }\n\n    hide(element, duration = 0, alpha = 0) {\n        if (element) {\n            TweenLite.to(element, duration, { autoAlpha: alpha }) // {visibility: 'hidden', display: 'none'})\n        }\n    }\n\n\n\n    enable(button) {\n        this.show(button, this.fadeDuration)\n        if (button) {\n            TweenLite.set(button, { pointerEvents: 'auto' })\n        }\n    }\n\n    disable(button) {\n        this.hide(button, this.fadeDuration)\n        if (button) {\n            TweenLite.set(button, { pointerEvents: 'none' })\n        }\n    }\n\n    start({ targetCenter = null } = {}) {\n        this.bringToFront()\n        if (!this.flipped) {\n            this.startX = this.element._gsTransform.x\n            this.startY = this.element._gsTransform.y\n            this.startAngle = this.element._gsTransform.rotation\n            this.startScale = this.element._gsTransform.scaleX\n            this.startWidth = this.element.style.width\n            this.startHeight = this.element.style.height\n            this.scatterStartWidth = this.scatter.width\n            this.scatterStartHeight = this.scatter.height\n            this.show(this.back)\n            this.disable(this.infoBtn)\n            this.disable(this.closeBtn)\n        } else {\n            this.show(this.front, this.fadeDuration)\n            this.disable(this.backBtn)\n        }\n        let { scalable, translatable, rotatable } = this.scatter\n        this.saved = { scalable, translatable, rotatable }\n        this.scatter.scalable = false\n        this.scatter.translatable = false\n        this.scatter.rotatable = false\n        this.scatter.killAnimation()\n\n        this.flipped = !this.flipped\n        let targetY = this.flipped ? 180 : 0\n        let targetZ = this.flipped\n            ? this.startAngle + this.targetRotation(this.startAngle)\n            : this.startAngle\n        let targetScale = this.flipped ? this.wantedScale : this.startScale\n        let w = this.flipped ? this.wantedWidth : this.startWidth\n        let h = this.flipped ? this.wantedHeight : this.startHeight\n        let dw = this.wantedWidth - this.scatter.width\n        let dh = this.wantedHeight - this.scatter.height\n        let tc = targetCenter\n        let xx = tc != null ? tc.x - w / 2 : this.startX - dw / 2\n        let yy = tc != null ? tc.y - h / 2 : this.startY - dh / 2\n        let x = this.flipped ? xx : this.startX\n        let y = this.flipped ? yy : this.startY\n\n        console.log(\"DOMFlippable.start\", this.flipped, targetCenter, x, y, this.saved)\n        let onUpdate = this.onUpdate !== null ? () => this.onUpdate(this) : null\n        console.log(this.flipDuration)\n        TweenLite.to(this.card, this.flipDuration, {\n            rotationY: targetY,\n            ease: Power1.easeOut,\n            transformOrigin: '50% 50%',\n            onUpdate,\n            onComplete: e => {\n                if (this.flipped) {\n                    //this.hide(this.front)\n                    this.enable(this.backBtn)\n                    this.show(this.backBtn)\n\n                    if (this.onFrontFlipped) {\n                        this.onFrontFlipped(this)\n                    }\n                } else {\n\n                    if (this.onBackFlipped == null) {\n                        this.enable(this.infoBtn, this.fadeDuration)\n                        this.enable(this.closeBtn, this.fadeDuration)\n                    } else {\n                        this.onBackFlipped(this)\n                    }\n                    this.flip.unload()\n                }\n                this.scatter.scale = targetScale\n                this.scaleButtons()\n                this.scatter.rotationDegrees = targetZ\n                this.scatter.width = this.flipped ? w : this.scatterStartWidth\n                this.scatter.height = this.flipped ? h : this.scatterStartHeight\n\n                let { scalable, translatable, rotatable } = this.saved\n                this.scatter.scalable = scalable\n                this.scatter.translatable = translatable\n                this.scatter.rotatable = rotatable\n            },\n            force3D: true\n        })\n\n        // See https://greensock.com/forums/topic/7997-rotate-the-shortest-way/\n        TweenLite.to(this.element, this.flipDuration / 2, {\n            scale: targetScale,\n            ease: Power1.easeOut,\n            rotationZ: targetZ + '_short',\n            transformOrigin: '50% 50%',\n            width: w,\n            height: h,\n            x: x,\n            y: y,\n            onComplete: e => {\n                if (this.flipped) {\n                    this.hide(this.front)\n                    // this.hide(this.infoBtn)\n                } else {\n                    this.hide(this.back)\n                    // this.show(this.infoBtn)\n                }\n            }\n        })\n    }\n}\n","\nexport const deepZoomTileCache = new Map()\n\n\n/** The current Tile implementation simply uses PIXI.Sprites.\n *\n * BTW: PIXI.extras.TilingSprite is not appropriate. It should be used for\n * repeating patterns.\n **/\nexport class Tile extends PIXI.Sprite {\n    constructor(texture, url) {\n        super(texture)\n        this.url = url\n        this.register(url)\n    }\n\n    static fromImage(imageId, crossorigin, scaleMode) {\n        return new Tile(PIXI.Texture.fromImage(imageId, crossorigin, scaleMode), imageId)\n    }\n\n    /**\n     * Registers the tile in the global reference counter for textures\n     *\n     * @param {*} url\n     * @param {boolean} [debug=false]\n     * @memberof Tile\n     */\n    register(url, debug = false) {\n        if (deepZoomTileCache.has(url)) {\n            let tiles = deepZoomTileCache.get(url)\n            tiles.add(this)\n            if (debug) console.log(\"Tile.register\", url, tiles.size)\n        }\n        else {\n            deepZoomTileCache.set(url, new Set([this]))\n            if (debug) console.log(\"Tile.register\", url, 1)\n        }\n    }\n\n    /**\n     * Unregisters the rile in the global reference counter for textures\n     *\n     * @returns {number} The number of how often a texture is used.\n     * @memberof Tile\n     */\n    unregister() {\n        let tiles = deepZoomTileCache.get(this.url)\n        tiles.delete(this)\n        if (tiles.size == 0) {\n            deepZoomTileCache.delete(this.url)\n        }\n        return tiles.size\n    }\n\n    /**\n     * Destroys this sprite and optionally its texture and children\n     *\n     * @param {*} options  Part of the PIXI API, but ignored in the implementation\n     * @memberof Tile\n     */\n    destroy(options, debug = false) {\n        if (this.parent != null) {\n\n        }\n        let count = this.unregister()\n        if (count <= 0) {\n            let opts = { children: true, texture: true, baseTexture: true }\n            super.destroy(opts)\n            if (debug) console.log(\"Tile.destroy\", deepZoomTileCache.size, opts)\n        }\n        else {\n            let opts = { children: true, texture: false, baseTexture: false }\n            if (debug) console.log(\"Tile.destroy\", deepZoomTileCache.size, opts)\n            super.destroy(opts)\n        }\n    }\n}\n","import { deepZoomTileCache, Tile } from './tile.js'\n\n/**\n * A Tile Loader component that can be plugged into a Tiles Layer.\n */\nexport class TileLoader {\n    constructor(tiles) {\n        this.debug = false\n        this.tiles = tiles\n        this.setup()\n    }\n\n    /** Setup collections and instance vars. */\n    setup() {\n        this.map = new Map() // Map {url : [ col, row]}\n        this.loading = new Set() // Set url\n        this.loaded = new Map() // Map {url : sprite }\n        this.loadQueue = []\n    }\n\n    /** Schedules a tile url for loading. The loading itself must be triggered\n    by a call to loadOneTile or loadAll\n\n    * @param {String} url - the url of the texture / tile\n    * @param {Number} col - the tile col\n    * @param {Number} row - the tile row\n    **/\n    schedule(url, col, row) {\n        if (this.loaded.has(url)) return false\n        if (this.loading.has(url)) return false\n        this.map.set(url, [col, row])\n        this.loading.add(url)\n        this.loadQueue.push(url)\n        return true\n    }\n\n    unschedule(url) {\n        if (this.loaded.has(url)) this.loaded.delete(url)\n        if (this.loading.has(url)) this.loading.delete(url)\n        this.loadQueue = this.loadQueue.filter(item => item != url)\n    }\n\n    /** Cancels loading by clearing the load queue **/\n    cancel() {\n        this.loadQueue = []\n        this.loading.clear()\n    }\n\n    /** Destroys alls collections. **/\n    destroy() {\n        this.setup()\n    }\n\n    /** Private method. Informs the tile layer about a texture for a given url.\n     * Creates the sprite for the loaded texture and informs the tile layer.\n     * @param {String} url - the url\n     * @param {Object} texture - the loaded resource\n     **/\n    _textureAvailable(url, col, row, texture) {\n        let tile = this.loaded.get(url)\n        if (tile != null) {\n            console.warn(\"Tile already loaded\")\n            tile.unregister()\n        }\n        tile = new Tile(texture, url)\n        this.loaded.set(url, tile)\n        this.tiles.tileAvailable(tile, col, row, url)\n    }\n}\n\n/**\n * Uses the PIXI Loader but can be replaced with othe loaders implementing\n * the public methods without underscore.\n * Calls the Tiles.tileAvailable method if the texture is available.\n **/\nexport class PIXITileLoader extends TileLoader {\n\n    constructor(tiles, compression) {\n        super(tiles)\n        this.destroyed = false\n        this.loader = new PIXI.loaders.Loader()\n        this.loader.on('load', this._onLoaded.bind(this))\n        this.loader.on('error', this._onError.bind(this))\n        if (compression) {\n            this.loader.pre(PIXI.compressedTextures.imageParser())\n        }\n    }\n\n    schedule(url, col, row) {\n        // Overwritten schedule to avoid BaseTexture and Texture already loaded errors.\n        if (this.loaded.has(url)) return false\n        if (this.loading.has(url)) return false\n\n        if (deepZoomTileCache.has(url)) {\n            let tiles = deepZoomTileCache.get(url)\n            for (let tile of tiles.values()) {\n                //console.log(\"Reusing cached texture\", tile.parent)\n                let texture = tile.texture\n                this._textureAvailable(url, col, row, texture)\n                return false\n            }\n        }\n        \n        let texture = PIXI.utils.TextureCache[url]\n        if (texture) {\n            if (this.debug) console.log('Texture already loaded', texture)\n            this._textureAvailable(url, col, row, texture)\n            return false\n        }\n        let base = PIXI.utils.BaseTextureCache[url]\n        if (base) {\n            if (this.debug) console.log('BaseTexture already loaded', base)\n            let texture = new PIXI.Texture(base)\n            this._textureAvailable(url, col, row, texture)\n            return false\n        }\n        return super.schedule(url, col, row)\n    }\n\n    /** Load one and only one of the scheduled tiles **/\n    loadOneTile() {\n        if (this.destroyed)\n            return\n        this._loadOneTile()\n    }\n\n    /** Load all scheduled tiles **/\n    loadAll() {\n        if (this.destroyed)\n            return\n        this._loadAllTiles()\n    }\n\n    /** Destroys the loader completly **/\n    destroy() {\n        this.destroyed = true\n        super.destroy()\n        try {\n            this.loader.reset()\n        } catch (error) {\n            console.warn(\"Error while resetting loader\", error)\n        }\n    }\n\n    _onError(loader, error) {\n        console.warn('Cannot load', error)\n    }\n\n    /** Private method. Called by the PIXI loader after each successfull\n     * loading of a single tile.\n     * Creates the sprite for the loaded texture and informs the tile layer.\n     * @param {Object} loader - the loader instance\n     * @param {Object} resource - the loaded resource with url and texture attr\n     **/\n    _onLoaded(loader, resource) {\n        if (this.destroyed) {\n            let texture = resource.texture\n            let destroyBase = !deepZoomTileCache.has(resource.url)\n            texture.destroy(destroyBase)\n            console.warn(\"Received resource after destroy\", texture)\n            return\n        }\n        try {\n            let [col, row] = this.map.get(resource.url)\n            this._textureAvailable(resource.url, col, row, resource.texture)\n        }\n        catch (err) {\n            console.warn(\"Texture unavailable: \" + err.message)\n        }\n    }\n\n    /** Private method: loads one tile from the queue. **/\n    _loadOneTile(retry = 1) {\n        //console.log(\"_loadOneTile\")\n        if (this.destroyed) {\n            //console.warn(\"_loadOneTile after destroy\")\n            return\n        }\n        if (this.loader.loading) {\n            setTimeout(() => {\n                this._loadOneTile()\n            }, retry)\n            return\n        }\n        if (this.loadQueue.length > 0) {\n            let url = this.loadQueue.pop()\n            this.loader.add(url, url)\n            this.loader.load()\n        }\n    }\n\n    /** Private method: loads all tiles from the queue in batches. Batches are\n    helpfull to avoid loading tiles that are no longer needed because the\n    user has already zoomed to a different level.**/\n    _loadAllTiles(batchSize = 8, retry = 16) {\n        if (this.destroyed) {\n            return\n        }\n        if (this.loadQueue.length > 0) {\n            if (this.loader.loading) {\n                //console.log(\"Loader busy\", this.loadQueue.length)\n                setTimeout(() => {\n                    this._loadAllTiles()\n                }, retry)\n                return\n            }\n            let i = 0\n            let urls = []\n            while (i < batchSize && this.loadQueue.length > 0) {\n                let url = this.loadQueue.pop()\n                if (!this.loaded.has(url)) {\n                    let resource = this.loader.resources[url]\n                    if (resource) {\n                        console.log(\"Resource already added\", url)\n                    }\n                    else {\n                        urls.push(url)\n                        i += 1\n                    }\n                }\n            }\n            this.loader.add(urls).load(() => {\n                this._loadAllTiles()\n            })\n        }\n    }\n}\n\n/**\n * Uses XMLHttpRequests but can be replaced with other loaders implementing\n * the public methods without underscore.\n * Calls the Tiles.tileAvailable method if the texture is available.\n **/\nexport class RequestTileLoader extends TileLoader {\n\n    constructor(tiles, compression) {\n        super(tiles)\n        this.compression = compression\n    }\n\n    schedule(url, col, row) {\n        this._load(url, col, row)\n        return super.schedule(url, col, row)\n    }\n\n    _load(url, col, row, callback = null) {\n        if (this.compression) {\n            let xhr = new XMLHttpRequest()\n            xhr.open('GET', url, false)\n            xhr.responseType = 'arraybuffer'\n            xhr.onload = e => {\n                let CompressedImage = PIXI.compressedTextures.CompressedImage\n                let compressed = CompressedImage.loadFromArrayBuffer(\n                    xhr.response,\n                    url\n                )\n                let base = new PIXI.BaseTexture(compressed)\n                let texture = new PIXI.Texture(base)\n                this._textureAvailable(url, col, row, texture)\n                if (callback) callback()\n            }\n            xhr.send()\n        } else {\n            let texture = PIXI.Texture.fromImage('assets/image.png')\n            this._textureAvailable(url, col, row, texture)\n            if (callback) callback()\n        }\n    }\n\n    /** Load one and only one of the scheduled tiles **/\n    loadOneTile() {\n        this._loadOneTile()\n    }\n\n    /** Load all scheduled tiles **/\n    loadAll() {\n        this._loadAllTiles()\n    }\n\n    /** Private method: loads one tile from the queue. **/\n    _loadOneTile(retry = 1) {\n        if (this.loadQueue.length > 0) {\n            let url = this.loadQueue.pop()\n            let [col, row] = this.map.get(url)\n            this._load(url, col, row)\n        }\n    }\n\n    /** Private method: loads all tiles from the queue in batches. Batches are\n    helpfull to avoid loading tiles that are no longer needed because the\n    user has already zoomed to a different level.**/\n    _loadAllTiles(batchSize = 8, retry = 16) {\n        if (this.loadQueue.length > 0) {\n            let i = 0\n            let urls = []\n            while (i < batchSize && this.loadQueue.length > 0) {\n                let url = this.loadQueue.pop()\n                if (this.debug) console.time(url)\n                if (!this.loaded.has(url)) {\n                    urls.push(url)\n                    i += 1\n                }\n            }\n            let total = urls.length\n            let count = 0\n            for (let url of urls) {\n                let [col, row] = this.map.get(url)\n                this._load(url, col, row, () => {\n                    count++\n                    if (count == total) this._loadAllTiles()\n                })\n            }\n        }\n    }\n}\n\n\n/**\n * Uses Workers but can be replaced with other loaders implementing\n * the public methods without underscore.\n * Calls the Tiles.tileAvailable method if the texture is available.\n **/\nexport class WorkerTileLoader extends TileLoader {\n\n    constructor(tiles) {\n        super(tiles)\n        let worker = this.worker = new Worker(\"../../lib/pixi/deepzoom/tileloader.js\")\n        worker.onmessage = (event) => {\n            if (event.data.success) {\n                let { url, col, row, buffer } = event.data\n                //console.log(\"WorkerTileLoader.loaded\", url, buffer)\n                let CompressedImage = PIXI.compressedTextures.CompressedImage\n                let compressed = CompressedImage.loadFromArrayBuffer(buffer, url)\n                let base = new PIXI.BaseTexture(compressed)\n                let texture = new PIXI.Texture(base)\n                this._textureAvailable(url, col, row, texture)\n            }\n        }\n    }\n\n    loadOne() {\n        if (this.loadQueue.length > 0) {\n            let url = this.loadQueue.pop()\n            let [col, row] = this.map.get(url)\n            let tile = [col, row, url]\n            this.worker.postMessage({ command: \"load\", tiles: [tile] })\n        }\n    }\n\n    loadAll() {\n        let tiles = []\n        while (this.loadQueue.length > 0) {\n            let url = this.loadQueue.pop()\n            let [col, row] = this.map.get(url)\n            tiles.push([col, row, url])\n        }\n        this.worker.postMessage({ command: \"load\", tiles })\n    }\n\n    cancel() {\n        super.cancel()\n        this.worker.postMessage({ command: \"abort\" })\n    }\n\n    destroy() {\n        this.worker.postMessage({ command: \"abort\" })\n        this.worker.terminate()\n        this.worker = null\n        super.destroy()\n    }\n}\n","import { Colors } from '../../utils.js'\nimport { WorkerTileLoader, PIXITileLoader } from \"./loader.js\"\n\n\n/**\n * A layer of tiles that represents a zoom level of a DeepZoomImage as a grid\n * of sprites.\n * @constructor\n * @param {number} level - the zoom level of the tile layer\n * @param {DeepZoomImage} view - the zoomable image the layer belongs to\n * @param {number} scale - the scale of the tile layer\n * @param {number} cols - the number of columns of the layer\n * @param {number} rows - the number of rows of the layer\n * @param {number} width - the width of the layer in pixel\n * @param {number} height - the height of the layer in pixel\n * @param {number} tileSize - the size of a single tile in pixel\n * @param {number} overlap - the overlap of the tiles in pixel\n * @param {number} fadeInTime - time needed to fade in tiles if TweenLite is set\n **/\nexport class Tiles extends PIXI.Container {\n    constructor(\n        level,\n        view,\n        scale,\n        cols,\n        rows,\n        width,\n        height,\n        tileSize,\n        overlap,\n        fadeInTime = 0.33\n    ) {\n        super()\n        this.debug = false\n        this.showGrid = false\n        this.view = view\n        this.level = level\n        this.cols = cols\n        this.rows = rows\n        this.pixelWidth = width\n        this.pixelHeight = height\n        this.tileSize = tileSize\n        this.overlap = overlap\n        this.needed = new Map() // url as key, [col, row] as value\n        this.requested = new Set()\n        this.available = new Map()\n        this.scale.set(scale, scale)\n        this.tileScale = scale\n        this.fadeInTime = fadeInTime\n        this.keep = false\n        if (this.view.preferWorker && view.info.compression.length > 0)\n            this.loader = new WorkerTileLoader(this)\n        else\n            this.loader = new PIXITileLoader(this, view.info.compression)\n        this.interactive = false\n        this._highlight = null\n\n        this._info = null\n\n        this._centerPoint = null\n        this._boundsRect = null\n\n        this.infoColor = Colors.random()\n        this.pprint()\n        this.destroyed = false\n    }\n\n\n\n    /** Tests whether all tiles are loaded. **/\n    isComplete() {\n        return this.cols * this.rows === this.children.length\n    }\n\n    /** Returns the highligh graphics layer for debugging purposes.\n     **/\n    get highlight() {\n        if (this._highlight == null) {\n            let graphics = new PIXI.Graphics()\n            graphics.beginFill(0xffff00, 0.1)\n            graphics.lineStyle(2, 0xffff00)\n            graphics.drawRect(1, 1, this.tileSize - 2, this.tileSize - 2)\n            graphics.endFill()\n            graphics.interactive = false\n            this._highlight = graphics\n        }\n        return this._highlight\n    }\n\n    /** Returns the highligh graphics layer for debugging purposes.\n     **/\n    get info() {\n        if (this._info == null) {\n            let graphics = new PIXI.Graphics()\n            graphics.lineStyle(4, 0xff0000)\n            graphics.interactive = false\n            this._info = graphics\n            this.addChild(this._info)\n        }\n        return this._info\n    }\n\n    /** Helper method pretty printing debug information. **/\n    pprint() {\n        if (this.debug)\n            console.log(\n                'Tiles level: ' +\n                this.level +\n                ' scale: ' +\n                this.scale.x +\n                ' cols: ' +\n                this.cols +\n                ' rows: ' +\n                this.rows +\n                ' w: ' +\n                this.pixelWidth +\n                ' h: ' +\n                this.pixelHeight +\n                ' tsize:' +\n                this.tileSize\n            )\n    }\n\n    /** Computes the tile position and obeys the overlap.\n     * @param {number} col - The column of the tile\n     * @param {number} row - The row of the tile\n     * @returns {PIXI.Point} obj\n     **/\n    tilePosition(col, row) {\n        let x = col * this.tileSize\n        let y = row * this.tileSize\n        let overlap = this.overlap\n        if (col != 0) {\n            x -= overlap\n        }\n        if (row != 0) {\n            y -= overlap\n        }\n        return new PIXI.Point(x, y)\n    }\n\n    /** Computes the tile size without overlap\n     * @param {number} col - The column of the tile\n     * @param {number} row - The row of the tile\n     * @returns {PIXI.Point} obj\n     **/\n    tileDimensions(col, row) {\n        let w = this.tileSize\n        let h = this.tileSize\n        let pos = this.tilePosition(col, row)\n        if (col == this.cols - 1) {\n            w = this.pixelWidth - pos.x\n        }\n        if (row == this.rows - 1) {\n            h = this.pixelHeight - pos.y\n        }\n        return new PIXI.Point(w, h)\n    }\n\n    /** Method to support debugging. Highlights the specified tile at col, row **/\n    highlightTile(col, row) {\n        if (col > -1 && row > -1 && col < this.cols && row < this.rows) {\n            let graphics = this.highlight\n            let dim = this.tileDimensions(col, row)\n            graphics.position = this.tilePosition(col, row)\n            graphics.clear()\n            graphics.beginFill(0xff00ff, 0.1)\n            graphics.lineStyle(2, 0xffff00)\n            graphics.drawRect(1, 1, dim.x - 2, dim.y - 2)\n            graphics.endFill()\n            this.addChild(this.highlight)\n        } else {\n            this.removeChild(this.highlight)\n        }\n    }\n\n    /** Loads the tiles for the given urls and adds the tiles as sprites.\n     * @param {array} urlpos - An array of URL, pos pairs\n     * @param {boolean} onlyone - Loads only on tile at a time if true\n     **/\n    loadTiles(urlpos, onlyone, refCol, refRow) {\n        if (this.showGrid) {\n            this.highlightTile(refCol, refRow)\n        }\n        urlpos.forEach(d => {\n            let [url, col, row] = d\n            if (this.loader.schedule(url, col, row)) {\n                if (onlyone) {\n                    return this.loader.loadOneTile()\n                }\n            }\n        })\n        this.loader.loadAll()\n    }\n\n    /** Private method: add a red border to a tile for debugging purposes. **/\n    _addTileBorder(tile, col, row) {\n        let dim = this.tileDimensions(col, row)\n        let graphics = new PIXI.Graphics()\n        graphics.beginFill(0, 0)\n        graphics.lineStyle(2, 0xff0000)\n        graphics.drawRect(1, 1, dim.x - 2, dim.y - 2)\n        graphics.endFill()\n        tile.addChild(graphics)\n    }\n\n    /** Adds a tile. **/\n    addTile(tile, col, row, url) {\n        if (this.available.has(url)) {\n            console.warn('Trying to add available tile')\n            return\n        }\n        this.addChildAt(tile, 0)\n        this.available.set(url, tile)\n        if (this.destroyed) {\n            console.warn('Adding to destroyed tiles layer')\n        }\n        // this._addTileBorder(tile, col, row)\n    }\n\n    /** Called by the loader after each successfull loading of a single tile.\n     * Adds the sprite to the tile layer.\n     * @param {Object} tile - the loaded tile sprite\n     * @param {Number} col - the col position\n     * @param {Number} row - the rowposition\n     **/\n    tileAvailable(tile, col, row, url) {\n        let pos = this.tilePosition(col, row)\n        if (this.showGrid) {\n            this._addTileBorder(tile, col, row)\n        }\n        tile.position = pos\n        tile.interactive = false\n        if (TweenLite) {\n            tile.alpha = 0\n            TweenLite.to(tile, this.fadeInTime, { alpha: this.alpha })\n        }\n        this.addTile(tile, col, row, url)\n    }\n\n    /** Destroys the tiles layer and destroys the loader. Async load calls are\n     * cancelled.\n     **/\n    destroy() {\n        this.destroyed = true\n        this.loader.destroy()\n        super.destroy({ children: true }) // Calls destroyChildren\n        this.available.clear()\n        this.requested.clear()\n        this.needed.clear()\n    }\n\n    destroyTile(url, tile) {\n        this.loader.unschedule(url)\n        this.removeChild(tile)\n        tile.destroy()\n        this.available.delete(url)\n    }\n\n    destroyTileByUrl(url) {\n        if (this.available.has(url)) {\n            let tile = this.available.get(url)\n            this.destroyTile(url, tile)\n        }\n    }\n\n    /* Destroys the tiles which are not with the bounds of the app to free\n    * memory.\n    **/\n    destroyTiles(quadTrees) {\n        let count = 0\n        for (let [url, tile] of this.available.entries()) {\n            if (!quadTrees.has(url)) {\n                this.destroyTile(url, tile)\n                count += 1\n            }\n        }\n        if (count && this.debug)\n            console.log('destroyTiles', this.level, count)\n    }\n\n    destroyUnneededTiles() {\n        let count = 0\n        for (let [url, tile] of this.available.entries()) {\n            if (!this.needed.has(url)) {\n                this.destroyTile(url, tile)\n                count += 1\n            }\n        }\n        if (count && this.debug)\n            console.log('destroyUnneededTiles', this.level, count)\n    }\n\n    highlightInfos() {\n        let graphics = this.info\n        let color = this.infoColor\n        graphics.clear()\n        graphics.lineStyle(2, color)\n        for (let [col, row] of this.needed.values()) {\n            let dim = this.tileDimensions(col, row)\n            let pos = this.tilePosition(col, row)\n            graphics.beginFill(color, 0.2)\n            graphics.drawRect(pos.x + 1, pos.y + 1, dim.x - 2, dim.y - 2)\n            graphics.endFill()\n        }\n        let r = this._boundsRect\n        if (r != null) {\n            graphics.lineStyle(20, color)\n            graphics.drawRect(r.x, r.y, r.width, r.height)\n            graphics.moveTo(r.x, r.y)\n            graphics.lineTo(r.x + r.width, r.y + r.height)\n\n            graphics.moveTo(r.x, r.y + r.height)\n            graphics.lineTo(r.x + r.width, r.y)\n        }\n\n        let p = this._centerPoint\n        if (p != null) {\n            graphics.drawCircle(p.x, p.y, 20)\n        }\n    }\n\n    tintTiles(quadTrees) {\n        for (let [url, tile] of this.available.entries()) {\n            if (!quadTrees.has(url)) tile.tint = 0xff0000\n        }\n    }\n\n    untintTiles() {\n        for (let [url, tile] of this.available.entries()) {\n            tile.tint = 0xffffff\n        }\n    }\n}\n","import { Capabilities } from '../../capabilities.js'\nimport { Points } from '../../utils.js'\nimport { deepZoomTileCache } from './tile.js'\nimport { Tiles } from './tiles.js'\n\nfunction isEven(n) {\n    return n % 2 == 0\n}\n\n\nfunction printTileCacheInfos() {\n    let references = new Map()\n    let multiples = 0\n    for (let [url, tiles] of deepZoomTileCache.entries()) {\n        let count = tiles.size\n        references.set(url, count)\n        if (count > 1) {\n            multiples += 1\n        }\n    }\n    console.log({ multiples, references })\n}\n/**\n * A utility class that holds information typically provided by DZI files, i.e.\n * height and width of the overall image, overlap, and image type.\n *\n * @constructor\n * @param {obj} attrs - A JSON-Object holding the listed keys and values\n * @example\n *     {\n *         \"tileSize\": 1024,\n *         \"format\": \"jpeg\",\n *         \"overlap\": 1,\n *         \"height\": 4794,\n *         \"width\": 4095,\n *         \"clip\": { \"minLevel\": 12, \"maxLevel\": 20, \"startCol\": 301436, \"startRow\": 354060 },\n *                   // optional: minLevel and maxLevel define the level bounds\n *                   // startCol: first col at maxLevel\n *                   // startRow: first row at maxLevel\n *         \"path\": \"var/Vermeer/Vermeer_files\",\n *         \"type\": \"dzi\",  // optional: dzi (default) or map\n *         \"urlTileTemplate\": \"{path}/{level}/{column}/{row}.{format}\"\n *           // optional: {path}/{level}/{column}_{row}.{format} (default) or\n *           // a template String with the format of the URL\n *     }\n */\nexport class DeepZoomInfo {\n    constructor(attrs) {\n        for (let key in attrs) {\n            this[key] = attrs[key]\n        }\n        this.maxLevel = 0 // The highest level number, typically corresponds to the\n        // number in the file system for the folder with tiles\n        this.clip = this.clip || null // e.g. { level: 12, col: 301436, row: 354060 }\n        this.type = this.type || 'dzi'\n        this.urlTileTemplate =\n            this.urlTileTemplate || '{path}/{level}/{column}_{row}.{format}'\n        this.setupDimensions()\n    }\n\n    /* Computes the needed number of layers from the width and height\n    *  of the image. Note that this includes the level 0, i.e. 0 ... 4\n    * means that 5 levels exist.\n    **/\n    numLevels() {\n        let maxDimension = Math.max(this.width, this.height)\n        let boundary = this.type === 'dzi' ? 1 : this.tileSize\n        let numLevels = 0\n        while (maxDimension >= boundary) {\n            maxDimension /= 2\n            numLevels++\n        }\n        return numLevels\n    }\n\n    /** Computes the scale at the given level.\n     * @param {number} level - The level of the wanted layer\n     * @returns {number} scale\n     **/\n    getScale(level) {\n        let scale = 1\n        if (this.type === 'dzi') {\n            scale = Math.pow(0.5, this.maxLevel - level + 1)\n        } else {\n            scale = Math.pow(0.5, this.maxLevel - level)\n        }\n        return scale\n    }\n\n    /** Computes the scaled width and height of the given level.\n     * @param {number} level - The level of the wanted layer\n     * @returns {array} size - The width and height\n     **/\n    getDimensions(level) {\n        let scale = this.getScale(level)\n        let w = Math.ceil(this.width * scale)\n        let h = Math.ceil(this.height * scale)\n        return [w, h]\n    }\n\n    /** Computes the number of cols and rows of tiles.\n     * @param {number} level - The level of the wanted layer\n     * @returns {array} size - The cols and rows\n     **/\n    getNumTiles(level) {\n        let dim = this.getDimensions(level)\n        let cols = Math.ceil(dim[0] / this.tileSize)\n        let rows = Math.ceil(dim[1] / this.tileSize)\n        if (this.clip) {\n            let rest = this.rests[level]\n            if (rest) {\n                if (rest.restCol) {\n                    cols += 1\n                }\n                if (rest.restRows) {\n                    rows += 1\n                }\n            }\n        }\n        return [cols, rows]\n    }\n\n    setupDimensions(loadBaseImage = false) {\n        /** Setup instance variables and load the base image, i.e. the largest\n        image that can be represented as a single tile.\n        @private\n        **/\n        let ww = this.width\n        let hh = this.height\n        let scale = 1.0\n        let level = 0\n        let single = 0\n        const tsize = this.tileSize\n\n        if (this.clip) {\n            this.baseLevel = this.clip.minLevel\n            this.maxLevel = this.clip.maxLevel\n            this.baseImage = null\n            this.size = this.getDimensions(this.baseLevel)\n            this.offsets = {}\n            this.rests = {}\n            let startCol = this.clip.startCol\n            let startRow = this.clip.startRow\n            let floatStartCol = startCol\n            let floatStartRow = startRow\n            for (let i = this.maxLevel; i >= this.baseLevel; i--) {\n                this.offsets[i] = { startCol, startRow }\n                let restCol = floatStartCol % 1\n                let restRow = floatStartRow % 1\n                this.rests[i] = { restCol, restRow }\n                startCol = Math.floor(startCol / 2)\n                startRow = Math.floor(startRow / 2)\n                floatStartCol /= 2\n                floatStartRow /= 2\n            }\n        } else {\n            const boundary = this.type === 'dzi' ? 1.0 : tsize\n            while (ww > boundary && hh > boundary) {\n                if (ww >= tsize && hh >= tsize) {\n                    single += 1\n                }\n                scale = scale / 2.0\n                ww = Math.ceil(this.width * scale)\n                hh = Math.ceil(this.height * scale)\n                level += 1\n            }\n            this.baseLevel = level - single\n            this.maxLevel = this.numLevels() - 1\n            this.baseURL = this.urlForTile(this.baseLevel, 0, 0, false)\n\n            if (loadBaseImage) {\n                this.imageForURL(this.baseURL, e => {\n                    this.size = [e.target.naturalWidth, e.target.naturalHeight]\n                    this.baseImage = e.target\n                })\n            } else {\n                this.baseImage = null\n                this.size = this.getDimensions(this.baseLevel)\n            }\n        }\n    }\n\n    get maxLoadableLevel() {\n        if (this.clip) {\n            return this.maxLevel\n        }\n        return this.type === 'dzi' ? this.maxLevel : this.maxLevel\n    }\n\n    /** Computes the url for the given level, column and and row.\n     * @param {number} level - The level of the wanted layer\n     * @param {number} column - The column of the tile\n     * @param {number} row - The row of the tile\n     * @returns {string} url\n     **/\n    urlForTile(level, column, row, compressed = true) {\n        let format = this.format\n        if (compressed && this.compression) {\n            let supported = Capabilities.isIOS ? 'pvr' : 'dds'\n            if (this.compression.indexOf(supported) >= 0) {\n                format = supported\n            }\n        }\n        if (this.clip) {\n            let offset = this.offsets[level]\n            if (offset) {\n                let { startCol, startRow } = offset\n                column += startCol\n                row += startRow\n            }\n        }\n        let url = this.urlTileTemplate\n            .replace(/\\{path\\}/g, this.path)\n            .replace(/\\{level\\}/g, level)\n            .replace(/\\{row\\}/g, row)\n            .replace(/\\{column\\}/g, column)\n            .replace(/\\{format\\}/g, format)\n        return url\n    }\n\n    /** Loads the image for the given url and executes a callback function\n    on completion.\n    * @param {string} url - The url of the tile\n    * @param {function} complete - The callback function\n    * @returns {Image} obj\n    **/\n    imageForURL(url, complete) {\n        let img = new Image()\n        img.onload = complete.bind(this)\n        img.src = url\n        return img\n    }\n\n    /** Computes the columns and rows as well as scaled width and height.\n     * @param {number} level - The level of the wanted layer\n     * @returns {array} [cols, rows, width, height]\n     **/\n    dimensions(level) {\n        let dim = this.getDimensions(level)\n        let tiles = this.getNumTiles(level)\n        return [tiles[0], tiles[1], dim[0], dim[1]]\n    }\n\n    test() {\n        //console.log(\"w=\" + this.width + \" h=\" + this.height + \" maxlevel=\" + this.maxLevel + \" base=\" + this.baseLevel)\n        for (let i = 0; i <= this.maxLevel; i++) {\n            console.log(\n                ' ' +\n                i +\n                ' -> ' +\n                this.getScale(i) +\n                ' [' +\n                this.dimensions(i) +\n                ']'\n            )\n        }\n        console.log(this.urlForTile(this.baseLevel, 0, 0))\n    }\n}\n\n/**\n * A utility class that describes a quad tree of tiles. Each tile on a given\n * level has up to four corresponding tiles on the next level. A TileQuadNode\n * uses the attributes nw (i.e. northwest), ne, sw, se to link to the\n * quad nodes on the next level. The previous attributes links to the quad\n * one level below that holds the given quad as nw, ne, sw, or se.\n * We use this node class because we need a representation of tiles that are\n * needed but not loaded yet to compute tiles which can be abandoned to reduce\n * the memory pressure.\n *\n * @constructor\n * @param {level} Number - The level the quad node belongs to\n * @param {col} Number - The col of the quad\n * @param {row} Number - The level the quad node belongs to\n * @param {url} String - The level the quad node belongs to\n */\nclass TileQuadNode {\n    constructor(level, col, row, url) {\n        this.level = level\n        this.col = col\n        this.row = row\n        this.url = url\n        this.nw = null\n        this.ne = null\n        this.sw = null\n        this.se = null\n        this.previous = null\n    }\n\n    /** Return True if this node has no successors and can be used as\n    an indicator of tiles to free.\n    **/\n    noQuads() {\n        if (this.previous === null) return false\n        return (\n            this.nw === null &&\n            this.ne === null &&\n            this.sw === null &&\n            this.se === null\n        )\n    }\n\n    /** Unlink the given quad node\n\n    * @param {node} TileQuadNode - The TileQuadNode to remove\n    **/\n    unlink(node) {\n        if (this.nw === node) this.nw = null\n        if (this.ne === node) this.ne = null\n        if (this.sw === node) this.sw = null\n        if (this.se === node) this.se = null\n    }\n\n    /** Link this quad node to the given previous node. Use the north\n    * and west flags to address nw, ne, sw, and se.\n\n    * @param {node} TileQuadNode - The TileQuadNode to remove\n    * @param {north} Boolean - Link to north (true) or south (false)\n    * @param {west} Boolean - Link to west (true) or east (false)\n    **/\n    link(north, west, previous) {\n        this.previous = previous\n        if (north) {\n            if (west) {\n                previous.nw = this\n            } else {\n                previous.ne = this\n            }\n        } else {\n            if (west) {\n                previous.sw = this\n            } else {\n                previous.se = this\n            }\n        }\n    }\n}\n\n\n/**\n * The main class of a deeply zoomable image that is represented by a hierarchy\n * of tile layers for each zoom level. This gives the user the impression that\n * even huge pictures (up to gigapixel-images) can be zoomed instantaneously,\n * since the tiles at smaller levels are scaled immediately and overloaded by\n * more detailed tiles at the larger level as fast as possible.\n\n * @constructor\n * @param {DeepZoomInfo} deepZoomInfo - Information extracted from a JSON-Object\n */\nexport class DeepZoomImage extends PIXI.Container {\n    constructor(\n        deepZoomInfo,\n        {\n            debug = false,\n            shadow = false,\n            center = false,\n            world = null,               // Defines the world bounds the images lives in\n            highResolution = true,\n            autoLoadTiles = true,\n            preferWorker = false,\n            minimumLevel = 0,\n            alpha = 1,\n            app = window.app\n        } = {}\n    ) {\n        super()\n        this.app = app\n        this.debug = debug\n        this.shadow = shadow\n        this.world = world\n        this.preferWorker = preferWorker\n        this.resolution = highResolution\n            ? Math.round(window.devicePixelRatio)\n            : 1\n        this.alpha = alpha\n        this.fastLoads = 0\n        this.autoLoadTiles = autoLoadTiles\n        this.minimumLevel = minimumLevel\n        this.quadTrees = new Map() // url as keys, TileQuadNodes as values\n        this.setup(deepZoomInfo, center)\n    }\n\n    get point() {\n        if (this._point == null) {\n            let graphics = new PIXI.Graphics()\n            graphics.lineStyle(2, 0x00ff00)\n            graphics.drawCircle(0, 0, 2)\n            graphics.interactive = false\n            this._point = graphics\n        }\n        return this._point\n    }\n\n    /** Reads the DeepZoomInfo object and initializes all tile layers.\n     * Called by the constructor.\n     * Creates the sprite for the loaded texture and add the sprite to the tile\n     * layer.\n     * @param {Object} deepZoomInfo - the DeepZoomInfo instance\n     * @param {boolean} center - If true ensures that the pivot is set to the center\n     **/\n    setup(deepZoomInfo, center) {\n        this.info = deepZoomInfo\n        this.interactive = true\n        this.tileLayers = {}\n\n        this._foreground = null\n        this.tileContainer = new PIXI.Container()\n        this.tileContainer.interactive = false\n\n        let [w, h] = this.baseSize\n        if (this.shadow) {\n            this.filters = [new PIXI.filters.DropShadowFilter(45, 3)]\n        }\n        this.addChild(this.tileContainer)\n\n        if (deepZoomInfo.clip) {\n            let mask = new PIXI.Graphics()\n            mask.beginFill(1, 1)\n            mask.drawRect(0, 0, w, h)\n            mask.endFill()\n            this.mask = mask\n            mask.alpha = 0\n            this.addChild(mask)\n            this.minimumLevel = deepZoomInfo.baseLevel\n        }\n        this.currentLevel = Math.max(this.minimumLevel, deepZoomInfo.baseLevel)\n        console.log(\"autoLoadTiles\", this.autoLoadTiles)\n        if (this.autoLoadTiles) {\n            this.setupTiles(center)\n        }\n    }\n\n    /** Default setup method for tiles. Loads all tiles of the current level.\n    Can be overwritten in subclasses.\n    @param {boolean} center - If true ensures that the pivot is set to the center\n    **/\n    setupTiles(center = false) {\n        // First load background tile\n        let tiles = this.ensureAllTiles(this.currentLevel)\n        if (center) {\n            this.pivot.set(w / 2, h / 2)\n        }\n        let scaleLevel = this.levelForScale(1)\n        this.ensureAllTiles(scaleLevel)\n    }\n\n    removeTileQuadNode(level, col, row, url) {\n        if (this.quadTrees.has(url)) {\n            let quad = this.quadTrees.get(url)\n            this.tileQuadRemoved(quad)\n            this.quadTrees.delete(url)\n        }\n    }\n\n    addTileQuadNode(level, col, row, url) {\n        if (this.quadTrees.has(url)) return this.quadTrees.get(url)\n        let quad = new TileQuadNode(level, col, row, url)\n        this.quadTrees.set(url, quad)\n        this.tileQuadAdded(quad)\n        return quad\n    }\n\n    tileQuadRemoved(quad) {\n        let below = quad.previous\n        // if (this.debug) console.log(\"tileQuadRemoved\", quad)\n        if (below) {\n            below.unlink(quad)\n            if (below.noQuads()) {\n                if (this.debug) console.log('Removed tile below')\n                let levelBelow = quad.level - 1\n                if (levelBelow < this.minimumLevel) return\n                let c = Math.floor(quad.col / 2)\n                let r = Math.floor(quad.row / 2)\n                let urlBelow = this.info.urlForTile(levelBelow, c, r)\n                if (this.quadTrees.has(urlBelow)) {\n                    this.removeTileQuadNode(levelBelow, c, r, urlBelow)\n                }\n            }\n        }\n    }\n\n    tileQuadAdded(quad) {\n        let levelBelow = quad.level - 1\n        if (levelBelow < this.minimumLevel) return\n        //if (this.debug) console.log(\"tileQuadAdded\", quad)\n        let c = Math.floor(quad.col / 2)\n        let r = Math.floor(quad.row / 2)\n        let urlBelow = this.info.urlForTile(levelBelow, c, r)\n        let below = null\n        if (!this.quadTrees.has(urlBelow)) {\n            below = this.addTileQuadNode(levelBelow, c, r, urlBelow)\n            quad.link(isEven(quad.row), isEven(quad.col), below)\n        }\n    }\n\n    /** Returns the tile layer level that corresponds to the given scale.\n     * @param {number} scale - the scale factor\n     **/\n    levelForScale(scale) {\n        let level = Math.round(Math.log2(scale * this.resolution)) // Math.floor(Math.log2(event.scale))+1\n        let newLevel = this.info.baseLevel + Math.max(level, 0)\n        return Math.min(newLevel, this.info.maxLoadableLevel)\n    }\n\n    /** Returns the tile layer level that corresponds to the given scale.\n     * @param {number} scale - the scale factor\n     **/\n    levelAndAlphaForScale(scale) {\n        let value = Math.log2(scale * this.resolution)\n        let level = Math.round(value)\n        let newLevel = this.info.baseLevel + Math.max(level, 0)\n\n        return { level: Math.min(newLevel, this.info.maxLoadableLevel), alpha: value - level }\n    }\n\n    /** Adds a tile layer to the DeepZoomImage.\n     * @param {string} key - the access key\n     * @param {Tiles} tiles - the tile layer object\n     **/\n    addTiles(key, tiles) {\n        if (key in this.tileLayers) {\n            console.warn('Tiles already availabl', key)\n        }\n        this.tileContainer.addChild(tiles)\n        this.tileLayers[key] = tiles\n    }\n\n    destroyTiles(key) {\n        let tiles = this.tileLayers[key]\n        this.tileContainer.removeChild(tiles)\n        tiles.destroy()\n        delete this.tileLayers[key]\n    }\n\n    /** Getter for PIXI.Container foreground layer.\n     * Adds a PIXI.Container if necessary.\n     **/\n    get foreground() {\n        if (this._foreground == null) {\n            this._foreground = new PIXI.Container()\n            this.addChild(this._foreground)\n        }\n        return this._foreground\n    }\n\n    /** Getter for the DeepZoomInfo base level size.\n     **/\n    get baseSize() {\n        return this.info.getDimensions(this.info.baseLevel)\n    }\n\n    /** Getter for the current scaled size in pixels.\n     **/\n    get pixelSize() {\n        let [w, h] = this.baseSize\n        return [w * this.scale.x, h * this.scale.y]\n    }\n\n    /** Getter for the max scale factor.\n     **/\n    get maxScale() {\n        let delta = this.info.maxLevel - this.info.baseLevel\n        return Math.pow(2, delta) / this.resolution * 2\n    }\n\n    /** Getter for the current width.\n     **/\n    get width() {\n        return this.pixelSize[0]\n    }\n\n    /** Getter for the current height.\n     **/\n    get height() {\n        return this.pixelSize[1]\n    }\n\n\n    /* Overrides PIXI.Container.hitArea()\n     * Allows to optimize the hit testing. Container with hit areas are directly\n     * hit tested without consideration of children.\n     */\n    get hitArea() {\n        // Defining the hitArea resulted hitting the scatter in masked area\n        // when a mask was used (@Tüsch[submaps]). Removing the hitArea() altogether\n        // broke the interaction in other projects (@googleart).\n        // Fix: When masked, the hitArea is ignored by returning null.\n        // TODO: test if childs are hittested, without setting interactiveChildren.\n        // Opel, 03-05-2018\n        if (this.mask) {\n            return null\n        }\n        return this\n    }\n\n    /* Overrides PIXI.Container.contains()\n     * Allows to optimize the hit testing.\n     */\n    contains(x, y) {\n        let [w, h] = this.baseSize\n        return x >= 0 && x <= w && y >= 0 && y <= h\n    }\n\n    /** Overrides PIXI.Container._calculateBounds()\n     * Only considers the base size and reduces the calculation to a single\n     * rect.\n     */\n    _calculateBounds() {\n        let [w, h] = this.baseSize\n        this._bounds.addFrame(this.transform, 0, 0, w, h)\n    }\n\n    /** Overrides PIXI.Container.calculateBounds()\n     * Skips the children and only considers the deep zoom base size. Calls\n     * the also overwritten _calculateBounds method.\n     */\n    calculateBounds() {\n        this._bounds.clear()\n        this._calculateBounds()\n        this._lastBoundsID = this._boundsID\n    }\n\n    /** Returns a single sprite that can be used a thumbnail representation of\n     * large images.\n     * @return {Sprite} sprite - A sprite with a single tile texture\n     */\n    thumbnail() {\n        return new PIXI.Sprite.fromImage(this.info.baseURL)\n    }\n\n    /** Returns a list of all tiles of a given level.\n     * @param {Tiles} tiles - the grid of tiles\n     * @param {number} level - The zoom level of the grid\n     * @return {Array[]} - An array of [url, col, row] arrays\n     **/\n    allTiles(tiles, level) {\n        let result = []\n        for (let col = 0; col < tiles.cols; col++) {\n            for (let row = 0; row < tiles.rows; row++) {\n                let url = this.info.urlForTile(level, col, row)\n                result.push([url, col, row])\n            }\n        }\n        return result\n    }\n\n    worldBounds() {\n        let viewBounds = this.app.scene.bounds\n        // Using getBounds extends visible scope after loading tiles and leads\n        // to excessive loading\n        if (this.world != null) {\n            let bounds = this.world.bounds\n            let x = Math.max(-bounds.width, bounds.x)\n            let y = Math.max(-bounds.height, bounds.y)\n            let width = Math.min(viewBounds.width, bounds.width)\n            let height = Math.min(viewBounds.height, bounds.height)\n            //console.log(\"worldBounds new\", { x, y, width, height })\n            return { x, y, width, height }\n        }\n        //console.log(\"worldBounds old\", viewBounds)\n        return viewBounds\n    }\n\n    /** Loads all tiles that are needed to fill the app bounds.\n     * @param {Tiles} tiles - the grid of tiles\n     * @param {number} level - The zoom level of the grid\n     * @param {boolean} debug\n     * @return {Array[]} - An array of [url, col, row] arrays\n     */\n    neededTiles(tiles, level, debug = false) {\n        let needed = []\n        let tsize = tiles.tileSize\n        let worldBounds = this.worldBounds()\n        let maxWidth = worldBounds.width\n        let maxHeight = worldBounds.height\n\n        let pointInWindow = new PIXI.Point()\n        let worldTopLeft = new PIXI.Point(worldBounds.x, worldBounds.y)\n        let worldBottomRight = new PIXI.Point(worldBounds.x + maxWidth, worldBounds.y + maxHeight)\n        let worldCenter = new PIXI.Point(worldBounds.x + maxWidth / 2, worldBounds.y + maxHeight / 2)\n        let tilesCenter = tiles.toLocal(worldCenter)\n\n        let topLeft = tiles.toLocal(worldTopLeft)\n        let bottomRight = tiles.toLocal(worldBottomRight)\n        tiles._centerPoint = tilesCenter\n        let bounds = new PIXI.Rectangle(\n            topLeft.x,\n            topLeft.y,\n            bottomRight.x - topLeft.x,\n            bottomRight.y - topLeft.y)\n\n        tiles._boundsRect = bounds\n\n        /* UO: we need a toLocal call here since the transform may need an update\n        which is guaranteed by the toLocal method. */\n        let centerCol = Math.floor(tilesCenter.x / tsize)\n        let centerRow = Math.floor(tilesCenter.y / tsize)\n\n        // Expand because we want to test for included centers\n        bounds.x -= tsize / 2\n        bounds.y -= tsize / 2\n        bounds.width += tsize\n        bounds.height += tsize\n\n        try {\n            let maxTilesWidth = Math.ceil(maxWidth / tsize)\n            let maxTilesHeight = Math.ceil(maxHeight / tsize)\n\n            maxTilesWidth += 2\n            maxTilesHeight += 2\n\n            let startCol = Math.max(0, centerCol - maxTilesWidth)\n            let endCol = Math.min(tiles.cols, centerCol + maxTilesWidth)\n\n            let startRow = Math.max(0, centerRow - maxTilesHeight)\n            let endRow = Math.min(tiles.rows, centerRow + maxTilesHeight)\n\n            for (let col = startCol; col < endCol; col++) {\n                let cx = (col + 0.5) * tsize\n                for (let row = startRow; row < endRow; row++) {\n                    let cy = (row + 0.5) * tsize\n                    let tileCenter = new PIXI.Point(cx, cy)\n                    if (bounds.contains(tileCenter.x, tileCenter.y)) {\n                        let url = this.info.urlForTile(level, col, row)\n                        needed.push([url, col, row])\n                    }\n                }\n            }\n        } catch (error) {\n            console.warn(error.message)\n        }\n        return { centerCol, centerRow, needed }\n    }\n\n\n\n\n    /** Returns all changed tiles for a given level.\n     * @param {Tiles} tiles - the grid of tiles\n     * @param {number} level - The zoom level of the grid\n     * @return {object} - An object with the keys added and removed which values are [url, col, row] arrays\n     */\n    changedTiles(tiles, level) {\n        if (this.debug) console.time('changedTiles')\n        let changed = { added: [], removed: [] }\n        let newNeeded = new Map()\n        let { centerCol, centerRow, needed } = this.neededTiles(tiles, level)\n        needed.forEach(d => {\n            let [url, col, row] = d\n            newNeeded.set(url, [col, row])\n            if (!tiles.requested.has(url)) {\n                changed.added.push(d)\n            }\n        })\n        for (let url of tiles.needed.keys()) {\n            if (!newNeeded.has(url)) {\n                let [col, row] = tiles.needed.get(url)\n                changed.removed.push([url, col, row])\n            }\n        }\n        tiles.needed = newNeeded\n        if (this.debug) console.log(newNeeded)\n        if (this.debug) console.timeEnd('changedTiles')\n        return { centerCol, centerRow, changed }\n    }\n\n    /** Populates all tiles for a given level.\n     * @param {Tiles} tiles - the grid of tiles\n     * @param {number} level - The zoom level of the grid\n     */\n    populateAllTiles(tiles, level) {\n        let all = this.allTiles(tiles, level)\n        for (let [url, col, row] of all) {\n            this.addTileQuadNode(level, col, row, url)\n        }\n        tiles.loadTiles(all, false, 0, 0)\n    }\n\n    /** Loads all tiles that are needed to fill the browser window.\n     * If the optional about parameter is provided (as a point with col as x,\n     * and row as y attr) the tiles are sorted by the distance to this point.\n     *\n     * @param {Tiles} tiles - the grid of tiles\n     * @param {number} level - The zoom level of the grid\n     * Optional parameter:\n     * @param {boolean} onlyone - if true only one tile is loaded\n     * @param {PIXI.Point} about - point of interaction\n     */\n    populateTiles(tiles, level, { onlyone = false, about = null } = {}) {\n        if (tiles.isComplete())\n            return\n        let referenceCol = -1\n        let referenceRow = -1\n        let { centerCol, centerRow, changed } = this.changedTiles(tiles, level)\n        if (about != null) {\n            // We want to load tiles in the focus of the user first, therefore\n            // we sort according to the distance of the focus of interaction\n            let refPoint = this.toLocal(about)\n            let scaledTileSize = tiles.tileSize * tiles.tileScale\n            referenceCol = Math.floor(refPoint.x / scaledTileSize)\n            referenceRow = Math.floor(refPoint.y / scaledTileSize)\n        }\n        else {\n            referenceCol = centerCol\n            referenceRow = centerRow\n        }\n        referenceCol = centerCol\n        referenceRow = centerRow\n\n        let removed = changed.removed\n        for (let [url, col, row] of removed) {\n            this.removeTileQuadNode(level, col, row, url)\n        }\n        let added = changed.added\n        if (added.length == 0) return\n        for (let [url, col, row] of added) {\n            this.addTileQuadNode(level, col, row, url)\n        }\n        let ref = new PIXI.Point(referenceCol, referenceRow)\n        // Note: The array must be sorted in a way that the nearest tiles\n        // are at the end of the array since the load queue uses Array.push\n        // Array.pop\n        added.sort((a, b) => {\n            let aa = new PIXI.Point(a[1], a[2])\n            let bb = new PIXI.Point(b[1], b[2])\n            let da = Points.distance(aa, ref)\n            let db = Points.distance(bb, ref)\n            return db - da\n        })\n        tiles.loadTiles(added, onlyone, referenceCol, referenceRow)\n    }\n\n    /** Private method: creates all tiles for a given level.\n     * @param {number} level - The zoom level of the grid\n     * @return {Tiles} - tiles\n     */\n    _createTiles(key, level) {\n        let [cols, rows, w, h] = this.info.dimensions(level)\n        let increasedLevels = level - this.info.baseLevel\n        let invScale = Math.pow(0.5, increasedLevels)\n        let tiles = new Tiles(\n            level,\n            this,\n            invScale,\n            cols,\n            rows,\n            w,\n            h,\n            this.info.tileSize,\n            this.info.overlap\n        )\n        this.addTiles(key, tiles)\n        if (this.info.clip) {\n            let rest = this.info.rests[level]\n            if (rest) {\n                let x = rest.restCol * this.info.tileSize * invScale\n                let y = rest.restRow * this.info.tileSize * invScale\n                tiles.x = -x\n                tiles.y = -y\n            }\n        }\n        return tiles\n    }\n\n    /** Ensures that all needed tiles of a given level are loaded. Creates\n     * a new Tiles layer if necessary\n     * @param {number} level - The zoom level of the grid\n     * @return {Tiles} tiles\n     */\n    ensureTiles(level, about) {\n        let key = level.toString()\n        if (key in this.tileLayers) {\n            let tiles = this.tileLayers[key]\n            this.populateTiles(tiles, level, { about: about })\n            return tiles\n        }\n        let tiles = this._createTiles(key, level)\n        this.populateTiles(tiles, level, { about: about })\n        //console.log(\"ensureTiles\", level)\n        return tiles\n    }\n\n    untintTiles(level) {\n        let key = level.toString()\n        if (key in this.tileLayers) {\n            let tiles = this.tileLayers[key]\n        }\n    }\n\n    /** Ensures that all tiles of a given level are loaded.\n     * @param {number} level - The zoom level of the grid\n     */\n    ensureAllTiles(level) {\n        let key = level.toString()\n        if (key in this.tileLayers) {\n            let tiles = this.tileLayers[key]\n            this.populateAllTiles(tiles, level)\n            tiles.keep = true\n            return\n        }\n        let tiles = this._createTiles(key, level)\n        this.populateAllTiles(tiles, level)\n        tiles.keep = true\n        return tiles\n    }\n\n    hideTilesAboveLevel(level) {\n        Object.keys(this.tileLayers).forEach(key => {\n            let tiles = this.tileLayers[key]\n            if (tiles.level > level) {\n                tiles.visible = false\n            }\n        })\n    }\n\n    /** Destroys all tiles above a given level to ensure that the memory can\n     * be reused.\n     * @param {number} level - The zoom level of the grid\n     */\n    destroyTilesAboveLevel(level) {\n        Object.keys(this.tileLayers).forEach(key => {\n            let tiles = this.tileLayers[key]\n            if (tiles.level > level && !tiles.keep) {\n                for (let url of tiles.available.keys()) {\n                    let quad = this.quadTrees.get(url)\n                    if (quad) this.removeTileQuadNode(quad)\n                }\n                this.destroyTiles(key)\n            }\n        })\n    }\n\n    destroyAllTiles() {\n        Object.keys(this.tileLayers).forEach(key => {\n            this.destroyTiles(key)\n        })\n    }\n\n    /**\n     * Tint tiles in all layers that are no longer needed\n     *\n     * @memberof DeepZoomImage\n     */\n    tintObsoleteTiles() {\n        Object.keys(this.tileLayers).forEach(key => {\n            let tiles = this.tileLayers[key]\n            tiles.untintTiles()\n            if (!tiles.keep) {\n                tiles.tintObsoleteTiles()\n            }\n        })\n    }\n\n\n    /**\n     * Destroy tiles in all layers that are no longer needed\n     *\n     * @memberof DeepZoomImage\n     */\n    destroyUnneededTiles() {\n        Object.keys(this.tileLayers).forEach(key => {\n            let tiles = this.tileLayers[key]\n            if (!tiles.keep) {\n                tiles.destroyUnneededTiles()\n            }\n        })\n    }\n\n    /**\n     * Destroy tiles in all layers that are no longer needed\n     *\n     * @memberof DeepZoomImage\n     */\n    destroyObsoleteTiles() {\n        Object.keys(this.tileLayers).forEach(key => {\n            let tiles = this.tileLayers[key]\n            if (!tiles.keep) {\n                tiles.destroyObsoleteTiles()\n            }\n        })\n    }\n\n    /**\n     * Destroy tiles in all layers that are not part of the\n     * visible quadTrees\n     *\n     * @memberof DeepZoomImage\n     */\n    destroyTiles() {\n        Object.keys(this.tileLayers).forEach(key => {\n            let tiles = this.tileLayers[key]\n            if (!tiles.keep) {\n                tiles.destroyTiles(this.quadTrees)\n            }\n        })\n    }\n\n    /* Tint all tiles\n    * @param {number} level - The zoom level of the grid\n    */\n    tintTilesBelowLevel(level) {\n        Object.keys(this.tileLayers).forEach(key => {\n            let tiles = this.tileLayers[key]\n            if (tiles.level < level) {\n                tiles.tintTiles(this.quadTrees)\n            }\n        })\n    }\n\n    /**\n     * Ensure that the given tiles layer is the topmost one and visible.\n     * @param {*} tiles \n     */\n    bringTilesToFront(tiles) {\n        this.tileContainer.addChild(tiles)\n        tiles.visible = true\n    }\n\n    /** A callback function that can be used by a Scatter view to inform\n     * the zoomable image that it has been moved, rotated or scaled, and should\n     * load tiles accordingly.\n     * @param {PIXI.Point} translated - the movement of the scatter\n     * @param {number} scale - the zoom factor\n     * @param {PIXI.Point} about - the anchor point of the zoom\n     * @param {boolean} fast - informs the callback to return as fast as possible,\n     *  i.e. after loading a single tile\n     * @param {boolean} debug - log debug infos\n     */\n    transformed(event) {\n        let key = this.currentLevel.toString()\n        let currentTiles = this.tileLayers[key]\n        if (typeof currentTiles == 'undefined') {\n            return\n        }\n        if (event.fast) {\n            this.fastLoads += 1\n            this.populateTiles(currentTiles, this.currentLevel, {\n                onlyone: false,\n                about: event.about\n            })\n            if (this.fastLoads == 3) {\n                this.fastLoads = 0\n            }\n            else {\n                return\n            }\n        }\n        if (event.scale == null) {\n            this.ensureTiles(this.currentLevel, event.about)\n            return\n        }\n        \n        let level = this.levelForScale(event.scale)\n        let newLevel = Math.max(level, this.minimumLevel)\n        if (newLevel != this.currentLevel) {\n            if (!currentTiles.keep) {\n                currentTiles.loader.cancel()\n            }\n            this.hideTilesAboveLevel(newLevel)\n            currentTiles = this.ensureTiles(newLevel, event.about)\n            this.currentLevel = newLevel\n        } else {\n            this.ensureTiles(this.currentLevel, event.about)\n        }\n        this.bringTilesToFront(currentTiles)\n        if (this._foreground) {\n            this.addChild(this._foreground)\n        }\n    }\n\n    /**\n   *Activates the textures on the DeepZoomImage.\n   *\n   * @memberof DeepZoomImage\n   */\n    activate() {\n        this.destroyTilesAboveLevel(this.currentLevel)\n        this.ensureTiles(this.currentLevel, null)\n        //console.log(\"Activate Textures!\", this.currentLevel)\n    }\n\n    /**\n   *Dectivates the textures on the DeepZoomImage.\n   *\n   * @memberof DeepZoomImage\n   */\n    deactivate() {\n        this.destroyAllTiles()\n        Object.keys(this.tileLayers).forEach(key => {\n            this.destroyTiles(key)\n        })\n        this.tileContainer.destroy({ children: true })\n        printTileCacheInfos()\n    }\n\n    throwFinished() {\n        console.log(\"throwFinished\")\n        let key = this.currentLevel.toString()\n        let currentTiles = this.tileLayers[key]\n        if (typeof currentTiles == 'undefined') {\n            return\n        }\n\n        this.ensureTiles(this.currentLevel)\n        // let all = new Set()\n        // for (let tile of currentTiles.children) {\n        //     all.add(tile.url)\n        // }\n        // let { centerCol, centerRow, needed } = this.neededTiles(currentTiles, this.currentLevel)\n        // for (let [url, col, row] of needed) {\n        //     all.delete(url)\n        // }\n        // for (let url of all) {\n        //     currentTiles.destroyTileByUrl(url)\n        // }\n        // currentTiles.loader.loader.reset()\n    }\n}\n","import {getId, Angle} from '../utils.js'\nimport {DOMScatter} from '../scatter.js'\nimport {CardLoader, DOMFlip, DOMFlippable} from '../flippable.js'\nimport {Capabilities} from '../capabilities.js'\nimport {DeepZoomImage} from './deepzoom/image.js'\n\nlet globalScatterLoaderCanvas = null\n\nexport class ScatterLoader extends CardLoader {\n\n    get scatter() {\n        return this.src\n    }\n\n    unscaledSize() {\n        let displayObject = this.scatter.displayObject\n        let w = displayObject.width\n        let h = displayObject.height\n        return [w / displayObject.scale.x, h / displayObject.scale.y]\n    }\n\n    scaledSize() {\n        let displayObject = this.scatter.displayObject\n        let w = displayObject.width\n        let h = displayObject.height\n        return [w, h]\n    }\n\n    cloneScatterImage() {\n        let w = this.scatter.width\n        let h = this.scatter.height\n        let isSprite = this.scatter.displayObject instanceof PIXI.Sprite\n        let isDeepZoom = this.scatter.displayObject instanceof DeepZoomImage\n        let resolution = app.renderer.resolution\n        if (isSprite) {\n            w = this.scatter.displayObject.texture.width\n            h = this.scatter.displayObject.texture.height\n        }\n        else if (isDeepZoom) {\n            let [ww, hh] = this.scatter.displayObject.baseSize\n            w = ww\n            h = hh\n        }\n        if (globalScatterLoaderCanvas === null) {\n            globalScatterLoaderCanvas = document.createElement('canvas')\n        }\n        let canvas = globalScatterLoaderCanvas\n        canvas.width = w\n        canvas.height = h\n        let renderer = new PIXI.WebGLRenderer(w, h, {\n                                    view: canvas,\n                                    resolution: resolution})\n\n        let displayObject = this.scatter.displayObject\n        let x = displayObject.x\n        let y = displayObject.y\n        let rot = displayObject.rotation\n        let sx = displayObject.scale.x\n        let sy = displayObject.scale.y\n        displayObject.rotation = 0\n        // The Safari WebGLRenderer wants everything flipped\n        // See https://github.com/pixijs/pixi.js/issues/2283\n        displayObject.x = 0\n        if (Capabilities.isSafari) {\n            displayObject.y = h\n            displayObject.scale.set(1, -1) // sx, -sy)\n        }\n        else {\n            displayObject.y = 0\n            displayObject.scale.set(1, 1)\n        }\n        if (isSprite) {\n            displayObject.width = w\n            displayObject.height = h\n        }\n        renderer.render(displayObject)\n        displayObject.rotation = rot\n        displayObject.x = x\n        displayObject.y = y\n        displayObject.scale.set(sx, sy)\n\n        let url = canvas.toDataURL()\n        return [x, y, w, h, url]\n    }\n\n    load(domNode) {\n        return new Promise((resolve, reject) => {\n            let isImage = domNode instanceof HTMLImageElement\n            let isSprite = this.scatter.displayObject instanceof PIXI.Sprite\n            let image = (isImage) ? domNode : document.createElement(\"img\")\n            let [x, y, w, h, cloneURL] = this.cloneScatterImage()\n            let [ww, hh] = this.unscaledSize()\n            image.onload = (e) => {\n                if (!isImage)\n                    domNode.appendChild(image)\n                this.x = x\n                this.y = y\n                this.wantedWidth = ww\n                this.wantedHeight = hh\n                this.scale = 1\n                this.rotation = this.scatter.rotation\n                resolve(this)\n            }\n            image.onerror = (e) => {\n                reject(this)\n            }\n            image.src = cloneURL\n            })\n    }\n\n}\n\nexport default class FlipEffect {\n\n    constructor(scatter, domScatterContainer, flipTemplate, backLoader) {\n        this.flipped = false\n        this.scatter = scatter\n        this.backLoader = backLoader\n        this.scatterLoader = new ScatterLoader(scatter)\n        this.domFlip = new DOMFlip(domScatterContainer, flipTemplate,\n                                    this.scatterLoader,\n                                    backLoader, {\n                                        onBack: this.backCardClosed.bind(this)\n                                    })\n        this.setupInfoButton()\n    }\n\n    startFlip() {\n        let center = this.flipCenter()\n        let loader = this.backLoader\n        this.domFlip.load().then((domFlip) => {\n            this.scatter.displayObject.visible = false\n            domFlip.centerAt(center)\n            domFlip.zoom(this.scatter.scale)\n            let target = this.constraintFlipCenter(center, loader)\n            console.log(\"FlipEffect.startFlip\", target, loader)\n            domFlip.start({targetCenter: target})\n        })\n    }\n\n    unscaledSize() {\n        return this.scatterLoader.unscaledSize()\n    }\n\n    flipCenter() {\n        let isSprite = this.scatter.displayObject instanceof PIXI.Sprite\n        let resolution = (isSprite) ? app.renderer.resolution : 1\n        let center = this.scatter.center\n        let canvas = app.renderer.view\n        let domNode = this.domFlip.domScatterContainer.element\n        let page = window.convertPointFromNodeToPage(canvas,\n                                                        center.x*resolution,\n                                                        center.y*resolution)\n        let local = window.convertPointFromPageToNode(domNode, page.x, page.y)\n        return local\n    }\n\n    constraintFlipCenter(center, loader) {\n        let w = loader.wantedWidth\n        let h = loader.wantedHeight\n        console.log(\"constraintFlipCenter\", w, h)\n        let canvas = app.renderer.view\n        let x = center.x\n        let y = center.y\n        if (x < w/2)\n            x = w/2\n        if (y < h/2)\n           y = h/2\n        if (x > canvas.width)\n            x = canvas.width - w/2\n        if (y > canvas.height)\n            y = canvas.height - h/2\n        return { x, y }\n    }\n\n    setupInfoButton() {\n        let iscale = 1.0 / this.scatter.scale\n        this.infoBtn = new PIXI.Graphics()\n        this.infoBtn.beginFill(0x333333)\n        this.infoBtn.lineStyle(4, 0xFFFFFF)\n        this.infoBtn.drawCircle(0, 0, 22)\n        this.infoBtn.endFill()\n\n        this.infoBtn.beginFill(0xFFFFFF)\n        this.infoBtn.lineStyle(0)\n        this.infoBtn.drawCircle(0, -8, 4)\n        this.infoBtn.endFill()\n\n        this.infoBtn.lineStyle(6, 0xFFFFFF)\n        this.infoBtn.moveTo(0, -2)\n        this.infoBtn.lineTo(0, 14)\n        this.infoBtn.endFill()\n\n        this.infoBtn.on('click', (e) => { this.infoSelected() })\n        this.infoBtn.on('tap', (e) => { this.infoSelected() })\n\n        this.infoBtn.interactive = true\n        this.infoBtn.width = 44\n        this.infoBtn.height = 44\n        this.infoBtn.pivot.x = 30\n        this.infoBtn.pivot.y = 30\n\n        let displayObject = this.scatter.displayObject\n        let [w, h] = this.unscaledSize()\n        this.infoBtn.position = new PIXI.Point(w, h)\n        if (displayObject.foreground) {\n            this.infoBtn.scale.x = iscale\n            this.infoBtn.scale.y = iscale\n            displayObject.foreground.addChild(this.infoBtn)\n        }\n        else {\n            displayObject.addChild(this.infoBtn)\n        }\n\n        this.scatter.addTransformEventCallback(e => {\n            let displayObject = this.scatter.displayObject\n            if (displayObject.foreground) {\n                if (e.scale) {\n                    let iscale = 1.0 / e.scale\n                    this.infoBtn.scale.x = iscale\n                    this.infoBtn.scale.y = iscale\n                }\n            }\n        })\n    }\n\n    setupButton(url) {\n        let svgImage = new Image()\n        let canvas = document.createElement('canvas')\n        canvas.width = 88 * 4\n        canvas.height = 44 * 4\n        svgImage.onload = e => {\n            let displayObject = this.scatter.displayObject\n            canvas.getContext ('2d').drawImage(svgImage, 0, 0,\n                                            canvas.width, canvas.height)\n            let texure = new PIXI.Texture(new PIXI.BaseTexture(canvas))\n            this.infoBtn = new PIXI.Sprite(texure)\n            this.infoBtn.anchor.set(0.5, 0.5)\n            if (displayObject.foreground) {\n                displayObject.foreground.addChild(this.infoBtn)\n            }\n            else {\n                displayObject.addChild(this.infoBtn)\n            }\n            this.infoBtn.scale.set(0.5, 0.5)\n\n            let [w, h] = this.unscaledSize()\n            this.infoBtn.position = new PIXI.Point(w, h)\n            this.infoBtn.interactive = true\n            this.infoBtn.updateTransform()\n            this.infoBtn.on('click', (e) => { this.infoSelected() })\n            this.infoBtn.on('tap', (e) => { this.infoSelected() })\n        }\n        svgImage.src = url\n    }\n\n    infoSelected() {\n        this.startFlip()\n    }\n\n    backSelected() {\n        this.domFlip.start()\n    }\n\n    backCardClosed() {\n        /*** The flip effect should now be in it's initial state again. All\n        memory should be freed. ***/\n        let displayObject = this.scatter.displayObject\n        displayObject.visible = true\n        this.domFlip.fadeOutAndRemove()\n        this.flipped = false\n    }\n\n    targetRotation(alpha) {\n        let ortho = 90\n        let rest = alpha % ortho\n        let delta = 0.0\n        if (rest > (ortho / 2.0)) {\n            delta = ortho - rest\n        }\n        else {\n            delta = -rest\n        }\n        return delta\n    }\n}\n\n","/* globals Power2, Sine */\n/*eslint no-console: [\"error\", { allow: [\"log\", \"info\", \"error\"] }]*/\n\n/**\n * Callback for the flippable onStart function.\n *\n * @callback onStartCallback\n * @param {Flippable} flippable - A reference to the flippable (also this refers to the flippable).\n */\n\n/**\n * Callback for the flippable onUpdate function.\n *\n * @callback onUpdateCallback\n * @param {Flippable} flippable - A reference to the flippable (also this refers to the flippable).\n */\n\n/**\n * Callback for the flippable onComplete function.\n *\n * @callback onCompleteCallback\n * @param {Flippable} flippable - A reference to the flippable (also this refers to the flippable).\n */\n\n/**\n * Class that represents a PixiJS Flippable.\n *\n * @example\n * const front = PIXI.Sprite.fromImage('./assets/front.jpg')\n * const back = PIXI.Sprite.fromImage('./assets/back.jpg')\n * app.scene.addChild(front)\n * \n * // Create the flippable\n * const flippable = new Flippable(front, back, app.renderer)\n * \n * front.interactive = true\n * front.on('click', event => flippable.toggle())\n *\n * @class\n * @extends PIXI.projection.Camera3d\n * @see {@link https://github.com/pixijs/pixi-projection|PixiJS Projection}\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/flippable.html|DocTest}\n */\nexport default class Flippable extends PIXI.projection.Camera3d {\n\n    /**\n     * Creates an instance of a Flippable.\n     *\n     * @constructor\n     * @param {PIXI.DisplayObject} front - The object to show initially. Should have been added to the scene.\n     * @param {PIXI.DisplayObject} back - The object to show on the backside. Should have not been added to the scene.\n     * @param {PIXI.WebGLRenderer|PIXI.CanvasRenderer} renderer - The renderer of the application.\n     * @param {object} [opts] - An options object which can contain the following properties.\n     * @param {number} [opts.duration=1] - The duration of the flip animation in seconds.\n     * @param {GSAP.Ease} [opts.ease=Power2.easeOut] - The ease of the flip animation.\n     * @param {boolean} [opts.shadow=false] - Should be a shadow been display during the animation?\n     * @param {numer} [opts.eulerX=0] - The shift of the x-axis during the animation.\n     * @param {numer} [opts.eulerY=0] - The shift of the y-axis during the animation.\n     * @param {GSAP.Ease} [opts.eulerEase=Sine.easeOut] - The ease of the shift.\n     * @param {boolean} [opts.useBackTransforms=false] - When set to true, the flip animation also animates to the transform parameters of the back-object.\n     * @param {GSAP.Ease} [opts.transformEase=Power2.easeOut] - The ease of the transform.\n     * @param {numer} [opts.focus=800] - The value of the focus of the 3D camera (see pixi-projection).\n     * @param {numer} [opts.near=10] - The near value of the 3D camera (see pixi-projection).\n     * @param {numer} [opts.far=10000] - The far value of the 3D camera (see pixi-projection).\n     * @param {boolean} [opts.orthographic=false] - Should the flip animation be an orthographic animation?\n     * @param {function} [opts.onStart=null] - A callback executed on start of the flip animation.\n     * @param {function} [opts.onUpdate=null] - A callback executed on each step of the flip animation.\n     * @param {function} [opts.onComplete=null] - A callback executed when the flip animation is finished.\n     */\n    constructor(front, back, renderer, opts = {}) {\n\n        super()\n\n        this.opts = Object.assign({}, {\n            front,\n            back,\n            renderer,\n            duration: 1,\n            ease: Power2.easeOut,\n            shadow: false,\n            eulerX: 0,\n            eulerY: 0,\n            eulerEase: Sine.easeOut,\n            useBackTransforms: false,\n            transformEase: Power2.easeOut,\n            focus: 800,\n            near: 10,\n            far: 10000,\n            orthographic: false\n        }, opts)\n\n        // planes\n        //--------------------\n        this.setPlanes(this.opts.focus, this.opts.near, this.opts.far, this.opts.orthographic)\n\n        // flipped\n        //--------------------\n        this._flipped = false\n\n        // objects\n        //--------------------\n        this.objects = {}\n\n        // setup\n        //--------------------\n        this.setup()\n    }\n\n    /**\n     * Creates children and instantiates everything.\n     *\n     * @private\n     * @return {Flippable} A reference to the flippable for chaining.\n     */\n    setup() {\n\n        const scale = .5\n\n        // filters\n        //--------------------\n        const blurFilter = new PIXI.filters.BlurFilter()\n        blurFilter.blur = 0.2\n        this.objects.blurFilter = blurFilter\n\n        // outer\n        //--------------------\n        const outer = new PIXI.projection.Container3d()\n        outer.scale3d.set(scale)\n        this.addChild(outer)\n        this.objects.outer = outer\n\n        // shadow\n        //--------------------\n        const shadow = new PIXI.projection.Sprite3d(PIXI.Texture.fromImage('../../assets/images/shadow.png'))\n        shadow.renderable = false\n        shadow.anchor.set(0.5)\n        shadow.scale3d.set(.98)\n        shadow.alpha = 0.7\n        shadow.filters = [blurFilter]\n        shadow.visible = this.opts.shadow\n        outer.addChild(shadow)\n        this.objects.shadow = shadow\n        \n        // inner\n        //--------------------\n        const inner = new PIXI.projection.Container3d()\n        inner.euler.y = Math.PI\n        outer.addChild(inner)\n        this.objects.inner = inner\n\n        // front\n        //--------------------\n        const front = new PIXI.projection.Sprite3d(PIXI.Texture.EMPTY)\n        front.scale.set(-1 / scale, 1 / scale)\n        front.renderable = true\n        front.anchor.set(.5)\n        inner.addChild(front)\n        this.objects.front = front\n\n        // back\n        //--------------------\n        const back = new PIXI.projection.Sprite3d(PIXI.Texture.EMPTY)\n        back.scale.set(1 / scale, 1 / scale)\n        back.renderable = false\n        back.anchor.set(.5)\n        inner.addChild(back)\n        this.objects.back = back\n\n        return this\n    }\n\n    /**\n     * Gets or sets the flipped state.\n     *\n     * @member {boolean}\n     */\n    get flipped() {\n        return this._flipped\n    }\n    set flipped(toBack) {\n\n        this._flipped = toBack\n\n        // references\n        //--------------------\n        const front = this.objects.front\n        const back = this.objects.back\n        const inner = this.objects.inner\n        const shadow = this.objects.shadow\n        const blurFilter = this.objects.blurFilter\n\n        const half = this.opts.duration / 2\n        const ease = this.opts.eulerEase\n\n        const fromObject = toBack ? this.opts.front : this.opts.back\n        const toObject = toBack ? this.opts.back : this.opts.front\n\n        // set textures for virtual front and virtual back\n        //--------------------\n        front.texture = this.generateTexture(this.opts.front)\n        back.texture = this.generateTexture(this.opts.back)\n        \n        // switch objects and set params for virtual objects\n        //--------------------\n        const fromCenter = this.anchorToCenter(fromObject)\n        const toCenter = this.anchorToCenter(toObject)\n\n        // from values\n        //--------------------\n        this.x = fromCenter.x\n        this.y = fromCenter.y\n        front.width = fromObject.width * 2\n        front.height = fromObject.height * 2\n        back.width = fromObject.width * 2\n        back.height = fromObject.height * 2\n        this.rotation = fromObject.rotation\n        this.skew.x = fromObject.skew.x\n        this.skew.y = fromObject.skew.y\n\n        // calculate to values\n        //--------------------\n        const to = {\n            x: this.opts.useBackTransforms ? toCenter.x : fromCenter.x,\n            y: this.opts.useBackTransforms ? toCenter.y : fromCenter.y,\n            anchorX: this.opts.useBackTransforms ? toObject.x : fromObject.x,\n            anchorY: this.opts.useBackTransforms ? toObject.y : fromObject.y,\n            width: this.opts.useBackTransforms ? toObject.width * 2 : fromObject.width * 2,\n            height: this.opts.useBackTransforms ? toObject.height * 2 : fromObject.height * 2,\n            rotation: this.opts.useBackTransforms ? toObject.rotation : fromObject.rotation,\n            skewX: this.opts.useBackTransforms ? toObject.skew.x : fromObject.skew.x,\n            skewY: this.opts.useBackTransforms ? toObject.skew.y : fromObject.skew.y\n        }\n\n        // set toObject end values\n        //--------------------\n        toObject.x = to.anchorX\n        toObject.y = to.anchorY\n        toObject.width = to.width / 2\n        toObject.height = to.height / 2\n        toObject.rotation = to.rotation\n        toObject.skew.x = to.skewX\n        toObject.skew.y = to.skewY\n\n        // flip\n        //--------------------\n        TweenLite.to(inner.euler, this.opts.duration, {\n            y: toBack ? 0 : Math.PI,\n            ease: this.opts.ease,\n            onStart: () => {\n                this.switchDisplayObject(fromObject, this)\n                shadow.renderable = true\n                if (this.opts.onStart) {\n                    this.opts.onStart(this, this)\n                }\n            },\n            onUpdate: () => {\n                this.layout()\n                if (this.opts.onUpdate) {\n                    this.opts.onUpdate(this, this)\n                }\n            },\n            onComplete: () => {\n                this.switchDisplayObject(this, toObject)\n                shadow.renderable = false\n                if (this.opts.onComplete) {\n                    this.opts.onComplete(this, this)\n                }\n            }\n        })\n\n        // x & y\n        //--------------------\n        TweenLite.to(this, this.opts.duration, {\n            x: to.x,\n            y: to.y,\n            ease: this.opts.transformEase\n        })\n\n        // width & height\n        //--------------------\n        TweenLite.to([front, back], this.opts.duration, {\n            width: to.width,\n            height: to.height,\n            ease: this.opts.transformEase\n        })\n\n        // rotation\n        //--------------------\n        TweenLite.to(this, this.opts.duration, {\n            directionalRotation: {\n                rotation: `${to.rotation}_short`,\n                useRadians: true\n            },\n            ease: this.opts.transformEase\n        })\n\n        // skewX & skewY\n        //--------------------\n        TweenLite.to(this.skew, this.opts.duration, {\n            x: to.skewX,\n            y: to.skewY,\n            ease: this.opts.transformEase\n        })\n\n        // camera\n        //--------------------\n        new TimelineMax()\n            .to(this.euler, half, {x: this.opts.eulerX, y: this.opts.eulerY, ease})\n            .to(this.euler, half, {x: 0, y: 0, ease})\n\n        // shadow\n        //--------------------\n        new TimelineMax()\n            .to(shadow, half, {alpha: .3, ease})\n            .to(shadow, half, {alpha: .7, ease})\n        \n        // blurfilter\n        //--------------------\n        new TimelineMax()\n            .to(blurFilter, half, {blur: 6, ease})\n            .to(blurFilter, half, {blur: .2, ease})\n    }\n\n    /**\n     * Should be called to refresh the layout of the camera.\n     *\n     * @return {Flippable} A reference to the flippable for chaining.\n     */\n    layout() {\n\n        const front = this.objects.front\n        const back = this.objects.back\n        const shadow = this.objects.shadow\n        const inner = this.objects.inner\n        \n        inner.position3d.z = -Math.sin(inner.euler.y) * front.texture.baseTexture.width * 2\n\n        //this.objects.shadow.euler = this.objects.inner.euler\n        shadow.euler.x = -inner.euler.x\n        shadow.euler.y = -inner.euler.y\n        \n        if (this.frontSideInFront) {\n            front.renderable = true\n            back.renderable = false\n            shadow.width = front.width\n            shadow.height = front.height\n        } else {\n            front.renderable = false\n            back.renderable = true\n            shadow.width = back.width\n            shadow.height = back.height\n        }\n\n        return this\n    }\n\n    /**\n     * Toggles the flippable. Switches the sides.\n     *\n     * @private\n     * @return {Flippable} A reference to the flippable for chaining.\n     */\n    toggle() {\n        this.flipped = !this.flipped\n\n        return this\n    }\n\n    /**\n     * Gets the alignment state. true if the front side is in front, false otherwise.\n     *\n     * @member {boolean}\n     */\n    get frontSideInFront() {\n        return !this.objects.inner.isFrontFace()\n    }\n\n    /**\n     * Calculates the center point of an PIXI.DisplayObject.\n     *\n     * @private\n     * @param {PIXI.DisplayObject} displayObject - The DisplayObject from which to calculate the center.\n     * @return {object} Return an object with x and y.\n     */\n    anchorToCenter(displayObject) {\n        const bounds = displayObject.getBounds()\n        return {\n            x: bounds.x + bounds.width / 2,\n            y: bounds.y + bounds.height / 2\n        }\n    }\n\n    /**\n     * Creates children and instantiates everything.\n     *\n     * @private\n     * @param {PIXI.DisplayObject} displayObject - The DisplayObject from which to generate the texture.\n     * @return {PIXI.Texture} The generated PIXI.Texture.\n     */\n    generateTexture(displayObject) {\n\n        // renderTexture\n        //--------------------\n        const renderTexture = PIXI.RenderTexture.create(displayObject.width, displayObject.height)\n\n        // save position\n        const transform = [displayObject.x, displayObject.y, displayObject.scale.x, displayObject.scale.y, displayObject.rotation, displayObject.skew.x, displayObject.skew.y, displayObject.pivot.x, displayObject.pivot.y]\n\n        displayObject.position.set(0, 0)\n        displayObject.skew.set(0, 0)\n        displayObject.rotation = 0\n\n        // render\n        //--------------------\n        this.opts.renderer.render(displayObject, renderTexture)\n        \n        // restore position\n        displayObject.setTransform(...transform)\n\n        return renderTexture\n    }\n\n    /**\n     * Removed the first DisplayObject and adds the second one at the exactly same position.\n     *\n     * @private\n     * @param {PIXI.DisplayObject} first - The old DisplayObject.\n     * @param {PIXI.DisplayObject} second - The new DisplayObject.\n     * @return {Flippable} A reference to the flippable for chaining.\n     */\n    switchDisplayObject(first, second) {\n        if (first && second && first.parent) {\n            const parent = first.parent\n            const index = parent.getChildIndex(first)\n            parent.addChildAt(second, index)\n            parent.removeChild(first)\n        }\n\n        return this\n    }\n}\n","/**\n * \n */\nexport default class Popover extends PIXI.Graphics {\n\n    constructor({title = null, text = null, x = 0, y = 0, placement = 'top', width = 250, titleStyle = {}, textStyle = {fontSize: '1.6em'}} = {}) {\n        super()\n\n        this.opts = {title, text, x, y, placement, width, titleStyle, textStyle}\n        \n        this.padding = 12\n\n        let style = {\n            fontFamily: 'Arial',\n            fontSize: '2em',\n            stroke: '#f6f6f6',\n            strokeThickness: 3,\n            wordWrap: true,\n            wordWrapWidth: width - (this.padding * 2)\n        }\n\n        this.titleTextStyle = new PIXI.TextStyle(Object.assign({}, style, titleStyle))\n        this.textTextStyle = new PIXI.TextStyle(Object.assign({}, style, textStyle))\n        \n        if (title || text) {\n            this.setup()\n            this.draw()\n            this.positioning()\n        }\n    }\n\n    setup() {\n        this.removeChildren()\n\n        if (this.opts.title) {\n            this.titleText = new PIXI.Text(this.opts.title, this.titleTextStyle)\n            this.titleText.position.set(this.padding, this.padding)\n            this.addChild(this.titleText)\n        }\n\n        this.titleY = this.titleText ? this.titleText.y : 0\n        this.titleHeight = this.titleText ? this.titleText.height : 0\n\n        if (this.opts.text) {\n            this.textText = new PIXI.Text(this.opts.text, this.textTextStyle)\n            this.textText.position.set(this.padding, this.titleY + this.titleHeight + this.padding)\n            this.addChild(this.textText)\n        }\n\n        this.textY = this.textText ? this.textText.y : 0\n        this.textHeight = this.textText ? this.textText.height : 0\n    }\n\n    close() {\n        this.parent.removeChild(this)\n    }\n\n    draw() {\n        this.clear()\n        this.beginFill(0xffffff, 1)\n        this.lineStyle(1, 0x282828, .5)\n\n        // Draw rounded rectangle\n        const height = this.height + this.padding\n        this.drawRoundedRect(0, 0, this.opts.width, height, 8)\n\n        // Draw anchor\n        this.drawAnchor(this.opts.placement)\n\n        // Draw title background\n        if (this.opts.title) {\n            this.lineStyle(0)\n            this.beginFill(0xf7f7f7, 1)\n            let x = 1\n            let y = this.titleText.x + this.titleText.height + (this.padding / 2)\n            this.moveTo(x, y)\n            y = 9\n            this.lineTo(x, y)\n            this.quadraticCurveTo(x, y - 8, x + 8, y - 8)\n            x += this.opts.width - 7\n            y -= 8\n            this.lineTo(x, y)\n            this.quadraticCurveTo(x + 5, y, x + 5, y + 8)\n            x += 5\n            y += this.titleText.x + this.titleText.height + (this.padding / 2)\n            this.lineTo(x, y)\n            if (this.opts.text) {\n                x = 1\n                this.lineTo(x, y)\n            } else {\n                this.quadraticCurveTo(x, y, x - 5, y + 4)\n                x = 6\n                y += 4\n                this.lineTo(x, y)\n                this.quadraticCurveTo(x, y, x - 5, y - 4)\n            }\n        }\n\n        this.endFill()\n    }\n\n    drawAnchor(placement) {\n\n        let x = 0\n        let y = 0\n\n        switch (placement) {\n            case 'bottom':\n                if (this.opts.title) {\n                    this.beginFill(0xf7f7f7, 1)\n                }\n                x = (this.width / 2) - 10\n                y = 1\n                this.moveTo(x, y)\n                x += 10\n                y -= 10\n                this.lineTo(x, y)\n                x += 10\n                y += 10\n                this.lineTo(x, y)\n                break\n            case 'right':\n                x = 1\n                y = (this.height / 2) - 10\n                if (this.titleY + this.titleHeight > y) {\n                    this.beginFill(0xf7f7f7, 1)\n                }\n                this.moveTo(x, y)\n                x -= 10\n                y += 10\n                this.lineTo(x, y)\n                x += 10\n                y += 10\n                this.lineTo(x, y)\n                break\n            case 'left':\n                x = this.width - 2\n                y = (this.height / 2) - 10\n                if (this.titleY + this.titleHeight > y) {\n                    this.beginFill(0xf7f7f7, 1)\n                }\n                this.moveTo(x, y)\n                x += 10\n                y += 10\n                this.lineTo(x, y)\n                x -= 10\n                y += 10\n                this.lineTo(x, y)\n                break\n            default:\n                x = (this.width / 2) - 10\n                y = this.height - 2\n                this.moveTo(x, y)\n                x += 10\n                y += 10\n                this.lineTo(x, y)\n                x += 10\n                y -= 10\n                this.lineTo(x, y)\n                break\n        }\n    }\n\n    positioning() {\n\n        const x = this.opts.x\n        const y = this.opts.y\n\n        switch (this.opts.placement) {\n            case 'bottom':\n                this.position.set(x - (this.width / 2), y + 10)\n                break\n            case 'right':\n                this.position.set(x, y - (this.height / 2))\n                break\n            case 'left':\n                this.position.set(x - this.width, y - (this.height / 2))\n                break\n            default:\n                this.position.set(x - (this.width / 2), y - this.height)\n                break\n        }\n    }\n}\n","import Events from '../events.js'\nimport { AbstractScatter } from '../scatter.js'\nimport { Angle, Points, Polygon } from '../utils.js'\nimport { InteractionMapper } from '../interaction.js'\n\n/** A container for scatter objects, which uses a single InteractionMapper\n * for all children. This reduces the number of registered event handlers\n * and covers the common use case that multiple objects are scattered\n * on the same level.\n */\nexport class ScatterContainer extends PIXI.Graphics {\n\n    /**\n    * @constructor\n    * @param {PIXI.Renderer} renderer - PIXI renderer, needed for hit testing\n    * @param {Bool} stopEvents - Whether events should be stopped or propagated\n    * @param {Bool} claimEvents - Whether events should be marked as claimed\n    *                             if findTarget return as non-null value.\n    * @param {PIXI.Container} container - A container for the scatter\n    * @param {Bool} showBounds - Show bounds for debugging purposes.\n    * @param {Bool} showTouches - Show touches and pointer for debugging purposes.\n    * @param {Color} backgroundColor - Set background color if specified.\n    * @param {PIXIApp} app - Needed if showBounds is true to register\n    *                                update handler.\n    */\n    constructor(renderer, {\n        stopEvents = true,\n        claimEvents = true,\n        container = null,\n        showBounds = false,\n        showPolygon = false,\n        showTouches = false,\n        backgroundColor = null,\n        app = window.app\n    } = {}) {\n        super()\n        this.container = container\n        if (this.container)\n            this.containerDimensions = {\n                x: this.container.width,\n                y: this.container.height\n            }\n        this.backgroundWidth = null\n        this.backgroundHeight = null\n        this.app = app\n        this.renderer = renderer\n        this.stopEvents = stopEvents\n        this.claimEvents = claimEvents\n        this.delegate = new InteractionMapper(this.eventReceiver, this)\n        this.showBounds = showBounds\n        this.showTouches = showTouches\n        this.showPolygon = showPolygon\n        this.backgroundColor = backgroundColor\n        if (showBounds || showTouches || showPolygon) {\n            //console.log(\"Show TOUCHES!!!\")\n            this.app.ticker.add((delta) => this.update(delta), this)\n        }\n        if (backgroundColor) {\n            this.updateBackground()\n        }\n    }\n\n    updateBackground() {\n        this.clear()\n        let rect = this.bounds\n        this.beginFill(this.backgroundColor, 1)\n        this.drawRect(0, 0, rect.width, rect.height)\n        this.endFill()\n    }\n\n    get eventReceiver() {\n        return this.renderer.plugins.interaction.interactionDOMElement\n    }\n\n    get bounds() {\n        let x = 0\n        let y = 0\n        // @container: We need to call the constant values, as the container\n        // gets resized, when a child moves outside the original boundaries.\n        let w = (this.container) ? this.containerDimensions.x : (this.backgroundWidth || this.app.width)\n        let h = (this.container) ? this.containerDimensions.y : (this.backgroundHeight || this.app.height)\n\n        if (this.app.fullscreen && this.app.monkeyPatchMapping) {\n            let fixed = this.mapPositionToPoint({ x: w, y: 0 })\n            if (fixed.x < w) {\n                w = fixed.x\n            }\n            if (fixed.y > 0) {\n                y += fixed.y\n                h -= fixed.y\n            }\n        }\n        return new PIXI.Rectangle(x, y, w, h)\n    }\n\n    get center() {\n        let r = this.bounds\n        return { x: r.width / 2, y: r.height / 2 }\n    }\n\n    get polygon() {\n        let r = this.bounds\n        let w2 = r.width / 2\n        let h2 = r.height / 2\n        let center = { x: w2, y: h2 }\n        let polygon = new Polygon(center)\n        polygon.addPoint({ x: -w2, y: -h2 })\n        polygon.addPoint({ x: w2, y: -h2 })\n        polygon.addPoint({ x: w2, y: h2 })\n        polygon.addPoint({ x: -w2, y: h2 })\n        return polygon\n    }\n\n    update(dt) {\n        this.clear()\n        this.lineStyle(1, 0x0000FF)\n        if (this.showBounds) {\n            for (let child of this.children) {\n                if (child.scatter) {\n                    //let {x, y, width, height} = child.scatter.throwBounds()\n                    // new PIXI.Rectangle(x, y, width, height)\n                    this.drawShape(child.scatter.bounds)\n                    let center = child.scatter.center\n                    this.drawCircle(center.x, center.y, 4)\n                    this.drawCircle(child.scatter.x, child.scatter.y, 4)\n                }\n            }\n            this.lineStyle(2, 0x0000FF)\n            this.drawShape(this.bounds)\n        }\n        if (this.showPolygon) {\n            this.lineStyle(2, 0xFF0000)\n            for (let child of this.children) {\n                if (child.scatter) {\n                    let polygon = child.scatter.polygon\n                    let shape = new PIXI.Polygon(polygon.flatAbsolutePoints())\n                    shape.close()\n                    this.drawShape(shape)\n                }\n            }\n        }\n        if (this.showTouches) {\n            let current = this.delegate.interaction.current\n            for (let [key, point] of current.entries()) {\n                let local = this.mapPositionToPoint(point)\n                this.drawCircle(local.x, local.y, 12)\n            }\n        }\n    }\n\n    capture(event) {\n        if (this.stopEvents)\n            Events.stop(event)\n        return true\n    }\n\n    fakeInteractionEvent(point, key) {\n        return { data: { global: point, key: key } }\n    }\n\n    findHitScatter(data, displayObject, hit) {\n        //     if (hit) {\n        //             console.log(\"findHitScatter\", displayObject)\n        //         }\n        if (hit && this.hitScatter === null && typeof (displayObject) != undefined) {\n            this.hitScatter = (displayObject.scatter) ? displayObject.scatter : null\n        }\n    }\n\n    mapPositionToPoint(point, element = null) {\n        // In case of nested scatters we get an additional parameter that\n        // contains the found scatter\n        let local = new PIXI.Point()\n        let interactionManager = this.renderer.plugins.interaction\n        interactionManager.mapPositionToPoint(local, point.x, point.y)\n        if (element instanceof DisplayObjectScatter && element.displayObject.parent != null) {\n            return element.displayObject.parent.toLocal(local)\n        }\n        return local\n    }\n\n    /**\n     * New method hitTest implemented (in InteractionManager, since 4.5.0).\n     * See https://github.com/pixijs/pixi.js/pull/3878\n     */\n    findTarget(event, local, global) {\n        if (event.claimedByScatter) {\n            return null\n        }\n        this.hitScatter = null\n        let interactionManager = this.renderer.plugins.interaction\n        let fakeEvent = this.fakeInteractionEvent(local)\n        interactionManager.processInteractive(fakeEvent,\n            this,\n            this.findHitScatter.bind(this), true)\n        if (this.claimEvents)\n            event.claimedByScatter = this.hitScatter\n        return this.hitScatter\n    }\n\n    findTargetNew(event, local, global) {\n        // UO: still problematic. Does not find non interactive elements\n        // which are needed for some stylus applications\n        if (event.claimedByScatter) {\n            return null\n        }\n        this.hitScatter = null\n        let interactionManager = this.renderer.plugins.interaction\n        let displayObject = interactionManager.hitTest(local, this)\n        if (displayObject != null && displayObject.scatter != null)\n            this.hitScatter = displayObject.scatter\n        if (this.claimEvents)\n            event.claimedByScatter = this.hitScatter\n        return this.hitScatter\n    }\n\n\n    onStart(event, interaction) {\n\n    }\n\n    onMove(event, interaction) {\n\n    }\n\n    onEnd(event, interaction) {\n        for (let key of interaction.ended.keys()) {\n            let point = interaction.ended.get(key)\n            if (interaction.isLongPress(key)) {\n                this.onLongPress(key, point)\n            }\n            if (interaction.isTap(key)) {\n                this.onTap(key, point)\n            }\n        }\n    }\n\n    onTap(key, point) {\n        console.info('ScatterContainer.onTap')\n    }\n\n    onLongPress(key, point) {\n        console.info('ScatterContainer.onLongPress')\n    }\n\n    bringToFront(displayObject) {\n        this.addChild(displayObject)\n    }\n\n    layout(width, height) {\n        this.backgroundWidth = width\n        this.backgroundHeight = height\n        if (this.backgroundColor) {\n            this.updateBackground()\n        }\n        \n    }\n}\n\n/** A wrapper for child elements of a ScatterContainer. Can be used\n *  to combine scattered objects with non-scattered objects. Any\n *  PIXI.DisplayObject can be wrapped.\n */\nexport class DisplayObjectScatter extends AbstractScatter {\n\n    constructor(displayObject, renderer,\n        { x = null, y = null,\n            minScale = 0.1,\n            maxScale = 1.0,\n            startScale = 1.0,\n            autoBringToFront = true,\n            translatable = true, scalable = true, rotatable = true, resizable = false,\n            movableX = true,\n            movableY = true,\n            throwVisibility = 44,\n            throwDamping = 0.95,\n            autoThrow = true,\n            rotationDegrees = null,\n            rotation = null,\n            overdoScaling = 1.5,\n            onTransform = null,\n            onThrowFinished = null } = {}) {\n        // For the simulation of named parameters,\n        // see: http://exploringjs.com/es6/ch_parameter-handling.html\n        super({\n            overdoScaling,\n            minScale, maxScale,\n            startScale,\n            autoBringToFront,\n            translatable, scalable, rotatable, resizable,\n            movableX, movableY, throwVisibility, throwDamping,\n            autoThrow,\n            onThrowFinished,\n            rotationDegrees, rotation,\n            onTransform\n        })\n        this.displayObject = displayObject\n        this.displayObject.scatter = this\n        this.renderer = renderer\n        this.scale = startScale\n        this.rotationDegrees = this.startRotationDegrees\n\n        // Only set x and y if they are specified.\n        // Otherwise the displayobject gets corrupted.\n        if (x != null) this.x = x\n        if (y != null) this.y = y\n    }\n\n    getWorldScatter() {\n        return this\n    }\n\n    /** Returns geometry data as object. **/\n    getState() {\n        return {\n            scale: this.scale,\n            x: this.x,\n            y: this.y,\n            rotation: this.rotation\n        }\n    }\n\n    setup() {\n        this.setupMouseWheelInteraction()\n    }\n\n    roundPixel(value) {\n        // UO: Should be obsolete because Renderer supports roundPixels by default\n        return value\n        let res = this.renderer.resolution\n        return Math.round(value * res) / res\n    }\n\n    get container() {\n        // return this.displayObject.parent\n        let obj = this.displayObject\n        while (obj.parent != null && !(obj.parent instanceof ScatterContainer))\n            obj = obj.parent\n        return obj.parent\n    }\n\n    get x() {\n        return this.position.x\n    }\n\n    set x(value) {\n        this.position.x = value\n    }\n\n    get y() {\n        return this.position.y\n    }\n\n    set y(value) {\n        this.position.y = value\n    }\n\n    get polygon() {\n        let polygon = new Polygon(this.center)\n        let w2 = this.width / 2\n        let h2 = this.height / 2\n        polygon.addPoint({ x: -w2, y: -h2 })\n        polygon.addPoint({ x: w2, y: -h2 })\n        polygon.addPoint({ x: w2, y: h2 })\n        polygon.addPoint({ x: -w2, y: h2 })\n        polygon.rotate(this.rotation)\n        return polygon\n    }\n\n    get containerBounds() {\n        return this.container.bounds\n    }\n\n    get containerPolygon() {\n        let container = this.container\n        if (container == null) return null\n        return container.polygon\n    }\n\n    get position() {\n        return this.displayObject.position\n    }\n\n    set position(value) {\n        this.displayObject.position = value\n    }\n\n    get scale() {\n        return this.displayObject.scale.x\n    }\n\n    set scale(value) {\n        this.displayObject.scale.x = value\n        this.displayObject.scale.y = value\n    }\n\n    get width() {\n        return this.displayObject.width\n    }\n\n    get height() {\n        return this.displayObject.height\n    }\n\n    get bounds() {\n        return this.displayObject.getBounds()\n    }\n\n    get pivot() {\n        return this.displayObject.pivot\n    }\n\n    get rotation() {\n        return this.displayObject.rotation\n    }\n\n    set rotation(value) {\n        this.displayObject.rotation = value\n    }\n\n    get rotationDegrees() {\n        return Angle.radian2degree(this.displayObject.rotation)\n    }\n\n    set rotationDegrees(value) {\n        this.displayObject.rotation = Angle.degree2radian(value)\n    }\n\n    get center() {\n        let w2 = this.width / 2\n        let h2 = this.height / 2\n        let dist = Math.sqrt(w2 * w2 + h2 * h2)\n        let angle = Points.angle({ x: w2, y: h2 }, { x: 0, y: 0 })\n        let p = this.displayObject.x\n        let c = Points.arc(this.position, this.rotation + angle, dist)\n        return c // Points.subtract(c, this.pivot)\n    }\n\n    get rotationOrigin() {\n        // In PIXI the default rotation and scale origin is the position\n        return this.position // Points.add(this.position, this.pivot)\n    }\n\n    mapPositionToContainerPoint(point) {\n        // UO: We need the coordinates related to this scatter in case\n        // of nested scatters\n        if (this.container != null)\n            return this.container.mapPositionToPoint(point, this)\n        return point\n    }\n\n    capture(event) {\n        return true\n    }\n\n    bringToFront() {\n        if (this.autoBringToFront) {\n            if (this.displayObject.parent instanceof ScatterContainer) {\n                let scatterContainer = this.displayObject.parent\n                scatterContainer.bringToFront(this.displayObject)\n            } else if (this.displayObject.parent != null && this.displayObject.parent.scatter) {\n                this.displayObject.parent.scatter.toFront(this.displayObject)\n            }\n        }\n    }\n\n    toFront(displayObject) {\n        this.displayObject.addChild(displayObject)\n    }\n\n    validScale(scale) {\n        scale = Math.max(scale, this.minScale)\n        scale = Math.min(scale, this.maxScale)\n        return scale\n    }\n}\n","import PIXIApp from './app.js'\n/**\n *\n */\nexport class Command extends PIXI.Graphics {\n    /*** Abstract base class for record, play, and stop commands. ***/\n    constructor(tools, selectedColor, shape) {\n        super()\n        this.tools = tools\n        this.shape = shape\n        this.selected = false\n        this.disabled = false\n        this.selectedColor = selectedColor\n        this.draw()\n        this.setup()\n    }\n\n    setup() {\n    }\n\n    draw() {\n        this.clear()\n        var color = (this.selected) ? this.selectedColor : 0xFFFFFF\n        this.lineStyle(0)\n        this.beginFill(color, 1)\n        this.drawShape(this.shape)\n        this.endFill()\n    }\n\n    select() {\n        this.selected = true\n        this.draw()\n    }\n\n    deselect() {\n        this.selected = false\n        this.draw()\n    }\n\n    toggle() {\n        this.selected = !this.selected\n        this.draw()\n    }\n\n    stop() {\n        this.selected = false\n        this.draw()\n    }\n}\n\nexport class RecordCommand extends Command {\n    /*** Records events for later replay. ***/\n    setup() {\n        this.recorder = new EventRecorder()\n    }\n\n    toggle() {\n        super.toggle()\n        if (!this.selected) {\n            this.recorder.stopRecording()\n        }\n    }\n\n    recordEvent(event) {\n        this.recorder.record(event)\n    }\n\n    normalize(value, limit) {\n        return value / limit\n    }\n\n    normalizeX(value) {\n        return this.normalize(value, window.innerWidth)\n    }\n\n    normalizeY(value) {\n        return this.normalize(value, window.innerHeight)\n    }\n\n    whileNotStopped() {\n        return this.tools.play.selected\n    }\n\n    startReplay() {\n        let whileCondition = this.whileNotStopped.bind(this)\n        this.recorder.startReplay(whileCondition, () => this.tools.play.stop())\n    }\n}\n\nexport class PlayCommand extends Command {\n    /*** Plays recorded events. ***/\n    toggle() {\n        super.toggle()\n        if (this.selected && this.tools.record.recorder.recorded.length > 0) {\n            this.tools.startReplay()\n        }\n    }\n}\n\nexport class StopCommand extends Command {\n    /*** Stops recording and playing. ***/\n    toggle() {\n        super.toggle()\n        this.tools.record.stop()\n        this.tools.play.stop()\n        setTimeout(this.deselect.bind(this), 500)\n    }\n}\n\nexport class RecorderTools extends PIXI.Container {\n\n    constructor(renderer) {\n        super(renderer)\n        this.renderer = renderer\n        this.setupToolbar()\n        this.replayRate = 100.0\n        this.onReset = null\n        this.touchGraphics = new PIXI.Graphics()\n        this.showTouches()\n    }\n\n    setup(container) {\n        // Since this delegate might shadow another delegate, we mus avoid\n        // capturing PointerEvents.\n        this.delegate = new InteractionMapper(container, this, { capturePointerEvents: false })\n    }\n\n    findTarget(event, local, global) {\n        return this\n    }\n\n    setupToolbar() {\n        this.toolbar = new PIXI.Graphics()\n        this.record = new RecordCommand(this, 0xCC0000, new PIXI.Circle(0, 0, 16))\n        this.play = new PlayCommand(this, 0x0000CC, new PIXI.Polygon(0, 16,\n            32, 16 + 16,\n            0, 16 + 32,\n            0, 16))\n        this.stop = new StopCommand(this, 0x0000CC,\n            new PIXI.Rectangle(0, 0, 32, 32))\n        this.toolbar.addChild(this.record).position.set(44, 48)\n        this.toolbar.addChild(this.play).position.set(44 + 44, 16)\n        this.toolbar.addChild(this.stop).position.set(44 + 44 + 44 + 16, 32)\n        this.updateToolbar()\n        this.addChild(this.toolbar)\n    }\n\n    updateToolbar() {\n        var graphics = this.toolbar\n        graphics.clear()\n        graphics.beginFill(0x000000, 0.5)\n        graphics.lineStyle(2, 0xFFFFFF, 1)\n        graphics.drawRoundedRect(16, 16, 44 * 4 + 8, 64, 8)\n        graphics.endFill()\n    }\n\n    onMouseWheel(event) {\n        console.log('onMouseWheel missing')\n    }\n\n    onPress(point) {\n        if (this.record.containsPoint(point)) {\n            this.record.toggle()\n        }\n        if (this.play.containsPoint(point)) {\n            this.play.toggle()\n        }\n        if (this.stop.containsPoint(point)) {\n            this.stop.toggle()\n            if (this.onReset) {\n                this.onReset()\n            }\n        }\n    }\n\n    mapPositionToPoint(point) {\n        let local = new PIXI.Point()\n        this.renderer.plugins.interaction.mapPositionToPoint(local, point.x, point.y)\n        return local\n    }\n\n    extractLocal(event) {\n        return this.mapPositionToPoint(Events.extractPoint(event))\n    }\n\n    capture(event) {\n        if (typeof event.mouseDownSubstitute != 'undefined')\n            return false\n        return true\n    }\n\n    startReplay() {\n        if (this.onReset) {\n            this.onReset()\n        }\n        this.record.startReplay()\n    }\n\n    showTouches() {\n        this.addChild(this.touchGraphics)\n    }\n\n    recordEvent(event) {\n        if (this.record.selected) {\n            this.record.recordEvent(event)\n        }\n    }\n\n    onStart(event, interaction) {\n        let local = this.extractLocal(event)\n        if (!this.toolbar.containsPoint(local)) {\n            this.recordEvent(event)\n            this.updateTouchGraphics(interaction)\n        }\n    }\n\n    onMove(event, interaction) {\n        let local = this.extractLocal(event)\n        if (!this.toolbar.containsPoint(local)) {\n            this.recordEvent(event)\n            this.updateTouchGraphics(interaction)\n        }\n    }\n\n    onEnd(event, interaction) {\n        let local = this.extractLocal(event)\n        if (this.toolbar.containsPoint(local)) {\n            this.onPress(local)\n        }\n        else {\n            this.recordEvent(event)\n            this.updateTouchGraphics(interaction)\n        }\n    }\n\n    updateTouchGraphics(interaction) {\n        let current = interaction.current\n        let graphics = this.touchGraphics\n        if (graphics != null) {\n            graphics.clear()\n            for (let key of current.keys()) {\n                if (interaction.ended.has(key)) {\n                    continue\n                }\n                let p = current.get(key)\n                if (key == 'mouse') {\n                    graphics.beginFill(0xCC0000, 0.5)\n                } else {\n                    graphics.beginFill(0xCCCCCC, 0.5)\n                }\n                graphics.drawCircle(p.x, p.y, 20)\n            }\n            graphics.endFill()\n        }\n    }\n}\n\nexport class AppTest extends PIXIApp {\n\n    constructor(canvas, container) {\n        super({ view: canvas, backgroundColor: 0x000000 })\n        this.container = container\n    }\n\n    sceneFactory() {\n        return new RecorderTools(this.renderer)\n    }\n\n    setup() {\n        super.setup()\n        this.scene.setup(this.container)\n    }\n\n    run(reset = null) {\n        this.scene.onReset = reset\n        console.log('Running AppTest')\n        return this\n    }\n}\n\n\n\n\n","\n\n/**\n * Defines usefull default text styles.\n */\nexport class FontInfo {\n\n    static get small() {\n        return app.theme.textStyleSmall\n    }\n\n    static get normal() {\n        return app.theme.textStyle\n    }\n\n    static get centered() {\n        return Object.assign({}, app.theme.textStyle, { align: 'center' })\n    }\n}\n\n/**\n * Static methods to support hyphenation of lines.\n * \n * @class Hypenate\n */\nexport class Hypenate {\n\n    static splitPart(part) {\n        let parts = part.split('-')\n        if (parts.length == 1)\n            return [part]\n        let result = []\n        let last = parts.pop()\n        for (let p of parts) {\n            result.push(p + '-')\n        }\n        result.push(last)\n        return result.filter(p => p.length > 0)\n    }\n\n    static splitWord(word) {\n        if (typeof (language) == 'undefined') {\n            if (word.indexOf('-') > -1) {\n                return word.split('-')\n            }\n            return [word]\n        }\n        let parts = language.hyphenate(word)\n        let result = []\n        for (let part of parts) {\n            for (let splitted of this.splitPart(part)) {\n                result.push(splitted)\n            }\n        }\n        return result\n    }\n\n    static abbreviateLine(label, style, width) {\n        const pixiStyle = new PIXI.TextStyle(style)   \n        let metrics = PIXI.TextMetrics.measureText(label, pixiStyle)\n        while(metrics.width > width && label.length > 3) {\n            label = label.slice(0, label.length-1)\n            metrics = PIXI.TextMetrics.measureText(label, pixiStyle)\n        }\n        label = label.slice(0, label.length-1)\n        return label + '…'\n    }\n\n    static splitLine(line, pixiStyle, width, space, minus) {\n        let x = 0\n        let result = ''\n        let words = line.split(' ')\n        for (let word of words) {\n            let wordMetrics = PIXI.TextMetrics.measureText(word, pixiStyle)\n            if (x + wordMetrics.width >= width) {\n                let parts = this.splitWord(word)\n                let newWord = ''\n                if (parts.length == 1) {\n                    newWord += '\\n' + word + ' '\n                    x = wordMetrics.width + space.width\n                }\n                else {\n                    let first = true\n                    let lastPart = ''\n                    for (let part of parts) {\n                        let partMetrics = PIXI.TextMetrics.measureText(part, pixiStyle)\n                        if (x + partMetrics.width + space.width > width) {\n                            newWord += ((first || lastPart.endsWith('-')) ? '\\n' : '-\\n') + part\n                            x = partMetrics.width\n                        }\n                        else {\n                            newWord += part\n                            x += partMetrics.width\n                        }\n                        lastPart = part\n                        first = false\n                    }\n                    x += space.width\n                }\n                result += newWord + ' '\n            }\n            else {\n                result += word + ' '\n                x += wordMetrics.width + space.width\n            }\n        }\n        return result\n    }\n\n    /**\n     *  Main method and entry point for text hyphenation \n     *\n     * @static\n     * @param {*} text\n     * @param {*} style\n     * @param {*} width\n     * @returns\n     * @memberof Hypenate\n     */\n    static splitLines(text, style, width) {\n        const pixiStyle = new PIXI.TextStyle(style)\n        const lines = text.split('\\n')\n        const space = PIXI.TextMetrics.measureText(' ', pixiStyle)\n        const minus = PIXI.TextMetrics.measureText('-', pixiStyle)\n        let result = []\n        for (let line of lines) {\n            result.push(this.splitLine(line, pixiStyle, width, space, minus))\n        }\n        return result.join('\\n')\n    }\n}\n\n/**\n * A specialization of the PIXI.Graphics class that allows to\n * resuse and place labels across different layout variants\n *\n * @export\n * @class LabeledGraphics\n * @extends {PIXI.Graphics}\n */\nexport class LabeledGraphics extends PIXI.Graphics {\n\n    /**\n     * Creates an instance of LabeledGraphics and defines a local label cache.\n     * \n     * @memberof LabeledGraphics\n     */\n    constructor() {\n        super()\n        this.labels = new Map()\n    }\n\n    _createText(label, fontInfo) {\n        return new PIXI.Text(label, fontInfo)\n    }\n\n    \n    /**\n     * Main additional method. Ensures that a text object is created that is cached\n     * under the given key.\n     *\n     * @param {*} key - The cache key\n     * @param {*} label - The label to show\n     * @param {*} [attrs={}] - Defines attributes of the text object. \n     *                               align: 'right', 'left', or 'center'\n     *                               justify: 'top', 'bottom', or 'center'\n     *                               maxLines: {integer} truncates the text and adds ellipsis\n     *                               maxHeight: {number} truncates text that needs more space and adds ellipsis\n     *                               maxWidth: {number} word wraps text using hyphenation if possible\n     * @param {*} [fontInfo=FontInfo.normal] - Defines PIXI.TextStyle attributes\n     * @returns {PIXI.Text} instance\n     * @memberof LabeledGraphics\n     */\n    ensureLabel(key, label, attrs = {}, fontInfo = FontInfo.normal) {\n\n        if (attrs.maxWidth && attrs.maxLines == 1) {\n            label = Hypenate.abbreviateLine(label, fontInfo, attrs.maxWidth)\n        }\n        else {\n            if (attrs.maxWidth) {\n                label = Hypenate.splitLines(label, fontInfo, attrs.maxWidth)\n            }\n            if (attrs.maxLines) {\n                label = this.truncateLabel(label, fontInfo, attrs.maxLines)\n            }\n            if (attrs.maxHeight) {\n                let styleInfo = new PIXI.TextStyle(fontInfo)\n                let metrics = PIXI.TextMetrics.measureText(label, styleInfo)\n                let maxLines = Math.max(attrs.maxHeight / metrics.lineHeight, 1)\n                label = this.truncateLabel(label, fontInfo, maxLines)\n            }\n        }\n       \n        if (!this.labels.has(key)) {\n            let text = this._createText(label, fontInfo)\n            this.labels.set(key, text)\n            this.addChild(text)\n        }\n        let text = this.labels.get(key)\n        for (let k in attrs) {\n            text[k] = attrs[k]\n        }\n        if (label != text.text)\n            text.text = label\n        // We do not follow the flexbox jargon and use align for x and justify for y axis\n        // This deviation is needed to ensure backward compatability\n        switch (attrs.justify || null) {\n            case 'top':\n                text.anchor.y = 0\n                break\n            case 'bottom':\n                text.anchor.x = 1\n                break\n            default:\n                text.anchor.y = 0.5\n                break\n        }\n        switch (attrs.align) {\n            case 'right':\n                text.anchor.x = 1\n                break\n            case 'center':\n                text.anchor.x = 0.5\n                break\n            default:\n                text.anchor.x = 0\n                break\n        }\n        text.visible = true\n        return text\n    }\n\n    /**\n     * Private method that truncates the text and adds an ellipsis if there are more lines\n     * than wanted\n     *\n     * @param {*} text\n     * @param {*} style\n     * @param {*} [maxLines=Infinity]\n     * @returns\n     * @memberof LabeledGraphics\n     */\n    truncateLabel(text, style, maxLines = Infinity) {\n        if (maxLines === Infinity) {\n            return text\n        }\n        const { wordWrapWidth } = style\n        const pixiStyle = new PIXI.TextStyle(style)\n        const { lines } = PIXI.TextMetrics.measureText(text, pixiStyle)\n        let newText = text\n        if (lines.length > maxLines) {\n            const truncatedLines = lines.slice(0, maxLines)\n            const lastLine = truncatedLines[truncatedLines.length - 1]\n            const words = lastLine.split(' ')\n            const wordMetrics = PIXI.TextMetrics.measureText(`\\u00A0\\n...\\n${words.join('\\n')}`, pixiStyle)\n            const [spaceLength, dotsLength, ...wordLengths] = wordMetrics.lineWidths\n            const { text: newLastLine } = wordLengths.reduce((data, wordLength, i) => {\n                if (data.length + wordLength + spaceLength >= wordWrapWidth) {\n                    return { ...data, length: wordWrapWidth }\n                }\n                return {\n                    text: `${data.text}${i > 0 ? ' ' : ''}${words[i]}`,\n                    length: data.length + wordLength + spaceLength,\n                };\n            }, { text: '', length: dotsLength })\n            truncatedLines[truncatedLines.length - 1] = `${newLastLine}...`\n            newText = truncatedLines.join('\\n')\n        }\n        return newText\n    }\n\n    /**\n     * Returns the label for the given key.\n     *\n     * @param {*} key\n     * @returns\n     * @memberof LabeledGraphics\n     */\n    getLabel(key) {\n        return this.labels.get(key)\n    }\n\n    /** \n     * Hides the label with the given key.\n     * @param {*} key\n     * @memberof LabeledGraphics\n     */\n    hideLabel(key) {\n        let label = this.labels.get(key)\n        if (label) {\n            label.visible = false\n        }\n    }\n\n    /** \n     * Removes the label with the given key.\n     * @param {*} key\n     * @memberof LabeledGraphics\n     */\n    removeLabel(key) {\n        let label = this.labels.get(key)\n        this.labels.delete(key)\n        label.destroy()\n    }\n\n   \n    /**\n     * Ensures that labels are hidden on clear.\n     *\n     * @memberof LabeledGraphics\n     */\n    clear() {\n        super.clear()\n        for (let key of this.labels.keys()) {\n            this.hideLabel(key)\n        }\n    }\n\n    /**\n     * Logs debugging infos\n     *\n     * @memberof LabeledGraphics\n     */\n    debugInfos() {\n        console.log({ size: this.labels.size, labels: this.labels })\n    }\n}\n\n\nconst labelCache = new Map()\n\nfunction getTexture(label, fontInfo = FontInfo.normal) {\n    let key = label + fontInfo.fontFamily + fontInfo.fontSize\n\n    if (labelCache.has(key)) {\n        return labelCache.get(key)\n    }\n    let expandedFont = Object.assign({}, fontInfo)\n    expandedFont.fontSize *= window.devicePixelRatio\n    let text = new PIXI.Text(label, expandedFont)\n    text.updateText()\n    labelCache.set(key, text.texture)\n    return text.texture\n}\n\nclass SpriteLabel extends PIXI.Sprite {\n\n    constructor(label, fontInfo) {\n        let texture = getTexture(label, fontInfo)\n        super(texture)\n        this.label = label\n        this.fontInfo = fontInfo\n        this.scale.set(0.8 / window.devicePixelRatio)\n    }\n\n    set text(label) {\n        this.label = label\n        this.texture = getTexture(label, this.fontInfo)\n    }\n\n    get text() {\n        return this.label\n    }\n}\n\nexport class BitmapLabeledGraphics extends LabeledGraphics {\n\n    _createText(label, fontInfo) {\n        let texture = getTexture(label, fontInfo)\n        return new SpriteLabel(texture)\n    }\n\n}","import { Cycle, Colors, Dates, isEmpty } from '../utils.js'\nimport { Capabilities } from '../capabilities.js'\nimport { BitmapLabeledGraphics, LabeledGraphics, FontInfo } from './labeledgraphics.js'\n\n\nexport class Ticks {\n\n    get reservedPrefixes() {\n        return ['decade', 'year', 'month', 'day', 'hour', 'minute', 'second']\n    }\n\n    get minWidth() {\n        return 10\n    }\n\n    format(available) {\n        return { year: '2-digit', timeZone: 'UTC' }\n    }\n\n    get minLabelWidth() {\n        return 44\n    }\n\n    get formatKey() {\n        return this.key\n    }\n\n    dateKey(date) {\n        return this.key + date.getFullYear()\n    }\n\n    *iter(start, end) {\n        let date = this.iterStart(start)\n        while (date <= end) {\n            yield date\n            date = this.next(date)\n        }\n        yield date\n    }\n\n    *iterRanges(range) {\n        for (let date of this.iter(range.start, range.end)) {\n            let next = this.next(date)\n            yield { start: date, end: next }\n        }\n    }\n\n    selectedRange(timeline, info) {\n        let first = null\n        let last = null\n        let visibleFirst = null\n        let visibleLast = null\n        let units = 0\n        for (let { start, end } of this.iterRanges(info)) {\n            if (timeline.visibleRange(start, end)) {\n                if (first == null) {\n                    first = start\n                }\n                last = end\n            }\n            if (timeline.visibleDate(start) && timeline.visibleDate(end)) {\n                units += 1\n                if (visibleFirst == null) {\n                    visibleFirst = start\n                }\n                visibleLast = end\n            }\n        }\n        if (first == null)\n            return info\n        return { start: first, end: last, visibleStart: visibleFirst, visibleEnd: visibleLast, units: units }\n    }\n\n    drawTick(timeline, x, y, date) {\n        let visible = date > timeline.start && date < timeline.end\n        if (!visible)\n            return false\n        timeline.drawTick(x)\n        return true\n    }\n\n    toLocaleString(date, format) {\n        return date.toLocaleDateString('de', format)\n    }\n\n    draw(timeline, range, width, height, available, format, nextFormat, level) {\n        let first = null\n        let last = null\n        let keyedFormat = (format) ? format[this.formatKey] : null\n        let keyedNextFormat = (nextFormat) ? nextFormat[this.formatKey] : null\n        let redundant = (nextFormat) ? this.formatKey in nextFormat : false\n        let fullyRedundant = keyedFormat != null && keyedFormat == keyedNextFormat\n        let y = timeline.getY()\n\n        for (let { start, end } of this.iterRanges(range)) {\n            let x = timeline.toX(start)\n            let xx = x\n            let yy = y + timeline.tickLabelOffset(-1)\n            if (this.drawTick(timeline, x, y, start) && format) {\n                let key = this.dateKey(start)\n                let text = this.toLocaleString(start, format)\n                let align = 'center'\n                let downTick = false\n                if (nextFormat) {\n                    yy = y + timeline.tickLabelOffset(-1, 1)\n                    align = 'left'\n                    timeline.drawTick(x, 4.2)\n                    let nextX = timeline.toX(end) - 100\n                    if (x < 0 && nextX > -100 && !redundant) {\n                        xx = Math.min(4, nextX)\n                    }\n                    else {\n                        xx -= 2\n                    }\n                    downTick = true\n                }\n                else if (level > 0) {\n                    xx = x + available / 2\n                }\n                else {\n                    downTick = true\n                }\n                if (!fullyRedundant) {\n                    timeline.ensureLabel(key, text,\n                        { x: xx, y: yy, align },\n                        FontInfo.small)\n                }\n                if (downTick) timeline.drawTick(x, -1)\n            }\n            if (timeline.visibleRange(start, end)) {\n                if (first == null)\n                    first = start\n                last = end\n            }\n        }\n        if (first == null)\n            return null\n        return { start: first, end: last }\n    }\n}\n\nexport class DecadeTicks extends Ticks {\n\n    get milliseconds() {\n        return 10 * 365 * 24 * 60 * 60 * 1000\n    }\n\n    format(available) {\n        return { year: 'numeric', timeZone: 'UTC' }\n    }\n\n    selection(timeline, dates, selected) {\n        return dates\n    }\n\n    get key() {\n        return 'decade'\n    }\n\n    get formatKey() {\n        return 'year'\n    }\n\n    iterStart(start) {\n        let modulo = start.getFullYear() % 10\n        let year = start.getFullYear() - modulo\n        return Dates.create(year, 0, 1)\n    }\n\n    next(decade) {\n        return Dates.nextYear(decade, 10)\n    }\n}\n\nexport class YearTicks extends Ticks {\n\n    get milliseconds() {\n        return 365 * 24 * 60 * 60 * 1000\n    }\n\n    format(available) {\n        if (available < 44)\n            return { year: '2-digit', timeZone: 'UTC' }\n        return { year: 'numeric', timeZone: 'UTC' }\n    }\n\n    get minLabelWidth() {\n        return 22\n    }\n\n    get key() {\n        return 'year'\n    }\n\n    iterStart(start) {\n        return Dates.create(start.getFullYear(), 0, 1)\n    }\n\n    next(year) {\n        return Dates.nextYear(year)\n    }\n}\n\nexport class MonthTicks extends Ticks {\n\n    get milliseconds() {\n        return (365 / 12) * 24 * 60 * 60 * 1000\n    }\n\n    format(available) {\n        let format = { month: 'narrow', timeZone: 'UTC' }\n        if (available > 44)\n            format.month = 'short'\n        if (available > 66)\n            format.year = '2-digit'\n        if (available > 100) {\n            format.month = 'long'\n            format.year = 'numeric'\n        }\n        return format\n    }\n\n    get minLabelWidth() {\n        return 32\n    }\n\n    get key() {\n        return 'month'\n    }\n\n    dateKey(date) {\n        return this.key + date.getFullYear() + date.getMonth()\n    }\n\n    iterStart(start) {\n        return Dates.create(start.getFullYear(), start.getMonth(), 1)\n    }\n\n    next(month) {\n        return Dates.nextMonth(month)\n    }\n}\n\nexport class DayTicks extends Ticks {\n\n    get milliseconds() {\n        return 24 * 60 * 60 * 1000\n    }\n\n    format(available) {\n        let format = { day: 'numeric', timeZone: 'UTC' }\n        if (available > 44)\n            format.month = 'short'\n        if (available > 100) {\n            format.month = 'long'\n            format.year = '2-digit'\n        }\n        if (available > 150) {\n            format.weekday = 'short'\n        }\n        if (available > 200) {\n            format.year = 'numeric'\n            format.weekday = 'long'\n        }\n        return format\n    }\n\n    get key() {\n        return 'day'\n    }\n\n    dateKey(date) {\n        return this.key + date.getFullYear() + date.getMonth() + date.getDate()\n    }\n\n    iterStart(start) {\n        return Dates.create(start.getFullYear(), start.getMonth(), start.getDate())\n    }\n\n    next(date) {\n        return Dates.nextDay(date)\n    }\n}\n\nexport class HourTicks extends Ticks {\n\n    get milliseconds() {\n        return 60 * 60 * 1000\n    }\n\n    format(available) {\n        let format = {}\n        if (available > 44) {\n            format.hour = '2-digit'\n        }\n        if (available > 100) {\n            format.day = '2-digit'\n            format.month = '2-digit'\n            format.year = '2-digit'\n        }\n        if (available > 150) {\n            format.weekday = 'short'\n            format.month = 'short'\n        }\n        if (available > 200) {\n            format.day = 'numeric'\n            format.year = 'numeric'\n            format.month = 'long'\n            format.weekday = 'long'\n        }\n        return format\n    }\n\n    get key() {\n        return 'hour'\n    }\n\n    dateKey(date) {\n        return this.key + date.getFullYear()\n            + date.getMonth()\n            + date.getDate()\n            + date.getHours()\n    }\n\n    iterStart(start) {\n        return Dates.create(start.getFullYear(),\n            start.getMonth(),\n            start.getDate(),\n            start.getHours())\n    }\n\n    next(date) {\n        return Dates.nextHour(date)\n    }\n\n    toLocaleString(date, format) {\n        return date.toLocaleTimeString('de', format)\n    }\n}\n\nexport class MinuteTicks extends Ticks {\n\n    get milliseconds() {\n        return 60 * 1000\n    }\n\n    format(available) {\n        let format = { minute: 'numeric', timeZone: 'UTC' }\n        if (available > 44) {\n            format.hour = 'numeric'\n            format.minute = 'numeric'\n        }\n        if (available > 100) {\n            format.month = 'short'\n            format.year = '2-digit'\n        }\n        if (available > 150) {\n            format.weekday = 'short'\n        }\n        if (available > 200) {\n            format.year = 'numeric'\n            format.weekday = 'long'\n        }\n        return format\n    }\n\n    get key() {\n        return 'minute'\n    }\n\n    dateKey(date) {\n        return this.key + date.getFullYear()\n            + date.getMonth()\n            + date.getDate()\n            + date.getHours()\n            + date.getMinutes()\n    }\n\n    iterStart(start) {\n        return Dates.create(start.getFullYear(),\n            start.getMonth(),\n            start.getDate(),\n            start.getHours(),\n            start.getMinutes())\n    }\n\n    next(date) {\n        return Dates.nextMinute(date)\n    }\n\n    toLocaleString(date, format) {\n        return date.toLocaleTimeString('de', format)\n    }\n}\n\nexport class TimeTicks {\n\n    constructor(...ticks) {\n        this.ticks = ticks\n    }\n\n    selectedRange(timeline) {\n        let info = { start: timeline.start, end: timeline.end, units: 0 }\n        for (let ticks of this.ticks) {\n            info = ticks.selectedRange(timeline, info)\n            if (info.units > 1) {\n                timeline.selection = [info.visibleStart, info.visibleEnd]\n                return\n            }\n        }\n        timeline.selection = [info.start, info.end]\n    }\n\n    draw(timeline, width, height) {\n        let range = timeline\n        let start = timeline.toX(range.start)\n        let end = timeline.toX(range.end)\n        let size = end - start\n        let duration = timeline.end - timeline.start\n        let formats = new Map()\n        let nextFormats = new Map()\n        let availables = new Map()\n        let previous = null\n        let visible = []\n        for (let ticks of this.ticks) {\n            let amount = ticks.milliseconds / duration\n            let available = amount * size\n            availables.set(ticks, available)\n            if (available < ticks.minWidth)\n                break\n            formats.set(ticks, (available < ticks.minLabelWidth) ? null : ticks.format(available))\n            nextFormats.set(previous, formats.get(ticks))\n            previous = ticks\n            visible.push(ticks)\n        }\n        let level = 0\n        for (let ticks of visible) {\n            if (range == null)\n                return\n            range = ticks.draw(timeline, range, width, height,\n                availables.get(ticks),\n                formats.get(ticks),\n                nextFormats.get(ticks), level)\n            level += 1\n        }\n    }\n}\n\nexport class ColorRanges {\n\n    constructor(label, color, ranges) {\n        this.label = label\n        this.color = color\n        this.ranges = ranges\n    }\n\n    draw(timeline, width, height, size = 12) {\n        let minimum = 1 / Capabilities.devicePixelRatio\n        let h2 = size\n        timeline.lineStyle(size, this.color)\n        for (let range of this.ranges) {\n            if (range.to === null) {\n                range.to = Dates.nextDay(range.from)\n            }\n            let start = timeline.toX(range.from)\n            let end = timeline.toX(range.to)\n            if (end < start + minimum) {\n                end = start + minimum\n            }\n            timeline.moveTo(start, h2)\n            timeline.lineTo(end, h2)\n        }\n    }\n}\n\nexport default class Timeline extends BitmapLabeledGraphics {\n\n    constructor(width, height, { ticks = null,\n        baseLine = 0.5, showRange = true } = {}) {\n        super()\n        this.wantedWidth = width\n        this.wantedHeight = height\n        this.extraLeft = 0\n        this.extraRight = 0\n        this.inset = 5\n        this.showRange = showRange\n        this.baseLine = baseLine\n        this.tickHeight = 4\n        this.zoom = 1\n        this.minZoom = 1\n        this.maxZoom = 12000\n        this.scroll = 0\n        this.deltas = []\n        this.labelDates = []\n        this.colorRanges = []\n        this.rangeColors = new Cycle(Colors.eminence,\n            Colors.steelblue,\n            Colors.ochre,\n            Colors.turquoise)\n        this.callbacks = []\n        this.onTapCallbacks = []\n        this.onDoubleTapCallbacks = []\n        this.onLongPressCallbacks = []\n        this.progress = null\n        this.start = null\n        this.end = null\n        this.selection = null\n        this.autoScroll = false\n        this.direction = -1\n        this.timeticks = ticks || new TimeTicks(new DecadeTicks(),\n            new YearTicks(),\n            new MonthTicks(),\n            new DayTicks())\n        this.labelPrefix = '__'\n    }\n\n    updateSelection() {\n        if (this.visibleDate(this.start) && this.visibleDate(this.end)) {\n            this.selection = [this.start, this.end]\n        }\n        else {\n            this.timeticks.selectedRange(this)\n        }\n\n        return this.selection\n    }\n\n    addCallback(callback) {\n        this.callbacks.push(callback)\n    }\n\n    addTabCallback(callback) {\n        this.onTapCallbacks.push(callback)\n    }\n\n    addDoubleTapCallback(callback) {\n        this.onDoubleTapCallbacks.push(callback)\n    }\n\n    addLongPressCallback(callback) {\n        this.onLongPressCallbacks.push(callback)\n    }\n\n    addLabels(labels) {\n        this.labelDates = labels\n    }\n\n    range(start, end) {\n        this.start = start\n        this.end = end\n    }\n\n    draw(width, height) {\n        this.wantedWidth = width\n        this.wantedHeight = height\n        this.redraw()\n    }\n\n    updateColorRanges(w, h) {\n        let xx = w - this.inset\n        let size = FontInfo.small.fontSize\n        let yy = h - size\n        for (let i = this.colorRanges.length - 1; i >= 0; i--) {\n            let cr = this.colorRanges[i]\n            let label = cr.label\n            cr.draw(this, w, h)\n            let current = this.ensureLabel('colorRange:' + label, label,\n                { x: xx, y: yy, align: 'right' }, FontInfo.small)\n            let r = current.getBounds()\n            xx -= r.width + 16\n\n            this.lineStyle(size, cr.color)\n            this.moveTo(xx, yy)\n            this.lineTo(xx + size, yy)\n            xx -= size + 4\n        }\n    }\n\n    drawSelectedRamge(selected) {\n        this.lineStyle(2, app.theme.primaryColor)\n        let start = this.toX(selected[0])\n        let end = this.toX(selected[1])\n        this.moveTo(start, 0)\n        this.lineTo(end, 0)\n        this.drawTick(start, -1.5, 0)\n        this.drawTick(end, -1.5, 0)\n    }\n\n    redraw() {\n        this.clear()\n        let h = this.wantedHeight\n        let w = this.wantedWidth\n        let y = this.getY()\n        this.prepareLabels()\n        this.updateColorRanges(w, h)\n\n        this.lineStyle(2, 0xFFFFFF)\n        if (this.start != null && this.end != null) {\n            this.moveTo(this.toX(this.start), y)\n            this.lineTo(this.toX(this.end), y)\n            this.updateTicksAndLabels(w, h)\n            this.updateSelection()\n            let selected = this.selection\n            if (selected[0] != this.start && selected[1] != this.end) {\n                if (this.showRange)\n                    this.drawSelectedRamge(selected)\n            }\n            for (let callback of this.callbacks) {\n                callback(this.scroll, this.zoom, this.selection)\n            }\n        }\n        else {\n            this.moveTo(this.inset, y)\n            this.lineTo(w - this.inset, y)\n        }\n\n        if (this.progress != null && this.progress < 1) {\n            this.lineStyle(2, 0xCCCCFF)\n            this.moveTo(this.inset, y)\n            this.lineTo((w - this.inset) * this.progress, y)\n        }\n    }\n\n    totalWidth(bounded = false) {\n        let w = this.wantedWidth - (2 * this.inset)\n        return w * this.validZoom(this.zoom, bounded)\n    }\n\n    validZoom(zoom, bounded = true) {\n        let overshoot = (bounded) ? 1.0 : 2.0\n        zoom = Math.max(zoom, this.minZoom / overshoot)\n        zoom = Math.min(zoom, this.maxZoom * overshoot)\n        return zoom\n    }\n\n    getY() {\n        return this.wantedHeight * this.baseLine\n    }\n\n    toX(date) {\n        let total = this.end - this.start\n        let offset = this.inset + this.scroll\n        let width = this.totalWidth()\n        let delta = date - this.start\n        let ratio = delta / total\n        return offset + ratio * width\n    }\n\n    fromX(value) {\n        let total = this.end - this.start\n        let offset = this.inset + this.scroll\n        let width = this.totalWidth()\n        let ratio = (value - offset) / width\n        let time = this.start.getTime() + total * ratio\n        let date = new Date(time)\n        return date\n    }\n\n    drawTick(x, direction = 1, y = null) {\n        if (y == null) {\n            y = this.getY()\n        }\n        this.moveTo(x, y)\n        this.lineTo(x, y - (this.tickHeight * direction * this.direction))\n    }\n\n    prepareLabels() {\n        for (let key of this.labels.keys()) {\n            if (!key.startsWith(this.labelPrefix))\n                this.labels.get(key).visible = false\n        }\n    }\n\n    updateTicksAndLabels(width, height) {\n        this.drawTick(this.toX(this.start))\n        this.drawTick(this.toX(this.end))\n        this.timeticks.draw(this, width, height)\n        this.updateLabels(width, height)\n    }\n\n    visibleDate(date, offset = 0) {\n        if (date >= this.start && date <= this.end) {\n            let x = this.toX(date) + offset\n            return (x > 0 && x < this.wantedWidth)\n        }\n        return false\n    }\n\n    visibleRange(start, end) {\n        let x = this.toX(start)\n        if (x > this.wantedWidth)\n            return false\n        x = this.toX(end)\n        if (x < 0)\n            return false\n        return true\n    }\n\n    tickLabelOffset(direction = 1, level = 0) {\n        let fs = FontInfo.small.fontSize\n        let dh = fs + (level * (fs + 2))\n        return this.direction * direction * dh\n    }\n\n    updateLabels(width, height) {\n        let h2 = height / 2\n        if (this.labelDates) {\n            let last = null\n            let y = h2 + this.tickLabelOffset()\n            for (let i = this.labelDates.length - 1; i >= 0; i--) {\n                let [label, date] = this.labelDates[i]\n                let align = 'center' // (last == null) ? 'right' : 'left'\n                let x = this.toX(date)\n                let current = this.ensureLabel(this.labelPrefix + label, label,\n                    {\n                        x: x, y: y,\n                        align\n                    },\n                    FontInfo.small)\n                let r = current.getBounds()\n                current.visible = !(last != null && r.x + r.width > last.x)\n                if (current.visible) {\n                    this.drawTick(x, -1)\n                    last = r\n                }\n            }\n        }\n        else {\n            let start = this.start.toLocaleDateString('de', { year: 'numeric', month: 'numeric', day: 'numeric' })\n            let end = this.end.toLocaleDateString('de', { year: 'numeric', month: 'numeric', day: 'numeric' })\n            this.ensureLabel(this.labelPrefix + 'start', start, { x: this.toX(this.start), y: h2 })\n            this.ensureLabel(this.labelPrefix + 'end', end, { x: this.toX(this.end), y: h2, align: 'right' })\n        }\n    }\n\n    onZoom(zoom, anchor) {\n        let date = this.fromX(anchor.x)\n        let newZoom = this.validZoom(this.zoom * zoom, false)\n        this.zoom = newZoom\n        let newX = this.toX(date)\n        this.scroll += anchor.x - newX\n    }\n\n    onStart(event, interaction) {\n        this.killTweens()\n        this.deltas = []\n        this.validScroll()\n        ThrowPropsPlugin.track(this, 'delta')\n    }\n\n    onMove(event, interaction) {\n        let delta = interaction.delta()\n        this.scroll += delta.x\n        while (this.deltas.length > 10) {\n            this.deltas.pop(0)\n        }\n        this.deltas.push(delta.x)\n        if (interaction.current.size > 1) {\n            this.onZoom(delta.zoom, delta.about)\n        }\n        this.redraw()\n    }\n\n    onEnd(event, interaction) {\n        let vel = ThrowPropsPlugin.getVelocity(this, 'delta')\n        ThrowPropsPlugin.untrack(this)\n\n        this.killTweens()\n        this.redraw()\n        let delta = 0\n        for (let d of this.deltas) {\n            delta += d\n        }\n        if (this.deltas.length > 0) {\n            delta /= this.deltas.length\n        }\n        this.autoScroll = true\n        let anchor = interaction.current.mean()\n        this.keepInBounds(delta, anchor)\n\n        for(let key of interaction.ended.keys()) {\n            if (interaction.isDoubleTap(key)) {\n                this.onDoubleTap(event, interaction, key)\n            }\n            else if (interaction.isTap(key)) {\n                this.onTap(event, interaction, key)\n            }\n            else if (interaction.isLongPress(key)) {\n                this.onLongPress(event, interaction, key)\n            }\n        }\n    }\n\n    onLongPress(event, interaction, key) {\n        for(let callback of this.onLongPressCallbacks) {\n            callback(event, interaction, key)\n        }\n    }\n\n    onTap(event, interaction, key) {\n        for(let callback of this.onTapCallbacks) {\n            callback(event, interaction, key)\n        }\n    }\n\n    onDoubleTap(event, interaction, key) {\n        for(let callback of this.onDoubleTapCallbacks) {\n            callback(event, interaction, key)\n        }\n    }\n\n    _scrollMinimum(bounded) {\n        let total = this.totalWidth(bounded)\n        return -total + this.wantedWidth - 2 * this.inset\n    }\n\n    _scrollMaximum(bounded) {\n        let total = this.totalWidth(bounded)\n        let limit = this.wantedWidth\n        if (total > limit)\n            return 0\n        let w = limit - 2 * this.inset\n        return (w - total) / 2\n    }\n\n    scrollMinimum(bounded) {\n        return this._scrollMinimum(bounded) - this.extraRight\n    }\n\n    scrollMaximum(bounded) {\n        return this._scrollMaximum(bounded) + this.extraLeft\n    }\n\n    killTweens() {\n        TweenLite.killTweensOf(this)\n        this.autoScroll = false\n    }\n\n\n    validScroll(bounded = true) {\n        let minimum = this.scrollMinimum(bounded)\n        let maximum = this.scrollMaximum(bounded)\n        if (this.scroll < minimum) {\n            this.scroll = minimum\n        }\n        if (this.scroll > maximum) {\n            this.scroll = maximum\n        }\n    }\n\n    keepInBounds(delta, anchor) {\n        let bounded = true\n        let minimum = this.scrollMinimum(bounded)\n        let maximum = this.scrollMaximum(bounded)\n        let tweens = {}\n        if (this.zoom > this.maxZoom) {\n            tweens.zoom = this.maxZoom\n            let date = this.fromX(anchor.x)\n            let oldZoom = this.zoom\n            this.zoom = this.maxZoom\n            let newX = this.toX(date)\n            tweens.scroll = this.scroll + anchor.x - newX\n            this.zoom = oldZoom\n        }\n        else {\n            if (this.zoom < this.minZoom) {\n                tweens.zoom = this.minZoom\n            }\n            if (this.scroll > maximum) {\n                tweens.scroll = maximum\n            }\n            if (this.scroll < minimum) {\n                tweens.scroll = minimum\n            }\n        }\n        if (!isEmpty(tweens)) {\n            tweens.onUpdate = () => { this.redraw() }\n            TweenLite.to(this, 0.5, tweens).delay(0.1)\n            return\n        }\n        this.scroll += delta\n        delta *= 0.985\n        this.redraw()\n        if (Math.abs(delta) > 1 && this.autoScroll) {\n            setTimeout(() => this.keepInBounds(delta, anchor), 1000 / 100)\n        }\n    }\n\n    onMouseWheel(event) {\n        this.killTweens()\n        let direction = event.detail < 0 || event.wheelDelta > 0\n        let anchor = { x: event.clientX, y: event.clientY }\n        const zoomFactor = 1.5\n        this.onZoom((direction) ? zoomFactor : 1 / zoomFactor, anchor)\n        this.redraw()\n        this.keepInBounds(0, anchor)\n    }\n\n    showRanges(ranges, label = \"Untitled\", color = null) {\n        for (let cr of this.colorRanges) {\n            if (cr.label == label)\n                return\n        }\n        while (this.colorRanges.length >= this.rangeColors.length) {\n            this.colorRanges.shift()\n        }\n        this.colorRanges.push(new ColorRanges(label, color, ranges))\n        this.redraw()\n    }\n}\n\n","import Theme from './theme.js'\nimport Tooltip from './tooltip.js'\n\n/**\n * Callback for the slider action onStart.\n *\n * @callback onStartCallback\n * @param {object} event - The event object.\n * @param {Slider} slider - A reference to the slider (also this refers to the slider).\n */\n\n/**\n * Callback for the slider action onUpdate.\n *\n * @callback onUpdateCallback\n * @param {object} event - The event object.\n * @param {Slider} slider - A reference to the slider (also this refers to the slider).\n */\n\n/**\n * Callback for the slider action onComplete.\n *\n * @callback onCompleteCallback\n * @param {object} event - The event object.\n * @param {Slider} slider - A reference to the slider (also this refers to the slider).\n */\n\n/**\n * Class that represents a PixiJS Slider.\n * \n * @example\n * // Create the app\n * const app = new PIXIApp({\n *     view: canvas,\n *     width: 900,\n *     height: 250\n * }).setup().run()\n * \n * // Create the slider\n * const slider = new Slider({\n *     x: 10,\n *     y: 20\n * })\n *\n * // Add the slider to a DisplayObject\n * app.scene.addChild(slider)\n *\n * @class\n * @extends PIXI.Container\n * @see {@link http://pixijs.download/dev/docs/PIXI.Container.html|PIXI.Container}\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/slider.html|DocTest}\n */\nexport default class Slider extends PIXI.Container {\n    \n    /**\n     * Creates an instance of a Slider.\n     * \n     * @constructor\n     * @param {object} [opts] - An options object to specify to style and behaviour of the slider.\n     * @param {number} [opts.id=auto generated] - The id of the slider.\n     * @param {number} [opts.x=0] - The x position of the slider. Can be also set after creation with slider.x = 0.\n     * @param {number} [opts.y=0] - The y position of the slider. Can be also set after creation with slider.y = 0.\n     * @param {string|Theme} [opts.theme=dark] - The theme to use for this slider. Possible values are dark, light, red\n     *     or a Theme object.\n     * @param {number} [opts.width=250] - The width of the slider.\n     * @param {number} [opts.height=2] - The height of the slider.\n     * @param {PIXI.DisplayObject} [opts.container=window.app|object] - The container where the slider events should be attached to.\n     * @param {number} [opts.fill=Theme.fill] - The color of the slider background as a hex value.\n     * @param {number} [opts.fillAlpha=Theme.fillAlpha] - The alpha value of the background.\n     * @param {number} [opts.stroke=Theme.stroke] - The color of the border as a hex value.\n     * @param {number} [opts.strokeWidth=Theme.strokeWidth] - The width of the border in pixel.\n     * @param {number} [opts.strokeAlpha=Theme.strokeAlpha] - The alpha value of the border.\n     * @param {number} [opts.controlFill=Theme.stroke] - The color of the slider control background as a hex value.\n     * @param {number} [opts.controlFillAlpha=Theme.strokeAlpha] - The alpha value of the background.\n     * @param {number} [opts.controlStroke=Theme.stroke] - The color of the border as a hex value.\n     * @param {number} [opts.controlStrokeWidth=Theme.strokeWidth * 0.8] - The width of the border in pixel.\n     * @param {number} [opts.controlStrokeAlpha=Theme.strokeAlpha] - The alpha value of the border.\n     * @param {number} [opts.controlRadius=16] - The radius of the slider control.\n     * @param {boolean} [opts.disabled=false] - Is the slider disabled? When disabled, the slider has a lower alpha value\n     *     and cannot be clicked (interactive is set to false).\n     * @param {onStartCallback} [opts.onStart] - Executed when the slider control starts to move.\n     * @param {onUpdateCallback} [opts.onUpdate] - Executed when the slider control is moved.\n     * @param {onCompleteCallback} [opts.onComplete] - Executed when the slider control was dropped.\n     * @param {string|object} [opts.tooltip] - A string for the label of the tooltip or an object to configure the tooltip\n     *     to display. \n     * @param {boolean} [opts.visible=true] - Is the slider initially visible (property visible)?\n     */\n    constructor(opts = {}) {\n\n        super()\n        \n        const theme = Theme.fromString(opts.theme)\n        this.theme = theme\n\n        this.opts = Object.assign({}, {\n            id: PIXI.utils.uid(),\n            x: 0,\n            y: 0,\n            width: 250,\n            height: 2,\n            container: null,\n            fill: theme.fill,\n            fillAlpha: theme.fillAlpha,\n            stroke: theme.stroke,\n            strokeWidth: theme.strokeWidth,\n            strokeAlpha: theme.strokeAlpha,\n            controlFill: theme.fill,\n            controlFillAlpha: .5,\n            controlStroke: theme.primaryColor,\n            controlStrokeWidth: 2,\n            controlStrokeAlpha: theme.strokeAlpha,\n            controlRadius: 16,\n            orientation: 'horizontal',\n            min: 0,\n            max: 100,\n            value: 0,\n            disabled: false,\n            onStart: null,\n            onUpdate: null,\n            onComplete: null,\n            tooltip: null,\n            visible: true\n        }, opts)\n        \n        this.opts.container = this.opts.container || this\n\n        // Validation\n        //-----------------\n        if (this.opts.height > this.opts.width) {\n            this.opts.height = this.opts.width\n        }\n\n        if (this.opts.value < this.opts.min) {\n            this.opts.value = this.opts.min\n        }\n\n        if (this.opts.value > this.opts.max) {\n            this.opts.value = this.opts.max\n        }\n\n        // Properties\n        //-----------------\n        this.id = this.opts.id\n        this.radius = this.opts.height / 2\n\n        this._value = this.opts.value\n        this._disabled = null\n\n        this.sliderObj = null\n        this.control = null\n        this.tooltip = null\n        \n        this.visible = this.opts.visible\n\n        // setup\n        //-----------------\n        this.setup()\n\n        // layout\n        //-----------------\n        this.layout()\n    }\n    \n    /**\n     * Creates children and instantiates everything.\n     * \n     * @private\n     * @return {Slider} A reference to the slider for chaining.\n     */\n    setup() {\n\n        // Container events\n        //-----------------\n        const container = this.opts.container\n\n        this.on('pointermove', e => {\n            if (this.control.dragging) {\n                const moveX = this.control.event.data.getLocalPosition(this.control.parent).x\n                this._value = this.pixelToValue(moveX - this.control.delta - this.opts.controlRadius)\n                let x = this.valueToPixel(this._value) + this.opts.controlRadius\n                this.control.x = x\n\n                if (this.opts.onUpdate) {\n                    this.opts.onUpdate.call(this, e, this)\n                }\n            }\n        })\n\n        if (container instanceof Element) {\n            container.addEventListener('pointerup', e => this.onEnd(e), false)\n            container.addEventListener('pointercancel', e => this.onEnd(e), false)\n            container.addEventListener('pointerleave', e => this.onEnd(e), false)\n            container.addEventListener('pointerout', e => this.onEnd(e), false)\n            container.addEventListener('mouseup', e => this.onEnd(e), false)\n            container.addEventListener('mousecancel', e => this.onEnd(e), false)\n            container.addEventListener('mouseleave', e => this.onEnd(e), false)\n            container.addEventListener('mouseout', e => this.onEnd(e), false)\n        } else {\n            container.interactive = true\n            container.on('pointerup', e => this.onEnd(e))\n            container.on('pointercancel', e => this.onEnd(e))\n            container.on('pointerleave', e => this.onEnd(e))\n            container.on('pointerout', e => this.onEnd(e))\n        }\n\n        // Slider\n        //-----------------\n        let sliderObj = new PIXI.Graphics()\n        this.sliderObj = sliderObj\n        this.addChild(sliderObj)\n\n        // Control\n        //-----------------\n        let control = new PIXI.Graphics()\n        control.x = this.opts.controlRadius + this.valueToPixel(this.opts.value)\n        control.y = this.opts.controlRadius\n\n        // pointerdown on the control for dragndrop\n        control.on('pointerdown', e => {\n            control.event = e\n            control.delta = e.data.getLocalPosition(this.control).x\n            control.dragging = true\n            \n            if (this.opts.onStart) {\n                this.opts.onStart.call(this, e, this)\n            }\n        })\n\n        this.control = control\n\n        this.addChild(this.control)\n        \n        // interaction\n        //-----------------\n        this.sliderObj.on('pointerover', e => {\n            TweenLite.to(this.control, this.theme.fast, {alpha: .83})\n        })\n\n        this.sliderObj.on('pointerout', e => {\n            TweenLite.to(this.control, this.theme.fast, {alpha: 1})\n        })\n\n        this.sliderObj.on('pointerdown', e => {\n            this.sliderObj.pointerdowned = true\n            TweenLite.to(this.control, this.theme.fast, {alpha: .7})\n        })\n\n        // Click on the slider bar\n        this.sliderObj.on('pointerup', e => {\n            if (this.sliderObj.pointerdowned) {\n                this.sliderObj.pointerdowned = false\n                const position = e.data.getLocalPosition(this.control.parent)\n                this.value = this.pixelToValue(position.x - this.opts.controlRadius)\n                TweenLite.to(this.control, this.theme.fast, {alpha: .83})\n            }\n        })\n\n        // disabled\n        //-----------------\n        this.disabled = this.opts.disabled\n        \n        // tooltip\n        //-----------------\n        if (this.opts.tooltip) {\n            if (typeof this.opts.tooltip === 'string') {\n                this.tooltip = new Tooltip({\n                    object: this,\n                    content: this.opts.tooltip\n                })\n            } else {\n                this.opts.tooltip.object = this\n                this.tooltip = new Tooltip(this.opts.tooltip)\n            }\n        }\n\n        return this\n    }\n    \n    /**\n     * Should be called to refresh the layout of the slider. Can be used after resizing.\n     * \n     * @return {Slider} A reference to the slider for chaining.\n     */\n    layout() {\n        \n        // set position\n        //-----------------\n        this.position.set(this.opts.x, this.opts.y)\n\n        // draw\n        //-----------------\n        this.draw()\n\n        return this\n    }\n    \n    /**\n     * Draws the slider to the canvas.\n     * \n     * @private\n     * @return {Slider} A reference to the slider for chaining.\n     */\n    draw() {\n\n        const r = this.radius\n        const cr = this.opts.controlRadius\n        const w = this.opts.width\n        const h = this.opts.height\n        const x = cr + r\n        const y = cr + r - h\n\n        this.sliderObj.clear()\n        this.sliderObj.beginFill(0xffffff, 0)\n        this.sliderObj.drawRect(0, 0, x + w + cr, cr * 2)\n        this.sliderObj.lineStyle(this.opts.strokeWidth, this.opts.stroke, this.opts.strokeAlpha)\n        this.sliderObj.beginFill(this.opts.fill, this.opts.fillAlpha)\n        this.sliderObj.moveTo(x, y)\n        this.sliderObj.lineTo(x + w, y)\n        this.sliderObj.arcTo(x + w + r, y, x + w + r, y + r, r)\n        this.sliderObj.lineTo(x + w + r, y + r + 1)                     // BUGFIX: If not specified, there is a small area without a stroke.\n        this.sliderObj.arcTo(x + w + r, y + h, x + w, y + h, r)\n        this.sliderObj.lineTo(x, y + h)\n        this.sliderObj.arcTo(x - r, y + h, x - r, y + r, r)\n        this.sliderObj.arcTo(x - r, y, x, y, r)\n        this.sliderObj.endFill()\n\n        // Draw control\n        this.control.clear()\n        this.control.lineStyle(this.opts.controlStrokeWidth, this.opts.controlStroke, this.opts.controlStrokeAlpha)\n        this.control.beginFill(this.opts.controlFill, this.opts.controlFillAlpha)\n        this.control.drawCircle(0, 0, cr - 1)\n        this.control.beginFill(this.opts.controlStroke, this.opts.controlStrokeAlpha)\n        this.control.drawCircle(0, 0, cr / 6)\n        this.control.endFill()\n\n        return this\n    }\n\n    /**\n     * Executed, when the slider control movement ended.\n     * \n     * @private\n     * @return {Slider} A reference to the slider for chaining.\n     */\n    onEnd(e) {\n\n        if (this.control.dragging) {\n            this.control.event = null\n            this.control.dragging = false\n            if (this.opts.onComplete) {\n                this.opts.onComplete.call(this, e, this)\n            }\n        }\n\n        return this\n    }\n\n    /**\n     * Calculates the value for a given pixel.\n     * \n     * @private\n     * @param {number} value \n     * @returns  {number} The calucalted pixel.\n     */\n    valueToPixel(value) {\n        if (value < this.opts.min) {\n            value = this.opts.min\n        } else if (value > this.opts.max) {\n            value = this.opts.max\n        }\n        return this.opts.width * (value - this.opts.min) / (this.opts.max - this.opts.min)\n    }\n\n    /**\n     * Calculates the pixel for a given value.\n     * \n     * @private\n     * @param {number} pixel \n     * @returns {number} The calucalted value.\n     */\n    pixelToValue(pixel) {\n        if (pixel < 0) {\n            pixel = 0\n        } else if (pixel > this.opts.width) {\n            pixel = this.opts.width\n        }\n        return this.opts.min + ((this.opts.max - this.opts.min) * pixel / this.opts.width)\n    }\n    \n    /**\n     * Gets or sets the value.\n     * \n     * @member {number}\n     */\n    get value() {\n        return Math.round(this._value)\n    }\n    set value(value) {\n        if (value < this.opts.min) {\n            value = this.opts.min\n        } else if (value > this.opts.max) {\n            value = this.opts.max\n        }\n        this._value = value\n\n        const x = this.valueToPixel(value) + this.opts.controlRadius\n\n        TweenLite.to(this.control, this.theme.fast, {x})\n    }\n    \n    /**\n     * Gets or sets the disabled state. When disabled, the slider cannot be clicked.\n     * \n     * @member {boolean}\n     */\n    get disabled() {\n        return this._disabled\n    }\n    set disabled(value) {\n\n        this._disabled = value\n        \n        if (this._disabled) {\n            this.interactive = false\n            this.sliderObj.interactive = false\n            this.control.interactive = false\n            this.control.buttonMode = false\n            this.alpha = .5\n        } else {\n            this.interactive = true\n            this.sliderObj.interactive = true\n            this.control.interactive = true\n            this.control.buttonMode = true\n            this.alpha = 1\n        }\n    }\n\n    /**\n     * Shows the slider (sets his alpha values to 1).\n     * \n     * @return {Slider} A reference to the slider for chaining.\n     */\n    show() {\n\n        this.opts.strokeAlpha = 1\n        this.opts.fillAlpha = 1\n        this.opts.controlStrokeAlpha = 1\n        this.opts.controlFillAlpha = 1\n\n        this.layout()\n\n        return this\n    }\n    \n    /**\n     * Hides the slider (sets his alpha values to 1).\n     * \n     * @return {Slider} A reference to the slider for chaining.\n     */\n    hide() {\n\n        this.opts.strokeAlpha = 0\n        this.opts.fillAlpha = 0\n        this.opts.controlStrokeAlpha = 0\n        this.opts.controlFillAlpha = 0\n\n        this.layout()\n\n        return this\n    }\n}\n","import Theme from './theme.js'\nimport Tooltip from './tooltip.js'\n\n/**\n * Callback for the switch action.\n *\n * @callback actionCallback\n * @param {object} event - The event object.\n * @param {Switch} switch - A reference to the switch (also this refers to the switch).\n */\n\n/**\n * Callback for the switch action.\n *\n * @callback actionActiveCallback\n * @param {object} event - The event object.\n * @param {Switch} switch - A reference to the switch (also this refers to the switch).\n */\n\n/**\n * Callback for the switch beforeAction.\n *\n * @callback beforeActionCallback\n * @param {object} event - The event object.\n * @param {Switch} switch - A reference to the switch (also this refers to the switch).\n */\n\n/**\n * Callback for the switch afterAction.\n *\n * @callback afterActionCallback\n * @param {object} event - The event object.\n * @param {Switch} switch - A reference to the switch (also this refers to the switch).\n */\n\n/**\n * Class that represents a PixiJS Switch.\n * \n * @example\n * // Create the app\n * const app = new PIXIApp({\n *     view: canvas,\n *     width: 900,\n *     height: 250\n * }).setup().run()\n * \n * // Create the switch\n * const switch1 = new Switch({\n *     x: 10,\n *     y: 20\n * })\n *\n * // Add the switch to a DisplayObject\n * app.scene.addChild(switch1)\n *\n * @class\n * @extends PIXI.Container\n * @see {@link http://pixijs.download/dev/docs/PIXI.Container.html|PIXI.Container}\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/switch.html|DocTest}\n */\nexport default class Switch extends PIXI.Container {\n    \n    /**\n     * Creates an instance of a Switch.\n     * \n     * @constructor\n     * @param {object} [opts] - An options object to specify to style and behaviour of the switch.\n     * @param {number} [opts.id=auto generated] - The id of the switch.\n     * @param {number} [opts.x=0] - The x position of the switch. Can be also set after creation with switch.x = 0.\n     * @param {number} [opts.y=0] - The y position of the switch. Can be also set after creation with switch.y = 0.\n     * @param {string|Theme} [opts.theme=dark] - The theme to use for this switch. Possible values are dark, light, red\n     *     or a Theme object.\n     * @param {number} [opts.width=44] - The width of the switch.\n     * @param {number} [opts.height=28] - The height of the switch.\n     * @param {number} [opts.fill=Theme.fill] - The color of the switch background as a hex value.\n     * @param {number} [opts.fillAlpha=Theme.fillAlpha] - The alpha value of the background.\n     * @param {number} [opts.fillActive=Theme.fillActive] - The color of the switch background when activated.\n     * @param {number} [opts.fillActiveAlpha=Theme.fillActiveAlpha] - The alpha value of the background when activated.\n     * @param {number} [opts.stroke=Theme.stroke] - The color of the border as a hex value.\n     * @param {number} [opts.strokeWidth=Theme.strokeWidth] - The width of the border in pixel.\n     * @param {number} [opts.strokeAlpha=Theme.strokeAlpha] - The alpha value of the border.\n     * @param {number} [opts.strokeActive=Theme.strokeActive] - The color of the border when activated.\n     * @param {number} [opts.strokeActiveWidth=Theme.strokeActiveWidth] - The width of the border in pixel when activated.\n     * @param {number} [opts.strokeActiveAlpha=Theme.strokeActiveAlpha] - The alpha value of the border when activated.\n     * @param {number} [opts.controlFill=Theme.stroke] - The color of the switch control background as a hex value.\n     * @param {number} [opts.controlFillAlpha=Theme.strokeAlpha] - The alpha value of the background.\n     * @param {number} [opts.controlFillActive=Theme.stroke] - The color of the switch control background when activated.\n     * @param {number} [opts.controlFillActiveAlpha=Theme.strokeAlpha] - The alpha value of the background when activated.\n     * @param {number} [opts.controlStroke=Theme.stroke] - The color of the border as a hex value.\n     * @param {number} [opts.controlStrokeWidth=Theme.strokeWidth * 0.8] - The width of the border in pixel.\n     * @param {number} [opts.controlStrokeAlpha=Theme.strokeAlpha] - The alpha value of the border.\n     * @param {number} [opts.controlStrokeActive=Theme.stroke] - The color of the border when activated.\n     * @param {number} [opts.controlStrokeActiveWidth=Theme.strokeActiveWidth * 0.8] - The width of the border in pixel when activated.\n     * @param {number} [opts.controlStrokeActiveAlpha=Theme.strokeActiveAlpha] - The alpha value of the border when activated.\n     * @param {number} [opts.duration=Theme.fast] - The duration of the animation when the switch gets activated in seconds.\n     * @param {number} [opts.durationActive=Theme.fast] - The duration of the animation when the switch gets deactivated in seconds.\n     * @param {boolean} [opts.disabled=false] - Is the switch disabled? When disabled, the switch has a lower alpha value\n     *     and cannot be clicked (interactive is set to false).\n     * @param {boolean} [opts.active=false] - Is the button initially active?\n     * @param {actionCallback} [opts.action] - Executed when the switch was triggered in inactive state (by pointerup).\n     * @param {actionActiveCallback} [opts.actionActive] - Executed when the button was triggered in active state (by pointerup).\n     * @param {beforeActionCallback} [opts.beforeAction] - Executed before an action is triggered.\n     * @param {afterActionCallback} [opts.afterAction] - Executed after an action was triggered.\n     * @param {string|object} [opts.tooltip] - A string for the label of the tooltip or an object to configure the tooltip\n     *     to display. \n     * @param {boolean} [opts.visible=true] - Is the switch initially visible (property visible)?\n     */\n    constructor(opts = {}) {\n\n        super()\n        \n        const theme = Theme.fromString(opts.theme)\n        this.theme = theme\n\n        this.opts = Object.assign({}, {\n            id: PIXI.utils.uid(),\n            x: 0,\n            y: 0,\n            width: 44,\n            height: 28,\n            fill: theme.fill,\n            fillAlpha: theme.fillAlpha,\n            fillActive: theme.primaryColor,\n            fillActiveAlpha: theme.fillActiveAlpha,\n            stroke: theme.stroke,\n            strokeWidth: theme.strokeWidth,\n            strokeAlpha: theme.strokeAlpha,\n            strokeActive: theme.primaryColor,\n            strokeActiveWidth: theme.strokeActiveWidth,\n            strokeActiveAlpha: theme.strokeActiveAlpha,\n            controlFill: theme.stroke,\n            controlFillAlpha: theme.strokeAlpha,\n            controlFillActive: theme.stroke,\n            controlFillActiveAlpha: theme.strokeAlpha,\n            controlStroke: theme.stroke,\n            controlStrokeWidth: theme.strokeWidth * .8,\n            controlStrokeAlpha: theme.strokeAlpha,\n            controlStrokeActive: theme.stroke,\n            controlStrokeActiveWidth: theme.strokeActiveWidth * .8,\n            controlStrokeActiveAlpha: theme.strokeActiveAlpha,\n            duration: theme.fast,\n            durationActive: theme.fast,\n            disabled: false,\n            active: false,\n            action: null,\n            actionActive: null,\n            beforeAction: null,\n            afterAction: null,\n            tooltip: null,\n            visible: true\n        }, opts)\n\n        this.opts.controlRadius = this.opts.controlRadius || (this.opts.height / 2)\n        this.opts.controlRadiusActive = this.opts.controlRadiusActive || this.opts.controlRadius\n\n        // Validation\n        //-----------------\n        if (this.opts.height > this.opts.width) {\n            this.opts.height = this.opts.width\n        }\n\n        // Properties\n        //-----------------\n        this.id = this.opts.id\n        this.radius = this.opts.height / 2\n\n        this._active = null\n        this._disabled = null\n\n        this.switchObj = null\n        this.control = null\n        this.tooltip = null\n        \n        this.visible = this.opts.visible\n\n        // animated\n        //-----------------\n        this.tempAnimated = {\n            fill: this.opts.fill,\n            fillAlpha: this.opts.fillAlpha,\n            stroke: this.opts.stroke,\n            strokeWidth: this.opts.strokeWidth,\n            strokeAlpha: this.opts.strokeAlpha,\n            controlFill: this.opts.controlFill,\n            controlFillAlpha: this.opts.controlFillAlpha,\n            controlStroke: this.opts.controlStroke,\n            controlStrokeWidth: this.opts.controlStrokeWidth,\n            controlStrokeAlpha: this.opts.controlStrokeAlpha,\n            controlRadius: this.opts.controlRadius\n        }\n\n        // setup\n        //-----------------\n        this.setup()\n\n        // layout\n        //-----------------\n        this.layout()\n    }\n    \n    /**\n     * Creates children and instantiates everything.\n     * \n     * @private\n     * @return {Switch} A reference to the switch for chaining.\n     */\n    setup() {\n\n        // Switch\n        //-----------------\n        let switchObj = new PIXI.Graphics()\n        this.switchObj = switchObj\n        this.addChild(switchObj)\n\n        // Control\n        //-----------------\n        this.xInactive = this.opts.controlRadius\n        this.xActive = this.opts.width - this.opts.controlRadiusActive\n        \n        let control = new PIXI.Graphics()\n        control.x = this.opts.active ? this.xActive : this.xInactive\n        control.y = this.opts.height / 2\n\n        this.control = control\n\n        this.addChild(this.control)\n        \n        // interaction\n        //-----------------\n        this.switchObj.on('pointerover', e => {\n            TweenLite.to(this.control, this.theme.fast, {alpha: .83})\n        })\n\n        this.switchObj.on('pointerout', e => {\n            TweenLite.to(this.control, this.theme.fast, {alpha: 1})\n        })\n\n        this.switchObj.on('pointerdown', e => {\n            TweenLite.to(this.control, this.theme.fast, {alpha: .7})\n        })\n\n        this.switchObj.on('pointerup', e => {\n\n            if (this.opts.beforeAction) {\n                this.opts.beforeAction.call(this, e, this)\n            }\n\n            this.active = !this.active\n\n            if (this.active) {\n                if (this.opts.action) {\n                    this.opts.action.call(this, e, this)\n                }\n            } else {\n                if (this.opts.actionActive) {\n                    this.opts.actionActive.call(this, e, this)\n                }\n            }\n\n            TweenLite.to(this.control, this.theme.fast, {alpha: .83})\n\n            if (this.opts.afterAction) {\n                this.opts.afterAction.call(this, e, this)\n            }\n        })\n\n        // disabled\n        //-----------------\n        this.disabled = this.opts.disabled\n\n        // active\n        //-----------------\n        this.active = this.opts.active\n        \n        // tooltip\n        //-----------------\n        if (this.opts.tooltip) {\n            if (typeof this.opts.tooltip === 'string') {\n                this.tooltip = new Tooltip({\n                    object: this,\n                    content: this.opts.tooltip\n                })\n            } else {\n                this.opts.tooltip.object = this\n                this.tooltip = new Tooltip(this.opts.tooltip)\n            }\n        }\n\n        return this\n    }\n    \n    /**\n     * Should be called to refresh the layout of the switch. Can be used after resizing.\n     * \n     * @return {Switch} A reference to the switch for chaining.\n     */\n    layout() {\n        \n        // set position\n        //-----------------\n        this.position.set(this.opts.x, this.opts.y)\n\n        // draw\n        //-----------------\n        this.draw()\n\n        return this\n    }\n    \n    /**\n     * Draws the switch to the canvas.\n     * \n     * @private\n     * @return {Switch} A reference to the switch for chaining.\n     */\n    draw() {\n\n        this.switchObj.clear()\n        if (this.active) {\n            this.switchObj.lineStyle(this.opts.strokeActiveWidth, this.opts.strokeActive, this.opts.strokeActiveAlpha)\n            this.switchObj.beginFill(this.opts.fillActive, this.opts.fillActiveAlpha)\n        } else {\n            this.switchObj.lineStyle(this.opts.strokeWidth, this.opts.stroke, this.opts.strokeAlpha)\n            this.switchObj.beginFill(this.opts.fill, this.opts.fillAlpha)\n        }\n        this.switchObj.moveTo(this.radius, 0)\n        this.switchObj.lineTo(this.opts.width - this.radius, 0)\n        this.switchObj.arcTo(this.opts.width, 0, this.opts.width, this.radius, this.radius)\n        this.switchObj.lineTo(this.opts.width, this.radius + 1)                                   // BUGFIX: If not specified, there is a small area without a stroke.\n        this.switchObj.arcTo(this.opts.width, this.opts.height, this.opts.width - this.radius, this.opts.height, this.radius)\n        this.switchObj.lineTo(this.radius, this.opts.height)\n        this.switchObj.arcTo(0, this.opts.height, 0, this.radius, this.radius)\n        this.switchObj.arcTo(0, 0, this.radius, 0, this.radius)\n        this.switchObj.endFill()\n\n        // Draw control\n        this.control.clear()\n        if (this.active) {\n            this.control.lineStyle(this.opts.controlStrokeActiveWidth, this.opts.controlStrokeActive, this.opts.controlStrokeActiveAlpha)\n            this.control.beginFill(this.opts.controlFillActive, this.opts.controlFillActiveAlpha)\n            this.control.drawCircle(0, 0, this.opts.controlRadiusActive - 1)\n        } else {\n            this.control.lineStyle(this.opts.controlStrokeWidth, this.opts.controlStroke, this.opts.controlStrokeAlpha)\n            this.control.beginFill(this.opts.controlFill, this.opts.controlFillAlpha)\n            this.control.drawCircle(0, 0, this.opts.controlRadius - 1)\n        }\n        this.control.endFill()\n\n        return this\n    }\n    \n    /**\n     * Draws the animation.\n     * \n     * @private\n     * @return {Switch} A reference to the switch for chaining.\n     */\n    drawAnimated() {\n\n        this.switchObj.clear()\n        this.switchObj.lineStyle(this.tempAnimated.strokeWidth, this.tempAnimated.stroke, this.tempAnimated.strokeAlpha)\n        this.switchObj.beginFill(this.tempAnimated.fill, this.tempAnimated.fillAlpha)\n        this.switchObj.moveTo(this.radius, 0)\n        this.switchObj.lineTo(this.opts.width - this.radius, 0)\n        this.switchObj.arcTo(this.opts.width, 0, this.opts.width, this.radius, this.radius)\n        this.switchObj.lineTo(this.opts.width, this.radius + 1)                                   // BUGFIX: If not specified, there is a small area without a stroke.\n        this.switchObj.arcTo(this.opts.width, this.opts.height, this.opts.width - this.radius, this.opts.height, this.radius)\n        this.switchObj.lineTo(this.radius, this.opts.height)\n        this.switchObj.arcTo(0, this.opts.height, 0, this.radius, this.radius)\n        this.switchObj.arcTo(0, 0, this.radius, 0, this.radius)\n        this.switchObj.endFill()\n\n        this.control.clear()\n        this.control.lineStyle(this.tempAnimated.controlStrokeWidth, this.tempAnimated.controlStroke, this.tempAnimated.controlStrokeAlpha)\n        this.control.beginFill(this.tempAnimated.controlFill, this.tempAnimated.controlFillAlpha)\n        this.control.drawCircle(0, 0, this.tempAnimated.controlRadius - 1)\n        this.control.endFill()\n\n        return this\n    }\n    \n    /**\n     * Gets or sets the active state.\n     * \n     * @member {boolean}\n     */\n    get active() {\n        return this._active\n    }\n\n    set active(value) {\n\n        this._active = value\n\n        if (this._active) {\n\n            TweenLite.to(this.control, this.opts.duration, {x: this.xActive})\n            TweenLite.to(this.tempAnimated, this.opts.duration, {\n                colorProps: {\n                    fill: this.opts.fillActive,\n                    stroke: this.opts.strokeActive,\n                    controlFill: this.opts.controlFillActive,\n                    controlStroke: this.opts.controlStrokeActive,\n                    format: 'number'\n                },\n                fillAlpha: this.opts.fillActiveAlpha,\n                strokeWidth: this.opts.strokeActiveWidth,\n                strokeAlpha: this.opts.strokeActiveAlpha,\n                controlFillAlpha: this.opts.controlFillActiveAlpha,\n                controlStrokeWidth: this.opts.controlStrokeActiveWidth,\n                controlStrokeAlpha: this.opts.controlStrokeActiveAlpha,\n                controlRadius: this.opts.controlRadiusActive,\n                onUpdate: () => this.drawAnimated(),\n                onComplete: () => this.draw()\n            })\n\n\n        } else {\n            TweenLite.to(this.control, this.opts.durationActive, {x: this.xInactive})\n            TweenLite.to(this.tempAnimated, this.opts.durationActive, {\n                colorProps: {\n                    fill: this.opts.fill,\n                    stroke: this.opts.stroke,\n                    controlFill: this.opts.controlFill,\n                    controlStroke: this.opts.controlStroke,\n                    format: 'number'\n                },\n                fillAlpha: this.opts.fillAlpha,\n                strokeWidth: this.opts.strokeWidth,\n                strokeAlpha: this.opts.strokeAlpha,\n                controlFillAlpha: this.opts.controlFillAlpha,\n                controlStrokeWidth: this.opts.controlStrokeWidth,\n                controlStrokeAlpha: this.opts.controlStrokeAlpha,\n                controlRadius: this.opts.controlRadius,\n                onUpdate: () => this.drawAnimated(),\n                onComplete: () => this.draw()\n            })\n        }\n    }\n    \n    /**\n     * Gets or sets the disabled state. When disabled, the switch cannot be clicked.\n     * \n     * @member {boolean}\n     */\n    get disabled() {\n        return this._disabled\n    }\n\n    set disabled(value) {\n\n        this._disabled = value\n        \n        if (this._disabled) {\n            this.switchObj.interactive = false\n            this.switchObj.buttonMode = false\n            this.switchObj.alpha = .5\n            this.control.alpha = .5\n        } else {\n            this.switchObj.interactive = true\n            this.switchObj.buttonMode = true\n            this.switchObj.alpha = 1\n            this.control.alpha = 1\n        }\n    }\n\n    /**\n     * Shows the switch (sets his alpha values to 1).\n     * \n     * @return {Switch} A reference to the switch for chaining.\n     */\n    show() {\n\n        this.opts.strokeAlpha = 1\n        this.opts.strokeActiveAlpha = 1\n        this.opts.fillAlpha = 1\n        this.opts.fillActiveAlpha = 1\n        this.opts.controlStrokeAlpha = 1\n        this.opts.controlStrokeActiveAlpha = 1\n        this.opts.controlFillAlpha = 1\n        this.opts.controlFillActiveAlpha = 1\n\n        this.layout()\n\n        return this\n    }\n    \n    /**\n     * Hides the switch (sets his alpha values to 1).\n     * \n     * @return {Switch} A reference to the switch for chaining.\n     */\n    hide() {\n\n        this.opts.strokeAlpha = 0\n        this.opts.strokeActiveAlpha = 0\n        this.opts.fillAlpha = 0\n        this.opts.fillActiveAlpha = 0\n        this.opts.controlStrokeAlpha = 0\n        this.opts.controlStrokeActiveAlpha = 0\n        this.opts.controlFillAlpha = 0\n        this.opts.controlFillActiveAlpha = 0\n\n        this.layout()\n\n        return this\n    }\n}\n","import Theme from './theme.js'\nimport Popup from './popup.js'\n\n/**\n * Class that represents a PixiJS PopupMenu.\n * \n * @example\n * // Create the button and the modal when clicked\n * const button = new Button({\n *     label: 'Show PopupMenu',\n *     action: e => {\n *         const popupmenu = new PopupMenu({\n *             items: [\n *                 {label: 'Save', action: () => alert('Saved')},\n *                 {label: 'Edit', action: () => alert('Edited')},\n *                 {label: 'Delete', action: () => alert('Deleted')}\n *             ]\n *         })\n *         app.scene.addChild(popupmenu)\n *     }\n * })\n *\n * // Add the button to a DisplayObject\n * app.scene.addChild(button)\n *\n * @class\n * @extends Popup\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/popupmenu.html|DocTest}\n */\nexport default class PopupMenu extends Popup {\n    \n    /**\n     * Creates an instance of a PopupMenu.\n     * \n     * @constructor\n     * @param {object} [opts] - An options object to specify to style and behaviour of the modal.\n     * @param {object[]} [opts.items=[]] - A list of the menu items. Each item must be of type object.\n     *     If an object has a label property, a PIXI.Text object is created (using the textStyle property).\n     *     If an object hasn't a label property, it must contain a content property which has to be a\n     *     PIXI.DisplayObject.\n     * @param {number} [opts.margin=Theme.margin / 2] - The app where the modal belongs to.\n     * @param {object} [opts.textStyle=Theme.textStyle] - The color of the background.\n     * @param {boolean} [opts.closeOnPopup=true] - The opacity of the background.\n     */\n    constructor(opts = {}) {\n        \n        const theme = Theme.fromString(opts.theme)\n        \n        opts = Object.assign({}, {\n            items: [],\n            margin: theme.margin / 2,\n            textStyle: theme.textStyle,\n            closeOnPopup: true\n        }, opts)\n\n        super(opts)\n    }\n    \n    /**\n     * Creates children and instantiates everything.\n     * \n     * @private\n     * @return {PopupMenu} A reference to the popupmenu for chaining.\n     */\n    setup() {\n\n        // content\n        //-----------------\n        const content = new PIXI.Container()\n        \n        let y = 0\n        for (let item of this.opts.items) {\n\n            let object = null\n\n            if (item.label) {\n                object = new PIXI.Text(item.label, item.textStyle || this.opts.textStyle)\n            } else {\n                object = item.content\n            }\n\n            object.y = y\n\n            if (item.action) {\n                if (item.disabled) {\n                    object.alpha = .5\n                } else {\n                    object.interactive = true\n                    object.buttonMode = true\n                }\n                object.on('pointerover', e => {\n                    TweenLite.to(object, this.theme.fast, {alpha: .83, overwrite: 'none'})\n                })\n                object.on('pointerout', e => {\n                    TweenLite.to(object, this.theme.fast, {alpha: 1, overwrite: 'none'})\n                })\n                object.on('pointerup', e => {\n                    item.action.call(object, e, object)\n                    if (this.opts.closeOnAction) {\n                        this.hide()\n                    }\n                })\n            }\n\n            content.addChild(object)\n\n            y += object.height + this.opts.margin\n        }\n\n        this.opts.content = content\n\n        super.setup()\n    }\n}\n","/* global Quad */\n\nimport Theme from './theme.js'\n\n/**\n * Class that represents a PixiJS Volatile.\n * \n * @example\n * const app = new PIXIApp({\n *     view: canvas,\n *     width: 900,\n *     height: 250\n * }).setup().run()\n * \n * const button = new Button({\n *     label: 'Volatile!',\n *     action: () => {\n *         new Volatile({\n *             object: button,\n *             direction: 'right',\n *             destroyOnComplete: false\n *         })\n *     }\n * })\n * \n * app.scene.addChild(button)\n *\n * @class\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/volatile.html|DocTest}\n */\nexport default class Volatile {\n    \n    /**\n     * Creates an instance of a Volatile.\n     * \n     * @constructor\n     * @param {object} [opts] - An options object to specify to style and behaviour of the modal.\n     * @param {number} [opts.id=auto generated] - The id of the tooltip.\n     * @param {PIXI.DisplayObject|PIXI.DisplayObject[]} opts.object - The object where the volatile should be applied to.\n     * @param {string} [opts.direction=top] - The animation direction. Possible values: top, right, bottom, left.\n     * @param {function} [opts.onStart] - A function which is executed when the volatile animation starts.\n     * @param {function} [opts.onComplete] - A function which is executed when the volatile animation finishes.\n     * @param {number} [opts.distance=160] - The animation distance.\n     * @param {number} [opts.duration=1.5] - The duration of the animation in seconds.\n     * @param {object} [opts.ease=Quad.easeOut] - The easing of the animation, see {@link https://greensock.com/docs/Easing}\n     * @param {boolean} [opts.destroyOnComplete=true] - Should the object be destroyed after the volatile animation?\n     */\n    constructor(opts = {}) {\n        \n        const theme = Theme.fromString(opts.theme)\n        this.theme = theme\n\n        this.opts = Object.assign({}, {\n            id: PIXI.utils.uid(),\n            object: null,\n            direction: 'top',               // top, right, bottom, left\n            onStart: null,\n            onComplete: null,\n            distance: 160,\n            duration: 1.5,\n            ease: Quad.easeOut,\n            destroyOnComplete: true\n        }, opts)\n\n        this.id = this.opts.id\n\n        if (!Array.isArray(this.opts.object)) {\n            this.opts.object = [this.opts.object]\n        }\n\n        this.objects = this.opts.object\n\n        // setup\n        //-----------------\n        this.setup()\n\n        // layout\n        //-----------------\n        this.layout()\n\n        // run\n        //-----------------\n        this.run()\n    }\n    \n    /**\n     * Creates children and instantiates everything.\n     * \n     * @private\n     * @return {Volatile} A reference to the volatile for chaining.\n     */\n    setup() {\n\n        return this\n    }\n    \n    /**\n     * Should be called to refresh the layout of the volatile. Can be used after resizing.\n     * \n     * @return {Volatile} A reference to the volatile for chaining.\n     */\n    layout() {\n        \n        return this\n    }\n    \n    /**\n     * Starts the volatile animation.\n     * \n     * @private\n     * @return {Volatile} A reference to the volatile for chaining.\n     */\n    run() {\n\n        for (let object of this.objects) {\n\n            let x = object.x\n            let y = object.y\n\n            switch (this.opts.direction) {\n                case 'top':\n                    y -= this.opts.distance\n                    break\n                case 'right':\n                    x += this.opts.distance\n                    break\n                case 'bottom':\n                    y += this.opts.distance\n                    break\n                case 'left':\n                    x -= this.opts.distance\n                    break\n            }\n\n            TweenLite.to(object, this.opts.duration, {\n                x,\n                y,\n                alpha: 0,\n                ease: this.opts.ease,\n                overwrite: 'all',\n                onStart: () => {\n                    if (this.opts.onStart) {\n                        this.opts.onStart.call(object, object)\n                    }\n                },\n                onComplete: () => {\n                    \n                    if (this.opts.onComplete) {\n                        this.opts.onComplete.call(object, object)\n                    }\n\n                    if (this.opts.destroyOnComplete) {\n                        object.destroy({children: true})\n                    }\n                }\n            })\n        }\n\n        return this\n    }\n}\n","/* globals */\n\n/* Imports */\nimport Events from '../events.js'\n\n/**\n * Class that represents a PixiJS List.\n *\n * @example\n * const elephant1 = PIXI.Sprite.fromImage('./assets/elephant-1.jpg')\n * const elephant2 = PIXI.Sprite.fromImage('./assets/elephant-2.jpg')\n * \n * // Create the list\n * const list = new List([elephant1, elephant2])\n * \n * app.scene.addChild(list)\n *\n * @class\n * @extends PIXI.Container\n * @see {@link http://pixijs.download/dev/docs/PIXI.Container.html|PixiJS Container}\n * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/list.html|DocTest}\n */\nexport default class List extends PIXI.Container {\n\n    /**\n     * Creates an instance of a Flippable.\n     *\n     * @constructor\n     * @param {PIXI.DisplayObject[]} items - An array of PIXI.DisplayObjects.\n     * @param {object} [opts] - An options object which can contain the following properties.\n     * @param {number} [opts.width] - The width of the list. If the items are larger than this width, the overflow\n     *     will be hidden.\n     * @param {number} [opts.height] - The height of the list. If the items are larger than this height, the overflow\n     *     will be hidden.\n     * @param {number} [opts.padding=10] - The inner spacing (distance from one item to the previous/next item).\n     * @param {number} [opts.margin=10] - The outer spacing (distance from one item to the border).\n     * @param {string} [opts.orientation=vertical] - The orientation of the button group. Can be horizontal or vertical.\n     * @param {string} [opts.align=left] - The horizontal position of the items. Possible values are\n     *     left, center and right.\n     * @param {string} [opts.verticalAlign=middle] - The vertical position of the items. Possible values are\n     *     top, middle and bottom.\n     */\n    constructor(items = [], opts = {}) {\n\n        super()\n\n        this.opts = Object.assign({}, {\n            padding: 10,\n            margin: 10,\n            orientation: 'vertical',\n            align: 'left',\n            verticalAlign: 'middle',\n            width: null,\n            height: null\n        }, opts)\n\n        this.__items = items\n        this.__dragging = false\n\n        // setup\n        //--------------------\n        this.setup()\n    }\n\n    /**\n     * Creates children and instantiates everything.\n     *\n     * @private\n     * @return {List} A reference to the list for chaining.\n     */\n    setup() {\n\n        // inner container\n        //--------------------\n        const container = new PIXI.Container()\n        this.addChild(container)\n        this.container = container\n\n        // mask\n        //--------------------\n        const mask = new PIXI.Graphics()\n        this.addChild(mask)\n        this.__mask = mask\n\n        // add items\n        //--------------------\n        for(let item of this.__items) {\n            container.addChild(item)\n        }\n\n        // interaction\n        //--------------------\n        this.interactive = this.opts.width || this.opts.height\n        this.on('pointerdown', this.onStart.bind(this))\n        this.on('pointermove', this.onMove.bind(this))\n        this.on('pointerup', this.onEnd.bind(this))\n        this.on('pointercancel', this.onEnd.bind(this))\n        this.on('pointerout', this.onEnd.bind(this))\n        this.on('pointerupoutside', this.onEnd.bind(this))\n\n        this.layout()\n\n        return this\n    }\n\n    /**\n     * Replaces the existing items and relayouts the list.\n     *\n     * @param {PIXI.DisplayObject[]} items - An array of PIXI.DisplayObjects.\n     * @return {List} A reference to the list for chaining.\n     */\n    setItems(items) {\n        this.container.removeChildren()\n        this.__items = items\n        for(let item of this.__items) {\n            this.container.addChild(item)\n        }\n        this.layout()\n    }\n\n    /**\n     * Should be called to refresh the layout of the list (the width or the height).\n     *\n     * @return {List} A reference to the list for chaining.\n     */\n    layout() {\n\n        const margin = this.opts.margin\n\n        let x = margin\n        let y = margin\n\n        for (let item of this.__items) {\n\n            item.x = x\n            item.y = y\n\n            if (this.opts.orientation === 'vertical') {\n                y += item.height + this.opts.padding\n            } else {\n                x += item.width + this.opts.padding\n            }\n        }\n\n        // vertical\n        //--------------------\n        if (this.opts.orientation === 'vertical') {\n            switch (this.opts.align) {\n                case 'center':\n                    this.__items.forEach(it => it.x = margin + this.width / 2 - it.width / 2)\n                    break\n                case 'right':\n                    this.__items.forEach(it => it.x = margin + this.width - it.width)\n                    break\n                default:\n                    this.__items.forEach(it => it.x = margin)\n                    break\n            }\n\n            if (this.opts.height) {\n                const mask = this.__mask\n                mask.clear()\n                mask.beginFill(0x000)\n                mask.drawRect(0, 0, this.width + 2 * margin, this.opts.height)\n                this.mask = mask\n\n                this.interactive = this.innerHeight > this.opts.height\n            }\n        }\n\n        // horizontal\n        //--------------------\n        if (this.opts.orientation === 'horizontal') {\n            switch (this.opts.verticalAlign) {\n                case 'top':\n                    this.__items.forEach(it => it.y = margin)\n                    break\n                case 'bottom':\n                    this.__items.forEach(it => it.y = margin + this.height - it.height)\n                    break\n                default:\n                    this.__items.forEach(it => it.y = margin + this.height / 2 - it.height / 2)\n                    break\n            }\n\n            if (this.opts.width) {\n                const mask = this.__mask\n                mask.clear()\n                mask.beginFill(0x000)\n                mask.drawRect(0, 0, this.opts.width, this.height + 2 * margin)\n                this.mask = mask\n\n                this.interactive = this.innerWidth > this.opts.width\n            }\n        }\n\n        return this\n    }\n\n    /**\n     * \n     */\n    get innerWidth() {\n\n        let size = 0\n\n        this.__items.forEach(it => size += it.width)\n        size += this.opts.padding * (this.__items.length - 1)\n        size += 2 * this.opts.margin\n\n        return size\n    }\n\n    /**\n     * \n     */\n    get innerHeight() {\n\n        let size = 0\n\n        this.__items.forEach(it => size += it.height)\n        size += this.opts.padding * (this.__items.length - 1)\n        size += 2 * this.opts.margin\n\n        return size\n    }\n\n    /**\n     * Resizes the list.\n     * \n     * @param {number} widthOrHeight - The new width (if orientation is horizontal) or height (if orientation is vertical) of the list.\n     */\n    resize(widthOrHeight) {\n\n        if (this.opts.orientation === 'horizontal') {\n            this.opts.width = widthOrHeight\n        } else {\n            this.opts.height = widthOrHeight\n        }\n\n        this.layout()\n    }\n\n    /**\n     * \n     * @private\n     * @param {*} event \n     */\n    onStart(event) {\n\n        this.__dragging = true\n\n        this.capture(event)\n\n        this.__delta = {\n            x: this.container.position.x - event.data.global.x,\n            y: this.container.position.y - event.data.global.y\n        }\n\n        TweenLite.killTweensOf(this.container.position, {x: true, y: true})\n        ThrowPropsPlugin.track(this.container.position, 'x,y')\n    }\n\n    /**\n     * \n     * @private\n     * @param {*} event \n     */\n    onMove(event) {\n\n        if (this.__dragging) {\n        \n            this.capture(event)\n\n            if (this.opts.orientation === 'horizontal') {\n                this.container.position.x = event.data.global.x + this.__delta.x\n            } else {\n                this.container.position.y = event.data.global.y + this.__delta.y\n            }\n        }\n    }\n\n    /**\n     * \n     * @private\n     * @param {*} event \n     */\n    onEnd(event) {\n\n        if (this.__dragging) {\n            this.__dragging = false\n\n            this.capture(event)\n\n            const throwProps = {}\n            \n            if (this.opts.orientation === 'horizontal') {\n                let min = this.opts.width - this.innerWidth\n                min = min > 0 ? 0 : min\n                throwProps.x = {\n                    velocity: 'auto',\n                    min,\n                    max: 0\n                }\n            } else {\n                let min = this.opts.height - this.innerHeight\n                min = min > 0 ? 0 : min\n                throwProps.y = {\n                    velocity: 'auto',\n                    min,\n                    max: 0\n                }\n            }\n\n            ThrowPropsPlugin.to(this.container.position, {\n                throwProps,\n                ease: Strong.easeOut,\n                onComplete: () => ThrowPropsPlugin.untrack(this.container.position)\n            }, .8, .4)\n        }\n    }\n\n    /**\n     * Captures an event to inform InteractionMapper about processed events.\n     *\n     * @param {event|PIXI.InteractionEvent} event - The PIXI event to capture.\n     */\n    capture(event) {\n        Events.capturedBy(event.data.originalEvent, this)\n    }\n}\n","import PIXIApp from './app.js'\nimport BlurFilter from './blurfilter.js'\nimport FlipEffect from './flipeffect.js'\nimport Flippable from './flippable.js'\nimport {DeepZoomInfo, DeepZoomImage} from './deepzoom/image.js'\nimport Popover from './popover.js'\nimport {ScatterContainer, DisplayObjectScatter} from './scatter.js'\nimport {AppTest, Command, RecorderTools} from './test.js'\nimport Timeline from './timeline.js'\nimport Theme from './theme.js'\nimport Button from './button.js'\nimport ButtonGroup from './buttongroup.js'\nimport Slider from './slider.js'\nimport Switch from './switch.js'\nimport Popup from './popup.js'\nimport PopupMenu from './popupmenu.js'\nimport Modal from './modal.js'\nimport Volatile from './volatile.js'\nimport Message from './message.js'\nimport Tooltip from './tooltip.js'\nimport Badge from './badge.js'\nimport Progress from './progress.js'\nimport List from './list.js'\nimport {LabeledGraphics, FontInfo} from './labeledgraphics.js'\n/* Needed to ensure that rollup.js includes class definitions and the classes\nare visible inside doctests.\n*/\nwindow.PIXIApp = PIXIApp\nwindow.BlurFilter = BlurFilter\nwindow.FlipEffect = FlipEffect\nwindow.Flippable = Flippable\nwindow.DeepZoomInfo = DeepZoomInfo\nwindow.DeepZoomImage = DeepZoomImage\nwindow.Popover = Popover\nwindow.ScatterContainer = ScatterContainer\nwindow.DisplayObjectScatter = DisplayObjectScatter\nwindow.Command = Command\nwindow.RecorderTools = RecorderTools\nwindow.Timeline = Timeline\nwindow.AppTest = AppTest\nwindow.Theme = Theme\nwindow.Button = Button\nwindow.ButtonGroup = ButtonGroup\nwindow.Slider = Slider\nwindow.Switch = Switch\nwindow.Popup = Popup\nwindow.PopupMenu = PopupMenu\nwindow.Modal = Modal\nwindow.Volatile = Volatile\nwindow.Message = Message\nwindow.Tooltip = Tooltip\nwindow.Badge = Badge\nwindow.Progress = Progress\nwindow.List = List\nwindow.LabeledGraphics = LabeledGraphics\nwindow.FontInfo = FontInfo"],"names":["Events","Elements","InteractionMapper","PopupMenu"],"mappings":"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"}
|