[置顶] Eclipse GEF UMLClass（1）

通过两篇文章对GEF进行了介绍，为了自己加深对GEF的理解和学习，从网上找了一下开源的amaterasuml的uml工具，并把其中对内容转换提取成。

Figure：

第一篇文章其实是对amaterasuml中ClassFigure的简化，真实的UML类图如下：



EntityFigure：实体Figure，用于获取Label和获取矩形编辑域，代码如下：

import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.Label;
import org.eclipse.draw2d.geometry.Rectangle;

public interface EntityFigure extends IFigure{

Label getLabel();

Rectangle getCellEditorRectangle();

}

PresentaionFigure:描述Figure，用于更新模型的描述

public interface PresentationFigure {

void updatePresentation(AbstractUMLModel model);
}

CompartmentFigure：用于分隔的Figure，用于分隔属性和方法

import org.eclipse.draw2d.AbstractBorder;
import org.eclipse.draw2d.Figure;
import org.eclipse.draw2d.Graphics;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.ToolbarLayout;
import org.eclipse.draw2d.geometry.Insets;

public class CompartmentFigure extends Figure {

public CompartmentFigure() {
ToolbarLayout layout = new ToolbarLayout();
layout.setMinorAlignment(ToolbarLayout.ALIGN_TOPLEFT);
layout.setStretchMinorAxis(false);
layout.setSpacing(2);
setLayoutManager(layout);
setBorder(new CompartmentFigureBorder());
}

public class CompartmentFigureBorder extends AbstractBorder {

public Insets getInsets(IFigure figure) {
return new Insets(1, 0, 2, 0);
}

public void paint(IFigure figure, Graphics graphics, Insets insets) {
graphics.drawLine(getPaintRectangle(figure, insets).getTopLeft(),
tempRect.getTopRight());
}
}
}

UMLClassFigure：最终展示的Figure，主要的ClassFigure，包含所有相关方法

import org.eclipse.draw2d.ColorConstants;
import org.eclipse.draw2d.Figure;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.Label;
import org.eclipse.draw2d.LineBorder;
import org.eclipse.draw2d.MarginBorder;
import org.eclipse.draw2d.PositionConstants;
import org.eclipse.draw2d.ToolbarLayout;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;

