@flashist/appframework 0.0.3

package/src/display/views/layout/BaseLayout.ts

@@ -0,0 +1,160 @@
+import {Align, Point, VAlign} from "@flashist/flibs";
+
+import {LayoutConfig} from "./LayoutConfig";
+import {ILayoutableContainer} from "./container/ILayoutableContainer";
+
+import {ILayoutableChild} from "./container/ILayoutableChild";
+import {GetSizeTools} from "../../tools/GetSizeTools";
+
+/**
+ * ...
+ * @author Mark (ruFlashist@gmail.com)
+ */
+export abstract class BaseLayout {
+    protected settings: LayoutConfig;
+    protected _totalSize: Point = new Point();
+
+    constructor(settings?: Partial<LayoutConfig>) {
+
+        this.settings = new LayoutConfig();
+        if (settings) {
+            (Object as any).assign(this.settings, settings);
+        }
+    }
+
+    public abstract arrange(container: ILayoutableContainer): void;
+
+    public getMaxChildSize(container: ILayoutableContainer): Point {
+        var result: Point = new Point();
+
+
+        var childrenCount: number = container.layoutGetChildrenNum();
+
+        var tempChild: ILayoutableChild;
+        var tempChildSize: Point;
+
+        for (var childIndex: number = 0; childIndex < childrenCount; childIndex++) {
+            tempChild = container.layoutGetChildAt(childIndex);
+
+            tempChildSize = GetSizeTools.getObjectSize(tempChild);
+
+            if (tempChildSize.x > result.x) {
+                result.x = tempChildSize.x;
+            }
+            if (tempChildSize.y > result.y) {
+                result.y = tempChildSize.y;
+            }
+        }
+
+
+        return result;
+    }
+
+    protected arrangeChild(child: ILayoutableChild,
+                           prevChild: ILayoutableChild,
+                           align: String,
+                           valign: String,
+                           childMaxSize: Point,
+                           columnIndex: number = 0,
+                           rowIndex: number = 0,
+                           cellShift: Point = null): void {
+
+        var tempChildSize: Point = GetSizeTools.getObjectSize(child);
+
+        var newChildPos: Point = new Point();
+
+        newChildPos.x = this.settings.paddingX + (childMaxSize.x + this.settings.spacingX) * columnIndex;
+        switch (align) {
+            case Align.CENTER:
+                newChildPos.x += Math.floor((childMaxSize.x - tempChildSize.x) / 2);
+                break;
+
+            case Align.RIGHT:
+                newChildPos.x += childMaxSize.x - tempChildSize.x;
+                break;
+        }
+
+        newChildPos.y = this.settings.paddingY + (childMaxSize.y + this.settings.paddingY) * rowIndex;
+        switch (valign) {
+            case VAlign.MIDDLE:
+                newChildPos.y += Math.floor((childMaxSize.y - tempChildSize.y) / 2);
+                break;
+
+            case VAlign.BOTTOM:
+                newChildPos.y += childMaxSize.y - tempChildSize.y;
+                break;
+        }
+
+
+        if (cellShift) {
+            newChildPos.x += cellShift.x;
+            newChildPos.y += cellShift.y;
+        }
+
+        this.applyChildPosition(child, newChildPos.x, newChildPos.y);
+    }
+
+    protected applyChildPosition(child: ILayoutableChild, x: number, y: number): void {
+        if (this.settings.isNeedFloorCoordinates) {
+            x = Math.floor(x);
+            y = Math.floor(y);
+        }
+
+        child.x = x;
+        child.y = y;
+    }
+
+    public abstract findRealRowsAndColumnsCount(container: ILayoutableContainer): Point;
+
+    public findFullColumnsAndRowsInSize(container: ILayoutableContainer, size: Point): Point {
+        var result: Point = new Point();
+
+        var tempSize: Point;
+        var childsCount: number = container.layoutGetChildrenNum();
+        for (var columnIndex: number = 1; columnIndex <= childsCount; columnIndex++) {
+            tempSize = this.getTotalSizeForRowsAndColumns(container, columnIndex, 1);
+
+            if (tempSize.x <= size.x) {
+                result.x = columnIndex;
+
+            } else {
+                break;
+            }
+        }
+
+        for (var rowIndex: number = 1; rowIndex <= childsCount; rowIndex++) {
+            tempSize = this.getTotalSizeForRowsAndColumns(container, 1, rowIndex);
+
+            if (tempSize.y <= size.y) {
+                result.y = rowIndex;
+
+            } else {
+                break;
+            }
+        }
+
+
+        return result;
+    }
+
+    protected getTotalSizeForRowsAndColumns(container: ILayoutableContainer, columnsCount: number, rowsCount: number): Point {
+        var result: Point = new Point();
+
+        var maxChildSize: Point = this.getMaxChildSize(container);
+        result.x = this.settings.paddingX * 2 + maxChildSize.x * columnsCount + (this.settings.spacingY * (columnsCount - 1));
+        result.y = this.settings.paddingY * 2 + maxChildSize.y * rowsCount + (this.settings.spacingX * (rowsCount - 1));
+
+        return result;
+    }
+
+    protected updateTotalSize(container: ILayoutableContainer): void {
+        var realRowsAndColumnsCount: Point = this.findRealRowsAndColumnsCount(container);
+        var newTotalSize: Point = this.getTotalSizeForRowsAndColumns(container, realRowsAndColumnsCount.x, realRowsAndColumnsCount.y);
+
+        this._totalSize = newTotalSize;
+    }
+
+    public getTotalSize(): Point {
+        return this._totalSize;
+    }
+}

