Attachment #37998 for bug #135565

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 135565
Collapse All | Expand All

Lines 11-20 Link Here

(-)ui/org/eclipse/jdt/internal/ui/navigator/JavaNavigatorContentProvider.java (-28 / +86 lines)
11	package org.eclipse.jdt.internal.ui.navigator;	11	package org.eclipse.jdt.internal.ui.navigator;
12		12
13	import java.util.Arrays;	13	import java.util.Arrays;
14	import java.util.HashSet;
15	import java.util.Iterator;	14	import java.util.Iterator;
		15	import java.util.LinkedHashSet;
16	import java.util.Set;	16	import java.util.Set;
17		17
		18	import org.eclipse.core.runtime.CoreException;
		19
		20	import org.eclipse.core.resources.IContainer;
		21	import org.eclipse.core.resources.IProject;
18	import org.eclipse.core.resources.IResource;	22	import org.eclipse.core.resources.IResource;
19	import org.eclipse.core.resources.IWorkspaceRoot;	23	import org.eclipse.core.resources.IWorkspaceRoot;
20		24
Lines 36-41 Link Here
36		40
37	import org.eclipse.jdt.ui.PreferenceConstants;	41	import org.eclipse.jdt.ui.PreferenceConstants;
38		42
		43	import org.eclipse.jdt.internal.ui.JavaPlugin;
		44	import org.eclipse.jdt.internal.ui.model.JavaSynchronizationContentProvider;
