/*******************************************************************************
* Copyright (c) 2001, 2009 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.wst.xsd.ui.internal.adt.design.editparts;
import java.util.Iterator;
import java.util.List;
import org.eclipse.draw2d.ColorConstants;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.Label;
import org.eclipse.draw2d.PositionConstants;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.gef.DragTracker;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.EditPolicy;
import org.eclipse.gef.GraphicalEditPart;
import org.eclipse.gef.LayerConstants;
import org.eclipse.gef.Request;
import org.eclipse.gef.RequestConstants;
import org.eclipse.gef.commands.Command;
import org.eclipse.gef.editparts.AbstractGraphicalEditPart;
import org.eclipse.gef.requests.DirectEditRequest;
import org.eclipse.gef.requests.LocationRequest;
import org.eclipse.swt.custom.CCombo;
import org.eclipse.swt.widgets.Display;
import org.eclipse.wst.xsd.ui.internal.adapters.XSDBaseAdapter;
import org.eclipse.wst.xsd.ui.internal.adt.design.directedit.ComboBoxCellEditorManager;
import org.eclipse.wst.xsd.ui.internal.adt.design.directedit.ElementReferenceDirectEditManager;
import org.eclipse.wst.xsd.ui.internal.adt.design.directedit.LabelCellEditorLocator;
import org.eclipse.wst.xsd.ui.internal.adt.design.directedit.LabelEditManager;
import org.eclipse.wst.xsd.ui.internal.adt.design.directedit.TypeReferenceDirectEditManager;
import org.eclipse.wst.xsd.ui.internal.adt.design.editparts.model.FocusTypeColumn;
import org.eclipse.wst.xsd.ui.internal.adt.design.editpolicies.ADTDirectEditPolicy;
import org.eclipse.wst.xsd.ui.internal.adt.design.editpolicies.ADTSelectionFeedbackEditPolicy;
import org.eclipse.wst.xsd.ui.internal.adt.design.editpolicies.IADTUpdateCommand;
import org.eclipse.wst.xsd.ui.internal.adt.design.figures.IFieldFigure;
import org.eclipse.wst.xsd.ui.internal.adt.editor.Messages;
import org.eclipse.wst.xsd.ui.internal.adt.facade.IADTObject;
import org.eclipse.wst.xsd.ui.internal.adt.facade.IField;
import org.eclipse.wst.xsd.ui.internal.adt.facade.IType;
import org.eclipse.wst.xsd.ui.internal.design.editparts.ConnectableEditPart;
import org.eclipse.wst.xsd.ui.internal.design.editparts.TargetConnectionSpacingFigureEditPart;
import org.eclipse.wst.xsd.ui.internal.design.editparts.model.TargetConnectionSpaceFiller;
import org.eclipse.wst.xsd.ui.internal.design.editpolicies.GraphNodeDragTracker;
import org.eclipse.xsd.XSDNamedComponent;
public class BaseFieldEditPart extends BaseTypeConnectingEditPart implements INamedEditPart, IAutoDirectEdit
{
protected TypeReferenceConnection connectionFigure;
protected ADTDirectEditPolicy adtDirectEditPolicy = new ADTDirectEditPolicy();
protected TypeReferenceConnection connectionFeedbackFigure;
protected IFigure createFigure()
{
IFieldFigure figure = getFigureFactory().createFieldFigure(getModel());
figure.setForegroundColor(ColorConstants.black);
return figure;
}
public IFieldFigure getFieldFigure()
{
return (IFieldFigure)figure;
}
protected boolean shouldDrawConnection()
{
boolean result = false;
// For now we only want to produce outbound lines from a Field to a Type
// when the field in contained in the 'focus' edit part
for (EditPart parent = getParent(); parent != null; parent = parent.getParent())
{
if (parent.getModel() instanceof FocusTypeColumn)
{
result = true;
break;
}
}
return result;
}
private EditPart getTargetEditPart(IType type)
{
ColumnEditPart columnEditPart = null;
for (EditPart editPart = this; editPart != null; editPart = editPart.getParent())
{
if (editPart instanceof ColumnEditPart)
{
columnEditPart = (ColumnEditPart)editPart;
break;
}
}
if (columnEditPart != null)
{
// get the next column
EditPart parent = columnEditPart.getParent();
List columns = parent.getChildren();
int index = columns.indexOf(columnEditPart);
if (index + 1 < columns.size())
{
EditPart nextColumn = (EditPart)columns.get(index + 1);
for (Iterator i = nextColumn.getChildren().iterator(); i.hasNext(); )
{
EditPart child = (EditPart)i.next();
if (child.getModel() == type)
{
return child;
}
}
}
}
return null;
}
private EditPart getTargetConnectionEditPart()
{
EditPart result = null;
IField field = (IField)getModel();
IType type = field.getType();
if (type != null)
{
result = getTargetEP(type); //getTargetEditPart(type);
}
return result;
}
/**
* Do not override
* @param type
* @return
*/
protected EditPart getTargetEP(IType type)
{
return getTargetEditPart(type);
}
public TypeReferenceConnection createConnectionFigure()
{
connectionFigure = null;
AbstractGraphicalEditPart referenceTypePart = (AbstractGraphicalEditPart)getTargetConnectionEditPart();
if (referenceTypePart != null)
{
connectionFigure = new TypeReferenceConnection();
if (getFigure().getParent() == referenceTypePart.getFigure())
{
connectionFigure.setSourceAnchor(new CenteredConnectionAnchor(getFigure(), CenteredConnectionAnchor.LEFT, 1));
}
else
{
connectionFigure.setSourceAnchor(new CenteredConnectionAnchor(getFigure(), CenteredConnectionAnchor.RIGHT, 5));
}
int targetAnchorYOffset = 8;
connectionFigure.setTargetAnchor(new CenteredConnectionAnchor(referenceTypePart.getFigure(), CenteredConnectionAnchor.HEADER_LEFT, 0, targetAnchorYOffset));
connectionFigure.setHighlight(false);
}
return connectionFigure;
}
protected void createEditPolicies()
{
super.createEditPolicies();
installEditPolicy(EditPolicy.DIRECT_EDIT_ROLE, adtDirectEditPolicy);
installEditPolicy(EditPolicy.SELECTION_FEEDBACK_ROLE, new ADTSelectionFeedbackEditPolicy());
}
public EditPart doGetRelativeEditPart(EditPart editPart, int direction)
{
EditPart result = null;
if (direction == PositionConstants.EAST)
{
result = getTargetConnectionEditPart();
}
else if (direction == PositionConstants.WEST)
{
for (Iterator iter = getParent().getChildren().iterator(); iter.hasNext(); )
{
Object child = iter.next();
if (child instanceof SectionEditPart)
{
SectionEditPart groups = (SectionEditPart) child;
for (Iterator i = groups.getChildren().iterator(); i.hasNext(); )
{
Object groupChild = i.next();
EditPart connectable = getParentConnectableEditPart((EditPart)groupChild);
if (connectable != null)
{
result = connectable;
}
}
}
}
if (result == null)
{
result = this;
}
}
else
{
result = super.doGetRelativeEditPart(editPart, direction);
if (result == null)
{
result = ((BaseEditPart)getParent()).doGetRelativeEditPart(editPart, direction);
}
}
return result;
}
protected ConnectableEditPart getParentConnectableEditPart(EditPart connectable)
{
if (connectable instanceof TargetConnectionSpacingFigureEditPart)
{
TargetConnectionSpaceFiller space = (TargetConnectionSpaceFiller) ((TargetConnectionSpacingFigureEditPart)connectable).getModel();
if (space.getAdapter() == this.getModel())
{
return (ConnectableEditPart)connectable;
}
}
for (Iterator i = connectable.getChildren().iterator(); i.hasNext(); )
{
Object child = i.next();
if (child instanceof ConnectableEditPart)
{
ConnectableEditPart r = getParentConnectableEditPart((EditPart)child);
if (r != null) return r;
}
else if (child instanceof TargetConnectionSpacingFigureEditPart)
{
TargetConnectionSpaceFiller space = (TargetConnectionSpaceFiller) ((TargetConnectionSpacingFigureEditPart)child).getModel();
if (space.getAdapter() == this.getModel() && connectable instanceof ConnectableEditPart)
{
return (ConnectableEditPart)connectable;
}
}
}
return null;
}
protected void refreshVisuals()
{
super.refreshVisuals();
IFieldFigure figure = getFieldFigure();
IField field = (IField) getModel();
figure.getNameLabel().setText(field.getName());
figure.getTypeLabel().setText(field.getTypeName());
figure.refreshVisuals(getModel());
figure.recomputeLayout();
((GraphicalEditPart)getRoot()).getFigure().invalidateTree();
}
public DragTracker getDragTracker(Request request)
{
return new GraphNodeDragTracker(this);
}
/*
public IAction[] getActions(Object object)
{
// when a FieldEditPart is selected it provides it's own actions
// as well as those of it's parent 'type' edit part
List list = new ArrayList();
EditPart compartment = getParent();
if (compartment != null)
{
EditPart type = compartment.getParent();
if (type != null && type instanceof IActionProvider)
{
IActionProvider provider = (IActionProvider)type;
addActionsToList(list, provider.getActions(object));
}
}
addActionsToList(list, super.getActions(object));
IAction[] result = new IAction[list.size()];
list.toArray(result);
return result;
}*/
public Label getNameLabelFigure()
{
return getFieldFigure().getNameLabel();
}
public void performDirectEdit(Point cursorLocation)
{
}
public void performRequest(Request request)
{
if (((IADTObject)getModel()).isReadOnly() || isFileReadOnly())
{
return;
}
if (request.getType() == RequestConstants.REQ_DIRECT_EDIT||
request.getType() == RequestConstants.REQ_OPEN)
{
IFieldFigure fieldFigure = getFieldFigure();
Object model = getModel();
if (request instanceof LocationRequest)
{
LocationRequest locationRequest = (LocationRequest)request;
Point p = locationRequest.getLocation();
if (hitTest(fieldFigure.getTypeLabel(), p))
{
TypeReferenceDirectEditManager manager = new TypeReferenceDirectEditManager((IField)model, this, fieldFigure.getTypeLabel());
TypeUpdateCommand typeUpdateCommand = new TypeUpdateCommand();
typeUpdateCommand.setDelegate(manager);
adtDirectEditPolicy.setUpdateCommand(typeUpdateCommand);
manager.show();
}
else if (hitTest(fieldFigure.getNameLabel(), p))
{
directEditNameField();
}
}
else {
directEditNameField();
}
}
}
protected void directEditNameField()
{
if (isFileReadOnly()) return;
Object model = getModel();
IFieldFigure fieldFigure = getFieldFigure();
if ( model instanceof IField)
{
IField field = (IField) model;
if (field.isReference())
{
ElementReferenceDirectEditManager manager = new ElementReferenceDirectEditManager((IField) model, this, fieldFigure.getNameLabel());
ReferenceUpdateCommand elementUpdateCommand = new ReferenceUpdateCommand();
elementUpdateCommand.setDelegate(manager);
adtDirectEditPolicy.setUpdateCommand(elementUpdateCommand);
manager.show();
}
else
{
LabelEditManager manager = new LabelEditManager(this, new LabelCellEditorLocator(this, null));
NameUpdateCommandWrapper wrapper = new NameUpdateCommandWrapper();
adtDirectEditPolicy.setUpdateCommand(wrapper);
manager.show();
}
}
}
public void doEditName(boolean addFromDesign)
{
if (!addFromDesign) return;
// removeFeedback();
Runnable runnable = new Runnable()
{
public void run()
{
Object object = ((XSDBaseAdapter)getModel()).getTarget();
if (object instanceof XSDNamedComponent)
{
Point p = getNameLabelFigure().getLocation();
LabelEditManager manager = new LabelEditManager(BaseFieldEditPart.this, new LabelCellEditorLocator(BaseFieldEditPart.this, p));
NameUpdateCommandWrapper wrapper = new NameUpdateCommandWrapper();
adtDirectEditPolicy.setUpdateCommand(wrapper);
manager.show();
}
}
};
Display.getCurrent().asyncExec(runnable);
}
protected class NameUpdateCommandWrapper extends Command implements IADTUpdateCommand
{
Command command;
protected DirectEditRequest request;
public NameUpdateCommandWrapper()
{
super(Messages._UI_ACTION_UPDATE_NAME);
}
public void setRequest(DirectEditRequest request)
{
this.request = request;
}
public void execute()
{
IField field = (IField)getModel();
Object newValue = request.getCellEditor().getValue();
if (newValue instanceof String)
{
command = field.getUpdateNameCommand((String)newValue);
}
if (command != null)
command.execute();
}
}
class TypeUpdateCommand extends Command implements IADTUpdateCommand
{
protected ComboBoxCellEditorManager delegate;
protected DirectEditRequest request;
public TypeUpdateCommand()
{
super(Messages._UI_ACTION_UPDATE_TYPE);
}
public void setDelegate(ComboBoxCellEditorManager delegate)
{
this.delegate = delegate;
}
public void setRequest(DirectEditRequest request)
{
this.request = request;
}
public void execute()
{
if (delegate != null)
{
delegate.performEdit(request.getCellEditor());
}
}
public boolean canExecute()
{
IField field = (IField)getModel();
Object newValue = ((CCombo)request.getCellEditor().getControl()).getText();
if (newValue instanceof String)
{
return !newValue.equals(field.getTypeName());
}
return true;
}
}
protected class ReferenceUpdateCommand extends Command implements IADTUpdateCommand
{
protected ComboBoxCellEditorManager delegate;
protected DirectEditRequest request;
public ReferenceUpdateCommand()
{
super(Messages._UI_ACTION_UPDATE_ELEMENT_REFERENCE);
}
public void setDelegate(ComboBoxCellEditorManager delegate)
{
this.delegate = delegate;
}
public void setRequest(DirectEditRequest request)
{
this.request = request;
}
public void execute()
{
if (delegate != null)
{
delegate.performEdit(request.getCellEditor());
}
}
public boolean canExecute()
{
return true;
}
}
public void addFeedback()
{
// Put back connection figure so it won't get overlayed by other non highlighted connections
if (connectionFigure != null && !isSelected)
{
connectionFeedbackFigure = new TypeReferenceConnection();
connectionFeedbackFigure.setSourceAnchor(connectionFigure.getSourceAnchor());
connectionFeedbackFigure.setTargetAnchor(connectionFigure.getTargetAnchor());
connectionFeedbackFigure.setHighlight(true);
getLayer(LayerConstants.FEEDBACK_LAYER).add(connectionFeedbackFigure);
}
super.addFeedback();
getFieldFigure().addSelectionFeedback();
}
public void removeFeedback()
{
if (connectionFeedbackFigure != null)
{
connectionFeedbackFigure.setHighlight(false);
getLayer(LayerConstants.FEEDBACK_LAYER).remove(connectionFeedbackFigure);
}
connectionFeedbackFigure = null;
super.removeFeedback();
getFieldFigure().removeSelectionFeedback();
}
public String getReaderText()
{
IFieldFigure fieldFigure = getFieldFigure();
String name="";
if (fieldFigure.getNameLabel() !=null&& fieldFigure.getNameLabel().getText().trim().length() > 0)
name +=fieldFigure.getNameLabel().getText();
if (fieldFigure.getNameAnnotationLabel() !=null && fieldFigure.getNameAnnotationLabel().getText().trim().length() > 0)
name += " "+fieldFigure.getNameAnnotationLabel().getText();
if (fieldFigure.getTypeLabel() !=null && fieldFigure.getTypeLabel().getText().trim().length() > 0)
name += " type "+fieldFigure.getTypeLabel().getText();
if (fieldFigure.getTypeAnnotationLabel() !=null && fieldFigure.getTypeAnnotationLabel().getText().trim().length() >0)
name += " "+fieldFigure.getTypeAnnotationLabel().getText();
return name;
}
}