//------------------------------------------------------------------------------
// Copyright (c) 2005, 2007 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 implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.library.ui;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import org.eclipse.core.resources.WorkspaceJob;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.JobChangeAdapter;
import org.eclipse.epf.common.service.utils.CommandLineRunUtil;
import org.eclipse.epf.common.utils.FileUtil;
import org.eclipse.epf.common.utils.I18nUtil;
import org.eclipse.epf.common.utils.NetUtil;
import org.eclipse.epf.common.utils.StrUtil;
import org.eclipse.epf.library.ILibraryManager;
import org.eclipse.epf.library.LibraryPlugin;
import org.eclipse.epf.library.LibraryService;
import org.eclipse.epf.library.LibraryServiceException;
import org.eclipse.epf.library.LibraryServiceUtil;
import org.eclipse.epf.library.configuration.ConfigurationHelper;
import org.eclipse.epf.library.edit.ui.UserInteractionHelper;
import org.eclipse.epf.library.edit.util.DebugUtil;
import org.eclipse.epf.library.edit.util.IRunnableWithProgress;
import org.eclipse.epf.library.layout.LayoutResources;
import org.eclipse.epf.library.persistence.ILibraryResourceSet;
import org.eclipse.epf.library.preferences.LibraryPreferences;
import org.eclipse.epf.library.prefs.PreferenceUtil;
import org.eclipse.epf.library.services.SafeUpdateController;
import org.eclipse.epf.library.ui.actions.ConfigurationContributionItem;
import org.eclipse.epf.library.ui.dialogs.CopyLibraryDialog;
import org.eclipse.epf.library.ui.preferences.LibraryUIPreferences;
import org.eclipse.epf.library.ui.wizards.LibraryBackupUtil;
import org.eclipse.epf.library.xmi.XMILibraryManager;
import org.eclipse.epf.library.xmi.XMILibraryUtil;
import org.eclipse.epf.persistence.MultiFileSaveUtil;
import org.eclipse.epf.persistence.migration.MappingUtil;
import org.eclipse.epf.persistence.migration.UpgradeCallerInfo;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.MethodLibrary;
import org.eclipse.epf.uma.util.MessageException;
import org.eclipse.jface.action.CoolBarManager;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.ICoolBarManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.ToolBarContributionItem;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.window.ApplicationWindow;
import org.eclipse.osgi.service.datalocation.Location;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IPartListener2;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IPerspectiveListener;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.WorkspaceModifyOperation;
import org.eclipse.ui.progress.WorkbenchJob;
/**
* The default Library UI Manager implementation.
* <p>
* A Library Manager provides the user interface for creating and opening a
* method library.
*
* @author Kelvin Low
* @author Phong Nguyen Le
* @since 1.0
*/
public class LibraryUIManager {
public static boolean DEBUG = LibraryUIPlugin.getDefault().isDebugging();
public static final String TOOLBAR_CONFIG_CONTRIBUTION_ID = "toolbar.config.contribution"; //$NON-NLS-1$
private static final String CONFIG_VIEW_ID = "org.eclipse.epf.authoring.ui.views.ConfigurationView"; //$NON-NLS-1$
private static final String PROCESS_EDITOR_ID = "org.eclipse.epf.authoring.ui.editors.ProcessEditor"; //$NON-NLS-1$
private static final String REPORT_PERS_ID = "org.eclipse.birt.report.designer.ui.ReportPerspective"; //$NON-NLS-1$
private static LibraryUIManager instance = null;
private static boolean skipInstallPathCheck = false;
// The URI of the method library that will be opened regardless of the
// saved library preferences.
protected static URI libraryURI;
// The URI of the method library that will be opened only if there are
// no saved library preferences.
protected static URI defaultLibraryURI;
protected static URI defaultLibraryURI_NL;
private boolean libraryInitialized = false;
protected ConfigurationContributionItem configCombo = null;
/**
* Returns the singleton instance.
*/
public static LibraryUIManager getInstance() {
if (instance == null) {
synchronized (LibraryUIManager.class) {
if (instance == null) {
instance = new LibraryUIManager();
}
}
}
return instance;
}
/**
* Private default constructor to prevent this class from being
* instantiated.
*/
private LibraryUIManager() {
// Monitor perspective changes to display/hide the configuration combo.
IWorkbenchWindow window = PlatformUI.getWorkbench()
.getActiveWorkbenchWindow();
if (DebugUtil.uiDebug) {
DebugUtil.print("LibraryUIManager() called, window: " + window);//$NON-NLS-1$
DebugUtil.print();
}
if (window != null) {
window.addPerspectiveListener(new IPerspectiveListener() {
public void perspectiveActivated(IWorkbenchPage page,
IPerspectiveDescriptor desc) {
checkConfigurationContribution();
}
public void perspectiveChanged(IWorkbenchPage page,
IPerspectiveDescriptor desc, String id) {
checkConfigurationContribution();
}
});
}
}
/**
* Creates and opens a new method library.
*
* @param path
* the method library path
* @return <code>true</code> if the method library is created and opened
* successfully
*/
public boolean createLibrary(String path) {
try {
File libraryPath = new File(path);
if (!libraryPath.exists()) {
libraryPath.mkdirs();
}
XMILibraryUtil.createMethodLibrary(libraryPath.getName(), path);
LibraryUIPreferences.setSavedLibraryPath(path);
return true;
} catch (Exception e) {
return false;
}
}
/**
* Opens the last opened method library in a non-UI job. If successful,
* successRunnable will be run, otherwise nextRunnable will be run.
*
* @param path
* URI path to a method library
* @return <code>true</code> if the method library is opened successfully
*/
private void openLastOpenedLibrary(final Runnable successRunnable, final Runnable nextRunnable) {
try {
// first check for saved lib in preference
// so that we don't show progress monitor if there's no lib
String savedMethodLibraryURI = LibraryPreferences
.getSavedMethodLibraryURI();
URI uri = new URI(savedMethodLibraryURI);
if (uri.getPath().length() == 0) {
nextRunnable.run();
return;
}
final WorkspaceJob openLibraryJob = new WorkspaceJob("Open last opened library") {
@Override
public IStatus runInWorkspace(IProgressMonitor monitor)
throws CoreException {
try {
monitor.beginTask(StrUtil.EMPTY_STRING, IProgressMonitor.UNKNOWN);
LibraryService.getInstance().closeCurrentMethodLibrary();
LibraryService.getInstance().openLastOpenedMethodLibrary();
} catch (Exception e) {
LibraryUIPlugin.getDefault().getLogger().logError(e);
}
return Status.OK_STATUS;
}
};
BusyIndicatorHelper.setUserInterfaceActive(false);
final Integer openLibraryJobBusyId = BusyIndicatorHelper.showWhile(PlatformUI.getWorkbench().getDisplay());
PlatformUI.getWorkbench().getProgressService().showInDialog(null, openLibraryJob);
openLibraryJob.setSystem(true);
openLibraryJob.addJobChangeListener(new JobChangeAdapter() {
@Override
public void done(IJobChangeEvent event) {
// UI activation job
WorkbenchJob reactivateUIJob = new WorkbenchJob(StrUtil.EMPTY_STRING) {
@Override
public IStatus runInUIThread(IProgressMonitor monitor) {
BusyIndicatorHelper.setUserInterfaceActive(true);
BusyIndicatorHelper.hideWhile(PlatformUI.getWorkbench().getDisplay(), openLibraryJobBusyId);
// Show Problems View if necessary.
ILibraryManager libMgr = LibraryService
.getInstance().getCurrentLibraryManager();
if(libMgr != null) {
ILibraryResourceSet resourceSet = (ILibraryResourceSet) libMgr.getEditingDomain().getResourceSet();
if (resourceSet.hasUnresolvedProxy()) {
try {
PlatformUI
.getWorkbench()
.getActiveWorkbenchWindow()
.getActivePage()
.showView(
"org.eclipse.ui.views.ProblemView", null, IWorkbenchPage.VIEW_VISIBLE); //$NON-NLS-1$
} catch (Exception e) {
LibraryUIPlugin.getDefault().getLogger()
.logError(e);
}
}
}
return Status.OK_STATUS;
}
};
reactivateUIJob.setSystem(true);
reactivateUIJob.schedule();
if(LibraryService.getInstance().getCurrentMethodLibrary() != null) {
successRunnable.run();
} else {
nextRunnable.run();
}
}
});
openLibraryJob.schedule();
} catch (Exception e) {
// don't do anything
LibraryUIPlugin.getDefault().getLogger().logError(e);
}
}
/**
* Opens a method library with the specified library path URI in a non-UI
* job. If successful, successRunnable will be run, otherwise nextRunnable
* will be run.
*
* @param path
* URI path to a method library
* @return <code>true</code> if the method library is opened successfully
*/
private void openLibrary(final URI uri, final Runnable successRunnable, final Runnable nextRunnable) {
if(uri == null) {
if (nextRunnable != null) {
nextRunnable.run();
}
return;
}
final Map<String, Object> args = new HashMap<String, Object>();
args.put(XMILibraryManager.ARG_LIBRARY_PATH, new File(uri).getAbsolutePath());
final List<Exception> errors = new ArrayList<Exception>();
WorkspaceJob openLibraryJob = new WorkspaceJob(LibraryUIResources.openingLibraryTask_name) {
@Override
public IStatus runInWorkspace(IProgressMonitor monitor)
throws CoreException {
try {
monitor.beginTask(StrUtil.EMPTY_STRING, IProgressMonitor.UNKNOWN);
LibraryService.getInstance().closeCurrentMethodLibrary();
String newPath = handleLibraryOnReadOnlyInstallPath(uri);
if (newPath != null) {
args.put(XMILibraryManager.ARG_LIBRARY_PATH, newPath);
}
MethodLibrary library = LibraryService.getInstance()
.openMethodLibrary(XMILibraryManager.LIBRARY_TYPE, args);
LibraryService.getInstance().setCurrentMethodLibrary(
library);
String path = (String) args.get(XMILibraryManager.ARG_LIBRARY_PATH);
LibraryUIPreferences.setSavedLibraryPath(path);
} catch (LibraryServiceException e) {
errors.add(e);
} finally {
monitor.done();
}
return Status.OK_STATUS;
}
};
openLibraryJob.setSystem(true);
final Integer openLibraryJobBusyId = BusyIndicatorHelper.showWhile(PlatformUI.getWorkbench().getDisplay());
BusyIndicatorHelper.setUserInterfaceActive(false);
PlatformUI.getWorkbench().getProgressService().showInDialog(null, openLibraryJob);
openLibraryJob.addJobChangeListener(new JobChangeAdapter() {
@Override
public void done(IJobChangeEvent event) {
// UI activation job
WorkbenchJob reactivateUIJob = new WorkbenchJob(StrUtil.EMPTY_STRING) {
@Override
public IStatus runInUIThread(IProgressMonitor monitor) {
BusyIndicatorHelper.setUserInterfaceActive(true);
BusyIndicatorHelper.hideWhile(PlatformUI.getWorkbench().getDisplay(), openLibraryJobBusyId);
// Show Problems View if necessary.
ILibraryManager libMgr = LibraryService
.getInstance().getCurrentLibraryManager();
if(libMgr != null) {
ILibraryResourceSet resourceSet = (ILibraryResourceSet) libMgr.getEditingDomain().getResourceSet();
if (resourceSet.hasUnresolvedProxy()) {
try {
PlatformUI
.getWorkbench()
.getActiveWorkbenchWindow()
.getActivePage()
.showView(
"org.eclipse.ui.views.ProblemView", null, IWorkbenchPage.VIEW_VISIBLE); //$NON-NLS-1$
} catch (Exception e) {
LibraryUIPlugin.getDefault().getLogger()
.logError(e);
}
}
}
postOpenLibrary(errors, (String) args.get(XMILibraryManager.ARG_LIBRARY_PATH));
if(errors.isEmpty()) {
successRunnable.run();
} else if (nextRunnable != null) {
nextRunnable.run();
}
return Status.OK_STATUS;
}
};
reactivateUIJob.setSystem(true);
reactivateUIJob.schedule();
}
});
openLibraryJob.schedule();
}
/**
* Opens a method library given the library path.
*
* @param path
* path to a method library
* @return <code>true</code> if the method library is opened successfully
*/
public boolean openLibrary(final String path) {
Map<String, Object> args = new HashMap<String, Object>();
args.put(XMILibraryManager.ARG_LIBRARY_PATH, path);
return openLibrary(XMILibraryManager.LIBRARY_TYPE, args);
}
/**
* Opens a method library.
*
* @param type
* the method library type
* @param params
* method library specific arguments
* @return <code>true</code> if the method library is opened successfully
*/
public boolean openLibrary(final String type, final Map<String, Object> args) {
final String path = (String) args
.get(XMILibraryManager.ARG_LIBRARY_PATH);
final List<Exception> errors = new ArrayList<Exception>();
UserInteractionHelper.getUIHelper().runWithProgress(new IRunnableWithProgress() {
public void run(IProgressMonitor monitor)
throws InvocationTargetException, InterruptedException {
try {
LibraryService.getInstance().closeCurrentMethodLibrary();
URI libURI = Path.fromOSString(path).toFile().toURI();
String newPath = handleLibraryOnReadOnlyInstallPath(libURI);
if (newPath != null) {
args.put(XMILibraryManager.ARG_LIBRARY_PATH, newPath);
}
MethodLibrary library = LibraryService.getInstance()
.openMethodLibrary(type, args);
LibraryService.getInstance().setCurrentMethodLibrary(
library);
LibraryUIPreferences.setSavedLibraryPath(path);
// Show Problems View if necessary.
ILibraryResourceSet resourceSet = ((ILibraryResourceSet) LibraryService
.getInstance().getCurrentLibraryManager()
.getEditingDomain().getResourceSet());
if (resourceSet.hasUnresolvedProxy()) {
SafeUpdateController.asyncExec(new Runnable() {
public void run() {
try {
PlatformUI
.getWorkbench()
.getActiveWorkbenchWindow()
.getActivePage()
.showView(
"org.eclipse.ui.views.ProblemView", null, IWorkbenchPage.VIEW_VISIBLE); //$NON-NLS-1$
} catch (Exception e) {
LibraryUIPlugin.getDefault().getLogger()
.logError(e);
}
}
});
}
} catch (Exception e) {
if (!(e instanceof IOException && e.getMessage()
.startsWith("###"))) { //$NON-NLS-1$
LibraryUIPlugin.getDefault().getLogger().logError(e);
}
errors.add(e);
}
}
}, false, LibraryUIResources.openingLibraryTask_name);
return postOpenLibrary(errors, (String) args.get(XMILibraryManager.ARG_LIBRARY_PATH));
}
private boolean postOpenLibrary(List<Exception> errors, String libPath) {
try {
if (errors.isEmpty()) {
IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench()
.getActiveWorkbenchWindow();
if (workbenchWindow != null) {
IWorkbenchPage activePage = workbenchWindow.getActivePage();
if (activePage != null) {
activePage.closeAllEditors(false);
}
}
return true;
} else {
Iterator<Exception> iter = errors.iterator();
while (iter.hasNext()) {
Exception e = iter.next();
if (e instanceof IOException) {
String message = e.getMessage();
if (message.startsWith("###")) { //$NON-NLS-1$
String projectFileName = message.substring(3);
String prompt = LibraryUIResources
.bind(
LibraryUIResources.readOnlyProjectFile_text,
projectFileName);
String[] buttonLabels = {
LibraryUIResources.retryButton_text,
LibraryUIResources.cancelButton_text };
MessageDialog msgBox = new MessageDialog(Display
.getCurrent().getActiveShell(),
LibraryUIResources.openLibraryWizard_title,
null, prompt, MessageDialog.WARNING,
buttonLabels, 0);
if (msgBox.open() == 0) {
return openLibrary(libPath);
} else {
return true;
}
}
} else {
Throwable ex = e;
for (ex = e; ex != null
&& !(ex instanceof MessageException); ex = ex
.getCause())
;
String msg = ex != null && ex.getMessage() != null ? ex
.getMessage() : e.getMessage() != null ? e
.getMessage() : e.toString();
LibraryUIPlugin
.getDefault()
.getMsgDialog()
.displayError(
LibraryUIResources.openLibraryWizard_title,
msg, e);
}
}
}
} catch (Exception e) {
LibraryUIPlugin.getDefault().getLogger().logError(e);
}
return false;
}
/**
* Upgrades a method library to a new meta-model.
*
* @param libPath
* path to a method library folder
* @return <code>true</code> if the given method library is sucessfully
* upgraded
*/
public static boolean upgradeLibrary(final String libPath,
final UpgradeCallerInfo callerInfo) {
Shell shell = Display.getCurrent().getActiveShell();
if (!CommandLineRunUtil.getInstance().isNeedToRun() && UpgradeCallerInfo.isUpgradeLibrary(callerInfo)) {
LibraryBackupUtil.promptBackupLibrary(shell, new File(libPath));
}
String libXmi = MultiFileSaveUtil.DEFAULT_LIBRARY_MODEL_FILENAME;
if (callerInfo != null && callerInfo.getIsExportedPluginLib()) {
libXmi = XMILibraryManager.exportFile;
}
return upgradeLibrary(new File(libPath, libXmi), callerInfo);
}
public static boolean upgradeLibrary(final File libFile,
final UpgradeCallerInfo callerInfo) {
final StringBuffer errMsg = new StringBuffer();
final boolean[] cancelFlagHolder = { false };
// Do the work within an operation because this is a long running
// activity that modifies the workbench.
WorkspaceModifyOperation operation = new WorkspaceModifyOperation() {
public void execute(IProgressMonitor monitor) {
monitor.beginTask(LibraryUIResources.upgradingLibraryTask_name,
10);
monitor.worked(1);
try {
MappingUtil.migrate(libFile.getAbsolutePath(), monitor,
callerInfo);
} catch (OperationCanceledException e) {
cancelFlagHolder[0] = true;
} catch (Exception e) {
LibraryUIPlugin.getDefault().getLogger().logError(e);
if (DEBUG) {
e.printStackTrace();
}
String msg = e.getMessage();
if (msg == null) {
msg = LibraryUIResources.upgradeLibraryError_msg;
}
errMsg.append(msg);
} finally {
monitor.done();
}
}
};
try {
// Run the operation and display the progress.
ProgressMonitorDialog pmDialog = new ProgressMonitorDialog(Display
.getCurrent().getActiveShell()) {
protected Point getInitialSize() {
Point calculatedSize = super.getInitialSize();
if (calculatedSize.x < 675) {
calculatedSize.x = 675;
}
return calculatedSize;
}
};
pmDialog.run(true, false, operation);
if (cancelFlagHolder[0]) {
return false;
} else if (errMsg.length() > 0) {
IStatus status = new Status(IStatus.ERROR,
LibraryUIPlugin.PLUGIN_ID, 0, "", null) {//$NON-NLS-1$
public IStatus[] getChildren() {
IStatus[] ret = new Status[1];
IStatus cs = new Status(IStatus.ERROR,
LibraryUIPlugin.PLUGIN_ID, 0,
errMsg.toString(), null);
ret[0] = cs;
return ret;
}
public boolean isMultiStatus() {
return true;
}
};
LibraryUIPlugin.getDefault().getMsgDialog().displayError(
LibraryUIResources.upgradeLibraryDialog_title,
LibraryUIResources.upgradeLibraryError_msg, status);
return false;
}
return true;
} catch (Exception e) {
LibraryUIPlugin.getDefault().getLogger().logError(e);
if (DEBUG) {
e.printStackTrace();
}
LibraryUIPlugin.getDefault().getMsgDialog().displayError(
LibraryUIResources.upgradeLibraryDialog_title,
LibraryUIResources.upgradeLibraryError_msg);
return false;
}
}
/**
* Sets the path of the method library that will be opened only if there are
* no saved library preferences.
*
* @param libraryPath
* path to a method library
*/
public static void setCommandLineDefaultLibrary(String libraryPath) {
if (libraryPath != null && libraryPath.length() > 0) {
IPath path = Path.fromOSString(libraryPath);
try {
defaultLibraryURI = path.toFile().toURI();
} catch (Exception e) {
defaultLibraryURI = null;
LibraryPlugin.getDefault().getLogger().logError(e);
}
}
}
/**
* Sets the path of the method library that will be opened regardless of the
* saved library preferences.
*
* @param libraryPath
* path to a method library
*/
public static void setCommandLineLibrary(String libraryPath) {
if (libraryPath != null && libraryPath.length() > 0) {
IPath path = Path.fromOSString(libraryPath);
try {
libraryURI = path.toFile().toURI();
} catch (Exception e) {
libraryURI = null;
LibraryPlugin.getDefault().getLogger().logError(e);
}
}
}
/**
* Checks whether the method configuration combobox should be added to the
* system toolbar.
* <p>
* The method configuration combobox lists all the method configurations in
* the current method library.
*/
public void checkConfigurationContribution() {
IWorkbench workbench = LibraryUIPlugin.getDefault().getWorkbench();
if (workbench != null) {
IWorkbenchWindow window = (IWorkbenchWindow) workbench
.getActiveWorkbenchWindow();
if (window != null && window instanceof ApplicationWindow) {
ICoolBarManager coolBarMgr = ((ApplicationWindow) window)
.getCoolBarManager();
try {
IWorkbenchPage activePage = window.getActivePage();
if (activePage != null) {
if (foundConfigView(activePage)
|| foundProcessEditor(activePage)
|| foundPerspective(activePage, REPORT_PERS_ID)
|| ConfigurationHelper.getDelegate().additionShowConfigSelectMenu(activePage)) {
showConfigurationContribution(coolBarMgr);
} else {
hideConfigurationContribution(coolBarMgr);
}
}
} catch (Exception e) {
LibraryUIPlugin.getDefault().getLogger().logError(e);
if (DEBUG) {
e.printStackTrace();
}
}
}
}
}
/**
* Checks for the presence of the Configuration view in the active workbench
* page.
*/
private boolean foundConfigView(IWorkbenchPage activePage) {
if (activePage == null) return false;
return activePage.findView(CONFIG_VIEW_ID) != null;
}
/**
* Checks for the presence of a Process editor in the active workbench.
* page.
*/
private boolean foundProcessEditor(IWorkbenchPage activePage) {
if (activePage == null) return false;
IEditorReference[] editorRefs = activePage.findEditors(null,
PROCESS_EDITOR_ID, IWorkbenchPage.MATCH_ID);
return editorRefs != null && editorRefs.length > 0;
}
/**
* Checks for the presence of Report Perspective in the active workbench
* page.
*/
private boolean foundPerspective(IWorkbenchPage activePage, String persId) {
if (activePage.getPerspective().getId().equals(persId)) {
return true;
}
return false;
}
/**
* Displays the method configuration combobox in the system toolbar.
*/
private void showConfigurationContribution(ICoolBarManager coolBarMgr)
throws Exception {
// Check for the method configuration combobox toolbar.
IContributionItem configToolBar = coolBarMgr
.find(TOOLBAR_CONFIG_CONTRIBUTION_ID);
if (configToolBar != null) {
// Make sure the toolbar has the method configuration combobox
// contribution.
if (configToolBar instanceof ToolBarContributionItem) {
IToolBarManager toolBarMgr = ((ToolBarContributionItem) configToolBar)
.getToolBarManager();
if (toolBarMgr != null) {
IContributionItem[] toolBarItems = toolBarMgr.getItems();
if (toolBarItems != null && toolBarItems.length > 0) {
for (int i = 0; i < toolBarItems.length; i++) {
toolBarItems[i].setVisible(true);
}
configToolBar.setVisible(true);
updateSystemToolBar(coolBarMgr);
return;
}
}
// The method configuration combobox toolbar has been restored
// via a saved perspective, add the method configuration
// combobox contribution.
configCombo = new ConfigurationContributionItem(
null);
if (DebugUtil.uiDebug) {
DebugUtil.print("showConfigurationContribution, configCombo 1: " + configCombo);//$NON-NLS-1$
DebugUtil.print();
}
configCombo.setId(ConfigurationContributionItem.class.getName());
toolBarMgr.add(configCombo);
configToolBar.setVisible(true);
updateSystemToolBar(coolBarMgr);
return;
}
}
IToolBarManager toolBarMgr = new ToolBarManager(SWT.FLAT | SWT.LEFT);
configCombo = new ConfigurationContributionItem(
null);
if (DebugUtil.uiDebug) {
DebugUtil.print("showConfigurationContribution, configCombo 2: " + configCombo);//$NON-NLS-1$
DebugUtil.print();
}
configCombo.setId(ConfigurationContributionItem.class.getName());
toolBarMgr.add(configCombo);
ToolBarContributionItem configComboToolBar = new ToolBarContributionItem(
toolBarMgr, TOOLBAR_CONFIG_CONTRIBUTION_ID);
coolBarMgr.add(configComboToolBar);
}
/**
* Hides the method configuration combobox from the system toolbar.
*/
private void hideConfigurationContribution(ICoolBarManager coolBarMgr)
throws Exception {
// Check for the method configuration combobox toolbar.
IContributionItem configToolBar = coolBarMgr
.find(TOOLBAR_CONFIG_CONTRIBUTION_ID);
if (configToolBar == null) {
return;
}
// Hide the method configuration combobox contribution from the toolbar.
if (configToolBar instanceof ToolBarContributionItem) {
IToolBarManager toolBarMgr = ((ToolBarContributionItem) configToolBar)
.getToolBarManager();
IContributionItem[] toolBarItems = toolBarMgr.getItems();
for (int i = 0; i < toolBarItems.length; i++) {
toolBarItems[i].setVisible(false);
}
}
// Hide the method configuration combobox toolbar contribution.
configToolBar.setVisible(false);
// Update the the system tool bar.
updateSystemToolBar(coolBarMgr);
}
/**
* Updates the system tool bar.
*/
private void updateSystemToolBar(ICoolBarManager coolBarMgr) {
if (coolBarMgr instanceof CoolBarManager) {
((CoolBarManager) coolBarMgr).update(true);
}
}
/**
* Adds a part listener so the library will open upon "startup"
* "startup" means when the view with the specified id is first
* visible
*/
public void addMethodViewPartListener(final String id) {
IWorkbench workbench = LibraryUIPlugin.getDefault().getWorkbench();
if (workbench != null) {
IWorkbenchWindow window = (IWorkbenchWindow) workbench
.getActiveWorkbenchWindow();
if (window != null && window instanceof ApplicationWindow) {
try {
final IWorkbenchPage activePage = window.getActivePage();
activePage.addPartListener(new IPartListener2() {
public void partActivated(
IWorkbenchPartReference partRef) {
}
public void partBroughtToTop(
IWorkbenchPartReference partRef) {
}
public void partClosed(IWorkbenchPartReference partRef) {
}
public void partDeactivated(
IWorkbenchPartReference partRef) {
}
public void partHidden(IWorkbenchPartReference partRef) {
}
public void partInputChanged(
IWorkbenchPartReference partRef) {
}
public void partOpened(IWorkbenchPartReference partRef) {
}
public void partVisible(IWorkbenchPartReference partRef) {
if (partRef.getId().equals(id)) {
activePage.removePartListener(this);
startupOpenLibrary();
}
}
});
} catch (Exception e) {
LibraryUIPlugin.getDefault().getLogger().logError(e);
if (DEBUG) {
e.printStackTrace();
}
}
}
}
}
/**
* Opens the library upon startup
* 1. First tries to open the library specified by -library
* 2. Then tries to open the last opened library
* 3. Finally, tries to open the library specified by -defaultlibrary
*/
public void startupOpenLibrary() {
if (libraryInitialized == true) {
return;
}
libraryInitialized = true;
try {
String savedMethodLibraryURI = LibraryPreferences.getSavedMethodLibraryURI();
final boolean hasSavedUri = savedMethodLibraryURI != null && savedMethodLibraryURI.length() > 0;
final String lastSavedConfigName = PreferenceUtil.getSavedLastConfig();
final Runnable successRunnable = new Runnable() {
public void run() {
if (LibraryService.getInstance().getCurrentMethodLibrary() != null) {
MethodConfiguration savedConfig = LibraryServiceUtil
.getMethodConfiguration(LibraryService.getInstance()
.getCurrentMethodLibrary(), lastSavedConfigName);
if (savedConfig != null) {
LibraryService.getInstance().setCurrentMethodConfiguration(savedConfig);
}
}
}
};
final Runnable openDefaultLibraryRunnable = new Runnable() {
public void run() {
if (defaultLibraryURI != null && !hasSavedUri) {
// Try loading the NL library first.
Locale locale = Locale.getDefault();
String defaultLibraryStr = new File(defaultLibraryURI)
.getAbsolutePath();
String localizedLibPath = I18nUtil.getLocalizedFile(
FileUtil.removeAllSeparator(defaultLibraryStr),
locale);
if (localizedLibPath != null) {
defaultLibraryURI_NL = StrUtil.toURI(localizedLibPath);
}
final URI defautlLibUrl = defaultLibraryURI_NL != null ? defaultLibraryURI_NL : defaultLibraryURI;
if (defautlLibUrl != null) {
// openLibrary(defautlLibUrl, successRunnable, new Runnable() {
// public void run() {
// openLibrary(defautlLibUrl, successRunnable, null);
// }
// });
openLibrary(defautlLibUrl, successRunnable, null);
}
}
}
};
openLibrary(libraryURI, successRunnable, new Runnable() {
public void run() {
openLastOpenedLibrary(successRunnable, openDefaultLibraryRunnable);
}
});
// if (libraryURI != null && openLibrary(libraryURI)) {
// } else if (openLastOpenedLibrary()) {
// } else if (defaultLibraryURI != null && !hasSavedUri) {
// // Try loading the NL library first.
// Locale locale = Locale.getDefault();
// String defaultLibraryStr = new File(defaultLibraryURI)
// .getAbsolutePath();
// String localizedLibPath = I18nUtil.getLocalizedFile(
// FileUtil.removeAllSeparator(defaultLibraryStr),
// locale);
// if (localizedLibPath != null) {
// defaultLibraryURI_NL = StrUtil.toURI(localizedLibPath);
// }
// if (defaultLibraryURI_NL != null && openDefaultLibrary(defaultLibraryURI_NL)) {
// } else {
// openDefaultLibrary(defaultLibraryURI);
// }
// }
} catch (Exception e) {
LibraryUIPlugin.getDefault().getLogger().logError(e);
}
}
/**
*
* @param path
* @return null if path is not on install path or not read-only or if user
* declines to copy the library to a writable location. Returns
* a new path if the user wishes to open the library in a different location
*
*/
private String handleLibraryOnReadOnlyInstallPath(URI libURI) {
if (isSkipInstallPathCheck()) {
return null;
}
try {
boolean readOnly = false;
// determine if path is in Installation directory
File libPathFile = new File(libURI);
if (!libPathFile.exists()) {
return null;
}
Location installLocation = Platform.getInstallLocation();
URL installLocationURL = installLocation.getURL();
URI installLocationURI = new URI(NetUtil.encodeFileURL(installLocationURL.toExternalForm()));
File installLocFile = new File(installLocationURI);
String canonicalLibPath = NetUtil.decodedFileUrl(libPathFile.getCanonicalPath());
String canonicalInstallPath = NetUtil.decodedFileUrl(installLocFile.getCanonicalPath());;
if (!canonicalLibPath.startsWith(canonicalInstallPath)) {
return null;
}
// show dialog, allow copy to new path
final String defaultCopyPath = new File(new File(LibraryUIPreferences.getDefaultLibraryPath()).getParent(), libPathFile.getName()).getAbsolutePath();
final StringBuffer newPath = new StringBuffer();
UserInteractionHelper.getUIHelper().runSafely(new Runnable() {
public void run() {
String title = LibraryUIResources.copyLibraryDialog_title;
String message = LibraryUIResources.copyLibraryDialog_text_readOnlyLib;
CopyLibraryDialog dlg = new CopyLibraryDialog(Display.getCurrent().getActiveShell(), title,
message, defaultCopyPath);
if (dlg.open() == Dialog.OK) {
newPath.append(dlg.getPath());
}
}
}, true);
if (newPath.length() > 0) {
copyLibrary(libPathFile, new File(newPath.toString()));
return newPath.toString();
} else {
return null;
}
} catch (URISyntaxException uriEx) {
LibraryUIPlugin.getDefault().getLogger().logError(uriEx);
return null;
} catch (IOException ioEx) {
LibraryUIPlugin.getDefault().getLogger().logError(ioEx);
return null;
}
}
/**
* Back up library
*
* @param source
* @param dest
*/
private static void copyLibrary(final File source, final File dest) {
Runnable runnable = new Runnable() {
public void run() {
try {
// excude the non-library files that might be locked by rmc.
// these files may cause backup to fail due to file lock.
String excludes = ".lock"; //$NON-NLS-1$
LayoutResources.copyDir(source, dest, "**", excludes); //$NON-NLS-1$
} catch (RuntimeException e) {
e.printStackTrace();
}
}
};
UserInteractionHelper.runWithProgress(runnable,
LibraryUIResources.copyLibraryTask_name);
}
/**
*
* @return the current MethodConfiguration dropdown box
*/
public ConfigurationContributionItem getConfigCombo() {
return configCombo;
}
public static boolean isSkipInstallPathCheck() {
return skipInstallPathCheck;
}
public static void setSkipInstallPathCheck(boolean skipInstallPathCheck) {
LibraryUIManager.skipInstallPathCheck = skipInstallPathCheck;
}
}