public class UMLClassFigure extends Figure implements EntityFigure, PresentationFigure {

public static Color classColor = new Color(null, 255, 255, 206);

private Label name;

private Label stereoType;

private Image icon;

private CompartmentFigure attributeFigure = new CompartmentFigure();
private CompartmentFigure methodFigure = new CompartmentFigure();
private Figure nameFigure;

public UMLClassFigure(Image icon, Figure nameFigure) {
this.nameFigure = nameFigure;
this.name = new Label();
this.name.setForegroundColor(ColorConstants.darkGray);
this.name.setBorder(new MarginBorder(5));
this.name.setIcon(icon);
this.icon = icon;
this.stereoType = new Label();
this.stereoType.setTextAlignment(PositionConstants.CENTER);
ToolbarLayout layout = new ToolbarLayout();
setLayoutManager(layout);
setBorder(new LineBorder(1));
setBackgroundColor(classColor);
setOpaque(true);

nameFigure.setLayoutManager(new ToolbarLayout());
//
//      nameFigure.add(this.stereoType);
nameFigure.add(this.name);
add(nameFigure);
add(attributeFigure);
add(methodFigure);
}

public void setFont(Font font){
this.name.setFont(font);
}

public void setClassName(String className){
this.name.setText(className);
}

public void add(IFigure figure, Object constraint, int index) {
if(figure instanceof AttributeLabel){
attributeFigure.add(figure);
} else if(figure instanceof OperationLabel){
methodFigure.add(figure);
} else {
super.add(figure,constraint,index);
}
}

public void moveAttribute(int index, boolean up){
@SuppressWarnings("rawtypes")
List children = attributeFigure.getChildren();
IFigure obj = (IFigure)children.get(index);
attributeFigure.remove(obj);
if(up){
attributeFigure.add(obj, index - 1);
} else {
attributeFigure.add(obj, index + 1);
}
}

public void moveOperation(int index, boolean up){
@SuppressWarnings("rawtypes")
List children = methodFigure.getChildren();
IFigure obj = (IFigure)children.get(index);
methodFigure.remove(obj);
if(up){
methodFigure.add(obj, index - 1);
} else {
methodFigure.add(obj, index + 1);
}
}

public void remove(IFigure figure) {
if(figure instanceof  AttributeLabel){
attributeFigure.remove(figure);
} else if(figure instanceof OperationLabel){
methodFigure.remove(figure);
} else {
super.remove(figure);
}
}

public Label getLabel(){
return name;
}

public Rectangle getCellEditorRectangle() {
Rectangle rect = name.getBounds().getCopy();
if (name.getIcon() != null) {
return new Rectangle(rect.x + 16, rect.y, rect.width - 16, rect.height);
}
return new Rectangle(rect.x, rect.y, rect.width, rect.height);
}

public void updatePresentation(AbstractUMLModel model) {
if (model.isShowIcon()) {
name.setIcon(icon);
} else {
name.setIcon(null);
}
}

public void setStereoType(String stereoType) {
if (stereoType == null || "".equals(stereoType)) {
if (nameFigure.getChildren().contains(this.stereoType)) {
nameFigure.remove(this.stereoType);
}
} else {
this.stereoType.setText("<<" + stereoType + ">>");
if (!nameFigure.getChildren().contains(this.stereoType)) {
nameFigure.add(this.stereoType, 0);
}
}
}
}

Modal ：

在GEF框架中，Modal是非常简单的一部分，用户可以把Modal理解成一个简单的可持久化的实体。但为了能让控制器知道模型的变化，应该控制器作为事件监听者注册到Modal中，当模型发生变化时，就触发相应的事件给控制器，后者负责通知各个视图进行更新。

典型的模型对象包含PropertyChangeSupport类型的成员变量，用来添加监听器和通知监听器(控制器)，一般来说，模型会实现一个基类，用来封装事件机制，主要包括添加监听器，删除监听器，以及模型属性改变触发的相应事件。另外，当用户希望通过属性视图编辑模型属性时，模型要实现IPropertySource接口，该接口的方法解释如下：

//得到在属性页中能编辑的值，可以返回this表示当前模型

public Object getEditableValue();

//得到IPropertyDescriptor的数组，其中每一项是属性页中能编辑的项

public IPropertyDescriptor[] getPropertyDescriptors();

//通过id得到某个属性值，在添加每一项IPropertyDescriptor都会指定id

public Object getPropertyValue(Object id);

//表示特定属性id值是否改变

public boolean isPropertySet(Object id);

public void resetPropertyValue(Object id);//通过id重置属性

public void setPropertyValue(Object id, Object value);//通过id和值设置某一项属性的值

类图如下：



我们定义一个AbstractUMLModel 封装事件机制和属性编辑

