GraphicalElementPatternRole.java

package org.openflexo.foundation.viewpoint;

import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
import java.util.logging.Logger;

import org.openflexo.antar.binding.Bindable;
import org.openflexo.antar.binding.BindingDefinition;
import org.openflexo.antar.binding.BindingDefinition.BindingDefinitionType;
import org.openflexo.antar.binding.BindingFactory;
import org.openflexo.fge.GraphicalRepresentation;
import org.openflexo.foundation.viewpoint.GraphicalElementAction.ActionMask;
import org.openflexo.foundation.viewpoint.ViewPoint.ViewPointBuilder;
import org.openflexo.foundation.viewpoint.binding.ViewPointDataBinding;
import org.openflexo.foundation.viewpoint.dm.GraphicalElementActionInserted;
import org.openflexo.foundation.viewpoint.dm.GraphicalElementActionRemoved;
import org.openflexo.foundation.viewpoint.inspector.InspectorBindingAttribute;

public abstract class GraphicalElementPatternRole extends PatternRole implements Bindable {

	@SuppressWarnings("unused")
	private static final Logger logger = Logger.getLogger(GraphicalElementPatternRole.class.getPackage().getName());

	private boolean readOnlyLabel;
	private ViewPointDataBinding label;

	private String exampleLabel = "label";

	protected Vector<GraphicalElementSpecification<?, ?>> grSpecifications;

	private Vector<GraphicalElementAction> actions;

	public GraphicalElementPatternRole(ViewPointBuilder builder) {
		super(builder);
		initDefaultSpecifications();
	}

	protected void initDefaultSpecifications() {
		grSpecifications = new Vector<GraphicalElementSpecification<?, ?>>();
		for (GraphicalFeature<?, ?> GF : AVAILABLE_FEATURES) {
			grSpecifications.add(new GraphicalElementSpecification(this, GF, false, true));
		}
	}

	public abstract GraphicalRepresentation<?> getGraphicalRepresentation();

	public abstract void setGraphicalRepresentation(GraphicalRepresentation<?> graphicalRepresentation);

	public abstract void _setGraphicalRepresentationNoNotification(GraphicalRepresentation<?> graphicalRepresentation);

	public static enum GraphicalElementBindingAttribute implements InspectorBindingAttribute {
		label
	}

	private BindingDefinition LABEL;

	public BindingDefinition getLabelBindingDefinition() {
		if (LABEL == null) {
			LABEL = new BindingDefinition("label", String.class, BindingDefinitionType.GET_SET, false) {
				@Override
				public BindingDefinitionType getBindingDefinitionType() {
					if (getReadOnlyLabel()) {
						return BindingDefinitionType.GET;
					} else {
						return BindingDefinitionType.GET_SET;
					}
				}
			};
		}
		return LABEL;
	}

	// Convenient method to access spec for label feature
	public ViewPointDataBinding getLabel() {
		return getGraphicalElementSpecification(LABEL_FEATURE).getValue();
	}

	// Convenient method to access spec for label feature
	public void setLabel(ViewPointDataBinding label) {
		getGraphicalElementSpecification(LABEL_FEATURE).setValue(label);
	}

	// Convenient method to access read-only property for spec for label feature
	public boolean getReadOnlyLabel() {
		return getGraphicalElementSpecification(LABEL_FEATURE).getReadOnly();
	}

	// Convenient method to access read-only property for spec for label feature
	public void setReadOnlyLabel(boolean readOnlyLabel) {
		getGraphicalElementSpecification(LABEL_FEATURE).setReadOnly(readOnlyLabel);
	}

	@Override
	public BindingFactory getBindingFactory() {
		return getEditionPattern().getInspector().getBindingFactory();
	}

	/*@Override
	public BindingModel getBindingModel() {
		return getEditionPattern().getInspector().getBindingModel();
	}*/

	public boolean getIsPrimaryRepresentationRole() {
		if (getEditionPattern() == null) {
			return false;
		}
		return getEditionPattern().getPrimaryRepresentationRole() == this;
	}

	public void setIsPrimaryRepresentationRole(boolean isPrimary) {
		if (getEditionPattern() == null) {
			return;
		}
		if (isPrimary) {
			getEditionPattern().setPrimaryRepresentationRole(this);
		} else {
			getEditionPattern().setPrimaryRepresentationRole(null);
		}
	}

	public boolean isIncludedInPrimaryRepresentationRole() {
		return getIsPrimaryRepresentationRole();
	}

	@Override
	public boolean getIsPrimaryRole() {
		return getIsPrimaryRepresentationRole();
	}

	@Override
	public void setIsPrimaryRole(boolean isPrimary) {
		setIsPrimaryRepresentationRole(isPrimary);
	}

	public boolean containsShapes() {
		for (ShapePatternRole role : getEditionPattern().getShapePatternRoles()) {
			if (role.getParentShapePatternRole() == this) {
				return true;
			}
		}
		return false;
	}

	public String getExampleLabel() {
		return exampleLabel;
	}

	public void setExampleLabel(String exampleLabel) {
		this.exampleLabel = exampleLabel;
	}

	public Vector<GraphicalElementAction> getActions() {
		return actions;
	}

