实现GEF线路由

最新推荐文章于 2024-07-31 19:38:21 发布
最新推荐文章于 2024-07-31 19:38:21 发布
阅读量183 收藏 1
点赞数
文章标签： 开发工具 java runtime
原文链接：http://www.cnblogs.com/bronte/articles/2374852.html
版权

*内容概述

---实现添加自己的线路由

---给出一个案例,线能自动绕开其他的图形.

 

*ManhattanConnectionRouter简介

---算法简介

与节点无关,只关心如何折线,拐点是不断取折点和结束锚点的中间点位置.

这是一个简洁的算法,却给我们提供了几点关键的概念和代码,作为设计线算法的思路.

a)直角线

开始和结束间的线不是水平线,就是垂直线,折角都是直角.

b)给出了线头的方向和线尾的方向的代码

getStartDirection(Connection conn),getEndDirection(Connection conn),getDirection(Rectangle r, Point p)

---缺点

1)线不会避开锚点间的节点,因为算法自身不考虑这个因素.

 

*实现智能连线

---目标

选择路径能够尽量绕开节点,效果是线不会穿过节点.

---源码

智能连线源码/*******************************************************************************
 * Copyright(C) 2011 Arzan Corporation. All rights reserved.
 *
 * Contributors:
 *     Arzan Corporation - initial API and implementation
 *******************************************************************************/
package galaxy.ide.common.draw2d.figures;

import java.util.List;

import org.eclipse.core.runtime.Assert;
import org.eclipse.draw2d.AbstractRouter;
import org.eclipse.draw2d.Connection;
import org.eclipse.draw2d.ConnectionAnchor;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PointList;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.draw2d.geometry.Vector;

/**
 * 具备自动避开节点的能力, 尽可能绕开的最短路径
 * 
 * @author dzh
 * @version 1.0 2011-12-16 上午10:33:38
 */
public class AIConnectionRouter extends AbstractRouter {

	private IFigure content;

	private static final int DEFAULT_SPACE = 10;

	private PointList points;

	private int space; /* 离障碍物的间隙 */

	private Vector endDirection;

	private Point endPoint;

	private static final Vector UP = new Vector(0, -1),
			DOWN = new Vector(0, 1), LEFT = new Vector(-1, 0),
			RIGHT = new Vector(1, 0);

	public AIConnectionRouter(IFigure content) {
		this(content, DEFAULT_SPACE);
	}

	public AIConnectionRouter(IFigure content, int space) {
		Assert.isNotNull(content);
		Assert.isLegal(space > 0, "Space must be gt zero.");

		this.content = content;
		this.space = space;
		this.points = new PointList();
	}

