仿IBM-BPM Editor实现的WorkFlowEditor

最新推荐文章于 2022-06-28 17:25:38 发布
最新推荐文章于 2022-06-28 17:25:38 发布
阅读量532 收藏
点赞数
分类专栏： AS3.0 文章标签： IBM Workflow Flash J#
在网上搜了一些例子，找了一大队资料，终于把workFlowEditor做得差不多了，这是一个类似IBM-BPM Editor的工作流编辑器，现还有一些功能没实现，现将部分代码贴在此，有需要的朋友可以交流，拍砖，哈哈。

上图：
[img]http://dl.iteye.com/upload/attachment/567690/1d83015d-ec06-34cc-b69a-71725bf4104c.jpg[/img]

节点间的连线重绘： 
package com
{
	import flash.geom.Point;

	public class RefreshLine
	{
		/** 和节点相关的线条的数组 **/
		public var lineList:Array = [];

		public var width:Number;
		public var height:Number;
		public var lineFlag:LineLag;
		public var line:Line;
		public var node:Nodes;
		private var isFromNode:Boolean=false;
		private var num1:int=0;		//开始节点，箭头右方向，连线数累加
		private var num2:int=0;		//开始节点，箭头左方向，连线数累加
		private var num3:int=0;		//开始节点，箭头上方向，连线数累加
		private var num4:int=0;		//开始节点，箭头下方向，连线数累加
		private var numA:int=0;		//结束节点，箭头右方向，连线数累加
		private var numB:int=0;		//结束节点，箭头左方向，连线数累加
		private var numC:int=0;		//结束节点，箭头上方向，连线数累加
		private var numD:int=0;		//结束节点，箭头下方向，连线数累加
		private var startX:int;
		private var startY:int;
		private var endX:int;
		private var endY:int;


		public function RefreshLine(node:Nodes)
		{
			this.node=node;
			lineList=node.lineList;
		}

		/**
		 * 重绘节点上的连线
		 * */
		public function getAspectArr():void{
			for(var j:int = 0; j < lineList.length; j++){
				lineFlag = lineList[j];
				line = lineFlag.line;

				switch(line.aspect){
					case 1:
						if(line.fromNode==node)
							num1++;
						else
							numA++;
						break;
					case 2:
						if(line.fromNode==node)
							num2++;
						else
							numB++;
						break;
					case 3:
						if(line.fromNode==node)
							num3++;
						else
							numC++;
						break;
					case 4:
						if(line.fromNode==node)
							num4++;
						else
							numD++;
						break;
				}
			}
		}

		public function refreshLine():void{
			var isHead:Boolean;
			var startNO:int=0;	//指向开始节点的连线的条数
			var endNO:int=0;	//指向结束节点的连线的条数

			width=node.width;
			height=node.height;
			getAspectArr();

			for(var i:int = 0; i < lineList.length; i++){
				startX = node.x;
				startY = node.y;
				endX = node.x;
				endY = node.y;
				lineFlag = lineList[i];
				line = lineFlag.line;
				isHead = lineFlag.isHead;

				if(line.fromNode==node){
					isFromNode=true;
					startNO++;
				}else{
					endNO++;
				}

				switch(node.type){
					case Nodes.NODE:
					case Nodes.EMAIL:
					case Nodes.CLOCK:
					case Nodes.ENDNODE:
						circleNodePosition(startNO,endNO);
						break;
					case Nodes.RECT:
						rectNodePosition(startNO,endNO);
						break;
					case Nodes.BRECT:
						rectNodePosition(startNO,endNO);
						break;
					case Nodes.DIAMOND:
						diamondNodePosition(startNO,endNO);
						break;
				}
				/**
				 * 如果是连线箭头所指的，则重设线条开始位置
				 * 如果不是，则重设连线结束
				 **/ 
				if(isHead)
					line.startPoint = new Point(startX,startY);
				else
					line.endPoint = new Point(endX,endY); 

				line.drawLine(line.aspect);
			}
			num1=0;
			num2=0;
			num3=0;
			num4=0;
			numA=0;
			numB=0;
			numC=0;
			numD=0;
		}

		private function circleNodePosition(startNO:int,endNO:int):void{
			switch(line.aspect){
				case 1:
					//箭头向右
					switch(line.lineStyle){
						case line.lineStyleArr[1]:
							if(line.fromNode.y<line.toNode.y){
								startY+=Nodes.CIRCLE_RADIUS*2+1;
							}else{
								startY-=1;
							}
							startX+=width/2-Nodes.CIRCLE_RADIUS+Nodes.CIRCLE_RADIUS*2/(num1+1)*(startNO);
							break;
						case line.lineStyleArr[2]:
							startX+=13;
							startY+=Nodes.CIRCLE_RADIUS*2/(num1+1)*(startNO);
							break;
						default:
							startX+=width-15;
							startY+=Nodes.CIRCLE_RADIUS*2/(num1+1)*(startNO);
							break;
					}
					endX+=15;
					endY+=Nodes.CIRCLE_RADIUS*2/(numA+1)*(endNO);
					break;
				case 2:
					//箭头向左
					switch(line.lineStyle){
						case line.lineStyleArr[1]:
							if(line.fromNode.y<line.toNode.y){
								startY+=Nodes.CIRCLE_RADIUS*2+1;
							}else{
								startY-=1;
							}
							startX+=width/2-Nodes.CIRCLE_RADIUS+Nodes.CIRCLE_RADIUS*2/(num2+1)*(startNO);
							break;
						case line.lineStyleArr[2]:
							startX+=width-15;
							startY+=Nodes.CIRCLE_RADIUS*2/(num2+1)*(startNO);
							break;
						default:
							startX+=13;
							startY+=Nodes.CIRCLE_RADIUS*2/(num2+1)*(startNO);
							break;
					}
					endX+=width-13;
					endY+=Nodes.CIRCLE_RADIUS*2/(numB+1)*(endNO);
					break;
				case 3:
					//箭头向上
					switch(line.lineStyle){
						case line.lineStyleArr[1]:
							if(line.fromNode.x<line.toNode.x){
								startX+=width-15;
							}else{
								startX+=13;
							}
							startY+=Nodes.CIRCLE_RADIUS*2/(num3+1)*(startNO);
							break;
						case line.lineStyleArr[2]:
							startX+=width/2-Nodes.CIRCLE_RADIUS+Nodes.CIRCLE_RADIUS*2/(num3+1)*(startNO);
							startY+=Nodes.CIRCLE_RADIUS*2+1;
							break;
						default:
							startX+=width/2-Nodes.CIRCLE_RADIUS+Nodes.CIRCLE_RADIUS*2/(num3+1)*(startNO);
							startY-=1;
							break;
					}
					endX+=width/2-Nodes.CIRCLE_RADIUS+Nodes.CIRCLE_RADIUS*2/(numC+1)*(endNO);
					endY+=Nodes.CIRCLE_RADIUS*2+3;
					break;
				case 4:
					//箭头向下
					switch(line.lineStyle){
						case line.lineStyleArr[1]:
							if(line.fromNode.x<line.toNode.x){
								startX+=width-15;
							}else{
								startX+=13;
							}
							startY+=Nodes.CIRCLE_RADIUS*2/(num4+1)*(startNO);
							break;
						case line.lineStyleArr[2]:
							startX+=width/2-Nodes.CIRCLE_RADIUS+Nodes.CIRCLE_RADIUS*2/(num4+1)*(startNO);
							startY-=1;
							break;
						default:
							startX+=width/2-Nodes.CIRCLE_RADIUS+Nodes.CIRCLE_RADIUS*2/(num4+1)*(startNO);
							startY+=Nodes.CIRCLE_RADIUS*2+1;
							break;
					}
					endX+=width/2-Nodes.CIRCLE_RADIUS+Nodes.CIRCLE_RADIUS*2/(numD+1)*(endNO);
					endY-=2;
					break;
			}
		}

		private function rectNodePosition(startNO:int,endNO:int):void{
			switch(line.aspect){
				case 1:
					switch(line.lineStyle){
						case line.lineStyleArr[1]:
							if(line.fromNode.y<line.toNode.y){
								startY+=height+2;
							}else{
								startY-=0;
							}
							startX+=width/(num1+1)*(startNO);
							break;
						case line.lineStyleArr[2]:
							startX-=0;
							startY+=height/(num1+1)*(startNO);
							break;
						default:
							startX+=width;
							startY+=height/(num1+1)*(startNO);
							break;
					}
					endX-=2;
					endY+=height/(numA+1)*(endNO);
					break;
				case 2:
					switch(line.lineStyle){
						case line.lineStyleArr[1]:
							if(line.fromNode.y<line.toNode.y){
								startY+=height+2;
							}else{
								startY-=0;
							}
							startX+=width/(num2+1)*(startNO);
							break;
						case line.lineStyleArr[2]:
							startX+=width;
							startY+=height/(num2+1)*(startNO);
							break;
						default:
							startX-=0;
							startY+=height/(num2+1)*(startNO);
							break;
					}
					endX+=width+2;
					endY+=height/(numB+1)*(endNO);
					break;
				case 3:
					switch(line.lineStyle){
						case line.lineStyleArr[1]:
							if(line.fromNode.x<line.toNode.x){
								startX+=width;
							}else{
								startX-=0;
							}
							startY+=height/(num3+1)*(startNO);
							break;
						case line.lineStyleArr[2]:
							startX+=width/(num3+1)*(startNO);
							startY+=height+2;
							break;
						default:
							startX+=width/(num3+1)*(startNO);
							startY-=0;
							break;
					}
					endX+=width/(numC+1)*(endNO);
					endY+=height+3;
					break;
				case 4:
					switch(line.lineStyle){
						case line.lineStyleArr[1]:
							if(line.fromNode.x<line.toNode.x){
								startX+=width;
							}else{
								startX-=0;
							}
							startY+=height/(num4+1)*(startNO);
							break;
						case line.lineStyleArr[2]:
							startX+=width/(num4+1)*(startNO);
							startY-=0;
							break;
						default:
							startX+=width/(num4+1)*(startNO);
							startY+=height+2;
							break;
					}
					endX+=width/(numD+1)*(endNO);
					endY-=1;
					break;
			}
		}

		private function diamondNodePosition(startNO:int,endNO:int):void{
			switch(line.aspect){
				case 1:
					if((num1<=1 && line.fromNode==node) || (numA<=1 && line.toNode==node)){
						switch(line.lineStyle){
							case line.lineStyleArr[1]:
								if(line.fromNode.y<line.toNode.y){
									startY+=Nodes.DIAMOND_BORDER;
								}else{
									startY-=0;
								}
								startX+=width/2;
								break;
							case line.lineStyleArr[2]:
								startX+=4;
								startY+=Nodes.DIAMOND_BORDER/(num1+1)*(startNO);
								break;
							default:
								startX+=Nodes.DIAMOND_BORDER+6;
								startY+=Nodes.DIAMOND_BORDER/2;
								break;
						}
						endX+=3;
						endY+=Nodes.DIAMOND_BORDER/2;
					}else{
						switch(line.lineStyle){
							case line.lineStyleArr[1]:
								if(line.fromNode.y<line.toNode.y){
									startY+=Nodes.DIAMOND_BORDER-13;
								}else{
									startY+=13;
								}
								startX+=width/(num1+1)*(startNO);
								break;
							case line.lineStyleArr[2]:
								startX+=(width-Nodes.DIAMOND_BORDER)/2+10;
								startY+=Nodes.DIAMOND_BORDER/(num1+1)*(startNO);
								break;
							default:
								startX+=Nodes.DIAMOND_BORDER-6;
								startY+=Nodes.DIAMOND_BORDER/(num1+1)*(startNO);
								break;
						}
						endY+=Nodes.DIAMOND_BORDER/(numA+1)*(endNO);

						if((num1==3 && startNO==2) || (numA==3 && endNO==2)){
							endX+=3;
						}else{
							endX+=15;
						}
					}
					break;
				case 2:
					if((num2<=1 && line.fromNode==node) || (numB<=1 && line.toNode==node)){
						switch(line.lineStyle){
							case line.lineStyleArr[1]:
								if(line.fromNode.y<line.toNode.y){
									startY+=Nodes.DIAMOND_BORDER;
								}else{
									startY-=0;
								}
								startX+=width/2;
								break;
							case line.lineStyleArr[2]:
								startX+=Nodes.DIAMOND_BORDER+6;
								startY+=Nodes.DIAMOND_BORDER/(num2+1)*(startNO);
								break;
							default:
								startX+=4;
								startY+=Nodes.DIAMOND_BORDER/2;
								break;
						}
						endX+=Nodes.DIAMOND_BORDER+6;
						endY+=Nodes.DIAMOND_BORDER/2;
					}else{
						switch(line.lineStyle){
							case line.lineStyleArr[1]:
								if(line.fromNode.y<line.toNode.y){
									startY+=Nodes.DIAMOND_BORDER-13;
								}else{
									startY+=13;
								}
								startX+=width/(num2+1)*(startNO);
								break;
							case line.lineStyleArr[2]:
								startX+=Nodes.DIAMOND_BORDER-6;
								startY+=Nodes.DIAMOND_BORDER/(num2+1)*(startNO);
								break;
							default:
								startX+=(width-Nodes.DIAMOND_BORDER)/2+13;
								startY+=Nodes.DIAMOND_BORDER/(num2+1)*(startNO);
								break;
						}
						endY+=Nodes.DIAMOND_BORDER/(numB+1)*(endNO);

						if((num2==3 && startNO==2) || (numB==3 && endNO==2)){
							endX+=Nodes.DIAMOND_BORDER+7;
						}else{
							endX+=Nodes.DIAMOND_BORDER-4;
						}
					}
					break;
				case 3:
					if((num3<=1 && line.fromNode==node) || (numC<=1 && line.toNode==node)){
						switch(line.lineStyle){
							case line.lineStyleArr[1]:
								if(line.fromNode.x<line.toNode.x){
									startX+=Nodes.DIAMOND_BORDER+6;
								}else{
									startX+=4;
								}
								startY+=Nodes.DIAMOND_BORDER/2;
								break;
							case line.lineStyleArr[2]:
								startX+=width/(num3+1)*(startNO);
								startY+=Nodes.DIAMOND_BORDER;
								break;
							default:
								startX+=width/2;
								startY-=0;
								break;
						}
						endX+=width/2;
						endY+=Nodes.DIAMOND_BORDER+2;
					}else{
						switch(line.lineStyle){
							case line.lineStyleArr[1]:
								if(line.fromNode.x<line.toNode.x){
									startX+=Nodes.DIAMOND_BORDER-13;
								}else{
									startX+=15;
								}
								startY+=Nodes.DIAMOND_BORDER/(num3+1)*(startNO);
								break;
							case line.lineStyleArr[2]:
								startX+=width/(num3+1)*(startNO);
								startY+=Nodes.DIAMOND_BORDER-13;
								break;
							default:
								startX+=width/(num3+1)*(startNO);
								startY+=13;
								break;
						}
						endX+=width/(numC+1)*(endNO);
						if((num3==3 && startNO==2) || (numC==3 && endNO==2)){
							endY+=Nodes.DIAMOND_BORDER+2;
						}else{
							endY+=Nodes.DIAMOND_BORDER-11;
						}
					}
					break;
				case 4:
					if((num4<=1 && line.fromNode==node) || (numD<=1 && line.toNode==node)){
						switch(line.lineStyle){
							case line.lineStyleArr[1]:
								if(line.fromNode.x<line.toNode.x){
									startX+=Nodes.DIAMOND_BORDER+6;
								}else{
									startX+=4;
								}
								startY+=Nodes.DIAMOND_BORDER/2;
								break;
							case line.lineStyleArr[2]:
								startX+=width/(num4+1)*(startNO);
								startY-=0;
								break;
							default:
								startX+=width/2;
								startY+=Nodes.DIAMOND_BORDER;
								break;
						}
						endX+=width/2;
						endY-=1;
					}else{
						switch(line.lineStyle){
							case line.lineStyleArr[1]:
								if(line.fromNode.x<line.toNode.x){
									startX+=Nodes.DIAMOND_BORDER-13;
								}else{
									startX+=15;
								}
								startY+=Nodes.DIAMOND_BORDER/(num4+1)*(startNO);
								break;
							case line.lineStyleArr[2]:
								startX+=width/(num4+1)*(startNO);
								startY+=13;
								break;
							default:
								startX+=width/(num4+1)*(startNO);
								startY+=Nodes.DIAMOND_BORDER-13;
								break;
						}
						endX+=width/(numD+1)*(endNO);
						if((num4==3 && startNO==2) || (numD==3 && endNO==2)){
							endY-=1;
						}else{
							endY+=11;
						}
					}
					break;
			}
		}

	}
}


