*** empty log message ***
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / ui / actions / GenerateActionGroup.java
1 /*******************************************************************************
2  * Copyright (c) 2002 International Business Machines Corp. and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v0.5 
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v05.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  ******************************************************************************/
11 package net.sourceforge.phpdt.ui.actions;
12
13 import java.util.ArrayList;
14 import java.util.Iterator;
15 import java.util.List;
16
17 import net.sourceforge.phpdt.internal.ui.actions.ActionMessages;
18 import net.sourceforge.phpdt.internal.ui.actions.AddTaskAction;
19 import net.sourceforge.phpdt.ui.IContextMenuConstants;
20 import net.sourceforge.phpeclipse.phpeditor.PHPEditor;
21
22 import org.eclipse.jface.action.IAction;
23 import org.eclipse.jface.action.IMenuManager;
24 import org.eclipse.jface.action.MenuManager;
25 import org.eclipse.jface.util.Assert;
26 import org.eclipse.jface.viewers.ISelection;
27 import org.eclipse.jface.viewers.ISelectionChangedListener;
28 import org.eclipse.jface.viewers.ISelectionProvider;
29 import org.eclipse.jface.viewers.IStructuredSelection;
30 import org.eclipse.ui.IActionBars;
31 import org.eclipse.ui.IViewPart;
32 import org.eclipse.ui.IWorkbenchActionConstants;
33 import org.eclipse.ui.IWorkbenchSite;
34 import org.eclipse.ui.actions.ActionGroup;
35 import org.eclipse.ui.actions.AddBookmarkAction;
36 import org.eclipse.ui.part.Page;
37 import org.eclipse.ui.texteditor.ConvertLineDelimitersAction;
38 import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds;
39 import org.eclipse.ui.texteditor.IUpdate;
40
41 /**
42  * Action group that adds the source and generate actions to a part's context
43  * menu and installs handlers for the corresponding global menu actions.
44  * 
45  * <p>
46  * This class may be instantiated; it is not intended to be subclassed.
47  * </p>
48  * 
49  * @since 2.0
50  */
51 public class GenerateActionGroup extends ActionGroup {
52   /**
53          * Pop-up menu: id of the source sub menu (value <code>org.eclipse.jdt.ui.source.menu</code>).
54          * 
55          * @since 3.0
56          */
57         public static final String MENU_ID= "net.sourceforge.pheclipse.ui.source.menu"; //$NON-NLS-1$
58         
59   private PHPEditor fEditor;
60 //      private boolean fEditorIsOwner;
61         private IWorkbenchSite fSite;
62         private String fGroupName= IContextMenuConstants.GROUP_SOURCE;
63         private List fRegisteredSelectionListeners;
64         
65 //      private AddImportOnSelectionAction fAddImport;
66 //      private OverrideMethodsAction fOverrideMethods;
67 //      private AddGetterSetterAction fAddGetterSetter;
68 //      private AddUnimplementedConstructorsAction fAddUnimplementedConstructors;
69 //      private AddJavaDocStubAction fAddJavaDocStub;
70         private AddBookmarkAction fAddBookmark;
71         private AddTaskAction fAddTaskAction;
72 //      private ExternalizeStringsAction fExternalizeStrings;
73 //      private FindStringsToExternalizeAction fFindStringsToExternalize;
74 //      private SurroundWithTryCatchAction fSurroundWithTryCatch;
75         
76         // private OrganizeImportsAction fOrganizeImports;
77
78         private ConvertLineDelimitersAction fConvertToWindows;
79         private ConvertLineDelimitersAction fConvertToUNIX;
80         private ConvertLineDelimitersAction fConvertToMac;
81         
82         /**
83          * Note: This constructor is for internal use only. Clients should not call this constructor.
84          */
85         public GenerateActionGroup(PHPEditor editor, String groupName) {
86                 fSite= editor.getSite();
87                 fEditor= editor;
88                 fGroupName= groupName;
89                                 
90                 ISelectionProvider provider= fSite.getSelectionProvider();
91                 ISelection selection= provider.getSelection();
92
93 //              fAddImport= new AddImportOnSelectionAction(editor);
94 //              fAddImport.setActionDefinitionId(IJavaEditorActionDefinitionIds.ADD_IMPORT);
95 //              fAddImport.update();
96 //              editor.setAction("AddImport", fAddImport); //$NON-NLS-1$
97                 
98 //              fOrganizeImports= new OrganizeImportsAction(editor);
99 //              fOrganizeImports.setActionDefinitionId(IJavaEditorActionDefinitionIds.ORGANIZE_IMPORTS);
100 //              fOrganizeImports.editorStateChanged();
101 //              editor.setAction("OrganizeImports", fOrganizeImports); //$NON-NLS-1$
102
103 //              fOverrideMethods= new OverrideMethodsAction(editor);
104 //              fOverrideMethods.setActionDefinitionId(IJavaEditorActionDefinitionIds.OVERRIDE_METHODS);
105 //              fOverrideMethods.editorStateChanged();
106 //              editor.setAction("OverrideMethods", fOverrideMethods); //$NON-NLS-1$
107                 
108 //              fAddGetterSetter= new AddGetterSetterAction(editor);
109 //              fAddGetterSetter.setActionDefinitionId(IJavaEditorActionDefinitionIds.CREATE_GETTER_SETTER);
110 //              fAddGetterSetter.editorStateChanged();
111 //              editor.setAction("AddGetterSetter", fAddGetterSetter); //$NON-NLS-1$
112                 
113 //              fAddUnimplementedConstructors= new AddUnimplementedConstructorsAction(editor);
114 //              fAddUnimplementedConstructors.setActionDefinitionId(IJavaEditorActionDefinitionIds.ADD_UNIMPLEMENTED_CONTRUCTORS);
115 //              fAddUnimplementedConstructors.editorStateChanged();
116 //              editor.setAction("AddUnimplementedConstructors", fAddUnimplementedConstructors); //$NON-NLS-1$          
117                 
118 //              fAddJavaDocStub= new AddJavaDocStubAction(editor);
119 //              fAddJavaDocStub.editorStateChanged();
120 //              
121 //              fSurroundWithTryCatch= new SurroundWithTryCatchAction(editor);
122 //              fSurroundWithTryCatch.setActionDefinitionId(IJavaEditorActionDefinitionIds.SURROUND_WITH_TRY_CATCH);
123 //              fSurroundWithTryCatch.update(selection);
124 //              provider.addSelectionChangedListener(fSurroundWithTryCatch);
125 //              editor.setAction("SurroundWithTryCatch", fSurroundWithTryCatch); //$NON-NLS-1$          
126 //              
127 //              fExternalizeStrings= new ExternalizeStringsAction(editor);
128 //              fExternalizeStrings.setActionDefinitionId(IJavaEditorActionDefinitionIds.EXTERNALIZE_STRINGS);
129 //              fExternalizeStrings.editorStateChanged();
130 //              editor.setAction("ExternalizeStrings", fExternalizeStrings); //$NON-NLS-1$              
131                 
132                 fConvertToWindows= new ConvertLineDelimitersAction(editor, "\r\n"); //$NON-NLS-1$
133                 fConvertToWindows.setActionDefinitionId( ITextEditorActionDefinitionIds .CONVERT_LINE_DELIMITERS_TO_WINDOWS);
134                 editor.setAction("ConvertLineDelimitersToWindows", fConvertToWindows); //$NON-NLS-1$            
135                 
136                 fConvertToUNIX= new ConvertLineDelimitersAction(editor, "\n"); //$NON-NLS-1$
137                 fConvertToUNIX.setActionDefinitionId( ITextEditorActionDefinitionIds .CONVERT_LINE_DELIMITERS_TO_UNIX);
138                 editor.setAction("ConvertLineDelimitersToUNIX", fConvertToUNIX); //$NON-NLS-1$          
139
140                 fConvertToMac= new ConvertLineDelimitersAction(editor, "\r"); //$NON-NLS-1$
141                 fConvertToMac.setActionDefinitionId( ITextEditorActionDefinitionIds .CONVERT_LINE_DELIMITERS_TO_MAC);
142                 editor.setAction("ConvertLineDelimitersToMac", fConvertToMac); //$NON-NLS-1$            
143         }
144         
145         /**
146          * Creates a new <code>GenerateActionGroup</code>. The group 
147          * requires that the selection provided by the page's selection provider 
148          * is of type <code>org.eclipse.jface.viewers.IStructuredSelection</code>.
149          * 
150          * @param page the page that owns this action group
151          */
152         public GenerateActionGroup(Page page) {
153                 this(page.getSite());
154         }
155
156         /**
157          * Creates a new <code>GenerateActionGroup</code>. The group 
158          * requires that the selection provided by the part's selection provider 
159          * is of type <code>org.eclipse.jface.viewers.IStructuredSelection</code>.
160          * 
161          * @param part the view part that owns this action group
162          */
163         public GenerateActionGroup(IViewPart part) {
164                 this(part.getSite());
165         }
166         
167         private GenerateActionGroup(IWorkbenchSite site) {
168                 fSite= site;
169                 ISelectionProvider provider= fSite.getSelectionProvider();
170                 ISelection selection= provider.getSelection();
171                 
172 //              fOverrideMethods= new OverrideMethodsAction(site);
173 //              fAddGetterSetter= new AddGetterSetterAction(site);
174 //              fAddUnimplementedConstructors= new AddUnimplementedConstructorsAction(site);
175 //              fAddJavaDocStub= new AddJavaDocStubAction(site);
176                 fAddBookmark= new AddBookmarkAction(site.getShell());
177                 fAddTaskAction= new AddTaskAction(site);
178 //              fExternalizeStrings= new ExternalizeStringsAction(site);
179 //              fFindStringsToExternalize= new FindStringsToExternalizeAction(site);
180 //              fOrganizeImports= new OrganizeImportsAction(site);
181 //              
182 //              fOverrideMethods.update(selection);
183 //              fAddGetterSetter.update(selection);
184 //              fAddUnimplementedConstructors.update(selection);        
185 //              fAddJavaDocStub.update(selection);
186 //              fExternalizeStrings.update(selection);
187 //              fFindStringsToExternalize.update(selection);
188                 fAddTaskAction.update(selection);
189 //              fOrganizeImports.update(selection);
190                 if (selection instanceof IStructuredSelection) {
191                         IStructuredSelection ss= (IStructuredSelection)selection;
192                         fAddBookmark.selectionChanged(ss);
193                 } else {
194                         fAddBookmark.setEnabled(false);
195                 }
196                 
197 //              registerSelectionListener(provider, fOverrideMethods);
198 //              registerSelectionListener(provider, fAddGetterSetter);
199 //              registerSelectionListener(provider, fAddUnimplementedConstructors);
200 //              registerSelectionListener(provider, fAddJavaDocStub);
201                 registerSelectionListener(provider, fAddBookmark);
202 //              registerSelectionListener(provider, fExternalizeStrings);
203 //              registerSelectionListener(provider, fFindStringsToExternalize);
204 //              registerSelectionListener(provider, fOrganizeImports);
205                 registerSelectionListener(provider, fAddTaskAction);
206         }
207         
208         private void registerSelectionListener(ISelectionProvider provider, ISelectionChangedListener listener) {
209                 if (fRegisteredSelectionListeners == null)
210                         fRegisteredSelectionListeners= new ArrayList(12);
211                 provider.addSelectionChangedListener(listener);
212                 fRegisteredSelectionListeners.add(listener);
213         }
214         
215         /*
216          * The state of the editor owning this action group has changed. 
217          * This method does nothing if the group's owner isn't an
218          * editor.
219          */
220         /**
221          * Note: This method is for internal use only. Clients should not call this method.
222          */
223         public void editorStateChanged() {
224                 Assert.isTrue(isEditorOwner());
225                 
226                 // http://dev.eclipse.org/bugs/show_bug.cgi?id=17709
227                 fConvertToMac.update();
228                 fConvertToUNIX.update();
229                 fConvertToWindows.update();
230         }
231
232         /* (non-Javadoc)
233          * Method declared in ActionGroup
234          */
235         public void fillActionBars(IActionBars actionBar) {
236                 super.fillActionBars(actionBar);
237                 setGlobalActionHandlers(actionBar);
238         }
239         
240         /* (non-Javadoc)
241          * Method declared in ActionGroup
242          */
243 //      public void fillContextMenu(IMenuManager menu) {
244 //              super.fillContextMenu(menu);
245 //              if (fEditorIsOwner) {
246 //                      IMenuManager subMenu= createEditorSubMenu(menu);
247 //                      if (subMenu != null)
248 //                              menu.appendToGroup(fGroupName, subMenu);
249 //              } else {
250 ////                    appendToGroup(menu, fOrganizeImports);
251 ////                    appendToGroup(menu, fOverrideMethods);
252 ////                    appendToGroup(menu, fAddGetterSetter);
253 ////                    appendToGroup(menu, fAddUnimplementedConstructors);
254 ////                    appendToGroup(menu, fAddJavaDocStub);
255 //                      appendToGroup(menu, fAddBookmark);
256 //              }
257 //      }
258         /* (non-Javadoc)
259          * Method declared in ActionGroup
260          */
261 //      public void fillContextMenu(IMenuManager menu) {
262 //              super.fillContextMenu(menu);
263 //              IMenuManager subMenu= null;
264 //              if (isEditorOwner()) {
265 //                      subMenu= fillEditorSubMenu(menu);
266 //              } else {
267 //      //              subMenu= createViewSubMenu(menu);
268 //              }
269 //              if (subMenu != null)
270 //                      menu.appendToGroup(fGroupName, subMenu);
271 //      }
272         public void fillContextMenu(IMenuManager menu) {
273                 super.fillContextMenu(menu);
274                 String shortCut= null; //$NON-NLS-1$
275 //              if (fQuickAccessAction != null) {
276 //                      shortCut= fQuickAccessAction.getShortCutString(); //$NON-NLS-1$
277 //              }               
278                 IMenuManager subMenu= new MenuManager(
279                         ActionMessages.getString("SourceMenu.label") + (shortCut != null ? "\t" + shortCut : ""), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
280                         MENU_ID); 
281                 int added= 0;
282                 if (isEditorOwner()) {
283                         added= fillEditorSubMenu(subMenu);
284                 } 
285 //              else {
286 //                      added= fillViewSubMenu(subMenu);
287 //              }
288                 if (added > 0)
289                         menu.appendToGroup(fGroupName, subMenu);
290         }
291   private int fillEditorSubMenu(IMenuManager source) {
292 //    IMenuManager result= new MenuManager(ActionMessages.getString("SourceMenu.label")); //$NON-NLS-1$
293     int added= 0;
294     added+= addEditorAction(source, "Comment"); //$NON-NLS-1$
295     added+= addEditorAction(source, "Uncomment"); //$NON-NLS-1$
296     added+= addEditorAction(source, "ToggleComment"); //$NON-NLS-1$
297         added+= addEditorAction(source, "AddBlockComment"); //$NON-NLS-1$
298         added+= addEditorAction(source, "RemoveBlockComment"); //$NON-NLS-1$
299         added+= addEditorAction(source, "Format"); //$NON-NLS-1$
300         added+= addEditorAction(source, "Indent"); //$NON-NLS-1$
301 //    result.add(new Separator());
302 //    added+= addAction(result, fOrganizeImports);
303 //    added+= addAction(result, fAddImport);
304 //    result.add(new Separator());
305 //    added+= addAction(result, fOverrideMethods);
306 //    added+= addAction(result, fAddGetterSetter);
307 //    added+= addAction(result, fAddUnimplementedConstructors);
308 //    added+= addAction(result, fAddJavaDocStub);
309 //    added+= addAction(result, fAddBookmark);
310 //    result.add(new Separator());              
311 //    added+= addAction(result, fSurroundWithTryCatch);
312 //    added+= addAction(result, fExternalizeStrings);
313 //    if (added == 0)
314 //      result= null;
315     return added;
316   }
317         /* (non-Javadoc)
318          * Method declared in ActionGroup
319          */
320         public void dispose() {
321                 if (fRegisteredSelectionListeners != null) {
322                         ISelectionProvider provider= fSite.getSelectionProvider();
323                         for (Iterator iter= fRegisteredSelectionListeners.iterator(); iter.hasNext();) {
324                                 ISelectionChangedListener listener= (ISelectionChangedListener) iter.next();
325                                 provider.removeSelectionChangedListener(listener);
326                         }
327                 }
328     fEditor= null;
329                 super.dispose();
330         }
331         
332         private void setGlobalActionHandlers(IActionBars actionBar) {
333 //              actionBar.setGlobalActionHandler(JdtActionConstants.ADD_IMPORT, fAddImport);
334 //              actionBar.setGlobalActionHandler(JdtActionConstants.SURROUND_WITH_TRY_CATCH, fSurroundWithTryCatch);
335 //              actionBar.setGlobalActionHandler(JdtActionConstants.OVERRIDE_METHODS, fOverrideMethods);
336 //              actionBar.setGlobalActionHandler(JdtActionConstants.GENERATE_GETTER_SETTER, fAddGetterSetter);
337 //              actionBar.setGlobalActionHandler(JdtActionConstants.ADD_CONSTRUCTOR_FROM_SUPERCLASS, fAddUnimplementedConstructors);
338 //              actionBar.setGlobalActionHandler(JdtActionConstants.ADD_JAVA_DOC_COMMENT, fAddJavaDocStub);
339 //              actionBar.setGlobalActionHandler(JdtActionConstants.EXTERNALIZE_STRINGS, fExternalizeStrings);
340 //              actionBar.setGlobalActionHandler(JdtActionConstants.FIND_STRINGS_TO_EXTERNALIZE, fFindStringsToExternalize);
341 //              actionBar.setGlobalActionHandler(JdtActionConstants.ORGANIZE_IMPORTS, fOrganizeImports);
342                 actionBar.setGlobalActionHandler(PHPdtActionConstants.CONVERT_LINE_DELIMITERS_TO_WINDOWS, fConvertToWindows);
343                 actionBar.setGlobalActionHandler(PHPdtActionConstants.CONVERT_LINE_DELIMITERS_TO_UNIX, fConvertToUNIX);
344                 actionBar.setGlobalActionHandler(PHPdtActionConstants.CONVERT_LINE_DELIMITERS_TO_MAC, fConvertToMac);
345                 if (!isEditorOwner()) {
346                         // editor provides its own implementation of these actions.
347                         actionBar.setGlobalActionHandler(IWorkbenchActionConstants.BOOKMARK, fAddBookmark);
348                         actionBar.setGlobalActionHandler(IWorkbenchActionConstants.ADD_TASK, fAddTaskAction);
349                 }
350         }
351         
352         private int appendToGroup(IMenuManager menu, IAction action) {
353                 if (action != null && action.isEnabled()) {
354                         menu.appendToGroup(fGroupName, action);
355                         return 1;
356                 }
357                 return 0;
358         }       
359
360         private int addAction(IMenuManager menu, IAction action) {
361                 if (action != null && action.isEnabled()) {
362                         menu.add(action);
363                         return 1;
364                 }
365                 return 0;
366         }       
367         
368   private int addEditorAction(IMenuManager menu, String actionID) {
369     if (fEditor == null)
370       return 0;
371     IAction action= fEditor.getAction(actionID);
372     if (action == null)
373       return 0;
374     if (action instanceof IUpdate)
375       ((IUpdate)action).update();
376     if (action.isEnabled()) {
377       menu.add(action);
378       return 1;
379     }
380     return 0;
381   }
382   
383   private boolean isEditorOwner() {
384     return fEditor != null;
385   }     
386 }