	private boolean validConn(Connection conn) {
		if ((conn.getSourceAnchor() == null)
				|| (conn.getTargetAnchor() == null))
			return false;

		// if (conn.getSourceAnchor().getOwner() == null
		// || conn.getTargetAnchor().getOwner() == null)
		// return false;

		return true;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.draw2d.ConnectionRouter#route(org.eclipse.draw2d.Connection)
	 */
	@Override
	public void route(Connection conn) {
		// testChildren(conn);
		Point startPoint = getStartPoint(conn).getCopy();
		// System.out.println("startPoint: " + startPoint);
		conn.translateToRelative(startPoint);
		// System.out.println("relativeStartPoint: " + startPoint);
		points.addPoint(startPoint);

		endPoint = getEndPoint(conn).getCopy();
		// System.out.println("endPoint: " + endPoint);
		conn.translateToRelative(endPoint);

		if (validConn(conn)) {
			Vector sdirection = getStartDirection(conn);
			// System.out.println("startDirection: " + direction);
			endDirection = getEndDirection(conn);

			// System.out.println("endDirection: " + endDirection);
			processPoints(startPoint, sdirection, null);
		}

		points.addPoint(endPoint);
		conn.setPoints(points.getCopy());

		endDirection = null;
		endPoint = null;
		points.removeAllPoints();
	}

	private void processPoints(Point startPoint, Vector direction,
			Rectangle parallelObs) {
		if (direction == UP)
			processUp(startPoint, parallelObs);
		else if (direction == DOWN)
			processDown(startPoint, parallelObs);
		else if (direction == LEFT)
			processLeft(startPoint, parallelObs);
		else
			processRight(startPoint, parallelObs);
	}

	private void processRight(Point startPoint, Rectangle parallelObs) {
		Point newStartPoint = new Point(startPoint);

		int min_xd = 0;
		Rectangle obstracle = null;
		@SuppressWarnings("unchecked")
		List<IFigure> list = content.getChildren();
		for (IFigure f : list) {
			Rectangle fr = f.getBounds();
			if (containPoint(fr, endPoint) || containPoint(fr, startPoint)
					|| fr.x > endPoint.x)
				continue;

			int xd = fr.x - startPoint.x;
			if (xd > 0 && fr.y <= startPoint.y
					&& (fr.y + fr.height) >= startPoint.y) {
				if (xd < min_xd || min_xd == 0) {
					min_xd = xd;
					obstracle = fr;
				}
			}

		}
		if (min_xd == 0) { // no obstacles
			if (parallelObs == null) {
				if (newStartPoint.y == endPoint.y)
					return;

			} else {
				if (newStartPoint.x < parallelObs.x)
					newStartPoint.x -= (parallelObs.x - newStartPoint.x) / 2;
			}

			if (newStartPoint.x < endPoint.x) {
				if (isVertical(endDirection, RIGHT))
					newStartPoint.x = endPoint.x;
				else {
					if (endDirection.equals(RIGHT)) {
						newStartPoint.x = endPoint.x + space;
					} else
						newStartPoint.x += (endPoint.x - newStartPoint.x) / 2;
				}
			}
		} else {
			int x = newStartPoint.x + min_xd - space;
			if (x < newStartPoint.x)
				x = newStartPoint.x + min_xd / 2;
			newStartPoint.x = x;
		}
		if (parallelObs != null) {
			if (newStartPoint.x >= parallelObs.x
					&& newStartPoint.x <= parallelObs.x + parallelObs.width)
				newStartPoint.x = parallelObs.x + parallelObs.width + space;
		}
		if (!newStartPoint.equals(startPoint))
			points.addPoint(newStartPoint);

		// next
		Vector newDirection = UP;
		if (obstracle == null) {
			if (endPoint.y > newStartPoint.y)
				newDirection = DOWN;
		} else {
			if (endPoint.y > obstracle.y)
				newDirection = DOWN;
		}

		processPoints(newStartPoint, newDirection, obstracle);
	}

	private void processLeft(Point startPoint, Rectangle parallelObs) {
		Point newStartPoint = new Point(startPoint);

		int min_xd = 0;
		Rectangle obstracle = null;
		@SuppressWarnings("unchecked")
		List<IFigure> list = content.getChildren();
		for (IFigure f : list) {
			Rectangle fr = f.getBounds();
			if (containPoint(fr, endPoint) || containPoint(fr, startPoint)
					|| (fr.x + fr.width) <= endPoint.x)
				continue;

			int xd = startPoint.x - fr.x - fr.width;
			if (xd > 0 && fr.y <= startPoint.y
					&& (fr.y + fr.height) >= startPoint.y) {
				if (xd < min_xd || min_xd == 0) {
					min_xd = xd;
					obstracle = fr;
				}
			}
		}
		if (min_xd == 0) { // no obstacles
			// not need bend point
			if (parallelObs == null) {
				if (newStartPoint.y == endPoint.y)
					return;
			} else {
				if (newStartPoint.x > parallelObs.x + parallelObs.width)
					newStartPoint.x -= (newStartPoint.x - parallelObs.x - parallelObs.width) / 2;
			}

			if (newStartPoint.x > endPoint.x) {
				if (isVertical(endDirection, LEFT))
					newStartPoint.x = endPoint.x;
				else {
					if (endDirection.equals(LEFT)) {
						newStartPoint.x = endPoint.x - space;
					} else
						newStartPoint.x += (newStartPoint.x - endPoint.x) / 2;
				}
			}
		} else {
			int x = newStartPoint.x + min_xd - space;
			if (x < newStartPoint.x)
				x = newStartPoint.x + min_xd / 2;
			newStartPoint.x = x;
		}
		if (parallelObs != null) {
			if (newStartPoint.x >= parallelObs.x
					&& newStartPoint.x <= (parallelObs.x + parallelObs.width)) {
				newStartPoint.x = parallelObs.x - space;
			}
		}
		if (!newStartPoint.equals(startPoint))
			points.addPoint(newStartPoint);

		// next row point
		Vector newDirection = UP;
		if (obstracle == null) {
			if (endPoint.y > newStartPoint.y)
				newDirection = DOWN;
		} else {
			if (endPoint.y >= obstracle.y)
				newDirection = DOWN;
		}

		processPoints(newStartPoint, newDirection, obstracle);
	}

	private void processDown(Point startPoint, Rectangle parallelObs) {
		Point newStartPoint = new Point(startPoint);

		int min_yd = 0;
		Rectangle obstracle = null;
		@SuppressWarnings("unchecked")
		List<IFigure> list = content.getChildren();
		for (IFigure f : list) {
			Rectangle fr = f.getBounds();
			// System.out.println(fr.width);
			if (containPoint(fr, endPoint) || containPoint(fr, startPoint)
					|| fr.y > endPoint.y)
				continue;

			int yd = fr.y - startPoint.y;
			if (yd > 0 && fr.x <= startPoint.x
					&& (fr.x + fr.width) >= startPoint.x) {
				if (yd < min_yd || min_yd == 0) {
					min_yd = yd;
					obstracle = fr;
				}
			}
		}
		if (min_yd == 0) { // no obstacles
			// not need bend point
			if (parallelObs == null) {
				if (newStartPoint.x == endPoint.x)
					return;
			} else {
				if (parallelObs.y > startPoint.y)
					newStartPoint.y += (parallelObs.y - startPoint.y) / 2;
			}
			if (newStartPoint.y < endPoint.y) {
				if (isVertical(endDirection, DOWN)) {
					newStartPoint.y = endPoint.y; // TODO avoid itself
				} else {
					if (endDirection.equals(DOWN))
						newStartPoint.y = startPoint.y + space;
					else
						newStartPoint.y += (endPoint.y - newStartPoint.y) / 2;
				}
			}
		} else {
			int y = newStartPoint.y + min_yd - space;
			if (y < newStartPoint.y)
				y = newStartPoint.y + min_yd / 2;
			newStartPoint.y = y;
		}

		if (parallelObs != null) {
			if (newStartPoint.y > parallelObs.y
					&& newStartPoint.y < parallelObs.y + parallelObs.height)
				newStartPoint.y = parallelObs.y + parallelObs.height + space;
		}
		if (!newStartPoint.equals(startPoint))
			points.addPoint(newStartPoint);
		// System.out.println("point:" + newStartPoint.toString());

		// next row point
		Vector newDirection = LEFT;
		if (obstracle == null) {
			if (endPoint.x > newStartPoint.x)
				newDirection = RIGHT;
		} else {
			if (endPoint.x > (obstracle.x + obstracle.width))
				newDirection = RIGHT;
		}

		processPoints(newStartPoint, newDirection, obstracle);
	}

	boolean isVertical(Vector v1, Vector v2) {
		double val = v1.x * v2.x + v1.y * v2.y;
		if (val == 0)
			return true;
		return false;
	}

	boolean containPoint(Rectangle r, Point p) {
		return p.x >= r.x && p.x <= r.x + r.width && p.y >= r.y
				&& p.y <= r.y + r.height;
	}

	private void processUp(Point startPoint, Rectangle parallelObs) {
		Point newStartPoint = new Point(startPoint);

		int min_yd = 0;
		Rectangle obstracle = null;
		@SuppressWarnings("unchecked")
		List<IFigure> list = content.getChildren();
		for (IFigure f : list) {
			Rectangle fr = f.getBounds();
			if (containPoint(fr, endPoint) || containPoint(fr, startPoint)
					|| (fr.y + fr.height) <= endPoint.y)
				continue;

			int yd = startPoint.y - fr.y - fr.height;
			if (yd > 0 && fr.x <= startPoint.x
					&& (fr.x + fr.width) >= startPoint.x) {
				if (yd < min_yd || min_yd == 0) {
					min_yd = yd;
					obstracle = fr;
				}
			}
		}
		if (min_yd == 0) { // no obstacles
			// not need bend point
			if (parallelObs == null) {
				if (newStartPoint.x == endPoint.x)
					return;
			} else {
				if (newStartPoint.y > parallelObs.y + parallelObs.height)
					newStartPoint.y -= (newStartPoint.y - parallelObs.y - parallelObs.height) / 2;
			}
			if (newStartPoint.y > endPoint.y) {
				if (isVertical(endDirection, UP))
					newStartPoint.y = endPoint.y;
				else {
					if (endDirection.equals(UP)) {
						newStartPoint.y = endPoint.y - space;
					} else
						newStartPoint.y -= (newStartPoint.y - endPoint.y) / 2;
				}
			}
		} else {
			int y = newStartPoint.y - min_yd + space;
			if (y > newStartPoint.y)
				y = newStartPoint.y - min_yd / 2;
			newStartPoint.y = y;
		}
		if (parallelObs != null) {
			if (newStartPoint.y >= parallelObs.y
					&& newStartPoint.y <= parallelObs.y + parallelObs.height)
				newStartPoint.y = parallelObs.y - space;
		}
		if (!newStartPoint.equals(startPoint))
			points.addPoint(newStartPoint);

		// next row point
		Vector newDirection = LEFT;
		if (obstracle == null) {
			if (endPoint.x > newStartPoint.x)
				newDirection = RIGHT;
		} else {
			if (endPoint.x >= obstracle.x)
				newDirection = RIGHT;
		}

		processPoints(newStartPoint, newDirection, obstracle);
	}

	protected Vector getDirection(Rectangle r, Point p) {
		int i, distance = Math.abs(r.x - p.x);
		Vector direction;

		direction = LEFT;

		i = Math.abs(r.y - p.y);
		if (i <= distance) {
			distance = i;
			direction = UP;
		}

		i = Math.abs(r.bottom() - p.y);
		if (i <= distance) {
			distance = i;
			direction = DOWN;
		}

		i = Math.abs(r.right() - p.x);
		if (i < distance) {
			distance = i;
			direction = RIGHT;
		}

		return direction;
	}

	protected Vector getStartDirection(Connection conn) {
		ConnectionAnchor anchor = conn.getSourceAnchor();
		Point p = getStartPoint(conn);
		Rectangle rect;
		if (anchor.getOwner() == null)
			rect = new Rectangle(p.x - 1, p.y - 1, 2, 2);
		else {
			rect = conn.getSourceAnchor().getOwner().getBounds().getCopy();
			conn.getSourceAnchor().getOwner().translateToAbsolute(rect);
		}
		return getDirection(rect, p);
	}

	protected Vector getEndDirection(Connection conn) {
		ConnectionAnchor anchor = conn.getTargetAnchor();
		Point p = getEndPoint(conn);
		Rectangle rect;
		if (anchor.getOwner() == null)
			rect = new Rectangle(p.x - 1, p.y - 1, 2, 2);
		else {
			rect = conn.getTargetAnchor().getOwner().getBounds().getCopy();
			conn.getTargetAnchor().getOwner().translateToAbsolute(rect);
		}
		return getDirection(rect, p);
	}

	// private IFigure getSourceOwner(Connection conn) {
	// return conn.getSourceAnchor().getOwner();
	// }
	//
	// private IFigure getTargetOwner(Connection conn) {
	// return conn.getTargetAnchor().getOwner();
	// }

	// private void testChildren(Connection conn) {
	// List<Figure> list = content.getChildren();
	// for (Figure f : list) {
	// Rectangle r = f.getBounds();
	// // conn.translateToRelative(r.getCopy());
	// Rectangle rc = r.getCopy();
	// content.translateToRelative(rc.getCopy());
	// System.out.println(rc.toString());
	// // if(f instanceof HandleBounds){
	// //
	// // }
	// }
	// System.out.println("\n");
	// }

}

---源码说明

这里只介绍思路,和关键点

a)实现线路由的基本方式,

