001: /*******************************************************************************
002: * Copyright (c) 2000, 2007 IBM Corporation and others.
003: * All rights reserved. This program and the accompanying materials
004: * are made available under the terms of the Eclipse Public License v1.0
005: * which accompanies this distribution, and is available at
006: * http://www.eclipse.org/legal/epl-v10.html
007: *
008: * Contributors:
009: * IBM Corporation - initial API and implementation
010: *******************************************************************************/package org.eclipse.jdt.internal.ui.browsing;
011:
012: import org.eclipse.core.runtime.Assert;
013: import org.eclipse.core.runtime.CoreException;
014:
015: import org.eclipse.core.resources.IFolder;
016:
017: import org.eclipse.swt.SWT;
018: import org.eclipse.swt.graphics.Image;
019: import org.eclipse.swt.widgets.Composite;
020: import org.eclipse.swt.widgets.Control;
021:
022: import org.eclipse.jface.action.Action;
023: import org.eclipse.jface.action.GroupMarker;
024: import org.eclipse.jface.action.IAction;
025: import org.eclipse.jface.action.IContributionItem;
026: import org.eclipse.jface.action.IMenuManager;
027: import org.eclipse.jface.action.IStatusLineManager;
028: import org.eclipse.jface.action.MenuManager;
029: import org.eclipse.jface.preference.IPreferenceStore;
030: import org.eclipse.jface.viewers.IContentProvider;
031: import org.eclipse.jface.viewers.ILabelDecorator;
032: import org.eclipse.jface.viewers.ISelection;
033: import org.eclipse.jface.viewers.IStructuredSelection;
034: import org.eclipse.jface.viewers.StructuredSelection;
035: import org.eclipse.jface.viewers.StructuredViewer;
036: import org.eclipse.jface.viewers.TableViewer;
037: import org.eclipse.jface.viewers.Viewer;
038:
039: import org.eclipse.ui.IActionBars;
040: import org.eclipse.ui.IMemento;
041: import org.eclipse.ui.IPageLayout;
042: import org.eclipse.ui.IViewSite;
043: import org.eclipse.ui.PartInitException;
044: import org.eclipse.ui.PlatformUI;
045: import org.eclipse.ui.actions.ActionFactory;
046: import org.eclipse.ui.part.IShowInTargetList;
047:
048: import org.eclipse.jdt.core.IClassFile;
049: import org.eclipse.jdt.core.ICompilationUnit;
050: import org.eclipse.jdt.core.IJavaElement;
051: import org.eclipse.jdt.core.IJavaProject;
052: import org.eclipse.jdt.core.IPackageFragment;
053: import org.eclipse.jdt.core.IPackageFragmentRoot;
054: import org.eclipse.jdt.core.IType;
055: import org.eclipse.jdt.core.JavaCore;
056:
057: import org.eclipse.jdt.internal.corext.util.Messages;
058:
059: import org.eclipse.jdt.ui.JavaElementComparator;
060: import org.eclipse.jdt.ui.JavaElementLabels;
061: import org.eclipse.jdt.ui.JavaUI;
062: import org.eclipse.jdt.ui.PreferenceConstants;
063:
064: import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
065: import org.eclipse.jdt.internal.ui.JavaPlugin;
066: import org.eclipse.jdt.internal.ui.JavaPluginImages;
067: import org.eclipse.jdt.internal.ui.actions.MultiActionGroup;
068: import org.eclipse.jdt.internal.ui.actions.SelectAllAction;
069: import org.eclipse.jdt.internal.ui.filters.NonJavaElementFilter;
070: import org.eclipse.jdt.internal.ui.viewsupport.DecoratingJavaLabelProvider;
071: import org.eclipse.jdt.internal.ui.viewsupport.JavaUILabelProvider;
072: import org.eclipse.jdt.internal.ui.viewsupport.LibraryFilter;
073: import org.eclipse.jdt.internal.ui.viewsupport.ProblemTableViewer;
074: import org.eclipse.jdt.internal.ui.viewsupport.ProblemTreeViewer;
075: import org.eclipse.jdt.internal.ui.viewsupport.StatusBarUpdater;
076:
077: public class PackagesView extends JavaBrowsingPart {
078:
079: private static final String TAG_VIEW_STATE = ".viewState"; //$NON-NLS-1$
080: private static final int LIST_VIEW_STATE = 0;
081: private static final int TREE_VIEW_STATE = 1;
082:
083: private static class StatusBarUpdater4LogicalPackage extends
084: StatusBarUpdater {
085:
086: private StatusBarUpdater4LogicalPackage(
087: IStatusLineManager statusLineManager) {
088: super (statusLineManager);
089: }
090:
091: protected String formatMessage(ISelection sel) {
092: if (sel instanceof IStructuredSelection) {
093: IStructuredSelection selection = (IStructuredSelection) sel;
094: int nElements = selection.size();
095: Object elem = selection.getFirstElement();
096: if (nElements == 1 && (elem instanceof LogicalPackage))
097: return formatLogicalPackageMessage((LogicalPackage) elem);
098: }
099: return super .formatMessage(sel);
100: }
101:
102: private String formatLogicalPackageMessage(
103: LogicalPackage logicalPackage) {
104: IPackageFragment[] fragments = logicalPackage
105: .getFragments();
106: StringBuffer buf = new StringBuffer(logicalPackage
107: .getElementName());
108: buf.append(JavaElementLabels.CONCAT_STRING);
109: String message = ""; //$NON-NLS-1$
110: boolean firstTime = true;
111: for (int i = 0; i < fragments.length; i++) {
112: IPackageFragment fragment = fragments[i];
113: IJavaElement element = fragment.getParent();
114: if (element instanceof IPackageFragmentRoot) {
115: IPackageFragmentRoot root = (IPackageFragmentRoot) element;
116: String label = JavaElementLabels.getElementLabel(
117: root, JavaElementLabels.DEFAULT_QUALIFIED
118: | JavaElementLabels.ROOT_QUALIFIED);
119: if (firstTime) {
120: buf.append(label);
121: firstTime = false;
122: } else
123: message = Messages.format(
124: JavaBrowsingMessages.StatusBar_concat,
125: new String[] { message, label });
126: }
127: }
128: buf.append(message);
129: return buf.toString();
130: }
131: }
132:
133: private SelectAllAction fSelectAllAction;
134:
135: private int fCurrViewState;
136:
137: private PackageViewerWrapper fWrappedViewer;
138:
139: private MultiActionGroup fSwitchActionGroup;
140: private boolean fLastInputWasProject;
141:
142: /**
143: * Adds filters the viewer of this part.
144: */
145: protected void addFilters() {
146: super .addFilters();
147: getViewer().addFilter(createNonJavaElementFilter());
148: getViewer().addFilter(new LibraryFilter());
149: }
150:
151: /**
152: * Creates new NonJavaElementFilter and overrides method select to allow for
153: * LogicalPackages.
154: * @return NonJavaElementFilter
155: */
156: protected NonJavaElementFilter createNonJavaElementFilter() {
157: return new NonJavaElementFilter() {
158: public boolean select(Viewer viewer, Object parent,
159: Object element) {
160: return ((element instanceof IJavaElement)
161: || (element instanceof LogicalPackage) || (element instanceof IFolder));
162: }
163: };
164: }
165:
166: public void init(IViewSite site, IMemento memento)
167: throws PartInitException {
168: super .init(site, memento);
169: //this must be created before all actions and filters
170: fWrappedViewer = new PackageViewerWrapper();
171: restoreLayoutState(memento);
172: }
173:
174: private void restoreLayoutState(IMemento memento) {
175: if (memento == null) {
176: //read state from the preference store
177: IPreferenceStore store = JavaPlugin.getDefault()
178: .getPreferenceStore();
179: fCurrViewState = store.getInt(this .getViewSite().getId()
180: + TAG_VIEW_STATE);
181: } else {
182: //restore from memento
183: Integer integer = memento.getInteger(this .getViewSite()
184: .getId()
185: + TAG_VIEW_STATE);
186: if ((integer == null) || !isValidState(integer.intValue())) {
187: fCurrViewState = LIST_VIEW_STATE;
188: } else
189: fCurrViewState = integer.intValue();
190: }
191: }
192:
193: private boolean isValidState(int state) {
194: return (state == LIST_VIEW_STATE) || (state == TREE_VIEW_STATE);
195: }
196:
197: /*
198: * @see org.eclipse.ui.IViewPart#saveState(org.eclipse.ui.IMemento)
199: */
200: public void saveState(IMemento memento) {
201: super .saveState(memento);
202: memento.putInteger(this .getViewSite().getId() + TAG_VIEW_STATE,
203: fCurrViewState);
204: }
205:
206: /* (non-Javadoc)
207: * @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#createViewer(org.eclipse.swt.widgets.Composite)
208: */
209: protected StructuredViewer createViewer(Composite parent) {
210: //Creates the viewer of this part dependent on the current layout.
211: StructuredViewer viewer;
212: if (isInListState())
213: viewer = createTableViewer(parent);
214: else
215: viewer = createTreeViewer(parent);
216:
217: fWrappedViewer.setViewer(viewer);
218: return fWrappedViewer;
219: }
220:
221: /* (non-Javadoc)
222: * @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#getAdapter(java.lang.Class)
223: */
224: public Object getAdapter(Class key) {
225: if (key == IShowInTargetList.class) {
226: return new IShowInTargetList() {
227: public String[] getShowInTargetIds() {
228: return new String[] { JavaUI.ID_PACKAGES,
229: IPageLayout.ID_RES_NAV };
230: }
231: };
232: }
233: return super .getAdapter(key);
234: }
235:
236: protected boolean isInListState() {
237: return fCurrViewState == LIST_VIEW_STATE;
238: }
239:
240: private ProblemTableViewer createTableViewer(Composite parent) {
241: return new PackagesViewTableViewer(parent, SWT.MULTI);
242: }
243:
244: private ProblemTreeViewer createTreeViewer(Composite parent) {
245: return new PackagesViewTreeViewer(parent, SWT.MULTI);
246: }
247:
248: /**
249: * Overrides the createContentProvider from JavaBrowsingPart
250: * Creates the content provider of this part.
251: */
252: protected IContentProvider createContentProvider() {
253: if (isInListState())
254: return new PackagesViewFlatContentProvider(fWrappedViewer
255: .getViewer());
256: else
257: return new PackagesViewHierarchicalContentProvider(
258: fWrappedViewer.getViewer());
259: }
260:
261: protected JavaUILabelProvider createLabelProvider() {
262: if (isInListState())
263: return createListLabelProvider();
264: else
265: return createTreeLabelProvider();
266: }
267:
268: private JavaUILabelProvider createTreeLabelProvider() {
269: return new PackagesViewLabelProvider(
270: PackagesViewLabelProvider.HIERARCHICAL_VIEW_STATE);
271: }
272:
273: private JavaUILabelProvider createListLabelProvider() {
274: return new PackagesViewLabelProvider(
275: PackagesViewLabelProvider.FLAT_VIEW_STATE);
276: }
277:
278: /**
279: * Returns the context ID for the Help system
280: *
281: * @return the string used as ID for the Help context
282: */
283: protected String getHelpContextId() {
284: return IJavaHelpContextIds.PACKAGES_BROWSING_VIEW;
285: }
286:
287: protected String getLinkToEditorKey() {
288: return PreferenceConstants.LINK_BROWSING_PACKAGES_TO_EDITOR;
289: }
290:
291: /**
292: * Answers if the given <code>element</code> is a valid
293: * input for this part.
294: *
295: * @param element the object to test
296: * @return <true> if the given element is a valid input
297: */
298: protected boolean isValidInput(Object element) {
299: if (element instanceof IJavaProject
300: || (element instanceof IPackageFragmentRoot && ((IJavaElement) element)
301: .getElementName() != IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH))
302: try {
303: IJavaProject jProject = ((IJavaElement) element)
304: .getJavaProject();
305: if (jProject != null)
306: return jProject.getProject().hasNature(
307: JavaCore.NATURE_ID);
308: } catch (CoreException ex) {
309: return false;
310: }
311: return false;
312: }
313:
314: /**
315: * Answers if the given <code>element</code> is a valid
316: * element for this part.
317: *
318: * @param element the object to test
319: * @return <true> if the given element is a valid element
320: */
321: protected boolean isValidElement(Object element) {
322: if (element instanceof IPackageFragment) {
323: IJavaElement parent = ((IPackageFragment) element)
324: .getParent();
325: if (parent != null)
326: return super .isValidElement(parent)
327: || super
328: .isValidElement(parent.getJavaProject());
329: }
330: return false;
331: }
332:
333: /* (non-Javadoc)
334: * @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#findElementToSelect(org.eclipse.jdt.core.IJavaElement)
335: */
336: protected IJavaElement findElementToSelect(IJavaElement je) {
337: if (je == null)
338: return null;
339:
340: switch (je.getElementType()) {
341: case IJavaElement.PACKAGE_FRAGMENT:
342: return je;
343: case IJavaElement.COMPILATION_UNIT:
344: return ((ICompilationUnit) je).getParent();
345: case IJavaElement.CLASS_FILE:
346: return ((IClassFile) je).getParent();
347: case IJavaElement.TYPE:
348: return ((IType) je).getPackageFragment();
349: default:
350: return findElementToSelect(je.getParent());
351: }
352: }
353:
354: /*
355: * @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#setInput(java.lang.Object)
356: */
357: protected void setInput(Object input) {
358: setViewerWrapperInput(input);
359: super .updateTitle();
360: }
361:
362: private void setViewerWrapperInput(Object input) {
363: fWrappedViewer.setViewerInput(input);
364: }
365:
366: /**
367: * @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#fillActionBars(org.eclipse.ui.IActionBars)
368: */
369: protected void fillActionBars(IActionBars actionBars) {
370: super .fillActionBars(actionBars);
371: fSwitchActionGroup.fillActionBars(actionBars);
372: }
373:
374: private void setUpViewer(StructuredViewer viewer) {
375: Assert.isTrue(viewer != null);
376:
377: JavaUILabelProvider labelProvider = createLabelProvider();
378: viewer
379: .setLabelProvider(createDecoratingLabelProvider(labelProvider));
380:
381: viewer.setComparator(createJavaElementComparator());
382: viewer.setUseHashlookup(true);
383:
384: createContextMenu();
385:
386: //disapears when control disposed
387: addKeyListener();
388:
389: //this methods only adds listeners to the viewer,
390: //these listenters disapear when the viewer is disposed
391: hookViewerListeners();
392:
393: // Set content provider
394: viewer.setContentProvider(createContentProvider());
395: //Disposed when viewer's Control is disposed
396: initDragAndDrop();
397:
398: }
399:
400: //alter sorter to include LogicalPackages
401: protected JavaElementComparator createJavaElementComparator() {
402: return new JavaElementComparator() {
403: public int category(Object element) {
404: if (element instanceof LogicalPackage) {
405: LogicalPackage cp = (LogicalPackage) element;
406: return super .category(cp.getFragments()[0]);
407: } else
408: return super .category(element);
409: }
410:
411: public int compare(Viewer viewer, Object e1, Object e2) {
412: if (e1 instanceof LogicalPackage) {
413: LogicalPackage cp = (LogicalPackage) e1;
414: e1 = cp.getFragments()[0];
415: }
416: if (e2 instanceof LogicalPackage) {
417: LogicalPackage cp = (LogicalPackage) e2;
418: e2 = cp.getFragments()[0];
419: }
420: return super .compare(viewer, e1, e2);
421: }
422: };
423: }
424:
425: protected StatusBarUpdater createStatusBarUpdater(
426: IStatusLineManager slManager) {
427: return new StatusBarUpdater4LogicalPackage(slManager);
428: }
429:
430: protected void setSiteSelectionProvider() {
431: getSite().setSelectionProvider(fWrappedViewer);
432: }
433:
434: void adjustInputAndSetSelection(Object o) {
435: if (!(o instanceof LogicalPackage)) {
436: super .adjustInputAndSetSelection(o);
437: return;
438: }
439:
440: LogicalPackage lp = (LogicalPackage) o;
441: if (!lp.getJavaProject().equals(getInput()))
442: setInput(lp.getJavaProject());
443:
444: setSelection(new StructuredSelection(lp), true);
445: }
446:
447: //do the same thing as the JavaBrowsingPart but with wrapper
448: protected void createActions() {
449: super .createActions();
450:
451: createSelectAllAction();
452:
453: //create the switch action group
454: fSwitchActionGroup = createSwitchActionGroup();
455: }
456:
457: private MultiActionGroup createSwitchActionGroup() {
458:
459: LayoutAction switchToFlatViewAction = new LayoutAction(
460: JavaBrowsingMessages.PackagesView_flatLayoutAction_label,
461: LIST_VIEW_STATE);
462: LayoutAction switchToHierarchicalViewAction = new LayoutAction(
463: JavaBrowsingMessages.PackagesView_HierarchicalLayoutAction_label,
464: TREE_VIEW_STATE);
465: JavaPluginImages.setLocalImageDescriptors(
466: switchToFlatViewAction, "flatLayout.gif"); //$NON-NLS-1$
467: JavaPluginImages.setLocalImageDescriptors(
468: switchToHierarchicalViewAction,
469: "hierarchicalLayout.gif"); //$NON-NLS-1$
470:
471: return new LayoutActionGroup(
472: new IAction[] { switchToFlatViewAction,
473: switchToHierarchicalViewAction },
474: fCurrViewState);
475: }
476:
477: private static class LayoutActionGroup extends MultiActionGroup {
478:
479: LayoutActionGroup(IAction[] actions, int index) {
480: super (actions, index);
481: }
482:
483: public void fillActionBars(IActionBars actionBars) {
484: //create new layout group
485: IMenuManager manager = actionBars.getMenuManager();
486: final IContributionItem groupMarker = new GroupMarker(
487: "layout"); //$NON-NLS-1$
488: manager.add(groupMarker);
489: IMenuManager newManager = new MenuManager(
490: JavaBrowsingMessages.PackagesView_LayoutActionGroup_layout_label);
491: manager.appendToGroup("layout", newManager); //$NON-NLS-1$
492: super .addActions(newManager);
493: }
494: }
495:
496: /**
497: * Switches between flat and hierarchical state.
498: */
499: private class LayoutAction extends Action {
500:
501: private int fState;
502:
503: public LayoutAction(String text, int state) {
504: super (text, IAction.AS_RADIO_BUTTON);
505: fState = state;
506: if (state == PackagesView.LIST_VIEW_STATE)
507: PlatformUI.getWorkbench().getHelpSystem().setHelp(this ,
508: IJavaHelpContextIds.LAYOUT_FLAT_ACTION);
509: else
510: PlatformUI.getWorkbench().getHelpSystem().setHelp(this ,
511: IJavaHelpContextIds.LAYOUT_HIERARCHICAL_ACTION);
512: }
513:
514: public int getState() {
515: return fState;
516: }
517:
518: public void setRunnable(Runnable runnable) {
519: Assert.isNotNull(runnable);
520: }
521:
522: /*
523: * @see org.eclipse.jface.action.IAction#run()
524: */
525: public void run() {
526: switchViewer(fState);
527: }
528: }
529:
530: private void switchViewer(int state) {
531: //Indicate which viewer is to be used
532: if (fCurrViewState == state)
533: return;
534: else {
535: fCurrViewState = state;
536: IPreferenceStore store = JavaPlugin.getDefault()
537: .getPreferenceStore();
538: store.setValue(getViewSite().getId() + TAG_VIEW_STATE,
539: state);
540: }
541:
542: //get the information from the existing viewer
543: StructuredViewer viewer = fWrappedViewer.getViewer();
544: Object object = viewer.getInput();
545: ISelection selection = viewer.getSelection();
546:
547: // create and set up the new viewer
548: Control control = createViewer(
549: fWrappedViewer.getControl().getParent()).getControl();
550:
551: setUpViewer(fWrappedViewer);
552:
553: createSelectAllAction();
554:
555: // add the selection information from old viewer
556: fWrappedViewer.setViewerInput(object);
557: fWrappedViewer.getControl().setFocus();
558: fWrappedViewer.setSelection(selection, true);
559:
560: // dispose old viewer
561: viewer.getContentProvider().dispose();
562: viewer.getControl().dispose();
563:
564: // layout the new viewer
565: if (control != null && !control.isDisposed()) {
566: control.setVisible(true);
567: control.getParent().layout(true);
568: }
569: }
570:
571: private void createSelectAllAction() {
572: IActionBars actionBars = getViewSite().getActionBars();
573: if (isInListState()) {
574: fSelectAllAction = new SelectAllAction(
575: (TableViewer) fWrappedViewer.getViewer());
576: actionBars.setGlobalActionHandler(ActionFactory.SELECT_ALL
577: .getId(), fSelectAllAction);
578: } else {
579: actionBars.setGlobalActionHandler(ActionFactory.SELECT_ALL
580: .getId(), null);
581: fSelectAllAction = null;
582: }
583: actionBars.updateActionBars();
584: }
585:
586: protected IJavaElement findInputForJavaElement(IJavaElement je) {
587: // null check has to take place here as well (not only in
588: // findInputForJavaElement(IJavaElement, boolean) since we
589: // are accessing the Java element
590: if (je == null)
591: return null;
592: if (je.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT
593: || je.getElementType() == IJavaElement.JAVA_PROJECT)
594: return findInputForJavaElement(je, true);
595: else
596: return findInputForJavaElement(je, false);
597:
598: }
599:
600: protected IJavaElement findInputForJavaElement(IJavaElement je,
601: boolean canChangeInputType) {
602: if (je == null || !je.exists())
603: return null;
604:
605: if (isValidInput(je)) {
606:
607: //don't update if input must be project (i.e. project is used as source folder)
608: if (canChangeInputType)
609: fLastInputWasProject = je.getElementType() == IJavaElement.JAVA_PROJECT;
610: return je;
611: } else if (fLastInputWasProject) {
612: IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot) je
613: .getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
614: if (!packageFragmentRoot.isExternal())
615: return je.getJavaProject();
616: }
617:
618: return findInputForJavaElement(je.getParent(),
619: canChangeInputType);
620: }
621:
622: /**
623: * Override the getText and getImage methods for the DecoratingLabelProvider
624: * to handel the decoration of logical packages.
625: *
626: * @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#createDecoratingLabelProvider(JavaUILabelProvider)
627: */
628: protected DecoratingJavaLabelProvider createDecoratingLabelProvider(
629: JavaUILabelProvider provider) {
630: return new DecoratingJavaLabelProvider(provider, false,
631: isInListState()) {
632:
633: public String getText(Object element) {
634: if (element instanceof LogicalPackage) {
635: LogicalPackage el = (LogicalPackage) element;
636: return super .getText(el.getFragments()[0]);
637: } else
638: return super .getText(element);
639: }
640:
641: public Image getImage(Object element) {
642: if (element instanceof LogicalPackage) {
643: LogicalPackage el = (LogicalPackage) element;
644: ILabelDecorator decorator = getLabelDecorator();
645: IPackageFragment[] fragments = el.getFragments();
646:
647: Image image = super .getImage(el);
648: for (int i = 0; i < fragments.length; i++) {
649: IPackageFragment fragment = fragments[i];
650: Image decoratedImage = decorator.decorateImage(
651: image, fragment);
652: if (decoratedImage != null)
653: image = decoratedImage;
654: }
655: return image;
656: } else
657: return super .getImage(element);
658: }
659:
660: };
661: }
662:
663: /*
664: * Overridden from JavaBrowsingPart to handel LogicalPackages and tree
665: * structure.
666: * @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#adjustInputAndSetSelection(org.eclipse.jdt.core.IJavaElement)
667: */
668: void adjustInputAndSetSelection(IJavaElement je) {
669:
670: IJavaElement jElementToSelect = findElementToSelect(je);
671: LogicalPackagesProvider p = (LogicalPackagesProvider) fWrappedViewer
672: .getContentProvider();
673:
674: Object elementToSelect = jElementToSelect;
675: if (jElementToSelect != null
676: && jElementToSelect.getElementType() == IJavaElement.PACKAGE_FRAGMENT) {
677: IPackageFragment pkgFragment = (IPackageFragment) jElementToSelect;
678: elementToSelect = p.findLogicalPackage(pkgFragment);
679: if (elementToSelect == null)
680: elementToSelect = pkgFragment;
681: }
682:
683: IJavaElement newInput = findInputForJavaElement(je);
684: if (elementToSelect == null && !isValidInput(newInput))
685: setInput(null);
686: else if (elementToSelect == null
687: || getViewer().testFindItem(elementToSelect) == null) {
688:
689: //optimization, if you are in the same project but expansion hasn't happened
690: Object input = getViewer().getInput();
691: if (elementToSelect != null && newInput != null) {
692: if (newInput.equals(input)) {
693: getViewer().reveal(elementToSelect);
694: // Adjust input to selection
695: } else {
696: setInput(newInput);
697: getViewer().reveal(elementToSelect);
698: }
699: } else
700: setInput(newInput);
701:
702: if (elementToSelect instanceof IPackageFragment) {
703: IPackageFragment pkgFragment = (IPackageFragment) elementToSelect;
704: elementToSelect = p.findLogicalPackage(pkgFragment);
705: if (elementToSelect == null)
706: elementToSelect = pkgFragment;
707: }
708: }
709:
710: ISelection selection;
711: if (elementToSelect != null)
712: selection = new StructuredSelection(elementToSelect);
713: else
714: selection = StructuredSelection.EMPTY;
715: setSelection(selection, true);
716: }
717:
718: }
|