seven_out.js

//{INSERTORDER:1}
var seven;
(function (seven) {
    class AbstractMap {
        constructor() {
            this.containerObject = new Object();
        }
        containsKey(key) {
            return this.containerObject.hasOwnProperty("" + key);
        }
        containsValue(value) {
            for (var k in this.containerObject) {
                if (this.containerObject[k] == value) {
                    return true;
                }
            }
            return false;
        }
        get(object) {
            if (this.containsKey(object) == true) {
                return this.containerObject["" + object];
            }
        }
        isEmpty() {
            for (var k in this.containerObject) {
                return false;
            }
            return true;
        }
        put(key, value) {
            this.containerObject["" + key] = value;
            return this.containerObject["" + key];
        }
        remove(key) {
            delete this.containerObject["" + key];
        }
        size() {
            var counter = 0;
            for (var k in this.containerObject) {
                counter++;
            }
            return counter;
        }
        values() {
            var values = new Array();
            for (var key in this.containerObject) {
                values.push(this.containerObject[key]);
            }
            return values;
        }
        keys() {
            return Object.keys(this.containerObject);
        }
    }
    seven.AbstractMap = AbstractMap;
    class Callback {
        constructor(thisRef, method) {
            this.thisRef = thisRef;
            this.method = method;
        }
        call(t, u, v) {
            if (t != undefined && u != undefined && v != undefined) {
                this.method.call(this.thisRef, t, u, v);
                return;
            }
            if (t != undefined && u != undefined) {
                this.method.call(this.thisRef, t, u);
                return;
            }
            if (t != undefined) {
                this.method.call(this.thisRef, t);
                return;
            }
        }
    }
    seven.Callback = Callback;
    class VoidCallback {
        constructor(thisRef, method) {
            this.thisRef = thisRef;
            this.method = method;
        }
        getClassName() { return VoidCallback.classname; }
        call() {
            this.method.call(this.thisRef);
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    VoidCallback.classname = "seven.VoidCallback";
    seven.VoidCallback = VoidCallback;
//{INSERTORDER:10}
    /**
     * the ClassLoader registers and loads classes
     */
    class ClassLoader {
        constructor() {
            //AutoGeneratedClassName-end - do not eidt this line
            this.constructedClasses = {};
            this.loadClasses = new Array();
            this.priorityClass = Array();
            this.priorityClasses = {};
            this.afterClasses = {};
        }
        getClassName() { return ClassLoader.classname; }
        static manager() {
            if (ClassLoader._instance == undefined) {
                ClassLoader._instance = new ClassLoader();
            }
            return ClassLoader._instance;
        }
        /**
         *
         * @param className the fully qualified className
         * <br/>
         * this method is normally defined in the global space and gets loaded when called from the document delegate
         * it is important that the class a has public static method called 'loadedInstance():thisRef'
         *
         */
        loadInstance(className) {
            this.loadClasses.push(className);
        }
        loadInstanceAtPriority(className, priority) {
            if (this.priorityClasses[priority] == undefined) {
                this.priorityClasses[priority] = new Array();
            }
            this.priorityClasses[priority].push(className);
        }
        startLoading() {
            var keys = Object.keys(this.priorityClasses).sort((a, b) => {
                return parseInt(a) - parseInt(b);
            });
            for (let key of keys) {
                for (let value of this.priorityClasses[key]) {
                    var classObject = eval(value + ".loadedInstance();");
                }
            }
            for (let className of this.loadClasses) {
                //  try {
                var classObject = eval(className + ".loadedInstance();");
                /*} catch (e) {
                    Logger.error("ClassLoader - No Class found for classname");
                }*/
            }
        }
        hasLoaded(classname) {
            this.constructedClasses[classname] = classname;
            if (this.afterClasses[classname] != undefined) {
                var classes = this.afterClasses[classname];
                if (classes == undefined) {
                    return;
                }
                for (let classObj of classes) {
                    this.loadInstance(classObj);
                }
            }
        }
        getLoadedInstance(classname) {
            this.constructedClasses[classname];
        }
        after(afterName, loadClassName) {
            if (this.afterClasses[afterName] == undefined) {
                this.afterClasses[afterName] = new Array();
            }
            var currentClasses = this.afterClasses[afterName];
            currentClasses.push(loadClassName);
            this.afterClasses[afterName] = currentClasses;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    ClassLoader.classname = "seven.ClassLoader";
    seven.ClassLoader = ClassLoader;
//{INSERTORDER:2}
    class Color {
        getClassName() { return Color.classname; }
        //AutoGeneratedClassName-end - do not eidt this line
        static transparent() {
            return "rgba(0,0,0,0.0)";
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    Color.classname = "seven.Color";
    seven.Color = Color;
    class CookieManager {
        getClassName() { return CookieManager.classname; }
        //AutoGeneratedClassName-end - do not eidt this line
        setCookie(name, value, expireHours) {
            try {
                localStorage.setItem(name, value);
            }
            catch (e) {
                var d = new Date();
                d.setTime(d.getTime() + (expireHours * 60 * 60 * 1000));
                var expires = "expires=" + d.toUTCString();
                document.cookie = name + "=" + value + "; " + expires;
            }
        }
        getCookie(name) {
            try {
                return localStorage.getItem(name);
            }
            catch (e) {
                name = name + "=";
                var ca = document.cookie.split(';');
                for (var i = 0; i < ca.length; i++) {
                    var c = ca[i];
                    while (c.charAt(0) == ' ') {
                        c = c.substring(1);
                    }
                    if (c.indexOf(name) == 0) {
                        return c.substring(name.length, c.length);
                    }
                }
            }
            return "";
        }
        getCookieStartWithNeedle(name) {
            var allCookies = new seven.JMBMap();
            try {
                for (var info in window.localStorage) {
                    if (info.indexOf(name) == 0) {
                        allCookies.put(info, this.getCookie(info));
                    }
                }
            }
            catch (e) {
                var ca = document.cookie.split(';');
                for (var i = 0; i < ca.length; i++) {
                    var c = ca[i];
                    while (c.charAt(0) == ' ') {
                        c = c.substring(1);
                    }
                    if (c.indexOf(name) == 0) {
                        var index = c.indexOf("=");
                        var key = c.substring(0, index);
                        allCookies.put(key, c.substring(key.length + 1, c.length));
                    }
                }
            }
            return allCookies;
        }
        getCookieArrayStartWithNeedle(name) {
            var allCookies = new Array();
            try {
                for (var info in window.localStorage) {
                    if (info.indexOf(name) == 0) {
                        allCookies.push(this.getCookie(info));
                    }
                }
            }
            catch (e) {
                var ca = document.cookie.split(';');
                for (var i = 0; i < ca.length; i++) {
                    var c = ca[i];
                    while (c.charAt(0) == ' ') {
                        c = c.substring(1);
                    }
                    if (c.indexOf(name) == 0) {
                        var index = c.indexOf("=");
                        var key = c.substring(0, index);
                        allCookies.push(c.substring(key.length + 1, c.length));
                    }
                }
            }
            return allCookies;
        }
        deleteCookie(name) {
            try {
                localStorage.removeItem(name);
            }
            catch (e) {
                document.cookie = name + '=; expires=Thu, 01 Jan 1970 00:00:01 GMT;';
            }
        }
        deleteAllCookiesWithNeedle(needle) {
            var cookies = this.getCookieStartWithNeedle(needle);
            for (let cookie of cookies.keys()) {
                this.deleteCookie(cookie);
            }
        }
        deleteAllCookies() {
            try {
                window.localStorage.clear();
            }
            catch (e) {
                document.cookie.split(";").forEach(function (c) { document.cookie = c.replace(/^ +/, "").replace(/=.*/, "=;expires=" + new Date().toUTCString() + ";path=/"); });
            }
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    CookieManager.classname = "seven.CookieManager";
    seven.CookieManager = CookieManager;
    class DefaultRenderer {
        getClassName() { return DefaultRenderer.classname; }
        //AutoGeneratedClassName-end - do not eidt this line
        loadIfDefault() {
            if (seven.JBDocument.document().hasRenderer() == false) {
                seven.Logger.boot("no renderer found -- using default");
                seven.JBDocument.document().setRenderer(this);
            }
        }
        renderViewHierachy(superView) {
            for (let subView of superView.getSubViews()) {
                subView.drawInRect(subView.frame);
                this.drawSubView(subView);
            }
        }
        drawSubView(view) {
            for (let subView of view.getSubViews()) {
                subView.drawInRect(subView.frame);
                this.drawSubView(subView);
            }
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    DefaultRenderer.classname = "seven.DefaultRenderer";
    seven.DefaultRenderer = DefaultRenderer;
    class DefaultStyleProvider {
        constructor() {
            //AutoGeneratedClassName-end - do not eidt this line
            this.backgroundColor = "white";
            this.strokeColor = "black";
        }
        getClassName() { return DefaultStyleProvider.classname; }
        setBackgroundColor(color) {
            this.backgroundColor = color;
        }
        getBackGroundColor() {
            return this.backgroundColor;
        }
        isHidden() {
            return this.hide;
        }
        setHidden(hide) {
            this.hide = hide;
        }
        getStrokeColor() {
            return this.strokeColor;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    DefaultStyleProvider.classname = "seven.DefaultStyleProvider";
    seven.DefaultStyleProvider = DefaultStyleProvider;
    class DefaultWindowLoader {
        getClassName() { return DefaultWindowLoader.classname; }
        loadIfDefault() {
            if (seven.JBDocument.document().hasWindowLoader() == false) {
                seven.Logger.boot("no window loader found -- using default");
                seven.JBDocument.document().setWindowLoader(this);
            }
        }
        setup(document) {
            this.document = document;
        }
        loadWindows(sizeClass) {
            var window = new seven.CanvasWindow().initWithId('main', new seven.Rect(0, 0, 1000, 800), new seven.ViewController());
            this.document.addSubWindow(window);
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    DefaultWindowLoader.classname = "seven.DefaultWindowLoader";
    seven.DefaultWindowLoader = DefaultWindowLoader;
    class UniqueKeyEnumation {
        constructor() {
            this.keys = new Array();
        }
        getClassName() { return UniqueKeyEnumation.classname; }
        hasKey(key) {
            var hasKey = 0;
            this.keys.forEach(element => {
                if (element == key) {
                    hasKey = 1;
                }
            });
            if (hasKey == 1) {
                return true;
            }
            return false;
        }
        addKey(key) {
            var hasKey = 0;
            this.keys.forEach(element => {
                if (element == key) {
                    hasKey = 1;
                }
            });
            if (hasKey == 1) {
                throw new Error("UniqueKeyEnumation - tried to add duplicate key");
            }
            this.keys.push(key);
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    UniqueKeyEnumation.classname = "seven.UniqueKeyEnumation";
    seven.UniqueKeyEnumation = UniqueKeyEnumation;
    class JBFunction {
    }
    seven.JBFunction = JBFunction;
    class ImageLoadedCallback {
        constructor(thisRef, method) {
            this.thisRef = thisRef;
            this.method = method;
        }
        getClassName() { return ImageLoadedCallback.classname; }
        call(image) {
            this.method.call(this.thisRef, image);
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    ImageLoadedCallback.classname = "seven.ImageLoadedCallback";
    seven.ImageLoadedCallback = ImageLoadedCallback;
    class JMBIterator {
        constructor(arr) {
            this.index = 0;
            this.inputArray = arr;
        }
        getClassName() { return JMBIterator.classname; }
        hasNext() {
            return this.index < this.inputArray.length;
        }
        next() {
            if (this.hasNext() == false) {
                return undefined;
            }
            var nextElement = this.inputArray[this.index];
            this.index++;
            return nextElement;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    JMBIterator.classname = "seven.JMBIterator";
    seven.JMBIterator = JMBIterator;
    class JBNotificationCenter {
        /* private */ constructor() {
            this.observers = new seven.JMBMap();
            this.priorityObservers = new seven.JMBMap();
        }
        getClassName() { return JBNotificationCenter.classname; }
        static touchEventManager() {
            if (JBNotificationCenter._touchEventCenter == undefined) {
                JBNotificationCenter._touchEventCenter = new JBNotificationCenter();
            }
            return JBNotificationCenter._touchEventCenter;
        }
        static defaultCenter() {
            if (JBNotificationCenter._defaultManager == undefined) {
                JBNotificationCenter._defaultManager = new JBNotificationCenter();
            }
            return JBNotificationCenter._defaultManager;
        }
        addObserverForName(name, observer, priority) {
            if (priority != undefined) {
                if (this.priorityObservers.containsKey(name) == false) {
                    this.priorityObservers.put(name, new seven.JMBMap());
                }
                var observerMap = this.priorityObservers.get(name);
                if (observerMap.containsKey(priority) == false) {
                    observerMap.put(priority, new Array());
                }
                var observers = observerMap.get(priority);
                var found = false;
                for (let everyObserver of observers) {
                    if (everyObserver.thisRef == observer.thisRef) {
                        found = true;
                    }
                }
                if (found == false) {
                    observers.push(observer);
                }
                return;
            }
            if (this.observers.containsKey(name) == false) {
                this.observers.put(name, new Array());
            }
            var observerArray = this.observers.get(name);
            var found = false;
            for (let everyObserver of observerArray) {
                if (everyObserver.thisRef == observer.thisRef) {
                    found = true;
                }
            }
            if (found == false) {
                observerArray.push(observer);
            }
        }
        postNotificationForName(name, userInfo) {
            this.postPriority(name, userInfo);
            var observerValues = this.observers.get(name);
            for (let observer of observerValues) {
                //call the observer method with userInfo 
                if (observer.userInfo) {
                    observer.method.call(observer.thisRef, userInfo);
                }
                else {
                    observer.method.call(observer.thisRef);
                }
            }
        }
        postPriority(name, userInfo) {
            var priorityMap = this.priorityObservers.get(name);
            if (priorityMap == undefined) {
                return;
            }
            var priorities = priorityMap.keys().sort((a, b) => {
                return a - b;
            });
            for (var prorityKey of priorities) {
                var values = priorityMap.get(prorityKey);
                for (let observer of values) {
                    //call the observer method with userInfo 
                    if (observer.userInfo) {
                        observer.method.call(observer.thisRef, userInfo);
                    }
                    else {
                        observer.method.call(observer.thisRef);
                    }
                }
            }
        }
        removeObserver(observerThis, name) {
            var observerValues = this.observers.get(name);
            for (var key in observerValues) {
                if (observerValues[key].thisRef == observerThis) {
                    delete observerValues[key];
                }
            }
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    JBNotificationCenter.classname = "seven.JBNotificationCenter";
    seven.JBNotificationCenter = JBNotificationCenter;
//{INSERTORDER:1}
    class JBObject {
        //AutoGeneratedClassName-end - do not eidt this line
        constructor() {
            seven.ClassLoader.manager().hasLoaded(this.getClassName());
        }
        getClassName() { return JBObject.classname; }
        equals(object) {
            if (object == undefined) {
                return false;
            }
            return object == this;
        }
        hasBeenLoaded() {
        }
        hashcode() {
            return 0;
        }
        toString() {
            return this.getClassName();
        }
        copyAttributes(toObject) {
        }
        copy() {
            var newObject = new JBObject();
            this.copyAttributes(newObject);
            return newObject;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    JBObject.classname = "seven.JBObject";
    seven.JBObject = JBObject;
    class Logger {
        constructor() { }
        getClassName() { return Logger.classname; }
        static only(args) {
            console.log(args);
            Logger.onlyFlag = true;
        }
        static log(args) {
            if (Logger.shouldLog() == false) {
                return;
            }
            var logMessage = Logger.toLogMessage(args);
            console.log(logMessage);
        }
        static develepor(args) {
            if (Logger.shouldLog() == false) {
                return;
            }
            var logMessage = Logger.toLogMessage(args);
            console.debug(logMessage);
        }
        static boot(args) {
            if (Logger.shouldLog() == false) {
                return;
            }
            var logMessage = Logger.toLogMessage(args);
            console.log(logMessage);
        }
        static develeporError(args) {
            if (Logger.shouldLog() == false) {
                return;
            }
            var logMessage = Logger.toLogMessage(args);
            console.error(logMessage);
        }
        static develeporInfo(args) {
            if (Logger.shouldLog() == false) {
                return;
            }
            var logMessage = Logger.toLogMessage(args);
            console.info(logMessage);
        }
        static error(errorText, showErrorDialog = false) {
            if (Logger.shouldLog() == false) {
                return;
            }
            console.error(errorText);
            if (showErrorDialog == false) {
                return;
            }
        }
        static shouldLog() {
            if (Logger.onlyFlag == true) {
                return false;
            }
            if (Logger.noLogging == true) {
                return false;
            }
        }
        static toLogMessage(args) {
            if (typeof args == "string") {
                return args;
            }
            var buildMessage = "";
            var elements = new Array();
            elements = elements.concat(args);
            elements.forEach(element => {
                if (typeof element == "object") {
                    buildMessage = buildMessage.concat(element.toString());
                }
                else {
                    buildMessage = buildMessage.concat(element);
                }
                buildMessage = buildMessage.concat(" , ");
            });
            return buildMessage;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    Logger.classname = "seven.Logger";
    //AutoGeneratedClassName-end - do not eidt this line
    Logger.onlyFlag = false;
    Logger.noLogging = false;
    seven.Logger = Logger;
window.onerror = function (error) {
    seven.Logger.error(error.toString(), true);
};
    class Objects {
        getClassName() { return Objects.classname; }
        //AutoGeneratedClassName-end - do not eidt this line
        Objects() {
        }
        static requireNonNull(message, object) {
            if (object == undefined || object == null) {
                throw new Error(message);
            }
            return object;
        }
        static requireNumber(message, object) {
            Objects.requireNonNull(message, object);
            if (typeof object == "string") {
                object = parseInt(object);
            }
            Objects.requireNonNull(message, object);
            if (typeof object != "number") {
                throw new Error(message);
            }
            return object;
        }
        static orElse(object, replacement) {
            if (object != undefined && object != null) {
                return object;
            }
            return replacement;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    Objects.classname = "seven.Objects";
    seven.Objects = Objects;
    class Observer {
        constructor(thisRef, method, userInfo) {
            this.thisRef = thisRef;
            this.method = method;
            this.userInfo = userInfo;
        }
        getClassName() { return Observer.classname; }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    Observer.classname = "seven.Observer";
    seven.Observer = Observer;
    class On {
        constructor() {
            this.registry = {};
        }
        getClassName() { return On.classname; }
        static on() {
            if (On._instance == undefined) {
                On._instance = new On();
            }
            return On._instance;
        }
        register(key, method) {
            if (this.registry[key] == undefined) {
                this.registry[key] = new Array();
            }
            this.registry[key].push(method);
        }
        call(key, args = undefined) {
            if (this.registry[key] == undefined) {
                return;
            }
            for (let method of this.registry[key]) {
                method.call(this, args);
            }
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    On.classname = "seven.On";
    seven.On = On;
    function on(action, method) {
        On.on().register(action, method);
    }
    seven.on = on;
    function onWindowLoad(method) {
        On.on().register("windowDidLoad", method);
    }
    seven.onWindowLoad = onWindowLoad;
//{INSERTORDER:4}
/**
 * This class provides the default implementation for the resize Manager
 * This class wil get loaded in the global space(last line of file)
 * Here it registeres for resize events and handles them
 */
    class ResizeManager {
        constructor() {
            this.hasRegistered = false;
            this.userScale = 0;
        }
        getClassName() { return ResizeManager.classname; }
        /**
         * This gives the instance, which was loaded by the Classloader
         * You can use this to access this instance afterwoulds-or don't, you decide
         */
        static loadedInstance() {
            var loadedInstance = seven.ClassLoader.manager().getLoadedInstance(ResizeManager.classname);
            if (loadedInstance != undefined) {
                seven.JBDocument.document().setResizeManager(loadedInstance);
                return loadedInstance;
            }
            var resize = new ResizeManager();
            seven.JBDocument.document().setResizeManager(resize);
            seven.on("documentInitSize", () => {
                resize.handleResize(window.innerWidth, window.innerHeight);
            });
            return resize;
        }
        /**
        * Here we register as the resizeManager
        *
        */
        initDocument() {
            seven.JBDocument.document().setResizeManager(this);
        }
        setup(document) {
            this.document = document;
        }
        startResizing() {
            this.registerForResizeEvent();
            this.handleResize(window.innerWidth, window.innerHeight);
        }
        resize() {
            this.handleResize(this.document.doucmentView.frame.width(), this.document.doucmentView.frame.height());
        }
        hasSizeClass() {
            return this.activeSizeClass != undefined;
        }
        verticalScreenValue(value, useBaseClass = true) {
            var resizeSizeClass = this.resizeSizeClass(useBaseClass);
            if (resizeSizeClass.getHeight() == undefined) {
                return value;
            }
            if (this.document == undefined || this.document.doucmentView == undefined) {
                return value;
            }
            return (value / resizeSizeClass.getHeight()) * this.document.doucmentView.frame.height();
        }
        horizontalScreenValue(value, useBaseClass = true) {
            var resizeSizeClass = this.resizeSizeClass(useBaseClass);
            if (this.document == undefined || this.document.doucmentView == undefined) {
                return value;
            }
            return (value / resizeSizeClass.getWidth()) * this.document.doucmentView.frame.width();
        }
        verticalReferenceValue(value, useBaseClass = true) {
            var resizeSizeClass = this.resizeSizeClass(useBaseClass);
            if (resizeSizeClass.getHeight() == undefined) {
                return value;
            }
            var testValue = 10;
            var temp = this.verticalScreenValue(testValue, useBaseClass);
            var ratio = testValue / temp;
            var result = value * ratio;
            return result;
        }
        horizontalReferenceValue(value, useBaseClass = true) {
            var testValue = 10;
            var temp = this.horizontalScreenValue(testValue, useBaseClass);
            var ratio = testValue / temp;
            var result = value * ratio;
            return result;
        }
        resizeSizeClass(useBaseClass = true) {
            if (useBaseClass == false) {
                return seven.JBDocument.document().getSizeLoader().getSizeClass();
            }
            return seven.JBDocument.document().getSizeLoader().getBaseClass();
        }
        handleResize(newWidth, newHeight) {
            var userScaleChange = window.outerWidth / window.innerWidth;
            if (this.userScale != 0 && userScaleChange != this.userScale) {
                this.userScale = userScaleChange;
                return;
            }
            this.userScale = userScaleChange;
            this.document.doucmentView.initWitFrame(new seven.Rect(0, 0, newWidth, newHeight));
            seven.JBDocument.document().getSizeLoader().changeSizeClass(newWidth, newHeight);
            var nextSizeClass = seven.JBDocument.document().getSizeLoader().getSizeClass();
            this.baseSizeClass = seven.JBDocument.document().getSizeLoader().getBaseClass();
            if (this.activeSizeClass == undefined) {
                this.activeSizeClass = this.baseSizeClass;
            }
            if (nextSizeClass != this.activeSizeClass) {
                seven.SizeNotifier.notifier().postSizeClassChange(this.activeSizeClass, nextSizeClass);
                this.activeSizeClass = nextSizeClass;
            }
            var newFrame = new seven.Rect(0, 0, newWidth, newHeight);
            this.document.render();
        }
        registerForResizeEvent() {
            if (this.hasRegistered == true) {
                return;
            }
            this.hasRegistered = true;
            var self = this;
            window.onresize = function () {
                // console.log("w: "+window.screen.width+" h: "+window.screen.height);
                //self.handleResize(window.innerWidth, window.innerHeight);
                setTimeout(function () {
                    self.handleResize(window.innerWidth, window.innerHeight);
                }, 200);
            };
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    ResizeManager.classname = "seven.ResizeManager";
    seven.ResizeManager = ResizeManager;
seven.ClassLoader.manager().loadInstance(seven.ResizeManager.classname);
    class SizeCatalog {
        constructor(name) {
            this.classes = new Array();
            this.name = name;
        }
        getClassName() { return SizeCatalog.classname; }
        setBaseClass(sizeClass) {
            this.baseClass = sizeClass;
            this.classes.push(this.baseClass);
        }
        setBaseClassById(id) {
            for (let sizeCLass of this.classes) {
                if (sizeCLass.getId() == id) {
                    this.setBaseClass(sizeCLass);
                    return;
                }
            }
        }
        getBaseClass() {
            return this.baseClass;
        }
        addSizeClasses(sizeCLasses) {
            for (let sizeCLass of sizeCLasses) {
                this.classes.push(sizeCLass);
            }
        }
        addSizeClass(sizeCLass) {
            this.classes.push(sizeCLass);
        }
        getSizeClasses() {
            return this.classes;
        }
        changeForSize(width, height) {
            if (width < this.baseClass.getWidth()) {
                this.currentSizeClass = this.findBiggestClass(width);
            }
            if (width > this.baseClass.getWidth()) {
                this.currentSizeClass = this.findSmallestClass(width);
            }
        }
        findBiggestClass(width) {
            var modulo = width % this.baseClass.getWidth();
            var runningClassObj = this.baseClass;
            for (var i in this.classes) {
                var classObj = this.classes[i];
                if (classObj.getWidth() > this.baseClass.getWidth()) {
                    continue;
                }
                if (classObj.getWidth() == width) {
                    return classObj;
                }
                if (width < classObj.getWidth() && width % classObj.getWidth() > modulo) {
                    runningClassObj = classObj;
                }
            }
            return runningClassObj;
        }
        findSmallestClass(width) {
            var baseClassDifference = width - this.baseClass.getWidth();
            var runningClassObj = this.baseClass;
            for (var i in this.classes) {
                var classObj = this.classes[i];
                if (classObj.getWidth() < this.baseClass.getWidth()) {
                    continue;
                }
                if (classObj.getWidth() == width) {
                    return classObj;
                }
                var currentClassDifference = width - classObj.getWidth();
                if (width > classObj.getWidth() && currentClassDifference < baseClassDifference) {
                    runningClassObj = classObj;
                }
            }
            return runningClassObj;
        }
        getName() {
            return this.name;
        }
        setName(name) {
            this.name = name;
        }
        getSizeClass() {
            return this.currentSizeClass || this.baseClass;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    SizeCatalog.classname = "seven.SizeCatalog";
    seven.SizeCatalog = SizeCatalog;
    class SizeLoadOption {
        getClassName() { return SizeLoadOption.classname; }
        //AutoGeneratedClassName-end - do not eidt this line
        isMobileDevice() {
            if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
                return true;
            }
            return false;
        }
        isDesktop() {
            if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
                return false;
            }
            return true;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    SizeLoadOption.classname = "seven.SizeLoadOption";
    seven.SizeLoadOption = SizeLoadOption;
    class SizeNotifier {
        /* private */ constructor() {
            this.observers = {};
        }
        getClassName() { return SizeNotifier.classname; }
        static notifier() {
            if (SizeNotifier._notifier == undefined) {
                SizeNotifier._notifier = new SizeNotifier();
            }
            return SizeNotifier._notifier;
        }
        addResizeHandler(handler) {
            if (this.observers[SizeNotifyOptions.SIZE_CLASS_CHANGE] == undefined) {
                this.observers[SizeNotifyOptions.SIZE_CLASS_CHANGE] = new Array();
            }
            var observerArray = this.observers[SizeNotifyOptions.SIZE_CLASS_CHANGE];
            var found = false;
            for (let everyObserver of observerArray) {
                if (everyObserver == handler) {
                    found = true;
                }
            }
            if (found == false) {
                observerArray.push(handler);
            }
            this.observers[SizeNotifyOptions.SIZE_CLASS_CHANGE] = observerArray;
        }
        postSizeClassChange(fromClass, toClass) {
            seven.Objects.requireNonNull("", fromClass);
            seven.Objects.requireNonNull("", toClass);
            for (var counter in this.observers[SizeNotifyOptions.SIZE_CLASS_CHANGE]) {
                var handler = this.observers[SizeNotifyOptions.SIZE_CLASS_CHANGE][counter];
                //call the observer method with userInfo 
                handler.handleSizeClassChange(fromClass, toClass);
            }
        }
        removeSizeClassChangeHandler(observerThis) {
            for (var counter in this.observers[SizeNotifyOptions.SIZE_CLASS_CHANGE]) {
                var observer = this.observers[SizeNotifyOptions.SIZE_CLASS_CHANGE][counter];
                //call the observer method with userInfo 
                if (observer.thisRef == observerThis) {
                    delete this.observers[SizeNotifyOptions.SIZE_CLASS_CHANGE][counter];
                }
            }
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    SizeNotifier.classname = "seven.SizeNotifier";
    seven.SizeNotifier = SizeNotifier;
    let SizeNotifyOptions;
    (function (SizeNotifyOptions) {
        SizeNotifyOptions[SizeNotifyOptions["NONE"] = 0] = "NONE";
        SizeNotifyOptions[SizeNotifyOptions["SIZE_CLASS_CHANGE"] = 1] = "SIZE_CLASS_CHANGE";
    })(SizeNotifyOptions || (SizeNotifyOptions = {}));
    class Timer {
        constructor() {
            //AutoGeneratedClassName-end - do not eidt this line
            this.timeoutTimer = undefined;
        }
        getClassName() { return Timer.classname; }
        timeout(time, callback) {
            this.timeoutCallback = callback;
            this.stop();
            var that = this;
            this.timeoutTimer = setTimeout(function () {
                that.timeoutCalled();
            }, time);
        }
        timeoutCalled() {
            console.log("called");
            this.stop();
            this.timeoutCallback.call();
        }
        interval(time, cllback) { }
        stop() {
            clearTimeout(this.timeoutTimer);
            this.timeoutTimer = undefined;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    Timer.classname = "seven.Timer";
    seven.Timer = Timer;
    class UserAgent {
        getClassName() { return UserAgent.classname; }
        static userAgent() {
            if (UserAgent._instance == undefined) {
                UserAgent._instance = new seven.ClassLoader();
            }
            return UserAgent._instance;
        }
        hasTouchScreen() {
            return (('ontouchstart' in window) || (navigator.msMaxTouchPoints > 0));
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    UserAgent.classname = "seven.UserAgent";
    seven.UserAgent = UserAgent;
    class UserInfo {
        getClassName() { return UserInfo.classname; }
        //AutoGeneratedClassName-end - do not eidt this line
        static clientInfo() {
            return new seven.SizeLoadOption();
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    UserInfo.classname = "seven.UserInfo";
    seven.UserInfo = UserInfo;
    class ViewUtility {
        //AutoGeneratedClassName-end - do not eidt this line
        constructor() {
        }
        getClassName() { return ViewUtility.classname; }
        static randomColor() {
            return '#' + this.hex(this.rg(1, 10)) + this.hex(this.rg(1, 10)) + this.hex(this.rg(1, 15)) +
                this.hex(this.rg(1, 15)) + this.hex(this.rg(1, 15)) + this.hex(this.rg(1, 15));
        }
        static rg(m, n) {
            return Math.floor(Math.random() * (n - m + 1)) + m;
        }
        static hex(i) {
            return i.toString(16);
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    ViewUtility.classname = "seven.ViewUtility";
    seven.ViewUtility = ViewUtility;
//{INSERTORDER:2}
    class AbstractViewController extends seven.JBObject {
        constructor() {
            super();
            this.childViewController = new Array();
            this.parentViewController = undefined;
        }
        getClassName() { return AbstractViewController.classname; }
        addChildViewController(viewController) {
            viewController.setParentViewController(this);
            this.childViewController.push(viewController);
        }
        setParentViewController(viewController) {
            this.parentViewController = viewController;
        }
        setView(view) {
            this.view = view;
        }
        dragStart(orgin, view) {
            return view;
        }
        dragHasMoved(orgin, view) {
            if (this.parentViewController != undefined) {
                this.parentViewController.dragHasMoved(orgin, view);
            }
        }
        dragHasEnded(orgin, view) {
            if (this.parentViewController != undefined) {
                return this.parentViewController.dragHasEnded(orgin, view);
            }
            return false;
        }
        dragHasLeft() {
            if (this.parentViewController != undefined) {
                this.parentViewController.dragHasLeft();
            }
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    AbstractViewController.classname = "seven.AbstractViewController";
    seven.AbstractViewController = AbstractViewController;
//{INSERTORDER:2}
    class JBDocument extends seven.JBObject {
        constructor() {
            super();
            this.windows = new Array();
        }
        getClassName() { return JBDocument.classname; }
        /**@returns the shared document singleton */
        static document() {
            if (JBDocument._instance == undefined) {
                JBDocument._instance = new JBDocument();
                JBDocument._instance.documentController = new seven.DocumentController();
                JBDocument._instance.documentController.view = new seven.DocumentView();
                JBDocument._instance.doucmentView = JBDocument._instance.documentController.view;
            }
            return JBDocument._instance;
        }
        /**
        *
        * @param resizeManager resizeManager takes controll over resizing #BigSuprise usually u get this for free - your welcome
        * mostly it is defined in the {Global.ClassLoader} in the global space for the inital loader
        */
        setResizeManager(resizeManager) {
            this.resizeManager = resizeManager;
        }
        /**
        *
        * @returns resizeManager takes controll over resizing #BigSuprise usually u get this for free - your welcome
        * mostly it is defined in the {Global.ClassLoader} in the global space for the inital loader
        */
        getResizeManager() {
            return this.resizeManager;
        }
        /**
         *
         * @param sizeLoader handles the sizing - how many size classes and which one to use,i.e. ipadPortrait
         */
        setSizeLoader(sizeLoader) {
            this.sizeLoader = sizeLoader;
        }
        getSizeLoader() {
            return this.sizeLoader;
        }
        /**
         *
         * @param windowLoader the window loader is the instance that decides,which windows should be loaded
         * - this takes can only be handled by you - so provide a implementation to get started
         * mostly it is defined in the {Global.ClassLoader} in the global space for the inital loader
         */
        setWindowLoader(windowLoader) {
            this.windowLoader = windowLoader;
        }
        getWindowLoader() {
            return this.windowLoader;
        }
        hasWindowLoader() {
            if (this.windowLoader == undefined) {
                return false;
            }
            return true;
        }
        setRenderer(renderer) {
            this.renderer = renderer;
        }
        getRenderer() {
            return this.renderer;
        }
        hasRenderer() {
            if (this.renderer == undefined) {
                return false;
            }
            return true;
        }
        prepareLoading() {
            seven.Objects.requireNonNull("DocumentDelegate.setup() document must not be null", document);
            seven.Objects.requireNonNull("DocumentDelegate.windowLoader must not be null", this.windowLoader);
            seven.Objects.requireNonNull("DocumentDelegate.resizeManager must not be null", this.resizeManager);
            seven.Objects.requireNonNull("DocumentDelegate.sizeLoader must not be null", this.sizeLoader);
            seven.Objects.requireNonNull("DocumentDelegate.renderer must not be null", this.render);
            this.windowLoader.setup(this);
            this.resizeManager.setup(this);
        }
        load() {
            //@TODO - define options better userInfo (iPad,ScreenSize,...)
            this.sizeLoader.initWithOptions(seven.UserInfo.clientInfo());
            this.windowLoader.loadWindows(this.sizeLoader.getSizeClass());
        }
        startRendering() {
            this.render();
            this.resizeManager.startResizing();
        }
        /**
         *
         *this is needed to change the window loader (switch between pages)
         */
        reloadWindows() {
            JBDocument.document().getWindowLoader().loadWindows(this.sizeLoader.getSizeClass());
            this.render();
            this.resizeManager.startResizing();
        }
        setDocumentController(documentController) {
            this.documentController = documentController;
        }
        addSubWindow(window) {
            seven.Objects.requireNonNull("Document : Added window must not be null", window);
            this.windows.push(window);
            this.doucmentView.addSubview(window.view);
            if (window.getController() != undefined) {
                this.documentController.addChildViewController(window.getController());
            }
        }
        removeSubWindow(window) {
            for (var index in this.windows) {
                if (this.windows[index] == window) {
                    this.windows.splice(parseInt(index), 1);
                }
            }
        }
        getWindows() {
            return this.windows;
        }
        /**redraw the view - this is mainly to render the changes in the canvas views */
        render() {
            this.renderer.renderViewHierachy(this.doucmentView);
        }
        /**
        *                 |
        *  vetical   =    |
        *                 |
        * horizontal = -- -- --
        *
        * @argument value : the value in scale with the sizeclass
        *@returns the value in scale with the screen(actual displayed value)
        */
        verticalScreenValue(value, useBaseClass = true) {
            if (this.getResizeManager() == undefined || this.getResizeManager().hasSizeClass() == false) {
                return value;
            }
            return this.getResizeManager().verticalScreenValue(value, useBaseClass);
        }
        /**
         *                 |
         *   vetical  =    |
         *                 |
         * horizontal = -- -- --
         *
        * @argument value : the value in scale with the sizeclass
        *@returns the value in scale with the screen(actual displayed value)
        */
        horizontalScreenValue(value, useBaseClass = true) {
            if (this.getResizeManager() == undefined || this.getResizeManager().hasSizeClass() == false) {
                return value;
            }
            return this.getResizeManager().horizontalScreenValue(value, useBaseClass);
        }
        /**
         *                 |
         *   vetical  =    |
         *                 |
         * horizontal = -- -- --
         *
         * @argument value : the value in scale with the screen(actual displayed value)
         *@returns the value in scale with the sizeclass
         */
        verticalReferenceValue(value, useBaseClass = true) {
            if (this.getResizeManager() == undefined || this.getResizeManager().hasSizeClass() == false) {
                return value;
            }
            return this.getResizeManager().verticalReferenceValue(value, useBaseClass);
        }
        /**
         *                 |
         *   vetical  =    |
         *                 |
         * horizontal = -- -- --
         *
         * @argument value : the value in scale with the screen(actual displayed value)
         *@returns the value in scale with the sizeclass
         */
        horizontalReferenceValue(value, useBaseClass = true) {
            if (this.getResizeManager() == undefined || this.getResizeManager().hasSizeClass() == false) {
                return value;
            }
            return this.getResizeManager().horizontalReferenceValue(value, useBaseClass);
        }
        /*
            Callbacks from the Drag - Touchinterpreters
            will find the toppest view witch is dragable
            and notify its controller, that a dragStart
            @TODO - Maybe the wrong place for it here
        */
        dragStart(orgin) {
            /*  this.dragView = this.doucmentView.getViewForOrignAndOptions(orgin, (view: View): boolean => {
                  return view.dragable == true;
              });
              if(this.dragView != undefined){
                  this.dragView = this.dragView.getController().dragStart(orgin, this.dragView);
              }
          
              return this.dragView;*/
            return undefined;
        }
        /*
            Callbacks from the Drag - Touchinterpreters
            get the toppest view for the dragging position(finger location)
            and if a drag has stopped visiting a controllers region(draged over somewhere) --> notify that controller
            @TODO - Maybe the wrong place for it here
        */
        dragMove(orgin) {
            /* if (this.dragView == undefined) {
                 Logger.error("JBDocument.dragMove() - dragView should not be undefined here");
                 return;
             }
             var testView = this.doucmentView.getViewForOrignAndOptions(orgin, (view: View): boolean => {
                 return view.controller != undefined;
             });
     
             if (testView == undefined || testView.getController() == undefined) {
                 return;
             }
             var testViewController: AbstractViewController = testView.getController();
             if (this.currentDragReciever == undefined) {
                 this.currentDragReciever = testViewController;
             }
             if (testViewController != this.currentDragReciever) {
                 this.currentDragReciever.dragHasLeft();
                 this.currentDragReciever = testViewController;
             }
     
             testViewController.dragHasMoved(orgin, this.dragView);*/
        }
        /*
            Callbacks from the Drag - Touchinterpreters
            get the toppest view for the dragging position(finger location)
            that view's controller wins and gets to decide what to to with the view
            @TODO - Maybe the wrong place for it here
        */
        dragEnd(orgin) {
            /* var posiibleViews = new Array<View>();
             this.doucmentView.getViewsForOrgin(posiibleViews, orgin);
     
             for (let view of posiibleViews) {
                 if (view == undefined || view.getController() == undefined) {
                     continue;
                 }
                 var testViewController: AbstractViewController = view.getController();
                 if (testViewController.dragHasEnded(orgin, this.dragView)) {
                     break;
                 }
             }
             //reset them vars
             this.dragView = undefined;
             this.currentDragReciever = undefined;*/
        }
        /*
            Callbacks from the Scroll - Touchinterpreters
            get the toppest view that is scrollable and notify it that a scroll happend
            @TODO - Maybe the wrong place for it here
        */
        scrollMove(orgin, difference) {
            /* var scrollView = this.doucmentView.getViewForOrignAndOptions(orgin, (view: View): boolean => {
                 return view.scrollable == true;
             });
             if (scrollView == undefined) {
                 return;
             }
             scrollView.scroll(difference);
             this.render(); */
        }
        /*
            Callbacks from the Click-Gesture Sender
            get the toppest view that will react to the event
            @TODO - Maybe the wrong place for it here
        */
        tapRecieved(orgin, values) {
            /* var key = TapGestureCallback.keyOf(values);
             var gestureReciever = this.doucmentView.getViewForOrignAndOptions(orgin, (view: View): boolean => {
                 return view.hasGestureType(key);
             });
             if (gestureReciever != undefined) {
                 gestureReciever.fireGesture(key, values);
             }*/
        }
        /*
                Callbacks from the Click-Gesture Sender
                get the toppest view that will react to the event
                @TODO - Maybe the wrong place for it here
            */
        clickRecieved(orgin, values) {
            /* var key = ClickGestureCallback.keyOf(values);
             var gestureReciever = this.doucmentView.getViewForOrignAndOptions(orgin, (view: View): boolean => {
                 return view.hasGestureType(key);
             });
             if (gestureReciever != undefined) {
                 gestureReciever.fireGesture(key, values);
             }*/
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    JBDocument.classname = "seven.JBDocument";
    seven.JBDocument = JBDocument;
//{INSERTORDER:2}
    class GestureCallback extends seven.JBObject {
        constructor() {
            super();
        }
        getClassName() { return GestureCallback.classname; }
        initWithMethod(thisRef, method) {
            this.thisRef = thisRef;
            this.method = method;
            return this;
        }
        call(values) {
            this.method.call(this.thisRef);
        }
        getType() {
            return seven.GestureType.None;
        }
        getKey() {
            return "" + seven.GestureType.None;
        }
        copyAttributes(toObject) {
            super.copyAttributes(toObject);
            toObject.thisRef = this.thisRef;
            toObject.method = this.method;
        }
        copy() {
            var newObject = new GestureCallback();
            this.copyAttributes(newObject);
            return newObject;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    GestureCallback.classname = "seven.GestureCallback";
    seven.GestureCallback = GestureCallback;
//{INSERTORDER:2}
    class GestureConfiguration extends seven.JBObject {
        constructor() {
            super();
            //AutoGeneratedClassName-end - do not eidt this line
            // this shows how much the user can move the mouse from mouseDown to mouseUp
            // to be valid click
            // it this case it means 10 px
            this.mouseClickRange = new seven.Rect(-5, -5, 10, 10);
            // this shows how much the user can move his finger from touchStart till touchEnd
            // to be valid click
            // it this case it means 20 px
            this.screenClickRange = new seven.Rect(-20, -20, 40, 40);
            // if the next tap happens within this time it gets added to the tapCount
            // ie. tapCount=1 -> next tap within time -> tapCount=2
            // else it will be treated as a new tap(tapCount=1)
            this.tapRetouchTimeout = 300 /* ms*/;
            // if the mouse/touch is held down too long it is no longer a tap
            this.tapMaximumTouchDown = 500;
        }
        getClassName() { return GestureConfiguration.classname; }
        getMouseClickRange() {
            return this.mouseClickRange;
        }
        setMouseClickRange(range) {
            this.mouseClickRange = range;
        }
        getScreenClickRange() {
            return this.screenClickRange;
        }
        setScreenClickRange(range) {
            this.screenClickRange = range;
        }
        getTapRetouchTimeout() {
            return this.tapRetouchTimeout;
        }
        getTapMaximumTouchDowm() {
            return this.tapMaximumTouchDown;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    GestureConfiguration.classname = "seven.GestureConfiguration";
    seven.GestureConfiguration = GestureConfiguration;
//{INSERTORDER:2}
    class JBTouchEvent extends seven.JBObject {
        constructor() {
            super();
            //AutoGeneratedClassName-end - do not eidt this line
            this.orgin = seven.Orgin.empty();
            this.difference = seven.Orgin.empty();
            this.differenceFromStart = seven.Orgin.empty();
            this.dragging = false;
            this.elementId = "";
            this.dragging = false;
        }
        getClassName() { return JBTouchEvent.classname; }
        setOrgin(orgin) {
            this.orgin = orgin;
        }
        getOrgin() {
            return this.orgin.copy();
        }
        setDifference(difference) {
            this.difference = difference;
        }
        getDifference() {
            return this.difference.copy();
        }
        setDifferenceFromStart(differenceFromStart) {
            this.differenceFromStart = differenceFromStart;
        }
        getDifferenceFromStart() {
            return this.differenceFromStart.copy();
        }
        isDragging() {
            return this.dragging;
        }
        setDragging(dragging) {
            this.dragging = dragging;
        }
        copyAttributes(toObject) {
            toObject.orgin = this.orgin.copy();
            toObject.configuration = this.configuration;
            toObject.difference = this.difference.copy();
            toObject.differenceFromStart = this.differenceFromStart.copy();
            toObject.dragging = this.dragging;
            this.elementId = this.elementId;
        }
        copy() {
            var newObject = new JBTouchEvent();
            this.copyAttributes(newObject);
            return newObject;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    JBTouchEvent.classname = "seven.JBTouchEvent";
    seven.JBTouchEvent = JBTouchEvent;
//{INSERTORDER:2}
    class JMBMap extends seven.AbstractMap {
        constructor() {
            super();
        }
        containsKey(key) {
            return super.containsKey(key);
        }
        containsValue(value) {
            return super.containsValue(value);
        }
        get(object) {
            return super.get(object);
        }
        isEmpty() {
            return super.isEmpty();
        }
        put(key, value) {
            return super.put(key, value);
        }
        remove(key) {
            return super.remove(key);
        }
        size() {
            return super.size();
        }
        values() {
            return super.values();
        }
        keys() {
            return super.keys();
        }
    }
    seven.JMBMap = JMBMap;
//{INSERTORDER:2}
    class JMBWindow extends seven.JBObject {
        constructor() {
            super();
        }
        getClassName() { return JMBWindow.classname; }
        init(htmlId, controller = new seven.ViewController()) {
            this.htmlElementId = htmlId;
            this.htmlElement = document.getElementById(htmlId);
            this.controller = controller;
            Object.freeze(this.htmlElement);
            return this;
        }
        setupTouches() {
        }
        getController() {
            return this.controller;
        }
        hasMovedToWindowController(controller) {
            this.controller = controller;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    JMBWindow.classname = "seven.JMBWindow";
    seven.JMBWindow = JMBWindow;
/** @class Orgin
 *
 * defines a point in space using x and y corrdinates
 *
*/
    class Orgin extends seven.JBObject {
        constructor(x, y) {
            super();
            this.empty = true;
            this.x = x;
            this.y = y;
        }
        getClassName() { return Orgin.classname; }
        // empty is better that undefined 
        static empty() {
            var resultOrgin = new Orgin(0, 0);
            return resultOrgin;
        }
        /**
         *
         * @param srcOrgin the orgin which should be copied
         * @returns the copied orgin
         */
        static copyOrgin(srcOrgin) {
            var resultOrgin = new Orgin(0, 0);
            resultOrgin.x = srcOrgin.x;
            resultOrgin.y = srcOrgin.y;
            return resultOrgin;
        }
        /**
         * this method contains the difference between two Orgins
         * @param source the dominand orgin
         * @param counter the orgin which gets removed from source
         *@returns the source - counter
         */
        static difference(source, counter) {
            var result = new Orgin(0, 0);
            result.x = source.x - counter.x;
            result.y = source.y - counter.y;
            return result;
        }
        addOrgin(orgin) {
            if (orgin == undefined) {
                seven.Logger.develepor("Tried to add undefined orgin");
                return;
            }
            this.addX(orgin.x);
            this.addY(orgin.y);
        }
        removeOrgin(orgin) {
            if (orgin == undefined) {
                seven.Logger.develepor("Tried to remove undefined orgin");
                return this;
            }
            this.removeX(orgin.x);
            this.removeY(orgin.y);
            return this;
        }
        setX(x) {
            this.x = x;
        }
        setY(y) {
            this.y = y;
        }
        addX(x) {
            this.x = this.x + x;
        }
        addY(y) {
            this.y = this.y + y;
        }
        removeX(x) {
            this.x = this.x - x;
        }
        removeY(y) {
            this.y = this.y - y;
        }
        isEmpty() {
            return this.empty && this.x == 0 && this.x == 0;
        }
        setEmpty(empty) {
            this.empty = empty;
        }
        toString() {
            return "[x: " + this.x + " y: " + this.y + "]";
        }
        //@Override JBObject
        copyAttributes(toObject) {
            toObject.x = this.x;
            toObject.y = this.y;
        }
        //@Override JBObject
        copy() {
            var newOrgin = Orgin.copyOrgin(this);
            this.copyAttributes(newOrgin);
            return newOrgin;
        }
        toAbsolute() {
            this.x = Math.abs(this.x);
            this.y = Math.abs(this.y);
            return this;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    Orgin.classname = "seven.Orgin";
    seven.Orgin = Orgin;
    class ResourceManager extends seven.JBObject {
        constructor() {
            super();
            //AutoGeneratedClassName-end - do not eidt this line
            this.images = new seven.JMBMap();
            this.callbacks = new seven.JMBMap();
            this.loadImage = undefined;
        }
        getClassName() { return ResourceManager.classname; }
        static manager() {
            if (ResourceManager._instance == undefined) {
                ResourceManager._instance = new ResourceManager();
            }
            return ResourceManager._instance;
        }
        imageForSrc(src, callback) {
            if (src == undefined) {
                return;
            }
            if (this.images.containsKey(src) == true) {
                return this.images.get(src);
            }
            this.callbacks.put(src, callback);
            if (this.loadImage != undefined) {
                return;
            }
            this.loadNextImage();
        }
        loadNextImage() {
            if (this.callbacks.keys().length == 0) {
                return;
            }
            var imageSrc = this.callbacks.keys()[0];
            this.loadImage = new Image();
            this.loadImage.src = imageSrc;
            this.loadImage.onload = (ev) => {
                this.imageLoaded();
            };
        }
        imageLoaded() {
            if (this.callbacks.keys().length == 0) {
                return;
            }
            var imageSrc = this.callbacks.keys()[0];
            var callback = this.callbacks.get(imageSrc);
            this.callbacks.remove(imageSrc);
            var imageClone = this.loadImage.cloneNode(true);
            imageClone.onload = undefined;
            this.images.put(imageSrc, imageClone);
            callback.call(imageClone);
            if (this.callbacks.keys().length > 0) {
                this.loadNextImage();
                return;
            }
            this.loadImage = undefined;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    ResourceManager.classname = "seven.ResourceManager";
    seven.ResourceManager = ResourceManager;
//{INSERTORDER:2}
    class TouchIntepreter extends seven.JBObject {
        constructor() {
            super();
        }
        getClassName() { return TouchIntepreter.classname; }
        setDelegate(delegate) {
            this.delegate = delegate;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    TouchIntepreter.classname = "seven.TouchIntepreter";
    seven.TouchIntepreter = TouchIntepreter;
//{INSERTORDER:3}
    class TouchSender extends seven.JBObject {
        constructor() {
            super();
            this.eventReciever = new seven.JMBMap();
        }
        getClassName() { return TouchSender.classname; }
        setConfiguration(configuration) {
            this.configuration = configuration;
        }
        setTouchReciever(touchReciever) {
            this.touchReciever = touchReciever;
        }
        addEventReciever(eventReciever) {
            this.eventReciever.put(eventReciever.getClassName(), eventReciever);
        }
        removeEventReciever(eventReciever) {
            this.eventReciever.remove(eventReciever.getClassName());
        }
        initEvents() {
        }
        getUserInfo(event) {
            return { "x": "0", "y": "0" };
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    TouchSender.classname = "seven.TouchSender";
    seven.TouchSender = TouchSender;
//{INSERTORDER:2}
    class View extends seven.JBObject {
        //  protected viewExtentions: Array<IViewDrawable> = new Array<IViewDrawable>();
        constructor() {
            super();
            this.frame = seven.Rect.empty();
            this.bounds = seven.Rect.empty();
            this.viewId = "";
            this.gestureActions = new seven.JMBMap();
            this.style = new seven.DefaultStyleProvider();
            this.subViews = new Array();
        }
        getClassName() { return View.classname; }
        /**
         * @param frame the frame which the view should get
         */
        initWitFrame(frame) {
            this.frame = seven.Rect.copyRect(frame);
            return this;
        }
        /**
        * @param key a vaid size-key
        */
        initWithViewId(id) {
            this.viewId = id;
            return this;
        }
        remove() {
            if (this.superView) {
                this.superView.removeSubView(this);
            }
            this.superView = undefined;
        }
        removeSubView(subView) {
            for (var index in this.subViews) {
                if (this.subViews[index] == subView) {
                    this.subViews.splice(parseInt(index), 1);
                }
            }
        }
        addSubview(view) {
            if (view.superView != undefined) {
                view.superView.removeSubView(view);
            }
            this.subViews.push(view);
            view.setSuperView(this);
        }
        setStyleProvider(styleProvider) {
            this.style = styleProvider;
        }
        setSuperView(view) {
            this.superView = view;
        }
        //@override
        drawInRect(rect) { }
        drawSubViews(rect) {
            var subViewRect = seven.Rect.copyRect(rect);
            this.subViews.forEach(element => {
                element.drawSubViews(subViewRect);
            });
        }
        addGestureCallback(callback) {
            if (callback.getType() == seven.GestureType.None) {
                seven.Logger.error("view - addGestureCallback gesture txpe must not be null");
            }
            this.gestureActions.put(callback.getKey(), callback);
        }
        getSubViews() {
            var views = new Array();
            for (let view of this.subViews) {
                views.push(view);
            }
            return views;
        }
        createHtmlContainer(id) {
            throw new Error("this method should be overwritten");
        }
        hasGestureType(needle) {
            for (let gestureType of this.gestureActions.keys()) {
                if (gestureType == needle) {
                    return true;
                }
            }
            return false;
        }
        fireGesture(key, values) {
            if (this.gestureActions.containsKey(key) == false || this.gestureActions.get(key) == undefined) {
                seven.Logger.error("view.fireGesture() - gesture not found");
            }
            var gestureAction = this.gestureActions.get(key);
            gestureAction.call(values);
        }
        //@Override JBObject
        copyAttributes(toObject) {
            super.copyAttributes(toObject);
            toObject.superView = this.superView;
            for (let gesture of this.gestureActions.values()) {
                toObject.gestureActions.put(gesture.getKey(), gesture.copy());
            }
            toObject.tag = this.tag;
        }
        //@Override - JBObject 
        copy() {
            throw new Error("can't create abstract object");
        }
        scroll(diff) {
            seven.Logger.develepor("view - scrol() called and not taken");
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    View.classname = "seven.View";
    seven.View = View;
//{INSERTORDER:3}
/**
 * A canvasView represents no html element
 * all canvasViews get drawn on a containing html-canvas
 * whens its time to render it gets the htmlCanvas from the containing HtmlCanvas
 *
*/
    class CanvasView extends seven.View {
        constructor() {
            super();
        }
        getClassName() { return CanvasView.classname; }
        initWitFrame(frame) {
            super.initWitFrame(frame);
            return this;
        }
        /**
         *
         * @param id an html id
         * @param opacity the opacity with wich the container should be inited
         */
        createHtmlContainer(id, opacity) {
            var canvasContainer = document.createElement("CANVAS");
            canvasContainer.id = id;
            canvasContainer.style.zIndex = "10";
            canvasContainer.style.position = "fixed";
            canvasContainer.style.opacity = opacity != undefined ? opacity : "0.8";
            document.body.appendChild(canvasContainer);
            var htmlCanavsView = new seven.HtmlCanvasView(id);
            return htmlCanavsView;
        }
        // returns the context of the HtmlCanvas
        getContext() {
            if (this.context) {
                return this.context;
            }
            if (this.superView) {
                return this.superView.getContext();
            }
        }
        /**
         * adds an extention to the view(border)
         * @param extention a valid extention
         
        addViewExtention(extention:ICanvasDrawable) {
            this.viewExtentions.push(extention);
        }
        */
        //@override
        drawInRect(rect) {
            if (this.style.isHidden() == true) {
                return;
            }
            if (rect.x() < 0) {
                var diff = rect.x();
                rect.setX(rect.x() - diff);
                rect.setWidth(rect.width() + diff);
            }
            if (rect.y() < 0) {
                var diff = rect.y();
                rect.setY(rect.y() - diff);
                rect.setHeight(rect.height() + diff);
            }
            if (this.style.getBackGroundColor() == undefined) {
                this.style.setBackgroundColor("white"); //ViewUtility.randomColor();
            }
            if (this.style.getStrokeColor()) {
                this.getContext().strokeStyle = "" + this.style.getStrokeColor();
                this.getContext().strokeRect(rect.x(), rect.y(), rect.width(), rect.height());
            }
            this.drawBackground(rect);
            this.drawInRect(rect);
            this.drawSubViews(rect);
            this.drawViewExtentions(rect);
            this.drawDebug();
        }
        drawBackground(drawRect) {
            this.getContext().fillStyle = "" + this.style.getBackGroundColor();
            this.getContext().fillRect(drawRect.x(), drawRect.y(), drawRect.width(), drawRect.height());
            this.getContext().fillStyle = "black";
        }
        drawViewExtentions(rect) {
            /*  for (let extention of this.viewExtentions) {
                  extention.drawInContext(this.getContext(), rect);
              }
              if (this.additionalDrawing) {
                  this.additionalDrawing.call(this, this.getContext(), rect);
              }*/
            // this.getContext().fillText(rect.toString(),rect.x(),rect.y()+10);
        }
        drawDebug() {
            //  this.getContext().fillText(rect.toString(),rect.x(),rect.y()+10);
        }
        //@Override View
        copyAttributes(toObject) {
            super.copyAttributes(toObject);
            toObject.superView = this.superView;
            toObject.context = this.context;
        }
        //@Override - View 
        copy() {
            var newPrototypeTableCell = new CanvasView();
            this.copyAttributes(newPrototypeTableCell);
            return newPrototypeTableCell;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    CanvasView.classname = "seven.CanvasView";
    seven.CanvasView = CanvasView;
//{INSERTORDER:3}
    class DocumentController extends seven.AbstractViewController {
        constructor() {
            super();
        }
        getClassName() { return DocumentController.classname; }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    DocumentController.classname = "seven.DocumentController";
    seven.DocumentController = DocumentController;
//{INSERTORDER:3}
/**
 * the view of the JBDocument
 * all windowViews are attached to here
*/
    class DocumentView extends seven.View {
        //AutoGeneratedClassName-end - do not eidt this line
        constructor() {
            super();
        }
        getClassName() { return DocumentView.classname; }
        get rect() {
            return this.frame;
        }
        getZIndex() {
            return 0;
        }
        //@override
        draw() {
            throw new Error("this view cannot be drawn. this should only be used for sizing the subviews");
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    DocumentView.classname = "seven.DocumentView";
    seven.DocumentView = DocumentView;
//{INSERTORDER:4}
    class KeyboardSender extends seven.TouchSender {
        constructor() {
            super(...arguments);
            this.acceleration = 1.0;
        }
        getClassName() { return KeyboardSender.classname; }
        /**
         * This gives the instance, which was loaded by the Classloader
         * You can use this to access this instance afterwoulds-or don't, you decide
        */
        static loadedInstance() {
            var loadedInstance = seven.ClassLoader.manager().getLoadedInstance(KeyboardSender.classname);
            if (loadedInstance != undefined) {
                return loadedInstance;
            }
            var keyboardSender = new KeyboardSender();
            seven.TouchManager.manager().keyboardSender = keyboardSender;
            keyboardSender.initEvents();
            return keyboardSender;
        }
        initEvents() {
            seven.Objects.requireNonNull("MouseTouchSender.reciever must not be null", this.touchReciever);
            var that = this;
            document.onkeydown = (event) => {
                that.keyDown.call(that, event);
            };
            document.onkeyup = (event) => {
                that.keyUp.call(that, event);
            };
            document.onkeypress = (event) => {
                that.keyPress.call(that, event);
            };
        }
        getConfiguration() {
            return this.configuration;
        }
        keyDown(event) {
            this.sendKeyDown(event);
            //  clearInterval(this.timer);
            var that = this;
            //  this.timer = setInterval(function () {
            //     that.sendKeyDown(event);
            //  }, this.configuration.getKeyHoldMove());
        }
        sendKeyDown(event) {
            var userInfo = this.getUserInfo(event);
            var touchEvent = this.keyDownRecieved(userInfo);
            if (touchEvent == undefined) {
                return;
            }
            for (let entry of this.eventReciever.values()) {
                entry.keyDown(event, touchEvent);
            }
            this.touchReciever.touchMoved(touchEvent);
        }
        keyUp(event) {
            this.acceleration = 1.0;
        }
        keyPress(event) {
        }
        getUserInfo(event) {
            return { "key": event.key };
        }
        keyDownRecieved(userInfo) {
            this.acceleration += 0.2;
            var difference = this.differenceForKey(userInfo.key);
            if (difference == undefined) {
                return undefined;
            }
            var touchEvent = new seven.JBTouchEvent();
            touchEvent.setDifference(difference);
            return touchEvent;
        }
        differenceForKey(key) {
            var move = 10 * this.acceleration;
            if (key == "ArrowLeft") {
                //left
                return new seven.Orgin(move, 0);
            }
            if (key == "ArrowUp") {
                //up
                return new seven.Orgin(0, move);
            }
            if (key == "ArrowRight") {
                //right
                return new seven.Orgin(-move, 0);
            }
            if (key == "ArrowDown") {
                //down
                return new seven.Orgin(0, -move);
            }
            return undefined;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    KeyboardSender.classname = "seven.KeyboardSender";
    seven.KeyboardSender = KeyboardSender;
//{INSERTORDER:4}
    class MouseSender extends seven.TouchSender {
        constructor() {
            super();
            this.orgin = seven.Orgin.empty();
            this.mousePressedDown = false;
            this.startOrgin = seven.Orgin.empty();
        }
        getClassName() { return MouseSender.classname; }
        /**
         * This gives the instance, which was loaded by the Classloader
         * You can use this to access this instance afterwoulds-or don't, you decide
        */
        static loadedInstance() {
            var loadedInstance = seven.ClassLoader.manager().getLoadedInstance(MouseSender.classname);
            if (loadedInstance != undefined) {
                return loadedInstance;
            }
            var mouseSender = new MouseSender();
            seven.TouchManager.manager().mouseSender = mouseSender;
            mouseSender.initEvents();
            return mouseSender;
        }
        getConfiguration() {
            return this.configuration;
        }
        initEvents() {
            seven.Objects.requireNonNull("MouseTouchSender.touchReciever must not be null", this.touchReciever);
            document.onmousedown = (event) => {
                this.mousedown.call(this, event);
            };
            document.onmousemove = (event) => {
                this.mousemove.call(this, event);
            };
            document.onmouseup = (event) => {
                this.mouseup.call(this, event);
            };
            document.onmouseout = (event) => {
                this.mouseout.call(this, event);
            };
            document.onwheel = (event) => {
                event.preventDefault();
                //console.log(event.deltaX);
                this.wheel(event);
            };
        }
        mousePressed() {
            this.mousePressedDown = true;
        }
        //@override TouchSender
        getUserInfo(event) {
            var userInfo = { "x": event.clientX, "y": event.clientY };
            return userInfo;
        }
        /* Callback functions for Events */
        mousedown(event) {
            this.time = window.setTimeout(() => {
                this.mousePressed();
            }, 100);
            var userInfo = this.getUserInfo(event);
            var touchEvent = this.mouseDownRecievedTouchEvent(userInfo);
            for (let entry of this.eventReciever.values()) {
                entry.mousedown(event, touchEvent);
            }
            this.touchReciever.touchBegan(touchEvent);
        }
        mousemove(event) {
            var userInfo = this.getUserInfo(event);
            var touchEvent = this.mouseMoveRecievedTouchEvent(userInfo);
            for (let entry of this.eventReciever.values()) {
                entry.mousemove(event, touchEvent);
            }
            this.touchReciever.touchMoved(touchEvent);
        }
        mouseup(event) {
            window.clearTimeout(this.time);
            var userInfo = this.getUserInfo(event);
            var touchEvent = this.mouseUpRecievedTouchEvent(userInfo);
            for (let entry of this.eventReciever.values()) {
                entry.mouseup(event, touchEvent);
            }
            this.touchReciever.touchEnded(touchEvent);
            this.resetState();
        }
        wheel(event) {
            //console.log(event.wheelDeltaX + " " + event.wheelDeltaY);
            for (let entry of this.eventReciever.values()) {
                if (typeof entry.mousewheel != "function") {
                    continue;
                }
                entry.mousewheel(event);
            }
        }
        mouseout(event) {
            if (event.fromElement != event.toElement) {
                return;
            }
            var userInfo = this.getUserInfo(event);
            var touchEvent = this.mouseOutRecievedTouchEvent(userInfo);
            for (let entry of this.eventReciever.values()) {
                entry.mouseout(event, touchEvent);
            }
            this.touchReciever.touchCanceled(touchEvent);
            this.resetState();
        }
        /* Proccessing events for touch reciever  */
        mouseDownRecievedTouchEvent(userInfo) {
            this.orgin = new seven.Orgin(userInfo.x, userInfo.y);
            this.startOrgin = new seven.Orgin(userInfo.x, userInfo.y);
            var mouseOrgin = new seven.Orgin(userInfo.x, userInfo.y);
            var touchEvent = new seven.JBTouchEvent();
            touchEvent.setDragging(false);
            touchEvent.setOrgin(mouseOrgin);
            touchEvent.setDifference(seven.Orgin.difference(mouseOrgin, this.orgin));
            touchEvent.setDifferenceFromStart(new seven.Orgin(0, 0));
            return touchEvent;
        }
        mouseMoveRecievedTouchEvent(userInfo) {
            var touchEvent = new seven.JBTouchEvent();
            var mouseOrgin = new seven.Orgin(userInfo.x, userInfo.y);
            if (this.orgin.isEmpty() == true) {
                this.orgin = mouseOrgin;
            }
            if (this.mousePressedDown == true) {
                touchEvent.setDragging(true);
            }
            touchEvent.setOrgin(mouseOrgin);
            touchEvent.setDifference(seven.Orgin.difference(mouseOrgin, this.orgin));
            touchEvent.setDifferenceFromStart(seven.Orgin.difference(mouseOrgin, this.startOrgin));
            this.orgin = seven.Orgin.copyOrgin(mouseOrgin);
            return touchEvent;
        }
        mouseUpRecievedTouchEvent(userInfo) {
            var touchEvent = new seven.JBTouchEvent();
            var mouseOrgin = new seven.Orgin(userInfo.x, userInfo.y);
            touchEvent.setDragging(false);
            touchEvent.setOrgin(mouseOrgin);
            touchEvent.setDifference(seven.Orgin.difference(mouseOrgin, this.orgin));
            touchEvent.setDifferenceFromStart(seven.Orgin.difference(mouseOrgin, this.startOrgin));
            return touchEvent;
        }
        mouseOutRecievedTouchEvent(userInfo) {
            var touchEvent = new seven.JBTouchEvent();
            var mouseOrgin = new seven.Orgin(userInfo.x, userInfo.y);
            touchEvent.setDragging(false);
            touchEvent.setOrgin(mouseOrgin);
            touchEvent.setDifference(seven.Orgin.difference(mouseOrgin, this.orgin));
            return touchEvent;
        }
        resetState() {
            this.orgin = seven.Orgin.empty();
            this.startOrgin = seven.Orgin.empty();
            this.mousePressedDown = false;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    MouseSender.classname = "seven.MouseSender";
    seven.MouseSender = MouseSender;
//{INSERTORDER:2}
/**
 * @class represents a Rectangle in 2d - space
 *
 */
    class Rect extends seven.JBObject {
        constructor(x, y, width, height) {
            super();
            this.xPosition = x;
            this.yPosition = y;
            this.widthSize = width;
            this.heightSize = height;
        }
        getClassName() { return Rect.classname; }
        /**
         *
         * @param object a valid rect object
         * @returns a rect from the object
         */
        static fromObject(object) {
            var newRect = new Rect(0, 0, 0, 0);
            newRect.setX(parseInt(object.x));
            newRect.setY(parseInt(object.y));
            newRect.setWidth(parseInt(object.width));
            newRect.setHeight(parseInt(object.height));
            return newRect;
        }
        static empty() {
            return new Rect(0, 0, 0, 0);
        }
        static copyRect(inputRect) {
            return new Rect(inputRect.x(), inputRect.y(), inputRect.width(), inputRect.height());
        }
        static difference(inputRect, counterRect) {
            var resultRect = new Rect(0, 0, 0, 0);
            resultRect.setX(inputRect.x() - counterRect.x());
            resultRect.setY(inputRect.y() - counterRect.y());
            resultRect.setWidth(inputRect.width() - counterRect.width());
            resultRect.setHeight(inputRect.height() - counterRect.height());
            return resultRect;
        }
        static merge(oneRect, anotherRect) {
            var resultRect = new Rect(0, 0, 0, 0);
            resultRect.setX(oneRect.x() + anotherRect.x());
            resultRect.setY(oneRect.y() + anotherRect.y());
            resultRect.setWidth(oneRect.width() + anotherRect.width());
            resultRect.setHeight(oneRect.height() + anotherRect.height());
            return resultRect;
        }
        get xPosition() {
            return this._xPosition;
        }
        set xPosition(value) {
            this._xPosition = parseInt("" + value);
        }
        get yPosition() {
            return this._yPosition;
        }
        set yPosition(value) {
            this._yPosition = parseInt("" + value);
        }
        get widthSize() {
            return this._widthSize;
        }
        set widthSize(value) {
            this._widthSize = parseInt("" + value);
        }
        get heightSize() {
            return this._heightSize;
        }
        set heightSize(value) {
            this._heightSize = parseInt("" + value);
        }
        equals(otherRect) {
            if (otherRect == undefined) {
                return false;
            }
            if (otherRect == this) {
                return true;
            }
            var rect = otherRect;
            if (rect.x() == this.x() && rect.y() == this.y() &&
                rect.width() == this.width() && rect.height() == this.height()) {
                return true;
            }
            return false;
        }
        isEmpty() {
            return this.xPosition == 0 && this.yPosition == 0 &&
                this.widthSize == 0 && this.heightSize == 0;
        }
        x() {
            return this.xPosition;
        }
        y() {
            return this.yPosition;
        }
        bottomLeft() {
            return this.yPosition + this.heightSize;
        }
        topRight() {
            return this.xPosition + this.widthSize;
        }
        width() {
            return this.widthSize;
        }
        height() {
            return this.heightSize;
        }
        setSizeChangeCallback(sizeChangeCallback) {
            this.sizeChangeCallback = sizeChangeCallback;
        }
        sizeChanged() {
            if (this.sizeChangeCallback != undefined) {
                this.sizeChangeCallback.call();
            }
        }
        removeRect(rect) {
            this.xPosition += rect.x();
            this.yPosition += rect.y();
            this.widthSize -= rect.width() * 2;
            this.heightSize -= rect.height() * 2;
            this.sizeChanged();
            return this;
        }
        remove(ammount) {
            this.xPosition -= ammount;
            this.yPosition -= ammount;
            this.widthSize -= ammount;
            this.heightSize -= ammount;
            this.sizeChanged();
            return this;
        }
        add(ammount) {
            this.xPosition += ammount;
            this.yPosition += ammount;
            this.widthSize += ammount;
            this.heightSize += ammount;
            this.sizeChanged();
        }
        setX(x) {
            this.xPosition = x;
            this.sizeChanged();
        }
        addX(x) {
            this.xPosition = this.xPosition + x;
            ;
            this.sizeChanged();
        }
        setY(y) {
            this.yPosition = parseInt("" + y);
            this.sizeChanged();
        }
        addY(y) {
            this.yPosition = this.yPosition + y;
            this.sizeChanged();
        }
        removeY(y) {
            this.yPosition = this.yPosition - y;
            this.sizeChanged();
        }
        setWidth(width) {
            this.widthSize = width;
            this.sizeChanged();
        }
        addWidth(width) {
            this.widthSize += width;
            this.sizeChanged();
        }
        removeWidth(width) {
            this.widthSize -= width;
            this.sizeChanged();
        }
        setHeight(height) {
            this.heightSize = height;
            this.sizeChanged();
        }
        addHeight(height) {
            this.heightSize = this.heightSize + height;
            this.sizeChanged();
        }
        removeHeight(height) {
            this.heightSize = this.heightSize - height;
            this.sizeChanged();
        }
        setOrgin(orgin) {
            this.xPosition = orgin.x;
            this.yPosition = orgin.y;
            this.sizeChanged();
        }
        addOrgin(orgin) {
            this.addX(orgin.x);
            this.addY(orgin.y);
        }
        size() {
            return new Rect(0, 0, this._widthSize, this._heightSize);
        }
        scaleBy(x, y, width, height) {
            return new Rect(this._xPosition * x, this._yPosition * y, this._widthSize * width, this._heightSize * height);
        }
        stepX() {
            this.xPosition = this.xPosition + this.widthSize;
            this.sizeChanged();
        }
        stepY() {
            this.yPosition = this.yPosition + this.heightSize;
            this.sizeChanged();
        }
        lazyContainsRect(otherRect, howLazyX, howLazyY) {
            if (howLazyX == undefined) {
                howLazyX = 0;
            }
            if (howLazyY == undefined) {
                howLazyY = 0;
            }
            if ((otherRect.topRight() + howLazyX) < this.x() || (otherRect.x() - howLazyX) > this.topRight()) {
                return false;
            }
            if ((otherRect.bottomLeft() + howLazyY) < this.y() || (otherRect.y() - howLazyY) > this.bottomLeft()) {
                return false;
            }
            return true;
        }
        containsRect(otherRect) {
            var contains = this.containsX(otherRect.x()) && this.containsY(otherRect.y()) &&
                this.containsTopRight(otherRect.topRight()) && this.containsBottomLeft(otherRect.bottomLeft());
            return contains;
        }
        containsOrgin(orgin) {
            var contains = this.containsX(orgin.x) && this.containsY(orgin.y);
            return contains;
        }
        containsX(x) {
            return this.xPosition <= x && x <= this.topRight();
        }
        containsY(y) {
            return this.yPosition <= y && y <= this.bottomLeft();
        }
        containsTopRight(topRight) {
            return topRight <= this.topRight();
        }
        containsBottomLeft(bottomLeft) {
            return bottomLeft <= this.topRight();
        }
        orgin() {
            return new seven.Orgin(this.xPosition, this.yPosition);
        }
        toJSON() {
            return '{"x": "' + this.x() + '", "y": "' + this.y() + '", "width": "' + this.width() + '", "height": "' + this.height() + '"}';
        }
        toString() {
            return "[x: " + this.x() + " y: " + this.y() + " width: " + this.width() + " height: " + this.height() + "]";
        }
        //@Override JBObject 
        copyAttributes(toObject) {
            toObject.xPosition = this.xPosition;
            toObject.yPosition = this.yPosition;
            toObject.widthSize = this.widthSize;
            toObject.heightSize = this.heightSize;
        }
        //@Override JBObject
        copy() {
            var newRect = Rect.copyRect(this);
            this.copyAttributes(newRect);
            return newRect;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    Rect.classname = "seven.Rect";
    seven.Rect = Rect;
    class TapGestureCallback extends seven.GestureCallback {
        constructor() {
            super();
            //AutoGeneratedClassName-end - do not eidt this line
            this.tapNumber = 0;
        }
        getClassName() { return TapGestureCallback.classname; }
        static keyOf(values) {
            TapGestureCallback.keyGenerator.tapNumber = values.get("tapCount");
            return TapGestureCallback.keyGenerator.getKey();
        }
        initWithMethod(thisRef, method) {
            throw new Error("TouchEvents::initWithMethod : bad init method ");
        }
        init(thisRef, tapNumber, method) {
            super.initWithMethod(thisRef, method);
            this.tapNumber = tapNumber;
            return this;
        }
        getKey() {
            return "" + seven.GestureType.Tap + "" + this.tapNumber;
        }
        getType() {
            return seven.GestureType.Tap;
        }
        copyAttributes(toObject) {
            super.copyAttributes(toObject);
        }
        copy() {
            var newObject = new TapGestureCallback();
            this.copyAttributes(newObject);
            return newObject;
        }
        call(values) {
            if (values.get("tapCount") == this.tapNumber) {
                this.method.call(this.thisRef);
            }
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    TapGestureCallback.classname = "seven.TapGestureCallback";
    TapGestureCallback.keyGenerator = new TapGestureCallback();
    seven.TapGestureCallback = TapGestureCallback;
//{INSERTORDER:2}
    class TouchInterpreterConfiguration extends seven.JBObject {
        //AutoGeneratedClassName-end - do not eidt this line
        constructor() {
            super();
        }
        getClassName() { return TouchInterpreterConfiguration.classname; }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    TouchInterpreterConfiguration.classname = "seven.TouchInterpreterConfiguration";
    seven.TouchInterpreterConfiguration = TouchInterpreterConfiguration;
//{INSERTORDER:4}
    class TouchManager extends seven.JBObject {
        constructor() {
            super();
            //reciever
            this.recievers = new Array();
        }
        getClassName() { return TouchManager.classname; }
        static manager() {
            if (TouchManager._instance == undefined) {
                TouchManager._instance = new TouchManager();
                TouchManager._instance.senderConfiguration = new seven.TouchSenderConfiguration();
                TouchManager._instance.interpreterConfiguration = new seven.TouchInterpreterConfiguration();
                TouchManager._instance.gestureConfiguration = new seven.GestureConfiguration();
            }
            return TouchManager._instance;
        }
        /**
         * This gives the instance, which was loaded by the Classloader
         * You can use this to access this instance afterwoulds-or don't, you decide
        */
        static loadedInstance() {
            return TouchManager.manager();
        }
        // sender 
        get keyboardSender() {
            return this._keyboardSender;
        }
        set keyboardSender(sender) {
            this._keyboardSender = sender;
            sender.touchReciever = this;
            sender.setConfiguration(this.senderConfiguration);
            // sender.addEventReciever(this.scrollIntepreter);
        }
        get mouseSender() {
            return this._mouseSender;
        }
        set mouseSender(sender) {
            this._mouseSender = sender;
            sender.touchReciever = this;
            sender.setConfiguration(this.senderConfiguration);
            //sender.addEventReciever(this.dragIntepreter);
            //sender.addEventReciever(this.tapGesture);
            //sender.addEventReciever(this.scrollIntepreter);
        }
        get screenSender() {
            return this._screenSender;
        }
        set screenSender(sender) {
            this._screenSender = sender;
            sender.touchReciever = this;
            sender.setConfiguration(this.senderConfiguration);
            // sender.addEventReciever(this.dragIntepreter);
            //sender.addEventReciever(this.tapGesture);
            //sender.addEventReciever(this.scrollIntepreter);
        }
        //interpreter
        get dragIntepreter() {
            return this._dragIntepreter;
        }
        set dragIntepreter(intepreter) {
            this._dragIntepreter = intepreter;
        }
        get scrollIntepreter() {
            return this._scrollInterpreter;
        }
        set scrollIntepreter(intepreter) {
            this._scrollInterpreter = intepreter;
        }
        //gesture
        get tapGesture() {
            return this._tapGesture;
        }
        set tapGesture(value) {
            this._tapGesture = value;
            this._tapGesture.setConfiguration(this.gestureConfiguration);
        }
        //reciever
        addTouchReciever(touchReciever) {
            this.recievers.push(touchReciever);
        }
        touchBegan(touchEvent) {
            for (let reciever of this.recievers) {
                reciever.touchBegan(touchEvent);
            }
        }
        touchMoved(touchEvent) {
            for (let reciever of this.recievers) {
                reciever.touchMoved(touchEvent);
            }
        }
        touchEnded(touchEvent) {
            for (let reciever of this.recievers) {
                reciever.touchEnded(touchEvent);
            }
        }
        touchCanceled(touchEvent) {
            for (let reciever of this.recievers) {
                reciever.touchCanceled(touchEvent);
            }
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    TouchManager.classname = "seven.TouchManager";
    seven.TouchManager = TouchManager;
seven.ClassLoader.manager().loadInstance(seven.TouchManager.classname);
//{INSERTORDER:3}
    class CanvasWindow extends seven.JMBWindow {
        constructor() {
            super();
        }
        getClassName() { return CanvasWindow.classname; }
        static new(canvasID, rect, controller = new seven.ViewController()) {
            return new CanvasWindow().initWithId(canvasID, rect, controller);
        }
        initWithId(htmlId, rect, controller) {
            super.init(htmlId, controller);
            this.controller.view = new seven.HtmlCanvasView(this.htmlElementId).initWitFrame(rect);
            this.view = this.controller.view;
            return this;
        }
        setupView() {
            this.view = new seven.HtmlCanvasView(this.htmlElementId);
        }
        remove() {
            this.view.remove();
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    CanvasWindow.classname = "seven.CanvasWindow";
    seven.CanvasWindow = CanvasWindow;
//{INSERTORDER:3}
    class ClickGestureCallback extends seven.GestureCallback {
        //AutoGeneratedClassName-end - do not eidt this line
        constructor() {
            super();
        }
        getClassName() { return ClickGestureCallback.classname; }
        static keyOf(values) {
            return ClickGestureCallback.keyGenerator.getKey();
        }
        getKey() {
            return "" + seven.GestureType.Click;
        }
        getType() {
            return seven.GestureType.Click;
        }
        copyAttributes(toObject) {
            super.copyAttributes(toObject);
        }
        copy() {
            var newObject = new ClickGestureCallback();
            this.copyAttributes(newObject);
            return newObject;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    ClickGestureCallback.classname = "seven.ClickGestureCallback";
    ClickGestureCallback.keyGenerator = new ClickGestureCallback();
    seven.ClickGestureCallback = ClickGestureCallback;
//{INSERTORDER:3}
/**
 * a wrapper for a div - htmlelement
 *
*/
    class HtmlElementView extends seven.View {
        /**
         *
         * @param canvasId the html-id of the canvas
         */
        constructor(elementId) {
            super();
            this.elementId = elementId;
            this.element = document.getElementById(elementId);
            Object.freeze(this.element);
            if (this.element) {
                seven.Logger.develepor("element already exists for Id : " + this.elementId);
                return;
            }
            this.element = document.createElement(this.getType());
            this.element.id = elementId;
            this.element.style.position = "fixed";
            this.element.style.display = "none";
            document.body.appendChild(this.element);
        }
        setSuperView(view) {
            super.setSuperView(view);
            this.element.style.display = "inline";
        }
        drawInRect(rect) {
            this.element.style.left = "" + rect.x() + "px";
            this.element.style.top = "" + rect.y() + "px";
            this.element.style.backgroundColor = this.style.getBackGroundColor();
            this.element.style.width = "" + rect.width() + "px";
            this.element.style.height = "" + rect.height() + "px";
        }
        remove() {
            super.remove();
            if (this.element && this.element.parentElement) {
                this.element.parentElement.removeChild(this.element);
            }
        }
        getType() {
            return "div";
        }
    }
    seven.HtmlElementView = HtmlElementView;
//{INSERTORDER:4}
    class ScreenSender extends seven.TouchSender {
        constructor() {
            super();
            this.orgin = seven.Orgin.empty();
            this.mousePressedDown = false;
            this.hasLongTouch = false;
            this.startOrgin = seven.Orgin.empty();
        }
        getClassName() { return ScreenSender.classname; }
        /**
         * This gives the instance, which was loaded by the Classloader
         * You can use this to access this instance afterwoulds-or don't, you decide
        */
        static loadedInstance() {
            var loadedInstance = seven.ClassLoader.manager().getLoadedInstance(ScreenSender.classname);
            if (loadedInstance != undefined) {
                return loadedInstance;
            }
            var screenSender = new ScreenSender();
            seven.TouchManager.manager().screenSender = screenSender;
            screenSender.initEvents();
            return screenSender;
        }
        getConfiguration() {
            return this.configuration;
        }
        addLongPressCallback(callBack) {
            this.longPressCallback = callBack;
        }
        initEvents() {
            seven.Objects.requireNonNull("ScreenTouchSender.touchreciever must not be null", this.touchReciever);
            var that = this;
            $(document).on("touchstart", function (event) {
                event.preventDefault();
                that.touchstart(event);
            });
            $(document).on("touchmove", function (event) {
                event.preventDefault();
                that.touchmove(event);
            });
            $(document).on("touchend", function (event) {
                event.preventDefault();
                that.touchend(event);
            });
            $(document).on("touchcancel", function (event) {
                event.preventDefault();
                that.touchcancel(event);
            });
        }
        //@override TouchSender
        getUserInfo(event) {
            return { "x": event.originalEvent.pageX, "y": event.originalEvent.pageY };
        }
        /* Callback functions for Events */
        touchstart(event) {
            var userInfo = this.getUserInfo(event);
            var touchEvent = this.touchStartRecievedTouchEvent(userInfo);
            for (let entry of this.eventReciever.values()) {
                entry.touchstart(event, touchEvent);
            }
            var that = this;
            this.longPressTimer = window.setTimeout(function () { that.haslongTouchTrue.call(that); }, this.getConfiguration().getScreenLongPressTime());
            this.touchReciever.touchBegan(touchEvent);
        }
        touchmove(event) {
            var userInfo = this.getUserInfo(event);
            var touchEvent = this.touchMovedReceivedTouchEvent(userInfo);
            for (let entry of this.eventReciever.values()) {
                entry.touchmove(event, touchEvent);
            }
            clearTimeout(this.longPressTimer);
            this.touchReciever.touchMoved(touchEvent);
        }
        touchend(event) {
            var userInfo = this.getUserInfo(event);
            var touchEvent = this.touchEndedRecievedTouchEvent(userInfo);
            for (let entry of this.eventReciever.values()) {
                entry.touchend(event, touchEvent);
            }
            this.touchReciever.touchEnded(touchEvent);
            this.resetState();
        }
        touchcancel(event) {
            var userInfo = this.getUserInfo(event);
            var touchEvent = this.touchCanceledRecievedTouchEvent(userInfo);
            for (let entry of this.eventReciever.values()) {
                entry.touchcancel(event, touchEvent);
            }
            this.touchReciever.touchCanceled(touchEvent);
            this.resetState();
        }
        /* Proccessing events for touch reciever  */
        touchStartRecievedTouchEvent(userInfo) {
            this.orgin = new seven.Orgin(userInfo.x, userInfo.y);
            this.startOrgin = new seven.Orgin(userInfo.x, userInfo.y);
            var touchOrgin = new seven.Orgin(userInfo.x, userInfo.y);
            var touchEvent = new seven.JBTouchEvent();
            touchEvent.setOrgin(touchOrgin);
            touchEvent.setDifference(seven.Orgin.difference(touchOrgin, this.orgin));
            return touchEvent;
        }
        touchMovedReceivedTouchEvent(userInfo) {
            var touchEvent = new seven.JBTouchEvent();
            var touchOrgin = new seven.Orgin(userInfo.x, userInfo.y);
            touchEvent.setDragging(this.hasLongTouch);
            touchEvent.setOrgin(touchOrgin);
            touchEvent.setDifference(seven.Orgin.difference(touchOrgin, this.orgin));
            touchEvent.setDifferenceFromStart(seven.Orgin.difference(touchOrgin, this.startOrgin));
            this.orgin = seven.Orgin.copyOrgin(touchOrgin);
            return touchEvent;
        }
        touchEndedRecievedTouchEvent(userInfo) {
            var touchEvent = new seven.JBTouchEvent();
            var touchOrgin = new seven.Orgin(userInfo.x, userInfo.y);
            touchEvent.setOrgin(touchOrgin);
            touchEvent.setDifference(seven.Orgin.difference(touchOrgin, this.orgin));
            touchEvent.setDifferenceFromStart(seven.Orgin.difference(touchOrgin, this.startOrgin));
            return touchEvent;
        }
        touchCanceledRecievedTouchEvent(userInfo) {
            var touchEvent = new seven.JBTouchEvent();
            var touchOrgin = new seven.Orgin(userInfo.x, userInfo.y);
            touchEvent.setOrgin(touchOrgin);
            touchEvent.setDifference(seven.Orgin.difference(touchOrgin, this.orgin));
            touchEvent.setDifferenceFromStart(seven.Orgin.difference(touchOrgin, this.startOrgin));
            return touchEvent;
        }
        haslongTouchTrue() {
            this.hasLongTouch = true;
            if (this.longPressCallback != undefined) {
                this.longPressCallback.call();
                this.longPressCallback = undefined;
            }
        }
        resetState() {
            this.orgin = new seven.Orgin(0, 0);
            this.hasLongTouch = false;
            this.longPressCallback = undefined;
            clearTimeout(this.longPressTimer);
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    ScreenSender.classname = "seven.ScreenSender";
    seven.ScreenSender = ScreenSender;
//{INSERTORDER:2}
    class SizeClass extends seven.JBObject {
        constructor(id, width, height, description) {
            super();
            this.description = "<>";
            this.id = id;
            this.width = width;
            this.height = height;
            this.description = description;
        }
        getClassName() { return SizeClass.classname; }
        static fromXML(xml) {
            var width = seven.Objects.requireNumber("SizeClass.fromXML : width was not defined/not a number", xml.attributes.getNamedItem("width").value);
            var height = seven.Objects.requireNumber("SizeClass.fromXML : hieght was not defined/not a number", xml.attributes.getNamedItem("height").value);
            var id = seven.Objects.requireNonNull("SizeClass.fromXML : id was not defined", xml.attributes.getNamedItem("id").value);
            var description = seven.Objects.orElse(xml.attributes.getNamedItem("description").value, "");
            return new SizeClass(id, width, height, description);
        }
        getId() {
            return this.id;
        }
        setWidth(width) {
            this.width = width;
        }
        getWidth() {
            return this.width;
        }
        setHeight(height) {
            this.height = height;
        }
        getHeight() {
            return this.height;
        }
        asRect() {
            return new seven.Rect(this.width, this.height, this.width, this.height);
        }
        getDescription() {
            return this.description;
        }
        setDescription(description) {
            this.description = description;
        }
        //@Override JBObject
        copyAttributes(toObject) {
            toObject.width = this.width;
            toObject.height = this.height;
            toObject.description = this.description;
        }
        //@Override JBObject
        copy() {
            var newSizeClass = new SizeClass(this.id, this.width, this.height);
            this.copyAttributes(newSizeClass);
            return newSizeClass;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    SizeClass.classname = "seven.SizeClass";
    seven.SizeClass = SizeClass;
//{INSERTORDER:3}
/**
 * this class represents a HTMLCanvas
 *  rendering means positing the htmlelement on the screen
 *
 */
    class HtmlCanvasView extends seven.HtmlElementView {
        /**
         *
         * @param canvasId the html-id of the canvas
         */
        constructor(canvasId) {
            super(canvasId);
            //AutoGeneratedClassName-end - do not eidt this line
            this.canavsRect = seven.Rect.empty();
            if (this.element) {
                if (this.element != undefined) {
                    this.context = this.element.getContext('2d');
                    Object.freeze(this.context);
                }
                return;
            }
        }
        getClassName() { return HtmlCanvasView.classname; }
        drawInRect(rect) {
            super.drawInRect(rect);
            this.canavsRect = seven.Rect.copyRect(rect);
            this.context.clearRect(0, 0, rect.width(), rect.height());
        }
        getContext() {
            return this.context;
        }
        remove() {
            super.remove();
        }
        addScreenOffset() {
            return this.canavsRect.orgin();
        }
        getType() {
            return "canvas";
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    HtmlCanvasView.classname = "seven.HtmlCanvasView";
    seven.HtmlCanvasView = HtmlCanvasView;
//{INSERTORDER:2}
    class TouchSenderConfiguration extends seven.JBObject {
        constructor() {
            super();
            //AutoGeneratedClassName-end - do not eidt this line
            this.keyHoldMove = 400;
            this.screenLongPressTime = 300;
            this.mouseLongPressTime = 100;
        }
        getClassName() { return TouchSenderConfiguration.classname; }
        getKeyHoldMove() {
            return this.keyHoldMove;
        }
        setKeyHoldMove(value) {
            this.keyHoldMove = value;
        }
        setScreenLongPressTime(longPressTime) {
            this.screenLongPressTime = longPressTime;
        }
        getScreenLongPressTime() {
            return this.screenLongPressTime;
        }
        setMouseLongPressTime(longPressTime) {
            this.mouseLongPressTime = longPressTime;
        }
        getMouseLongPressTime() {
            return this.mouseLongPressTime;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    TouchSenderConfiguration.classname = "seven.TouchSenderConfiguration";
    seven.TouchSenderConfiguration = TouchSenderConfiguration;
    class Gesture extends seven.JBObject {
        constructor() {
            super();
        }
        getClassName() { return Gesture.classname; }
        setDelegate(delegate) {
            this.delegate = delegate;
        }
        setConfiguration(configuration) {
            this.configuration = configuration;
        }
        getKey() {
            return seven.GestureType.None;
        }
        touchstart(event, touchEvent) {
            this.touchBeganPosition = touchEvent.copy();
        }
        touchmove(event, touchEvent) {
        }
        touchend(event, touchEvent) {
            this.touchEndPosition = touchEvent.copy();
        }
        touchcancel(event, touchEvent) {
        }
        mousedown(event, touchEvent) {
            this.touchBeganPosition = touchEvent.copy();
        }
        mouseup(event, touchEvent) {
            this.touchEndPosition = touchEvent.copy();
        }
        mousemove(event, touchEvent) {
        }
        mouseout(event, touchEvent) {
            this.touchEndPosition = touchEvent.copy();
        }
        endTouchInClickRange(range) {
            if (this.touchBeganPosition == undefined || this.touchEndPosition == undefined) {
                seven.Logger.develeporError("touchPositions not defined");
                return false;
            }
            var orgin = this.touchEndPosition.getOrgin().copy();
            orgin.removeOrgin(this.touchBeganPosition.getOrgin());
            if (orgin.x < range.x() || orgin.x > range.topRight()) {
                return false;
            }
            if (orgin.y < range.y() || orgin.y > range.bottomLeft()) {
                return false;
            }
            return true;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    Gesture.classname = "seven.Gesture";
    seven.Gesture = Gesture;
//{INSERTORDER:3}
    class ViewController extends seven.AbstractViewController {
        constructor() {
            super();
        }
        getClassName() { return ViewController.classname; }
        documentController() {
            seven.Objects.requireNonNull("ViewController.docuemntController : tried to access nonnull value", seven.JBDocument.document().documentController);
            return seven.JBDocument.document().documentController;
        }
        setParentViewController(viewController) {
            this.parentViewController = viewController;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    ViewController.classname = "seven.ViewController";
    seven.ViewController = ViewController;
//{INSERTORDER:4}
    class TapGesture extends seven.Gesture {
        constructor() {
            super();
            this.delegateData = new seven.JMBMap();
            this.tapCount = 0;
            this.firstTouchOrgin = seven.Orgin.empty();
            this.setDelegate(seven.JBDocument.document());
        }
        getClassName() { return TapGesture.classname; }
        /**
         * This gives the instance, which was loaded by the Classloader
         * You can use this to access this instance afterwoulds-or don't, you decide
        */
        static loadedInstance() {
            var loadedInstance = seven.ClassLoader.manager().getLoadedInstance(TapGesture.className);
            if (loadedInstance != undefined) {
                return loadedInstance;
            }
            var clickGesture = new TapGesture();
            seven.TouchManager.manager().tapGesture = clickGesture;
            return clickGesture;
        }
        setDelegate(delegate) {
            this.delegate = delegate;
        }
        getKey() {
            return seven.GestureType.Tap;
        }
        touchstart(event, touchEvent) {
            super.touchstart(event, touchEvent);
            if (this.firstTouchOrgin.isEmpty() == true) {
                this.firstTouchOrgin = touchEvent.getOrgin().copy();
            }
            this.start();
        }
        touchend(event, touchEvent) {
            super.touchend(event, touchEvent);
            this.end(this.configuration.getScreenClickRange());
        }
        mousedown(event, touchEvent) {
            super.mousedown(event, touchEvent);
            if (this.firstTouchOrgin.isEmpty() == true) {
                this.firstTouchOrgin = touchEvent.getOrgin().copy();
            }
            this.start();
        }
        mouseup(event, touchEvent) {
            super.mouseup(event, touchEvent);
            this.end(this.configuration.getMouseClickRange());
        }
        start() {
            console.log("start");
            clearTimeout(this.nextTouchTimer);
            this.touchDownTimer = window.setTimeout(() => {
                this.tapCount = 0;
                this.firstTouchOrgin = seven.Orgin.empty();
            }, this.configuration.getTapMaximumTouchDowm());
        }
        end(range) {
            console.log("end");
            clearTimeout(this.nextTouchTimer);
            clearTimeout(this.touchDownTimer);
            this.checkForClick(range);
            this.nextTouchTimer = window.setTimeout(() => {
                this.sendEvent(true);
                this.tapCount = 0;
                this.firstTouchOrgin = seven.Orgin.empty();
            }, this.configuration.getTapRetouchTimeout());
            return;
        }
        checkForClick(range) {
            var testOrgin = this.firstTouchOrgin.copy().removeOrgin(this.touchEndPosition.getOrgin());
            console.log("checkForClick " + testOrgin.toString() + " rect " + range.toString());
            if (this.endTouchInClickRange(range) == true && range.containsOrgin(testOrgin.toAbsolute()) == true) {
                this.tapCount++;
                this.sendEvent(false);
                console.log("tapped");
                // this.delegate.tapRecieved(this.touchEndPosition.getOrgin(), this.getDelegateData());
            }
            this.touchBeganPosition = undefined;
            //this.touchEndPosition = undefined;
        }
        sendEvent(timmerCalled) {
            if (this.tapCount == 0) {
                console.log("sendEvent : tapCount is 0");
                return;
            }
            if (timmerCalled == true) {
                if (this.tapCount == 1) {
                    this.delegate.clickRecieved(this.touchEndPosition.getOrgin(), this.getDelegateData());
                }
                return;
            }
            this.delegate.tapRecieved(this.touchEndPosition.getOrgin(), this.getDelegateData());
        }
        getDelegateData() {
            this.delegateData.put("tapCount", this.tapCount);
            return this.delegateData;
        }
    }
    //AutoGeneratedClassName-start - do not eidt this line
    TapGesture.classname = "seven.TapGesture";
    TapGesture.className = "seven.TapGesture";
    seven.TapGesture = TapGesture;
seven.ClassLoader.manager().loadInstance(seven.TapGesture.className);
    function boot() {
        //classes can register in the global scope and get loaded at this point
        seven.ClassLoader.manager().startLoading();
        seven.On.on().call("prepareDocument");
        seven.On.on().call("prepareDocument-Default");
        seven.JBDocument.document().prepareLoading();
        seven.On.on().call("documentDidPrepare");
        seven.JBDocument.document().load();
        seven.On.on().call("documentInitSize");
        seven.On.on().call("windowDidLoad", seven.JBDocument.document().getWindows()[0]);
        seven.JBDocument.document().startRendering();
    }
    seven.boot = boot;
    let GestureType;
    (function (GestureType) {
        GestureType[GestureType["None"] = 0] = "None";
        GestureType[GestureType["Click"] = 1] = "Click";
        GestureType[GestureType["Tap"] = 2] = "Tap";
    })(GestureType = seven.GestureType || (seven.GestureType = {}));
    function stringToBool(s) {
        if (s == undefined) {
            return false;
        }
        if (typeof s == "boolean") {
            return s;
        }
        var lower = s.toLocaleLowerCase().trim();
        if (lower == "true") {
            return true;
        }
        return false;
    }
    seven.stringToBool = stringToBool;
    let TextAlign;
    (function (TextAlign) {
        TextAlign[TextAlign["LEFT"] = 0] = "LEFT";
        TextAlign[TextAlign["CENTER"] = 1] = "CENTER";
        TextAlign[TextAlign["RIGHT"] = 2] = "RIGHT";
    })(TextAlign = seven.TextAlign || (seven.TextAlign = {}));
})(seven || (seven = {}));