public abstract class AbstractUMLModel implements Serializable, IPropertySource {

//定义属性的常量ID
public static final String P_BACKGROUND_COLOR = "_background";

public static final String P_FOREGROUND_COLOR = "_foreground";

public static final String P_SHOW_ICON = "_showicon";

private RGB backgroundColor;

private RGB foregroundColor;

private boolean showIcon = true;

private AbstractUMLEntityModel parent;

private PropertyChangeSupport listeners = new PropertyChangeSupport(this);

public void addPropertyChangeListener(PropertyChangeListener listener) {
listeners.addPropertyChangeListener(listener);
}

public void firePropertyChange(String propName, Object oldValue,Object newValue) {
listeners.firePropertyChange(propName, oldValue, newValue);
}

public void removePropertyChangeListener(PropertyChangeListener listener) {
listeners.removePropertyChangeListener(listener);
}

public Object getEditableValue() {
return this;
}

public void setParent(AbstractUMLEntityModel parent) {
this.parent = parent;
}

public AbstractUMLEntityModel getParent() {
return parent;
}

public IPropertyDescriptor[] getPropertyDescriptors() {
//定义属性的编辑项
return new IPropertyDescriptor[] {
new ColorPropertyDescriptor(P_BACKGROUND_COLOR, "Background Color"),
new ColorPropertyDescriptor(P_FOREGROUND_COLOR, "Foreground Color"),
//自定义的PropertyDescriptor
new BooleanPropertyDescriptor(P_SHOW_ICON, "Show Icon") };

}

public Object getPropertyValue(Object id) {
if (id.equals(P_BACKGROUND_COLOR)) {
return backgroundColor;
} else if (P_FOREGROUND_COLOR.equals(id)) {
return foregroundColor;
} else if (P_SHOW_ICON.equals(id)) {
return new Boolean(isShowIcon());
}
return null;
}

public boolean isPropertySet(Object id) {
return P_BACKGROUND_COLOR.equals(id) || P_FOREGROUND_COLOR.equals(id)
|| P_SHOW_ICON.equals(id);
}

//设置属性的值
public void setPropertyValue(Object id, Object value) {
if (P_BACKGROUND_COLOR.equals(id)) {
setBackgroundColor((RGB) value);
} else if (P_FOREGROUND_COLOR.equals(id)) {
setForegroundColor((RGB) value);
} else if (P_SHOW_ICON.equals(id)) {
setShowIcon(((Boolean) value).booleanValue());
}
}

public void resetPropertyValue(Object id) {
}

public Color getBackgroundColor() {
//调用自定义生成颜色对象
return UMLColorRegistry.getColor(backgroundColor);
}

public void setBackgroundColor(RGB backgroundColor) {
this.backgroundColor = backgroundColor;
//当backgroundColor改变后，触发属性改变的事件
firePropertyChange(P_BACKGROUND_COLOR, null, backgroundColor);
}

public Color getForegroundColor() {
return UMLColorRegistry.getColor(foregroundColor);
}

public void setForegroundColor(RGB foregroundColor) {
this.foregroundColor = foregroundColor;
//当foregroundColor改变后，触发属性改变的事件
firePropertyChange(P_FOREGROUND_COLOR, null, foregroundColor);
}

public boolean isShowIcon() {
return showIcon;
}

public void setShowIcon(boolean showIcon) {
this.showIcon = showIcon;
//当SHOW_ICON改变后，触发属性改变的事件
firePropertyChange(P_SHOW_ICON, null, new Boolean(showIcon));
}

public void copyPresentation(AbstractUMLModel model) {
if (backgroundColor != null) {
model.setBackgroundColor(backgroundColor);
}
if (foregroundColor != null) {
model.setForegroundColor(foregroundColor);
}
model.setShowIcon(showIcon);
}
}

AbstractUMLEntityModel代码如下：

