@flashist/appframework 0.0.3

package/src/display/views/simplelist/SimpleList.ts

@@ -0,0 +1,318 @@
+import {ArrayTools, Dictionary, IConstructor, Logger, ObjectTools} from "@flashist/fcore";
+
+import {DisplayTools, FContainer, Point} from "@flashist/flibs";
+
+import {ISimpleListItem} from "./ISimpleListItem";
+import {ILayoutableContainer} from "../layout/container/ILayoutableContainer";
+import {IResizable} from "../resize/IResizable";
+
+export class SimpleList
+    <ItemType extends ISimpleListItem = ISimpleListItem, ItemData extends any = any>
+    extends FContainer
+    implements ILayoutableContainer {
+
+    private _dataProvider: ItemData[];
+    private _itemsDataPropertyName: string;
+    private _itemsProperties: any;
+
+    private _ItemRendererClass: IConstructor<ItemType>;
+
+    protected items: ItemType[];
+    protected cacheItems: ItemType[];
+
+    public useItemsCache: boolean;
+    public reuseItemsForConcreteData: boolean;
+
+    protected construction(): void {
+        super.construction();
+
+        this._dataProvider = [];
+        this.items = [];
+        this.cacheItems = [];
+        this._itemsDataPropertyName = "data";
+    }
+
+    public get ItemRendererClass(): IConstructor<ItemType> {
+        return this._ItemRendererClass;
+    }
+    public set ItemRendererClass(value: IConstructor<ItemType>) {
+        if (value == this._ItemRendererClass) {
+            return;
+        }
+
+        this._ItemRendererClass = value;
+
+        this.commitItemsData();
+    }
+
+    get itemsProperties(): any {
+        return this._itemsProperties;
+    }
+    set itemsProperties(value: any) {
+        if (value === this._itemsProperties) {
+            return;
+        }
+
+        this._itemsProperties = value;
+
+        this.commitItemsData();
+    }
+
+    public get dataProvider(): ItemData[] {
+        return this._dataProvider;
+    }
+    public set dataProvider(value: ItemData[]) {
+        if (!value) {
+            value = [];
+        }
+
+        if (ArrayTools.checkIfEqual(value, this.dataProvider)) {
+            return;
+        }
+
+        this._dataProvider = value;
+
+        this.commitItemsData();
+    }
+
+    public get itemsDataPropertyName(): string {
+        return this._itemsDataPropertyName;
+    }
+    public set itemsDataPropertyName(value: string) {
+        if (value == this._itemsDataPropertyName) {
+            return;
+        }
+
+        this._itemsDataPropertyName = value;
+
+        this.commitItemsData();
+    }
+
+
+    protected getItemFromCacheToReuse(data: ItemData): ItemType {
+        let result: ItemType;
+        for (let item of this.cacheItems) {
+            if (item[this._itemsDataPropertyName] === data) {
+                result = item;
+                // Remove item from the cache, to prevent reusing it as a regular cached item
+                ArrayTools.removeItem(this.cacheItems, result);
+                break;
+            }
+        }
+
+        return result;
+    }
+
+    protected getItemFromCache(): ItemType {
+        let result: ItemType;
+
+        if (this.cacheItems.length > 0) {
+            result = this.cacheItems.shift();
+        }
+
+        return result;
+    }
+
+    addItemToCache(item: ItemType): void {
+        if (this.cacheItems.indexOf(item) !== -1) {
+            return;
+        }
+
+        this.cacheItems.push(item);
+    }
+
+    removeItemFromCache(item: ItemType): void {
+        ArrayTools.removeItem(this.cacheItems, item);
+    }
+
+    protected commitItemsData(): void {
+        if (!this.ItemRendererClass) {
+
+        } else if (!this.dataProvider) {
+            this.removeAllItems();
+
+        } else {
+            var tempData: any;
+            var tempItem: ItemType;
+            var itemIndex: number;
+            var itemsCount: number = this.dataProvider.length;
+
+
+            var prevItems: ItemType[] = this.items.concat();
+
+            if (this.items.length) {
+                var maxStepsCount: number = 100000;
+                var stepIndex: number = 0;
+                while (this.items.length > 0) {
+                    tempItem = this.items[0];
+                    this.removeItem(tempItem, false);
+
+                    stepIndex++;
+                    if (stepIndex >= maxStepsCount) {
+                        Logger.log("SimpleList | commitItemsData", "WARNING! Max steps count reached!");
+                        break;
+                    }
+                }
+            }
+
+            var reuseItemsToDataMap: Dictionary<ItemData, ItemType> = new Dictionary();
+            var reuseDataItems: ItemType[] = [];
+            if (this.reuseItemsForConcreteData) {
+                itemsCount = this.dataProvider.length;
+                for (itemIndex = 0; itemIndex < itemsCount; itemIndex++) {
+                    tempData = this.dataProvider[itemIndex];
+                    tempItem = this.getItemFromCacheToReuse(tempData);
+
+                    if (tempItem) {
+                        reuseDataItems.push(tempItem);
+                        reuseItemsToDataMap.addItem(tempData, tempItem);
+                    }
+                }
+
+                // Remove all items, which will be reused for specific data, from the cache
+                // ArrayTools.removeItems(this.cacheItems, reuseDataItems);
+            }
+
+            // Creation of items
+            for (itemIndex = 0; itemIndex < itemsCount; itemIndex++) {
+                tempItem = null;
+                tempData = this.dataProvider[itemIndex];
+
+                // If cache should be used
+                if (this.useItemsCache) {
+                    // If reusing elements for specific data is turned on,
+                    // try to find an item for specific data
+                    if (this.reuseItemsForConcreteData) {
+                        //tempItem = this.getItemFromCache(tempData, this.reuseItemsForConcreteData);
+                        // tempItem = this.getItemFromCacheToReuse(tempData);
+                        tempItem = reuseItemsToDataMap.getItem(tempData);
+                        if (tempItem) {
+                            reuseItemsToDataMap.removeItemByKey(tempData);
+                        }
+                    }
+
+                    if (this.cacheItems.length > 0) {
+                        // If a cached item for the specific data wasn't found,
+                        // then try to get regular cached item
+                        if (!tempItem) {
+                            tempItem = this.getItemFromCache();
+                        }
+                    }
+                }
+
+                if (!tempItem) {
+                    tempItem = new this.ItemRendererClass();
+                }
+
+                this.addItem(tempItem, itemIndex);
+            }
+
+            // Remove newly used items from the list of the previously used items
+            ArrayTools.removeItems(prevItems, this.items);
+            // Remove all previously used items (and add them to cache if allowed)
+            itemsCount = prevItems.length;
+            for (itemIndex = 0; itemIndex < itemsCount; itemIndex++) {
+                tempItem = prevItems[itemIndex];
+
+                this.removeItem(tempItem);
+            }
+        }
+
+        if (this.items && this._itemsProperties) {
+            for (const singleItem of this.items) {
+                ObjectTools.copyProps(
+                    singleItem,
+                    this._itemsProperties
+                );
+            }
+        }
+
+        this.arrange();
+    }
+
+    protected addItem(item: ItemType, index: number): void {
+        this.items[index] = item;
+
+        this.applyDataToItem(item, this.dataProvider[index]);
+        DisplayTools.safeAddChildAt(this, item, index);
+
+        this.resizeSingleItem(item);
+    }
+
+    protected removeItem(item: ItemType, removeFromDisplayList: boolean = true): void {
+        if (!item) {
+            return;
+        }
+
+        if (removeFromDisplayList) {
+            DisplayTools.childRemoveItselfFromParent(item);
+        }
+        ArrayTools.removeItem(this.items, item);
+
+        if (this.useItemsCache) {
+            this.addItemToCache(item);
+        }
+    }
+
+    protected applyDataToItem(item: ItemType, itemData: any): void {
+        if (!item) {
+            return;
+        }
+
+        item[this.itemsDataPropertyName] = itemData;
+    }
+
+    protected removeAllItems(): void {
+        DisplayTools.removeAllChildren(this);
+
+        this.items = [];
+        this.cacheItems = [];
+    }
+
+
+    layoutGetChildrenNum(): number {
+        return this.items.length;
+    }
+
+    layoutGetChildAt(index: number): ItemType {
+        return this.items[index];
+    }
+
+    public getItems(): ItemType[] {
+        return this.items.concat();
+    }
+
+    protected childrenResizeSize: Point;
+    public resizeItems(childrenWidth: number, childrenHeight: number): void {
+        if (!this.childrenResizeSize) {
+            this.childrenResizeSize = new Point();
+        }
+
+        if (this.childrenResizeSize.x === childrenWidth &&
+            this.childrenResizeSize.y === childrenHeight) {
+            return;
+        }
+
+        this.childrenResizeSize.x = childrenWidth;
+        this.childrenResizeSize.y = childrenHeight;
+
+        for (let singleItem of this.items) {
+            this.resizeSingleItem(singleItem);
+        }
+    }
+
+    protected resizeSingleItem(item: ItemType): void {
+        if (!this.childrenResizeSize) {
+            return;
+        }
+
+        const resizableItem: IResizable = (item as any);
+        if (resizableItem.resize) {
+            resizableItem.resize(this.childrenResizeSize.x, this.childrenResizeSize.y);
+
+        } else {
+            item.width = this.childrenResizeSize.x;
+            item.height = this.childrenResizeSize.y;
+        }
+    }
+}

