基于vue和jsplumb的工作流编辑器开发(二)

背景

本文是对 ‘基于vue和jsplumb的工作流编辑器开发’ 的扩展

业务实现

  • 撤销
  • 初始化数据
  • 自动排列
  • 清空数据

撤销

对于撤销的实现,主要是需要一个缓冲内存,存储每次操作之后的数据结构,方便再点击撤销按钮的时候,从缓冲内存中拿出数据结构来渲染页面。

利用数组来存储操作之后的数据结构。

let MEMORY_LIST = [];

这里只缓存10次操作。


$_updateMemoryList() {
    <!--格式化数据结构-->
    const tempItem = this.formatData();

    // max store is 10
    if (MEMORY_LIST.length > 10) {
        MEMORY_LIST.shift();
    }
    MEMORY_LIST.push(tempItem);
    // 更新按钮可操作状态。
    this.$_updateCanUndoBtn();
}

然后在各种操作,比如新增节点,拖拽节点的时候,调用$_updateMemoryList方法

当点击撤销按钮的时候,

handleUndo() {
    if (!this.canUndo) {
        return;
    }

    if (MEMORY_LIST.length > 0) {
        const tempItem = MEMORY_LIST.pop();
        this.$_doClear();
        this.$options.jsPlumb.reset();
        this.$nextTick(() => {
            this.updateFlow(tempItem, this.$_plumbRepaintEverything);
        })
    }

    this.$_updateCanUndoBtn();
},

直接从缓冲内存里面读取数据结构,重新渲染流程图。更新按钮状态。

初始化数据

对于初始化渲染的数据结构

{
    positions:{
        "key":{
            left:'xx',
            top:'xx'
        }
    },
    steps:[
        {
            elementId:'startNode',
            stepId:'uuid',
            nextStep:'uuid'
        },
        {
            "elementId": "switchNode",
            "stepId": "c89829f5-8595-458c-b040-4ff84d27befc",
            "nextSteps": [
                {
                    "nextStep": "d611c32f-b6c0-4b97-80d9-47b783bd93ad",
                },
                {
                    "nextStep": "7bd4fc3d-c3b9-4b19-81dc-e49cd1e7b5c5",
                },
                {
                    "nextStep": "85c30556-75fa-441c-9a1d-0dced21755a5",
                }
            ],
        },
        {
            "elementId": "stopNode",
            "stepId": "d611c32f-b6c0-4b97-80d9-47b783bd93ad",
            "nextStep": null
        },
    ]
}

通过这样的数据结构,然后执行渲染方法updateFlow

