KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > netbeans > modules > xml > wsdl > ui > view > grapheditor > widget > PortTypeWidget


1 /*
2  * The contents of this file are subject to the terms of the Common Development
3  * and Distribution License (the License). You may not use this file except in
4  * compliance with the License.
5  *
6  * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
7  * or http://www.netbeans.org/cddl.txt.
8  *
9  * When distributing Covered Code, include this CDDL Header Notice in each file
10  * and include the License file at http://www.netbeans.org/cddl.txt.
11  * If applicable, add the following below the CDDL Header, with the fields
12  * enclosed by brackets [] replaced by your own identifying information:
13  * "Portions Copyrighted [year] [name of copyright owner]"
14  *
15  * The Original Software is NetBeans. The Initial Developer of the Original
16  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
17  * Microsystems, Inc. All Rights Reserved.
18  */

19
20 /*
21  * PortTypeColumnWidget.java
22  *
23  * Created on November 5, 2006, 10:42 PM
24  *
25  * To change this template, choose Tools | Template Manager
26  * and open the template in the editor.
27  */

28
29 package org.netbeans.modules.xml.wsdl.ui.view.grapheditor.widget;
30
31 import java.awt.BasicStroke JavaDoc;
32 import java.awt.Color JavaDoc;
33 import java.awt.Container JavaDoc;
34 import java.awt.Dimension JavaDoc;
35 import java.awt.Font JavaDoc;
36 import java.awt.Graphics2D JavaDoc;
37 import java.awt.Image JavaDoc;
38 import java.awt.Paint JavaDoc;
39 import java.awt.Point JavaDoc;
40 import java.awt.Rectangle JavaDoc;
41 import java.awt.RenderingHints JavaDoc;
42 import java.awt.Stroke JavaDoc;
43 import java.awt.datatransfer.DataFlavor JavaDoc;
44 import java.awt.datatransfer.Transferable JavaDoc;
45 import java.awt.event.KeyEvent JavaDoc;
46 import java.awt.event.MouseEvent JavaDoc;
47 import java.awt.geom.GeneralPath JavaDoc;
48 import java.awt.geom.Rectangle2D JavaDoc;
49 import java.awt.image.BufferedImage JavaDoc;
50 import java.util.ArrayList JavaDoc;
51 import java.util.EnumSet JavaDoc;
52 import java.util.List JavaDoc;
53 import java.util.Vector JavaDoc;
54
55 import javax.swing.BorderFactory JavaDoc;
56 import javax.swing.ComboBoxModel JavaDoc;
57 import javax.swing.DefaultComboBoxModel JavaDoc;
58 import javax.swing.JComboBox JavaDoc;
59 import javax.swing.JComponent JavaDoc;
60 import javax.swing.UIManager JavaDoc;
61 import javax.swing.border.Border JavaDoc;
62
63 import org.netbeans.api.visual.action.ActionFactory;
64 import org.netbeans.api.visual.action.InplaceEditorProvider;
65 import org.netbeans.api.visual.action.TextFieldInplaceEditor;
66 import org.netbeans.api.visual.action.WidgetAction;
67 import org.netbeans.api.visual.layout.Layout;
68 import org.netbeans.api.visual.layout.LayoutFactory;
69 import org.netbeans.api.visual.model.ObjectState;
70 import org.netbeans.api.visual.widget.LayerWidget;
71 import org.netbeans.api.visual.widget.Scene;
72 import org.netbeans.api.visual.widget.Widget;
73 import org.netbeans.modules.visual.util.GeomUtil;
74 import org.netbeans.modules.xml.refactoring.ui.util.AnalysisUtilities;
75 import org.netbeans.modules.xml.wsdl.model.Definitions;
76 import org.netbeans.modules.xml.wsdl.model.Input;
77 import org.netbeans.modules.xml.wsdl.model.Operation;
78 import org.netbeans.modules.xml.wsdl.model.Output;
79 import org.netbeans.modules.xml.wsdl.model.PortType;
80 import org.netbeans.modules.xml.wsdl.model.WSDLComponentFactory;
81 import org.netbeans.modules.xml.wsdl.model.WSDLModel;
82 import org.netbeans.modules.xml.wsdl.model.extensions.bpel.PartnerLinkType;
83 import org.netbeans.modules.xml.wsdl.model.extensions.bpel.Role;
84 import org.netbeans.modules.xml.wsdl.ui.actions.NameGenerator;
85 import org.netbeans.modules.xml.wsdl.ui.actions.schema.ExtensibilityElementCreatorVisitor;
86 import org.netbeans.modules.xml.wsdl.ui.netbeans.module.Utility;
87 import org.netbeans.modules.xml.wsdl.ui.view.grapheditor.actions.ComboBoxInplaceEditor;
88 import org.netbeans.modules.xml.wsdl.ui.view.grapheditor.actions.ComboBoxInplaceEditorProvider;
89 import org.netbeans.modules.xml.wsdl.ui.view.grapheditor.layout.OneSideJustifiedLayout;
90 import org.netbeans.modules.xml.wsdl.ui.view.treeeditor.PortTypeNode;
91 import org.netbeans.modules.xml.wsdl.ui.wsdl.util.DisplayObject;
92 import org.netbeans.modules.xml.xam.Model;
93 import org.netbeans.modules.xml.xam.dom.NamedComponentReference;
94 import org.netbeans.modules.xml.xam.ui.XAMUtils;
95 import org.openide.nodes.Node;
96 import org.openide.util.Lookup;
97 import org.openide.util.NbBundle;
98
99 /**
100  *
101  * @author radval
102  */

103 public class PortTypeWidget extends AbstractWidget<PortType> implements DnDHandler {
104     
105     private LayerWidget mHotSpotLayer;
106     private CenteredLabelWidget mNameWidget;
107     private Role mRole;
108     private RectangleWidget mHotspot;
109     private PartnerLinkTypeContentWidget mPLTContentWidget;
110     private ButtonWidget showComboBoxBtnWidget;
111     private Widget nameHolderWidget;
112     private Layout mFillLayout = LayoutFactory.createFillLayout();
113     private Layout mHorizontalJustifiedLayout = new OneSideJustifiedLayout(true);
114     private Border JavaDoc greenBorder = BorderFactory.createLineBorder(Color.GREEN);
115     private Border JavaDoc emptyBorder = BorderFactory.createEmptyBorder();
116     
117     private boolean enable = true;
118     private Paint JavaDoc enableColor = null;
119     private Color JavaDoc disableColor = WidgetConstants.DISABLED_GRAY;
120     
121     /**
122      * Creates a new instance of PortTypeWidget.
123      *
124      * @param scene the Scene to contain this widget.
125      * @param portType the WSDL component.
126      * @param lookup the Lookup for this widget.
127      */

128     public PortTypeWidget(Scene scene, PortType portType, Lookup lookup) {
129         super(scene, portType, lookup);
130         mPLTContentWidget = (PartnerLinkTypeContentWidget) getLookup().lookup(PartnerLinkTypeContentWidget.class);
131         mRole = (Role) getLookup().lookup(Role.class);
132         if (mRole != null) {
133             PartnerLinkType plt = (PartnerLinkType) mRole.getParent();
134             boolean rightSided = mRole == plt.getRole1();
135             DirectionCookie dc = new DirectionCookie(rightSided);
136             getLookupContent().add(dc);
137         }
138         
139         init();
140         
141         
142     }
143
144     private void init() {
145         setOpaque(true);
146         setLayout(LayoutFactory.createVerticalLayout());
147         
148         mHotspot = new RectangleWidget(getScene(), 12, 70);
149         mHotspot.setThickness(2);
150         mHotspot.setColor(WidgetConstants.HIT_POINT_BORDER);
151         
152         nameHolderWidget = new Widget(getScene());
153         nameHolderWidget.setBackground(new Color JavaDoc(217, 244, 218));
154         nameHolderWidget.setLayout(mFillLayout);
155         nameHolderWidget.setMinimumSize(new Dimension JavaDoc(225, 25));
156         
157         enable = mRole != null && getWSDLComponent() != null && !isImported();
158         
159         NamedComponentReference<PortType> ptRef = mRole == null ? null : mRole.getPortType();
160         PortType pt;
161         try {
162             pt = ptRef == null ? null : ptRef.get();
163         } catch (IllegalStateException JavaDoc ise) {
164             // Indicates PortType reference is no longer in model.
165
pt = null;
166         }
167         //if port type cannot be found, then it may be the default value added for required attributes.
168
if (ptRef != null && pt == null &&
169                 !ptRef.getRefString().equals(NbBundle.getMessage(ExtensibilityElementCreatorVisitor.class, "REQUIRED_PROPERTY_DEFAULT_VALUE"))) {
170             mNameWidget = new CenteredLabelWidget(getScene(), ptRef.getRefString(),
171                     new Color JavaDoc(217, 244, 218));
172             mNameWidget.setFont(UIManager.getFont("Label.font").deriveFont(Font.ITALIC));
173         } else {
174             String JavaDoc name = getName();
175             Color JavaDoc color = new Color JavaDoc(217, 244, 218);
176             if (mRole == null) {
177                 greenBorder = BorderFactory.createLineBorder(Color.BLACK);
178                 color = WidgetConstants.DISABLED_GRAY;
179             } else {
180                 if (enable) {
181                     greenBorder = BorderFactory.createLineBorder(Color.GREEN);
182                 } else {
183                     greenBorder = BorderFactory.createLineBorder(Color.gray);
184                 }
185             }
186             mNameWidget = new CenteredLabelWidget(getScene(), name, color);
187         }
188
189         mNameWidget.setBorder(greenBorder);
190         
191         
192         showComboBoxBtnWidget = new ButtonWidget(getScene(), IMAGE_EXPAND);
193         showComboBoxBtnWidget.setBackground(new Color JavaDoc(217, 244, 218));
194         showComboBoxBtnWidget.setMinimumSize(new Dimension JavaDoc(25, 25));
195         showComboBoxBtnWidget.getActions().addAction(createInplaceEditorAction(
196                 new ComboBoxInplaceEditorProvider(new ComboBoxInplaceEditor() {
197                     
198                     DisplayObject blankDispObj = new DisplayObject("", (Object JavaDoc) "Reset");
199                     
200                     public void setSelectedItem(Object JavaDoc selectedItem) {
201                         WSDLModel model = mRole.getModel();
202                         try {
203                             if (model.startTransaction()) {
204                                 PortType portType = mRole.getPortType() == null ?
205                                     null : mRole.getPortType().get();
206                                 if (selectedItem instanceof DisplayObject) {
207                                     DisplayObject dispObj = (DisplayObject) selectedItem;
208                                     if (dispObj == blankDispObj) {
209                                         portType = null;
210                                     } else {
211                                         portType = (PortType) dispObj.getValue();
212                                     }
213                                     
214                                 }
215                                 if (portType != null) {
216                                     mRole.setPortType(mRole.createReferenceTo(portType, PortType.class));
217                                 } else {
218                                     mRole.setPortType(null);
219                                 }
220                                 
221                             }
222                         } finally {
223                             model.endTransaction();
224                         }
225                     }
226
227                     public boolean isEnabled(Widget widget) {
228                         return isWritable();
229                     }
230
231                     public Object JavaDoc getSelectedItem() {
232                         if (mRole.getPortType() != null)
233                             return mRole.getPortType().get();
234                         return null;
235                     }
236
237                     public ComboBoxModel JavaDoc getModel() {
238                         Vector JavaDoc<DisplayObject> list = getAllPortTypes(mRole.getModel());
239                         
240                         list.insertElementAt(blankDispObj, 0);
241                         DefaultComboBoxModel JavaDoc model = new DefaultComboBoxModel JavaDoc(list);
242
243                         if (getSelectedItem() != null) {
244                             DisplayObject selectedObject = null;
245                             for (DisplayObject dispObj : list) {
246                                 if (dispObj.getValue().equals(getSelectedItem())) {
247                                     selectedObject = dispObj;
248                                     break;
249                                 }
250                             }
251                             if (selectedObject != null) {
252                                 model.setSelectedItem(selectedObject);
253                             }
254                         }
255                         return model;
256                     }
257
258                     public boolean getEditable() {
259                         return false;
260                     }
261
262                 }, EnumSet.<InplaceEditorProvider.ExpansionDirection>of (InplaceEditorProvider.ExpansionDirection.LEFT,
263                         InplaceEditorProvider.ExpansionDirection.RIGHT)), nameHolderWidget));
264         
265         if (mRole != null) {
266             mNameWidget.getActions().addAction(new WidgetAction.Adapter() {
267                 
268                 @Override JavaDoc
269                 public State mouseClicked(Widget widget, WidgetMouseEvent event) {
270                     if (event.getButton() == MouseEvent.BUTTON1 && event.getClickCount() == 1) {
271                         if (isWritable())
272                             showComboBoxBtnWidget();
273                     }
274                     return super.mouseClicked(widget, event);
275                 }
276                 
277                 @Override JavaDoc
278                 public State focusLost(Widget widget, WidgetFocusEvent event) {
279                     removeComboBoxBtnWidget();
280                     return super.focusLost(widget, event);
281                 }
282                 
283             });
284             
285             mNameWidget.getActions().addAction(ActionFactory.createInplaceEditorAction(new TextFieldInplaceEditor() {
286
287                 public void setText(Widget widget, String JavaDoc text) {
288                     if (text == null || text.trim().length() == 0) return;
289                     if (getWSDLComponent() == null) {
290                         WSDLModel model = getModel();
291                         if (model.startTransaction()) {
292                             try {
293                                 //create new one first time.
294
PortType portType = model.getFactory().createPortType();
295                                 portType.setName(text);
296                                 model.getDefinitions().addPortType(portType);
297                                 mRole.setPortType(mRole.createReferenceTo(portType, PortType.class));
298                             } finally {
299                                 model.endTransaction();
300                             }
301                         }
302                     } else {
303                         // try rename silent and locally
304
AnalysisUtilities.locallyRenameRefactor(getWSDLComponent(), text);
305                     }
306                 }
307
308                 public boolean isEnabled(Widget widget) {
309                     return !isImported() && isWritable();
310                 }
311
312                 public String JavaDoc getText(Widget widget) {
313                     if (getWSDLComponent() != null)
314                         return getWSDLComponent().getName();
315                     return NameGenerator.getInstance().generateUniquePortTypeName(getModel());
316                 }
317
318             }, null));
319         }
320         
321
322         nameHolderWidget.addChild(mNameWidget);
323         addChild(nameHolderWidget);
324         getScene().validate();
325         mHotSpotLayer = new LayerWidget(getScene());
326         addChild(mHotSpotLayer);
327         setMinimumSize(new Dimension JavaDoc(0, 250));
328         //setBorder(BorderFactory.createLineBorder(Color.CYAN));
329
if (getWSDLComponent() != null) {
330             getActions().addAction(((PartnerScene) getScene()).getDnDAction());
331         }
332         
333     }
334
335     public boolean isWritable() {
336         if (mRole != null) {
337             return XAMUtils.isWritable(mRole.getModel());
338         }
339         return false;
340     }
341     
342     private boolean isImported() {
343         if (getWSDLComponent() != null) {
344             return getModel() != getWSDLComponent().getModel();
345         }
346         return false;
347     }
348     private void showComboBoxBtnWidget() {
349         if (showComboBoxBtnWidget.getParentWidget() == null) {
350             nameHolderWidget.setLayout(mHorizontalJustifiedLayout);
351             nameHolderWidget.addChild(showComboBoxBtnWidget);
352             mNameWidget.setBorder(emptyBorder);
353             nameHolderWidget.setBorder(greenBorder);
354             getScene().revalidate();
355         }
356     }
357     
358     private void removeComboBoxBtnWidget() {
359         if (showComboBoxBtnWidget.getParentWidget() != null) {
360             nameHolderWidget.removeChild(showComboBoxBtnWidget);
361             nameHolderWidget.setLayout(mFillLayout);
362             mNameWidget.setBorder(greenBorder);
363             nameHolderWidget.setBorder(emptyBorder);
364             getScene().revalidate();
365         }
366     }
367
368     @Override JavaDoc
369     protected void notifyStateChanged(ObjectState previousState, ObjectState state) {
370         if (!state.isSelected()) {
371             removeComboBoxBtnWidget();
372         }
373         super.notifyStateChanged(previousState, state);
374     }
375     
376     private <C extends JComponent JavaDoc> WidgetAction createInplaceEditorAction (InplaceEditorProvider<JComboBox JavaDoc> provider, Widget widget) {
377         return new SingleSelectInplaceEditorAction(provider, widget);
378     }
379     
380     
381     
382     @Override JavaDoc
383     protected Node getNodeFilter(Node original) {
384         if (isImported()) {
385             return new ReadOnlyWidgetFilterNode(original);
386         }
387         return super.getNodeFilter(original);
388     }
389
390     @Override JavaDoc
391     protected void postDeleteComponent(Model JavaDoc model) {
392         // In addition to removing the component, clear the reference in
393
// the role component (using null will remove the attribute).
394
mRole.setPortType(null);
395     }
396
397     private String JavaDoc getName() {
398         PortType pt = getWSDLComponent();
399         if (mRole == null) {
400             return NbBundle.getMessage(PortTypeWidget.class, "PortTypeWidget_PLACEHOLDER_PORTTYPE_NAME");
401         }
402         if (pt == null) {
403             return NbBundle.getMessage(PortTypeWidget.class, "PortTypeWidget_BLANK_PORTTYPE_MSG");
404         }
405         String JavaDoc ptTNS = pt.getModel().getDefinitions().getTargetNamespace();
406         if (ptTNS != null) {
407             return Utility.getNameAndDropPrefixIfInCurrentModel(ptTNS, pt.getName(), mRole.getModel());
408         }
409         return pt.getName();
410     }
411     
412     /* returning -1 doesnt show the hotspot*/
413     public int getEffectiveOperationCount() {
414         int count = 0;
415         DirectionCookie dc = (DirectionCookie) getLookup().lookup(
416                 DirectionCookie.class);
417         if (dc != null && dc.isLeftSided()) {
418             PartnerLinkType plt = (PartnerLinkType) mRole.getParent();
419             if (plt != null) {
420                 Role role1 = plt.getRole1();
421                 if (role1 != null && role1.getPortType() != null) {
422                     PortType pt = role1.getPortType().get();
423                     if (pt != null) {
424                         count += pt.getOperations().size();
425                     }
426                 }
427             }
428             
429         }
430         if (mRole != null && mRole.getPortType() != null) {
431             PortType pt = mRole.getPortType().get();
432             if (pt != null) {
433                 if (pt.getOperations() != null) {
434                     count += pt.getOperations().size();
435                 }
436             } else {
437                 return -1;
438             }
439         } else {
440             return -1;
441         }
442         return count;
443     }
444     
445     public Point JavaDoc getLastAnchor() {
446         int count = getEffectiveOperationCount();
447        // int oslayerCount = mContext.getContentWidget().getOperationSceneLayer().getChildren().size();
448
/* if (oslayerCount != 1 && oslayerCount > count) {
449             if (!mRightSided) {
450                 count ++;
451             }
452         }*/

453         if (count == 0 || count == -1) {
454             return null;
455         }
456         int height = 67 + 20; //15 = operation name height
457
int y = (height + 25) * count;//25 = gap between operations
458
if (mHotspot.getParentWidget() == null) {
459             return new Point JavaDoc(0, y);
460         }
461         return mHotspot.getParentWidget().convertLocalToScene(new Point JavaDoc(0, y));//we dont need to find x.
462
}
463     
464     public Point JavaDoc getMidPoint() {
465         Rectangle JavaDoc clientArea = getBounds();
466         if (clientArea == null) return new Point JavaDoc();
467         
468         int x = clientArea.x;
469         int y = clientArea.y;
470
471         return new Point JavaDoc(x+clientArea.width/2, y + 70);
472     }
473     
474     public void showHotSpot() {
475         if (mHotSpotLayer.getChildren() != null && mHotSpotLayer.getChildren().size() == 0) {
476             mPLTContentWidget.getOperationSceneLayer().showBlankWidget(getEffectiveOperationCount());
477             mHotSpotLayer.addChild(mHotspot);
478             mHotspot.setPreferredLocation(getHotSpotLocation());
479             getScene().getView().scrollRectToVisible(getScene().getView().getVisibleRect());
480         }
481     }
482     
483     
484     public void clearHotSpot() {
485         if(mHotSpotLayer.getChildren().contains(mHotspot)) {
486             mHotSpotLayer.removeChild(mHotspot);
487             mHotSpotLayer.setPreferredLocation(null);
488             mPLTContentWidget.getOperationSceneLayer().removeBlankWidget();
489        }
490     }
491     
492     
493     private Point JavaDoc getHotSpotLocation() {
494         Point JavaDoc p = getLastAnchor();
495         if(p == null) {
496             Rectangle JavaDoc clientArea = getBounds();
497             int x = clientArea.x;
498             int y = clientArea.y;
499             return new Point JavaDoc((x + getMidPoint().x) - 4, y + mNameWidget.getBounds().height + 10);
500         }
501         
502         p = convertSceneToLocal(p);
503         return new Point JavaDoc(getMidPoint().x - 6, p.y + mNameWidget.getBounds().height + 10);
504         
505     }
506     
507
508     @Override JavaDoc
509     protected Rectangle JavaDoc calculateClientArea() {
510         Rectangle JavaDoc bounds = getBounds();
511         if (bounds == null) return super.calculateClientArea();
512         
513         int y = bounds.y;
514         
515         int newY = y + bounds.height;
516         if (mPLTContentWidget.getBounds() != null) {
517             int tempY = mPLTContentWidget.getBounds().y + mPLTContentWidget.getBounds().height;
518             Point JavaDoc scenePoint = mPLTContentWidget.convertLocalToScene(new Point JavaDoc(0, tempY));
519             newY = convertSceneToLocal(scenePoint).y;
520         }
521         int height = newY - y;
522         Rectangle JavaDoc clientArea = super.calculateClientArea();
523         clientArea.height = height;
524         return clientArea;
525     }
526
527     /**
528      * Paints the label widget.
529      */

530     @Override JavaDoc
531     protected void paintWidget () {
532         Graphics2D JavaDoc gr = getGraphics ();
533         
534         Rectangle JavaDoc clientArea = getBounds();
535
536         int x = clientArea.x;
537         int y = clientArea.y;
538         
539         int newY = y + clientArea.height;
540         if (mPLTContentWidget.getBounds() != null) {
541             int tempY = mPLTContentWidget.getBounds().y + mPLTContentWidget.getBounds().height;
542             Point JavaDoc scenePoint = mPLTContentWidget.convertLocalToScene(new Point JavaDoc(0, tempY));
543             newY = convertSceneToLocal(scenePoint).y;
544         }
545         Stroke JavaDoc oldStroke = gr.getStroke();
546         Color JavaDoc oldColor = gr.getColor();
547         Font JavaDoc font = gr.getFont();
548         
549         BasicStroke JavaDoc dotted = new BasicStroke JavaDoc(1, BasicStroke.CAP_SQUARE,
550                      BasicStroke.JOIN_ROUND, 10.0f, new float[]{5,10,5,10}, 0);
551         
552         
553         
554         if(enable) {
555             if(enableColor != null) {
556                 gr.setPaint(enableColor);
557             }
558             gr.setColor(Color.GRAY);
559         } else {
560             enableColor = gr.getPaint();
561             Rectangle JavaDoc rect = getBounds();
562             Rectangle2D JavaDoc rectShape = new Rectangle2D.Double JavaDoc(rect.x, rect.y, rect.width,
563                     rect.height);
564             gr.setPaint(disableColor);
565             gr.fill(rectShape);
566             gr.setColor(Color.BLACK);
567         }
568         
569         gr.setStroke(dotted);
570         gr.setFont (getFont ());
571         
572         gr.drawLine((x+clientArea.width)/2, y + mNameWidget.getClientArea().height, (x+clientArea.width)/2, newY);
573         
574         gr.setStroke(oldStroke);
575         gr.setColor(oldColor);
576         gr.setFont(font);
577     }
578     
579     private Vector JavaDoc<DisplayObject> getAllPortTypes(WSDLModel model) {
580         Vector JavaDoc<DisplayObject> list = new Vector JavaDoc<DisplayObject>();
581         
582         list.addAll(getAllAvailablePortTypes(model, model));
583         
584         for (WSDLModel imported : Utility.getImportedDocuments(model)) {
585             list.addAll(getAllAvailablePortTypes(model, imported));
586         }
587         
588         return list;
589         
590     }
591     
592     private static List JavaDoc<DisplayObject> getAllAvailablePortTypes(WSDLModel source, WSDLModel document) {
593         ArrayList JavaDoc<DisplayObject> portTypesList = new ArrayList JavaDoc<DisplayObject>();
594
595         Definitions definition = document.getDefinitions();
596         
597         for (PortType portType : definition.getPortTypes()) {
598             String JavaDoc name = portType.getName();
599             String JavaDoc targetNamespace = document.getDefinitions().getTargetNamespace();
600             String JavaDoc prefix = Utility.getNamespacePrefix(targetNamespace, source);
601             if(name != null) {
602                 if(prefix != null) {
603                     String JavaDoc portTypeQNameStr = prefix + ":" + name;
604                     portTypesList.add(new DisplayObject(portTypeQNameStr, portType));
605                 } else {
606                     portTypesList.add(new DisplayObject(name, portType));
607                 }
608             }
609         }
610         
611         return portTypesList;
612     }
613     
614     public void addOperation(String JavaDoc name) {
615         PortType pt = getWSDLComponent();
616         if (pt == null || name == null) {
617             return;
618         }
619         
620         WSDLModel model = getWSDLComponent().getModel();
621         WSDLComponentFactory factory = model.getFactory();
622         try {
623             if (model.startTransaction()) {
624                 Operation operation = null;
625                 if (name.startsWith("RequestReply")) {
626                     operation = factory.createRequestResponseOperation();
627                     operation.setName(NameGenerator.getInstance().
628                             generateUniqueOperationName(pt));
629                     pt.addOperation(operation);
630                     Input in = factory.createInput();
631                     in.setName(NameGenerator.getInstance().
632                             generateUniqueOperationInputName(operation));
633                     operation.setInput(in);
634                     Output out = factory.createOutput();
635                     out.setName(NameGenerator.getInstance().
636                             generateUniqueOperationOutputName(operation));
637                     operation.setOutput(out);
638                 } else if (name.startsWith("OneWay")) {
639                     operation = factory.createOneWayOperation();
640                     operation.setName(NameGenerator.getInstance().
641                             generateUniqueOperationName(pt));
642                     pt.addOperation(operation);
643                     Input in = factory.createInput();
644                     in.setName(NameGenerator.getInstance().
645                             generateUniqueOperationInputName(operation));
646                     operation.setInput(in);
647                 } else if (name.startsWith("Notification")) {
648                     operation = factory.createNotificationOperation();
649                     operation.setName(NameGenerator.getInstance().
650                             generateUniqueOperationName(pt));
651                     pt.addOperation(operation);
652                     Output out = factory.createOutput();
653                     out.setName(NameGenerator.getInstance().
654                             generateUniqueOperationOutputName(operation));
655                     operation.setOutput(out);
656                 } else if (name.startsWith("SolicitResponse")) {
657                     operation = factory.createSolicitResponseOperation();
658                     operation.setName(NameGenerator.getInstance().
659                             generateUniqueOperationName(pt));
660                     pt.addOperation(operation);
661                     Input in = factory.createInput();
662                     in.setName(NameGenerator.getInstance().
663                             generateUniqueOperationInputName(operation));
664                     operation.setInput(in);
665                     Output out = factory.createOutput();
666                     out.setName(NameGenerator.getInstance().
667                             generateUniqueOperationOutputName(operation));
668                     operation.setOutput(out);
669                 }
670             }
671         } finally {
672             model.endTransaction();
673         }
674     }
675   
676
677
678     @Override JavaDoc
679     public void updateContent() {
680         if (!getName().equals(mNameWidget.getLabel())) {
681             mNameWidget.setLabel(getName());
682         }
683     }
684
685     
686     // DnDHandler implementation BEGIN
687

688     public void dragExit() {
689         clearHotSpot();
690         setBorder(BorderFactory.createEmptyBorder());
691     }
692
693     
694     public boolean dragOver(Point JavaDoc scenePoint, WidgetAction.WidgetDropTargetDragEvent event) {
695         Transferable JavaDoc transferable = event.getTransferable();
696         
697         try {
698             if (transferable != null) {
699                 for (DataFlavor JavaDoc flavor : transferable.getTransferDataFlavors()) {
700                     Class JavaDoc repClass = flavor.getRepresentationClass();
701                     if (Node.class.isAssignableFrom(repClass)) {
702                         Node node = Node.class.cast(transferable.getTransferData(flavor));
703                         if (isAssignable(node)) {
704                             if (!isImported()) {
705                                 showHotSpot();
706                                 return true;
707                             }
708                         } else if (node instanceof PortTypeNode) {
709                             setBorder(BorderFactory.createLineBorder(WidgetConstants.HIT_POINT_BORDER, 2));
710                             return true;
711                         }
712                     }
713                 }
714             }
715         } catch (Exception JavaDoc ex) {
716             //do nothing
717
}
718         
719         clearHotSpot();
720         setBorder(BorderFactory.createEmptyBorder());
721         return false;
722     }
723
724     
725     public boolean drop(Point JavaDoc scenePoint, WidgetAction.WidgetDropTargetDropEvent event) {
726         Transferable JavaDoc transferable = event.getTransferable();
727         try {
728             if (transferable != null) {
729                 for (DataFlavor JavaDoc flavor : transferable.getTransferDataFlavors()) {
730                     Class JavaDoc repClass = flavor.getRepresentationClass();
731                     Object JavaDoc data = transferable.getTransferData(flavor);
732                     if (Node.class.isAssignableFrom(repClass)) {
733                         Node node = (Node) data;
734                         if (node instanceof PortTypeNode) {
735                             setBorder(BorderFactory.createEmptyBorder());
736                             setPortTypeToRole((PortTypeNode)node);
737                             return true;
738                         }
739                         //else its for operation.
740
clearHotSpot();
741                         addOperation(node.getName());
742                         return true;
743                     }
744                 }
745             }
746         } catch (Exception JavaDoc ex) {
747             //do nothing
748
}
749         return false;
750     }
751
752     private void setPortTypeToRole(PortTypeNode node) {
753         PortType pt = (PortType) node.getWSDLComponent();
754         if (mRole.getModel().startTransaction()) {
755             try {
756                 mRole.setPortType(mRole.createReferenceTo(pt, PortType.class));
757             } finally {
758                 mRole.getModel().endTransaction();
759             }
760         }
761         
762     }
763
764     public boolean isCollapsed() {
765         return false;
766     }
767
768     public void expandForDragAndDrop() {
769     }
770     
771     
772     private boolean isAssignable(Node node) {
773         if (node.getName().startsWith("Notification") ||
774                 node.getName().startsWith("SolicitResponse") ||
775                 node.getName().startsWith("RequestReply") ||
776                 node.getName().startsWith("OneWay")) {
777             return true;
778         }
779
780         return false;
781     }
782     
783     // DnDHandler implamentation END
784

785     
786     class SingleSelectInplaceEditorAction extends WidgetAction.LockedAdapter implements InplaceEditorProvider.EditorController {
787
788         private InplaceEditorProvider<JComboBox JavaDoc> provider;
789
790         private JComboBox JavaDoc editor = null;
791         private Widget replaceableWidget = null;
792         private Rectangle JavaDoc rectBounds = null;
793
794         /**
795          * The JComponent is drawn with bounds and location of the given widget, though this action may be on a different widget.
796          *
797          * @param provider the provider
798          * @param widget the widget upon which the JComponent will be shown
799          */

800         
801         public SingleSelectInplaceEditorAction (InplaceEditorProvider<JComboBox JavaDoc> provider, Widget widget) {
802             this.provider = provider;
803             this.replaceableWidget = widget;
804         }
805
806         @Override JavaDoc
807         protected boolean isLocked () {
808             return editor != null;
809         }
810
811         @Override JavaDoc
812         public State mouseClicked (Widget widget, WidgetMouseEvent event) {
813             if (event.getButton () == MouseEvent.BUTTON1 && event.getClickCount () == 1) {
814                 if (openEditor (replaceableWidget))
815                     return State.createLocked (widget, this);
816             }
817             return State.REJECTED;
818         }
819
820         @Override JavaDoc
821         public State mousePressed (Widget widget, WidgetMouseEvent event) {
822             if (editor != null)
823                 closeEditor (true);
824             return State.REJECTED;
825         }
826
827         @Override JavaDoc
828         public State mouseReleased (Widget widget, WidgetAction.WidgetMouseEvent event) {
829             if (editor != null)
830                 closeEditor (true);
831             return State.REJECTED;
832         }
833
834         @Override JavaDoc
835         public State keyTyped (Widget widget, WidgetKeyEvent event) {
836             if (event.getKeyChar () == KeyEvent.VK_ENTER)
837                 if (openEditor (replaceableWidget))
838                     return State.createLocked (widget, this);
839             return State.REJECTED;
840         }
841
842         public final boolean isEditorVisible () {
843             return editor != null;
844         }
845
846         public final boolean openEditor (Widget widget) {
847             if (editor != null)
848                 return false;
849
850             Scene scene = widget.getScene ();
851             JComponent JavaDoc component = scene.getView ();
852             if (component == null)
853                 return false;
854
855             editor = provider.createEditorComponent (this, widget);
856             if (editor == null)
857                 return false;
858
859             component.add (editor);
860             provider.notifyOpened (this, widget, editor);
861
862             Rectangle JavaDoc rectangle = widget.getScene ().convertSceneToView (widget.convertLocalToScene (widget.getPreferredBounds ()));
863
864             Point JavaDoc center = GeomUtil.center (rectangle);
865             Dimension JavaDoc size = editor.getMinimumSize ();
866             if (rectangle.width > size.width)
867                 size.width = rectangle.width;
868             if (rectangle.height > size.height)
869                 size.height = rectangle.height;
870             int x = center.x - size.width / 2;
871             int y = center.y - size.height / 2;
872
873             rectangle = new Rectangle JavaDoc (x, y, size.width, size.height);
874             updateRectangleToFitToView (rectangle);
875
876             Rectangle JavaDoc r = provider.getInitialEditorComponentBounds (this, widget, editor, rectangle);
877             this.rectBounds = r != null ? r : rectangle;
878
879             editor.setPreferredSize(new Dimension JavaDoc(size.width, size.height));
880             editor.setLocation(x, y);
881             notifyEditorComponentBoundsChanged ();
882             editor.requestFocus ();
883             editor.showPopup();
884             return true;
885         }
886
887         private void updateRectangleToFitToView (Rectangle JavaDoc rectangle) {
888             JComponent JavaDoc component = replaceableWidget.getScene ().getView ();
889             if (rectangle.x + rectangle.width > component.getWidth ())
890                 rectangle.x = component.getWidth () - rectangle.width;
891             if (rectangle.y + rectangle.height > component.getHeight ())
892                 rectangle.y = component.getHeight () - rectangle.height;
893             if (rectangle.x < 0)
894                 rectangle.x = 0;
895             if (rectangle.y < 0)
896                 rectangle.y = 0;
897         }
898
899         public final void closeEditor (boolean commit) {
900             if (editor == null)
901                 return;
902             Container JavaDoc parent = editor.getParent ();
903             Rectangle JavaDoc bounds = parent != null ? editor.getBounds () : null;
904             provider.notifyClosing (this, replaceableWidget, editor, commit);
905             if (bounds != null) {
906                 parent.remove (editor);
907                 parent.repaint (bounds.x, bounds.y, bounds.width, bounds.height);
908                 parent.requestFocus ();
909             }
910             editor = null;
911             rectBounds = null;
912         }
913
914         public void notifyEditorComponentBoundsChanged () {
915             EnumSet JavaDoc<InplaceEditorProvider.ExpansionDirection> directions = provider.getExpansionDirections (this, replaceableWidget, editor);
916             if (directions == null)
917                 directions = EnumSet.noneOf (InplaceEditorProvider.ExpansionDirection.class);
918             Rectangle JavaDoc rectangle = this.rectBounds;
919             Dimension JavaDoc size = editor.getPreferredSize ();
920             Dimension JavaDoc minimumSize = editor.getMinimumSize ();
921             if (minimumSize != null) {
922                 if (size.width < minimumSize.width)
923                     size.width = minimumSize.width;
924                 if (size.height < minimumSize.height)
925                     size.height = minimumSize.height;
926             }
927
928             int heightDiff = rectangle.height - size.height;
929             int widthDiff = rectangle.width - size.width;
930
931             boolean top = directions.contains (InplaceEditorProvider.ExpansionDirection.TOP);
932             boolean bottom = directions.contains (InplaceEditorProvider.ExpansionDirection.BOTTOM);
933
934             if (top) {
935                 if (bottom) {
936                     rectangle.y += heightDiff / 2;
937                     rectangle.height = size.height;
938                 } else {
939                     rectangle.y += heightDiff;
940                     rectangle.height = size.height;
941                 }
942             } else {
943                 if (bottom) {
944                     rectangle.height = size.height;
945                 } else {
946                 }
947             }
948
949             boolean left = directions.contains (InplaceEditorProvider.ExpansionDirection.LEFT);
950             boolean right = directions.contains (InplaceEditorProvider.ExpansionDirection.RIGHT);
951
952             if (left) {
953                 if (right) {
954                     rectangle.x += widthDiff / 2;
955                     rectangle.width = size.width;
956                 } else {
957                     rectangle.x += widthDiff;
958                     rectangle.width = size.width;
959                 }
960             } else {
961                 if (right) {
962                     rectangle.width = size.width;
963                 } else {
964                 }
965             }
966
967             updateRectangleToFitToView (rectangle);
968
969             editor.setBounds (rectangle);
970             editor.repaint ();
971         }
972
973     }
974     
975     /** The expand button image. */
976     private static final Image JavaDoc IMAGE_EXPAND = new BufferedImage JavaDoc(12, 12,
977             BufferedImage.TYPE_INT_ARGB);
978     
979     static {
980
981         // Create the expand image.
982
Graphics2D JavaDoc g2 = ((BufferedImage JavaDoc) IMAGE_EXPAND).createGraphics();
983         g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
984                 RenderingHints.VALUE_ANTIALIAS_ON);
985         float w = IMAGE_EXPAND.getWidth(null);
986         float h = IMAGE_EXPAND.getHeight(null);
987         float r = Math.min(w, h) * 0.5f * 0.75f;
988         GeneralPath JavaDoc gp = new GeneralPath JavaDoc();
989         float dx = (float) (r * Math.cos(Math.toRadians(-30)));
990         float dy = (float) (r * Math.sin(Math.toRadians(-30)));
991         gp.moveTo(dx, dy);
992         gp.lineTo(0, r);
993         gp.lineTo(-dx, dy);
994         gp.lineTo(dx, dy);
995         gp.closePath();
996         g2.translate(w / 2, h / 2);
997         g2.setPaint(Color.BLACK);
998         g2.fill(gp);
999        
1000    }
1001}
1002
Popular Tags