001: /*
002: * The contents of this file are subject to the terms of the Common Development
003: * and Distribution License (the License). You may not use this file except in
004: * compliance with the License.
005: *
006: * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
007: * or http://www.netbeans.org/cddl.txt.
008: *
009: * When distributing Covered Code, include this CDDL Header Notice in each file
010: * and include the License file at http://www.netbeans.org/cddl.txt.
011: * If applicable, add the following below the CDDL Header, with the fields
012: * enclosed by brackets [] replaced by your own identifying information:
013: * "Portions Copyrighted [year] [name of copyright owner]"
014: *
015: * The Original Software is NetBeans. The Initial Developer of the Original
016: * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
017: * Microsystems, Inc. All Rights Reserved.
018: */
019:
020: package org.netbeans.modules.xslt.mapper.methoid;
021:
022: import java.util.Iterator;
023: import org.netbeans.modules.soa.mapper.common.IMapperGroupNode;
024: import org.netbeans.modules.soa.mapper.common.IMapperLink;
025: import org.netbeans.modules.soa.mapper.common.IMapperNode;
026: import org.netbeans.modules.soa.mapper.common.basicmapper.literal.ILiteralUpdater;
027: import org.netbeans.modules.soa.mapper.common.basicmapper.literal.ILiteralUpdater.LiteralSubTypeInfo;
028: import org.netbeans.modules.soa.mapper.common.basicmapper.methoid.IFieldNode;
029: import org.netbeans.modules.soa.mapper.common.basicmapper.methoid.IMethoid;
030: import org.netbeans.modules.soa.mapper.common.basicmapper.methoid.IMethoidNode;
031: import org.openide.nodes.Node;
032:
033: /**
034: * Handles creation of literal editors for the BPEL editor as well
035: * as what to do when the resulting editor value is applied.
036: * Whenever support for a new literal type is added, an editor as well
037: * as an updater must be created to handle it. Editors are the UI
038: * for the visual mapper editor. They allow users to enter a new
039: * literal value or modify an existing one. Updaters are responsible
040: * for changing the model expression once the user has finished
041: * editing the value.
042: *
043: * @author Josh Sandusky
044: */
045: public abstract class AbstractLiteralUpdater implements ILiteralUpdater {
046:
047: protected XPathNodeExpressionUpdater mProcessor;
048:
049: public AbstractLiteralUpdater() {
050: }
051:
052: public boolean hasEditor() {
053: return true;
054: }
055:
056: // TODO reimplement
057: // protected void applyLiteral(IFieldNode fieldNode,
058: // String newValue,
059: // XPathLiteralNode literalNode) {
060: // updateModelLiteral(
061: // fieldNode,
062: // literalNode,
063: // false);
064: // fieldNode.setLiteralName(newValue);
065: // updateToolTip(fieldNode, newValue);
066: // if (mProcessor != null) {
067: // mProcessor.updateNodeExpression(fieldNode);
068: // }
069: // }
070:
071: public void setXPathProcessor(XPathNodeExpressionUpdater processor) {
072: mProcessor = processor;
073: }
074:
075: protected void updateToolTip(IFieldNode fieldNode, String newValue) {
076: IMethoidNode methoidNode = (IMethoidNode) fieldNode
077: .getGroupNode();
078: IMethoid methoid = (IMethoid) methoidNode.getMethoidObject();
079: if (methoid.isLiteral()) {
080: fieldNode.setToolTipText(newValue);
081: }
082: }
083:
084: public void literalUnset(IFieldNode fieldNode) {
085: // TODO reimplement
086: // updateModelLiteral(
087: // fieldNode,
088: // (XPathLiteralNode) fieldNode.getNodeObject(),
089: // true);
090: fieldNode.setLiteralName(null);
091: if (mProcessor != null) {
092: mProcessor.updateNodeExpression(fieldNode);
093: }
094: }
095:
096: public String getLiteralDisplayText(String literalText) {
097: return literalText;
098: }
099:
100: public LiteralSubTypeInfo getLiteralSubType(String freeTextValue) {
101: // default case is no special sub-type information
102: return null;
103: }
104:
105: // TODO reimplement
106: // private void updateModelLiteral(IFieldNode fieldNode,
107: // XPathLiteralNode literalNode,
108: // boolean isRemove) {
109: // boolean linksNeedRemoving = false;
110: // IMapperGroupNode groupNode = fieldNode.getGroupNode();
111: // Node groupNodeObject = (Node) groupNode.getNodeObject();
112: // if (groupNodeObject instanceof XPathOperatorNode) {
113: // XPathOperatorNode operatorNode = (XPathOperatorNode) groupNodeObject;
114: // int fieldIndex = MapperUtil.findFieldIndex(groupNode, fieldNode);
115: // if (isRemove) {
116: // if (literalNode != null) {
117: // fieldNode.setNodeObject(null);
118: // operatorNode.removeInput(literalNode);
119: // }
120: // } else {
121: // linksNeedRemoving = true;
122: // fieldNode.setNodeObject(literalNode);
123: // operatorNode.addInput(fieldIndex, literalNode);
124: // }
125: // } else if (groupNodeObject instanceof XPathLiteralNode) {
126: // if (isRemove) {
127: // groupNode.setNodeObject(null);
128: // } else {
129: // groupNode.setNodeObject(literalNode);
130: // }
131: // }
132: //
133: // if (linksNeedRemoving) {
134: // // Now for each link connected to the field node, we remove the
135: // // link's starting node's output.
136: // for (Iterator iter=fieldNode.getLinks().iterator(); iter.hasNext();) {
137: // IMapperLink link = (IMapperLink) iter.next();
138: // IMapperNode startNode = link.getStartNode();
139: // Node modelNode = MapperUtil.getMapperNodeObject(startNode);
140: // if (modelNode instanceof CanvasNode) {
141: // CanvasNode modelCanvasNode = (CanvasNode) modelNode;
142: // modelCanvasNode.removeOutput(groupNodeObject);
143: // }
144: // }
145: // }
146: // }
147:
148: public interface XPathNodeExpressionUpdater {
149: public void updateNodeExpression(IFieldNode sourceNode);
150: }
151: }
|