updateFlow(editItem, callback) {
    let positions = JSON.parse(editItem.positions);
    let steps = editItem.steps;
    let flowList = [];

    steps.forEach((step) => {
        let flowItem = this.getFlowItemById(step.elementId);

        if (!flowItem) {
            return;
        }
        flowItem.next = [];
        flowItem.prev = [];
        flowItem.uuid = step.stepId;

        let position = positions[step.stepId];

        if (position) {
            flowItem.left = position.left;
            flowItem.top = position.top;
        }

        if (step.nextStep) {
            flowItem.next = [step.nextStep];
        } else if (step.nextSteps) {
            flowItem.next = step.nextSteps.map((nextStep) => {
                return nextStep.nextStep;
            });
        }

        if (flowItem.type !== FLOW_ITEM_TYPE.endNode) {
            //
            if (this.isIfFlowItem(flowItem.type)) {
                let formData = clone(step.nextSteps[0]);
                formData.stepName = step.stepName;
                flowItem.formData = this.getFlowItemFormData(formData);
                // else
                if (formData.isDefault) {
                    flowItem.nextElseId = formData.nextStep;
                    flowItem.nextIfId = step.nextSteps[1].nextStep;
                } else {
                    flowItem.nextIfId = formData.nextStep;
                    flowItem.nextElseId = step.nextSteps[1].nextStep;
                }
                if (step.stepJson) {
                    let stepOtherObj = JSON.parse(step.stepJson);
                    flowItem.formData.ifNodeTitle = stepOtherObj.ifNodeTitle;
                }
            } else if (this.isExpandFlowItem(flowItem.type)) {
                let ruleGroupList = step.nextSteps;
                let formData = {};
                formData.stepName = step.stepName;
                formData.ruleGroupList = ruleGroupList;
                flowItem.formData = formData;
            } else {
                flowItem.formData = this.getFlowItemFormData(step);
            }
        }

        flowList.push(flowItem);
    });

    // update
    flowList.forEach((item) => {
        if (item.next.length > 0) {
            item.next.forEach((id) => {
                let nextItem = _.find(flowList, (tempItem) => {
                    return tempItem.uuid === id;
                });

                if (nextItem) {
                    if (nextItem.prev.indexOf(item.uuid) === -1) {
                        nextItem.prev.push(item.uuid);
                    }
                }
            });
        }
    });
    this.flowList = flowList;

    this.$nextTick(() => {
        //
        flowList.forEach((item) => {
            this.$options.jsPlumb.draggable(item.uuid, {});
        });

        this.$nextTick(() => {
            flowList.forEach((item) => {
                item.next.forEach((id, index) => {
                    let nextFlowItem = this.getFlow(id);
                    if (!this.isTempFlowItem(nextFlowItem)) {
                        this.addFlowItemConnect(item.uuid, id);
                    } else {
                        this.draggableFlowConnect(item.uuid, id, true);
                    }
                    //
                    if (this.isIfFlowItem(item.type)) {
                        let isIf = item.nextIfId === nextFlowItem.uuid;
                        this.createFlowItemLabel(item.uuid, id, isIf ? '是' : '否');
                    } else if (this.isExpandFlowItem(item.type)) {
                        let name = this.getExpandFlowItemName(item, id);
                        this.createFlowItemLabel(item.uuid, id, name);
                    }
                });
            });
            this.$nextTick(() => {
                callback && callback();
            })
        });
    });
},

自动排列

对于自动排列的实现,主要是借鉴了 一种紧凑树形布局算法的实现的实现,写的非常棒,谢谢这位巨人,让我站在了他的肩膀上。

大体的思路就是:

  1. 我们从上往下,先根据相邻节点间地最小间距 FLOW_LEFT_STEP_LENGTH对树进行第一次布局。先初始化根节点的位置 。从根节点开始。人为设定好根节点的坐标 ,然后将根节点的子节点挂在根节点下,且子节点分布在根节点的FLOW_STEP_LENGTH高度下方,子节点彼此间距为FLOW_LEFT_STEP_LENGTH且相对于根节点对称分布。递归进行此步骤,直到所有的节点都布局好。
  2. 然后,我们需要一个hashTree,用作将树保存到一个按层次分别的线性表中。我们将树转换到hashTree。效果图中的树对应hashTree如下:
/**
 * layer [
 *   0  [ node(0) ], 
 *   1  [ node(1), node(2), node(3), node(4), node(5) ],
 *   2  [ node(6), node(7), node(8), node(9), node(10), node(11), node(12), node(13), node(14), node(15), node(16), node(17), node(18), node(19), node(20) ],
 *   3  [ node(21), node(22), node(23), node(24), node(25), node(26), node(27), node(28) ]
 * ]
 */
  1. 从最低层开始从下往上按层遍历hashTree,检测相邻的节点。假设n1,n2为相邻的一对节点,n1的在线性表的下标小于n2。检测n1,n2是否重叠。如果发生重叠,则左边不动,整体往右进行调整。但调整的不是n2节点,而是“与n1的某个祖先节点为兄弟节点的n2的祖先节点”。
  2. 每移动完一个节点,其父节点都会失去对称性,所以要进行调整。但我们不动父节点,只通过往左移动子节点来恢复对称性。
  3. 每次恢复对称性后,有某些子节点又会发生重叠现象,所以这时要回到底层重新开始扫描。
  4. 重复3,4,5步骤,直到所有重叠都被消除,布局完成。