键盘事件类： 
package com
{
	import flash.events.KeyboardEvent;
	import flash.events.MouseEvent;

	import mx.core.UITextField;

	import net.L4cd.iTrace;

	public class WFKeyboard
	{
		private var node:Nodes;
		private var line:Line;
		private var workFlow:CusWorkFlow;
		private var o:Object;
		/** CusWorkFlow对象的放大/缩小参数 **/
		private var scaleNO:Number=.2;
		/** 封装连线的对象 **/
		private var lineLag1:LineLag;

		public var trace:Function = iTrace.init;

		public function WFKeyboard()
		{

		}

		/** 选择键盘按键ASCII值 **/
		public function chooseKey(e:KeyboardEvent,mouseE:MouseEvent):void {
			o=getObjects(mouseE);
			node=o.node as Nodes;
			line=o.line as Line;
			workFlow=o.workFlow as CusWorkFlow;
			switch(e.keyCode){
				case 8:
				case 46:
					deleteNode(node,line,workFlow);
					break;
				case 65:
					if(!e.ctrlKey)return;

					break;
				case 107:
					if(!e.ctrlKey)return;
					workFlow.scaleX+=scaleNO;//放大CusWorkFlow对象
					workFlow.scaleY+=scaleNO;
					break;
				case 109:
					if(!e.ctrlKey)return;
					workFlow.scaleX-=scaleNO;//缩小CusWorkFlow对象
					workFlow.scaleY-=scaleNO;
					break;
			}
		}

		/** 删除节点或连线 **/
		private function deleteNode(node:Nodes,line:Line,workFlow:CusWorkFlow):void {
			if(!workFlow)return;

			if(node){
				var num:int=node.lineList.length;
				for(var i:int=0;i<num;i++){
					var lineLag:LineLag=node.lineList[i];
					workFlow.removeChild(lineLag.line);

					if(node==lineLag.line.fromNode){
						for(var j:int=0;j<lineLag.line.toNode.lineList.length;j++){
							lineLag1=lineLag.line.toNode.lineList[j] as LineLag;
							if(node==lineLag1.line.fromNode){
								lineLag.line.toNode.lineList.splice(j,1);
							}
						}
					}else{
						for(var k:int=0;k<lineLag.line.fromNode.lineList.length;k++){
							lineLag1=lineLag.line.fromNode.lineList[k] as LineLag;
							if(node==lineLag1.line.toNode){
								lineLag.line.fromNode.lineList.splice(k,1);
							}
						}
					}
				}

				workFlow.removeChild(node);
			}else if(line){
				for(var m:int=0;m<line.toNode.lineList.length;m++){
					lineLag1=line.toNode.lineList[m] as LineLag;
					if(line==lineLag1.line){
						line.toNode.lineList.splice(m,1);
						break;
					}
				}

				for(var n:int=0;n<line.fromNode.lineList.length;n++){
					lineLag1=line.fromNode.lineList[n] as LineLag;
					if(line==lineLag1.line){
						line.fromNode.lineList.splice(n,1);
					}
				}
				workFlow.removeChild(line);
			}
		}

		/** 重画节点边框，表示选中或非选中 **/
		public function reDrawNode(map:Nodes):void{
			switch(map.type){
				case Nodes.NODE:
					map.drawNode();
					break;
				case Nodes.DOC:
					map.drawDoc();
					break;
				case Nodes.EMAIL:
					map.drawEmail();
					break;
				case Nodes.RECT:
					map.drawRect();
					break;
				case Nodes.BRECT:
					map.drawBRect();
					break;
				case Nodes.DIAMOND:
					map.drawDiamond();
					break;
				case Nodes.CLOCK:
					map.drawClock();
					break;
				case Nodes.ENDNODE:
					map.drawEndNode();
					break;
				case Nodes.LEFTDASHED:
					map.drawDashed();
					break;
				case Nodes.RIGHTDASHED:
					map.drawDashed2();
					break;
			}
		}

		/** 返回鼠标选中的对象 **/
		private function getObjects(e:MouseEvent):Object{
			o=new Object();
			if(e.target is UITextField){
				o.node=e.target.parent.parent as Nodes;
				o.workFlow=e.target.parent.parent.parent as CusWorkFlow;
			}else if(e.target is Nodes){
				o.node=e.target as Nodes;
				o.workFlow=e.target.parent as CusWorkFlow;
			}else if(e.target is CusWorkFlow){
				o.workFlow=e.target as CusWorkFlow;
			}else if(e.target is Line){
				o.line=e.target as Line;
				o.workFlow=e.target.parent as CusWorkFlow;
			}
			return o;
		}
	}
}
shilei22
关注
专栏目录
Together Workflow Editor
muduo809的专栏
01-18 1299
# Together Workflow Editor  # Copyright (C) 2010 Together Teamsolutions Co., Ltd. #  # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General
可视化工作流建模工具WorkFlowEditor设计与实现
10-16
针对企业业务过程建模的需求，分析目前典型的工作流过程建模方法，并结合工作流管理联盟提出的XPDL过程定义语言，设计一种可视化工作流建模工具WorkFlowEditor。依据“问题分离”原则，对WFMC的工作流过程定义元模型进行了改进，使建立的模型具有易修改、元素可重用等特点。针对建模元素可扩展性的需求，通过定义建模元素类的通用接口和设计一种动态加载方案，在很好地方便企业用户定制建模元素的同时又不需要修改建模工具。针对多任务多分支环境下复杂的流程编辑问题，设计了一种有限状态机（FSM）模型，实现了复杂编辑动作的实时性处理和灵活控制，降低了时间复杂度，并且实现模块化编程，很好地实现了流程的建模。
workflow_editor:Panoptes 的图形工作流编辑器
06-06
工作流编辑器 Panoptes 的图形工作流编辑器。
纯ActionScript3.0打造的工作流程编辑器(WorkFlowEdit V1.0Bata1.0)
寧缺勿爛
06-17 272
首先,在此要特别感谢Y.Boy,我这个是根据它的UMLer改造过来的. 这是一个纯AS3打造的流程编辑器,目前刚开发测试,还存在很多bug. 想看看效果:   猛击这里     目前实现的功能有:     1.流程图的设计.     2.导出JPG图片到本地.     3.导出XML文件到本地.     4.加载本地XML文件显示出流程图.     5.支持缩略图的显示,可对流...
仿IBM-BPM Monitor实现的demo
07-29
【标题】：“仿IBM-BPM Monitor实现的demo” 在IT领域，流程管理（Business Process Management，BPM）是企业信息化建设中的重要组成部分，它帮助企业优化业务流程，提高工作效率。IBM BPM是一款强大的流程管理工具...
IBM BPM8.5安装详细步骤
12-19
IBM Business Process Manager (BPM) 8.5 是一款先进的业务流程管理软件，它可以帮助企业实现业务流程自动化，提高效率并增强灵活性。本文档将详细介绍IBM BPM 8.5的安装过程，包括必要的Linux环境准备、Oracle...
IBM公司BPM流程管理体系介绍
10-13
流程管理、流程设计、流程简化、IBM、企业流程管理体系建设、再造
改进的IBM BPM流程调试器。「Improved IBM BPM Process Debugger」-crx插件
03-09
通过显示XML数据对象的颜色和可折叠性来改进流程调试器。 通过显示彩色和可折叠的XML数据对象来改进过程调试器。 XML颜色，前景色和背景色是可配置的。 XML属性宽度是可调的，以提高可读性。 提供以下功能的热键：*'...
基于WfMC的工作流,可视化编辑工具Together Workflow Editor 例子(可下载）
睿智科技
06-08 522
最近做项目时，大量地用到了工作流，根据自己的开发实践，和大家分享一下，热烈欢迎网友来拍砖！ 工作流技术是目前发展比较迅速的一项技术，其主要特点就是采用计算机技术，使业务流程部分或全部自动化。工作流管理系统的主要目标是通过调用有关信息资源与人力资源来协调业务流程的各个环节，使之按照一定的顺序依次进行，从而实现业务流程的自动化，提高工作效率。 真是一流企业卖标准，二流...
bpmeditor
06-18
bpmeditor.swf BPM流程元素
最新版工作流编辑器
10-27
对原有工作流在线编辑器的升级版本，界面更漂亮，扩展性更好。欢迎大家加入来对代码就行优化和修改。
SAP workflow
08-13
SAP workflow 创建,修改....看过最好的版本
bpmn-editor:bpmn编辑器
03-12
bpmn编辑 下载 npm install @ 99 cloud / bpmn - editor -- save 该组件有13个传出方法，7个调用方法。 < bpmn xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed> < / bpmn-edior > 13个调用方法： /** * 获取bpmn文件内的高度和宽度 * 传入参数：xml */ getBpmnStyle ( xml ) {
outlineEditor:大纲编辑器。轮廓幕布，workflowy，roamResearch，roamEdit等大纲类笔记所用
03-17
@ mind-kit / outlineEditor 大纲编辑器。 以树形结构编辑和展示文本主要的层级内容。 一块幕布，workflowy，roamResearch，roamEdit等大纲类笔记所用。 React技术栈。 如何运行 git clone ， npm install ， npm run build ，并npm run storybook 。 使用组件- import { EditableTree } from "./EditableTree" ; import { data } from "./data" ; function App ( ) { return < EditableTree xss=removed xss=removed xss=removed> console . log ( data ) } trig
20060427: 部分汉化Together Workflow Editor
weixin_34009794的博客
07-02 343
没有完全汉化完，一方面是没有太多时间，另一方面是工作流概念都生疏了，遇到一些单词不好翻译。文件放在这里。使用方法：解压后将得到的 .properties 文件用 WinRAR 导入到 TWE 的 twelan.jar 中覆盖原文件（那个 jar 当中只有这一个文件）。 转载于:https://www.cnblogs.com/yidinghe/archive/2006/04/27/386370....
IBM FileNet BPM 工作流应用举例
wuqingCL的博客
06-01 566
IBM FileNet BPM 简介 FileNet 业务流程管理 (Business Process management) 软件是国际领先的流程管理软件，许多企业已经开始利用 FileNet BPM 管理自己的业务流程。企业每天都要涉及到数百个流程，怎样保证运作的速度及有条不紊已经成为一个至关重要的问题，BPM 可通过灵活的业务运作来有效地满足不断变化的客户和业务需求，这些根据流...
IDEA2020u以上版本Bpmn文件无Editor属性设置编辑器问题的解决
weixin_42023748的博客
06-28 2207
工作流
BPM流程jar
06-05
根据用户名和实例ID得到当前流程图。网上之前的东西，完善了一下
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值