继承org.eclipse.draw2d.AbstractRouter-->自定义route()方法,它是布局算法的入口,算法就在这个方法里实现

-->getStartPoint(Connection conn)获取起点+getEndPoint(Connection connection)获取终点+自定义算法获取的其他点,

所有的这些点全部放入PointList中-->route()的最后关键就是conn.setPoints(points.getCopy());这个方法将会重新绘制连线.

b)这里添加的private IFigure content;就是要避开节点的父容器图形;

c)要注意,conn.translateToRelative(startPoint);

这个方法的作用,把点换算成相对线容器的相对坐标,比如说GEF对figure做了放大缩小后,调用这个方法才能保证节点坐标的相对正确性.

d)解决方法,一个基本的障碍物模型+递推+直角线的方式,读者只需看其中一个方向的处理代码就能明白细节思路了.

下图是processDown时的障碍物模型图

障碍物模型

e)后续优化点,在考虑障碍物时,没有把开始和结束点所在的figure作为障碍物,这样就导致了线穿过开始或者结束figure的情况.

 

*添加路由

一般有2中方式给线添加路由

---统一添加方式

在figure的连接层添加,那么这个线路由将作用于其中的所有线

全局添加ConnectionLayer connLayer = (ConnectionLayer) ((CommonNodeEditPart)editPart).getLayer(org.eclipse.gef.LayerConstants.CONNECTION_LAYER);