先初始化 开始节点的位置。

 this.tempLayerMap = [];
const startNode = _.find(this.flowList, (flowItem) => {
    return this.isStartFlowItem(flowItem);
});

// init start flow item
startNode.top = FLOW_START_STEP_TOP;
startNode.left = this.getFlowItemInitLeft();

初始化第一层的数据。

this.tempLayerMap[0] = [startNode];

对子树进行递归下降布局

this.$_layoutChild(startNode, 1);

在这个方法里面,遍历所有的子节点,初始化topleft 的位置。

$_layoutChild 方法

$_layoutChild(pre, layer) {
    const nextList = pre.next;
    const nextListLength = nextList.length;

    if (this.tempLayerMap[layer] === undefined) {
        this.tempLayerMap[layer] = [];
    }

    nextList.forEach((nextFlowUUid, index) => {
        const flowItem = this.getFlow(nextFlowUUid);
        // 初始化 top
        flowItem.top = pre.top + FLOW_STEP_LENGTH;
        const startLeft = pre.left - (FLOW_LEFT_STEP_LENGTH * (nextListLength - 1)) / 2
        // 初始化 left
        flowItem.left = startLeft + FLOW_LEFT_STEP_LENGTH * index;
        this.tempLayerMap[layer].push(flowItem);
        if (flowItem.next && flowItem.next.length > 0) {
            this.$_layoutChild(flowItem, layer + 1);
        }
    })

},

然后再 对所有子节点进行上升重叠调整

$_adjustChild()

$_adjustChild() {
    let flowList = null;
    <!--从最底层开始-->
    for (let i = this.tempLayerMap.length - 1; i >= 0; i--) {
        flowList = this.tempLayerMap[i];
        flowList.forEach((flowItem, index) => {
            const leftFlowItem = flowList[index - 1];
            <!--发生重叠-->
            if (leftFlowItem && flowItem.left - leftFlowItem.left < FLOW_LEFT_STEP_LENGTH) {
            <!---->
                const parentFlowItem = this.$_findCommonParentNode(leftFlowItem, flowItem);
                const leftOffset = Math.abs(flowItem.left - leftFlowItem.left) + FLOW_LEFT_STEP_LENGTH;
                <!--更改每个节点的left值--> 
                this.$_translateXTree(parentFlowItem, leftOffset);
                const prevFlowItem = this.getFlow(parentFlowItem.prev[0]);
                <!--居中所有子节点-->
                this.$_centerChild(prevFlowItem);
                <!--移动后下层节点有可能再次发生重叠,所以重新从底层扫描-->
                i = this.tempLayerMap.length;
            }
        })
    }
},

清空数据(重做)

因为涉及到清除掉每个节点信息,以及节点绑定的事件,以及jsPlumb上面绑定的事件,所以不能单纯的清除vue 绑定的 list 数据、

所以我的做法是,找到开始节点,然后一层层的遍历下去,把节点信息以及绑定的jsPlumb信息删除掉。

$_doClear(needInit) {
    const startNode = _.find(this.flowList, (flowItem) => {
        return this.isStartFlowItem(flowItem);
    });

    if (startNode) {
        this.deleteNextFlowItem(startNode.uuid);
        if (needInit) {
            this.$nextTick(() => {
                this.initFlow();
            })
        }

    }
},

项目地址

github: https://github.com/bosscheng/vue-draggable-workflow