package/src/display/views/simplelist/SimpleListEvent.ts

@@ -0,0 +1,4 @@
+export const SimpleListEvent = {
+    ITEM_ADDED: "ITEM_ADDED",
+    ITEM_REMOVED: "ITEM_REMOVED"
+};

package/src/display/views/sizedistributor/ISizeDistributorChild.ts

@@ -0,0 +1,5 @@
+import {DisplayObjectContainer} from "@flashist/flibs";
+import {IResizable} from "../resize/IResizable";
+
+export interface ISizeDistributorChild extends DisplayObjectContainer, IResizable {
+}

package/src/display/views/sizedistributor/SizeDistributor.ts

@@ -0,0 +1,129 @@
+export class SizeDistributor {
+
+    /*protected config: SizeDistributorConfig;
+    protected sizePerChild: Dictionary<any, Point>;
+
+    constructor(config?: Partial<SizeDistributorConfig>) {
+        this.config = new SizeDistributorConfig();
+        if (config) {
+            (Object as any).assign(this.config, config);
+        }
+    }
+
+    updateSize(container: ILayoutableContainer<ISizeDistributorChild>, width: number, height: number): void {
+
+        this.sizePerChild = new Dictionary<any, Point>();
+
+        let childrenCount: number = container.layoutGetChildrenNum();
+
+        let tempChild: ISizeDistributorChild;
+        let tempChildWidth: number;
+        let tempChildHeight: number;
+        //
+        let defaultChildWidth: number = 0;
+        let defaultChildHeight: number = 0;
+        //
+        let tempSize: Point;
+
+        // Find distribution and predefined size values
+        let totalPredefinedWidth: number = 0;
+        let totalPredefinedHeight: number = 0;
+        //
+        let predefinedWidthChildren: ISizeDistributorChild[] = [];
+        let predefinedHeightChildren: ISizeDistributorChild[] = [];
+        //
+        for (let childIndex = 0; childIndex < childrenCount; childIndex++) {
+            tempChild = container.layoutGetChildAt(childIndex);
+
+            if (this.config.distributeWidth) {
+                if (tempChild.getPredefinedWidth && tempChild.getPredefinedWidth()) {
+                    tempChildWidth = tempChild.getPredefinedWidth();
+                    predefinedWidthChildren.push(tempChild);
+                    totalPredefinedWidth += tempChildWidth;
+
+                    tempSize = this.getSizeForChild(tempChild);
+                    tempSize.x = tempChildWidth;
+                }
+            }
+
+            if (this.config.distributeHeight) {
+                if (tempChild.getPredefinedHeight && tempChild.getPredefinedHeight()) {
+                    tempChildHeight = tempChild.getPredefinedHeight();
+                    predefinedHeightChildren.push(tempChild);
+                    totalPredefinedHeight += tempChildHeight;
+
+                    tempSize = this.getSizeForChild(tempChild, true);
+                    tempSize.y = tempChildHeight;
+                }
+            }
+        }
+
+        if (this.config.distributeWidth) {
+            let totalAvailableWidth: number = width - totalPredefinedWidth - (this.config.paddingX * 2);
+            totalAvailableWidth -= (this.config.spacingX * (childrenCount - 1));
+            //
+            let distributeWidthChildrenCount: number = childrenCount - predefinedWidthChildren.length;
+            if (distributeWidthChildrenCount > 0) {
+                defaultChildWidth = totalAvailableWidth / distributeWidthChildrenCount;
+            }
+
+        } else {
+            defaultChildWidth = width;
+        }
+        // Prevent minus values
+        if (defaultChildWidth < 0) {
+            defaultChildWidth = 0;
+        }
+
+        if (this.config.distributeHeight) {
+            let totalAvailableHeight: number = height - totalPredefinedHeight - (this.config.paddingY * 2);
+            totalAvailableHeight -= (this.config.spacingY * (childrenCount - 1));
+            //
+            let distributeHeightChildrenCount: number = childrenCount - predefinedHeightChildren.length;
+            if (distributeHeightChildrenCount > 0) {
+                defaultChildHeight = totalAvailableHeight / distributeHeightChildrenCount;
+            }
+
+        } else {
+            defaultChildHeight = height;
+        }
+        // Prevent minus values
+        if (defaultChildHeight < 0) {
+            defaultChildHeight = 0;
+        }
+
+        if (this.config.isNeedFloorValues) {
+            defaultChildWidth = Math.floor(defaultChildWidth);
+            defaultChildHeight = Math.floor(defaultChildHeight);
+        }
+
+        // Set size
+        for (let childIndex = 0; childIndex < childrenCount; childIndex++) {
+            tempChild = (container.layoutGetChildAt(childIndex) as ISizeDistributorChild);
+
+            tempSize = this.getSizeForChild(tempChild);
+            if (tempSize) {
+                if (tempSize.x <= 0) {
+                    tempSize.x = defaultChildWidth;
+                }
+                if (tempSize.y <= 0) {
+                    tempSize.y = defaultChildHeight;
+                }
+
+                tempChild.resize(tempSize.x, tempSize.y);
+            }
+        }
+    }
+
+    protected getSizeForChild(child: any, isNeedCreate: boolean = true): Point {
+        let result: Point = this.sizePerChild.getItem(child);
+        if (!result) {
+            if (isNeedCreate) {
+                this.sizePerChild.addItem(child, new Point());
+                result = this.sizePerChild.getItem(child)
+            }
+        }
+
+        return result;
+    }*/
+}

package/src/display/views/sizedistributor/SizeDistributorConfig.ts

@@ -0,0 +1,12 @@
+export class SizeDistributorConfig {
+    distributeWidth:boolean;
+    distributeHeight:boolean;
+
+    spacingX:number = 0;
+    spacingY:number = 0;
+
+    paddingX:number = 0;
+    paddingY:number = 0;
+
+    isNeedFloorValues:boolean = true;
+}

package/src/display/views/togglegroup/IToggableItem.ts

@@ -0,0 +1,6 @@
+import {DisplayObjectContainer} from "@flashist/flibs";
+
+export interface IToggableItem extends DisplayObjectContainer {
+    id?: string;
+    selected: boolean;
+}

package/src/display/views/togglegroup/IToggleGroupItem.ts

@@ -0,0 +1,6 @@
+import {DisplayObjectContainer} from "@flashist/flibs";
+
+export interface IToggleGroupItem extends DisplayObjectContainer {
+    id: string;
+    selected: boolean;
+}

package/src/display/views/togglegroup/ToggleGroup.ts

@@ -0,0 +1,140 @@
+import {AssociativeArray, BaseObject} from "@flashist/fcore";
+import {InteractiveEvent} from "@flashist/flibs";
+
+import {IToggableItem} from "./IToggableItem";
+import {ToggleGroupEvent} from "./ToggleGroupEvent";
+
+export class ToggleGroup<IToggleItemType extends IToggableItem = IToggableItem> extends BaseObject {
+
+    protected itemsToIdMap: AssociativeArray<IToggleItemType>;
+
+    private _selectedItem: IToggleItemType;
+    // protected toggleItems: IToggleItemType[];
+    protected _selectedId: string = "";
+
+    construction(...args) {
+        super.construction(...args);
+
+        // this.toggleItems = [];
+        this.itemsToIdMap = new AssociativeArray<IToggleItemType>();
+    }
+
+    destruction(): void {
+        super.destruction();
+
+        if (this.itemsToIdMap) {
+            this.itemsToIdMap.destruction();
+        }
+    }
+
+    protected processItemTap(item: IToggleItemType): void {
+        this.selectedId = item.id;
+    }
+
+    protected addItemListeners(item: IToggleItemType): void {
+        if (!item) {
+            return;
+        }
+
+        this.eventListenerHelper.addEventListener(
+            item,
+            InteractiveEvent.TAP,
+            () => {
+                this.processItemTap(item);
+            }
+        );
+    }
+
+    protected removeItemListeners(item: IToggleItemType): void {
+        if (!item) {
+            return;
+        }
+
+        this.eventListenerHelper.removeAllListeners(item);
+    }
+
+
+    addItem(item: IToggleItemType): void {
+        // if (this.toggleItems.indexOf(item) != -1) {
+        if (this.itemsToIdMap.getItem(item.id)) {
+            return;
+        }
+
+        // this.toggleItems.push(item);
+        this.itemsToIdMap.push(item, item.id);
+
+        this.addItemListeners(item);
+    }
+
+    removeItem(item: IToggleItemType): void {
+        if (this.selectedItem == item) {
+            this.selectedId = null;
+        }
+
+        // ArrayTools.removeItem(this.toggleItems, item);
+        this.itemsToIdMap.remove(item);
+
+        this.removeItemListeners(item);
+    }
+
+    removeAllItems(): void {
+        const itemsCopy: IToggleItemType[] = this.itemsToIdMap.getAllItems();
+        for (const item of itemsCopy) {
+            this.removeItem(item);
+        }
+    }
+
+    /*get selectedItem(): IToggleItemType {
+        return this._selectedItem;
+    }
+    set selectedItem(value: IToggleItemType) {
+        if (value == this._selectedItem) {
+            return;
+        }
+        if (value && this.toggleItems.indexOf(value) == -1) {
+            return;
+        }
+
+        // Reset the previous selected item
+        if (this._selectedItem) {
+            this._selectedItem.selected = false;
+        }
+
+        this._selectedItem = value;
+        // Setup the new selected item
+        if (this._selectedItem) {
+            this._selectedItem.selected = true;
+        }
+
+        this.commitData();
+
+        this.dispatchEvent(ToggleGroupEvent.SELECTED_ID_CHANGE);
+    }*/
+
+    public get selectedId(): string {
+        return this._selectedId;
+    }
+    public set selectedId(value: string) {
+        if (this._selectedId === value) {
+            return;
+        }
+
+        // Reset the previous selected item
+        if (this._selectedItem) {
+            this._selectedItem.selected = false;
+        }
+
+        this._selectedId = value;
+        this._selectedItem = this.itemsToIdMap.getItem(this._selectedId);
+        // Setup the new selected item
+        if (this._selectedItem) {
+            this._selectedItem.selected = true;
+        }
+
+        this.dispatchEvent(ToggleGroupEvent.SELECTED_ID_CHANGE);
+    }
+
+    public get selectedItem(): IToggleItemType {
+        return this._selectedItem;
+    }
+}