39	import org.eclipse.jdt.internal.ui.navigator.IExtensionStateConstants.Values;	45	import org.eclipse.jdt.internal.ui.navigator.IExtensionStateConstants.Values;
40	import org.eclipse.jdt.internal.ui.packageview.PackageExplorerContentProvider;	46	import org.eclipse.jdt.internal.ui.packageview.PackageExplorerContentProvider;
41		47
Lines 55-68 Link Here
55	private IExtensionStateModel fStateModel;	61	private IExtensionStateModel fStateModel;
56		62
57	public void init(ICommonContentExtensionSite commonContentExtensionSite) {	63	public void init(ICommonContentExtensionSite commonContentExtensionSite) {
58	IExtensionStateModel stateModel= commonContentExtensionSite.getExtensionStateModel();	64	IExtensionStateModel stateModel = commonContentExtensionSite
59	IMemento memento= commonContentExtensionSite.getMemento();	65	.getExtensionStateModel();
60		66	IMemento memento = commonContentExtensionSite.getMemento();
61	fStateModel = stateModel;	67
62	// fManager = new WorkingSetModelManager(fStateModel, this);	68	fStateModel = stateModel;
63	// expose the manager for the action provider
64	// fStateModel.setProperty(WorkingSetModelManager.INSTANCE_KEY,
65	// fManager);
66	restoreState(memento);	69	restoreState(memento);
67	fStateModel.addPropertyChangeListener(new IPropertyChangeListener() {	70	fStateModel.addPropertyChangeListener(new IPropertyChangeListener() {
68	public void propertyChange(PropertyChangeEvent event) {	71	public void propertyChange(PropertyChangeEvent event) {
Lines 133-172 Link Here
133		136
134	public PipelinedShapeModification interceptAdd(	137	public PipelinedShapeModification interceptAdd(
135	PipelinedShapeModification addModification) {	138	PipelinedShapeModification addModification) {
136	// TODO Auto-generated method stub	139	convertToJavaElements(addModification);
137	return null;	140	return addModification;
138	}	141	}
139		142
140	public PipelinedShapeModification interceptRemove(	143	public PipelinedShapeModification interceptRemove(
141	PipelinedShapeModification removeModification) {	144	PipelinedShapeModification removeModification) {
142	// TODO Auto-generated method stub	145	convertToJavaElements(removeModification.getChildren());
		146	return removeModification;
		147	}
		148
		149	/**
		150	* Returns the java element associated with the project.
		151	*
		152	* Reused from {@link JavaSynchronizationContentProvider}.
		153	*
		154	* @param project
		155	* the project
		156	* @return the associated java element, or <code>null</code> if the
		157	* project is not a java project
		158	*/
		159	private IJavaElement asJavaProject(final IProject project) {
		160	try {
		161	if (project.getDescription().hasNature(JavaCore.NATURE_ID))
		162	return JavaCore.create(project);
		163	} catch (CoreException exception) {
		164	JavaPlugin.log(exception);
		165	}
143	return null;	166	return null;
144	}	167	}
145		168
146	public boolean interceptRefresh(PipelinedViewerUpdate refreshSynchronization) {	169	/**
147	IJavaElement javaElement;	170	* Converts the shape modification to use Java elements.
148	Set interceptedElements = new HashSet();	171	*
149	for (Iterator iter = refreshSynchronization.getRefreshTargets().iterator(); iter.hasNext();) {	172	*
150	Object element = iter.next();	173	* @param modification
151	if (element instanceof IResource) {	174	* the shape modification to convert
152	if ((javaElement = JavaCore.create((IResource) element)) != null && javaElement.exists()) {	175	*/
153	iter.remove();	176	private boolean convertToJavaElements(
154	interceptedElements.add(javaElement);	177	PipelinedShapeModification modification) {
155	}	178	Object parent = modification.getParent();
		179	if (parent instanceof IContainer) {
		180	IJavaElement element = JavaCore.create((IContainer) parent);
		181	if (element != null && element.exists()) {
		182	// we don't convert the root
		183	if( !(element instanceof IJavaModel))
		184	modification.setParent(element);
		185	return convertToJavaElements(modification.getChildren());
		186
156	}	187	}
157	}	188	}
158	if (interceptedElements.size() > 0) {	189	return false;
159	refreshSynchronization.getRefreshTargets().addAll(	190	}
160	interceptedElements);	191
		192	/**
		193	* Converts the shape modification to use Java elements.
		194	*
		195	*
		196	* @param currentChildren
		197	* The set of current children that would be contributed or refreshed in the viewer.
		198	*/
		199	private boolean convertToJavaElements(Set currentChildren) {
		200
		201	LinkedHashSet convertedChildren = new LinkedHashSet();
		202	IJavaElement newChild;
		203	for (Iterator childrenItr = currentChildren.iterator(); childrenItr
		204	.hasNext();) {
		205	Object child = childrenItr.next();
		206	if (child instanceof IResource)
		207	if ((newChild = JavaCore.create((IResource) child)) != null
		208	&& newChild.exists()) {
		209	childrenItr.remove();
		210	convertedChildren.add(newChild);
		211	}
		212	}
		213	if (!convertedChildren.isEmpty()) {
		214	currentChildren.addAll(convertedChildren);
161	return true;	215	return true;
162	}	216	}
163	return false;	217	return false;
164		218
165	}	219	}
166		220
167	public boolean interceptUpdate(PipelinedViewerUpdate updateSynchronization) {	221	public boolean interceptRefresh(PipelinedViewerUpdate refreshSynchronization) {
168	// TODO Auto-generated method stub	222	return convertToJavaElements(refreshSynchronization.getRefreshTargets());
169	return false;	223
		224	}
		225
		226	public boolean interceptUpdate(PipelinedViewerUpdate updateSynchronization) {
		227	return convertToJavaElements(updateSynchronization.getRefreshTargets());
170	}	228	}
171		229
172	protected void postAdd(final Object parent, final Object element) {	230	protected void postAdd(final Object parent, final Object element) {




/***************************************************************************************************
 * Copyright (c) 2003, 2006 IBM Corporation and others. All rights reserved. This program and the
 * accompanying materials are made available under the terms of the Eclipse Public License v1.0
 * 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: IBM Corporation - initial API and implementation
 **************************************************************************************************/
 *******************************************************************************/
package org.eclipse.jdt.internal.ui.navigator;

import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.actions.ActionContext;
import org.eclipse.ui.navigator.CommonActionProvider;
import org.eclipse.ui.navigator.ICommonActionConstants;
import org.eclipse.ui.navigator.ICommonActionExtensionSite;
import org.eclipse.ui.navigator.ICommonViewerWorkbenchSite;
import org.eclipse.ui.navigator.IExtensionStateModel;

import org.eclipse.jdt.ui.actions.CCPActionGroup;
import org.eclipse.jdt.ui.actions.GenerateActionGroup;
import org.eclipse.jdt.ui.actions.JavaSearchActionGroup;
import org.eclipse.jdt.ui.actions.OpenViewActionGroup;
import org.eclipse.jdt.ui.actions.OpenEditorActionGroup;
import org.eclipse.jdt.ui.actions.RefactorActionGroup;

import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.navigator.IExtensionStateConstants.Values;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.newsourcepage.GenerateBuildPathActionGroup;

public class PackageExplorerActionProvider extends CommonActionProvider {

	private static final int HIERARCHICAL_LAYOUT = 0x1;

	private static final int FLAT_LAYOUT = 0x2;

	private static final String TAG_LAYOUT = "layout"; //$NON-NLS-1$

	private CommonLayoutActionGroup fLayoutActionGroup;

	private boolean fHasFilledViewMenu = false;

	private IExtensionStateModel fStateModel;
	
	private OpenViewActionGroup fOpenViewGroup;
	
	private OpenEditorActionGroup fOpenGroup;

	private CCPActionGroup fCCPGroup;

	private RefactorActionGroup fRefactorGroup;

	private JavaSearchActionGroup fSearchGroup;

	private GenerateBuildPathActionGroup fBuildPathGroup;

	private GenerateActionGroup fGenerateGroup;

	private boolean fInViewPart = false;

	public void fillActionBars(IActionBars actionBars) {
		if (!fHasFilledViewMenu) {
			fLayoutActionGroup.fillActionBars(actionBars);
			fHasFilledViewMenu = true;
		}
		if (fInViewPart) {
			fOpenViewGroup.fillActionBars(actionBars);
			fCCPGroup.fillActionBars(actionBars);
			fBuildPathGroup.fillActionBars(actionBars);
			fGenerateGroup.fillActionBars(actionBars);
			fRefactorGroup.fillActionBars(actionBars);
			fRefactorGroup.retargetFileMenuActions(actionBars);
			fSearchGroup.fillActionBars(actionBars);
			
			if(fOpenAndExpand == null && fOpenGroup.getOpenAction().isEnabled()) // TODO: is not updated!
				actionBars.setGlobalActionHandler(ICommonActionConstants.OPEN, fOpenGroup.getOpenAction());
			else if(fOpenAndExpand.isEnabled())
				actionBars.setGlobalActionHandler(ICommonActionConstants.OPEN, fOpenAndExpand);
		}

	}

	public void fillContextMenu(IMenuManager menu) {

		if (fInViewPart) {
			fOpenViewGroup.fillContextMenu(menu);
			fCCPGroup.fillContextMenu(menu);
			fBuildPathGroup.fillContextMenu(menu);
			fGenerateGroup.fillContextMenu(menu);
			fRefactorGroup.fillContextMenu(menu);
			fSearchGroup.fillContextMenu(menu);
		}
	}

	public void init(ICommonActionExtensionSite site) {

		ICommonViewerWorkbenchSite workbenchSite = null;
		if (site.getViewSite() instanceof ICommonViewerWorkbenchSite)
			workbenchSite = (ICommonViewerWorkbenchSite) site.getViewSite();

		fStateModel = site.getExtensionStateModel();

		fLayoutActionGroup = new CommonLayoutActionGroup(site.getStructuredViewer(), fStateModel);
				.getStructuredViewer(), fStateModel);

		if (workbenchSite != null) {
			if (workbenchSite.getPart() != null && workbenchSite.getPart() instanceof IViewPart) {
					&& workbenchSite.getPart() instanceof IViewPart) {
				IViewPart viewPart = (IViewPart) workbenchSite.getPart();
				
				fOpenViewGroup = new OpenViewActionGroup(viewPart, site.getStructuredViewer(), false);
				fCCPGroup = new CCPActionGroup(viewPart);
				fRefactorGroup = new RefactorActionGroup(viewPart);
				fGenerateGroup = new GenerateActionGroup(viewPart);
				fSearchGroup = new JavaSearchActionGroup(viewPart);
				fBuildPathGroup = new GenerateBuildPathActionGroup(viewPart);
				
				if(site.getStructuredViewer() instanceof TreeViewer)
					fOpenAndExpand = new OpenAndExpand(workbenchSite.getSite(), (OpenAction) fOpenGroup.getOpenAction(), (TreeViewer)site.getStructuredViewer());
				fInViewPart = true;
			}

		}

	}

	public void setContext(ActionContext context) {
		super.setContext(context);
		if (fInViewPart) {
			fOpenViewGroup.setContext(context);
			fCCPGroup.setContext(context);
			fRefactorGroup.setContext(context);
			fGenerateGroup.setContext(context);


		// If no memento try an restore from preference store
		if (state == null) {
			IPreferenceStore store = JavaPlugin.getDefault().getPreferenceStore();
					.getPreferenceStore();
			state = new Integer(store.getInt(TAG_LAYOUT));
		}


		else if (state.intValue() == HIERARCHICAL_LAYOUT)
			isCurrentLayoutFlat = false;

		fStateModel.setBooleanProperty(Values.IS_LAYOUT_FLAT, isCurrentLayoutFlat);
				isCurrentLayoutFlat);
		fLayoutActionGroup.setFlatLayout(isCurrentLayoutFlat);
	}

	public void saveState(IMemento aMemento) {
		super.saveState(aMemento);
		IPreferenceStore store = JavaPlugin.getDefault().getPreferenceStore();
		if (fStateModel.getBooleanProperty(Values.IS_LAYOUT_FLAT))
			store.setValue(TAG_LAYOUT, FLAT_LAYOUT);
		else
			store.setValue(TAG_LAYOUT, HIERARCHICAL_LAYOUT);

	}

}




public class OpenViewActionGroup extends ActionGroup {

    private boolean fEditorIsOwner;
    private final boolean fShowProperties;
	private boolean fIsTypeHiararchyViewerOwner;
    private boolean fIsCallHiararchyViewerOwner;
    

	 * 
	 * @param page the page that owns this action group
	 */
	public OpenViewActionGroup(Page page) { 
		this(page.getSite(), null);
	}
	
	/**

	 * @since 3.2
	 */
	public OpenViewActionGroup(Page page, ISelectionProvider selectionProvider) {
		fShowProperties = true;
		createSiteActions(page.getSite(), selectionProvider);
	}
	

	 * @since 3.2
	 */
	public OpenViewActionGroup(IViewPart part, ISelectionProvider selectionProvider) {
		this(part, selectionProvider, true);
	}
	
	
	/**
	 * Creates a new <code>OpenActionGroup</code>. The group requires
	 * that the selection provided by the given selection provider is of type
	 * {@link IStructuredSelection}.
	 * 
	 * <p>
	 * This constructor is for internal use only. Clients may not call this constructor.
	 * </p>
	 * 
	 * @param part the view part that owns this action group
	 * @param selectionProvider the selection provider used instead of the
	 *  page selection provider.
	 * @param showProperties True indicates that the properties dialog action should be shown
	 *  
	 * @since 3.2
	 */
	public OpenViewActionGroup(IViewPart part, ISelectionProvider selectionProvider, boolean showProperties) {
		fShowProperties = showProperties;
		createSiteActions(part.getSite(), selectionProvider);
		// we do a name check here to avoid class loading. 
		String partName= part.getClass().getName();

	 * @since 3.2
	 */
	public OpenViewActionGroup(IWorkbenchSite site, ISelectionProvider selectionProvider) {
		fShowProperties = true;
		createSiteActions(site, selectionProvider);
	}
	

	 */
	public OpenViewActionGroup(JavaEditor part) {
		fEditorIsOwner= true;
		fShowProperties = true;

		fOpenSuperImplementation= new OpenSuperImplementationAction(part);
		fOpenSuperImplementation.setActionDefinitionId(IJavaEditorActionDefinitionIds.OPEN_SUPER_IMPLEMENTATION);


        ISelectionProvider provider= specialProvider != null ? specialProvider : site.getSelectionProvider();
        
        if(fShowProperties) {
	        fOpenPropertiesDialog= new PropertyDialogAction(site, provider);
	        fOpenPropertiesDialog.setActionDefinitionId(IWorkbenchActionDefinitionIds.PROPERTIES);
        }
		
        initialize(provider);
	}

		fOpenTypeHierarchy.update(selection);
        fOpenCallHierarchy.update(selection);
		if (!fEditorIsOwner) {
			if(fShowProperties) {
				if (selection instanceof IStructuredSelection) {
					IStructuredSelection ss= (IStructuredSelection)selection;
					fOpenPropertiesDialog.selectionChanged(ss);
				} else {
					fOpenPropertiesDialog.selectionChanged(selection);
				}
			}
			provider.addSelectionChangedListener(fOpenSuperImplementation);
			provider.addSelectionChangedListener(fOpenExternalJavadoc);

            appendToGroup(menu, fOpenCallHierarchy);
		appendToGroup(menu, fOpenSuperImplementation);
		IStructuredSelection selection= getStructuredSelection();
		if (fShowProperties && fOpenPropertiesDialog != null && fOpenPropertiesDialog.isEnabled() && selection != null &&fOpenPropertiesDialog.isApplicableForSelection(selection))
			menu.appendToGroup(IContextMenuConstants.GROUP_PROPERTIES, fOpenPropertiesDialog);
	}


		actionBars.setGlobalActionHandler(JdtActionConstants.OPEN_TYPE_HIERARCHY, fOpenTypeHierarchy);
        actionBars.setGlobalActionHandler(JdtActionConstants.OPEN_CALL_HIERARCHY, fOpenCallHierarchy);
        
        if (!fEditorIsOwner && fShowProperties)
        	actionBars.setGlobalActionHandler(ActionFactory.PROPERTIES.getId(), fOpenPropertiesDialog);		
	}
	




      </navigatorContent>
   </extension>


    <!-- CommonNavigator -->
	
	<extension

	</extension>
	
	<extension
			point="org.eclipse.ui.navigator.navigatorContent">                                                                                                                                                                 type="new"
		<navigatorContent                                                                                                                                                                                                                                  wizardId="org.eclipse.jdt.ui.wizards.JavaProjectWizard"/>	<navigatorContent
				activeByDefault="true"
				contentProvider="org.eclipse.jdt.internal.ui.navigator.JavaNavigatorContentProvider"
				icon="$nl$/icons/full/obj16/java_model.gif"

			</possibleChildren>
			<actionProvider
					class="org.eclipse.jdt.internal.ui.navigator.PackageExplorerActionProvider"
					overrides="org.eclipse.ui.navigator.resources.actions.RefactorActions"> 
				<enablement>
				</enablement>
			</actionProvider>
			<override
					policy="InvokeAlwaysRegardlessOfSuppressedExt"

			<commonSorter
					class="org.eclipse.jdt.ui.JavaElementSorter"
					id="org.eclipse.jdt.ui.javaElementSorter"/>
		   <actionProvider
		         class="org.eclipse.jdt.internal.ui.navigator.PackageExplorerOpenActionProvider"
		         id="org.eclipse.jdt.internal.ui.navigator.PackageExplorerOpenActionProvider"
		         overrides="org.eclipse.ui.navigator.resources.OpenActions"> 
		   </actionProvider> 
		</navigatorContent>
		  <commonWizard
		        type="new"
		        wizardId="org.eclipse.jdt.ui.wizards.NewPackageCreationWizard">
		     <enablement>
		        <or>
		           <instanceof value="org.eclipse.jdt.core.IPackageFragment"/>
		           <instanceof value="org.eclipse.jdt.core.IPackageFragmentRoot"/>
		           <instanceof value="org.eclipse.jdt.core.ICompilationUnit"/>
		           <adapt type="org.eclipse.core.resources.IProject">
		              <test
		                    property="org.eclipse.core.resources.projectNature"
		                    value="org.eclipse.jdt.core.javanature"/>
		           </adapt>
		        </or>
		     </enablement>
		  </commonWizard>
		  <commonWizard
		        type="new"
		        wizardId="org.eclipse.jdt.ui.wizards.NewClassCreationWizard">
		     <enablement>
		        <or>
		           <instanceof value="org.eclipse.jdt.core.IPackageFragment"/>
		           <instanceof value="org.eclipse.jdt.core.IPackageFragmentRoot"/>
		           <instanceof value="org.eclipse.jdt.core.ICompilationUnit"/>
		           <adapt type="org.eclipse.core.resources.IProject">
		              <test
		                    property="org.eclipse.core.resources.projectNature"
		                    value="org.eclipse.jdt.core.javanature"/>
		           </adapt>
		        </or>
		     </enablement>
		  </commonWizard>

   	      <commonWizard
		        type="new"
		        wizardId="org.eclipse.jdt.ui.wizards.NewInterfaceCreationWizard">
		     <enablement>
		        <or>
		           <instanceof value="org.eclipse.jdt.core.IPackageFragment"/>
		           <instanceof value="org.eclipse.jdt.core.IPackageFragmentRoot"/>
		           <instanceof value="org.eclipse.jdt.core.ICompilationUnit"/>
		           <adapt type="org.eclipse.core.resources.IProject">
		              <test
		                    property="org.eclipse.core.resources.projectNature"
		                    value="org.eclipse.jdt.core.javanature"/>
		           </adapt>
		        </or>
		     </enablement>
		  </commonWizard>		  
		  <commonWizard
		        type="new"
		        wizardId="org.eclipse.jdt.ui.wizards.NewAnnotationCreationWizard">
		     <enablement>
		        <or>
		           <instanceof value="org.eclipse.jdt.core.IPackageFragment"/>
		           <instanceof value="org.eclipse.jdt.core.IPackageFragmentRoot"/>
		           <instanceof value="org.eclipse.jdt.core.ICompilationUnit"/>
		           <adapt type="org.eclipse.core.resources.IProject">
		              <test
		                    property="org.eclipse.core.resources.projectNature"
		                    value="org.eclipse.jdt.core.javanature"/>
		           </adapt>
		        </or>
		     </enablement>
		  </commonWizard>

		    <commonWizard
		          type="new"
		          wizardId="org.eclipse.jdt.ui.wizards.NewEnumCreationWizard">
				     <enablement>
				        <or>
				           <instanceof value="org.eclipse.jdt.core.IPackageFragment"/>
				           <instanceof value="org.eclipse.jdt.core.IPackageFragmentRoot"/>
				           <instanceof value="org.eclipse.jdt.core.ICompilationUnit"/>
				           <adapt type="org.eclipse.core.resources.IProject">
				              <test
				                    property="org.eclipse.core.resources.projectNature"
				                    value="org.eclipse.jdt.core.javanature"/>
				           </adapt>
				        </or>
				     </enablement>
		    </commonWizard>	 
		    <commonWizard
		          type="new"
		          wizardId="org.eclipse.jdt.ui.wizards.NewSourceFolderCreationWizard">
				     <enablement>
				        <or> 
				           <instanceof value="org.eclipse.jdt.core.IPackageFragmentRoot"/> 
				           <adapt type="org.eclipse.core.resources.IProject">
				              <test
				                    property="org.eclipse.core.resources.projectNature"
				                    value="org.eclipse.jdt.core.javanature"/>
				           </adapt>
				        </or>
				     </enablement>
			 </commonWizard>
		
	</extension>
     
</plugin>




/*******************************************************************************
 * Copyright (c) 2003, 2004 IBM Corporation and others.
 * 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:
 * IBM Corporation - initial API and implementation
 *******************************************************************************/ 
package org.eclipse.jdt.internal.ui.navigator;

import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.actions.ActionContext;
import org.eclipse.ui.navigator.CommonActionProvider;
import org.eclipse.ui.navigator.ICommonActionConstants;
import org.eclipse.ui.navigator.ICommonActionExtensionSite;
import org.eclipse.ui.navigator.ICommonViewerWorkbenchSite;

import org.eclipse.jdt.ui.actions.OpenAction;
import org.eclipse.jdt.ui.actions.OpenEditorActionGroup;

public class PackageExplorerOpenActionProvider extends CommonActionProvider {
	

	private IAction fOpenAndExpand;
	private OpenEditorActionGroup fOpenGroup;

	private boolean fInViewPart = false;

	public void fillActionBars(IActionBars actionBars) { 
		if(fInViewPart) { 
			fOpenGroup.fillActionBars(actionBars); 
			
			if(fOpenAndExpand == null && fOpenGroup.getOpenAction().isEnabled()) // TODO: is not updated!
				actionBars.setGlobalActionHandler(ICommonActionConstants.OPEN, fOpenGroup.getOpenAction());
			else if(fOpenAndExpand.isEnabled())
				actionBars.setGlobalActionHandler(ICommonActionConstants.OPEN, fOpenAndExpand);
		}

	}

	public void fillContextMenu(IMenuManager menu) {

		if (fInViewPart) {
			if (fOpenGroup.getOpenAction().isEnabled()) {
				fOpenGroup.fillContextMenu(menu);
			} 
		}
	}

	public void init(ICommonActionExtensionSite site) {

		ICommonViewerWorkbenchSite workbenchSite = null;
		if (site.getViewSite() instanceof ICommonViewerWorkbenchSite)
			workbenchSite = (ICommonViewerWorkbenchSite) site.getViewSite();
 
		if (workbenchSite != null) {
			if (workbenchSite.getPart() != null && workbenchSite.getPart() instanceof IViewPart) {
				IViewPart viewPart = (IViewPart) workbenchSite.getPart();

				fOpenGroup = new OpenEditorActionGroup(viewPart); 

				if (site.getStructuredViewer() instanceof TreeViewer)
					fOpenAndExpand = new OpenAndExpand(workbenchSite.getSite(), (OpenAction) fOpenGroup.getOpenAction(), (TreeViewer) site.getStructuredViewer());
				fInViewPart = true;
			} 
		} 
	}

	public void setContext(ActionContext context) {
		super.setContext(context);
		if (fInViewPart) {
			fOpenGroup.setContext(context); 
		}
	}

}

Return to bug 135565

Lines 5088-5093 Link Here

(-)plugin.xml (-5 / +106 lines)
5088	</navigatorContent>	5088	</navigatorContent>
5089	</extension>	5089	</extension>
5090		5090
		5091
5091	<!-- CommonNavigator -->	5092	<!-- CommonNavigator -->
5092		5093
5093	<extension	5094	<extension
Lines 5100-5107 Link Here
5100	</extension>	5101	</extension>
5101		5102
5102	<extension	5103	<extension
5103	point="org.eclipse.ui.navigator.navigatorContent">	5104	point="org.eclipse.ui.navigator.navigatorContent"> type="new"
5104	<navigatorContent	5105	<navigatorContent wizardId="org.eclipse.jdt.ui.wizards.JavaProjectWizard"/> <navigatorContent
5105	activeByDefault="true"	5106	activeByDefault="true"
5106	contentProvider="org.eclipse.jdt.internal.ui.navigator.JavaNavigatorContentProvider"	5107	contentProvider="org.eclipse.jdt.internal.ui.navigator.JavaNavigatorContentProvider"
5107	icon="$nl$/icons/full/obj16/java_model.gif"	5108	icon="$nl$/icons/full/obj16/java_model.gif"
Lines 5164-5172 Link Here
5164	</possibleChildren>	5165	</possibleChildren>
5165	<actionProvider	5166	<actionProvider
5166	class="org.eclipse.jdt.internal.ui.navigator.PackageExplorerActionProvider"	5167	class="org.eclipse.jdt.internal.ui.navigator.PackageExplorerActionProvider"
5167	overrides="org.eclipse.ui.navigator.resources.actions.RefactorActions">	5168	overrides="org.eclipse.ui.navigator.resources.actions.RefactorActions">
5168	<enablement>
5169	</enablement>
5170	</actionProvider>	5169	</actionProvider>
5171	<override	5170	<override
5172	policy="InvokeAlwaysRegardlessOfSuppressedExt"	5171	policy="InvokeAlwaysRegardlessOfSuppressedExt"
Lines 5174-5180 Link Here
5174	<commonSorter	5173	<commonSorter
5175	class="org.eclipse.jdt.ui.JavaElementSorter"	5174	class="org.eclipse.jdt.ui.JavaElementSorter"
5176	id="org.eclipse.jdt.ui.javaElementSorter"/>	5175	id="org.eclipse.jdt.ui.javaElementSorter"/>
		5176	<actionProvider
		5177	class="org.eclipse.jdt.internal.ui.navigator.PackageExplorerOpenActionProvider"
		5178	id="org.eclipse.jdt.internal.ui.navigator.PackageExplorerOpenActionProvider"
		5179	overrides="org.eclipse.ui.navigator.resources.OpenActions">
		5180	</actionProvider>
5177	</navigatorContent>	5181	</navigatorContent>
		5182	<commonWizard
		5183	type="new"
		5184	wizardId="org.eclipse.jdt.ui.wizards.NewPackageCreationWizard">
		5185	<enablement>
		5186	<or>
		5187	<instanceof value="org.eclipse.jdt.core.IPackageFragment"/>
		5188	<instanceof value="org.eclipse.jdt.core.IPackageFragmentRoot"/>
		5189	<instanceof value="org.eclipse.jdt.core.ICompilationUnit"/>
		5190	<adapt type="org.eclipse.core.resources.IProject">
		5191	<test
		5192	property="org.eclipse.core.resources.projectNature"
		5193	value="org.eclipse.jdt.core.javanature"/>
		5194	</adapt>
		5195	</or>
		5196	</enablement>
		5197	</commonWizard>
		5198	<commonWizard
		5199	type="new"
		5200	wizardId="org.eclipse.jdt.ui.wizards.NewClassCreationWizard">
		5201	<enablement>
		5202	<or>
		5203	<instanceof value="org.eclipse.jdt.core.IPackageFragment"/>
		5204	<instanceof value="org.eclipse.jdt.core.IPackageFragmentRoot"/>
		5205	<instanceof value="org.eclipse.jdt.core.ICompilationUnit"/>
		5206	<adapt type="org.eclipse.core.resources.IProject">
		5207	<test
		5208	property="org.eclipse.core.resources.projectNature"
		5209	value="org.eclipse.jdt.core.javanature"/>
		5210	</adapt>
		5211	</or>
		5212	</enablement>
		5213	</commonWizard>
		5214
		5215	<commonWizard
		5216	type="new"
		5217	wizardId="org.eclipse.jdt.ui.wizards.NewInterfaceCreationWizard">
		5218	<enablement>
		5219	<or>
		5220	<instanceof value="org.eclipse.jdt.core.IPackageFragment"/>
		5221	<instanceof value="org.eclipse.jdt.core.IPackageFragmentRoot"/>
		5222	<instanceof value="org.eclipse.jdt.core.ICompilationUnit"/>
		5223	<adapt type="org.eclipse.core.resources.IProject">
		5224	<test
		5225	property="org.eclipse.core.resources.projectNature"
		5226	value="org.eclipse.jdt.core.javanature"/>
		5227	</adapt>
		5228	</or>
		5229	</enablement>
		5230	</commonWizard>
		5231	<commonWizard
		5232	type="new"
		5233	wizardId="org.eclipse.jdt.ui.wizards.NewAnnotationCreationWizard">
		5234	<enablement>
		5235	<or>
		5236	<instanceof value="org.eclipse.jdt.core.IPackageFragment"/>
		5237	<instanceof value="org.eclipse.jdt.core.IPackageFragmentRoot"/>
		5238	<instanceof value="org.eclipse.jdt.core.ICompilationUnit"/>
		5239	<adapt type="org.eclipse.core.resources.IProject">
		5240	<test
		5241	property="org.eclipse.core.resources.projectNature"
		5242	value="org.eclipse.jdt.core.javanature"/>
		5243	</adapt>
		5244	</or>
		5245	</enablement>
5246	</commonWizard>
5247
5248	<commonWizard
5249	type="new"
5250	wizardId="org.eclipse.jdt.ui.wizards.NewEnumCreationWizard">
5251	<enablement>
5252	<or>
5253	<instanceof value="org.eclipse.jdt.core.IPackageFragment"/>
5254	<instanceof value="org.eclipse.jdt.core.IPackageFragmentRoot"/>
5255	<instanceof value="org.eclipse.jdt.core.ICompilationUnit"/>
5256	<adapt type="org.eclipse.core.resources.IProject">
5257	<test
5258	property="org.eclipse.core.resources.projectNature"
5259	value="org.eclipse.jdt.core.javanature"/>
5260	</adapt>
5261	</or>
5262	</enablement>
5263	</commonWizard>
5264	<commonWizard
5265	type="new"
5266	wizardId="org.eclipse.jdt.ui.wizards.NewSourceFolderCreationWizard">
5267	<enablement>
5268	<or>
5269	<instanceof value="org.eclipse.jdt.core.IPackageFragmentRoot"/>
5270	<adapt type="org.eclipse.core.resources.IProject">
5271	<test
5272	property="org.eclipse.core.resources.projectNature"
5273	value="org.eclipse.jdt.core.javanature"/>
5274	</adapt>
5275	</or>
5276	</enablement>
5277	</commonWizard>
5278
5178	</extension>	5279	</extension>
5179		5280
5180	</plugin>	5281	</plugin>

Lines 1-26 Link Here

(-)ui/org/eclipse/jdt/internal/ui/navigator/PackageExplorerActionProvider.java (-57 / +49 lines)
1	/*******************************************************************************	1	/***************************************************************************************************
2	* Copyright (c) 2003, 2006 IBM Corporation and others.	2	* Copyright (c) 2003, 2006 IBM Corporation and others. All rights reserved. This program and the
3	* All rights reserved. This program and the accompanying materials	3	* accompanying materials are made available under the terms of the Eclipse Public License v1.0
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	4	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	5	* http://www.eclipse.org/legal/epl-v10.html
7	*	6	*
8	* Contributors:	7	* Contributors: IBM Corporation - initial API and implementation
9	* IBM Corporation - initial API and implementation	8	**************************************************************************************************/
10	*******************************************************************************/
11	package org.eclipse.jdt.internal.ui.navigator;	9	package org.eclipse.jdt.internal.ui.navigator;
12		10
13	import org.eclipse.jface.action.IAction;
14	import org.eclipse.jface.action.IMenuManager;	11	import org.eclipse.jface.action.IMenuManager;
15	import org.eclipse.jface.preference.IPreferenceStore;	12	import org.eclipse.jface.preference.IPreferenceStore;
16	import org.eclipse.jface.viewers.TreeViewer;
17		13
18	import org.eclipse.ui.IActionBars;	14	import org.eclipse.ui.IActionBars;
19	import org.eclipse.ui.IMemento;	15	import org.eclipse.ui.IMemento;
20	import org.eclipse.ui.IViewPart;	16	import org.eclipse.ui.IViewPart;
21	import org.eclipse.ui.actions.ActionContext;	17	import org.eclipse.ui.actions.ActionContext;
22	import org.eclipse.ui.navigator.CommonActionProvider;	18	import org.eclipse.ui.navigator.CommonActionProvider;
23	import org.eclipse.ui.navigator.ICommonActionConstants;
24	import org.eclipse.ui.navigator.ICommonActionExtensionSite;	19	import org.eclipse.ui.navigator.ICommonActionExtensionSite;
25	import org.eclipse.ui.navigator.ICommonViewerWorkbenchSite;	20	import org.eclipse.ui.navigator.ICommonViewerWorkbenchSite;
26	import org.eclipse.ui.navigator.IExtensionStateModel;	21	import org.eclipse.ui.navigator.IExtensionStateModel;
Lines 28-140 Link Here
28	import org.eclipse.jdt.ui.actions.CCPActionGroup;	23	import org.eclipse.jdt.ui.actions.CCPActionGroup;
29	import org.eclipse.jdt.ui.actions.GenerateActionGroup;	24	import org.eclipse.jdt.ui.actions.GenerateActionGroup;
30	import org.eclipse.jdt.ui.actions.JavaSearchActionGroup;	25	import org.eclipse.jdt.ui.actions.JavaSearchActionGroup;
31	import org.eclipse.jdt.ui.actions.OpenAction;	26	import org.eclipse.jdt.ui.actions.OpenViewActionGroup;
32	import org.eclipse.jdt.ui.actions.OpenEditorActionGroup;
33	import org.eclipse.jdt.ui.actions.RefactorActionGroup;	27	import org.eclipse.jdt.ui.actions.RefactorActionGroup;
34		28
35	import org.eclipse.jdt.internal.ui.JavaPlugin;	29	import org.eclipse.jdt.internal.ui.JavaPlugin;
36	import org.eclipse.jdt.internal.ui.navigator.IExtensionStateConstants.Values;	30	import org.eclipse.jdt.internal.ui.navigator.IExtensionStateConstants.Values;
37	import org.eclipse.jdt.internal.ui.wizards.buildpaths.newsourcepage.GenerateBuildPathActionGroup;	31	import org.eclipse.jdt.internal.ui.wizards.buildpaths.newsourcepage.GenerateBuildPathActionGroup;
38		32
39	public class PackageExplorerActionProvider extends CommonActionProvider {	33	public class PackageExplorerActionProvider extends CommonActionProvider {
40		34
41	private static final int HIERARCHICAL_LAYOUT = 0x1;	35	private static final int HIERARCHICAL_LAYOUT = 0x1;
42		36
43	private static final int FLAT_LAYOUT = 0x2;	37	private static final int FLAT_LAYOUT = 0x2;
44		38
45	private static final String TAG_LAYOUT = "layout"; //$NON-NLS-1$	39	private static final String TAG_LAYOUT = "layout"; //$NON-NLS-1$
46		40
47	private CommonLayoutActionGroup fLayoutActionGroup;	41	private CommonLayoutActionGroup fLayoutActionGroup;
48		42
49	private boolean fHasFilledViewMenu = false;	43	private boolean fHasFilledViewMenu = false;
50		44
51	private IExtensionStateModel fStateModel;	45	private IExtensionStateModel fStateModel;
52		46
53	private IAction fOpenAndExpand;	47	private OpenViewActionGroup fOpenViewGroup;
54
55	private OpenEditorActionGroup fOpenGroup;
56		48
57	private CCPActionGroup fCCPGroup;	49	private CCPActionGroup fCCPGroup;
58		50
59	private RefactorActionGroup fRefactorGroup;	51	private RefactorActionGroup fRefactorGroup;
60		52
61	private JavaSearchActionGroup fSearchGroup;	53	private JavaSearchActionGroup fSearchGroup;
62		54
63	private GenerateBuildPathActionGroup fBuildPathGroup;	55	private GenerateBuildPathActionGroup fBuildPathGroup;
64		56
65	private GenerateActionGroup fGenerateGroup;	57	private GenerateActionGroup fGenerateGroup;
66		58
67	private boolean fInViewPart = false;	59	private boolean fInViewPart = false;
68		60
69	public void fillActionBars(IActionBars actionBars) {	61	public void fillActionBars(IActionBars actionBars) {
70	if (!fHasFilledViewMenu) {	62	if (!fHasFilledViewMenu) {
71	fLayoutActionGroup.fillActionBars(actionBars);	63	fLayoutActionGroup.fillActionBars(actionBars);
72	fHasFilledViewMenu = true;	64	fHasFilledViewMenu = true;
73	}	65	}
74	if(fInViewPart) {	66	if (fInViewPart) {
75	fOpenGroup.fillActionBars(actionBars);	67	fOpenViewGroup.fillActionBars(actionBars);
76	fCCPGroup.fillActionBars(actionBars);	68	fCCPGroup.fillActionBars(actionBars);
77	fBuildPathGroup.fillActionBars(actionBars);	69	fBuildPathGroup.fillActionBars(actionBars);
78	fGenerateGroup.fillActionBars(actionBars);	70	fGenerateGroup.fillActionBars(actionBars);
79	fRefactorGroup.fillActionBars(actionBars);	71	fRefactorGroup.fillActionBars(actionBars);
80	fRefactorGroup.retargetFileMenuActions(actionBars);	72	fRefactorGroup.retargetFileMenuActions(actionBars);
81	fSearchGroup.fillActionBars(actionBars);	73	fSearchGroup.fillActionBars(actionBars);
82
83	if(fOpenAndExpand == null && fOpenGroup.getOpenAction().isEnabled()) // TODO: is not updated!
84	actionBars.setGlobalActionHandler(ICommonActionConstants.OPEN, fOpenGroup.getOpenAction());
85	else if(fOpenAndExpand.isEnabled())
86	actionBars.setGlobalActionHandler(ICommonActionConstants.OPEN, fOpenAndExpand);
87	}	74	}
88		75
89	}	76	}
90		77
91	public void fillContextMenu(IMenuManager menu) {	78	public void fillContextMenu(IMenuManager menu) {
92		79
93	if(fInViewPart) {	80	if (fInViewPart) {
94	fCCPGroup.fillContextMenu(menu);	81	fOpenViewGroup.fillContextMenu(menu);
		82	fCCPGroup.fillContextMenu(menu);
95	fBuildPathGroup.fillContextMenu(menu);	83	fBuildPathGroup.fillContextMenu(menu);
96	fGenerateGroup.fillContextMenu(menu);	84	fGenerateGroup.fillContextMenu(menu);
97	fRefactorGroup.fillContextMenu(menu);	85	fRefactorGroup.fillContextMenu(menu);
98	fSearchGroup.fillContextMenu(menu);	86	fSearchGroup.fillContextMenu(menu);
99	}	87	}
100	}	88	}
101		89
102	public void init(ICommonActionExtensionSite site) {	90	public void init(ICommonActionExtensionSite site) {
103		91
104	ICommonViewerWorkbenchSite workbenchSite = null;	92	ICommonViewerWorkbenchSite workbenchSite = null;
105	if (site.getViewSite() instanceof ICommonViewerWorkbenchSite)	93	if (site.getViewSite() instanceof ICommonViewerWorkbenchSite)
106	workbenchSite = (ICommonViewerWorkbenchSite) site.getViewSite();	94	workbenchSite = (ICommonViewerWorkbenchSite) site.getViewSite();
107		95
108	fStateModel = site.getExtensionStateModel();	96	fStateModel = site.getExtensionStateModel();
109		97
110	fLayoutActionGroup = new CommonLayoutActionGroup(site	98	fLayoutActionGroup = new CommonLayoutActionGroup(site.getStructuredViewer(), fStateModel);
111	.getStructuredViewer(), fStateModel);
112		99
113	if (workbenchSite != null) {	100	if (workbenchSite != null) {
114	if (workbenchSite.getPart() != null	101	if (workbenchSite.getPart() != null && workbenchSite.getPart() instanceof IViewPart) {
115	&& workbenchSite.getPart() instanceof IViewPart) {
116	IViewPart viewPart = (IViewPart) workbenchSite.getPart();	102	IViewPart viewPart = (IViewPart) workbenchSite.getPart();
117		103
118	fOpenGroup = new OpenEditorActionGroup(viewPart);	104	fOpenViewGroup = new OpenViewActionGroup(viewPart, site.getStructuredViewer(), false);
119	fCCPGroup = new CCPActionGroup(viewPart);	105	fCCPGroup = new CCPActionGroup(viewPart);
120	fRefactorGroup = new RefactorActionGroup(viewPart);	106	fRefactorGroup = new RefactorActionGroup(viewPart);
121	fGenerateGroup = new GenerateActionGroup(viewPart);	107	fGenerateGroup = new GenerateActionGroup(viewPart);
122	fSearchGroup = new JavaSearchActionGroup(viewPart);	108	fSearchGroup = new JavaSearchActionGroup(viewPart);
123	fBuildPathGroup = new GenerateBuildPathActionGroup(viewPart);	109	fBuildPathGroup = new GenerateBuildPathActionGroup(viewPart);
124		110
125	if(site.getStructuredViewer() instanceof TreeViewer)
126	fOpenAndExpand = new OpenAndExpand(workbenchSite.getSite(), (OpenAction) fOpenGroup.getOpenAction(), (TreeViewer)site.getStructuredViewer());
127	fInViewPart = true;	111	fInViewPart = true;
128	}	112	}
129		113
130	}	114	}
131		115
132	}	116	}
133		117
134	public void setContext(ActionContext context) {	118	public void setContext(ActionContext context) {
135	super.setContext(context);	119	super.setContext(context);
136	if(fInViewPart) {	120	if (fInViewPart) {
137	fOpenGroup.setContext(context);	121	fOpenViewGroup.setContext(context);
138	fCCPGroup.setContext(context);	122	fCCPGroup.setContext(context);
139	fRefactorGroup.setContext(context);	123	fRefactorGroup.setContext(context);
140	fGenerateGroup.setContext(context);	124	fGenerateGroup.setContext(context);
Lines 156-163 Link Here
156		140
157	// If no memento try an restore from preference store	141	// If no memento try an restore from preference store
158	if (state == null) {	142	if (state == null) {
159	IPreferenceStore store = JavaPlugin.getDefault()	143	IPreferenceStore store = JavaPlugin.getDefault().getPreferenceStore();
160	.getPreferenceStore();
161	state = new Integer(store.getInt(TAG_LAYOUT));	144	state = new Integer(store.getInt(TAG_LAYOUT));
162	}	145	}
163		146
Lines 166-174 Link Here
166	else if (state.intValue() == HIERARCHICAL_LAYOUT)	149	else if (state.intValue() == HIERARCHICAL_LAYOUT)
167	isCurrentLayoutFlat = false;	150	isCurrentLayoutFlat = false;
168		151
169	fStateModel.setBooleanProperty(Values.IS_LAYOUT_FLAT,	152	fStateModel.setBooleanProperty(Values.IS_LAYOUT_FLAT, isCurrentLayoutFlat);
170	isCurrentLayoutFlat);
171	fLayoutActionGroup.setFlatLayout(isCurrentLayoutFlat);	153	fLayoutActionGroup.setFlatLayout(isCurrentLayoutFlat);
172	}	154	}
173		155
		156	public void saveState(IMemento aMemento) {
		157	super.saveState(aMemento);
		158	IPreferenceStore store = JavaPlugin.getDefault().getPreferenceStore();
		159	if (fStateModel.getBooleanProperty(Values.IS_LAYOUT_FLAT))
		160	store.setValue(TAG_LAYOUT, FLAT_LAYOUT);
		161	else
		162	store.setValue(TAG_LAYOUT, HIERARCHICAL_LAYOUT);
		163
		164	}
		165
174	}	166	}

Lines 43-48 Link Here

(-)ui/org/eclipse/jdt/ui/actions/OpenViewActionGroup.java (-11 / +41 lines)
43	public class OpenViewActionGroup extends ActionGroup {	43	public class OpenViewActionGroup extends ActionGroup {
44		44
45	private boolean fEditorIsOwner;	45	private boolean fEditorIsOwner;
		46	private final boolean fShowProperties;
46	private boolean fIsTypeHiararchyViewerOwner;	47	private boolean fIsTypeHiararchyViewerOwner;
47	private boolean fIsCallHiararchyViewerOwner;	48	private boolean fIsCallHiararchyViewerOwner;
48		49
Lines 61-68 Link Here
61	*	62	*
62	* @param page the page that owns this action group	63	* @param page the page that owns this action group
63	*/	64	*/
64	public OpenViewActionGroup(Page page) {	65	public OpenViewActionGroup(Page page) {
65	createSiteActions(page.getSite(), null);	66	this(page.getSite(), null);
66	}	67	}
67		68
68	/**	69	/**
Lines 77-82 Link Here
77	* @since 3.2	78	* @since 3.2
78	*/	79	*/
79	public OpenViewActionGroup(Page page, ISelectionProvider selectionProvider) {	80	public OpenViewActionGroup(Page page, ISelectionProvider selectionProvider) {
		81	fShowProperties = true;
80	createSiteActions(page.getSite(), selectionProvider);	82	createSiteActions(page.getSite(), selectionProvider);
81	}	83	}
82		84
Lines 103-108 Link Here
103	* @since 3.2	105	* @since 3.2
104	*/	106	*/
105	public OpenViewActionGroup(IViewPart part, ISelectionProvider selectionProvider) {	107	public OpenViewActionGroup(IViewPart part, ISelectionProvider selectionProvider) {
		108	this(part, selectionProvider, true);
		109	}
		110
		111
		112	/**
		113	* Creates a new <code>OpenActionGroup</code>. The group requires
		114	* that the selection provided by the given selection provider is of type
		115	* {@link IStructuredSelection}.
		116	*
		117	* <p>
		118	* This constructor is for internal use only. Clients may not call this constructor.
		119	* </p>
		120	*
		121	* @param part the view part that owns this action group
		122	* @param selectionProvider the selection provider used instead of the
		123	* page selection provider.
		124	* @param showProperties True indicates that the properties dialog action should be shown
		125	*
		126	* @since 3.2
		127	*/
		128	public OpenViewActionGroup(IViewPart part, ISelectionProvider selectionProvider, boolean showProperties) {
		129	fShowProperties = showProperties;
106	createSiteActions(part.getSite(), selectionProvider);	130	createSiteActions(part.getSite(), selectionProvider);
107	// we do a name check here to avoid class loading.	131	// we do a name check here to avoid class loading.
108	String partName= part.getClass().getName();	132	String partName= part.getClass().getName();
Lines 122-127 Link Here
122	* @since 3.2	146	* @since 3.2
123	*/	147	*/
124	public OpenViewActionGroup(IWorkbenchSite site, ISelectionProvider selectionProvider) {	148	public OpenViewActionGroup(IWorkbenchSite site, ISelectionProvider selectionProvider) {
		149	fShowProperties = true;
125	createSiteActions(site, selectionProvider);	150	createSiteActions(site, selectionProvider);
126	}	151	}
127		152
Lines 131-136 Link Here
131	*/	156	*/
132	public OpenViewActionGroup(JavaEditor part) {	157	public OpenViewActionGroup(JavaEditor part) {
133	fEditorIsOwner= true;	158	fEditorIsOwner= true;
		159	fShowProperties = true;
134		160
135	fOpenSuperImplementation= new OpenSuperImplementationAction(part);	161	fOpenSuperImplementation= new OpenSuperImplementationAction(part);
136	fOpenSuperImplementation.setActionDefinitionId(IJavaEditorActionDefinitionIds.OPEN_SUPER_IMPLEMENTATION);	162	fOpenSuperImplementation.setActionDefinitionId(IJavaEditorActionDefinitionIds.OPEN_SUPER_IMPLEMENTATION);
Lines 170-177 Link Here
170		196
171	ISelectionProvider provider= specialProvider != null ? specialProvider : site.getSelectionProvider();	197	ISelectionProvider provider= specialProvider != null ? specialProvider : site.getSelectionProvider();
172		198
173	fOpenPropertiesDialog= new PropertyDialogAction(site, provider);	199	if(fShowProperties) {
174	fOpenPropertiesDialog.setActionDefinitionId(IWorkbenchActionDefinitionIds.PROPERTIES);	200	fOpenPropertiesDialog= new PropertyDialogAction(site, provider);
		201	fOpenPropertiesDialog.setActionDefinitionId(IWorkbenchActionDefinitionIds.PROPERTIES);
		202	}
175		203
176	initialize(provider);	204	initialize(provider);
177	}	205	}
Lines 184-194 Link Here
184	fOpenTypeHierarchy.update(selection);	212	fOpenTypeHierarchy.update(selection);
185	fOpenCallHierarchy.update(selection);	213	fOpenCallHierarchy.update(selection);
186	if (!fEditorIsOwner) {	214	if (!fEditorIsOwner) {
187	if (selection instanceof IStructuredSelection) {	215	if(fShowProperties) {
188	IStructuredSelection ss= (IStructuredSelection)selection;	216	if (selection instanceof IStructuredSelection) {
189	fOpenPropertiesDialog.selectionChanged(ss);	217	IStructuredSelection ss= (IStructuredSelection)selection;
190	} else {	218	fOpenPropertiesDialog.selectionChanged(ss);
191	fOpenPropertiesDialog.selectionChanged(selection);	219	} else {
		220	fOpenPropertiesDialog.selectionChanged(selection);
		221	}
192	}	222	}
193	provider.addSelectionChangedListener(fOpenSuperImplementation);	223	provider.addSelectionChangedListener(fOpenSuperImplementation);
194	provider.addSelectionChangedListener(fOpenExternalJavadoc);	224	provider.addSelectionChangedListener(fOpenExternalJavadoc);
Lines 217-223 Link Here
217	appendToGroup(menu, fOpenCallHierarchy);	247	appendToGroup(menu, fOpenCallHierarchy);
218	appendToGroup(menu, fOpenSuperImplementation);	248	appendToGroup(menu, fOpenSuperImplementation);
219	IStructuredSelection selection= getStructuredSelection();	249	IStructuredSelection selection= getStructuredSelection();
220	if (fOpenPropertiesDialog != null && fOpenPropertiesDialog.isEnabled() && selection != null &&fOpenPropertiesDialog.isApplicableForSelection(selection))	250	if (fShowProperties && fOpenPropertiesDialog != null && fOpenPropertiesDialog.isEnabled() && selection != null &&fOpenPropertiesDialog.isApplicableForSelection(selection))
221	menu.appendToGroup(IContextMenuConstants.GROUP_PROPERTIES, fOpenPropertiesDialog);	251	menu.appendToGroup(IContextMenuConstants.GROUP_PROPERTIES, fOpenPropertiesDialog);
222	}	252	}
223		253
Lines 238-244 Link Here
238	actionBars.setGlobalActionHandler(JdtActionConstants.OPEN_TYPE_HIERARCHY, fOpenTypeHierarchy);	268	actionBars.setGlobalActionHandler(JdtActionConstants.OPEN_TYPE_HIERARCHY, fOpenTypeHierarchy);
239	actionBars.setGlobalActionHandler(JdtActionConstants.OPEN_CALL_HIERARCHY, fOpenCallHierarchy);	269	actionBars.setGlobalActionHandler(JdtActionConstants.OPEN_CALL_HIERARCHY, fOpenCallHierarchy);
240		270
241	if (!fEditorIsOwner)	271	if (!fEditorIsOwner && fShowProperties)
242	actionBars.setGlobalActionHandler(ActionFactory.PROPERTIES.getId(), fOpenPropertiesDialog);	272	actionBars.setGlobalActionHandler(ActionFactory.PROPERTIES.getId(), fOpenPropertiesDialog);
243	}	273	}
244		274

Added Link Here

(-)ui/org/eclipse/jdt/internal/ui/navigator/PackageExplorerOpenActionProvider.java (+83 lines)
1	/*******************************************************************************
2	* Copyright (c) 2003, 2004 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.internal.ui.navigator;
12
13	import org.eclipse.jface.action.IAction;
14	import org.eclipse.jface.action.IMenuManager;
15	import org.eclipse.jface.viewers.TreeViewer;
16
17	import org.eclipse.ui.IActionBars;
18	import org.eclipse.ui.IViewPart;
19	import org.eclipse.ui.actions.ActionContext;
20	import org.eclipse.ui.navigator.CommonActionProvider;
21	import org.eclipse.ui.navigator.ICommonActionConstants;
22	import org.eclipse.ui.navigator.ICommonActionExtensionSite;
23	import org.eclipse.ui.navigator.ICommonViewerWorkbenchSite;
24
25	import org.eclipse.jdt.ui.actions.OpenAction;
26	import org.eclipse.jdt.ui.actions.OpenEditorActionGroup;
27
28	public class PackageExplorerOpenActionProvider extends CommonActionProvider {
29
30
31	private IAction fOpenAndExpand;
32	private OpenEditorActionGroup fOpenGroup;
33
34	private boolean fInViewPart = false;
35
36	public void fillActionBars(IActionBars actionBars) {
37	if(fInViewPart) {
38	fOpenGroup.fillActionBars(actionBars);
39
40	if(fOpenAndExpand == null && fOpenGroup.getOpenAction().isEnabled()) // TODO: is not updated!
41	actionBars.setGlobalActionHandler(ICommonActionConstants.OPEN, fOpenGroup.getOpenAction());
42	else if(fOpenAndExpand.isEnabled())
43	actionBars.setGlobalActionHandler(ICommonActionConstants.OPEN, fOpenAndExpand);
44	}
45
46	}
47
48	public void fillContextMenu(IMenuManager menu) {
49
50	if (fInViewPart) {
51	if (fOpenGroup.getOpenAction().isEnabled()) {
52	fOpenGroup.fillContextMenu(menu);
53	}
54	}
55	}
56
57	public void init(ICommonActionExtensionSite site) {
58
59	ICommonViewerWorkbenchSite workbenchSite = null;
60	if (site.getViewSite() instanceof ICommonViewerWorkbenchSite)
61	workbenchSite = (ICommonViewerWorkbenchSite) site.getViewSite();
62
63	if (workbenchSite != null) {
64	if (workbenchSite.getPart() != null && workbenchSite.getPart() instanceof IViewPart) {
65	IViewPart viewPart = (IViewPart) workbenchSite.getPart();
66
67	fOpenGroup = new OpenEditorActionGroup(viewPart);
68
69	if (site.getStructuredViewer() instanceof TreeViewer)
70	fOpenAndExpand = new OpenAndExpand(workbenchSite.getSite(), (OpenAction) fOpenGroup.getOpenAction(), (TreeViewer) site.getStructuredViewer());
71	fInViewPart = true;
72	}
73	}
74	}
75
76	public void setContext(ActionContext context) {
77	super.setContext(context);
78	if (fInViewPart) {
79	fOpenGroup.setContext(context);
80	}
81	}
82
83	}