demo: https://bosscheng.github.io/vue-draggable-workflow

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
### 回答1: 基于Vue开发的组态编辑器已经有很多开源项目可以使用。Vue是一种流行的JavaScript框架,适用于构建现代且高效的用户界面。 组态编辑器是一种可以帮助开发人员和设计师创建和编辑用户界面的工具。它通常提供了一个可视化界面,允许用户拖放和配置各种组件,并生成相应的代码。 通过使用Vue,开源的组态编辑器可以充分利用Vue的特性。Vue的组件化架构使得创建和嵌套组件变得非常容易,这使得组态编辑器可以提供丰富的组件库以及快速配置和编辑的功能。 这些开源的基于Vue的组态编辑器提供了灵活的自定义选项,可以根据用户的需求进行扩展和定制。通过使用Vue的生态系统中的其他工具和库,如Vuex和Vue Router,组态编辑器可以实现更复杂的功能,如状态管理和路由。 开源的组态编辑器项目还提供了强大的社区支持。开发者可以从其他用户的经验中获益,找到解决问题的方法,并与其他人共享自己的成果。 总之,基于Vue开发的开源组态编辑器是一个非常有用的工具,可以帮助开发人员和设计人员更轻松地创建和编辑用户界面。它利用了Vue的特性和生态系统,并通过强大的社区支持提供了一个简单而灵活的解决方案。 ### 回答2: 基于Vue开发的组态编辑器是一种用于创建、编辑和管理可视化组态的开源工具。它是使用Vue框架开发的,通过Vue的响应式数据绑定、组件化和虚拟DOM等特性,具备高效、灵活和可扩展的特点。 作为一个开源项目,基于Vue开发的组态编辑器允许用户自由使用、修改和分发。这意味着用户可以根据自己的需求自定义组态编辑器的功能、扩展其特性,甚至与其他项目进行集成。这种开源的特性使得组态编辑器具有更高的可定制性和可持续性。 基于Vue开发的组态编辑器不仅可以用于创建静态的组态界面,还可以通过各种交互元素(如按钮、输入框等)实现动态的组态效果。它提供了丰富的组件库,包括图表、控件、容器等,用户可以直接拖拽并配置这些组件来构建自己的组态界面。同时,组态编辑器还支持导入、导出组态配置,方便用户在不同项目之间进行共享和迁移。 基于Vue的组态编辑器具有良好的用户界面和用户体验,通过直观的操作和友好的设计,使用户能够轻松地创建、编辑和管理组态界面。它还提供了丰富的文档和示例,帮助用户快速上手并掌握使用技巧。 总之,基于Vue开发的组态编辑器是一个功能丰富、高度可定制和易于使用的开源工具,可以帮助开发者高效地创建和管理可视化组态界面。无论是个人开发者还是企业项目,都可以从中受益并加速开发进程。 ### 回答3: 基于Vue开发的组态编辑器目前是开源的。组态编辑器是一种可帮助用户设计和配置工控系统界面的工具,Vue作为一种流行的JavaScript框架,在开发过程中提供了诸多便利和灵活性。 开源的组态编辑器可以使用户更容易地创建和定制工控系统界面。它提供了一套易于使用和交互友好的界面组件,可以方便地拖拽、缩放和配置,以实现个性化的界面设计。用户可以根据需求自定义各种组件的样式、布局和交互行为。 基于Vue框架的组态编辑器还具备一些高级功能,如数据绑定和响应式设计。它可以与后端服务器进行数据交互,实现动态的数据展示和更新。同时,在用户修改界面配置时,可以实时反映在界面上,减少开发者的调试时间。 由于是开源的,组态编辑器还具备扩展性和可定制性。开发者可以根据自己的需求进行开发和定制,添加新的功能或者修改现有功能。同时,开源社区的积极参与也可以提供更多的插件和扩展,丰富组态编辑器的功能。 总的来说,基于Vue开发的组态编辑器具有易用性、灵活性和扩展性等优势。它为用户提供了一种方便快捷的方式来设计和定制工控系统界面,帮助用户实现个性化的界面配置。开源的特性也使得组态编辑器可以更好地适应不同的需求,并获得更多的改进和支持。
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值