connLayer.setConnectionRouter(new AIConnectionRouter(content));

---个别添加,直接调用线自身的方法

void org.eclipse.draw2d.PolylineConnection.setConnectionRouter(ConnectionRouter cr)

 

*总结

---draw2d已提供ManhattanConnectionRouter,BendpointConnectionRouter,ShortestPathConnectionRouter等,可以直接使用或者继承后做些修改.

---当需要自己定制连线路由时,继承AbstractRouter,并自定义route(Connection conn)方法,也不难,麻烦的可能就是算法.

---线的路由算法,设计思路是建立解决方案的基本模型,保证通用正确性处理,兼顾考虑特殊情况并给出特殊优化,这也是算法设计的基本思路之一.

转载于:https://www.cnblogs.com/bronte/articles/2374852.html

weixin_30355437
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
GEF实现拷贝粘贴
03-30
标题“GEF实现拷贝粘贴”涉及到的是在软件开发中使用Graphical Editing Framework（GEF）进行图形界面编辑时，如何实现复制和粘贴功能的技术。GEF是Eclipse平台下用于构建图形化编辑器的框架，它提供了一套完整的...
GEF典型实现例子
03-18
标题“GEF典型实现例子”指的是使用Graphical Editing Framework (GEF)的示例应用。GEF是Eclipse平台下的一个开源项目，主要用于构建图形化编辑工具，它提供了丰富的图形用户界面（GUI）组件和框架，帮助开发者创建...
GEF 连线路由（Router）
qq123zhz的专栏
04-21 313
  第二部分:Router Router（连线路由器）是对连线进行布局的重要组件，本文介绍了路由器的基本概念和应用场景，剖析了一个连线路由器的接口并给出了一个简单实例。最后演示了如何把自定义的路由器应用到图形中，使得不同的连线可以有不同的路由器。 ConnectionRouter（连线路由器） 图形之间连线的路线，是由连线路由器来决定的。在Shapes Examples中，使用...
