All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.yaoqiang.graph.view.SwimlaneManager Maven / Gradle / Ivy

There is a newer version: 2.2.18
Show newest version
package org.yaoqiang.graph.view;

import java.util.Map;

import org.yaoqiang.graph.model.YGraphModel;
import org.yaoqiang.graph.swing.YGraphComponent;
import org.yaoqiang.graph.util.Constants;
import org.yaoqiang.graph.util.Utils;

import com.mxgraph.model.mxCell;
import com.mxgraph.util.mxEvent;
import com.mxgraph.util.mxEventObject;
import com.mxgraph.util.mxEventSource;
import com.mxgraph.util.mxUtils;
import com.mxgraph.view.mxCellState;

/**
 * SwimlaneManager
 * 
 * @author Shi Yaoqiang([email protected])
 */
public class SwimlaneManager extends mxEventSource {

	protected YGraphComponent graphComponent;

	protected YGraph graph;

	protected YGraphModel model;

	public SwimlaneManager(YGraphComponent graphComponent) {
		if (this.graph != null) {
			this.graph.removeListener(handler);
		}

		this.graphComponent = graphComponent;
		this.graph = graphComponent.getGraph();
		this.model = graphComponent.getGraph().getModel();

		if (this.graph != null) {
			this.graph.addListener(null, handler);
		}
	}

	public final mxIEventListener getHandler() {
		return handler;
	}