package/src/display/views/layout/ColumnLayout.ts

@@ -0,0 +1,120 @@
+import {BaseLayout} from "./BaseLayout";
+import {ILayoutableContainer} from "./container/ILayoutableContainer";
+import {Logger} from "@flashist/fcore";
+import {Point} from "@flashist/flibs";
+import {GetSizeTools} from "../../tools/GetSizeTools";
+import {ILayoutableChild} from "./container/ILayoutableChild";
+
+/**
+ * ...
+ * @author Mark (ruFlashist@gmail.com)
+ */
+export class ColumnLayout extends BaseLayout {
+
+    /**
+     * Расстановка элементов контейнера.
+     *
+     * @param    coutnainer
+     */
+    public arrange(container:ILayoutableContainer):void {
+
+        if (!container) {
+            Logger.log("ColumnLayout | arrange", "WARNING! Can't find container!");
+            return;
+        }
+
+        var tempChild:ILayoutableChild;
+        //var tempSizableChild:IGetSizeSprite;
+        var tempChildSize:Point;
+
+
+        var childMaxSize:Point = this.getMaxChildSize(container);
+
+        //
+        var prevChild:ILayoutableChild;
+        var prevChildSize:Point;
+        //
+        var childrenCount:number = container.layoutGetChildrenNum();
+        for (var childIndex:number = 0; childIndex < childrenCount; childIndex++) {
+            tempChild = container.layoutGetChildAt(childIndex);
+
+            tempChildSize = GetSizeTools.getObjectSize(tempChild);
+
+            this.arrangeChild(tempChild, prevChild, this.settings.align, this.settings.valign, childMaxSize, 0, childIndex);
+
+            // Запоминаем данные о текущем элементе
+            prevChild = tempChild;
+            prevChildSize = tempChildSize;
+        }
+
+
+        this.updateTotalSize(container);
+    }
+
+    /**
+     * Выравнивание объекта.
+     *
+     * @param    child
+     * @param    align
+     * @param    valign
+     * @param    childMaxSize
+     * @param    columnIndex
+     * @param    rowIndex
+     * @param    cellShift
+     */
+    protected arrangeChild(child:ILayoutableChild, prevChild:ILayoutableChild, align:String, valign:String, childMaxSize:Point, columnIndex:number = 0, rowIndex:number = 0, cellShift:Point = null):void {
+        super.arrangeChild(child, prevChild, align, valign, childMaxSize, columnIndex, rowIndex, cellShift);
+
+        // В однострочных/одностолбцовых расстановках объекты должны расстанавливаться друг от дуга
+        // не в зависимости от максимального размера, а в зависимости от взаимного размера ближайших объектов
+        if (prevChild) {
+            var prevChildSize:Point = GetSizeTools.getObjectSize(prevChild);
+            //child.y = prevChild.y + prevChildSize.y + this.settings.spacing.y;
+
+            this.applyChildPosition(
+                child,
+                child.x,
+                prevChild.y + prevChildSize.y + this.settings.spacingY
+            );
+        }
+    }
+
+    /**
+     * Обновление общего размера расстановки.
+     *
+     * @param    container
+     */
+    protected updateTotalSize(container:ILayoutableContainer):void {
+        super.updateTotalSize(container);
+
+        // В однострочных/одностолбцовых расстановках общий размер по одной из сторон должен рассчитываться
+        // не на основе максимального размера, а на положения и размера последнего элемента
+        var childrenCount:number = container.layoutGetChildrenNum();
+        if (childrenCount > 0) {
+            var lastChild:ILayoutableChild = container.layoutGetChildAt(childrenCount - 1);
+            if (lastChild) {
+                var lastChildSize:Point = GetSizeTools.getObjectSize(lastChild);
+                this._totalSize.y = lastChild.y + lastChildSize.y + this.settings.paddingY;
+            }
+        }
+    }
+
+
+    /**
+     * Получение количества строк и столбцов.
+     *
+     * @param    container
+     *
+     * @return
+     */
+    public findRealRowsAndColumnsCount(container:ILayoutableContainer):Point {
+        var result:Point = new Point();
+
+        var childrenCount:number = container.layoutGetChildrenNum();
+        result.x = 1;
+        result.y = childrenCount;
+
+
+        return result;
+    }
+}

