/*******************************************************************************
* Copyright (c) 2010 SAP AG.
* 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:
* Emil Simeonov - initial API and implementation.
* Dimitar Donchev - initial API and implementation.
* Dimitar Tenev - initial API and implementation.
* Nevena Manova - initial API and implementation.
* Georgi Konstantinov - initial API and implementation.
*******************************************************************************/
package org.eclipse.wst.sse.sieditor.ui.v2.sections.elements;
import org.eclipse.wst.sse.sieditor.model.api.IModelObject;
import org.eclipse.wst.sse.sieditor.model.xsd.api.IElement;
import org.eclipse.wst.sse.sieditor.model.xsd.api.ISimpleType;
import org.eclipse.wst.sse.sieditor.model.xsd.api.IStructureType;
import org.eclipse.wst.sse.sieditor.model.xsd.api.IType;
import org.eclipse.wst.sse.sieditor.ui.v2.UIConstants;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.AttributeStrategy;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.IConstraintsController;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.IDataTypesFormPageController;
import org.eclipse.wst.sse.sieditor.ui.v2.nodes.ITreeNode;
public class ElementNodeDetailsController {
private final IDataTypesFormPageController formPageController;
private IElementStrategy strategy;
private ITreeNode input;
public ElementNodeDetailsController(final IDataTypesFormPageController formPageController) {
this.formPageController = formPageController;
}
public IDataTypesFormPageController getFormPageController() {
return formPageController;
}
public IConstraintsController getConstraintsController() {
return strategy.getConstraintsSectionController();
}
public String getName() {
final String name = strategy.getName();
return name == null ? UIConstants.EMPTY_STRING : name;
}
public void setName(final String name) {
if (!name.equals(getName())) {
strategy.setName(name);
}
}
public boolean isNameEditable() {
return strategy.isNameEditable();
}
public String getNamespace() {
return strategy.getNamespace();
}
public boolean isNamespaceEditable() {
return strategy.isNamespaceEditable();
}
public boolean isNillable() {
return strategy.getNillable();
}
public boolean isNillableEditable() {
return strategy.isNillableEditable();
}
public boolean isNillableVisible() {
return strategy.isNillableApplicable();
}
public void setNillable(final boolean nillable) {
strategy.setNillable(nillable);
}
public boolean isCardinalityEditable() {
return strategy.isCardinalityEditable();
}
public boolean isCardinalityVisible() {
return strategy.isCardinalityApplicable();
}
public CardinalityType getCardinality() {
return strategy.getCardinality();
}
public void setCardinality(final CardinalityType cardinality) {
strategy.setCardinality(cardinality);
}
public IType getType() {
final IType type = strategy.getType();
if (type != null && !type.isAnonymous() && type.getName() == null) {
return strategy.getBaseType();
}
return type;
}
public void setType(final IType type) {
if (getType() != type) {
strategy.setType(type);
// initStrategy();
}
}
public IType getBaseType() {
return strategy.getBaseType();
}
public void setBaseType(final IType baseType) {
if (getBaseType() != baseType) {
strategy.setBaseType(baseType);
// initStrategy();
}
}
public boolean isBaseTypeApplicable() {
return strategy.isBaseTypeApplicable();
}
public boolean isBaseTypeEditable() {
return strategy.isBaseTypeEditable();
}
public boolean isConstraintsSectionApplicable() {
return strategy.isConstraintsSectionApplicable();
}
public boolean isTypeApplicable() {
return strategy.isTypeApplicable();
}
private ElementType getElementType(final IElement element) {
if (!element.isAttribute()) {
final IType type = element.getType();
if (type instanceof IStructureType) {
final IStructureType structureType = (IStructureType) type;
if (structureType.isElement()) {
return ElementType.GLOBAL_ELEMENT_REFERENCE;
// 2: Element refers to a Global Element
} else {
if (structureType.isAnonymous()) {
return ElementType.ANONYMOUS_TYPE;
// 1.2: Element of Complex Anonymous Type
} else {
return ElementType.GLOBAL_TYPE;
// 1.1: Element of Complex Global Type
}
}
} else {
if (type.isAnonymous()) {
return ElementType.ANONYMOUS_TYPE;
// 1.2: Element of Simple Anonymous Type
} else {
return ElementType.GLOBAL_TYPE;
// 1.1: Element of Simple Global Type
}
}
} else {
return ElementType.ATTRIBUTE;
// 3: Attribute (only 'local' supported for now)
}
}
public enum ElementType {
GLOBAL_TYPE, ANONYMOUS_TYPE, GLOBAL_ELEMENT_REFERENCE, ATTRIBUTE, ATTRIBUTE_REFERENCE
}
public static class CardinalityType {
public static final int UNBOUNDED = -1;
public static final CardinalityType ZERO_TO_ONE = new CardinalityType(0, 1);
public static final CardinalityType ONE_TO_ONE = new CardinalityType(1, 1);
public static final CardinalityType ZERO_TO_MANY = new CardinalityType(0, UNBOUNDED);
public static final CardinalityType ONE_TO_MANY = new CardinalityType(1, UNBOUNDED);
public static final CardinalityType[] VALUES = { ZERO_TO_ONE, ONE_TO_ONE, ZERO_TO_MANY, ONE_TO_MANY };
int min;
int max;
String stringValue;
CardinalityType(final int min, final int max) {
this.min = min;
this.max = max;
final StringBuilder buf = new StringBuilder(4);
buf.append(min).append(" .. "); //$NON-NLS-1$
if (max == UNBOUNDED) {
buf.append('*');
} else {
buf.append(max);
}
stringValue = buf.toString();
}
@Override
public String toString() {
return stringValue;
}
public static CardinalityType get(final int min, final int max) {
if (min == 0 && max == 1)
return CardinalityType.ZERO_TO_ONE;
if (min == 1 && max == 1)
return CardinalityType.ONE_TO_ONE;
if (min == 0 && (max == UNBOUNDED))
return CardinalityType.ZERO_TO_MANY;
if (min == 1 && (max == UNBOUNDED))
return CardinalityType.ONE_TO_MANY;
return new CardinalityType(min, max);
}
public static CardinalityType[] values() {
return VALUES;
}
}
public void setInput(final ITreeNode input) {
this.input = input;
initStrategy();
}
public ITreeNode getInput() {
return input;
}
private void initStrategy() {
strategy = calculateStrategy(input);
strategy.setInput(input);
}
protected IElementStrategy calculateStrategy(final ITreeNode treeNode) {
final IModelObject input = treeNode == null ? null : treeNode.getModelObject();
if (input instanceof IElement) {
final ElementType type = getElementType((IElement) input);
switch (type) {
case GLOBAL_TYPE:
return new ElementOfGlobalTypeStrategy(formPageController);
case ANONYMOUS_TYPE:
return new ElementOfAnonymousTypeStrategy(formPageController);
case GLOBAL_ELEMENT_REFERENCE:
return new ElementRefToGlobalElementStrategy(formPageController);
case ATTRIBUTE:
case ATTRIBUTE_REFERENCE:
return new AttributeStrategy(formPageController);
}
} else if (input instanceof IStructureType) {
if (((IStructureType) input).isElement()) {
return new GlobalElementStrategy(formPageController);
}
return new StructureTypeStrategy(formPageController);
} else if (input instanceof ISimpleType) {
return new SimpleTypeStrategy(formPageController);
}
throw new IllegalArgumentException();
}
}