/*******************************************************************************
* Copyright (c) 2000, 2005 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.gef.examples.logicdesigner.model.commands;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Vector;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.gef.commands.Command;
import org.eclipse.gef.examples.logicdesigner.LogicMessages;
import org.eclipse.gef.examples.logicdesigner.model.AndGate;
import org.eclipse.gef.examples.logicdesigner.model.Circuit;
import org.eclipse.gef.examples.logicdesigner.model.GroundOutput;
import org.eclipse.gef.examples.logicdesigner.model.LED;
import org.eclipse.gef.examples.logicdesigner.model.LiveOutput;
import org.eclipse.gef.examples.logicdesigner.model.LogicDiagram;
import org.eclipse.gef.examples.logicdesigner.model.LogicFlowContainer;
import org.eclipse.gef.examples.logicdesigner.model.LogicGuide;
import org.eclipse.gef.examples.logicdesigner.model.LogicLabel;
import org.eclipse.gef.examples.logicdesigner.model.LogicSubpart;
import org.eclipse.gef.examples.logicdesigner.model.OrGate;
import org.eclipse.gef.examples.logicdesigner.model.Wire;
import org.eclipse.gef.examples.logicdesigner.model.WireBendpoint;
import org.eclipse.gef.examples.logicdesigner.model.XORGate;
public class CloneCommand
extends Command
{
private List parts, newTopLevelParts, newConnections;
private LogicDiagram parent;
private Map bounds, indices, connectionPartMap;
private ChangeGuideCommand vGuideCommand, hGuideCommand;
private LogicGuide hGuide, vGuide;
private int hAlignment, vAlignment;
public CloneCommand() {
super(LogicMessages.CloneCommand_Label);
parts = new LinkedList();
}
public void addPart(LogicSubpart part, Rectangle newBounds) {
parts.add(part);
if (bounds == null) {
bounds = new HashMap();
}
bounds.put(part, newBounds);
}
public void addPart(LogicSubpart part, int index) {
parts.add(part);
if (indices == null) {
indices = new HashMap();
}
indices.put(part, new Integer(index));
}
protected void clonePart(LogicSubpart oldPart, LogicDiagram newParent, Rectangle newBounds,
List newConnections, Map connectionPartMap, int index) {
LogicSubpart newPart = null;
if (oldPart instanceof AndGate) {
newPart = new AndGate();
} else if (oldPart instanceof Circuit) {
newPart = new Circuit();
} else if (oldPart instanceof GroundOutput) {
newPart = new GroundOutput();
} else if (oldPart instanceof LED) {
newPart = new LED();
newPart.setPropertyValue(LED.P_VALUE, oldPart.getPropertyValue(LED.P_VALUE));
} else if (oldPart instanceof LiveOutput) {
newPart = new LiveOutput();
} else if (oldPart instanceof LogicLabel) {
newPart = new LogicLabel();
((LogicLabel)newPart).setLabelContents(((LogicLabel)oldPart).getLabelContents());
} else if (oldPart instanceof OrGate) {
newPart = new OrGate();
} else if (oldPart instanceof LogicFlowContainer) {
newPart = new LogicFlowContainer();
} else if (oldPart instanceof XORGate) {
newPart = new XORGate();
}
if (oldPart instanceof LogicDiagram) {
Iterator i = ((LogicDiagram)oldPart).getChildren().iterator();
while (i.hasNext()) {
// for children they will not need new bounds
clonePart((LogicSubpart)i.next(), (LogicDiagram)newPart, null,
newConnections, connectionPartMap, -1);
}
}
Iterator i = oldPart.getTargetConnections().iterator();
while (i.hasNext()) {
Wire connection = (Wire)i.next();
Wire newConnection = new Wire();
newConnection.setValue(connection.getValue());
newConnection.setTarget(newPart);
newConnection.setTargetTerminal(connection.getTargetTerminal());
newConnection.setSourceTerminal(connection.getSourceTerminal());
newConnection.setSource(connection.getSource());
Iterator b = connection.getBendpoints().iterator();
Vector newBendPoints = new Vector();
while (b.hasNext()) {
WireBendpoint bendPoint = (WireBendpoint)b.next();
WireBendpoint newBendPoint = new WireBendpoint();
newBendPoint.setRelativeDimensions(bendPoint.getFirstRelativeDimension(),
bendPoint.getSecondRelativeDimension());
newBendPoint.setWeight(bendPoint.getWeight());
newBendPoints.add(newBendPoint);
}
newConnection.setBendpoints(newBendPoints);
newConnections.add(newConnection);
}
if (index < 0) {
newParent.addChild(newPart);
} else {
newParent.addChild(newPart, index);
}
newPart.setSize(oldPart.getSize());
if (newBounds != null) {
newPart.setLocation(newBounds.getTopLeft());
} else {
newPart.setLocation(oldPart.getLocation());
}
// keep track of the new parts so we can delete them in undo
// keep track of the oldpart -> newpart map so that we can properly attach
// all connections.
if (newParent == parent)
newTopLevelParts.add(newPart);
connectionPartMap.put(oldPart, newPart);
}
public void execute() {
connectionPartMap = new HashMap();
newConnections = new LinkedList();
newTopLevelParts = new LinkedList();
Iterator i = parts.iterator();
LogicSubpart part = null;
while (i.hasNext()) {
part = (LogicSubpart)i.next();
if (bounds != null && bounds.containsKey(part)) {
clonePart(part, parent, (Rectangle)bounds.get(part),
newConnections, connectionPartMap, -1);
} else if (indices != null && indices.containsKey(part)) {
clonePart(part, parent, null, newConnections,
connectionPartMap, ((Integer)indices.get(part)).intValue());
} else {
clonePart(part, parent, null, newConnections, connectionPartMap, -1);
}
}
// go through and set the source of each connection to the proper source.
Iterator c = newConnections.iterator();
while (c.hasNext()) {
Wire conn = (Wire)c.next();
LogicSubpart source = conn.getSource();
if (connectionPartMap.containsKey(source)) {
conn.setSource((LogicSubpart)connectionPartMap.get(source));
conn.attachSource();
conn.attachTarget();
}
}
if (hGuide != null) {
hGuideCommand = new ChangeGuideCommand(
(LogicSubpart)connectionPartMap.get(parts.get(0)), true);
hGuideCommand.setNewGuide(hGuide, hAlignment);
hGuideCommand.execute();
}
if (vGuide != null) {
vGuideCommand = new ChangeGuideCommand(
(LogicSubpart)connectionPartMap.get(parts.get(0)), false);
vGuideCommand.setNewGuide(vGuide, vAlignment);
vGuideCommand.execute();
}
}
public void setParent(LogicDiagram parent) {
this.parent = parent;
}
public void redo() {
for (Iterator iter = newTopLevelParts.iterator(); iter.hasNext();)
parent.addChild((LogicSubpart)iter.next());
for (Iterator iter = newConnections.iterator(); iter.hasNext();) {
Wire conn = (Wire) iter.next();
LogicSubpart source = conn.getSource();
if (connectionPartMap.containsKey(source)) {
conn.setSource((LogicSubpart)connectionPartMap.get(source));
conn.attachSource();
conn.attachTarget();
}
}
if (hGuideCommand != null)
hGuideCommand.redo();
if (vGuideCommand != null)
vGuideCommand.redo();
}
public void setGuide(LogicGuide guide, int alignment, boolean isHorizontal) {
if (isHorizontal) {
hGuide = guide;
hAlignment = alignment;
} else {
vGuide = guide;
vAlignment = alignment;
}
}
public void undo() {
if (hGuideCommand != null)
hGuideCommand.undo();
if (vGuideCommand != null)
vGuideCommand.undo();
for (Iterator iter = newTopLevelParts.iterator(); iter.hasNext();)
parent.removeChild((LogicSubpart)iter.next());
}
}