@flashist/appframework 0.0.3

package/src/base/models/BaseAppGenericObjectsModel.ts

@@ -0,0 +1,23 @@
+import {GenericObjectsModel, getInstance, IGenericObjectVO} from "@flashist/flibs";
+
+import {GlobalEventDispatcher} from "../../globaleventdispatcher/dispatcher/GlobalEventDispatcher";
+
+// export class BaseAppGenericObjectsModel extends BaseObject {
+export class BaseAppGenericObjectsModel<ItemType extends IGenericObjectVO = IGenericObjectVO> extends GenericObjectsModel<ItemType> {
+
+    protected globalDispatcher: GlobalEventDispatcher;
+
+    protected construction(...args): void {
+        this.globalDispatcher = getInstance(GlobalEventDispatcher);
+
+        super.construction(...args);
+    }
+
+    dispatchEvent(event: string, ...args: any[]): void {
+        super.dispatchEvent(event, ...args);
+
+        // Redispatch event to the global level
+        this.globalDispatcher.dispatchEvent(event, ...args);
+    }
+
+}

package/src/base/models/BaseAppModel.ts

@@ -0,0 +1,5 @@
+import {BaseObjectWithGlobalDispatcher} from "../BaseObjectWithGlobalDispatcher";
+
+export class BaseAppModel extends BaseObjectWithGlobalDispatcher {
+
+}

package/src/base/modules/AppModulesManager.ts

@@ -0,0 +1,44 @@
+import {ArrayTools} from "@flashist/fcore";
+import {BaseAppModule} from "./BaseAppModule";
+
+export class AppAppModulesManager {
+    protected modules: BaseAppModule[] = [];
+
+    destroy(): void {
+        this.modules = [];
+    }
+
+
+    // Modules
+
+    addModule(module: BaseAppModule): void {
+        this.modules.push(module);
+    }
+
+    removeModule(module: BaseAppModule): void {
+        ArrayTools.removeItem(this.modules, module);
+    }
+
+    initModules(): void {
+        let modulesCount: number = this.modules.length;
+        // Init all modules
+        for (let moduleIndex: number = 0; moduleIndex < modulesCount; moduleIndex++) {
+            this.modules[moduleIndex].init();
+        }
+
+        // Go through all modules and call the hook after completion,
+        // to add a way to do something, when everything is prepared
+        for (let moduleIndex: number = 0; moduleIndex < modulesCount; moduleIndex++) {
+            this.modules[moduleIndex].initCompleteHook();
+        }
+    }
+
+    activateModules(): void {
+        let modulesCount: number = this.modules.length;
+        // Go through all modules and call the hook after completion,
+        // to add a way to do something, when everything is prepared
+        for (let moduleIndex: number = 0; moduleIndex < modulesCount; moduleIndex++) {
+            this.modules[moduleIndex].activateCompleteHook();
+        }
+    }
+}

package/src/base/modules/BaseAppModule.ts

@@ -0,0 +1,17 @@
+import {BaseObject} from "@flashist/fcore";
+
+export abstract class BaseAppModule extends BaseObject {
+
+    init(): void {
+        // Should be overridden in subclasses, if needed
+    }
+
+    initCompleteHook(): void {
+        // Should be overridden in subclasses, if needed
+    }
+    
+    activateCompleteHook(): void {
+        // Should be overridden in subclasses, if needed
+    }
+
+}

package/src/base/views/BaseAppView.ts

@@ -0,0 +1,25 @@
+import { IEventListenerCallback } from "@flashist/fcore";
+import { getInstance } from "@flashist/flibs";
+
+import { ResizableContainer } from "../../display/views/resize/ResizableContainer";
+import { GlobalEventDispatcher } from "../../globaleventdispatcher/dispatcher/GlobalEventDispatcher";
+
+export class BaseAppView<DataType extends object = object> extends ResizableContainer<DataType> {
+
+    protected globalDispatcher: GlobalEventDispatcher;
+
+    protected construction(...args): void {
+        super.construction(...args);
+
+        this.globalDispatcher = getInstance(GlobalEventDispatcher);
+    }
+
+    protected addGlobalEventListener(event: string, fn: IEventListenerCallback): void {
+        this.eventListenerHelper.addEventListener(
+            this.globalDispatcher,
+            event,
+            fn
+        );
+    }
+
+}

package/src/containers/ContainersModule.ts

@@ -0,0 +1,13 @@
+import {serviceLocatorAdd} from "@flashist/flibs";
+
+import {BaseAppModule} from "../base/modules/BaseAppModule";
+import {ContainersManager} from "./managers/ContainersManager";
+
+export class ContainersModule extends BaseAppModule {
+
+    init(): void {
+        super.init();
+
+        serviceLocatorAdd(ContainersManager, {isSingleton: true});
+    }
+}

package/src/containers/managers/ContainersManager.ts

@@ -0,0 +1,27 @@
+import {FContainer} from "@flashist/flibs";
+
+import {BaseAppManager} from "../../base/managers/BaseAppManager";
+
+export class ContainersManager extends BaseAppManager {
+
+    private containersMap: { [key: string]: FContainer } = {};
+
+    public addContainer(container: FContainer, id: string): void {
+        this.containersMap[id] = container;
+    }
+
+    public removeContainer(id: string): void {
+        delete this.containersMap[id];
+    }
+
+    public getContainer(id: string): FContainer {
+        let result: FContainer;
+
+        if (this.containersMap[id]) {
+            result = this.containersMap[id];
+        }
+
+        return result;
+    }
+
+}

package/src/data/IAppGenericObjectVO.ts

@@ -0,0 +1,5 @@
+import { IGenericObjectVO } from "@flashist/flibs";
+
+export interface IAppGenericObjectVO extends IGenericObjectVO {
+    localeId?: string;
+}

package/src/date/DateSettings.ts

@@ -0,0 +1,6 @@
+export const DateSettings = {
+    MS_IN_SECOND: 1000,
+    MS_IN_MINUTE: 1000 * 60,
+    MS_IN_HOUR: 1000 * 60 * 60,
+    MS_IN_DAY: 1000 * 60 * 60 * 24
+};

package/src/debug/DebugModule.ts

@@ -0,0 +1,22 @@
+import {ConsoleCustomLoggerItem, Logger} from "@flashist/fcore";
+import {FApp} from "@flashist/flibs";
+import {FC} from "@flashist/fconsole";
+
+import {BaseAppModule} from "../base/modules/BaseAppModule";
+
+export class DebugModule extends BaseAppModule {
+    activateCompleteHook(): void {
+        super.activateCompleteHook();
+
+        FC.startInit(
+            FApp.instance.stage,
+            {
+                console: {
+                    defaultVisible: true
+                }
+            }
+        );
+
+        Logger.addLoggerItem(new ConsoleCustomLoggerItem());
+    }
+}

package/src/dependencies/DependenciesModule.ts

@@ -0,0 +1,13 @@
+import {GenericObjectsByTypeModel, serviceLocatorAdd} from "@flashist/flibs";
+
+import {BaseAppModule} from "../base/modules/BaseAppModule";
+
+export class DependenciesModule extends BaseAppModule {
+
+    init(): void {
+        super.init();
+
+        // Modules
+        serviceLocatorAdd(GenericObjectsByTypeModel, {isSingleton: true});
+    }
+}

package/src/display/data/IGetSizable.ts

@@ -0,0 +1,5 @@
+import {Point} from "@flashist/flibs";
+
+export interface IGetSizable {
+    getSize():Point;
+}

package/src/display/tools/GetSizeTools.ts

@@ -0,0 +1,25 @@
+import {DisplayObjectContainer, Point} from "@flashist/flibs";
+import {IGetSizable} from "../data/IGetSizable";
+
+export class GetSizeTools {
+
+    static getObjectSize(sourceObject: DisplayObjectContainer): Point {
+        let result: Point = new Point();
+
+        let getSizeObject: IGetSizable = (sourceObject as any as IGetSizable);
+        if (getSizeObject.getSize) {
+            result = getSizeObject.getSize();
+
+        } else {
+            if (sourceObject.width) {
+                result.x = sourceObject.width;
+            }
+            if (sourceObject.height) {
+                result.y = sourceObject.height;
+            }
+        }
+
+        return result;
+    }
+
+}

package/src/display/views/AppContainer.ts

@@ -0,0 +1,20 @@
+import {FContainer} from "@flashist/flibs";
+import {EventListenerHelper} from "@flashist/fcore";
+
+export class AppContainer<DataType extends any = any> extends FContainer<DataType> {
+
+    protected dataEventListenerHelper: EventListenerHelper;
+
+    protected construction(...args): void {
+        super.construction(...args);
+
+        this.dataEventListenerHelper = new EventListenerHelper(this);
+    }
+
+    protected processDataUnset(value: DataType): void {
+        super.processDataUnset(value);
+
+        this.dataEventListenerHelper.removeAllListeners();
+    }
+
+}

package/src/display/views/button/BaseBtn.ts

@@ -0,0 +1,325 @@
+import { BaseObject, EventListenerHelper, IDefaultEventDispatcher } from "@flashist/fcore";
+
+import { DisplayObject, InteractiveEvent } from "@flashist/flibs";
+
+import { BaseBtnState } from "./BaseBtnState";
+import { BaseBtnEvent } from "./BaseBtnEvent";
+
+export class BaseBtn extends BaseObject {
+
+    protected interactiveEventHelper: EventListenerHelper;
+
+    // ToDo: the previous code worked with MovieClip implementation,
+    // so this method might be moved to the MovieClip/Timeline-Button instead of the SimpleButton class
+    /*protected static SELECTED_FRAMES_FIRST_PART:string = "selected_";
+     protected static DISABLED_FRAME_NAME:string = "disabled";
+     protected static HIT_AREA_CLIP_NAME:string = "customHitArea";
+     protected static LABEL_FIELD_NAME:string = "labelField";*/
+
+    protected _hitArea: DisplayObject;
+
+    // protected label:BaseLabel;
+
+    private _state: string;
+    private _selected: boolean;
+
+    public autoToggleSelected: boolean;
+
+    private _enabled: boolean;
+
+
+    protected construction(): void {
+        super.construction();
+
+        this.interactiveEventHelper = new EventListenerHelper(this);
+        // this.label = new BaseLabel();
+
+        this.state = BaseBtnState.NORMAL;
+        this.enabled = true;
+    }
+
+    public destruction(): void {
+        super.destruction();
+
+        if (this.interactiveEventHelper) {
+            this.interactiveEventHelper.destruction();
+            this.interactiveEventHelper = null;
+        }
+    }
+
+    protected removeListeners(): void {
+        super.removeListeners();
+
+        this.removeMouseListeners();
+    }
+
+    protected addMouseListeners(dispatcher: IDefaultEventDispatcher<any>): void {
+        if (!dispatcher) {
+            return;
+        }
+
+        this.removeMouseListeners();
+
+        this.interactiveEventHelper.addEventListener(
+            dispatcher,
+            InteractiveEvent.OVER,
+            this.onOver
+        );
+
+        this.interactiveEventHelper.addEventListener(
+            dispatcher,
+            InteractiveEvent.OUT,
+            this.onOut
+        );
+
+        this.interactiveEventHelper.addEventListener(
+            dispatcher,
+            InteractiveEvent.DOWN,
+            this.onMouseDown
+        );
+
+        this.interactiveEventHelper.addEventListener(
+            dispatcher,
+            InteractiveEvent.TAP,
+            this.onTap
+        );
+    }
+
+    protected removeMouseListeners(): void {
+        if (!this.isConstructed) {
+            return;
+        }
+
+        this.interactiveEventHelper.removeAllListeners();
+    }
+
+
+    protected onOver(): void {
+        if (!this._enabled) {
+            return;
+        }
+
+        this.state = this.findStateValue(BaseBtnState.OVER);
+
+        this.redispatchEvent(InteractiveEvent.OVER);
+    }
+
+    protected onOut(): void {
+        if (!this._enabled) {
+            return;
+        }
+
+        this.state = this.findStateValue(BaseBtnState.NORMAL);
+
+        this.redispatchEvent(InteractiveEvent.OUT);
+    }
+
+    protected onMouseDown(): void {
+        if (!this._enabled) {
+            return;
+        }
+
+        this.state = this.findStateValue(BaseBtnState.PRESS);
+
+        this.redispatchEvent(InteractiveEvent.DOWN);
+    }
+
+    protected onTap(): void {
+        if (!this._enabled) {
+            return;
+        }
+
+        if (this.autoToggleSelected) {
+            this.selected = !this.selected;
+        }
+
+        this.state = this.findStateValue(BaseBtnState.OVER);
+
+        this.redispatchEvent(InteractiveEvent.TAP);
+    }
+
+
+    protected redispatchEvent(sourceEvent: string): void {
+        this.dispatchEvent(sourceEvent);
+    }
+
+    protected commitStateData(): void {
+        if (!this.isConstructed) {
+            return;
+        }
+
+        this.commitEnabledData();
+    }
+
+    protected commitEnabledData(): void {
+        if (this.hitArea) {
+            if (this.enabled) {
+                this.hitArea.interactive = true;
+                this.hitArea.buttonMode = true;
+
+            } else {
+                this.hitArea.interactive = false;
+                this.hitArea.buttonMode = false;
+            }
+        }
+    }
+
+    public get state(): string {
+        return this._state;
+    }
+    public set state(value: string) {
+        if (value == this.state) {
+            return;
+        }
+
+        this._state = value;
+
+        this.commitStateData();
+
+        this.dispatchEvent(BaseBtnEvent.STATE_CHANGE);
+    }
+
+    public get selected(): boolean {
+        return this._selected;
+    }
+    public set selected(value: boolean) {
+        if (value == this.selected) {
+            return;
+        }
+
+        this._selected = value;
+
+        if (this._selected) {
+            this.state = BaseBtnState.SELECTED_NORMAL;
+        } else {
+            this.state = BaseBtnState.NORMAL;
+        }
+
+        this.dispatchEvent(BaseBtnEvent.SELECTED_CHANGE);
+    }
+
+    public get enabled(): boolean {
+        return this._enabled;
+    }
+    public set enabled(value: boolean) {
+        if (value == this.enabled) {
+            return;
+        }
+
+        this._enabled = value;
+
+        if (this._enabled) {
+            this.state = this.findStateValue(BaseBtnState.NORMAL);
+        } else {
+            this.state = this.findStateValue(BaseBtnState.DISABLED);
+        }
+
+        this.commitEnabledData();
+    }
+
+
+    protected commitData(): void {
+        super.commitData();
+
+        if (!this.isConstructed) {
+            return;
+        }
+
+        // this.updateHitArea();
+        this.commitStateData();
+    }
+
+
+    public get hitArea(): DisplayObject {
+        return this._hitArea;
+    }
+    public set hitArea(value: DisplayObject) {
+        if (value == this.hitArea) {
+            return;
+        }
+
+        // Remove previous hit area
+        this.removeMouseListeners();
+
+        // Set the new hit area
+        this._hitArea = value;
+        this.addMouseListeners(this.hitArea);
+
+        this.commitData();
+    }
+
+    // protected updateHitArea():void {
+    //     /*var tempNewHitArea:createjs.DisplayObject;
+    //     if (this.view) {
+    //         tempNewHitArea = (this.view[BaseBtn.HIT_AREA_CLIP_NAME] as createjs.DisplayObject);
+    //         if (!tempNewHitArea) {
+    //             tempNewHitArea = this.view;
+    //         }
+    //     }
+    //
+    //     this.hitArea = tempNewHitArea;*/
+    //     // ToDo: the previous code worked with MovieClip implementation,
+    //     // so this method might be moved to the MovieClip/Timeline-Button instead of the SimpleButton class
+    // }
+
+    /*protected updateLabel():void {
+     // var tempNewField:createjs.Text;
+     // if (this.view) {
+     //     tempNewField = DisplayObjectTools.findChildByName<createjs.Text>(this.view, BaseBtn.LABEL_FIELD_NAME, true);
+     // }
+     //
+     // this.label.field = tempNewField;
+     // ToDo: the previous code worked with MovieClip implementation,
+     // so this method might be moved to the MovieClip/Timeline-Button instead of the BaseBtn class
+     }*/
+
+    // Think whether we really need to have the label object in the BaseBtn class
+    /*public get text():string {
+     return this.label.text;
+     }
+     public set text(value:string) {
+     this.label.text = value;
+     }*/
+
+
+    /*public simulateClick():void {
+     if (this.enabled) {
+     var tempEvent:createjs.MouseEvent = new createjs.MouseEvent(createjs.MouseEvent.CLICK);
+     tempEvent.target = this;
+
+     this.onTap(tempEvent);
+     }
+     }*/
+
+
+    /*private _commitStateDataCallback: Function;
+    get commitStateDataCallback(): Function {
+        return this._commitStateDataCallback;
+    }
+    set commitStateDataCallback(value: Function) {
+        if (value === this.commitStateDataCallback) {
+            return;
+        }
+
+        this._commitStateDataCallback = value;
+
+        this.commitStateData();
+    }*/
+
+    protected findStateValue(sourceState: string): string {
+        let result: string;
+
+        if (this.selected) {
+            result = BaseBtnState.NORMAL_TO_SELECTED_MAP[sourceState];
+
+        } else {
+            result = BaseBtnState.SELECTED_TO_NORMAL_MAP[sourceState];
+        }
+
+        if (!result) {
+            result = sourceState;
+        }
+
+        return result;
+    }
+}

package/src/display/views/button/BaseBtnEvent.ts

@@ -0,0 +1,4 @@
+export const BaseBtnEvent = {
+    STATE_CHANGE: "STATE_CHANGE",
+    SELECTED_CHANGE: "SELECTED_CHANGE"
+};

package/src/display/views/button/BaseBtnState.ts

@@ -0,0 +1,31 @@
+export class BaseBtnState {
+    public static NORMAL:string = "normal";
+    public static OVER:string = "over";
+    public static PRESS:string = "press";
+    public static DISABLED:string = "disabled";
+
+    public static SELECTED_NORMAL:string = "selected_normal";
+    public static SELECTED_OVER:string = "selected_over";
+    public static SELECTED_PRESS:string = "selected_press";
+    public static SELECTED_DISABLED:string = "selected_disabled";
+
+    public static NORMAL_TO_SELECTED_MAP = ((): any => {
+        let result: any = {};
+        result[BaseBtnState.NORMAL] = BaseBtnState.SELECTED_NORMAL;
+        result[BaseBtnState.OVER] = BaseBtnState.SELECTED_OVER;
+        result[BaseBtnState.PRESS] = BaseBtnState.SELECTED_PRESS;
+        result[BaseBtnState.DISABLED] = BaseBtnState.SELECTED_DISABLED;
+
+        return result;
+    })();
+
+    public static SELECTED_TO_NORMAL_MAP = ((): any => {
+        let result: any = {};
+        result[BaseBtnState.SELECTED_NORMAL] = BaseBtnState.NORMAL;
+        result[BaseBtnState.SELECTED_OVER] = BaseBtnState.OVER;
+        result[BaseBtnState.SELECTED_PRESS] = BaseBtnState.PRESS;
+        result[BaseBtnState.SELECTED_DISABLED] = BaseBtnState.DISABLED;
+
+        return result;
+    })();
+}