| // $codepro.audit.able com.instantiations.assist.eclipse.analysis.audit.rule.effectivejava.alwaysOverridetoString.alwaysOverrideToString, com.instantiations.assist.eclipse.analysis.deserializeabilitySecurity, com.instantiations.assist.eclipse.analysis.disallowReturnMutable, com.instantiations.assist.eclipse.analysis.enforceCloneableUsageSecurity |
| /******************************************************************************* |
| * Copyright (c) 2010, 2012 Ericsson AB 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 |
| * |
| * Description: |
| * |
| * This class implements the Review Navigator View. It is used to quickly browse the current |
| * R4E elements |
| * |
| * Contributors: |
| * Sebastien Dubois - Created for Mylyn Review R4E project |
| * |
| *******************************************************************************/ |
| |
| package org.eclipse.mylyn.reviews.r4e.ui.internal.navigator; |
| |
| import java.io.FileNotFoundException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.prefs.PreferenceChangeEvent; |
| |
| import org.eclipse.core.commands.ExecutionException; |
| import org.eclipse.core.commands.NotEnabledException; |
| import org.eclipse.core.commands.NotHandledException; |
| import org.eclipse.core.commands.common.NotDefinedException; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.preferences.IEclipsePreferences; |
| import org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener; |
| import org.eclipse.core.runtime.preferences.InstanceScope; |
| import org.eclipse.jface.action.IContributionItem; |
| import org.eclipse.jface.action.IMenuListener; |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.action.MenuManager; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.viewers.ColumnViewerToolTipSupport; |
| import org.eclipse.jface.viewers.DoubleClickEvent; |
| import org.eclipse.jface.viewers.IDoubleClickListener; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EFileVersion; |
| import org.eclipse.mylyn.reviews.r4e.core.model.serial.impl.CompatibilityException; |
| import org.eclipse.mylyn.reviews.r4e.core.model.serial.impl.ResourceHandlingException; |
| import org.eclipse.mylyn.reviews.r4e.ui.R4EUIPlugin; |
| import org.eclipse.mylyn.reviews.r4e.ui.internal.editors.EditorProxy; |
| import org.eclipse.mylyn.reviews.r4e.ui.internal.model.IR4EUIModelElement; |
| import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIFileContext; |
| import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIModelController; |
| import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIReviewBasic; |
| import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIReviewGroup; |
| import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIRuleSet; |
| import org.eclipse.mylyn.reviews.r4e.ui.internal.preferences.PreferenceConstants; |
| import org.eclipse.mylyn.reviews.r4e.ui.internal.preferences.R4EPreferencePage; |
| import org.eclipse.mylyn.reviews.r4e.ui.internal.sorters.DateComparator; |
| import org.eclipse.mylyn.reviews.r4e.ui.internal.sorters.LinePositionComparator; |
| import org.eclipse.mylyn.reviews.r4e.ui.internal.utils.R4EUIConstants; |
| import org.eclipse.mylyn.reviews.r4e.ui.internal.utils.UIUtils; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Menu; |
| import org.eclipse.ui.IActionBars; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorReference; |
| import org.eclipse.ui.IFileEditorInput; |
| import org.eclipse.ui.IPartListener; |
| import org.eclipse.ui.IPropertyListener; |
| import org.eclipse.ui.IViewPart; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.IWorkbenchPartSite; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.actions.ActionContext; |
| import org.eclipse.ui.actions.ActionGroup; |
| import org.eclipse.ui.part.ViewPart; |
| import org.eclipse.ui.services.IEvaluationService; |
| import org.eclipse.ui.views.properties.IPropertySheetPage; |
| import org.eclipse.ui.views.properties.PropertySheet; |
| import org.eclipse.ui.views.properties.tabbed.ITabbedPropertySheetPageContributor; |
| import org.eclipse.ui.views.properties.tabbed.TabbedPropertySheetPage; |
| |
| /** |
| * @author Sebastien Dubois |
| * @version $Revision: 1.0 $ |
| */ |
| public class ReviewNavigatorView extends ViewPart implements IMenuListener, IPreferenceChangeListener, |
| ITabbedPropertySheetPageContributor, IPropertyListener { |
| |
| // ------------------------------------------------------------------------ |
| // Member variables |
| // ------------------------------------------------------------------------ |
| |
| /** |
| * Field fReviewTreeViewer. |
| */ |
| private ReviewNavigatorTreeViewer fReviewTreeViewer = null; |
| |
| /** |
| * Field fContextMenu. |
| */ |
| private Menu fContextMenu = null; |
| |
| /** |
| * Field fActionSet. |
| */ |
| private ActionGroup fActionSet = null; |
| |
| /** |
| * Field fEditorLinked - this is set if the editor is linked to the review Navigator view |
| */ |
| private boolean fEditorLinked; |
| |
| /** |
| * Field fPropertiesLinked - this is set if the R4E properties view is linked to the review Navigator view |
| */ |
| private boolean fPropertiesLinked; |
| |
| /** |
| * Field fPropertySheetPage - the associated Tabbed Properties view |
| */ |
| protected TabbedPropertySheetPage fPropertySheetPage; |
| |
| /** |
| * Field fPartListener |
| */ |
| private IPartListener fPartListener = null; |
| |
| // ------------------------------------------------------------------------ |
| // Constructors |
| // ------------------------------------------------------------------------ |
| |
| /** |
| * Constructor for ReviewNavigatorView. |
| */ |
| public ReviewNavigatorView() { |
| R4EUIModelController.setNavigatorView(this); |
| } |
| |
| // ------------------------------------------------------------------------ |
| // Methods |
| // ------------------------------------------------------------------------ |
| |
| /** |
| * Method isVisible. |
| * |
| * @return - true is the view is visible, false otherwise |
| */ |
| public boolean isVisible() { |
| final IWorkbenchPage page = R4EUIPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getActivePage(); |
| if (null != page) { |
| return page.isPartVisible(this); |
| } |
| return false; |
| } |
| |
| /** |
| * Method setEditorLinked. |
| * |
| * @param aEditorLinked |
| * boolean - true is the editor is linked, false otherwise |
| */ |
| public void setEditorLinked(boolean aEditorLinked) { |
| fEditorLinked = aEditorLinked; |
| } |
| |
| /** |
| * Method isEditorLinked. |
| * |
| * @return - true is the editor is linked, false otherwise |
| */ |
| public boolean isEditorLinked() { |
| return fEditorLinked; |
| } |
| |
| /** |
| * Method setPropertiesLinked. |
| * |
| * @param aPropertiesLinked |
| * boolean - true is the R4E properties view is linked, false otherwise |
| */ |
| public void setPropertiesLinked(boolean aPropertiesLinked) { |
| fPropertiesLinked = aPropertiesLinked; |
| } |
| |
| /** |
| * Method isPropertiesLinked. |
| * |
| * @return - true is the R4E properties view is linked, false otherwise |
| */ |
| public boolean isPropertiesLinked() { |
| return fPropertiesLinked; |
| } |
| |
| /** |
| * Method isDefaultDisplay. |
| * |
| * @return boolean |
| */ |
| public boolean isDefaultDisplay() { |
| if (fReviewTreeViewer != null) { |
| return fReviewTreeViewer.isDefaultDisplay(); |
| } |
| return true; |
| |
| } |
| |
| /** |
| * Method dispose. |
| * |
| * @see org.eclipse.ui.IWorkbenchPart#dispose() |
| */ |
| @Override |
| public void dispose() { |
| if (null != fPartListener) { |
| getSite().getPage().removePartListener(fPartListener); |
| } |
| |
| if (null != fContextMenu && !fContextMenu.isDisposed()) { |
| fContextMenu.dispose(); |
| } |
| if (null != fActionSet) { |
| fActionSet.dispose(); |
| } |
| final IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(R4EUIConstants.R4E_TEMP_PROJECT); |
| |
| if (null != fPropertySheetPage) { |
| fPropertySheetPage.dispose(); |
| } |
| |
| try { |
| if (project.exists()) { |
| project.delete(true, null); |
| } |
| } catch (CoreException e) { |
| R4EUIPlugin.Ftracer.traceWarning("Exception: " + e.toString() + " (" + e.getMessage() + ")"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ |
| R4EUIPlugin.getDefault().logWarning("Exception: " + e.toString(), e); //$NON-NLS-1$ |
| } finally { |
| R4EUIModelController.setActiveReview(null); |
| super.dispose(); |
| } |
| } |
| |
| /** |
| * Method createPartControl. |
| * |
| * @param parent |
| * Composite |
| * @see org.eclipse.ui.IWorkbenchPart#createPartControl(Composite) |
| */ |
| @Override |
| public void createPartControl(Composite parent) { |
| R4EUIPlugin.Ftracer.traceInfo("Build Review Navigator view"); //$NON-NLS-1$ |
| |
| //Set tree viewer |
| fReviewTreeViewer = new ReviewNavigatorTreeViewer(parent, SWT.FULL_SELECTION | SWT.MULTI | SWT.H_SCROLL |
| | SWT.V_SCROLL); |
| fReviewTreeViewer.setUseHashlookup(true); |
| fReviewTreeViewer.getTree().setHeaderVisible(true); |
| ColumnViewerToolTipSupport.enableFor(fReviewTreeViewer); |
| fReviewTreeViewer.setContentProvider(new ReviewNavigatorContentProvider()); |
| |
| fReviewTreeViewer.setComparator(new LinePositionComparator()); |
| fReviewTreeViewer.setInput(getInitalInput()); |
| fReviewTreeViewer.setDefaultInput(fReviewTreeViewer.getInput()); |
| fReviewTreeViewer.setSorter(new LineViewerSorter()); |
| |
| //Set Context menus |
| final MenuManager menuMgr = new MenuManager(); |
| menuMgr.setRemoveAllWhenShown(true); |
| menuMgr.addMenuListener(this); |
| fContextMenu = menuMgr.createContextMenu(fReviewTreeViewer.getTree()); |
| fReviewTreeViewer.getTree().setMenu(fContextMenu); |
| |
| // Register viewer with site. This must be done before making the actions. |
| final IWorkbenchPartSite site = getSite(); |
| site.registerContextMenu(menuMgr, fReviewTreeViewer); |
| site.setSelectionProvider(fReviewTreeViewer); |
| |
| //Set Actions in Action group |
| makeActions(); // call before registering for selection changes |
| |
| //Tie UI listeners |
| hookListeners(); |
| final IEclipsePreferences node = new InstanceScope().getNode(R4EUIPlugin.PLUGIN_ID); |
| node.addPreferenceChangeListener(this); |
| |
| //Set default Tree representation |
| fReviewTreeViewer.setViewTree(); |
| |
| //Apply default filters |
| final IEvaluationService evService = (IEvaluationService) getSite().getWorkbenchWindow().getService( |
| IEvaluationService.class); |
| evService.requestEvaluation(R4EUIConstants.DEFAULT_DISPLAY_COMMAND); |
| applyDefaultFilters(); |
| getTreeViewer().setComparator(null); |
| |
| //Make sure that the User Id in preferences is set to lower case |
| final IPreferenceStore store = R4EUIPlugin.getDefault().getPreferenceStore(); |
| store.setValue(PreferenceConstants.P_USER_ID, store.getString(PreferenceConstants.P_USER_ID).toLowerCase()); |
| |
| //Make sure the Participants Lists map is populated |
| R4EPreferencePage.populateParticipantListMap(); |
| |
| //Make sure Navigator View is enabled at startup |
| R4EUIModelController.setJobInProgress(false); |
| } |
| |
| /** |
| * Method resetInput. |
| */ |
| public void resetInput() { |
| IR4EUIModelElement[] groups = R4EUIModelController.getRootElement().getChildren(); |
| final List<String> openGroupNames = new ArrayList<String>(); |
| for (IR4EUIModelElement group : groups) { |
| if (group.isOpen()) { |
| group.close(); |
| openGroupNames.add(group.getName()); |
| } |
| } |
| |
| //Only set input if the Tree widget is present |
| if (!fReviewTreeViewer.getTree().isDisposed()) { |
| fReviewTreeViewer.setInput(getInitalInput()); |
| } else { |
| return; |
| } |
| |
| //Restore previously open groups |
| groups = R4EUIModelController.getRootElement().getChildren(); |
| for (String groupName : openGroupNames) { |
| for (IR4EUIModelElement group : groups) { |
| if (group.getName().equals(groupName)) { |
| try { |
| group.open(); |
| } catch (ResourceHandlingException e) { |
| UIUtils.displayResourceErrorDialog(e); |
| } catch (FileNotFoundException e) { |
| R4EUIPlugin.Ftracer.traceError("Exception: " + e.toString() + " (" + e.getMessage() + ")"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ |
| R4EUIPlugin.getDefault().logError("Exception: " + e.toString(), e); //$NON-NLS-1$ |
| } catch (CompatibilityException e) { |
| UIUtils.displayCompatibilityErrorDialog(e); |
| } |
| break; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Method setFocus. |
| * |
| * @see org.eclipse.ui.IWorkbenchPart#setFocus() |
| */ |
| @Override |
| public void setFocus() { |
| fReviewTreeViewer.getControl().setFocus(); |
| } |
| |
| /** |
| * Method menuAboutToShow. |
| * |
| * @param aMenuManager |
| * IMenuManager |
| * @see org.eclipse.jface.action.IMenuListener#menuAboutToShow(IMenuManager) |
| */ |
| public void menuAboutToShow(IMenuManager aMenuManager) { |
| fActionSet.setContext(new ActionContext(fReviewTreeViewer.getSelection())); |
| fActionSet.fillContextMenu(aMenuManager); |
| fActionSet.setContext(null); |
| } |
| |
| /** |
| * Get the view's jface tree viewer |
| * |
| * @return the tree viewer |
| */ |
| public TreeViewer getTreeViewer() { |
| return fReviewTreeViewer; |
| } |
| |
| /** |
| * Get the initial input from the R4E model and populate the UI model with it |
| * |
| * @return the root element of the UI model |
| */ |
| public IR4EUIModelElement getInitalInput() { |
| R4EUIModelController.loadModel(); |
| final IR4EUIModelElement rootTreeNode = R4EUIModelController.getRootElement(); |
| rootTreeNode.getChildren(); |
| return rootTreeNode; |
| } |
| |
| /** |
| * Add the listeners to the tree viewer |
| */ |
| protected void hookListeners() { |
| fReviewTreeViewer.addSelectionChangedListener(new ISelectionChangedListener() { // $codepro.audit.disable com.instantiations.assist.eclipse.analysis.avoidInnerClasses |
| public void selectionChanged(SelectionChangedEvent event) { |
| if (event.getSelection() instanceof IStructuredSelection) { |
| final IStructuredSelection selection = (IStructuredSelection) event.getSelection(); |
| if (isPropertiesLinked()) { |
| showProperties(); |
| } |
| |
| if (isEditorLinked()) { |
| IR4EUIModelElement element = (IR4EUIModelElement) selection.getFirstElement(); |
| |
| //Find the parent FileContextElement |
| while (null != element && !(element instanceof R4EUIFileContext)) { |
| element = element.getParent(); |
| } |
| if (null == element) { |
| return; |
| } |
| |
| //Get file reference |
| final R4EFileVersion fileVersion = ((R4EUIFileContext) element).getFileContext().getTarget(); |
| if (null == fileVersion) { |
| return; |
| } |
| |
| final IResource resource = fileVersion.getResource(); |
| if (resource instanceof IFile) { |
| |
| //Get open editors |
| final IEditorReference[] editors = PlatformUI.getWorkbench() |
| .getActiveWorkbenchWindow() |
| .getActivePage() |
| .getEditorReferences(); |
| |
| for (IEditorReference editor : editors) { |
| try { |
| final IEditorInput input = editor.getEditorInput(); |
| if (input instanceof IFileEditorInput) { |
| if (((IFileEditorInput) input).getFile().equals(resource)) { |
| PlatformUI.getWorkbench() |
| .getActiveWorkbenchWindow() |
| .getActivePage() |
| .bringToTop(editor.getPart(true)); |
| break; |
| } |
| } |
| } catch (PartInitException e) { |
| continue; //ignore |
| } |
| } |
| } |
| } |
| } |
| } |
| }); |
| |
| fReviewTreeViewer.addDoubleClickListener(new IDoubleClickListener() { // $codepro.audit.disable com.instantiations.assist.eclipse.analysis.avoidInnerClasses |
| public void doubleClick(DoubleClickEvent event) { |
| R4EUIPlugin.Ftracer.traceInfo("Double-click event received"); //$NON-NLS-1$ |
| |
| final IStructuredSelection selection = (IStructuredSelection) event.getSelection(); |
| final IR4EUIModelElement element = (IR4EUIModelElement) selection.getFirstElement(); |
| if (element instanceof R4EUIReviewBasic || element instanceof R4EUIReviewGroup |
| || element instanceof R4EUIRuleSet) { |
| try { |
| //open or close review if ReviewElement is double-clicked |
| if (element.isEnabled()) { |
| if (element.isOpen()) { |
| ((ReviewNavigatorActionGroup) getActionSet()).closeElementCommand(); |
| } else { |
| ((ReviewNavigatorActionGroup) getActionSet()).openElementCommand(); |
| } |
| } |
| } catch (ExecutionException e) { |
| R4EUIPlugin.Ftracer.traceError("Exception: " + e.toString() + " (" + e.getMessage() + ")"); //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$ |
| R4EUIPlugin.getDefault().logError("Exception: " + e.toString(), e); //$NON-NLS-1$ |
| } catch (NotDefinedException e) { |
| R4EUIPlugin.Ftracer.traceError("Exception: " + e.toString() + " (" + e.getMessage() + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| R4EUIPlugin.getDefault().logError("Exception: " + e.toString(), e); //$NON-NLS-1$ |
| } catch (NotEnabledException e) { |
| R4EUIPlugin.Ftracer.traceError("Exception: " + e.toString() + " (" + e.getMessage() + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| R4EUIPlugin.getDefault().logError("Exception: " + e.toString(), e); //$NON-NLS-1$ |
| } catch (NotHandledException e) { |
| R4EUIPlugin.Ftracer.traceError("Exception: " + e.toString() + " (" + e.getMessage() + ")"); //$NON-NLS-1$ //$NON-NLS-2$//$NON-NLS-3$ |
| R4EUIPlugin.getDefault().logError("Exception: " + e.toString(), e); //$NON-NLS-1$ |
| } |
| } else if (isEditorLinked()) { |
| EditorProxy.openEditor(getSite().getPage(), selection, false); |
| } |
| } |
| }); |
| |
| getSite().getPage().addPartListener(fPartListener = new IPartListener() { |
| |
| public void partOpened(IWorkbenchPart part) { // $codepro.audit.disable emptyMethod |
| // No implementation |
| } |
| |
| public void partDeactivated(IWorkbenchPart part) { // $codepro.audit.disable emptyMethod |
| // No implementation |
| } |
| |
| public void partClosed(IWorkbenchPart part) { // $codepro.audit.disable emptyMethod |
| //Remove Properties View references when it is closed |
| if (part instanceof PropertySheet) { |
| if (((PropertySheet) part).getCurrentPage() == fPropertySheetPage) { |
| fPropertySheetPage = null; |
| } |
| } |
| } |
| |
| public void partBroughtToTop(IWorkbenchPart part) { // $codepro.audit.disable emptyMethod |
| // No implementation |
| } |
| |
| @SuppressWarnings("synthetic-access") |
| public void partActivated(IWorkbenchPart part) { |
| if (isEditorLinked() && part instanceof IEditorPart) { |
| //Check if the part activated is an editor, if so select corresponding |
| //review navigator file context if applicable |
| final IEditorInput input = ((IEditorPart) part).getEditorInput(); |
| if (input instanceof IFileEditorInput) { |
| final IFile editorFile = ((IFileEditorInput) input).getFile(); |
| final IR4EUIModelElement rootElement = R4EUIModelController.getRootElement(); |
| |
| for (IR4EUIModelElement group : rootElement.getChildren()) { |
| for (IR4EUIModelElement review : group.getChildren()) { |
| for (IR4EUIModelElement item : review.getChildren()) { |
| for (final IR4EUIModelElement navigatorFile : item.getChildren()) { |
| if (navigatorFile instanceof R4EUIFileContext) { |
| R4EFileVersion version = ((R4EUIFileContext) navigatorFile).getFileContext() |
| .getTarget(); |
| if (null != version && null != (IFile) version.getResource() |
| && ((IFile) version.getResource()).equals(editorFile)) { |
| |
| //We found the parent fileContext, now check if the selection is already within this branch |
| IR4EUIModelElement selectedElement = (IR4EUIModelElement) ((IStructuredSelection) fReviewTreeViewer.getSelection()).getFirstElement(); |
| IR4EUIModelElement fileContextElement = selectedElement; |
| while (null != fileContextElement |
| && !(fileContextElement instanceof R4EUIFileContext)) { |
| fileContextElement = fileContextElement.getParent(); |
| } |
| if (null != fileContextElement) { |
| if (fileContextElement.equals(navigatorFile)) { |
| return; //Correct selection already set |
| } |
| } |
| //selection to the file context corresponding to the editor input |
| Display.getDefault().asyncExec(new Runnable() { |
| public void run() { |
| while (Display.getDefault().readAndDispatch()) { |
| //wait for events to finish before continue |
| } |
| |
| fReviewTreeViewer.setSelection(new StructuredSelection( |
| navigatorFile), true); |
| } |
| }); |
| return; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| }); |
| } |
| |
| /** |
| * Method showProperties. |
| * |
| * @return IViewPart |
| */ |
| public IViewPart showProperties() { |
| //Force show properties view |
| IViewPart propertiesView = null; |
| try { |
| final IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); |
| propertiesView = page.findView("org.eclipse.ui.views.PropertySheet"); //$NON-NLS-1$ |
| if (!page.isPartVisible(propertiesView)) { |
| //Make sure that the properties view references are updated properly before showing it |
| if (null != fPropertySheetPage) { |
| fPropertySheetPage = null; |
| } |
| getPropertySheetPage(); |
| propertiesView = page.showView("org.eclipse.ui.views.PropertySheet"); //$NON-NLS-1$ |
| } |
| } catch (PartInitException e) { |
| R4EUIPlugin.Ftracer.traceWarning("Exception: " + e.toString() + " (" + e.getMessage() + ")"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ |
| R4EUIPlugin.getDefault().logWarning("Exception: " + e.toString(), e); //$NON-NLS-1$ |
| // Do nothing |
| } |
| return propertiesView; |
| } |
| |
| /** |
| * Create the Action Group associated with the view |
| */ |
| private void makeActions() { |
| fActionSet = new ReviewNavigatorActionGroup(this); |
| final IActionBars actionBars = getViewSite().getActionBars(); |
| fActionSet.fillActionBars(actionBars); |
| } |
| |
| /** |
| * Gets the Action Group |
| * |
| * @return the action group |
| */ |
| public ActionGroup getActionSet() { |
| return fActionSet; |
| } |
| |
| /** |
| * Method preferenceChange. |
| * |
| * @param event |
| * PreferenceChangeEvent |
| * @see org.eclipse.core.runtime.preferences.IEclipsePreferences$IPreferenceChangeListener#preferenceChange(PreferenceChangeEvent) |
| */ |
| public void preferenceChange(org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent event) { |
| |
| if (event.getKey().equals(PreferenceConstants.P_USER_ID)) { |
| //Reset reviewer to current ID |
| final IPreferenceStore store = R4EUIPlugin.getDefault().getPreferenceStore(); |
| R4EUIModelController.setReviewer(store.getString(PreferenceConstants.P_USER_ID)); |
| if (isVisible()) { |
| getTreeViewer().refresh(); |
| } |
| } else if (event.getKey().equals(PreferenceConstants.P_GROUP_FILE_PATH)) { |
| //Check what is currently loaded vs. what is in the preferences. Adjust input accordingly |
| final List<R4EUIReviewGroup> groupsLoaded = Arrays.asList(R4EUIModelController.getRootElement().getGroups()); |
| final List<String> groupsPreferencesPaths = UIUtils.parseStringList((String) event.getNewValue()); |
| |
| //Convert the loaded groups array to array of File Paths |
| final List<String> groupsLoadedPaths = new ArrayList<String>(); |
| IPath path; |
| for (R4EUIReviewGroup group : groupsLoaded) { |
| path = new Path(group.getGroupFile()); |
| groupsLoadedPaths.add(path.toOSString()); |
| } |
| |
| //Groups that are in preferences, but not loaded should be loaded |
| final List<String> result = new ArrayList<String>(); |
| result.addAll(groupsPreferencesPaths); |
| result.removeAll(groupsLoadedPaths); |
| final List<String> groupsToLoad = new ArrayList<String>(); |
| for (String groupToLoad : result) { |
| groupsToLoad.add(groupToLoad); |
| } |
| |
| //Groups that are loaded, but not in preferences should be removed |
| result.clear(); |
| result.addAll(groupsLoadedPaths); |
| result.removeAll(groupsPreferencesPaths); |
| final List<IR4EUIModelElement> groupsToRemove = new ArrayList<IR4EUIModelElement>(); |
| for (R4EUIReviewGroup group : groupsLoaded) { |
| for (String groupPath : result) { |
| path = new Path(group.getGroupFile()); |
| if (groupPath.equals(path.toOSString())) { |
| groupsToRemove.add(group); |
| } |
| } |
| } |
| |
| //Adjust loaded groups |
| for (IR4EUIModelElement groupToRemove : groupsToRemove) { |
| R4EUIModelController.getRootElement().removeChildrenFromUI(groupToRemove); |
| } |
| if (groupsToLoad.size() > 0) { |
| List<String> loadErrors = new ArrayList<String>(); |
| loadErrors = R4EUIModelController.loadReviewGroups(groupsToLoad, loadErrors); |
| |
| //Report elements that failed to load |
| if (loadErrors.size() > 0) { |
| UIUtils.displayFailedLoadDialog(loadErrors); |
| } |
| } |
| Display.getDefault().syncExec(new Runnable() { |
| public void run() { |
| //test if the tree is disposed first |
| if (!fReviewTreeViewer.getControl().isDisposed()) { |
| fReviewTreeViewer.refresh(); |
| } else { |
| R4EUIPlugin.Ftracer.traceWarning("Exception: " + "preferenceChange() R4E Tree viewer is DISPOSED , Group path "); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| } |
| }); |
| } else if (event.getKey().equals(PreferenceConstants.P_RULE_SET_FILE_PATH)) { |
| //Check what is currently loaded vs. what is in the preferences. Adjust input accordingly |
| final List<R4EUIRuleSet> ruleSetsLoaded = R4EUIModelController.getRootElement().getRuleSets(); |
| final List<String> ruleSetsPreferencesPaths = UIUtils.parseStringList((String) event.getNewValue()); |
| |
| //Convert the loaded rule set array to array of File Paths |
| final List<String> ruleSetsLoadedPaths = new ArrayList<String>(); |
| IPath path; |
| for (R4EUIRuleSet ruleSet : ruleSetsLoaded) { |
| path = new Path(ruleSet.getRuleSetFile()); |
| ruleSetsLoadedPaths.add(path.toOSString()); |
| } |
| |
| //Rule Sets that are in preferences, but not loaded should be loaded |
| final List<String> result = new ArrayList<String>(); |
| result.addAll(ruleSetsPreferencesPaths); |
| result.removeAll(ruleSetsLoadedPaths); |
| final List<String> ruleSetsToLoad = new ArrayList<String>(); |
| for (String ruleSetToLoad : result) { |
| ruleSetsToLoad.add(ruleSetToLoad); |
| } |
| |
| //Rule Sets that are loaded, but not in preferences should be removed |
| result.clear(); |
| result.addAll(ruleSetsLoadedPaths); |
| result.removeAll(ruleSetsPreferencesPaths); |
| final List<IR4EUIModelElement> ruleSetsToRemove = new ArrayList<IR4EUIModelElement>(); |
| for (IR4EUIModelElement ruleSet : ruleSetsLoaded) { |
| for (String ruleSetPath : result) { |
| path = new Path(((R4EUIRuleSet) ruleSet).getRuleSetFile()); |
| if (ruleSetPath.equals(path.toOSString())) { |
| ruleSetsToRemove.add(ruleSet); |
| } |
| } |
| } |
| |
| //Adjust loaded groups |
| for (IR4EUIModelElement ruleSetToRemove : ruleSetsToRemove) { |
| R4EUIModelController.getRootElement().removeChildrenFromUI(ruleSetToRemove); |
| } |
| if (ruleSetsToLoad.size() > 0) { |
| List<String> loadErrors = new ArrayList<String>(); |
| loadErrors = R4EUIModelController.loadRuleSets(ruleSetsToLoad, loadErrors); |
| |
| //Report elements that failed to load |
| if (loadErrors.size() > 0) { |
| UIUtils.displayFailedLoadDialog(loadErrors); |
| } |
| } |
| Display.getDefault().syncExec(new Runnable() { |
| public void run() { |
| //test if the tree is disposed first |
| if (!fReviewTreeViewer.getControl().isDisposed()) { |
| fReviewTreeViewer.refresh(); |
| } else { |
| R4EUIPlugin.Ftracer.traceWarning("Exception: " + "preferenceChange() R4E Tree viewer is DISPOSED , RULES SET PATH "); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| } |
| }); |
| |
| } else if (event.getKey().equals(PreferenceConstants.P_SHOW_DISABLED)) { |
| resetInput(); //TODO This needs to be changed to not reload the model all the time |
| } |
| |
| } |
| |
| /** |
| * Method applyDefaultFilters. |
| */ |
| public void applyDefaultFilters() { |
| final IPreferenceStore store = R4EUIPlugin.getDefault().getPreferenceStore(); |
| try { |
| ((ReviewNavigatorActionGroup) fActionSet).resetAllFilterActions(); |
| ((ReviewNavigatorActionGroup) fActionSet).runReviewsCompletedFilterCommand(store.getBoolean(PreferenceConstants.P_REVIEWS_COMPLETED_FILTER)); |
| ((ReviewNavigatorActionGroup) fActionSet).runReviewsOnlyFilterCommand(store.getBoolean(PreferenceConstants.P_REVIEWS_ONLY_FILTER)); |
| ((ReviewNavigatorActionGroup) fActionSet).runReviewsMyFilterCommand(store.getBoolean(PreferenceConstants.P_REVIEWS_MY_FILTER)); |
| ((ReviewNavigatorActionGroup) fActionSet).runReviewsParticipantFilterCommand(store.getString(PreferenceConstants.P_PARTICIPANT_FILTER)); |
| ((ReviewNavigatorActionGroup) fActionSet).runAssignedMyFilterCommand(store.getBoolean(PreferenceConstants.P_ASSIGN_MY_FILTER)); |
| ((ReviewNavigatorActionGroup) fActionSet).runAssignedParticipantFilterCommand(store.getString(PreferenceConstants.P_ASSIGN_FILTER)); |
| ((ReviewNavigatorActionGroup) fActionSet).runUnassignedFilterCommand(store.getBoolean(PreferenceConstants.P_UNASSIGN_FILTER)); |
| ((ReviewNavigatorActionGroup) fActionSet).runAnomaliesFilterCommand(store.getBoolean(PreferenceConstants.P_ANOMALIES_ALL_FILTER)); |
| ((ReviewNavigatorActionGroup) fActionSet).runAnomaliesMyFilterCommand(store.getBoolean(PreferenceConstants.P_ANOMALIES_MY_FILTER)); |
| ((ReviewNavigatorActionGroup) fActionSet).runReviewElemsFilterCommand(store.getBoolean(PreferenceConstants.P_REVIEWED_ITEMS_FILTER)); |
| ((ReviewNavigatorActionGroup) fActionSet).runHideRuleSetsFilterCommand(store.getBoolean(PreferenceConstants.P_HIDE_RULE_SETS_FILTER)); |
| ((ReviewNavigatorActionGroup) fActionSet).runHideDeltasFilterCommand(store.getBoolean(PreferenceConstants.P_HIDE_DELTAS_FILTER)); |
| getTreeViewer().setComparator(new DateComparator()); |
| } catch (ExecutionException e) { |
| R4EUIPlugin.Ftracer.traceError("Exception: " + e.toString() + " (" + e.getMessage() + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| R4EUIPlugin.getDefault().logError("Exception: " + e.toString(), e); //$NON-NLS-1$ |
| } catch (NotDefinedException e) { |
| R4EUIPlugin.Ftracer.traceError("Exception: " + e.toString() + " (" + e.getMessage() + ")"); //$NON-NLS-1$ //$NON-NLS-2$//$NON-NLS-3$ |
| R4EUIPlugin.getDefault().logError("Exception: " + e.toString(), e); //$NON-NLS-1$ |
| } catch (NotEnabledException e) { |
| R4EUIPlugin.Ftracer.traceError("Exception: " + e.toString() + " (" + e.getMessage() + ")"); //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$ |
| R4EUIPlugin.getDefault().logError("Exception: " + e.toString(), e); //$NON-NLS-1$ |
| } catch (NotHandledException e) { |
| R4EUIPlugin.Ftracer.traceError("Exception: " + e.toString() + " (" + e.getMessage() + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| R4EUIPlugin.getDefault().logError("Exception: " + e.toString(), e); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * Method getAdapter. |
| * |
| * @param adapter |
| * Class |
| * @return Object |
| * @see org.eclipse.core.runtime.IAdaptable#getAdapter(Class) |
| */ |
| @Override |
| public Object getAdapter(@SuppressWarnings("rawtypes") |
| Class adapter) { |
| if (adapter.equals(IPropertySheetPage.class)) { |
| return getPropertySheetPage(); |
| } |
| return super.getAdapter(adapter); |
| } |
| |
| /** |
| * Method getPropertySheetPage. |
| * |
| * @return TabbedPropertySheetPage |
| */ |
| public TabbedPropertySheetPage getPropertySheetPage() { |
| if (null == fPropertySheetPage || null == fPropertySheetPage.getControl() |
| || null == fPropertySheetPage.getCurrentTab()) { |
| fPropertySheetPage = new TabbedPropertySheetPage(this); |
| } |
| return fPropertySheetPage; |
| } |
| |
| /** |
| * Method getContributorId. |
| * |
| * @return String |
| * @see org.eclipse.ui.views.properties.tabbed.ITabbedPropertySheetPageContributor#getContributorId() |
| */ |
| public String getContributorId() { |
| return getSite().getId(); |
| } |
| |
| /** |
| * Method propertyChanged. |
| * |
| * @param source |
| * Object |
| * @param propId |
| * int |
| * @see org.eclipse.ui.IPropertyListener#propertyChanged(Object, int) |
| */ |
| public void propertyChanged(Object source, int propId) { |
| ((ReviewNavigatorActionGroup) fActionSet).dialogOpenNotify(); |
| } |
| |
| /** |
| * Method updateView. Set focus to current view/element |
| * |
| * @param aElement |
| * R4EUIModelElement |
| * @param aExpandLevel |
| * int |
| */ |
| public void updateView(final IR4EUIModelElement aElement, final int aExpandLevel) { |
| Display.getDefault().syncExec(new Runnable() { |
| public void run() { |
| //Activate View |
| getSite().getPage().activate(R4EUIModelController.getNavigatorView()); |
| |
| //Set selection to current element |
| fReviewTreeViewer.expandToLevel(aElement, aExpandLevel); |
| fReviewTreeViewer.refresh(); //Make sure tree is refreshed |
| |
| //NOTE: This is a trick to get around TabbedPropertySheetPage problems, we unselect the current selection and |
| // then immediately select it back. This makes sure the Properties view is |
| // refreshed properly without causing Exceptions |
| fReviewTreeViewer.setSelection(null); |
| final ISelection newSelection = new StructuredSelection(aElement); |
| fReviewTreeViewer.setSelection(newSelection, true); |
| } |
| }); |
| } |
| |
| /** |
| * Method refreshItems. Refresh view elements states |
| */ |
| public void refreshItems() { |
| //Toolbar items |
| IContributionItem[] items = R4EUIModelController.getNavigatorView() |
| .getViewSite() |
| .getActionBars() |
| .getToolBarManager() |
| .getItems(); |
| for (IContributionItem item : items) { |
| item.update(); |
| } |
| |
| //Menu items |
| MenuManager menu = (MenuManager) R4EUIModelController.getNavigatorView() |
| .getViewSite() |
| .getActionBars() |
| .getMenuManager(); |
| menu.updateAll(true); |
| } |
| } |
