devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【web系列十四】Jsplumb画布使用方法_前端jsplumb无边画布容器

作者：你好赵伟 | 2024-02-19 22:45:52

赞

踩

前端jsplumb无边画布容器

目录

写在前面

Jsplumb介绍

jsplumb是什么

安装和导入方式

基本概念

主要方法介绍

getInstance()

addEndpoint()

draggable()

开发建议

jsplumb开发实战

实现关系图的显示

数据

数据转换

template

添加端点endpoint

添加连接线connector

实际效果

 整体代码

jsplumb+D3实现自动布局

D3是什么

D3 的优势

安装和导入

 数据转换

 d3生成树状图（自动布局）

其他细节 

效果展示

 整体代码

jsplumb+D3更多交互

修改数据格式

优化页面交互效果

双击弹出菜单

添加、删除操作

更新本地数据

整体代码

参考资料

写在前面

        博主最近的需要实现一个前端绘制拓扑图的工具，并且要求能够编辑节点的信息，以及将拓扑结构传给后端。首先想到的就是Jsplumb，这边记录一下开发过程中的一些知识点，本文中的代码都是基于vue3+ts写的。

Jsplumb介绍

        先给大家推荐一些写的不错的文章和文档。

jsPlumb初认识 - 知乎 (zhihu.com)

jsPlumb 基本概念 - 简书 (jianshu.com)

Overview | jsPlumb Documentation (jsplumbtoolkit.com)

jsplumb 中文基础教程 (wdd.js.org)

jsplumb是什么

        一句话来说就是一个在web端绘制关系图的开源工具。 

安装和导入方式

       安装很简单，直接使用以下命令即可

npm install jsplumb --save

        导入工具

  1. <script lang="ts" setup>
  2. import { jsPlumb } from 'jsplumb';
  3. import type { jsPlumbInstance } from 'jsplumb';
  4. import { onMounted } from 'vue';
  5.  
  6. let jsPlumb_instance: jsPlumbInstance = null;
  7.  
  8. onMounted(() => {
  9.     jsPlumb_instance = jsPlumb.getInstance();
  10.     
  11.     jsPlumb_instance.ready(function() {
  12.         /* code */
  13.     };)
  14. })
  15. </script>

        这里要注意，ready函数是jsplumb的初始化函数，由于jsplumb是基于dom元素的，因此在dom元素挂载上之前jsplumb是无法工作的，所以需要将ready函数放在onMounted函数下。而getInstance函数可以选择放在onMounted也可以放在onBeforeMount中。

基本概念

  • Anchor 锚点：表示一个dom元素上的位置，endpoint可以存在于这个位置。
  • Endpoint 端点：connector一端的可视化表示。
  • Connector 连接：用于连接两个dom元素的可视化表示。
  • Overlays 遮罩层：用于修饰连接器的UI组件，如标签、箭头等。一个连接器上可以同时存在多个overlays。

        官方文档用一句话概括了这些元素

In summary - one Connection is made up of two Endpoints, a Connector, and zero or more Overlays working together to join two elements. Each Endpoint has an associated Anchor.

        翻译过来就是：

总之，一个Connection由两个端点(endpoint)、一个Connector和零个或多个overlay组成，它们一起连接两个元素。每个端点都有一个关联的锚。

主要方法介绍

getInstance()

        创建一个实例

  1. <script lang="ts" setup>
  2. import { jsPlumb } from 'jsplumb';
  3. import type { jsPlumbInstance } from 'jsplumb';
  4. import { onMounted } from 'vue';
  5.  
  6. let jsPlumb_instance: jsPlumbInstance = null;
  7.  
  8. onMounted(() => {
  9.     jsPlumb_instance = jsPlumb.getInstance();
  10. })
  11. </script>