	public void setActions(Vector<GraphicalElementAction> someActions) {
		actions = someActions;
	}

	public void addToActions(GraphicalElementAction anAction) {
		anAction.setGraphicalElementPatternRole(this);
		actions.add(anAction);
		setChanged();
		notifyObservers(new GraphicalElementActionInserted(anAction, this));
	}

	public void removeFromActions(GraphicalElementAction anAction) {
		anAction.setGraphicalElementPatternRole(null);
		actions.remove(anAction);
		setChanged();
		notifyObservers(new GraphicalElementActionRemoved(anAction, this));
	}

	public List<GraphicalElementAction.ActionMask> getReferencedMasks() {
		ArrayList<GraphicalElementAction.ActionMask> returned = new ArrayList<GraphicalElementAction.ActionMask>();
		for (GraphicalElementAction a : getActions()) {
			if (!returned.contains(a.getActionMask())) {
				returned.add(a.getActionMask());
			}
		}
		return returned;
	}

	public List<GraphicalElementAction> getActions(ActionMask mask) {
		ArrayList<GraphicalElementAction> returned = new ArrayList<GraphicalElementAction>();
		for (GraphicalElementAction a : getActions()) {
			if (a.getActionMask() == mask) {
				returned.add(a);
			}
		}
		return returned;
	}

	public GraphicalElementAction createAction() {
		GraphicalElementAction newAction = new GraphicalElementAction(null);
		addToActions(newAction);
		return newAction;
	}

	public GraphicalElementAction deleteAction(GraphicalElementAction anAction) {
		removeFromActions(anAction);
		anAction.delete();
		return anAction;
	}

	public Vector<GraphicalElementSpecification<?, ?>> getGrSpecifications() {
		return grSpecifications;
	}

	public GraphicalElementSpecification<?, ?> getGraphicalElementSpecification(String featureName) {
		for (GraphicalElementSpecification<?, ?> spec : grSpecifications) {
			if (spec.getFeatureName().equals(featureName)) {
				return spec;
			}
		}
		return null;
	}

	public GraphicalElementSpecification<?, ?> getGraphicalElementSpecification(GraphicalFeature<?, ?> feature) {
		if (feature != null) {
			return getGraphicalElementSpecification(feature.getName());
		}
		return null;
	}

	public Vector<GraphicalElementSpecification<?, ?>> _getDeclaredGRSpecifications() {
		Vector<GraphicalElementSpecification<?, ?>> returned = new Vector<GraphicalElementSpecification<?, ?>>();
		for (GraphicalElementSpecification<?, ?> spec : grSpecifications) {
			if (spec.getValue().isSet()) {
				returned.add(spec);
			}
		}
		return returned;
	}

	public void _setDeclaredGRSpecifications(Vector<GraphicalElementSpecification<?, ?>> someSpecs) {
		for (GraphicalElementSpecification<?, ?> s : someSpecs) {
			_addToDeclaredGRSpecifications(s);
		}
	}

	public void _addToDeclaredGRSpecifications(GraphicalElementSpecification<?, ?> aSpec) {
		GraphicalElementSpecification<?, ?> existingSpec = getGraphicalElementSpecification(aSpec.getFeatureName());
		if (existingSpec == null) {
			logger.warning("Cannot find any GraphicalElementSpecification matching " + aSpec.getFeatureName() + ". Ignoring...");
		} else {
			existingSpec.setValue(aSpec.getValue());
			existingSpec.setReadOnly(aSpec.getReadOnly());
		}
	}

	public void _removeFromDeclaredGRSpecifications(GraphicalElementSpecification<?, ?> aSpec) {
		GraphicalElementSpecification<?, ?> existingSpec = getGraphicalElementSpecification(aSpec.getFeatureName());
		if (existingSpec == null) {
			logger.warning("Cannot find any GraphicalElementSpecification matching " + aSpec.getFeatureName() + ". Ignoring...");
		} else {
			existingSpec.setValue(null);
		}
	}

	public static GraphicalFeature<String, GraphicalRepresentation<?>> LABEL_FEATURE = new GraphicalFeature<String, GraphicalRepresentation<?>>(
			"label", GraphicalRepresentation.Parameters.text, String.class) {
		@Override
		public String retrieveFromGraphicalRepresentation(GraphicalRepresentation<?> gr) {
			return gr.getText();
		}

		@Override
		public void applyToGraphicalRepresentation(GraphicalRepresentation<?> gr, String value) {
			gr.setText(value);
		}
	};

	public static GraphicalFeature<Boolean, GraphicalRepresentation<?>> VISIBLE_FEATURE = new GraphicalFeature<Boolean, GraphicalRepresentation<?>>(
			"visible", GraphicalRepresentation.Parameters.isVisible, Boolean.class) {
		@Override
		public Boolean retrieveFromGraphicalRepresentation(GraphicalRepresentation<?> gr) {
			return gr.getIsVisible();
		}

		@Override
		public void applyToGraphicalRepresentation(GraphicalRepresentation<?> gr, Boolean value) {
			gr.setIsVisible(value);
		}
	};

	public static GraphicalFeature<?, ?>[] AVAILABLE_FEATURES = { LABEL_FEATURE, VISIBLE_FEATURE };

}