package/src/display/views/togglegroup/ToggleGroupEvent.ts

@@ -0,0 +1,3 @@
+export const ToggleGroupEvent = {
+    SELECTED_ID_CHANGE: "ToggleGroupEvent.SELECTED_ID_CHANGE"
+};

package/src/display/views/viewstack/IViewStackItem.ts

@@ -0,0 +1,7 @@
+import {IDatable} from "@flashist/fcore";
+
+import {IResizable} from "../resize/IResizable";
+
+export interface IViewStackItem extends Partial<IResizable>, IDatable {
+
+}

package/src/display/views/viewstack/ViewLazyCreationServiceLocatorStack.ts

@@ -0,0 +1,19 @@
+import {IConstructor} from "@flashist/fcore";
+
+import {DisplayObjectContainer, getInstance} from "@flashist/flibs";
+
+import {ViewLazyCreationStack} from "./ViewLazyCreationStack";
+
+export class ViewLazyCreationServiceLocatorStack<StackViewType extends DisplayObjectContainer = DisplayObjectContainer> extends ViewLazyCreationStack<StackViewType> {
+
+    protected getNewInstance(id: string): StackViewType {
+        let result: StackViewType;
+
+        let TempClass: IConstructor<any> = (this.viewClassToIdMap.getItem(id) as IConstructor<any>);
+        if (TempClass) {
+            result = getInstance(TempClass);
+        }
+
+        return result;
+    }
+}