public abstract class AbstractUMLEntityModel extends AbstractUMLModel {

private Rectangle constraint;
//定义模型连线的列表
private List<AbstractUMLConnectionModel> sourceConnections = new ArrayList<AbstractUMLConnectionModel>();
private List<AbstractUMLConnectionModel> targetConnections = new ArrayList<AbstractUMLConnectionModel>();

private List<AbstractUMLModel> children = new ArrayList<AbstractUMLModel>();
private Map<String, Boolean> filterProperty = new HashMap<String, Boolean>();

//定义属性的常量ID
public static final String P_CONSTRAINT = "_constraint";
public static final String P_SOURCE_CONNECTION = "_source_connection";
public static final String P_TARGET_CONNECTION = "_target_connection";
public static final String P_CHILDREN = "_children";
public static final String P_FILTER = "_filter";
public static final String P_FORCE_UPDATE = "_force_update";

public Map<String, Boolean> getFilterProperty() {
return filterProperty;
}

public void setFilterProperty(Map<String, Boolean> filterProperty) {
this.filterProperty = filterProperty;
firePropertyChange(P_FILTER, null, filterProperty);
}

public Rectangle getConstraint() {
return constraint;
}

public void addChild(AbstractUMLModel model) {
children.add(model);
model.setParent(this);
//当增加子模型时，触发属性改变的事件
firePropertyChange(P_CHILDREN,null,model);
}

public void removeChild(AbstractUMLModel model) {
children.remove(model);
model.setParent(this);
//当删除子模型时，触发属性改变的事件
firePropertyChange(P_CHILDREN,null,model);
}

public void forceUpdate() {
firePropertyChange(P_FORCE_UPDATE, null ,null);
}

public List<AbstractUMLModel> getChildren(){
return this.children;
}

public void setConstraint(Rectangle constraint) {
if(constraint.x < 0){
constraint.x = 0;
}
if(constraint.y < 0){
constraint.y = 0;
}
this.constraint = constraint;
firePropertyChange(P_CONSTRAINT, null, constraint);
}

public void addSourceConnection(AbstractUMLConnectionModel connx) {
sourceConnections.add(connx);
//当输入的连线改变后，触发属性改变的事件
firePropertyChange(P_SOURCE_CONNECTION, null, connx);
}

public void addTargetConnection(AbstractUMLConnectionModel connx) {
targetConnections.add(connx);
//当输入的连线改变后，触发属性改变的事件
firePropertyChange(P_TARGET_CONNECTION, null, connx);
}

public List<AbstractUMLConnectionModel> getModelSourceConnections() {
return sourceConnections;
}

public List<AbstractUMLConnectionModel> getModelTargetConnections() {
return targetConnections;
}

public void removeSourceConnection(AbstractUMLConnectionModel connx) {
sourceConnections.remove(connx);
//当输入的连线改变后，触发属性改变的事件
firePropertyChange(P_SOURCE_CONNECTION, connx, null);
}

public void removeTargetConnection(AbstractUMLConnectionModel connx) {
targetConnections.remove(connx);
//当输入的连线改变后，触发属性改变的事件
firePropertyChange(P_TARGET_CONNECTION, connx, null);
}

public void setBackgroundColor(RGB backgroundColor) {
for (Iterator<AbstractUMLModel> iter = children.iterator(); iter.hasNext();) {
AbstractUMLModel element = (AbstractUMLModel) iter.next();
element.setBackgroundColor(backgroundColor);
}
super.setBackgroundColor(backgroundColor);
}

public void setForegroundColor(RGB foregroundColor) {
for (Iterator<AbstractUMLModel> iter = children.iterator(); iter.hasNext();) {
AbstractUMLModel element = (AbstractUMLModel) iter.next();
element.setForegroundColor(foregroundColor);
}
super.setForegroundColor(foregroundColor);
}

public void setShowIcon(boolean showIcon) {
for (Iterator<AbstractUMLModel> iter = children.iterator(); iter.hasNext();) {
AbstractUMLModel element = (AbstractUMLModel) iter.next();
element.setShowIcon(showIcon);
}
super.setShowIcon(showIcon);
}
}

AbstractUMLConnectionModel，分析方法跟上面的都类似：