addEndpoint()

        向已有元素增加端点。

  1. <script lang="ts" setup>
  2. ...
  3. import type { EndpointOptions } from "jsplumb";
  4. ...
  5.  
  6. ...
  7. let el = <Element>(document.getElementById("node1");
  8. jsPlumb_instance.addEndpoint(el, <EndpointOptions>{
  9.     isTarget: true,
  10.     isSource: true,
  11.     anchor: "Top"
  12. });
  13. </script>

draggable()

        设置元素是否可拖拽，并可以限制拖拽区域。

  1. <script lang="ts" setup>
  2. ...
  3. import type { DragOptions} from "jsplumb";
  4. ...
  5.  
  6. ...
  7. let el = <Element>(document.getElementById("node1");
  8. jsPlumb_instance.draggable(el, <DragOptions>{
  9.     containment: "jsplumb_canvas"
  10. });
  11. </script>

开发建议

         jsplumb的功能还是很强大的，这里不可能完全罗列出来，也没有必要，但是为了帮助大家更快的上手jsplumb的开发，我在这里提几个建议。

  1. 首先了解一下jsplumb大概能做什么事，有什么基本概念，这块其实就看博主前面写的内容就够了。
  2. 根据开发的需求去官网文档查看是否有满足需求的功能/方法，博主在文中贴出的中文文档不是那么全，但是也可以参考，如果没有找到可以去看那篇英文的。
  3. 功能/方法的语法直接从jsplumb库的index.d.ts中查看，index.d.ts中记录了这个库所有的接口及接口的使用方法，基本上能解决90%的语法问题。
  4. 如果还是有问题，再百度查阅资料。博主也会在后面的篇幅中，给出一些具体的开发实例，大家可以参考，希望能对大家有帮助。

jsplumb开发实战

实现关系图的显示

数据

        首先给出数据，说明一下数据的含义：id、name、value都是指当前节点的属性，in_id表示指向当前节点的另一个节点的id。input表示输入节点的id，output表示的节点会指向一个输出节点。

  1. let input: number[] = [-1];
  2. let output: number[] = [6, 7];
  3. let blocks: PlumbBlock[] = [
  4. 	{
  5. 		id: 0,
  6. 		in_id: [-1],
  7. 		name: "block",
  8. 		value: ["3"]
  9. 	},
  10. 	{
  11. 		id: 1,
  12. 		in_id: [0],
  13. 		name: "block-long",
  14. 		value: ["32"]
  15. 	},
  16. 	{
  17. 		id: 2,
  18. 		in_id: [1],
  19. 		name: "block",
  20. 		value: ["64"]
  21. 	},
  22. 	{
  23. 		id: 3,
  24. 		in_id: [2],
  25. 		name: "block-long",
  26. 		value: ["64"]
  27. 	},
  28. 	{
  29. 		id: 4,
  30. 		in_id: [1, 3],
  31. 		name: "block",
  32. 		value: ["128"]
  33. 	},
  34. 	{
  35. 		id: 5,
  36. 		in_id: [4],
  37. 		name: "block-long",
  38. 		value: ["128"]
  39. 	},
  40. 	{
  41. 		id: 6,
  42. 		in_id: [2, 5],
  43. 		name: "block",
  44. 		value: ["256"]
  45. 	},
  46. 	{
  47. 		id: 7,
  48. 		in_id: [6],
  49. 		name: "block-long",
  50. 		value: ["256"]
  51. 	}
  52. ];

数据转换

        可以看到input和output节点的表示与其他blocks是不同的，并且为了展示的时候这些节点是分开的而不是堆叠在一起，这边需要先做一个数据格式的转换，生成node_list和line_list两个列表，第一个列表包含所有的节点信息（包含了节点的位置偏移信息），第二个列表表示节点之间的连接关系。

  1. export interface PlumbBlock {
  2. 	id: number;
  3. 	name: string;
  4. 	in_id?: number[] | undefined;
  5. 	value?: string[];
  6. 	top?: string;
  7. };
  8.  
  9. let node_list: PlumbBlock[] = [];
  10. let line_list: number[][] = [];  // [Source, Target]
  11.  
  12. function setNodeInfo(): void {
  13. 	let count: number = 0;
  14. 	let step: number = 75;
  15. 	
  16. 	for(let i = 0; i < input.length; ++i) {
  17. 		node_list.push({
  18. 			id: input[i],
  19. 			name: "input",
  20. 			top: count * step + "px",
  21. 		});
  22. 		++count;
  23. 	};
  24. 	
  25. 	for(let i = 0; i < blocks.length; ++i) {
  26. 		node_list.push({
  27. 			id: blocks[i].id,
  28. 			in_id: blocks[i].in_id,
  29. 			name: blocks[i].name,
  30. 			value: blocks[i].value,
  31. 			top: count * step + "px",
  32. 		});
  33. 		++count;
  34. 		
  35. 		let in_id: number[] | undefined = blocks[i].in_id;
  36. 		if(in_id != undefined) {
  37. 			for(let j = 0; j < in_id.length; ++j) 
  38. 				line_list.push([in_id[j], blocks[i].id);
  39. 		}
  40. 	};
  41. 	
  42. 	for(let i = 0; i < output.length; ++i) {
  43. 		let id = blocks.length + i;
  44. 		node_list.push({
  45. 			id: id,
  46. 			name: "output",
  47. 			top: count * step + "px",
  48. 		});
  49. 		++count;
  50. 		
  51. 		line_list.push([output[i], id);
  52. 	};
  53. };

template

        这里使用一个v-for循环来渲染这些数据，也就是说给每个数据生成一个dom元素。这样jsplumb才能工作。

  1. <template>
  2. 	<div id="jsplumb" class="jsplumb">
  3. 		<div 
  4. 		  class="nodes"
  5. 		  v-for="item in node_list"
  6. 		  :key="item.id"
  7. 		  :id="item.id"
  8. 		  :style="{left: '40%', top: item.top}"
  9. 		>{{ item.name }}<div>
  10. 	</div>
  11. </template>
  12.  
  13. <style scoped>
  14. .jsplumb {
  15. 	position: absolute,
  16. 	margin: 10px;
  17. 	left: 45%;
  18. 	width: 50%;
  19. 	height: 800px;
  20. 	box-sizing: bording-box;
  21. 	border: 1px solid black;
  22. }
  23. .nodes {
  24. 	position: absolute;
  25. 	min-width: 60px;
  26. 	height: 40px;
  27. 	color: black;
  28. 	border: 1px solid black;
  29. 	line-height: 40px;
  30. }
  31. </style>

        这里注意两个踩坑点：

  1. 每个节点nodes设置了position:absolute属性，这是实现可拖拽节点的必备属性。
  2. 画布区域jsplumb也设置了position:absolute属性，这是为了保证可拖拽节点的拖拽区域限制是绝对的，而不是相对整个页面的。也就是说，如果画布jsplumb在整个页面上是偏移的，这时候不设置position:absolute的话，当给可拖拽节点设置拖拽区域为jsplumb时，你会发现实际的可拖拽区域是从整个页面的左上角开始算的，这样并不符合我们的需求。

添加端点endpoint

        为每个节点添加端点，注意输入节点input只添加Source端点，输出节点output只添加Target端点，其他节点需要同时添加两类端点。

  1. function addEndpoints(): void {
  2. 	for(let i = 0; i < node_list.length; ++i) {
  3. 		let el = <Element>(document.getElementById(String(node_list[i].id)));
  4. 		
  5. 		jsPlumb_instance.draggable(el, <DragOptions>{ containment: "jsplumb" });
  6. 		if(node_list[i].name != "input") {
  7. 			jsPlumb_instance.addEndpoint(el, <EndpointOptions>{
  8. 				isTarget: true,
  9. 				anchor: "Top",
  10. 				endpoint: <EndpointSpec>["Dot", { radius: 3 }]，
  11. 			});
  12. 		}
  13. 		if(node_list[i].name != "output") {
  14. 			jsPlumb_instance.addEndpoint(el, <EndpointOptions>{
  15. 				isSource: true,
  16. 				anchor: "Bottom",
  17. 				endpoint: <EndpointSpec>["Dot", { radius: 3 }]，
  18. 			});
  19. 		}
  20. 	}
  21. };

添加连接线connector

        这里可以看到我将一些公共属性提取出来了，作为一个参数传入，这是一个小技巧。

  1. let connect_common = {
  2. 	connector: ["Bezier", { curviness: 15 }],
  3. 	anchor: ["Top", "Bottom"],
  4. 	
  5. 	endpoint: <EndpointSpec>["Dot", { radius: 3 }],
  6. 	endpointStyle: {
  7. 		stroke: "black",
  8. 		fill: "white",
  9. 		strokeWidth: 2,
  10. 	},
  11. };
  12.  
  13. function drawLines(): void {
  14. 	for(let i = 0; i < line_list.length; ++i) {
  15. 		let start: Element = document.getElementById(String(line_list[i][0]));
  16. 		let end: Element = document.getElementById(String(line_list[i][1]));
  17. 		
  18. 		jsPlumb_instance.connect(
  19. 			{
  20. 				source: start,
  21. 				target: end,
  22. 				overlays: [["Arrow", { width: 12, length: 12, location: 0.5 }]],
  23. 			},
  24. 			connect_common
  25. 		);
  26. 	}
  27. };

        这里也有两个坑要注意：

  1. 当connector设置为"Bezier"时，其实他包含一个curviness属性用来设置弯曲程度，这个属性可以生效的，并且在官网上有说明，但是在index.d.ts文件中好像没有。
  2. 端点的尺寸问题，在添加端点和连接线的时候都可以设置，以"Dot"举例，尺寸参数时radius，他的默认值是10，如果你想改大一些，那么无论在端点还是连接线那里设置都是可以的，但是如果你想改小一点，你会发现只设置端点或者连接线处的属性是不会生效的。博主猜测是由于元素的端点和连接线的两端都生成了一个可视化图形，并且会互相覆盖，因此需要把两边的尺寸都改小才可以看到效果。

实际效果

        这样就可以显示拓扑结构了，并且可以随意拖拽这些节点。但是看到这里大家也会发现jsplumb一个比较大的问题，没有自动布局，其实也是有的，在jsplumbtoolkits中，但是需要付费。那如果不想花钱咋办呢，不要急，看下一章。

 整体代码

  1. <template>
  2. 	<div id="jsplumb" class="jsplumb">
  3. 		<div 
  4. 		  class="nodes"
  5. 		  v-for="item in node_list"
  6. 		  :key="item.id"
  7. 		  :id="item.id"
  8. 		  :style="{left: '40%', top: item.top}"
  9. 		>{{ item.name }}<div>
  10. 	</div>
  11. </template>
  12.  
  13. <script lang="ts" setup>
  14. import { jsPlumb } from 'jsplumb';
  15. import type { 
  16. 	Element,
  17. 	DragOptions,
  18. 	EndpointOptions,
  19. 	EndpointSpec,
  20. 	jsPlumbInstance,
  21. } from 'jsplumb';
  22. import { onBeforeonMount, onMounted } from 'vue';
  23.  
  24. export interface PlumbBlock {
  25. 	id: number;
  26. 	name: string;
  27. 	in_id?: number[] | undefined;
  28. 	value?: string[];
  29. 	top?: string;
  30. };
  31.  
  32. let jsPlumb_instance: jsPlumbInstance = null;
  33. let node_list: PlumbBlock[] = [];
  34. let line_list: number[][] = [];
  35.  
  36. onBeforeonMount(() => {
  37. 	setNodeInfo();
  38. });
  39.  
  40. onMounted(() => {
  41.     jsPlumb_instance = jsPlumb.getInstance();
  42. 	
  43. 	jsPlumb_instance.ready(function() {
  44. 		addEndpoints();
  45. 		drawLines();
  46. 	});
  47. });
  48.  
  49. let connect_common = {
  50. 	connector: ["Bezier", { curviness: 15 }],
  51. 	anchor: ["Top", "Bottom"],
  52. 	
  53. 	endpoint: <EndpointSpec>["Dot", { radius: 3 }],
  54. 	endpointStyle: {
  55. 		stroke: "black",
  56. 		fill: "white",
  57. 		strokeWidth: 2,
  58. 	},
  59. };
  60. let input: number = -1;
  61. let output: number[] = [6, 7];
  62. let blocks: PlumbBlock[] = [
  63. 	{
  64. 		id: 0,
  65. 		in_id: [-1],
  66. 		name: "block",
  67. 		value: ["3"]
  68. 	},
  69. 	{
  70. 		id: 1,
  71. 		in_id: [0],
  72. 		name: "block-long",
  73. 		value: ["32"]
  74. 	},
  75. 	{
  76. 		id: 2,
  77. 		in_id: [1],
  78. 		name: "block",
  79. 		value: ["64"]
  80. 	},
  81. 	{
  82. 		id: 3,
  83. 		in_id: [2],
  84. 		name: "block-long",
  85. 		value: ["64"]
  86. 	},
  87. 	{
  88. 		id: 4,
  89. 		in_id: [1, 3],
  90. 		name: "block",
  91. 		value: ["128"]
  92. 	},
  93. 	{
  94. 		id: 5,
  95. 		in_id: [4],
  96. 		name: "block-long",
  97. 		value: ["128"]
  98. 	},
  99. 	{
  100. 		id: 6,
  101. 		in_id: [2, 5],
  102. 		name: "block",
  103. 		value: ["256"]
  104. 	},
  105. 	{
  106. 		id: 7,
  107. 		in_id: [6],
  108. 		name: "block-long",
  109. 		value: ["256"]
  110. 	}
  111. ];
  112.  
  113. function setNodeInfo(): void {
  114. 	let count: number = 0;
  115. 	let step: number = 75;
  116. 	
  117. 	node_list.push({
  118. 		id: input,
  119. 		name: "input",
  120. 		top: count * step + "px",
  121. 	});
  122. 	++count;
  123. 	
  124. 	for(let i = 0; i < blocks.length; ++i) {
  125. 		node_list.push({
  126. 			id: blocks[i].id,
  127. 			in_id: blocks[i].in_id,
  128. 			name: blocks[i].name,
  129. 			value: blocks[i].value,
  130. 			top: count * step + "px",
  131. 		});
  132. 		++count;
  133. 		
  134. 		let in_id: number[] | undefined = blocks[i].in_id;
  135. 		if(in_id != undefined) {
  136. 			for(let j = 0; j < in_id.length; ++j) 
  137. 				line_list.push([in_id[j], blocks[i].id);
  138. 		}
  139. 	};
  140. 	
  141. 	for(let i = 0; i < output.length; ++i) {
  142. 		let id = blocks.length + i;
  143. 		node_list.push({
  144. 			id: id,
  145. 			name: "output",
  146. 			top: count * step + "px",
  147. 		});
  148. 		++count;
  149. 		
  150. 		line_list.push([output[i], id);
  151. 	};
  152. };
  153.  
  154. function addEndpoints(): void {
  155. 	for(let i = 0; i < node_list.length; ++i) {
  156. 		let el = <Element>(document.getElementById(String(node_list[i].id)));
  157. 		
  158. 		jsPlumb_instance.draggable(el, <DragOptions>{ containment: "jsplumb" });
  159. 		if(node_list[i].name != "input") {
  160. 			jsPlumb_instance.addEndpoint(el, <EndpointOptions>{
  161. 				isTarget: true,
  162. 				anchor: "Top",
  163. 				endpoint: <EndpointSpec>["Dot", { radius: 3 }],
  164. 			});
  165. 		}
  166. 		if(node_list[i].name != "output") {
  167. 			jsPlumb_instance.addEndpoint(el, <EndpointOptions>{
  168. 				isSource: true,
  169. 				anchor: "Bottom",
  170. 				endpoint: <EndpointSpec>["Dot", { radius: 3 }],
  171. 			});
  172. 		}
  173. 	}
  174. };
  175.  
  176. function drawLines(): void {
  177. 	for(let i = 0; i < line_list.length; ++i) {
  178. 		let start: Element = document.getElementById(<string>(<unknown>line_list[i][0]));
  179. 		let end: Element = document.getElementById(<string>(<unknown>line_list[i][1]));
  180. 		
  181. 		jsPlumb_instance.connect(
  182. 			{
  183. 				source: start,
  184. 				target: end,
  185. 				overlays: [["Arrow", { width: 12, length: 12, location: 0.5 }]],
  186. 			},
  187. 			connect_common
  188. 		);
  189. 	}
  190. };
  191.  
  192. </script>
  193.  
  194. <style scoped>
  195. .jsplumb {
  196. 	position: absolute,
  197. 	margin: 10px;
  198. 	left: 45%;
  199. 	width: 50%;
  200. 	height: 800px;
  201. 	box-sizing: bording-box;
  202. 	border: 1px solid black;
  203. }
  204. .nodes {
  205. 	position: absolute;
  206. 	min-width: 60px;
  207. 	height: 40px;
  208. 	color: black;
  209. 	border: 1px solid black;
  210. 	line-height: 40px;
  211. }
  212. </style>

jsplumb+D3实现自动布局

D3是什么

        D3 的全称是 Data-Driven Document，可以理解为：由数据来决定绘图流程的程序设计模型。D3 是一个JavaScript的函数库，是用来做数据可视化的。将数据变成图形，要想用原生的 HTML、SVG、Canvas 来实现是烦琐和困难的。D3 为我们封装好这些，让开发者能更注重图表的布局和逻辑。

D3 的优势

        JavaScript 的前端可视化库，除了 D3 外还有不少：Highcharts、Echarts、Chart.js。它们可以看作一类的，共同特点是封装层次很高，能够非常简单地制作图表，但是给予开发者控制和设计的空间很少。封装层次太高自然会失去部分自由，但太低又会使程序过长，D3 在这一点上取得了平衡。

安装和导入

        直接使用以下命令。

npm install d3

        导入

import * as D3 from 'd3';

        但是如果你用了ts语言的话会报错Could not find a declaration file for module 'd3'，因为d3是js写的。解决方法很简单，找到vue3工程下的shims-vue.d.ts文件，添加以下内容。

declare module 'd3'

 数据转换

        咱们想要使用d3，就必须遵循d3对数据格式的要求，这里我们会使用树状图，因此需要把原始数据转换成树的形式。

        顺便提一下为什么选择树状图，我想要绘制的图其实也不是完全的树状结构，而是更接近d3的网络结构图。因为树状图的子节点只会存在一个父节点，但是我希望子节点可以存在多个父节点，而网络结构图可以满足这个要求。那为啥不选网络结构图呢，因为我希望生成的图形层级结构更加清晰，这点是树状图的优势，所以关键就是怎么解决树状图不能存在多个父节点的问题了。不过还有一点需要提一下，树状图有一个缺点是不能存在多个输入节点，大家如果由这个需求的话，可能要考虑考虑用其他的图。

        首先，我们先不管这个问题哈，我们先要知道d3的树状图需要什么样的输入，我已经展示在下方了。注意这里要遵循一个原则，即使子节点存在于多个父节点下，也不能在树中存在等多个相同的子节点，否则你会发现绘制的图上有重复的节点，所以我们先根据原始数据的in_id与id的关系来生成树，当子节点存在多个父节点时，将子节点插在id较小的父节点下。最后得到的树应该就是像下面这样。

  1. let blocks_tree: Object = {
  2. 	id: -1;
  3. 	name: "input",
  4. 	children: [
  5. 		{
  6. 			id: 0,
  7. 			name: "block",
  8. 			value: ["3"],
  9. 			children: [
  10. 				{
  11. 					id: 1,
  12. 					name: "block-long",
  13. 					value: ["32"],
  14. 					children: [
  15. 						{
  16. 							id: 2,
  17. 							name: "block",
  18. 							value: ["64"]
  19. 							children: [
  20. 								{
  21. 									id: 3,
  22. 									name: "block-long",
  23. 									value: ["64"],
  24. 								},
  25. 								{
  26. 									id: 6,
  27. 									name: "block",
  28. 									value: ["256"],
  29. 									children: [
  30. 										{
  31. 											id: 7,
  32. 											name: "block-long",
  33. 											value: ["256"],
  34. 											children: [
  35. 												{
  36. 													id: 9,
  37. 													name: "output",
  38. 												},
  39. 											],
  40. 										},
  41. 										{
  42. 											id: 8,
  43. 											name: "output",
  44. 										}
  45. 									],
  46. 								},
  47. 							],
  48. 						},
  49. 						{
  50. 							id: 4,
  51. 							name: "block",
  52. 							value: ["128"],
  53. 							children: [
  54. 								id: 5,
  55. 								name: "block-long",
  56. 								value: ["128"],
  57. 							],
  58. 						},
  59. 					],
  60. 				},
  61. 			],
  62. 		},
  63. 	],
  64. };

        但是我们的原始数据格式是不变的，大家可以回到上面去看原始数据的格式，因此需要一个格式转换的算法，如下，细节说明已经在代码中标注了。

  1. // 创建一个树的接口，必须是嵌套的
  2. export interface BlockTree {
  3. 	id: number;
  4. 	name: string;
  5. 	value?: string[];
  6. 	children?: BlockTree[];
  7. }
  8.  
  9. let blocks_tree: BlockTree = { id: -100, name: "unknown" };  // 初始化
  10.  
  11. function transform(): void {
  12. 	// 生成block_list,包含所有Block和input\output
  13. 	let block_list: PlumbBlock[] = [];
  14. 	
  15. 	block_list.push({
  16. 		id: input,
  17. 		name: "input",
  18. 	});
  19. 	
  20. 	for(let i = 0; i < blocks.length; ++i) {
  21. 		block_list.push({
  22. 			id: blocks[i].id,
  23. 			in_id: blocks[i].in_id,
  24. 			name: blocks[i].name,
  25. 			value: blocks[i].value,
  26. 		});
  27. 	}
  28. 	
  29. 	for(let i = 0; i < output.length; ++i) {
  30. 		let id = blocks.length + i;
  31. 		block_list.push({
  32. 			id: id,
  33. 			in_id: [output[i]],
  34. 			name: "output",
  35. 		});
  36. 	}
  37. 	
  38. 	// 生成树，根据block_list的in_id<->id的关系插入，当一个子级存在多个父级时，将子级插在id较小的父级下
  39. 	blocks_tree = { id: input, name: "input", children: [] }; // 初始化时直接把input插入
  40. 	for(let i = 0; i < block_list.length; ++i) {
  41. 		let in_id = block_list[i].in_id;
  42. 		let min: number = in_id[0]; // 除了input外都是存在in_id的，且循环不包含input
  43. 		
  44. 		for(let j = 1; j < in_id.length; ++j) {
  45. 			if(in_id[j] < min)
  46. 				min = in_id[j];
  47. 		}
  48. 		addChildren(blocks_tree, min, block_list[i]);
  49. 	}
  50. }
  51.  
  52. function addChildren(tree: BlockTree, idx: number, block: PlumbBlock): void {
  53. 	let key: keyof BlockTree;
  54. 	let find: boolean = false;
  55. 	for(key in tree) {
  56. 		if(key == "id") {
  57. 			if(tree[key] != idx)
  58. 				break;  // id不对，直接不用继续比较了
  59. 			else
  60. 				find = true;  // 说明找到叶子了
  61. 		}
  62. 	}
  63. 	
  64. 	if(!find) {
  65. 		if('children' in tree)
  66. 			for(let i = 0; i < tree.children.length; ++i)
  67. 				addChildren(tree.children[i], idx, block);
  68. 	}
  69. 	else {	// 找到叶子后把新的block插在叶子的children属性中
  70. 		// 确保有children属性
  71. 		if(!('children' in tree))
  72. 			tree.children = [];
  73. 			
  74. 		if('value' in block)
  75. 			tree.children.push({
  76. 				id: block.id,
  77. 				name: block.name,
  78. 				value: block.value,
  79. 			});
  80. 		else
  81. 			tree.children.push({
  82. 				id: block.id,
  83. 				name: block.name,
  84. 			});
  85. 	} 
  86. }

 d3生成树状图（自动布局）

        得到了树结构数据后，就可以由d3来生成树状图了。

        这里就是解决之前那个问题的关键了，d3的树状图本来可以直接生成连接线的，使用以下函数。

  1. let links = treeData.links();
  2.  
  3. lineList = links.map(item => {
  4. 	return {
  5. 		source: item.source.data.id,
  6. 		target: item.target.data.id,
  7. 	}
  8. })

        而我这里放弃使用这个函数，而用原先的addEndpoints以及drawLines两个函数替代，这样就可以自由的生成连接线了。

  1. // 修改node的生成方式，使用d3的树状图生成
  2. function setNodeInfo(): void {
  3. 	let data = D3.hierachy(blocks_tree);
  4. 	
  5. 	let style = window.getcomputedStyle(document.getElementById('jsplumb')); // 获取元素的风格
  6. 	let canvas_width: number = Number(style.width.split('px')[0]);
  7. 	let canvas_height: number = Number(style.height.split('px')[0]);
  8. 	
  9. 	// 限制元素的位置
  10. 	let scale_width: number = 0.9;
  11. 	let scale_height: number = 0.9;
  12.  
  13. 	// 创建树，根据jsplumb元素的尺寸来限制树的尺寸，这个size会和nodesize属性冲突
  14. 	let treeGenerator = D3.tree().size([canvas_width * scale_width, canvas_height * scale_height]);
  15. 	let treeData = treeGenerator(data);
  16. 	
  17. 	let nodes = treeData.descendants();
  18. 	
  19. 	node_list.value = nodes.map((item) => {
  20. 		return {
  21. 			id: item.data.id,
  22. 			name: item.data.name,
  23. 			left: item.x + "px",
  24. 			top: item.y + 20+ "px",
  25. 		};
  26. 	});
  27. 	
  28. 	for(let i = 0; i < blocks.length; ++i) {
  29. 		let in_id: number[] | undefined = blocks[i].in_id;
  30. 		if(in_id != undefined) {
  31. 			for(let j = 0; j < in_id.length; ++j) 
  32. 				line_list.push([in_id[j], blocks[i].id);
  33. 		}
  34. 	};
  35. 	
  36. 	for(let i = 0; i < output.length; ++i) 
  37. 		line_list.push([output[i], id);
  38. };

其他细节 

1、由d3生成树状图包括了生成node，这个node的left和top都是由d3得到的，因此都要设置成变量，所以template和接口中也要做相应的改变。

:style="{left: item.left, top: item.top}"
  1. export interface PlumbBlock {
  2. 	id: number;
  3. 	name: string;
  4. 	in_id?: number[] | undefined;
  5. 	value?: string[];
  6. 	left?: string;     // 用来控制元素的水平位置
  7. 	top?: string;
  8. };

 2、为了方便控制生成的内容style，直接将common设置成jsplumb的全局属性了，但是要注意所有属性是首字母大写的

  1. let common: Object = {
  2. 	Connector: ["Bezier", { curviness: 15 }],
  3. 	Overlays: [["Arrow", { width: 12, length: 12, location: 0.5 }]], 
  4. 	Anchor: ["AutoDefault"], // 这是由于自动布局的话，难以保证层级关系非常合理，容易产生输入输出的连接线出现在同一端点上的情况，使用autodefault可以看上去更加合理
  5. 	//anchor: ["Top", "Bottom"],
  6. 	
  7. 	Endpoint: <EndpointSpec>["Dot", { radius: 3 }],
  8. 	EndpointStyle: {
  9. 		stroke: "black",
  10. 		fill: "white",
  11. 		strokeWidth: 2,
  12. 	},
  13. };

 3、函数的位置也很关键，我在下方标注了。

  1. onBeforeonMount(() => {
  2. 	transform();  // 用来生成树
  3. });
  4.  
  5. onMounted(() => {
  6. 	setNodeInfo();  // 移到这里是因为为了根据页面尺寸自适应的生成树，因此需要等jsplumb挂载完
  7.     jsPlumb_instance = jsPlumb.getInstance();
  8. 	
  9. 	jsPlumb_instance.ready(function() {
  10. 		nextTick(() => {    // 增加nextTick是为了等待树的元素都挂载完，这样addEndpoints中才能给元素添加端点
  11. 			addEndpoints();
  12. 			drawLines();
  13. 		})
  14. 	});
  15. });

效果展示

        效果如下，是不是还不错。

 整体代码

  1. <template>
  2. 	<div id="jsplumb" class="jsplumb">
  3. 		<div 
  4. 		  class="nodes"
  5. 		  v-for="item in node_list"
  6. 		  :key="item.id"
  7. 		  :id="item.id"
  8. 		  :style="{left: item.left, top: item.top}"
  9. 		>{{ item.name }}<div>
  10. 	</div>
  11. </template>
  12.  
  13. <script lang="ts" setup>
  14. import { jsPlumb } from 'jsplumb';
  15. import * as D3 from 'd3';
  16. import type { 
  17. 	Element,
  18. 	DragOptions,
  19. 	EndpointOptions,
  20. 	EndpointSpec,
  21. 	jsPlumbInstance,
  22. } from 'jsplumb';
  23. import { ref, onBeforeonMount, onMounted, nextTick } from 'vue';
  24.  
  25. // 创建一个树的接口，必须是嵌套的
  26. export interface BlockTree {
  27. 	id: number;
  28. 	name: string;
  29. 	value?: string[];
  30. 	children?: BlockTree[];
  31. }
  32.  
  33. export interface PlumbBlock {
  34. 	id: number;
  35. 	name: string;
  36. 	in_id?: number[] | undefined;
  37. 	value?: string[];
  38. 	left?: string;     // 用来控制元素的水平位置
  39. 	top?: string;
  40. };
  41.  
  42. let jsPlumb_instance: jsPlumbInstance = null;
  43. let blocks_tree: BlockTree = { id: -100, name: "unknown" };  // 初始化
  44. let node_list= ref<PlumbBlock>([]);  // 需要改成ref的
  45. let line_list: number[][] = [];
  46.  
  47. onBeforeonMount(() => {
  48. 	transform();  // 用来生成树
  49. });
  50.  
  51. onMounted(() => {
  52. 	setNodeInfo();  // 移到这里是因为为了根据页面尺寸自适应的生成树，因此需要等jsplumb挂载完
  53.     jsPlumb_instance = jsPlumb.getInstance();
  54.     jsPlumb_instance.importDefaults(common);
  55. 	
  56. 	jsPlumb_instance.ready(function() {
  57. 		nextTick(() => {    // 增加nextTick是为了等待树的元素都挂载完，这样addEndpoints中才能给元素添加端点
  58. 			addEndpoints();
  59. 			drawLines();
  60. 		})
  61. 	});
  62. });
  63.  
  64. // 直接设置成jsplumb的全局属性了，但是要注意所有属性是首字母大写的
  65. let common: Object = {
  66. 	Connector: ["Bezier", { curviness: 15 }],
  67. 	Overlays: [["Arrow", { width: 12, length: 12, location: 0.5 }]], 
  68. 	Anchor: ["AutoDefault"], // 这是由于自动布局的话，难以保证层级关系非常合理，容易产生输入输出的连接线出现在同一端点上的情况，使用autodefault可以看上去更加合理
  69. 	//Anchor: ["Top", "Bottom"],
  70. 	
  71. 	Endpoint: <EndpointSpec>["Dot", { radius: 3 }],
  72. 	EndpointStyle: {
  73. 		stroke: "black",
  74. 		fill: "white",
  75. 		strokeWidth: 2,
  76. 	},
  77. };
  78. let input: number = -1;
  79. let output: number[] = [6, 7];
  80. let blocks: PlumbBlock[] = [
  81. 	{
  82. 		id: 0,
  83. 		in_id: [-1],
  84. 		name: "block",
  85. 		value: ["3"]
  86. 	},
  87. 	{
  88. 		id: 1,
  89. 		in_id: [0],
  90. 		name: "block-long",
  91. 		value: ["32"]
  92. 	},
  93. 	{
  94. 		id: 2,
  95. 		in_id: [1],
  96. 		name: "block",
  97. 		value: ["64"]
  98. 	},
  99. 	{
  100. 		id: 3,
  101. 		in_id: [2],
  102. 		name: "block-long",
  103. 		value: ["64"]
  104. 	},
  105. 	{
  106. 		id: 4,
  107. 		in_id: [1, 3],
  108. 		name: "block",
  109. 		value: ["128"]
  110. 	},
  111. 	{
  112. 		id: 5,
  113. 		in_id: [4],
  114. 		name: "block-long",
  115. 		value: ["128"]
  116. 	},
  117. 	{
  118. 		id: 6,
  119. 		in_id: [2, 5],
  120. 		name: "block",
  121. 		value: ["256"]
  122. 	},
  123. 	{
  124. 		id: 7,
  125. 		in_id: [6],
  126. 		name: "block-long",
  127. 		value: ["256"]
  128. 	}
  129. ];
  130.  
  131. function transform(): void {
  132. 	// 生成block_list,包含所有Block和input\output
  133. 	let block_list: PlumbBlock[] = [];
  134. 	
  135. 	block_list.push({
  136. 		id: input,
  137. 		name: "input",
  138. 	});
  139. 	
  140. 	for(let i = 0; i < blocks.length; ++i) {
  141. 		block_list.push({
  142. 			id: blocks[i].id,
  143. 			in_id: blocks[i].in_id,
  144. 			name: blocks[i].name,
  145. 			value: blocks[i].value,
  146. 		});
  147. 	}
  148. 	
  149. 	for(let i = 0; i < output.length; ++i) {
  150. 		let id = blocks.length + i;
  151. 		block_list.push({
  152. 			id: id,
  153. 			in_id: [output[i]],
  154. 			name: "output",
  155. 		});
  156. 	}
  157. 	
  158. 	// 生成树，根据block_list的in_id<->id的关系插入，当一个子级存在多个父级时，将子级插在id较小的父级下
  159. 	blocks_tree = { id: input, name: "input", children: [] }; // 初始化时直接把input插入
  160. 	for(let i = 0; i < block_list.length; ++i) {
  161. 		let in_id = block_list[i].in_id;
  162. 		let min: number = in_id[0]; // 除了input外都是存在in_id的，且循环不包含input
  163. 		
  164. 		for(let j = 1; j < in_id.length; ++j) {
  165. 			if(in_id[j] < min)
  166. 				min = in_id[j];
  167. 		}
  168. 		addChildren(blocks_tree, min, block_list[i]);
  169. 	}
  170. }
  171.  
  172. function addChildren(tree: BlockTree, idx: number, block: PlumbBlock): void {
  173. 	let key: keyof BlockTree;
  174. 	let find: boolean = false;
  175. 	for(key in tree) {
  176. 		if(key == "id") {
  177. 			if(tree[key] != idx)
  178. 				break;  // id不对，直接不用继续比较了
  179. 			else
  180. 				find = true;  // 说明找到叶子了
  181. 		}
  182. 	}
  183. 	
  184. 	if(!find) {
  185. 		if('children' in tree)
  186. 			for(let i = 0; i < tree.children.length; ++i)
  187. 				addChildren(tree.children[i], idx, block);
  188. 	}
  189. 	else {	// 找到叶子后把新的block插在叶子的children属性中
  190. 		// 确保有children属性
  191. 		if(!('children' in tree))
  192. 			tree.children = [];
  193. 			
  194. 		if('value' in block)
  195. 			tree.children.push({
  196. 				id: block.id,
  197. 				name: block.name,
  198. 				value: block.value,
  199. 			});
  200. 		else
  201. 			tree.children.push({
  202. 				id: block.id,
  203. 				name: block.name,
  204. 			});
  205. 	} 
  206. }
  207.  
  208.  
  209. // 修改node的生成方式，使用d3的树状图生成
  210. function setNodeInfo(): void {
  211. 	let data = D3.hierachy(blocks_tree);
  212. 	
  213. 	let style = window.getcomputedStyle(document.getElementById('jsplumb')); // 获取元素的风格
  214. 	let canvas_width: number = Number(style.width.split('px')[0]);
  215. 	let canvas_height: number = Number(style.height.split('px')[0]);
  216. 	
  217. 	// 限制元素的位置
  218. 	let scale_width: number = 0.9;
  219. 	let scale_height: number = 0.9;
  220.  
  221. 	// 创建树，根据jsplumb元素的尺寸来限制树的尺寸，这个size会和nodesize属性冲突
  222. 	let treeGenerator = D3.tree().size([canvas_width * scale_width, canvas_height * scale_height]);
  223. 	let treeData = treeGenerator(data);
  224. 	
  225. 	let nodes = treeData.descendants();
  226. 	
  227. 	node_list.value = nodes.map((item) => {
  228. 		return {
  229. 			id: item.data.id,
  230. 			name: item.data.name,
  231. 			left: item.x + "px",
  232. 			top: item.y + 20+ "px",
  233. 		};
  234. 	});
  235. 	
  236. 	for(let i = 0; i < blocks.length; ++i) {
  237. 		let in_id: number[] | undefined = blocks[i].in_id;
  238. 		if(in_id != undefined) {
  239. 			for(let j = 0; j < in_id.length; ++j) 
  240. 				line_list.push([in_id[j], blocks[i].id);
  241. 		}
  242. 	};
  243. 	
  244. 	for(let i = 0; i < output.length; ++i) 
  245. 		line_list.push([output[i], id);
  246. };
  247.  
  248. function addEndpoints(): void {
  249. 	for(let i = 0; i < node_list.value.length; ++i) {
  250. 		let el = <Element>(document.getElementById(String(node_list.value[i].id)));
  251. 		
  252. 		jsPlumb_instance.draggable(el, <DragOptions>{ containment: "jsplumb" });
  253. 		if(node_list.value[i].name != "input") {
  254. 			jsPlumb_instance.addEndpoint(el, <EndpointOptions>{
  255. 				isTarget: true,
  256. 				anchor: "Top",
  257. 				endpoint: <EndpointSpec>["Dot", { radius: 3 }],
  258. 			});
  259. 		}
  260. 		if(node_list.value[i].name != "output") {
  261. 			jsPlumb_instance.addEndpoint(el, <EndpointOptions>{
  262. 				isSource: true,
  263. 				anchor: "Bottom",
  264. 				endpoint: <EndpointSpec>["Dot", { radius: 3 }],
  265. 			});
  266. 		}
  267. 	}
  268. };
  269.  
  270. function drawLines(): void {
  271. 	for(let i = 0; i < line_list.length; ++i) {
  272. 		let start: Element = document.getElementById(String(line_list[i][0]));
  273. 		let end: Element = document.getElementById(String(line_list[i][1]));
  274. 		
  275. 		jsPlumb_instance.connect({
  276. 			source: start,
  277. 			target: end,
  278. 		});
  279. 	}
  280. };
  281.  
  282. </script>
  283.  
  284. <style scoped>
  285. .jsplumb {
  286. 	position: absolute,
  287. 	margin: 10px;
  288. 	left: 45%;
  289. 	width: 50%;
  290. 	height: 800px;
  291. 	box-sizing: bording-box;
  292. 	border: 1px solid black;
  293. }
  294. .nodes {
  295. 	position: absolute;
  296. 	min-width: 60px;
  297. 	height: 40px;
  298. 	color: black;
  299. 	border: 1px solid black;
  300. 	line-height: 40px;
  301. 	padding: 0 10px;
  302. }
  303. </style>

jsplumb+D3更多交互

修改数据格式

        为了便于存储和更新数据，也为了让逻辑更加清晰，先对数据格式做了以下修改：

1、拆分PlumbBlock接口，PlumbBlock为存储原始数据的最小单元，PlumbNode为画布显示的最小单元

  1. interface PlumbBlock {
  2. 	id: number;
  3. 	name: string;
  4. 	in_id?: number[] | undefined;
  5. 	value?: string[];
  6. };
  7.  
  8. interface PlumbNode {
  9. 	id: number;
  10. 	name: string;
  11. 	left: string;
  12. 	top: string;
  13. }

2、将input、output、blocks合并成一个block_list

  1. let block_list: PlumbBlock = [];
  2. block_list = [
  3. 	{
  4. 		id: -1,
  5. 		name: "input",
  6. 	},
  7. 	{
  8. 		id: 0,
  9. 		in_id: [-1],
  10. 		name: "block",
  11. 		value: ["3"]
  12. 	},
  13. 	{
  14. 		id: 1,
  15. 		in_id: [0],
  16. 		name: "block-long",
  17. 		value: ["32"]
  18. 	},
  19. 	{
  20. 		id: 2,
  21. 		in_id: [1],
  22. 		name: "block",
  23. 		value: ["64"]
  24. 	},
  25. 	{
  26. 		id: 3,
  27. 		in_id: [2],
  28. 		name: "block-long",
  29. 		value: ["64"]
  30. 	},
  31. 	{
  32. 		id: 4,
  33. 		in_id: [1, 3],
  34. 		name: "block",
  35. 		value: ["128"]
  36. 	},
  37. 	{
  38. 		id: 5,
  39. 		in_id: [4],
  40. 		name: "block-long",
  41. 		value: ["128"]
  42. 	},
  43. 	{
  44. 		id: 6,
  45. 		in_id: [2, 5],
  46. 		name: "block",
  47. 		value: ["256"]
  48. 	},
  49. 	{
  50. 		id: 7,
  51. 		in_id: [6],
  52. 		name: "block-long",
  53. 		value: ["256"]
  54. 	},
  55. 	{
  56. 		id: 8,
  57. 		in_id: [6],
  58. 		name: "output"
  59. 	},
  60. 	{
  61. 		id: 9,
  62. 		in_id: [7],
  63. 		name: "output"
  64. 	}
  65. ];

优化页面交互效果

       修改jsplumb默认配置、template和css，实现鼠标悬停可以高亮节点和连线。

  1. <template>
  2. 	<div id="jsplumb" class="jsplumb">
  3. 		<div 
  4. 		  class="nodes"
  5. 		  v-for="item in node_list"
  6. 		  :key="item.id"
  7. 		  :id="item.id"
  8. 		  @mouseleave="mouseleave(item.id)"
  9. 		  :style="{left: item.left, top: item.top}"
  10. 		>{{ item.name }}<div>
  11. 	</div>
  12. </template>
  13.  
  14. <script lang="ts" setup>
  15. // 直接设置成jsplumb的全局属性了，但是要注意所有属性是首字母大写的
  16. let common: Object = {
  17. 	Overlays: [["Arrow", { width: 12, length: 12, location: 0.5 }]], 
  18. 	Anchor: ["Top", "Bottom"], 
  19. 	
  20. 	MaxConnections: -1,    // 每个端点可以连接多条线
  21. 	Connector: ["Bezier", { curviness: 15 }],
  22. 	PaintStyle: {           // 聚焦前的style
  23. 		stroke: "#99ccff",
  24. 		strokeWidth: 3,
  25. 	},
  26. 	HoverPaintStyle: {      // 聚焦后的style
  27. 		stroke: "#0077cc",
  28. 		strokeWidth: 4,
  29. 	},
  30. 	
  31. 	Endpoint: <EndpointSpec>["Dot", { radius: 3 }],
  32. 	EndpointStyle: {        // 聚焦前的style
  33. 		stroke: "#77ccff",
  34. 		fill: "#ffffff",
  35. 		strokeWidth: 2,
  36. 	},
  37. 	EndpointHoverStyle: {   // 聚焦后的style   
  38. 		stroke: "#0077cc",
  39. 		fill: "#0077cc",
  40. 		strokeWidth: 2,
  41. 	},
  42. };
  43.  
  44. // 移动节点后需要在鼠标离开后更新当前位置
  45. function mouseleave(id: number): void {
  46. 	let style = window.getcomputedStyle(document.getElementById(String(id)));
  47. 	for(let i = 0; i < node_list,value.length; ++i) {
  48. 		if(node_list.value[i].id === id) {
  49. 			node_list.value[i].left = style.left;
  50. 			node_list.vlaue[i].top = style.top;
  51. 		}
  52. 	}
  53. }
  54. </script>
  55.  
  56. <style scoped>
  57. .jsplumb {
  58. 	position: absolute,
  59. 	margin: 10px;
  60. 	left: 45%;
  61. 	width: 50%;
  62. 	height: 800px;
  63. 	box-sizing: bording-box;
  64. 	border: 1px solid black;
  65. }
  66. .nodes {
  67. 	position: absolute;
  68. 	min-width: 60px;
  69. 	height: 40px;
  70. 	color: black;
  71. 	border: 1px solid black;
  72. 	background-color: #eeeeee;
  73. 	line-height: 40px;
  74. 	padding: 0 10px;
  75. }
  76. .nodes:hover{  
  77. 	position: absolute;
  78. 	min-width: 60px;
  79. 	height: 40px;
  80. 	color: black;
  81. 	border: 1px solid black;
  82. 	background-color: #eeeeaa;
  83. 	line-height: 40px;
  84. 	padding: 0 10px;
  85. }
  86. </style>

        正常界面。

         鼠标悬停在节点上。

         鼠标悬停在连接线上。

双击弹出菜单

        双击节点或连接线，可以弹出操作菜单。

  1. <template>
  2. 	<div id="jsplumb" class="jsplumb">
  3. 		<div
  4. 			class="menu"
  5. 			v-if="show"
  6. 			:style="{
  7. 				left: menu_left,
  8. 				top: menu_top,
  9. 			}"
  10. 		>
  11. 			<el-button class="button" @click="remove" type="danger">删除</el-button>
  12. 			<el-button class="button" @click="cancel" type="primary">取消</el-button>
  13. 		</div>
  14. 	</div>
  15. </template>
  16.  
  17. <script lang="ts" setup>
  18. let show = ref<boolean>(false); // 控制菜单的显示
  19. let menu_left = ref<string>(""); // 控制菜单的水平位置
  20. let menu_top = ref<string>(""); // 控制菜单的垂直位置
  21.  
  22. // 节点双击弹出菜单，
  23. function dblclick(id: number): void {
  24. 	let style = window.getcomputedStyle(document.getElementById(String(id)));   // 获取dom元素信息
  25. 	let x: string = Number(style.left.split('px')[0]) + Number(style.width.split('px')[0]) + "px"; // 想定位精确一点的话还应该加上padding、border等参数，这些都可以在style中获取
  26. 	let y: string = Number(style.top.split('px')[0]) + 'px';
  27. 	
  28. 	menu_left.value = x;
  29. 	menu_top.value = y;
  30. 	show.value = true;
  31. 	cur_type = DomType.node;
  32. 	cur_source_id = String(id);
  33. }
  34.  
  35. // 连接线事件都在这儿
  36. function bindEvent(): void {
  37. 	// 双击弹出菜单
  38. 	jsPlumb_instance.bind("dblclick", function(info) {
  39. 		let style = window.getcomputedStyle(document.getElementById(info.sourceId));
  40. 		let x_1: string = Number(style.left.split('px')[0]) + Number(style.width.split('px')[0];
  41. 		let y_1: string = Number(style.top.split('px')[0]) + Number(style.height.split('px')[0]);
  42. 		style = window.getcomputedStyle(document.getElementById(info.targetIdId));
  43. 		let x_2: string = Number(style.left.split('px')[0]) + Number(style.width.split('px')[0];
  44. 		let y_2: string = Number(style.top.split('px')[0]);
  45. 		
  46. 		let x: string = (x_1 + x_2) / 2 + 'px';
  47. 		let y: string = (y_1 + y_2) / 2 + 'px';
  48. 		
  49. 		menu_left.value = x;
  50. 		menu_top.value = y;
  51. 		show.value = true;
  52. 		cur_type = DomType.connection;
  53. 		cur_source_id = info.sourceId;
  54. 		cur_source_id = info.targetId;
  55. 	});
  56. }
  57. </script>
  58.  
  59. <style scoped>
  60. .menu {
  61. 	position：absolute;
  62. }
  63. </style>

         双击节点

         双击连接线

添加、删除操作

         实现节点或连接线的添加和删除。

  1. // 用于区分Dom元素的类型，做逻辑判断用
  2. enum DomType {
  3. 	empty,
  4. 	node,
  5. 	connection
  6. }
  7.  
  8. let cur_type: DomType = DomType.empty;
  9. let cur_source_id: string = ""; 
  10. let cur_target_id: string = "";
  11.  
  12. function remove(): void {
  13. 	if(cur_type === DomType.node && cur_source_id ！== "") {
  14. 		let find: boolean = false;
  15. 		for (let i = 1; i < block_list.length; ++i) {
  16. 			if(String(block_list[i].id) === cur_source_id) {
  17. 				block_list.splice(i, 1);
  18. 				find = true;
  19. 				break;
  20. 			}
  21. 		}
  22. 		// 删除节点及其连接线
  23. 		jsPlumb_instance.remove(cur_source_id);
  24. 	}
  25. 	else if(cur_type === DomType.connect && cur_source_id !== "" && cur_target_id !== "") {
  26. 		let connections = jsPlumb_instance.getAllConnections();  // 找到所有连接
  27. 		for(let idx in connections) {
  28. 			if(connections[idx].sourceId === cur_source_id && connections[idx].targetId === cur_target_id) {   // 筛选出首尾相同的连接并删除
  29. 				jsPlumb_instance.deleteConnection(connections[idx]);
  30. 				break;
  31. 			}
  32. 		}
  33. 	}
  34. 	show.value = false;
  35. 	cur_type = DomType.empty;
  36. }
  37.  
  38. function cancel(): void {
  39. 	show.value = false;
  40. 	cur_type = DomType.empty;
  41. }
  42.  
  43. // 连接线事件都在这儿
  44. function bindEvent(): void {
  45. 	// 连接节点，删除重复连接，并确保output节点只有一个输入
  46. 	jsPlumb_instance.bind("connection", function(info) {
  47. 		// target是output
  48. 		for (let i = 1; i < block_list.length; ++i) {
  49. 			if(String(block_list[i].id) === info.targetId && block_list[i].name === "output" && block_list[i].in_id.length > 0) {
  50. 				let arr = jsPlumb_instance.select({ target: info.targetId });
  51. 				if(arr.length > 1) {
  52. 					block_list.splice(i, 1);
  53. 					break;
  54. 				}
  55. 			}
  56. 		}
  57. 		// target不是output
  58. 		let arr = jsPlumb_instance.select({ source: info.sourceId, target: info.targetId });
  59. 		if(arr.length > 1)
  60. 			jsPlumb_instance.deleteConnection(info.connection);
  61. 		
  62. 		need_update.value = true;
  63. 	});
  64. 	
  65. 	// 删除连接线，更新数据
  66. 	jsPlumb_instance.bind("connectionDetached", function(info) {
  67. 		need_update.value = true;
  68. 	});
  69. }

        添加连接线。

         删除节点。

更新本地数据

        获取画布上的连接信息，更新本地数据。

  1. let need_update = ref<boolean>(false);  // 由watch监视，决定是否更新数据
  2.  
  3. // 连接线事件都在这儿
  4. function bindEvent(): void {
  5. 	// 连接节点，删除重复连接，并确保output节点只有一个输入
  6. 	jsPlumb_instance.bind("connection", function(info) {
  7.         // ...
  8. 		need_update.value = true;
  9. 	});
  10. 	
  11. 	// 删除连接线，更新数据
  12. 	jsPlumb_instance.bind("connectionDetached", function(info) {
  13. 		need_update.value = true;
  14. 	});
  15. }
  16.  
  17. // 更新block_list中的连接关系
  18. function update(): void {
  19. 	let connections = jsPlumb_instance.getAllConnections();
  20. 	// 先清空
  21. 	for(let i = 1; i < block_list.length; ++i)
  22. 		block_list[i].in_id.splice(0, block_list[i].in_id.length);
  23. 		
  24. 	// 插入新的连接线
  25. 	for(let i = 0; i < connections.length; ++i) {
  26. 		for(let j = 1; j < block_list.length; ++j) {
  27. 			if(String(block_list[j].id) === connection[i].targetId)
  28. 				block_list[j].in_id.push(Number(connections[i].sourceId));
  29. 		}
  30. 	}
  31. 	need_update.value = false;
  32. }
  33.  
  34. // 监视need_update
  35. watch(
  36. 	() => need_update.value,
  37. 	(cur: boolean, pre: boolean) => {
  38. 		if(cur === true)
  39. 			update();
  40. 	}
  41. );

         删除一个节点后更新数据，可以看到id为1的节点和相关的in_id没有了。

整体代码

  1. <template>
  2. 	<div id="jsplumb" class="jsplumb">
  3. 		<div 
  4. 		  class="nodes"
  5. 		  v-for="item in node_list"
  6. 		  :key="item.id"
  7. 		  :id="item.id"
  8. 		  @mouseleave="mouseleave(item.id)"
  9. 		  @dblclick="dblclick(item.id)"
  10. 		  :style="{left: item.left, top: item.top}"
  11. 		>{{ item.name }}<div>
  12. 		<!--增加两个交互操作-->
  13. 		<div
  14. 			class="menu"
  15. 			v-if="show"
  16. 			:style="{
  17. 				left: menu_left,
  18. 				top: menu_top,
  19. 			}"
  20. 		>
  21. 			<el-button class="button" @click="remove" type="danger">删除</el-button>
  22. 			<el-button class="button" @click="cancel" type="primary">取消</el-button>
  23. 		</div>
  24. 		<!--增加右击弹出的菜单-->
  25. 	</div>
  26. </template>
  27.  
  28. <script lang="ts" setup>
  29. import { jsPlumb } from 'jsplumb';
  30. import * as D3 from 'd3';
  31. import type { 
  32. 	Element,
  33. 	DragOptions,
  34. 	EndpointOptions,
  35. 	EndpointSpec,
  36. 	jsPlumbInstance,
  37. 	Connection,
  38. } from 'jsplumb';
  39. import { ref, onBeforeonMount, onMounted, nextTick, watch } from 'vue';
  40.  
  41. // 创建一个树的接口，必须是嵌套的
  42. interface BlockTree {
  43. 	id: number;
  44. 	name: string;
  45. 	value?: string[];
  46. 	children?: BlockTree[];
  47. }
  48.  
  49. // 拆分接口，逻辑更清晰，PlumbBlock为存储原始数据的最小单元，PlumbNode为画布显示的最小单元
  50. interface PlumbBlock {
  51. 	id: number;
  52. 	name: string;
  53. 	in_id?: number[] | undefined;
  54. 	value?: string[];
  55. };
  56.  
  57. interface PlumbNode {
  58. 	id: number;
  59. 	name: string;
  60. 	left: string;
  61. 	top: string;
  62. }
  63.  
  64. // 用于区分Dom元素的类型，做逻辑判断用
  65. enum DomType {
  66. 	empty,
  67. 	node,
  68. 	connection
  69. }
  70.  
  71. let jsPlumb_instance: jsPlumbInstance = null;
  72. let block_tree: BlockTree = { id: -100, name: "unknown" };  // 初始化
  73. let block_list: PlumbBlock = [];
  74. let node_list = ref<PlumbNode>([]); 
  75. let line_list: number[][] = [];
  76. let show = ref<boolean>(false); // 控制菜单的显示
  77. let menu_left = ref<string>(""); // 控制菜单的水平位置
  78. let menu_top = ref<string>(""); // 控制菜单的垂直位置
  79. let cur_type: DomType = DomType.empty;
  80. let cur_source_id: string = ""; 
  81. let cur_target_id: string = "";
  82. let need_update = ref<boolean>(false);  // 由watch监视，决定是否更新数据
  83.  
  84.  
  85. onBeforeonMount(() => {
  86. 	transform();  // 用来生成树
  87. });
  88.  
  89. onMounted(() => {
  90. 	setNodeInfo();  // 移到这里是因为为了根据页面尺寸自适应的生成树，因此需要等jsplumb挂载完
  91.     jsPlumb_instance = jsPlumb.getInstance();
  92. 	jsPlumb_instance.importDefaults(common);
  93. 	
  94. 	jsPlumb_instance.ready(function() {
  95. 		nextTick(() => {    // 增加nextTick是为了等待树的元素都挂载完，这样addEndpoints中才能给元素添加端点
  96. 			addEndpoints();
  97. 			drawLines();
  98. 			bindEvent();
  99. 		})
  100. 	});
  101. });
  102.  
  103. // 直接设置成jsplumb的全局属性了，但是要注意所有属性是首字母大写的
  104. let common: Object = {
  105. 	Overlays: [["Arrow", { width: 12, length: 12, location: 0.5 }]], 
  106. 	Anchor: ["Top", "Bottom"], 
  107. 	
  108. 	MaxConnections: -1,    // 每个端点可以连接多条线
  109. 	Connector: ["Bezier", { curviness: 15 }],
  110. 	PaintStyle: {           // 聚焦前的style
  111. 		stroke: "#99ccff",
  112. 		strokeWidth: 3,
  113. 	},
  114. 	HoverPaintStyle: {      // 聚焦后的style
  115. 		stroke: "#0077cc",
  116. 		strokeWidth: 4,
  117. 	},
  118. 	
  119. 	Endpoint: <EndpointSpec>["Dot", { radius: 3 }],
  120. 	EndpointStyle: {        // 聚焦前的style
  121. 		stroke: "#77ccff",
  122. 		fill: "#ffffff",
  123. 		strokeWidth: 2,
  124. 	},
  125. 	EndpointHoverStyle: {   // 聚焦后的style   
  126. 		stroke: "#0077cc",
  127. 		fill: "#0077cc",
  128. 		strokeWidth: 2,
  129. 	},
  130. };
  131.  
  132. block_list = [
  133. 	{
  134. 		id: -1,
  135. 		name: "input",
  136. 	},
  137. 	{
  138. 		id: 0,
  139. 		in_id: [-1],
  140. 		name: "block",
  141. 		value: ["3"]
  142. 	},
  143. 	{
  144. 		id: 1,
  145. 		in_id: [0],
  146. 		name: "block-long",
  147. 		value: ["32"]
  148. 	},
  149. 	{
  150. 		id: 2,
  151. 		in_id: [1],
  152. 		name: "block",
  153. 		value: ["64"]
  154. 	},
  155. 	{
  156. 		id: 3,
  157. 		in_id: [2],
  158. 		name: "block-long",
  159. 		value: ["64"]
  160. 	},
  161. 	{
  162. 		id: 4,
  163. 		in_id: [1, 3],
  164. 		name: "block",
  165. 		value: ["128"]
  166. 	},
  167. 	{
  168. 		id: 5,
  169. 		in_id: [4],
  170. 		name: "block-long",
  171. 		value: ["128"]
  172. 	},
  173. 	{
  174. 		id: 6,
  175. 		in_id: [2, 5],
  176. 		name: "block",
  177. 		value: ["256"]
  178. 	},
  179. 	{
  180. 		id: 7,
  181. 		in_id: [6],
  182. 		name: "block-long",
  183. 		value: ["256"]
  184. 	},
  185. 	{
  186. 		id: 8,
  187. 		in_id: [6],
  188. 		name: "output"
  189. 	},
  190. 	{
  191. 		id: 9,
  192. 		in_id: [7],
  193. 		name: "output"
  194. 	}
  195. ];
  196.  
  197. function transform(): void {
  198. 	// 生成树，根据block_list的in_id<->id的关系插入，当一个子级存在多个父级时，将子级插在id较小的父级下
  199. 	block_tree = { id: input, name: "input", children: [] }; // 初始化时直接把input插入
  200. 	for(let i = 1; i < block_list.length; ++i) {
  201. 		let in_id = block_list[i].in_id;
  202. 		let min: number = in_id[0]; // 除了input外都是存在in_id的，且循环不包含input
  203. 		
  204. 		for(let j = 1; j < in_id.length; ++j) {
  205. 			if(in_id[j] < min)
  206. 				min = in_id[j];
  207. 		}
  208. 		addChildren(blocks_tree, min, block_list[i]);
  209. 	}
  210. }
  211.  
  212. function addChildren(tree: BlockTree, idx: number, block: PlumbBlock): void {
  213. 	let key: keyof BlockTree;
  214. 	let find: boolean = false;
  215. 	for(key in tree) {
  216. 		if(key == "id") {
  217. 			if(tree[key] != idx)
  218. 				break;  // id不对，直接不用继续比较了
  219. 			else
  220. 				find = true;  // 说明找到叶子了
  221. 		}
  222. 	}
  223. 	
  224. 	if(!find) {
  225. 		if('children' in tree)
  226. 			for(let i = 0; i < tree.children.length; ++i)
  227. 				addChildren(tree.children[i], idx, block);
  228. 	}
  229. 	else {	// 找到叶子后把新的block插在叶子的children属性中
  230. 		// 确保有children属性
  231. 		if(!('children' in tree))
  232. 			tree.children = [];
  233. 			
  234. 		if('value' in block)
  235. 			tree.children.push({
  236. 				id: block.id,
  237. 				name: block.name,
  238. 				value: block.value,
  239. 			});
  240. 		else
  241. 			tree.children.push({
  242. 				id: block.id,
  243. 				name: block.name,
  244. 			});
  245. 	} 
  246. }
  247.  
  248.  
  249. // 修改node的生成方式，使用d3的树状图生成
  250. function setNodeInfo(): void {
  251. 	let data = D3.hierachy(blocks_tree);
  252. 	
  253. 	let style = window.getcomputedStyle(document.getElementById('jsplumb'), null); // 获取元素的风格
  254. 	let canvas_width: number = Number(style.width.split('px')[0]);
  255. 	let canvas_height: number = Number(style.height.split('px')[0]);
  256. 	
  257. 	// 限制元素的位置
  258. 	let scale_width: number = 0.9;
  259. 	let scale_height: number = 0.9;
  260.  
  261. 	// 创建树，根据jsplumb元素的尺寸来限制树的尺寸，这个size会和nodesize属性冲突
  262. 	let treeGenerator = D3.tree().size([canvas_width * scale_width, canvas_height * scale_height]);
  263. 	let treeData = treeGenerator(data);
  264. 	
  265. 	let nodes = treeData.descendants();
  266. 	
  267. 	node_list.value = nodes.map((item) => {
  268. 		return {
  269. 			id: item.data.id,
  270. 			name: item.data.name,
  271. 			left: item.x + "px",
  272. 			top: item.y + 20+ "px",
  273. 		};
  274. 	});
  275. 	
  276. 	for(let i = 0; i < blocks_list.length; ++i) {
  277. 		let in_id: number[] | undefined = blocks_list[i].in_id;
  278. 		if(in_id != undefined) {
  279. 			for(let j = 0; j < in_id.length; ++j) 
  280. 				line_list.push([in_id[j], blocks_list[i].id);
  281. 		}
  282. 	};
  283. };
  284.  
  285. function addEndpoints(): void {
  286. 	for(let i = 0; i < node_list.value.length; ++i) {
  287. 		let el = <Element>(document.getElementById(String(node_list.value[i].id)));
  288. 		
  289. 		jsPlumb_instance.draggable(el, <DragOptions>{ containment: "jsplumb" });
  290. 		if(node_list.value[i].name != "input") {
  291. 			jsPlumb_instance.addEndpoint(el, <EndpointOptions>{
  292. 				isTarget: true,
  293. 				anchor: "Top",
  294. 				endpoint: <EndpointSpec>["Dot", { radius: 3 }],
  295. 			});
  296. 		}
  297. 		if(node_list.value[i].name != "output") {
  298. 			jsPlumb_instance.addEndpoint(el, <EndpointOptions>{
  299. 				isSource: true,
  300. 				anchor: "Bottom",
  301. 				endpoint: <EndpointSpec>["Dot", { radius: 3 }],
  302. 			});
  303. 		}
  304. 	}
  305. };
  306.  
  307. function drawLines(): void {
  308. 	for(let i = 0; i < line_list.length; ++i) {
  309. 		let start: Element = document.getElementById(String(line_list[i][0]));
  310. 		let end: Element = document.getElementById(String(line_list[i][1]));
  311. 		
  312. 		jsPlumb_instance.connect({
  313. 			source: start,
  314. 			target: end,
  315. 		});
  316. 	}
  317. };
  318.  
  319. function remove(): void {
  320. 	if(cur_type === DomType.node && cur_source_id ！== "") {
  321. 		let find: boolean = false;
  322. 		for (let i = 1; i < block_list.length; ++i) {
  323. 			if(String(block_list[i].id) === cur_source_id) {
  324. 				block_list.splice(i, 1);
  325. 				find = true;
  326. 				break;
  327. 			}
  328. 		}
  329. 		// 删除节点及其连接线
  330. 		jsPlumb_instance.remove(cur_source_id);
  331. 	}
  332. 	else if(cur_type === DomType.connect && cur_source_id !== "" && cur_target_id !== "") {
  333. 		let connections = jsPlumb_instance.getAllConnections();  // 找到所有连接
  334. 		for(let idx in connections) {
  335. 			if(connections[idx].sourceId === cur_source_id && connections[idx].targetId === cur_target_id) {   // 筛选出首尾相同的连接并删除
  336. 				jsPlumb_instance.deleteConnection(connections[idx]);
  337. 				break;
  338. 			}
  339. 		}
  340. 	}
  341. 	show.value = false;
  342. 	cur_type = DomType.empty;
  343. }
  344.  
  345. function cancel(): void {
  346. 	show.value = false;
  347. 	cur_type = DomType.empty;
  348. }
  349.  
  350. // 移动节点后需要在鼠标离开后更新当前位置
  351. function mouseleave(id: number): void {
  352. 	let style = window.getcomputedStyle(document.getElementById(String(id)));
  353. 	for(let i = 0; i < node_list,value.length; ++i) {
  354. 		if(node_list.value[i].id === id) {
  355. 			node_list.value[i].left = style.left;
  356. 			node_list.vlaue[i].top = style.top;
  357. 		}
  358. 	}
  359. }
  360.  
  361. // 节点双击弹出菜单，
  362. function dblclick(id: number): void {
  363. 	let style = window.getcomputedStyle(document.getElementById(String(id))); // 获取dom元素信息
  364. 	let x: string = Number(style.left.split('px')[0]) + Number(style.width.split('px')[0]) + "px"; // 想定位精确一点的话还应该加上padding、border等参数，这些都可以在style中获取
  365. 	let y: string = Number(style.top.split('px')[0]) + 'px';
  366. 	
  367. 	menu_left.value = x;
  368. 	menu_top.value = y;
  369. 	show.value = true;
  370. 	cur_type = DomType.node;
  371. 	cur_source_id = String(id);
  372. }
  373.  
  374. // 连接线事件都在这儿
  375. function bindEvent(): void {
  376. 	// 双击弹出菜单
  377. 	jsPlumb_instance.bind("dblclick", function(info) {
  378. 		let style = window.getcomputedStyle(document.getElementById(info.sourceId));
  379. 		let x_1: string = Number(style.left.split('px')[0]) + Number(style.width.split('px')[0];
  380. 		let y_1: string = Number(style.top.split('px')[0]) + Number(style.height.split('px')[0]);
  381. 		style = window.getcomputedStyle(document.getElementById(info.targetIdId));
  382. 		let x_2: string = Number(style.left.split('px')[0]) + Number(style.width.split('px')[0];
  383. 		let y_2: string = Number(style.top.split('px')[0]);
  384. 		
  385. 		let x: string = (x_1 + x_2) / 2 + 'px';
  386. 		let y: string = (y_1 + y_2) / 2 + 'px';
  387. 		
  388. 		menu_left.value = x;
  389. 		menu_top.value = y;
  390. 		show.value = true;
  391. 		cur_type = DomType.connection;
  392. 		cur_source_id = info.sourceId;
  393. 		cur_source_id = info.targetId;
  394. 	});
  395. 	
  396. 	// 连接节点，删除重复连接，并确保output节点只有一个输入
  397. 	jsPlumb_instance.bind("connection", function(info) {
  398. 		// target是output
  399. 		for (let i = 1; i < block_list.length; ++i) {
  400. 			if(String(block_list[i].id) === info.targetId && block_list[i].name === "output" && block_list[i].in_id.length > 0) {
  401. 				let arr = jsPlumb_instance.select({ target: info.targetId });
  402. 				if(arr.length > 1) {
  403. 					block_list.splice(i, 1);
  404. 					break;
  405. 				}
  406. 			}
  407. 		}
  408. 		// target不是output
  409. 		let arr = jsPlumb_instance.select({ source: info.sourceId, target: info.targetId });
  410. 		if(arr.length > 1)
  411. 			jsPlumb_instance.deleteConnection(info.connection);
  412. 		
  413. 		need_update.value = true;
  414. 	});
  415. 	
  416. 	// 删除连接线，更新数据
  417. 	jsPlumb_instance.bind("connectionDetached", function(info) {
  418. 		need_update.value = true;
  419. 	});
  420. }
  421.  
  422. // 更新block_list中的连接关系
  423. function update(): void {
  424. 	let connections = jsPlumb_instance.getAllConnections();
  425. 	// 先清空
  426. 	for(let i = 1; i < block_list.length; ++i)
  427. 		block_list[i].in_id.splice(0, block_list[i].in_id.length);
  428. 		
  429. 	// 插入新的连接线
  430. 	for(let i = 0; i < connections.length; ++i) {
  431. 		for(let j = 1; j < block_list.length; ++j) {
  432. 			if(String(block_list[j].id) === connection[i].targetId)
  433. 				block_list[j].in_id.push(Number(connections[i].sourceId));
  434. 		}
  435. 	}
  436. 	need_update.value = false;
  437. }
  438.  
  439. // 监视need_update
  440. watch(
  441. 	() => need_update.value,
  442. 	(cur: boolean, pre: boolean) => {
  443. 		if(cur === true)
  444. 			update();
  445. 	}
  446. );
  447. </script>
  448.  
  449. <style scoped>
  450. .jsplumb {
  451. 	position: absolute,
  452. 	margin: 10px;
  453. 	left: 45%;
  454. 	width: 50%;
  455. 	height: 800px;
  456. 	box-sizing: bording-box;
  457. 	border: 1px solid black;
  458. }
  459. .nodes {
  460. 	position: absolute;
  461. 	min-width: 60px;
  462. 	height: 40px;
  463. 	color: black;
  464. 	border: 1px solid black;
  465. 	background-color: #eeeeee;
  466. 	line-height: 40px;
  467. 	padding: 0 10px;
  468. }
  469. .nodes:hover{  
  470. 	position: absolute;
  471. 	min-width: 60px;
  472. 	height: 40px;
  473. 	color: black;
  474. 	border: 1px solid black;
  475. 	background-color: #eeeeaa;
  476. 	line-height: 40px;
  477. 	padding: 0 10px;
  478. }
  479. .menu {
  480. 	position：absolute;
  481. }
  482. </style>

参考资料

jsPlumb初认识 - 知乎 (zhihu.com)

jsPlumb 基本概念 - 简书 (jianshu.com)

Overview | jsPlumb Documentation (jsplumbtoolkit.com)

 jsplumb 中文基础教程 (wdd.js.org)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/117150
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号