package/src/display/views/layout/LayoutConfig.ts

@@ -0,0 +1,15 @@
+
+export class LayoutConfig {
+
+    paddingX: number = 0;
+    paddingY: number = 0;
+
+    spacingX: number = 0;
+    spacingY: number = 0;
+
+    align: string = "";
+    valign: string = "";
+
+    isNeedFloorCoordinates: boolean = true;
+
+}

package/src/display/views/layout/RowLayout.ts

@@ -0,0 +1,115 @@
+import {BaseLayout} from "./BaseLayout";
+import {Logger} from "@flashist/fcore";
+import {Point} from "@flashist/flibs";
+import {ILayoutableContainer} from "./container/ILayoutableContainer";
+import {ILayoutableChild} from "./container/ILayoutableChild";
+import {GetSizeTools} from "../../tools/GetSizeTools";
+
+export class RowLayout extends BaseLayout {
+
+    /**
+     * Расстановка элементов контейнера.
+     *
+     * @param    coutnainer
+     */
+    public arrange(container: ILayoutableContainer): void {
+        if (!container) {
+            Logger.log("ColumnLayout | arrange", "WARNING! Can't find container!");
+            return;
+        }
+
+        var tempChild: ILayoutableChild;
+        //var tempSizableChild:IGetSizeSprite;
+        var tempChildSize: Point;
+
+
+        var childMaxSize: Point = this.getMaxChildSize(container);
+
+        //
+        var prevChild: ILayoutableChild;
+        var prevChildSize: Point;
+        //
+        var childrenCount: number = container.layoutGetChildrenNum();
+        for (var childIndex: number = 0; childIndex < childrenCount; childIndex++) {
+            tempChild = container.layoutGetChildAt(childIndex);
+
+            tempChildSize = GetSizeTools.getObjectSize(tempChild);
+
+            this.arrangeChild(tempChild, prevChild, this.settings.align, this.settings.valign, childMaxSize, childIndex);
+
+            // Запоминаем данные о текущем элементе
+            prevChild = tempChild;
+            prevChildSize = tempChildSize;
+        }
+
+
+        this.updateTotalSize(container);
+    }
+
+    /**
+     * Выравнивание объекта.
+     *
+     * @param    child
+     * @param    align
+     * @param    valign
+     * @param    childMaxSize
+     * @param    columnIndex
+     * @param    rowIndex
+     * @param    cellShift
+     */
+    protected arrangeChild(child: ILayoutableChild, prevChild: ILayoutableChild, align: String, valign: String, childMaxSize: Point, columnIndex: number = 0, rowIndex: number = 0, cellShift: Point = null): void {
+        super.arrangeChild(child, prevChild, align, valign, childMaxSize, columnIndex, rowIndex, cellShift);
+
+        // В однострочных/одностолбцовых расстановках объекты должны расстанавливаться друг от дуга
+        // не в зависимости от максимального размера, а в зависимости от взаимного размера ближайших объектов
+        if (prevChild) {
+            var prevChildSize: Point = GetSizeTools.getObjectSize(prevChild);
+            //child.y = prevChild.y + prevChildSize.y + this.settings.spacing.y;
+
+            this.applyChildPosition(
+                child,
+                prevChild.x + prevChildSize.x + this.settings.spacingX,
+                child.y
+            );
+        }
+    }
+
+    /**
+     * Обновление общего размера расстановки.
+     *
+     * @param    container
+     */
+    protected updateTotalSize(container: ILayoutableContainer): void {
+        super.updateTotalSize(container);
+
+        // В однострочных/одностолбцовых расстановках общий размер по одной из сторон должен рассчитываться
+        // не на основе максимального размера, а на положения и размера последнего элемента
+        var childrenCount: number = container.layoutGetChildrenNum();
+        if (childrenCount > 0) {
+            var lastChild: ILayoutableChild = container.layoutGetChildAt(childrenCount - 1);
+            if (lastChild) {
+                var lastChildSize: Point = GetSizeTools.getObjectSize(lastChild);
+                this._totalSize.x = lastChild.x + lastChildSize.x + this.settings.paddingX;
+            }
+        }
+    }
+
+
+    /**
+     * Получение количества строк и столбцов.
+     *
+     * @param    container
+     *
+     * @return
+     */
+    public findRealRowsAndColumnsCount(container: ILayoutableContainer): Point {
+        var result: Point = new Point();
+
+        var childrenCount: number = container.layoutGetChildrenNum();
+        result.x = childrenCount;
+        result.y = 1;
+
+        return result;
+    }
+
+}

package/src/display/views/layout/container/BaseLayoutableContainer.ts

@@ -0,0 +1,21 @@
+import {FContainer} from "@flashist/flibs";
+
+import {ILayoutableContainer} from "./ILayoutableContainer";
+import {ILayoutableChild} from "./ILayoutableChild";
+
+export class BaseLayoutableContainer<ChildType extends ILayoutableChild = ILayoutableChild>
+    extends FContainer
+    implements ILayoutableContainer<ChildType> {
+
+    public children: ChildType[];
+
+    layoutGetChildrenNum(): number {
+        return this.children.length;
+    }
+
+    layoutGetChildAt(index: number): ChildType {
+        return this.children[index];
+    }
+
+}
+	

package/src/display/views/layout/container/ILayoutableChild.ts

@@ -0,0 +1,3 @@
+import {DisplayObjectContainer} from "@flashist/flibs";
+
+export type ILayoutableChild = DisplayObjectContainer;

package/src/display/views/layout/container/ILayoutableContainer.ts

@@ -0,0 +1,18 @@
+import {ILayoutableChild} from "./ILayoutableChild";
+
+/**
+ * ...
+ * @author Mark (ruFlashist@gmail.com)
+ */
+export interface ILayoutableContainer<ChildrenType extends ILayoutableChild = ILayoutableChild> {
+
+    /**
+     * Получение количество дочерних объектов
+     */
+    layoutGetChildrenNum(): number;
+
+    /**
+     * Получение дочернего объекта по индексу
+     */
+    layoutGetChildAt(index: number): ChildrenType;
+}

package/src/display/views/resize/IResizable.ts

@@ -0,0 +1,6 @@
+import {Point} from "@flashist/flibs";
+
+export interface IResizable {
+    resizeSize: Point;
+    resize(width: number, height: number);
+}

package/src/display/views/resize/ResizableContainer.ts

@@ -0,0 +1,80 @@
+import { FContainer, Point } from "@flashist/flibs";
+import { IResizable } from "./IResizable";
+import { AppContainer } from "../AppContainer";
+
+export class ResizableContainer<DataType extends object = object> extends AppContainer<DataType> implements IResizable {
+
+    private _resizeSize: Point;
+    private _maxSize: Point;
+    private _minSize: Point;
+
+    protected construction(...args): void {
+        super.construction(...args);
+
+        this._minSize = new Point();
+        this._maxSize = new Point();
+        this._resizeSize = new Point();
+    }
+
+    public resize(width: number, height: number): void {
+        if (this._minSize.x) {
+            width = Math.max(width, this._minSize.x)
+        }
+        if (this._maxSize.x) {
+            width = Math.min(width, this._maxSize.x)
+        }
+
+        if (this._minSize.y) {
+            height = Math.max(width, this._minSize.y)
+        }
+        if (this._maxSize.y) {
+            height = Math.min(height, this._maxSize.y)
+        }
+
+        this.resizeSize.x = width;
+        this.resizeSize.y = height;
+
+        if (this.isConstructed) {
+            this.arrange();
+        }
+    }
+
+    get minSize(): Point {
+        return this._minSize;
+    }
+    set minSize(value: Point) {
+        if (!value) {
+            return;
+        }
+        if (value.x === this._minSize.x && value.y === this._minSize.y) {
+            return;
+        }
+
+        this._minSize = value.clone();
+
+        this.resize(this.resizeSize.x, this.resizeSize.y);
+    }
+
+    get maxSize(): Point {
+        return this._maxSize;
+    }
+    set maxSize(value: Point) {
+        if (!value) {
+            return;
+        }
+        if (value.x === this._maxSize.x && value.y === this._maxSize.y) {
+            return;
+        }
+
+        this._maxSize = value.clone();
+
+        this.resize(this.resizeSize.x, this.resizeSize.y);
+    }
+
+    public get resizeSize(): Point {
+        return this._resizeSize;
+    }
+    public set resizeSize(value: Point) {
+        throw new Error("Resize size should be changed through the resize method!");
+    }
+}

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

@@ -0,0 +1,5 @@
+import {ILayoutableChild} from "../layout/container/ILayoutableChild";
+
+export interface ISimpleListItem extends ILayoutableChild {
+    //
+}