public abstract class AbstractUMLConnectionModel extends AbstractUMLModel {

private AbstractUMLEntityModel source;

private AbstractUMLEntityModel target;

private List<ConnectionBendpoint> bendpoints = new ArrayList<ConnectionBendpoint>();

public static final String P_BEND_POINT = "_bend_point";

public void addBendpoint(int index, ConnectionBendpoint point) {
bendpoints.add(index, point);
firePropertyChange(P_BEND_POINT, null, null);
}

public List<ConnectionBendpoint> getBendpoints() {
if (bendpoints == null) {
bendpoints = new ArrayList<ConnectionBendpoint>();
}
return bendpoints;
}

public void removeBendpoint(int index) {
bendpoints.remove(index);
firePropertyChange(P_BEND_POINT, null, null);
}

public void removeBendpoint(ConnectionBendpoint point) {
bendpoints.remove(point);
firePropertyChange(P_BEND_POINT, null, null);
}

public void replaceBendpoint(int index, ConnectionBendpoint point) {
bendpoints.set(index, point);
firePropertyChange(P_BEND_POINT, null, null);
}

public void attachSource() {

if (!source.getModelSourceConnections().contains(this)) {
source.addSourceConnection(this);
}
}

public void attachTarget() {
if (!target.getModelTargetConnections().contains(this)) {
target.addTargetConnection(this);
}
}

public void detachSource() {
if (source != null) {
source.removeSourceConnection(this);
}
}

public void detachTarget() {
if (target != null) {
target.removeTargetConnection(this);
}
}

public AbstractUMLEntityModel getSource() {
return source;
}

public AbstractUMLEntityModel getTarget() {
return target;
}

public void setSource(AbstractUMLEntityModel model) {
source = model;
}

public void setTarget(AbstractUMLEntityModel model) {
target = model;
}

public IPropertyDescriptor[] getPropertyDescriptors() {
return new IPropertyDescriptor[] {
new ColorPropertyDescriptor(P_FOREGROUND_COLOR, "Foreground Color")
};
}

}

ConnectionBendpoint类如下：

public class ConnectionBendpoint implements Serializable, Bendpoint {

private float weight = 0.5f;

private Dimension d1 = null;

private Dimension d2 = null;

public ConnectionBendpoint() {
// ignore
}

public ConnectionBendpoint(Dimension dim1, Dimension dim2) {
d1 = dim1;
d2 = dim2;
}

public Dimension getFirstRelativeDimension() {
return d1;
}

public Point getLocation() {
return null;
}

public Dimension getSecondRelativeDimension() {
return d2;
}

public float getWeight() {
return weight;
}

public void setRelativeDimensions(Dimension dim1, Dimension dim2) {
d1 = dim1;
d2 = dim2;
}

public void setWeight(float w) {
weight = w;
}
}

UMLColorRegistry类如下：

public class UMLColorRegistry {

private ColorRegistry registry;

private static UMLColorRegistry instance;

private UMLColorRegistry() {
registry = new ColorRegistry();
}
//单例
public static final Color getColor(RGB rgb) {
if (instance == null) {
instance = new UMLColorRegistry();
}
if (rgb == null) {
return null;
}
return instance.createColor(rgb);
}

//获取颜色对象
private Color createColor(RGB rgb) {
registry.put(rgb.toString(), rgb);
return registry.get(rgb.toString());
}

}

BooleanPropertyDescriptor类如下：

public class BooleanPropertyDescriptor extends PropertyDescriptor {

public BooleanPropertyDescriptor(Object id,String displayName){
super(id,displayName);
}

public CellEditor createPropertyEditor(Composite parent) {
CellEditor editor = new ComboBoxCellEditor(
parent, new String[]{"true","false"},SWT.READ_ONLY){
public void doSetValue(Object value){
if(((Boolean)value).booleanValue()){
super.doSetValue(new Integer(0));
} else {
super.doSetValue(new Integer(1));
}
}
public Object doGetValue(){
int selection = ((Integer)super.doGetValue()).intValue();
if(selection==0){
return new Boolean(true);
} else {
return new Boolean(false);
}
}
};

if (getValidator() != null)
editor.setValidator(getValidator());

return editor;
}
}

现在对于UML的抽象类已经大致看到了外貌，主要是把Figure与Model做了较详细的介绍，以及详细的代码，但是还是停留在抽象层面，下一篇文章主要针对UMLClass类图的具体类进行分析。