连线自动路由算法：在GEF中实现连线的自动直角路由，智能避障并绕开模型，选择最佳路径进行布线，仿Visio效果
热门推荐
Pure Pleasure
09-21 1万+
在使用GEF（图形编辑框架）开发建模工具时，比如利用GEF实现程序流程图建模功能，有时对连线的路由方式会有比较高的要求，比如连线自动采用直角布局，要能够智能地避障并绕开模型，选择最佳路径进行布线。在建模类工具中，Microsoft Visio基本流程图中的连线的智能效果做的是同类工具中最好的，起码作者感觉如此。这篇博客就介绍如何在GEF中为连线实现类似Visio中的智能效果。当然，本文以GEF为背...
GEF中同时使用两个Router
liulijuan529的专栏
06-23 1355
GEF中同时使用两个Router        gef中经常会有很多连线,这些连线如何和每个node连接,允不允许交叉等等都是用router来控制的.网上有篇文章对这个做了一些介绍:http://www-128.ibm.com/developerworks/cn/opensource/os-ecl-gef/part2/       我现在做的这个项目需要在两个node之间同时存在多根线,如果不使用router的话就只能看见一根,在diagram的 figure里面set一个FanRouter作为缺省的ro
Draw2d 连线六 路由 Router
xmind
11-19 575
关键字：Draw2d 连线 路由 Router ManhattanConnectionRouter   NullConnectionRouter ： 直接的直线连接。 FanRouter ： 防治连线重叠的连接。 BendpointConnectionRouter ： 允许用户任意拖动连线中的部分的方式增加节点。 ShortestPathConnectionRouter ： 最短路径的连...
Douglas-Peucker折线抽稀算法 Python 通过距离阈值控制和通过节点数量控制两种实现
zzzzhhhhyyyy1的博客
11-02 2676
折线抽稀 当折线点的数量过多时，往往需要对折线简化，且简化的折线能最大程度的保留原始折线的几何特征，这就是折线抽稀。主要的抽稀算法有Ramer-Douglas-Peucker、Visvalingam-Whyatt等，本文介绍Ramer-Douglas-Peucker算法。 Douglas-Peucker原理 具体原理可以参考Wiki或者其他博客，在此不过多介绍简单来说，Douglas-Peucker算法首先连接首尾两端，然后寻找折线上距离该线最远的点并计算距离，当距离大于距离阈值时，则保留改点，然后对首点
GEF学习资料.zip
09-08
2. **视图（View）**：视图是模型的可视化表示，由GEF提供的画布（Canvas）和图形元素（如线条、形状等）构成。视图根据模型的变化实时更新，保持模型与视图的一致性。 3. **控制器（Controller）**：控制器处理...
ECLIPSE GEF 5.4.0
01-18
3. **图形编辑器**：编辑器是GEF中实现用户交互的主要部分，允许用户创建、修改和查看模型。它支持多种编辑操作，如拖放、复制粘贴、撤销重做等。 4. **手势和命令**：GEF使用命令模式来处理用户的输入手势，如鼠标...
gef AmaterasUML for ECLIPSE
01-17
Gef AmaterasUML for Eclipse 是一个专门为Eclipse集成开发环境设计的图形化建模工具。这个工具基于Graphical Editing Framework (GEF)，提供了一种高效且用户友好的方式来创建和编辑UML（统一建模语言）模型。...
[Web Chart系列之五] 6. 实战draw2d之ConnectionRouter
oscar999的专栏
08-30 2999
ConnectionRouter 的作用是定义连线的展示样式. 是直线连接还是曲线连接(好像也是基于Bezier曲线) 位于包： draw2d.layout.connection 下。 常见的有： 1. DirectRouter -- 用直线连接两个节点 2. ManhattanConnectionRouter -- 使用 曼哈顿距离算法， 效果看上去是直角折线连接的。 3. SplineConnectionRouter 从ManhattanConnectionRouter继承过来， 不过是曲
[zt]GEF 进阶，第二部分: Router
疯狂的菠菜
02-13 228
FROM:http://www.ibm.com/developerworks/cn/opensource/os-ecl-gef/part2/index.html 2006 年 11 月 30 日 Router（连线路由器）是对连线进行布局的重要组件，本文介绍了路由器的基本概念和应用场景，剖析了一个连线路由器的接口并给出了一个简单实例。最后演示了如何把自定义的路由器应用到图形中，使得不同的连线可以有...
Router路由
leng1987021的博客
12-02 161
Router路由：设定线的轨迹，在Connection接口中定义了添加路由的方式，所以实现了Connection接口的Figure都可以添加路由。另外在ConnectionLayer中有一个方法，是为此Layer下的所有实现了Connection接口的Figure添加一个路由。当然，我们还可以自定义一些Figure添加路由。   ConnectionRouter接口：路由的基础接口，所有的路由...
wwww
yutianapple的专栏
04-16 145
// 创建一个连线的实例 PolylineConnection conn = new PolylineConnection(); conn.setConnectionRouter(new ManhattanConnectionRouter()); conn.setLineStyle(SWT.LINE_SOLID); co...
line线
leng1987021的博客
12-02 730
1.Connection接口：draw2d里面的线必须实现这个接口，这个接口里面有一个PointList，这个list里面放跟这个线相关的所有ConnectionAnchor。ConnectionAnchor是一个个瞄点，线是必须穿过这些瞄点的。   2.Polyline：这个相当于线的实现类，一个Figure，是在Shape的基础上发展出来的。这个类里面控制线的宽度大小形状还有颜色之类的，是...
ConnectionLayer 与 PrimaryLayer
salever的专栏
11-26 652
   接触GEF也有半年多了   还有一些概念始终不大清楚      内置的RootEditPart中的ConnectionLayer 和 PrimaryLayer， 能不能调换个位置显示呢？
