KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > netbeans > modules > xml > refactoring > ui > j > ui > RefactoringPanelContainer


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 package org.netbeans.modules.xml.refactoring.ui.j.ui;
20
21 import java.awt.BorderLayout JavaDoc;
22 import java.awt.Image JavaDoc;
23 import java.awt.event.MouseEvent JavaDoc;
24 import java.beans.PropertyChangeEvent JavaDoc;
25 import java.beans.PropertyChangeListener JavaDoc;
26 import javax.swing.ActionMap JavaDoc;
27 import javax.swing.JLabel JavaDoc;
28 import javax.swing.JPanel JavaDoc;
29 import javax.swing.JPopupMenu JavaDoc;
30 import org.openide.awt.MouseUtils;
31 import org.openide.nodes.AbstractNode;
32 import org.openide.nodes.Children;
33 import org.openide.nodes.Node;
34 import org.openide.util.HelpCtx;
35 import org.openide.util.Lookup;
36 import org.openide.util.Utilities;
37 import org.openide.util.lookup.Lookups;
38 import org.openide.util.lookup.ProxyLookup;
39 import org.openide.windows.TopComponent;
40 import org.openide.windows.WindowManager;
41 import java.awt.Component JavaDoc;
42 import java.awt.event.ActionEvent JavaDoc;
43 import javax.swing.AbstractAction JavaDoc;
44 import javax.swing.JTabbedPane JavaDoc;
45 //import org.openide.awt.JPopupMenuPlus;
46
import org.openide.util.NbBundle;
47
48 /**
49  *
50  * @author Jan Becicka
51  * @author Jeri Lockhart
52  */

53 public class RefactoringPanelContainer extends TopComponent
54         implements PropertyChangeListener JavaDoc {
55     public static final long serialVersionUID = 1L;
56     
57     private static RefactoringPanelContainer usages = null;
58     private static RefactoringPanelContainer refactorings = null;
59     private transient boolean isVisible = false;
60     private JPopupMenu JavaDoc pop;
61     /** Popup menu listener */
62     private PopupListener listener;
63     private CloseListener closeL;
64     private boolean isRefactoring;
65     private static Image JavaDoc REFACTORING_BADGE = Utilities.loadImage(
66             "org/netbeans/modules/refactoring/resources/"+
67             "refactoringpreview.png" ); // NOI18N
68
private static Image JavaDoc USAGES_BADGE = Utilities.loadImage(
69             "org/netbeans/modules/refactoring/resources/"+
70             "findusages.png" ); // NOI18N
71
private static final String JavaDoc XML_FIND_USAGES = "xml-find-usages"; // NOI18N
72
private static final String JavaDoc XML_REFACTORING_PREVIEW =
73             "xml-refactoring-preview"; // NOI18N
74
// private transient InstanceContent selectedNode;
75
// public static final String SCHEMA_COMPONENT_SELECTION =
76
// "schema-component-selection";
77
public static final String JavaDoc PROP_SCHEMA_COMPONENT_CHANGED =
78             "prop-schema-component-changed";
79     public static final String JavaDoc PROP_REQUEST_HIGHLIGHT_IN_SCHEMA_VIEW =
80             "prop-request-highlight-in-schema-view";
81     
82     
83     private RefactoringPanelContainer() {
84         this("", false);
85     }
86     /** Creates new form RefactoringPanelContainer */
87     private RefactoringPanelContainer(String JavaDoc name, boolean isRefactoring) {
88         setName(name);
89         setToolTipText(name);
90         setFocusable(true);
91         setLayout(new java.awt.BorderLayout JavaDoc());
92         getAccessibleContext().setAccessibleDescription(
93                 NbBundle.getMessage(RefactoringPanelContainer.class,
94                 "ACSD_usagesPanel")
95                 );
96         pop = new JPopupMenu JavaDoc();
97         pop.add(new Close());
98         pop.add(new CloseAll());
99         pop.add(new CloseAllButCurrent());
100         listener = new PopupListener();
101         closeL = new CloseListener();
102         this.isRefactoring = isRefactoring;
103         setFocusCycleRoot(true);
104         JLabel JavaDoc label = new JLabel JavaDoc(NbBundle.getMessage(
105                 RefactoringPanelContainer.class, "LBL_NoUsages"));
106         label.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
107         this.add(label, BorderLayout.CENTER);
108 // selectedNode = new InstanceContent();
109
initActions();
110     }
111     
112 // public Lookup getLookup() {
113
// return lookup;
114
// }
115

116     
117     
118     void addPanel(JPanel JavaDoc panel) {
119         RefactoringPanel.checkEventThread();
120         if (panel == null){
121             return;
122         }
123         panel.addPropertyChangeListener(
124                 RefactoringPanel.NODE_SELECTION_CHANGE,
125                 this);
126         if (getComponentCount() == 0) {
127             add(panel, BorderLayout.CENTER);
128         } else {
129             Component comp = getComponent(0);
130             if (comp instanceof JTabbedPane JavaDoc) {
131                 ((JTabbedPane JavaDoc) comp).addTab(panel.getName() + " ",
132                         null, panel, panel.getToolTipText()); //NOI18N
133
((JTabbedPane JavaDoc) comp).setSelectedComponent(panel);
134                 comp.validate();
135             } else if (comp instanceof JLabel JavaDoc) {
136                 remove(comp);
137                 add(panel, BorderLayout.CENTER);
138             } else {
139                 remove(comp);
140                 JTabbedPane JavaDoc pane = new CloseButtonTabbedPane();
141                 pane.addMouseListener(listener);
142                 pane.addPropertyChangeListener(closeL);
143                 add(pane, BorderLayout.CENTER);
144                 pane.addTab(comp.getName() + " ", null, comp,
145                         ((JPanel JavaDoc) comp).getToolTipText()); //NOI18N
146
pane.addTab(panel.getName() + " ", null, panel,
147                         panel.getToolTipText()); //NOI18N
148
pane.setSelectedComponent(panel);
149                 pane.validate();
150             }
151         }
152         if (!isVisible) {
153             isVisible = true;
154             open();
155         }
156         validate();
157         requestActive();
158     }
159     
160     protected void componentActivated() {
161         super.componentActivated();
162         JPanel JavaDoc panel = getCurrentPanel();
163         if (panel!=null)
164             panel.requestFocus();
165     }
166     
167     void removePanel(JPanel JavaDoc panel) {
168 // HighlightManager hm = HighlightManager.getDefault();
169
// Lookup hmLookup = Lookups.singleton(hm);
170
// HighlightProvider.hideResults(hmLookup);
171
RefactoringPanel.checkEventThread();
172         Component comp = getComponentCount() > 0 ? getComponent(0) : null;
173         if (comp instanceof JTabbedPane JavaDoc) {
174             JTabbedPane JavaDoc tabs = (JTabbedPane JavaDoc) comp;
175             if (panel == null) {
176                 panel = (JPanel JavaDoc) tabs.getSelectedComponent();
177             }
178             tabs.remove(panel);
179             if (tabs.getComponentCount() == 1) {
180                 Component c = tabs.getComponent(0);
181                 tabs.removeMouseListener(listener);
182                 tabs.removePropertyChangeListener(closeL);
183                 remove(tabs);
184                 add(c, BorderLayout.CENTER);
185             }
186         } else {
187             if(panel==null || panel==comp) {
188                 if (comp != null)
189                     remove(comp);
190                 isVisible = false;
191                 close();
192             }
193         }
194         validate();
195     }
196     
197     void closeAllButCurrent() {
198         Component comp = getComponent(0);
199         if (comp instanceof JTabbedPane JavaDoc) {
200             JTabbedPane JavaDoc tabs = (JTabbedPane JavaDoc) comp;
201             Component current = tabs.getSelectedComponent();
202             Component[] c = tabs.getComponents();
203             for (int i = 0; i< c.length; i++) {
204                 if (c[i]!=current) {
205                     ((RefactoringPanel) c[i]).close();
206                 }
207             }
208         }
209     }
210     
211     public static synchronized RefactoringPanelContainer getUsagesComponent() {
212         if ( usages == null ) {
213             usages =
214                     (RefactoringPanelContainer)
215                     WindowManager.getDefault().findTopComponent(
216                     XML_FIND_USAGES );
217         }
218         return usages;
219     }
220     
221     public static synchronized RefactoringPanelContainer
222             getRefactoringComponent() {
223         if (refactorings == null) {
224             refactorings = (RefactoringPanelContainer)
225             WindowManager.getDefault().findTopComponent(
226                     XML_REFACTORING_PREVIEW );
227         }
228         return refactorings;
229     }
230     
231     public static synchronized RefactoringPanelContainer
232             createRefactoringComponent() {
233         if (refactorings == null)
234             refactorings = new RefactoringPanelContainer(
235                     NbBundle.getMessage(
236                     RefactoringPanelContainer.class, "LBL_Refactoring"), true);
237         return refactorings;
238     }
239     
240     public static synchronized RefactoringPanelContainer
241             createUsagesComponent() {
242         if (usages == null)
243             usages = new RefactoringPanelContainer(
244                     NbBundle.getMessage(RefactoringPanelContainer.class,
245                     "LBL_Usages"), false);
246         return usages;
247     }
248     
249     protected void componentClosed() {
250         isVisible = false;
251         if (getComponentCount() == 0) {
252             return ;
253         }
254         Component comp = getComponent(0);
255         if (comp instanceof JTabbedPane JavaDoc) {
256             JTabbedPane JavaDoc pane = (JTabbedPane JavaDoc) comp;
257             Component[] c = pane.getComponents();
258             for (int i = 0; i< c.length; i++) {
259                 ((RefactoringPanel) c[i]).close();
260             }
261         } else if (comp instanceof RefactoringPanel) {
262             ((RefactoringPanel) comp).close();
263         }
264     }
265     
266     protected String JavaDoc preferredID() {
267         return "RefactoringPanel"; // NOI18N
268
}
269     
270     public int getPersistenceType() {
271         return PERSISTENCE_ALWAYS;
272     }
273     
274     private void initActions() {
275         ActionMap JavaDoc map = getActionMap();
276         
277         map.put("jumpNext", new PrevNextAction(false)); // NOI18N
278
map.put("jumpPrev", new PrevNextAction(true)); // NOI18N
279
}
280     
281     private RefactoringPanel getCurrentPanel() {
282         if (getComponentCount() > 0) {
283             Component comp = getComponent(0);
284             if (comp instanceof JTabbedPane JavaDoc) {
285                 JTabbedPane JavaDoc tabs = (JTabbedPane JavaDoc) comp;
286                 return (RefactoringPanel) tabs.getSelectedComponent();
287             } else {
288                 if (comp instanceof RefactoringPanel)
289                     return (RefactoringPanel) comp;
290             }
291         }
292         return null;
293     }
294     
295     private final class PrevNextAction extends javax.swing.AbstractAction JavaDoc {
296         public static final long serialVersionUID = 1L;
297         private boolean prev;
298         
299         public PrevNextAction(boolean prev) {
300             this.prev = prev;
301         }
302         
303         public void actionPerformed(java.awt.event.ActionEvent JavaDoc actionEvent) {
304             RefactoringPanel panel = getCurrentPanel();
305             if (panel != null) {
306                 if (prev) {
307                     panel.selectPrevUsage();
308                 } else {
309                     panel.selectNextUsage();
310                 }
311             }
312         }
313     }
314     
315     
316     private class CloseListener implements PropertyChangeListener JavaDoc {
317         
318         public void propertyChange(java.beans.PropertyChangeEvent JavaDoc evt) {
319             if (CloseButtonTabbedPane.PROP_CLOSE.equals(
320                     evt.getPropertyName())) {
321                 removePanel((JPanel JavaDoc) evt.getNewValue());
322             }
323         }
324         
325     }
326     /**
327      * Class to showing popup menu
328      */

329     private class PopupListener extends MouseUtils.PopupMouseAdapter {
330         
331         /**
332          * Called when the sequence of mouse events should lead to
333          * actual showing popup menu
334          */

335         protected void showPopup(MouseEvent JavaDoc e) {
336             pop.show(RefactoringPanelContainer.this, e.getX(), e.getY());
337         }
338     } // end of PopupListener
339

340     private class Close extends AbstractAction JavaDoc {
341         public static final long serialVersionUID = 1L;
342         
343         public Close() {
344             super(NbBundle.getMessage(RefactoringPanelContainer.class,
345                     "LBL_CloseWindow"));
346         }
347         
348         public void actionPerformed(ActionEvent JavaDoc e) {
349             removePanel(null);
350         }
351     }
352     
353     private final class CloseAll extends AbstractAction JavaDoc {
354         public static final long serialVersionUID = 1L;
355         
356         public CloseAll() {
357             super(NbBundle.getMessage(RefactoringPanelContainer.class,
358                     "LBL_CloseAll"));
359         }
360         
361         public void actionPerformed(ActionEvent JavaDoc e) {
362             close();
363         }
364     }
365     
366     private class CloseAllButCurrent extends AbstractAction JavaDoc {
367         public static final long serialVersionUID = 1L;
368         
369         public CloseAllButCurrent() {
370             super(NbBundle.getMessage(RefactoringPanelContainer.class,
371                     "LBL_CloseAllButCurrent"));
372         }
373         
374         public void actionPerformed(ActionEvent JavaDoc e) {
375             closeAllButCurrent();
376         }
377     }
378     
379     public HelpCtx getHelpCtx() {
380         String JavaDoc title = getName();
381         if(title.equalsIgnoreCase(NbBundle.getMessage(RefactoringPanelContainer.class, "LBL_Usages")))
382             return new HelpCtx(RefactoringPanelContainer.class.getName()+".find-usages");//NOI18N
383
else
384             return new HelpCtx(RefactoringPanelContainer.class.getName()+".refactoring-preview");//NOI18N
385
}
386     
387     public java.awt.Image JavaDoc getIcon() {
388         if (isRefactoring)
389             return REFACTORING_BADGE;
390         else
391             return USAGES_BADGE;
392     }
393     
394     
395     
396     /**
397      * Implement PropertyChangeListener
398      * NODE_SELECTION_CHANGE
399      */

400     public void propertyChange(PropertyChangeEvent JavaDoc evt) {
401         String JavaDoc propName = evt.getPropertyName();
402         if (propName.equals(
403                 RefactoringPanel.NODE_SELECTION_CHANGE)){
404 // selectedNode.set(Arrays.asList(evt.getNewValue()), null);
405
if (evt.getNewValue() != null){
406                 Object JavaDoc newVal = evt.getNewValue();
407                 // The newVal could also be a Project, FileObject, SourceGroup
408

409                 assert newVal != null:
410                     "RefactoringPanel should not fire NODE_SELECTION_CHANGE" +
411                         " with a null new value";
412                 firePropertyChange(PROP_SCHEMA_COMPONENT_CHANGED, null, newVal);
413             }
414         }
415     }
416     
417     
418     
419 }
420
Popular Tags