	protected mxIEventListener handler = new mxIEventListener() {
		public void invoke(Object source, mxEventObject evt) {
			String eventName = evt.getName();
			if (evt.getName().equals(mxEvent.REPAINT) || evt.getName().equals(mxEvent.CONNECT_CELL) || evt.getName().equals(mxEvent.CELL_CONNECTED)
					|| evt.getName().equals(mxEvent.CHANGE) || evt.getName().equals(mxEvent.ORDER_CELLS) || evt.getName().equals(mxEvent.CELLS_ORDERED)) {
				return;
			}

			Object cell = graph.getSelectionCell();
			Object[] cells = (Object[]) evt.getProperty("cells");
			if (cell == null) {
				if (cells != null && cells.length > 0) {
					cell = (mxCell) cells[0];
				}
			}
			if (!graph.isSwimlane(cell) && !eventName.equals(mxEvent.ROOT) && !eventName.equals(mxEvent.MOVE_CELLS) && !eventName.equals(mxEvent.FOLD_CELLS) && !eventName.equals(mxEvent.RESIZE_CELLS)) {
				return;
			}

			if (eventName.equals(mxEvent.RESIZE_CELLS) || (!graph.isSwimlane(cell) && eventName.equals(mxEvent.FOLD_CELLS))) {
				model.beginUpdate();
				try {
					if (!graph.isSwimlane(cell)) {
						cell = graph.getParentSwimlane(cell);
					}
					if (cell != null) {
						Utils.arrangeSwimlanePosition(graphComponent);
						Utils.arrangeSwimlaneLength(graph, cell, false, false);
						Utils.manualArrangeSwimlaneLength(graph, cell);
						Utils.arrangeSwimlaneSize(graph, cell, false, false, true);
					}
				} finally {
					model.endUpdate();
				}
			} else if (eventName.equals(mxEvent.REMOVE_CELLS)) {
				Utils.arrangeSwimlaneSize(graph, cell, false, false, true);
				Object parent = model.getParent(cell);
				if (graph.isVerticalSwimlane(cell)) {
					Utils.arrangeLaneXOffset(graph, parent);
				} else {
					Utils.arrangeLaneYOffset(graph, parent);
				}
				if (graph.isLane(parent) && model.getChildCount(parent) == 0) {
					Utils.setLaneStyle(graph, parent);
				}
			} else if (eventName.equals(mxEvent.FOLD_CELLS)) {
				model.beginUpdate();
				try {
					Utils.arrangeSwimlaneLength(graph, cell, false, true);
					Utils.manualArrangeSwimlaneLength(graph, cell);
					Utils.arrangeSwimlaneSize(graph, cell, false, true, false);
					if (graph.isManualPool(model.getParent(cell))) {
						if (graph.isVerticalSwimlane(model.getParent(cell))) {
							Utils.arrangeLaneXOffset(graph, model.getParent(cell));
						} else {
							Utils.arrangeLaneYOffset(graph, model.getParent(cell));
						}
					} else {
						Utils.arrangeSwimlanePosition(graphComponent);
					}
				} finally {
					model.endUpdate();
				}
			} else if (eventName.equals(mxEvent.UNDO) || eventName.equals(mxEvent.REDO)) {
				Utils.arrangeSwimlaneLength(graph, cell, true, false);
				Utils.manualArrangeSwimlaneLength(graph, cell);
				Utils.arrangeSwimlaneSize(graph, cell, false, false, false);
				if (graph.isVerticalSwimlane(cell)) {
					Utils.arrangeLaneXOffset(graph, model.getParent(cell));
				} else {
					Utils.arrangeLaneYOffset(graph, model.getParent(cell));
				}
				Utils.arrangeSwimlanePosition(graphComponent);
			} else if (eventName.equals(mxEvent.MOVE_CELLS)) {
				Object targetCell = evt.getProperty("target");
				boolean changeStyle = evt.getProperty("changeStyle") == null ? true : false;
				for (int i = 0; i < cells.length; i++) {
					String value = (String) model.getValue(cells[i]);
					mxCellState state = graph.getView().getState(cells[i]);
					Map style = (state != null) ? state.getStyle() : graph.getCellStyle(cells[i]);

					if (graph.isSwimlane(cells[i]) && changeStyle) {
						if (targetCell == null || graph.isPlane(targetCell)) {
							if (value.equals("Lane")) {
								model.setValue(cells[i], "Participant");
							}
							if (mxUtils.isTrue(style, Constants.SWIMLANE_STYLE_LANE, true)) {
								Utils.setPoolStyle(graph, cells[i]);
							}
						} else if (graph.isSwimlane(targetCell)) {
							if (value.equals("Participant")) {
								model.setValue(cells[i], "Lane");
							}
							if (model.getChildCount(cells[i]) == 0 || graph.hasChildNonLane(cells[i])) {
								Utils.setLaneStyle(graph, cells[i]);
							}
							// if (model.getChildCount(targetCell) == 1) {
							// if (!graph.isPool(targetCell)) {
							// Utils.setPoolStyle(graph, targetCell);
							// }
							// }
						}
					}
				}

				if ((targetCell == null || graph.isPlane(targetCell) || graph.isSwimlane(targetCell)) && graph.isSwimlane(cells[0])) {
					Utils.arrangeSwimlaneLength(graph, cells[0], true, false);
					Utils.manualArrangeSwimlaneLength(graph, cells[0]);
					Utils.arrangeSwimlaneSize(graph, cells[0], false, false, false);
					Utils.arrangeSwimlanePosition(graphComponent);
				} else if (graph.isSwimlane(targetCell) && !graph.isSwimlane(cells[0])) {
					Utils.arrangeSwimlaneSize(graph, targetCell, false, false, false);
					Utils.arrangeSwimlanePosition(graphComponent);
				}
			} else if (eventName.equals(mxEvent.ROOT)) {
				for (Object pool : graph.getAllPools()) {
					Utils.arrangeSwimlaneLength(graph, pool, true, false);
					Utils.manualArrangeSwimlaneLength(graph, pool);
					Utils.arrangeSwimlaneSize(graph, pool, false, true, false);
					Utils.arrangeSwimlanePosition(graphComponent);
				}
			} else if (eventName.equals(mxEvent.CELLS_ADDED)) {
				Object parent = evt.getProperty("parent");
				if (parent != null) {
					if (graph.isVerticalSwimlane(cell)) {
						Utils.arrangeLaneXOffset(graph, parent);
					} else {
						Utils.arrangeLaneYOffset(graph, parent);
					}
				}
			}

			graph.refresh();
		}
	};

}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy