fineui/src/case/tree/tree.level.js

import {
    shortcut,
    Widget,
    extend,
    isKey,
    each,
    UUID,
    defaults,
    isNotEmptyArray,
    Tree,
    createWidget,
    VerticalLayout, Controller, Events
} from "@/core";
import { ButtonTree, CustomTree } from "@/base";
import { TreeExpander } from "./treeexpander/tree.expander";
import { BasicTreeItem, BasicTreeNode } from "@/case";

@shortcut()
export class LevelTree extends Widget {
    static xtype = "bi.level_tree";

    static EVENT_CHANGE = "EVENT_CHANGE";

    props = {
        baseCls: "bi-level-tree",
        el: {
            chooseType: 0,
        },
        expander: {},
        items: [],
        value: "",
    };

    _init() {
        super._init(...arguments);

        this.initTree(this.options.items);
    }

    _formatItems(nodes, layer, pNode) {
        const self = this;
        each(nodes, (i, node) => {
            const extend = {
                layer,
                height: BI.SIZE_CONSANTS.LIST_ITEM_HEIGHT,
                isFirstNode: i === 0,
                isLastNode: i === nodes.length - 1,
            };
            if (!isKey(node.id)) {
                node.id = UUID();
            }
            extend.pNode = pNode;
            if (node.isParent === true || node.parent === true || isNotEmptyArray(node.children)) {
                extend.type = BasicTreeNode.xtype;
                extend.selectable = false;

                defaults(node, extend);
                self._formatItems(node.children, layer + 1, node);
            } else {
                extend.type = BasicTreeItem.xtype;
                defaults(node, extend);
            }
        });

        return nodes;
    }

    _assertId(sNodes) {
        each(sNodes, (i, node) => {
            if (!isKey(node.id)) {
                node.id = UUID();
            }
        });
    }

    initTree(nodes) {
        const self = this, o = this.options;
        this.empty();
        this._assertId(nodes);
        this.tree = createWidget({
            type: CustomTree.xtype,
            element: this,
            expander: extend({
                type: TreeExpander.xtype,
                el: {},
                isDefaultInit: false,
                selectable: false,
                popup: {
                    type: CustomTree.xtype,
                },
            }, o.expander),
            items: this._formatItems(Tree.transformToTreeFormat(nodes), 0),
            value: o.value,

            el: extend({
                type: ButtonTree.xtype,
                chooseType: 0,
                layouts: [
                    {
                        type: VerticalLayout.xtype,
                    }
                ],
            }, o.el),
        });
        this.tree.on(Controller.EVENT_CHANGE, function (type, value, ob) {
            self.fireEvent(Controller.EVENT_CHANGE, arguments);
            if (type === Events.CLICK) {
                self.fireEvent(LevelTree.EVENT_CHANGE, value, ob);
                self.setValue(value);
            }
        });
    }

    stroke(nodes) {
        this.tree.stroke(nodes);
    }

    populate(items, keyword) {
        items = this._formatItems(Tree.transformToTreeFormat(items), 0);
        this.tree.populate(items, keyword);
    }

    setValue(v) {
        this.tree.setValue(v);
    }

    getValue() {
        return this.tree.getValue();
    }

    getAllLeaves() {
        return this.tree.getAllLeaves();
    }

    getNodeById(id) {
        return this.tree.getNodeById(id);
    }

    getNodeByValue(id) {
        return this.tree.getNodeByValue(id);
    }
}