Draw2d中的连线路由器及gef中连线抗锯齿
zhongkem的专栏
07-13 216
前两天也是在javaEye中看到一位大哥关于gef中连线抗锯齿的文章，学习之后感觉效果不错，如果你也正在用gef这个框架开发东西，不妨把下面这些代码加入，一定会让你的连线视觉效果好些~~   protected void refreshVisuals() {    super.refreshVisuals();  //以下这些代码是设置连接线抗锯齿  ConnectionLayer conne...
[zt]GEF 进阶，第一部分: Anchor
疯狂的菠菜
02-13 182
FROM:http://www.ibm.com/developerworks/cn/opensource/os-ecl-gef/part1/index.html 2006 年 11 月 30 日 GEF(Graphical Editing Framework)是Eclipse Tools的子项目，它在底层使用Draw2D作为布局和渲染引擎，在整体上使用MVC模式管理模型和视图。利用GEF，开发者可...
社区养老服务小程序的设计
最新发布
Karen198的博客
07-31 316
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
GEF进阶探索：自定义Anchor实现
文档详细讲解了如何在GEF中定义和实现自定义的Anchor，包括四个步骤：确定锚点表示策略、修改Model、实现ConnectionAnchor接口和修改EditPart。此外，文档还涵盖了锚点在图形连接中的作用，以及它们如何根据图形位置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值