| /******************************************************************************* |
| * Copyright (c) 2004 - 2006 University Of British Columbia 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: |
| * University Of British Columbia - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.mylar.provisional.ui; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.MissingResourceException; |
| import java.util.ResourceBundle; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IConfigurationElement; |
| import org.eclipse.core.runtime.IExtension; |
| import org.eclipse.core.runtime.IExtensionPoint; |
| import org.eclipse.core.runtime.IExtensionRegistry; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.text.TextSelection; |
| import org.eclipse.jface.viewers.ILabelProvider; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.mylar.internal.core.util.MylarStatusHandler; |
| import org.eclipse.mylar.internal.tasklist.ui.ITaskHighlighter; |
| import org.eclipse.mylar.internal.ui.AbstractContextLabelProvider; |
| import org.eclipse.mylar.internal.ui.ColorMap; |
| import org.eclipse.mylar.internal.ui.ContentOutlineManager; |
| import org.eclipse.mylar.internal.ui.Highlighter; |
| import org.eclipse.mylar.internal.ui.HighlighterList; |
| import org.eclipse.mylar.internal.ui.MylarUiPrefContstants; |
| import org.eclipse.mylar.internal.ui.MylarViewerManager; |
| import org.eclipse.mylar.provisional.core.IMylarElement; |
| import org.eclipse.mylar.provisional.core.IMylarRelation; |
| import org.eclipse.mylar.provisional.core.MylarPlugin; |
| import org.eclipse.mylar.provisional.tasklist.ITask; |
| import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.plugin.AbstractUIPlugin; |
| import org.osgi.framework.BundleContext; |
| |
| /** |
| * @author Mik Kersten |
| */ |
| public class MylarUiPlugin extends AbstractUIPlugin { |
| |
| public static final String PLUGIN_ID = "org.eclipse.mylar.ui"; |
| |
| private Map<String, IMylarUiBridge> bridges = new HashMap<String, IMylarUiBridge>(); |
| |
| private Map<String, ILabelProvider> contextLabelProviders = new HashMap<String, ILabelProvider>(); |
| |
| private static MylarUiPlugin plugin; |
| |
| private ResourceBundle resourceBundle; |
| |
| private boolean decorateInterestMode = false; |
| |
| private HighlighterList highlighters = null; |
| |
| private Highlighter intersectionHighlighter; |
| |
| private ColorMap colorMap = new ColorMap(); |
| |
| private MylarViewerManager viewerManager = new MylarViewerManager(); |
| |
| private ContentOutlineManager contentOutlineManager = new ContentOutlineManager(); |
| |
| private final ITaskHighlighter DEFAULT_HIGHLIGHTER = new ITaskHighlighter() { |
| public Color getHighlightColor(ITask task) { |
| Highlighter highlighter = getHighlighterForContextId("" + task.getHandleIdentifier()); |
| if (highlighter != null) { |
| return highlighter.getHighlightColor(); |
| } else { |
| return null; |
| } |
| } |
| }; |
| |
| private static final AbstractContextLabelProvider DEFAULT_LABEL_PROVIDER = new AbstractContextLabelProvider() { |
| |
| @Override |
| protected Image getImage(IMylarElement node) { |
| return null; |
| } |
| |
| @Override |
| protected Image getImage(IMylarRelation edge) { |
| return null; |
| } |
| |
| @Override |
| protected String getText(IMylarElement node) { |
| return "? " + node; |
| } |
| |
| @Override |
| protected String getText(IMylarRelation edge) { |
| return "? " + edge; |
| } |
| |
| @Override |
| protected Image getImageForObject(Object object) { |
| return null; |
| } |
| |
| @Override |
| protected String getTextForObject(Object node) { |
| return "? " + node; |
| } |
| |
| }; |
| |
| private static final IMylarUiBridge DEFAULT_UI_BRIDGE = new IMylarUiBridge() { |
| |
| public void open(IMylarElement node) { |
| // ignore |
| } |
| |
| public void close(IMylarElement node) { |
| // ignore |
| } |
| |
| public boolean acceptsEditor(IEditorPart editorPart) { |
| return false; |
| } |
| |
| public List<TreeViewer> getContentOutlineViewers(IEditorPart editor) { |
| return Collections.emptyList(); |
| } |
| |
| public Object getObjectForTextSelection(TextSelection selection, IEditorPart editor) { |
| return null; |
| } |
| |
| public void restoreEditor(IMylarElement document) { |
| // ignore |
| } |
| |
| public void setContextCapturePaused(boolean paused) { |
| // ignore |
| } |
| |
| public IMylarElement getElement(IEditorInput input) { |
| return null; |
| } |
| }; |
| |
| public MylarUiPlugin() { |
| super(); |
| plugin = this; |
| try { |
| resourceBundle = ResourceBundle.getBundle("org.eclipse.mylar.MylarUiPluginResources"); |
| } catch (MissingResourceException x) { |
| resourceBundle = null; |
| } catch (Throwable t) { |
| MylarStatusHandler.log(t, "plug-in intialization failed"); |
| } |
| initializeHighlighters(); |
| initializeDefaultPreferences(getPrefs()); |
| initializeActions(); |
| } |
| |
| // public void earlyStartup() { |
| // } |
| |
| @Override |
| public void start(BundleContext context) throws Exception { |
| super.start(context); |
| final IWorkbench workbench = PlatformUI.getWorkbench(); |
| workbench.getDisplay().asyncExec(new Runnable() { |
| public void run() { |
| try { |
| // TODO: move to MylarPlugin? |
| PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell().addShellListener( |
| MylarPlugin.getContextManager().getShellLifecycleListener()); |
| MylarPlugin.getContextManager().addListener(viewerManager); |
| |
| MylarPlugin.getDefault().addWindowPartListener(contentOutlineManager); |
| // MylarPlugin.getDefault().addWindowPageListener(contentOutlineManager); |
| |
| // if (ApplyMylarToOutlineAction.getDefault() != null) |
| // ApplyMylarToOutlineAction.getDefault().update(); |
| MylarTaskListPlugin.getDefault().setHighlighter(DEFAULT_HIGHLIGHTER); |
| } catch (Exception e) { |
| MylarStatusHandler.fail(e, "Mylar UI initialization failed", true); |
| } |
| } |
| }); |
| } |
| |
| /** |
| * This method is called when the plug-in is stopped |
| */ |
| @Override |
| public void stop(BundleContext context) throws Exception { |
| try { |
| super.stop(context); |
| MylarPlugin.getContextManager().removeListener(viewerManager); |
| MylarPlugin.getDefault().removeWindowPartListener(contentOutlineManager); |
| // MylarPlugin.getDefault().removeWindowPageListener(contentOutlineManager); |
| viewerManager.dispose(); |
| colorMap.dispose(); |
| highlighters.dispose(); |
| if (PlatformUI.getWorkbench() != null && !PlatformUI.getWorkbench().isClosing()) { |
| PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell().removeShellListener( |
| MylarPlugin.getContextManager().getShellLifecycleListener()); |
| } |
| } catch (Exception e) { |
| MylarStatusHandler.fail(e, "Mylar UI stop failed", false); |
| } |
| } |
| |
| private void initializeActions() { |
| // don't have any actions to initialize |
| } |
| |
| private void initializeHighlighters() { |
| String hlist = getPrefs().getString(MylarUiPrefContstants.HIGHLIGHTER_PREFIX); |
| if (hlist != null && hlist.length() != 0) { |
| highlighters = new HighlighterList(hlist); |
| } else { |
| // Only get here if it is the first time running |
| // mylar. load default colors |
| highlighters = new HighlighterList(); |
| highlighters.setToDefaultList(); |
| getPrefs().setValue(MylarUiPrefContstants.HIGHLIGHTER_PREFIX, this.highlighters.externalizeToString()); |
| } |
| } |
| |
| @Override |
| protected void initializeDefaultPreferences(IPreferenceStore store) { |
| store.setDefault(MylarUiPrefContstants.AUTO_MANAGE_EDITORS, true); |
| store.setDefault(MylarUiPrefContstants.AUTO_MANAGE_EDITORS_OPEN_NUM, 8); |
| |
| store.setDefault(MylarUiPrefContstants.GAMMA_SETTING_LIGHTENED, false); |
| store.setDefault(MylarUiPrefContstants.GAMMA_SETTING_STANDARD, true); |
| store.setDefault(MylarUiPrefContstants.GAMMA_SETTING_DARKENED, false); |
| |
| if (!store.contains(MylarUiPrefContstants.GLOBAL_FILTERING)) |
| store.setDefault(MylarUiPrefContstants.GLOBAL_FILTERING, true); |
| } |
| |
| public void setHighlighterMapping(String id, String name) { |
| String prefId = MylarUiPrefContstants.TASK_HIGHLIGHTER_PREFIX + id; |
| getPrefs().putValue(prefId, name); |
| } |
| |
| /** |
| * Returns the shared instance. |
| */ |
| public static MylarUiPlugin getDefault() { |
| return plugin; |
| } |
| |
| public static IPreferenceStore getPrefs() { |
| return MylarPlugin.getDefault().getPreferenceStore(); |
| } |
| |
| /** |
| * Returns the string from the plugin's resource bundle, or 'key' if not |
| * found. |
| */ |
| public static String getResourceString(String key) { |
| ResourceBundle bundle = MylarUiPlugin.getDefault().getResourceBundle(); |
| try { |
| return (bundle != null) ? bundle.getString(key) : key; |
| } catch (MissingResourceException e) { |
| return key; |
| } |
| } |
| |
| /** |
| * Returns the string from the plugin's resource bundle, or 'key' if not |
| * found. |
| */ |
| public static String getMessage(String key) { |
| ResourceBundle bundle = getDefault().getResourceBundle(); |
| try { |
| return (bundle != null) ? bundle.getString(key) : key; |
| } catch (MissingResourceException e) { |
| return key; |
| } |
| } |
| |
| /** |
| * Returns the plugin's resource bundle, |
| */ |
| public ResourceBundle getResourceBundle() { |
| return resourceBundle; |
| } |
| |
| public boolean isDecorateInterestMode() { |
| return decorateInterestMode; |
| } |
| |
| public void setDecorateInterestMode(boolean decorateInterestLevel) { |
| this.decorateInterestMode = decorateInterestLevel; |
| } |
| |
| public List<IMylarUiBridge> getUiBridges() { |
| return new ArrayList<IMylarUiBridge>(bridges.values()); |
| } |
| |
| /** |
| * @return the corresponding adapter if found, or an adapter with no |
| * behavior otherwise (so null is never returned) |
| */ |
| public IMylarUiBridge getUiBridge(String contentType) { |
| if (!UiExtensionPointReader.extensionsRead) |
| UiExtensionPointReader.initExtensions(); |
| IMylarUiBridge bridge = bridges.get(contentType); |
| if (bridge != null) { |
| return bridge; |
| } else { |
| return DEFAULT_UI_BRIDGE; |
| } |
| } |
| |
| /** |
| * TODO: cache this to improve performance? |
| */ |
| public IMylarUiBridge getUiBridgeForEditor(IEditorPart editorPart) { |
| if (!UiExtensionPointReader.extensionsRead) |
| UiExtensionPointReader.initExtensions(); |
| IMylarUiBridge foundBridge = null; |
| for (IMylarUiBridge bridge : bridges.values()) { |
| if (bridge.acceptsEditor(editorPart)) { |
| foundBridge = bridge; |
| break; |
| } |
| } |
| if (foundBridge != null) { |
| return foundBridge; |
| } else { |
| return DEFAULT_UI_BRIDGE; |
| } |
| } |
| |
| private void internalAddBridge(String extension, IMylarUiBridge bridge) { |
| this.bridges.put(extension, bridge); |
| } |
| |
| public ILabelProvider getContextLabelProvider(String extension) { |
| if (!UiExtensionPointReader.extensionsRead) |
| UiExtensionPointReader.initExtensions(); |
| ILabelProvider provider = contextLabelProviders.get(extension); |
| if (provider != null) { |
| return provider; |
| } else { |
| return DEFAULT_LABEL_PROVIDER; |
| } |
| } |
| |
| private void internalAddContextLabelProvider(String extension, ILabelProvider provider) { |
| this.contextLabelProviders.put(extension, provider); |
| } |
| |
| public void updateGammaSetting(ColorMap.GammaSetting setting) { |
| if (colorMap.getGammaSetting() != setting) { |
| highlighters.updateHighlighterWithGamma(colorMap.getGammaSetting(), setting); |
| colorMap.setGammaSetting(setting); |
| } |
| } |
| |
| public ColorMap getColorMap() { |
| return colorMap; |
| } |
| |
| public Highlighter getDefaultHighlighter() { |
| return HighlighterList.DEFAULT_HIGHLIGHTER; |
| } |
| |
| /** |
| * @return null if not found |
| */ |
| public Highlighter getHighlighter(String name) { |
| if (highlighters == null) { |
| this.initializeHighlighters(); |
| } |
| return highlighters.getHighlighter(name); |
| } |
| |
| public Highlighter getHighlighterForContextId(String id) { |
| String prefId = MylarUiPrefContstants.TASK_HIGHLIGHTER_PREFIX + id; |
| String highlighterName = getPrefs().getString(prefId); |
| return getHighlighter(highlighterName); |
| } |
| |
| public HighlighterList getHighlighterList() { |
| if (this.highlighters == null) { |
| this.initializeHighlighters(); |
| } |
| return this.highlighters; |
| } |
| |
| public List<Highlighter> getHighlighters() { |
| if (highlighters == null) { |
| this.initializeHighlighters(); |
| } |
| return highlighters.getHighlighters(); |
| } |
| |
| public Highlighter getIntersectionHighlighter() { |
| return intersectionHighlighter; |
| } |
| |
| public void setColorMap(ColorMap colorMap) { |
| this.colorMap = colorMap; |
| } |
| |
| public void setIntersectionHighlighter(Highlighter intersectionHighlighter) { |
| this.intersectionHighlighter = intersectionHighlighter; |
| } |
| |
| public boolean isGlobalFoldingEnabled() { |
| return getPrefs().getBoolean(MylarUiPrefContstants.GLOBAL_FILTERING); |
| } |
| |
| public void setGlobalFilteringEnabled(boolean globalFilteringEnabled) { |
| getPrefs().setValue(MylarUiPrefContstants.GLOBAL_FILTERING, globalFilteringEnabled); |
| } |
| |
| public boolean isIntersectionMode() { |
| return getPrefs().getBoolean(MylarUiPrefContstants.INTERSECTION_MODE); |
| } |
| |
| public void setIntersectionMode(boolean isIntersectionMode) { |
| getPrefs().setValue(MylarUiPrefContstants.INTERSECTION_MODE, isIntersectionMode); |
| } |
| |
| public MylarViewerManager getViewerManager() { |
| return viewerManager; |
| } |
| |
| static class UiExtensionPointReader { |
| |
| private static boolean extensionsRead = false; |
| |
| private static UiExtensionPointReader thisReader = new UiExtensionPointReader(); |
| |
| // read the extensions and load the required plugins |
| public static void initExtensions() { |
| // code from "contributing to eclipse" with modifications for |
| // deprecated code |
| if (!extensionsRead) { |
| IExtensionRegistry registry = Platform.getExtensionRegistry(); |
| IExtensionPoint extensionPoint = registry |
| .getExtensionPoint(UiExtensionPointReader.EXTENSION_ID_CONTEXT); |
| IExtension[] extensions = extensionPoint.getExtensions(); |
| for (int i = 0; i < extensions.length; i++) { |
| IConfigurationElement[] elements = extensions[i].getConfigurationElements(); |
| for (int j = 0; j < elements.length; j++) { |
| if (elements[j].getName().compareTo(UiExtensionPointReader.ELEMENT_UI_BRIDGE) == 0) { |
| readBridge(elements[j]); |
| } else if (elements[j].getName().compareTo( |
| UiExtensionPointReader.ELEMENT_UI_CONTEXT_LABEL_PROVIDER) == 0) { |
| readLabelProvider(elements[j]); |
| } |
| } |
| } |
| extensionsRead = true; |
| } |
| } |
| |
| private static void readLabelProvider(IConfigurationElement element) { |
| try { |
| Object provider = element.createExecutableExtension(UiExtensionPointReader.ELEMENT_UI_CLASS); |
| Object contentType = element.getAttribute(UiExtensionPointReader.ELEMENT_UI_BRIDGE_CONTENT_TYPE); |
| if (provider instanceof ILabelProvider && contentType != null) { |
| MylarUiPlugin.getDefault().internalAddContextLabelProvider((String) contentType, |
| (ILabelProvider) provider); |
| } else { |
| MylarStatusHandler.log("Could not load label provider: " + provider.getClass().getCanonicalName() |
| + " must implement " + ILabelProvider.class.getCanonicalName(), thisReader); |
| } |
| } catch (CoreException e) { |
| MylarStatusHandler.log(e, "Could not load label provider extension"); |
| } |
| } |
| |
| private static void readBridge(IConfigurationElement element) { |
| try { |
| Object bridge = element.createExecutableExtension(UiExtensionPointReader.ELEMENT_UI_CLASS); |
| Object contentType = element.getAttribute(UiExtensionPointReader.ELEMENT_UI_BRIDGE_CONTENT_TYPE); |
| if (bridge instanceof IMylarUiBridge && contentType != null) { |
| MylarUiPlugin.getDefault().internalAddBridge((String) contentType, (IMylarUiBridge) bridge); |
| } else { |
| MylarStatusHandler.log("Could not load bridge: " + bridge.getClass().getCanonicalName() |
| + " must implement " + IMylarUiBridge.class.getCanonicalName(), thisReader); |
| } |
| } catch (CoreException e) { |
| MylarStatusHandler.log(e, "Could not load bridge extension"); |
| } |
| } |
| |
| public static final String EXTENSION_ID_CONTEXT = "org.eclipse.mylar.ui.context"; |
| |
| public static final String ELEMENT_UI_BRIDGE = "uiBridge"; |
| |
| public static final String ELEMENT_UI_CLASS = "class"; |
| |
| public static final String ELEMENT_UI_CONTEXT_LABEL_PROVIDER = "labelProvider"; |
| |
| public static final String ELEMENT_UI_BRIDGE_CONTENT_TYPE = "contentType"; |
| } |
| } |
