| /* |
| * Copyright (c) 2015-2017 Eike Stepper (Loehne, Germany) and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v2.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v20.html |
| * |
| * Contributors: |
| * Eike Stepper - initial API and implementation |
| * Yatta Solutions - [466264] Enhance UX in simple installer |
| */ |
| package org.eclipse.oomph.setup.internal.installer; |
| |
| import org.eclipse.oomph.base.Annotation; |
| import org.eclipse.oomph.internal.setup.SetupProperties; |
| import org.eclipse.oomph.internal.ui.AccessUtil; |
| import org.eclipse.oomph.internal.ui.FlatButton; |
| import org.eclipse.oomph.internal.ui.ImageHoverButton; |
| import org.eclipse.oomph.internal.ui.ToggleSwitchButton; |
| import org.eclipse.oomph.p2.core.BundlePool; |
| import org.eclipse.oomph.p2.core.P2Util; |
| import org.eclipse.oomph.p2.core.ProfileTransaction.Resolution; |
| import org.eclipse.oomph.p2.internal.ui.AgentManagerDialog; |
| import org.eclipse.oomph.setup.AnnotationConstants; |
| import org.eclipse.oomph.setup.Index; |
| import org.eclipse.oomph.setup.Product; |
| import org.eclipse.oomph.setup.ProductCatalog; |
| import org.eclipse.oomph.setup.ProductVersion; |
| import org.eclipse.oomph.setup.Scope; |
| import org.eclipse.oomph.setup.User; |
| import org.eclipse.oomph.setup.internal.core.util.CatalogManager; |
| import org.eclipse.oomph.setup.internal.core.util.ECFURIHandlerImpl; |
| import org.eclipse.oomph.setup.internal.core.util.IndexManager; |
| import org.eclipse.oomph.setup.internal.installer.SimpleInstallerMenu.InstallerMenuItem; |
| import org.eclipse.oomph.setup.internal.installer.SimpleMessageOverlay.ControlRelocator; |
| import org.eclipse.oomph.setup.p2.util.MarketPlaceListing; |
| import org.eclipse.oomph.setup.ui.SetupUIPlugin; |
| import org.eclipse.oomph.setup.ui.wizards.ConfigurationProcessor; |
| import org.eclipse.oomph.setup.ui.wizards.ExtensionsDialog; |
| import org.eclipse.oomph.setup.ui.wizards.MarketPlaceListingProcessor; |
| import org.eclipse.oomph.setup.ui.wizards.ProjectPage; |
| import org.eclipse.oomph.setup.ui.wizards.SetupWizard.SelectionMemento; |
| import org.eclipse.oomph.ui.ErrorDialog; |
| import org.eclipse.oomph.ui.StatusDialog; |
| import org.eclipse.oomph.ui.UIUtil; |
| import org.eclipse.oomph.util.ExceptionHandler; |
| import org.eclipse.oomph.util.IOExceptionWithCause; |
| import org.eclipse.oomph.util.IOUtil; |
| import org.eclipse.oomph.util.OS; |
| import org.eclipse.oomph.util.ObjectUtil; |
| import org.eclipse.oomph.util.OomphPlugin.BundleFile; |
| import org.eclipse.oomph.util.OomphPlugin.Preference; |
| import org.eclipse.oomph.util.PropertiesUtil; |
| import org.eclipse.oomph.util.StringUtil; |
| |
| import org.eclipse.emf.common.util.Diagnostic; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.edit.ui.provider.ExtendedColorRegistry; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.jface.dialogs.Dialog; |
| import org.eclipse.jface.dialogs.IDialogConstants; |
| import org.eclipse.jface.dialogs.IDialogSettings; |
| import org.eclipse.jface.layout.GridDataFactory; |
| import org.eclipse.jface.resource.JFaceResources; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.StackLayout; |
| import org.eclipse.swt.events.DisposeEvent; |
| import org.eclipse.swt.events.DisposeListener; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.Drawable; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.graphics.GC; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.Label; |
| |
| import java.beans.PropertyChangeEvent; |
| import java.beans.PropertyChangeListener; |
| import java.io.File; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.LinkedHashSet; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Set; |
| |
| /** |
| * @author Eike Stepper |
| */ |
| public final class SimpleInstallerDialog extends AbstractSimpleDialog implements InstallerUI |
| { |
| private static final String CATALOGS_MENU_ITEM_TEXT = ProductCatalogsDialog.TITLE.toUpperCase() + StringUtil.HORIZONTAL_ELLIPSIS; |
| |
| private static final String APPLY_CONFIGURATION_MENU_ITEM_TEXT = Messages.SimpleInstallerDialog_AppyConfiguration_label; |
| |
| private static final String APPLY_CONFIGURATION_MENU_ITEM_DESCRIPTION = Messages.SimpleInstallerDialog_ApplyConfiguration_message; |
| |
| private static final String APPLY_MARKET_PLACE_LISTING_MENU_ITEM_TEXT = Messages.SimpleInstallerDialog_ApplyMarketplaceListing_label |
| + StringUtil.HORIZONTAL_ELLIPSIS; |
| |
| private static final String APPLY_MARKET_PLACE_LISTING_MENU_ITEM_DESCRIPTION = Messages.SimpleInstallerDialog_ApplyMarketplaceListing_message; |
| |
| private static final String EXTENSIONS_MENU_ITEM_TEXT = Messages.SimpleInstallerDialog_Extensions_label + StringUtil.HORIZONTAL_ELLIPSIS; |
| |
| static final String EXTENSIONS_MENU_ITEM_DESCRIPTION = Messages.SimpleInstallerDialog_Extensions_message; |
| |
| private static final String SWITCH_CATALOG_INDEX_MENU_ITEM_TEXT = Messages.SimpleInstallerDialog_SwitchIndex_label; |
| |
| private static final String BUNDLE_POOLS_MENU_ITEM_TEXT = Messages.SimpleInstallerDialog_BundlePools_label + StringUtil.HORIZONTAL_ELLIPSIS; |
| |
| private static final String UPDATE_MENU_ITEM_TEXT = Messages.SimpleInstallerDialog_Update_label; |
| |
| private static final String ADVANCED_MENU_ITEM_TEXT = Messages.SimpleInstallerDialog_AdvancedMode_label + StringUtil.HORIZONTAL_ELLIPSIS; |
| |
| private static final String WEB_LINKS_MENU_ITEM_TEXT = Messages.SimpleInstallerDialog_WebLinks_label + StringUtil.HORIZONTAL_ELLIPSIS; |
| |
| static final String WEB_LINKS_MENU_ITEM_DESCRIPTION = Messages.SimpleInstallerDialog_WebLinks_message; |
| |
| private static final String TRUST_MENU_ITEM_TEXT = Messages.SimpleInstallerDialog_Trust_label + StringUtil.HORIZONTAL_ELLIPSIS; |
| |
| static final String TRUST_MENU_ITEM_DESCRIPTION = Messages.SimpleInstallerDialog_Trust_message; |
| |
| private static final String MARKET_PLACE_MENU_ITEM_TEXT = Messages.SimpleInstallerDialog_Marketplace_label + StringUtil.HORIZONTAL_ELLIPSIS; |
| |
| private static final String ASK_A_QUESTION_MENU_ITEM_TEXT = Messages.SimpleInstallerDialog_AskQuestion_label + StringUtil.HORIZONTAL_ELLIPSIS; |
| |
| private static final String REPORT_A_PROBLEM_MENU_ITEM_TEXT = Messages.SimpleInstallerDialog_ReportProblem_label + StringUtil.HORIZONTAL_ELLIPSIS; |
| |
| private static final String CONTRIBUTE_MENU_ITEM_TEXT = Messages.SimpleInstallerDialog_Contribute_label + StringUtil.HORIZONTAL_ELLIPSIS; |
| |
| private static final String ABOUT_MENU_ITEM_TEXT = Messages.SimpleInstallerDialog_About_label; |
| |
| private static final String EXIT_MENU_ITEM_TEXT = Messages.SimpleInstallerDialog_Exit_label; |
| |
| private static final Preference PREF_POOL_ENABLED = SetupInstallerPlugin.INSTANCE.getConfigurationPreference("poolEnabled"); //$NON-NLS-1$ |
| |
| private static final boolean MARKETPLACE_MENU_ITEM_ENABLED = !"false".equals(PropertiesUtil.getProperty(SetupProperties.PROP_SETUP_INSTALLER_MARKETPLACE)); //$NON-NLS-1$ |
| |
| private static final String HOST = PropertiesUtil.getProperty("oomph.setup.installer.host", "https://www.eclipse.org/setups/installer"); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| private static final String PROBLEM_REPORT_URL = PropertiesUtil.getProperty(SetupProperties.PROP_SETUP_INSTALLER_PROBLEM_REPORT, HOST + "/problem/"); //$NON-NLS-1$ |
| |
| private static final String FORUM_URL = PropertiesUtil.getProperty(SetupProperties.PROP_SETUP_INSTALLER_FORUM, HOST + "/question/"); //$NON-NLS-1$ |
| |
| private static final String CONTRIBUTE_URL = PropertiesUtil.getProperty(SetupProperties.PROP_SETUP_INSTALLER_CONTRIBUTE, HOST + "/notification/"); //$NON-NLS-1$ |
| |
| private static final File FILE_BRANDING_NOTIFICTION_URIS = new File(SetupInstallerPlugin.INSTANCE.getUserLocation().toFile(), "brandingNotificationURIs.txt"); //$NON-NLS-1$ |
| |
| private static Font defaultFont; |
| |
| private static Point defaultSize; |
| |
| private static String css; |
| |
| private static String pageTemplate; |
| |
| private static String productTemplate; |
| |
| private static String productTemplateLarge; |
| |
| private final Installer installer; |
| |
| private final boolean restarted; |
| |
| private final CatalogManager catalogManager; |
| |
| private final PageStack pageStack = new PageStack(); |
| |
| private Composite stack; |
| |
| private StackLayout stackLayout; |
| |
| private SimpleProductPage productPage; |
| |
| private SimpleVariablePage variablePage; |
| |
| private SimpleReadmePage readmePage; |
| |
| private SimpleInstallationLogPage installationLogPage; |
| |
| private SimpleKeepInstallerPage keepInstallerPage; |
| |
| private SimpleInstallerMenu installerMenu; |
| |
| private SimpleInstallerMenuButton menuButton; |
| |
| private NotifictionButton notificationButton; |
| |
| private boolean poolEnabled; |
| |
| private BundlePool pool; |
| |
| private Resolution updateResolution; |
| |
| private SimpleMessageOverlay currentMessage; |
| |
| private ToggleSwitchButton bundlePoolSwitch; |
| |
| private ToggleSwitchButton webLinksSwitch; |
| |
| private boolean showProductCatalogsItem; |
| |
| public SimpleInstallerDialog(Display display, Installer installer, boolean restarted) |
| { |
| super(display, SWT.NO_TRIM, getDefaultSize(display).x, getDefaultSize(display).y); |
| setMinimumSize(385, 75); |
| this.installer = installer; |
| this.restarted = restarted; |
| catalogManager = installer.getCatalogManager(); |
| } |
| |
| protected void applyConfiguration() |
| { |
| MarketPlaceListingProcessor marketPlaceListingProcessor = new MarketPlaceListingProcessor(installer); |
| if (marketPlaceListingProcessor.isMarketPlaceListing()) |
| { |
| marketPlaceListingProcessor.processMarketPlaceListing(); |
| IStatus status = marketPlaceListingProcessor.getStatus(); |
| if (!status.isOK()) |
| { |
| new StatusDialog(getShell(), Messages.SimpleInstallerDialog_MPCProblems_title, null, status, Diagnostic.ERROR).open(); |
| } |
| } |
| else |
| { |
| ConfigurationProcessor configurationProcessor = new ConfigurationProcessor(installer) |
| { |
| @Override |
| protected void handleSwitchToAdvancedMode() |
| { |
| switchToAdvancedMode(); |
| } |
| |
| @Override |
| protected boolean applyEmptyProductVersion() |
| { |
| applyInstallation(); |
| return true; |
| } |
| |
| @Override |
| protected boolean applyProductVersion(ProductVersion productVersion) |
| { |
| applyInstallation(); |
| |
| productPage.handleFilter(""); //$NON-NLS-1$ |
| productPage.productSelected(productVersion.getProduct()); |
| variablePage.setProductVersion(productVersion); |
| return true; |
| } |
| }; |
| |
| if (configurationProcessor.processWorkspace()) |
| { |
| configurationProcessor.processInstallation(); |
| } |
| |
| IStatus status = configurationProcessor.getStatus(); |
| if (!status.isOK()) |
| { |
| new StatusDialog(getShell(), Messages.SimpleInstallerDialog_ConfigurationProblems_title, null, status, Diagnostic.ERROR).open(); |
| } |
| } |
| } |
| |
| @Override |
| protected IDialogSettings getDialogSizeSettings() |
| { |
| return SetupInstallerPlugin.INSTANCE.getDialogSettings("SimpleInstaller"); //$NON-NLS-1$ |
| } |
| |
| @Override |
| protected int getTitleColumnCount() |
| { |
| return super.getTitleColumnCount() + 1; |
| } |
| |
| @Override |
| protected GridData createTitleImageGridData() |
| { |
| GridData gridData = super.createTitleImageGridData(); |
| gridData.grabExcessHorizontalSpace = false; |
| return gridData; |
| } |
| |
| @Override |
| protected void createUI(Composite titleComposite) |
| { |
| Composite notificationContainer = new Composite(titleComposite, SWT.NONE); |
| GridLayout notificationContainerLayout = UIUtil.createGridLayout(1); |
| // notificationContainerLayout.marginLeft = 20; |
| notificationContainerLayout.marginRight = 20; |
| notificationContainer.setLayout(notificationContainerLayout); |
| notificationContainer.setLayoutData(GridDataFactory.swtDefaults().grab(true, true).align(SWT.END, SWT.BEGINNING).create()); |
| |
| notificationButton = new NotifictionButton(notificationContainer) |
| { |
| @Override |
| protected void handleWidgetSelected() |
| { |
| super.handleWidgetSelected(); |
| handleBrandingNotificationURIOpen(getURI()); |
| } |
| |
| @Override |
| protected boolean hasOpenedBrandingNotificationURI(URI uri) |
| { |
| return SimpleInstallerDialog.this.hasOpenedBrandingNotificationURI(uri); |
| } |
| }; |
| |
| notificationButton.setLayoutData(GridDataFactory.swtDefaults().align(SWT.CENTER, SWT.BEGINNING).create()); |
| notificationButton.setVisible(false); |
| |
| Composite exitMenuButtonContainer = new Composite(titleComposite, SWT.NONE); |
| exitMenuButtonContainer.setLayout(UIUtil.createGridLayout(1)); |
| exitMenuButtonContainer.setLayoutData(GridDataFactory.swtDefaults().grab(false, true).align(SWT.CENTER, SWT.FILL).create()); |
| |
| FlatButton exitButton = new ImageHoverButton(exitMenuButtonContainer, SWT.PUSH, SetupInstallerPlugin.INSTANCE.getSWTImage("simple/exit.png"), //$NON-NLS-1$ |
| SetupInstallerPlugin.INSTANCE.getSWTImage("simple/exit_hover.png")); //$NON-NLS-1$ |
| exitButton.setShowButtonDownState(false); |
| exitButton.setLayoutData(GridDataFactory.swtDefaults().align(SWT.CENTER, SWT.BEGINNING).create()); |
| exitButton.setToolTipText(Messages.SimpleInstallerDialog_Exit_message); |
| exitButton.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| exitSelected(); |
| } |
| }); |
| |
| menuButton = new SimpleInstallerMenuButton(exitMenuButtonContainer); |
| menuButton.setLayoutData(GridDataFactory.swtDefaults().grab(false, true).align(SWT.CENTER, SWT.BEGINNING).indent(11, 0).create()); |
| menuButton.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| // Don't use the event, it can be null! |
| toggleMenu(); |
| } |
| }); |
| |
| stackLayout = new StackLayout(); |
| |
| stack = new Composite(this, SWT.NONE); |
| stack.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, true)); |
| stack.setLayout(stackLayout); |
| |
| SelectionMemento selectionMemento = installer.getSelectionMemento(); |
| productPage = new SimpleProductPage(stack, this, selectionMemento); |
| variablePage = new SimpleVariablePage(stack, this, selectionMemento); |
| |
| if (UIUtil.isBrowserAvailable()) |
| { |
| readmePage = new SimpleReadmePage(stack, this); |
| } |
| |
| installationLogPage = new SimpleInstallationLogPage(stack, this); |
| keepInstallerPage = new SimpleKeepInstallerPage(stack, this); |
| |
| switchToPage(productPage); |
| |
| Display display = getDisplay(); |
| |
| if (!restarted) |
| { |
| Thread updateSearcher = new UpdateSearcher(display); |
| updateSearcher.start(); |
| } |
| |
| display.timerExec(500, new Runnable() |
| { |
| @Override |
| public void run() |
| { |
| installer.getResourceSet().getLoadOptions().put(ECFURIHandlerImpl.OPTION_CACHE_HANDLING, ECFURIHandlerImpl.CacheHandling.CACHE_WITHOUT_ETAG_CHECKING); |
| installer.loadIndex(); |
| } |
| }); |
| |
| // Initialize menu. |
| getInstallerMenu(); |
| |
| final PropertyChangeListener catalogManagerListener = new PropertyChangeListener() |
| { |
| @Override |
| public void propertyChange(PropertyChangeEvent evt) |
| { |
| if (CatalogManager.PROPERTY_INDEX.equals(evt.getPropertyName())) |
| { |
| indexLoaded((Index)evt.getNewValue()); |
| } |
| } |
| }; |
| catalogManager.addPropertyChangeListener(catalogManagerListener); |
| |
| addDisposeListener(new DisposeListener() |
| { |
| @Override |
| public void widgetDisposed(DisposeEvent e) |
| { |
| catalogManager.removePropertyChangeListener(catalogManagerListener); |
| } |
| }); |
| |
| enablePool(SHOW_BUNDLE_POOL_UI && PREF_POOL_ENABLED.get(true)); |
| |
| updateAvailable(false); |
| |
| titleComposite.layout(true); |
| } |
| |
| private void indexLoaded(Index index) |
| { |
| @SuppressWarnings("unchecked") |
| List<ProductCatalog> productCatalogs = (List<ProductCatalog>)catalogManager.getCatalogs(true); |
| |
| int count = 0; |
| if (productCatalogs != null) |
| { |
| for (ProductCatalog productCatalog : productCatalogs) |
| { |
| if (SimpleProductPage.isIncluded(productCatalog)) |
| { |
| ++count; |
| } |
| } |
| } |
| |
| // Show it if there is more than one catalog, |
| // or if there are no filters in place and there indices available to switch to. |
| // This will not show it for the crippled installer because it has filters in place. |
| showProductCatalogsItem = count > 1 |
| || StringUtil.isEmpty(SimpleInstallerPage.PRODUCT_CATALOG_FILTER.pattern()) && StringUtil.isEmpty(SimpleInstallerPage.PRODUCT_FILTER.pattern()) |
| && StringUtil.isEmpty(SimpleInstallerPage.PRODUCT_VERSION_FILTER.pattern()) && new IndexManager().getIndexNames(false).size() > 1; |
| |
| // Initialize notification button with the default. |
| notificationButton.setBrandingNotificationScope(productCatalogs); |
| } |
| |
| public void setBrandingNotificationScope(Scope scope) |
| { |
| notificationButton.setBrandingNotificationScope(scope); |
| } |
| |
| private void toggleMenu() |
| { |
| SimpleInstallerMenu installerMenu = getInstallerMenu(); |
| boolean show = !installerMenu.isVisible(); |
| |
| Installer installer = getInstaller(); |
| if (show) |
| { |
| installer.setConfigurationResources(Collections.<Resource> emptySet()); |
| SimpleInstallerPage topPage = getTopPage(); |
| if (topPage != null) |
| { |
| topPage.menuAboutToShow(installerMenu); |
| } |
| |
| InstallerMenuItem extensionsItem = installerMenu.findMenuItemByName(EXTENSIONS_MENU_ITEM_TEXT); |
| extensionsItem.setVisible(!installer.getAppliedConfigurationResources().isEmpty()); |
| |
| InstallerMenuItem switchCatalogIndexItem = installerMenu.findMenuItemByName(SWITCH_CATALOG_INDEX_MENU_ITEM_TEXT); |
| InstallerMenuItem catalogsMenuItem = installerMenu.findMenuItemByName(CATALOGS_MENU_ITEM_TEXT); |
| InstallerMenuItem marketPlaceItem = installerMenu.findMenuItemByName(MARKET_PLACE_MENU_ITEM_TEXT); |
| InstallerMenuItem applyConfigurationMenuItem = installerMenu.findMenuItemByName(APPLY_CONFIGURATION_MENU_ITEM_TEXT); |
| if (applyConfigurationMenuItem == null) |
| { |
| applyConfigurationMenuItem = installerMenu.findMenuItemByName(APPLY_MARKET_PLACE_LISTING_MENU_ITEM_TEXT); |
| } |
| |
| if (topPage == productPage) |
| { |
| Collection<? extends Resource> configurationResources = installer.getUnappliedConfigurationResources(); |
| URI indexLocation = ProjectPage.ConfigurationListener.getIndexURI(configurationResources); |
| boolean visible = !configurationResources.isEmpty() && indexLocation == null; |
| if (visible) |
| { |
| boolean isMarketPlaceListing = false; |
| for (Resource resource : configurationResources) |
| { |
| if (MarketPlaceListing.isMarketPlaceListing(resource.getURI())) |
| { |
| isMarketPlaceListing = true; |
| break; |
| } |
| } |
| |
| applyConfigurationMenuItem.setText(isMarketPlaceListing ? APPLY_MARKET_PLACE_LISTING_MENU_ITEM_TEXT : APPLY_CONFIGURATION_MENU_ITEM_TEXT); |
| applyConfigurationMenuItem |
| .setToolTipText(isMarketPlaceListing ? APPLY_MARKET_PLACE_LISTING_MENU_ITEM_DESCRIPTION : APPLY_CONFIGURATION_MENU_ITEM_DESCRIPTION); |
| } |
| |
| applyConfigurationMenuItem.setVisible(visible); |
| boolean switchCatalogVisible = indexLocation != null && !catalogManager.isCurrentIndex(indexLocation); |
| switchCatalogIndexItem.setVisible(switchCatalogVisible); |
| if (switchCatalogVisible) |
| { |
| switchCatalogIndexItem |
| .setToolTipText(NLS.bind(Messages.SimpleInstallerDialog_SwitchCatalogIndex_message, IndexManager.getUnderlyingLocation(indexLocation))); |
| } |
| |
| catalogsMenuItem.setVisible(showProductCatalogsItem); |
| |
| if (marketPlaceItem != null) |
| { |
| marketPlaceItem.setVisible(true); |
| } |
| } |
| else |
| { |
| catalogsMenuItem.setVisible(false); |
| applyConfigurationMenuItem.setVisible(false); |
| switchCatalogIndexItem.setVisible(false); |
| if (marketPlaceItem != null) |
| { |
| marketPlaceItem.setVisible(false); |
| } |
| } |
| } |
| |
| installerMenu.layout(true, true); |
| installerMenu.setVisible(show); |
| } |
| |
| public Installer getInstaller() |
| { |
| return installer; |
| } |
| |
| public void setButtonsEnabled(boolean enabled) |
| { |
| menuButton.setEnabled(enabled); |
| } |
| |
| private void enablePool(boolean poolEnabled) |
| { |
| if (this.poolEnabled != poolEnabled) |
| { |
| this.poolEnabled = poolEnabled; |
| PREF_POOL_ENABLED.set(poolEnabled); |
| } |
| |
| if (poolEnabled) |
| { |
| pool = P2Util.getAgentManager().getDefaultBundlePool(SetupUIPlugin.INSTANCE.getSymbolicName()); |
| } |
| else |
| { |
| pool = null; |
| } |
| |
| if (bundlePoolSwitch != null) |
| { |
| bundlePoolSwitch.setSelected(poolEnabled); |
| } |
| } |
| |
| public BundlePool getPool() |
| { |
| return pool; |
| } |
| |
| private SimpleInstallerMenu getInstallerMenu() |
| { |
| if (installerMenu == null) |
| { |
| installerMenu = createInstallerMenu(); |
| } |
| |
| return installerMenu; |
| } |
| |
| private SimpleInstallerMenu createInstallerMenu() |
| { |
| final SimpleInstallerMenu menu = new SimpleInstallerMenu(this); |
| |
| SimpleInstallerMenu.InstallerMenuItem updateInstallerItem = new SimpleInstallerMenu.InstallerMenuItem(menu); |
| updateInstallerItem.setDefaultImage(SetupInstallerPlugin.INSTANCE.getSWTImage("simple/exclamation_circle.png")); //$NON-NLS-1$ |
| updateInstallerItem.setHoverImage(SetupInstallerPlugin.INSTANCE.getSWTImage("simple/exclamation_circle_hover.png")); //$NON-NLS-1$ |
| updateInstallerItem.setText(UPDATE_MENU_ITEM_TEXT); |
| updateInstallerItem.setToolTipText(Messages.SimpleInstallerDialog_InstallUpdates_message); |
| updateInstallerItem.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| Runnable successRunnable = new Runnable() |
| { |
| @Override |
| public void run() |
| { |
| restart(); |
| } |
| }; |
| |
| ExceptionHandler<CoreException> exceptionHandler = new ExceptionHandler<CoreException>() |
| { |
| @Override |
| public void handleException(CoreException ex) |
| { |
| ErrorDialog.open(ex); |
| } |
| }; |
| |
| SelfUpdate.update(getShell(), updateResolution, successRunnable, exceptionHandler, null); |
| } |
| }); |
| |
| SimpleInstallerMenu.InstallerMenuItem applyConfigurationItem = new SimpleInstallerMenu.InstallerMenuItem(menu); |
| applyConfigurationItem.setText(APPLY_CONFIGURATION_MENU_ITEM_TEXT); |
| applyConfigurationItem.setToolTipText(APPLY_CONFIGURATION_MENU_ITEM_DESCRIPTION); |
| applyConfigurationItem.setVisible(false); |
| applyConfigurationItem.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| applyConfiguration(); |
| } |
| }); |
| |
| SimpleInstallerMenu.InstallerMenuItem extensionsItem = new SimpleInstallerMenu.InstallerMenuItem(menu); |
| extensionsItem.setDefaultImage(SetupInstallerPlugin.INSTANCE.getSWTImage("simple/extension_circle.png")); //$NON-NLS-1$ |
| extensionsItem.setHoverImage(SetupInstallerPlugin.INSTANCE.getSWTImage("simple/extension_circle_hover.png")); //$NON-NLS-1$ |
| extensionsItem.setText(EXTENSIONS_MENU_ITEM_TEXT); |
| extensionsItem.setToolTipText(EXTENSIONS_MENU_ITEM_DESCRIPTION); |
| extensionsItem.setVisible(false); |
| extensionsItem.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| Collection<? extends Resource> appliedConfigurationResources = installer.getAppliedConfigurationResources(); |
| ExtensionsDialog extensionsDialog = new ExtensionsDialog(getShell(), appliedConfigurationResources); |
| if (extensionsDialog.open() == Window.OK) |
| { |
| Collection<? extends Resource> result = extensionsDialog.getResult(); |
| for (Resource resource : appliedConfigurationResources) |
| { |
| if (!result.contains(resource)) |
| { |
| installer.removeAppliedConfigurationResource(resource); |
| } |
| } |
| } |
| } |
| }); |
| |
| SimpleInstallerMenu.InstallerMenuItem switchCatalogIndexItem = new SimpleInstallerMenu.InstallerMenuItem(menu); |
| switchCatalogIndexItem.setText(SWITCH_CATALOG_INDEX_MENU_ITEM_TEXT); |
| switchCatalogIndexItem.setVisible(false); |
| switchCatalogIndexItem.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| applyConfiguration(); |
| } |
| }); |
| |
| SimpleInstallerMenu.InstallerMenuItem catalogsItem = new SimpleInstallerMenu.InstallerMenuItem(menu); |
| catalogsItem.setText(CATALOGS_MENU_ITEM_TEXT); |
| catalogsItem.setToolTipText(ProductCatalogsDialog.DESCRIPTION); |
| catalogsItem.setVisible(false); |
| catalogsItem.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| ProductCatalogsDialog productCatalogsDialog = new ProductCatalogsDialog(SimpleInstallerDialog.this, getInstaller(), catalogManager); |
| productCatalogsDialog.open(); |
| } |
| }); |
| AccessUtil.setKey(catalogsItem, "catalogs"); //$NON-NLS-1$ |
| |
| // Label spacer1 = new Label(menu, SWT.NONE); |
| // spacer1.setLayoutData(GridDataFactory.swtDefaults().hint(SWT.DEFAULT, 46).create()); |
| |
| SimpleInstallerMenu.InstallerMenuItem advancedModeItem = new SimpleInstallerMenu.InstallerMenuItem(menu); |
| advancedModeItem.setText(ADVANCED_MENU_ITEM_TEXT); |
| advancedModeItem.setToolTipText(Messages.SimpleInstallerDialog_SwitchToAdvancedMode_message); |
| advancedModeItem.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| switchToAdvancedMode(); |
| } |
| }); |
| |
| if (SHOW_BUNDLE_POOL_UI) |
| { |
| SimpleInstallerMenu.InstallerMenuItemWithToggle bundlePoolsItem = new SimpleInstallerMenu.InstallerMenuItemWithToggle(menu); |
| bundlePoolsItem.setText(BUNDLE_POOLS_MENU_ITEM_TEXT); |
| bundlePoolsItem.setToolTipText(AgentManagerDialog.MESSAGE); |
| // bundlePoolsItem.setDividerVisible(false); |
| bundlePoolsItem.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| manageBundlePools(); |
| } |
| }); |
| |
| bundlePoolSwitch = bundlePoolsItem.getToggleSwitch(); |
| bundlePoolSwitch.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| enablePool(bundlePoolSwitch.isSelected()); |
| } |
| }); |
| } |
| |
| SimpleInstallerMenu.InstallerMenuItemWithToggle webLinksItem = new SimpleInstallerMenu.InstallerMenuItemWithToggle(menu); |
| webLinksItem.setText(WEB_LINKS_MENU_ITEM_TEXT); |
| webLinksItem.setToolTipText(WEB_LINKS_MENU_ITEM_DESCRIPTION); |
| webLinksItem.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| if (URISchemeUtil.manageRegistrations(getShell()) == URISchemeUtil.RegistrationConfirmation.KEEP_INSTALLER) |
| { |
| close(); |
| } |
| else |
| { |
| webLinksSwitch.setSelected(URISchemeUtil.isRegistered()); |
| } |
| } |
| }); |
| |
| webLinksSwitch = webLinksItem.getToggleSwitch(); |
| webLinksSwitch.setSelected(URISchemeUtil.isRegistered()); |
| webLinksSwitch.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| boolean enable = webLinksSwitch.isSelected(); |
| if (enable) |
| { |
| switch (URISchemeUtil.confirmRegistration(getShell())) |
| { |
| case KEEP_INSTALLER: |
| { |
| showKeepInstaller(true); |
| break; |
| } |
| case OK: |
| { |
| URISchemeUtil.setRegistered(true); |
| break; |
| } |
| case DONE: |
| case CANCEL: |
| { |
| break; |
| } |
| } |
| } |
| else |
| { |
| URISchemeUtil.setRegistered(false); |
| } |
| |
| webLinksSwitch.setSelected(URISchemeUtil.isRegistered()); |
| } |
| }); |
| |
| { |
| SimpleInstallerMenu.InstallerMenuItem trustMenuItem = new SimpleInstallerMenu.InstallerMenuItem(menu); |
| trustMenuItem.setText(TRUST_MENU_ITEM_TEXT); |
| trustMenuItem.setToolTipText(TRUST_MENU_ITEM_DESCRIPTION); |
| trustMenuItem.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| Dialog dialog = new TrustDialog(getShell()); |
| dialog.open(); |
| } |
| }); |
| } |
| |
| if (MARKETPLACE_MENU_ITEM_ENABLED) |
| { |
| SimpleInstallerMenu.InstallerMenuItem marketPlaceItem = new SimpleInstallerMenu.InstallerMenuItem(menu); |
| marketPlaceItem.setText(MARKET_PLACE_MENU_ITEM_TEXT); |
| marketPlaceItem.setToolTipText(Messages.SimpleInstallerDialog_BrowseMPC_message); |
| marketPlaceItem.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| OS.INSTANCE.openSystemBrowser("https://marketplace.eclipse.org"); //$NON-NLS-1$ |
| } |
| }); |
| } |
| |
| if (!StringUtil.isEmpty(FORUM_URL)) |
| { |
| SimpleInstallerMenu.InstallerMenuItem askAQuestionItem = new SimpleInstallerMenu.InstallerMenuItem(menu); |
| askAQuestionItem.setText(ASK_A_QUESTION_MENU_ITEM_TEXT); |
| askAQuestionItem.setToolTipText(Messages.SimpleInstallerDialog_AskQuestion_message); |
| askAQuestionItem.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| OS.INSTANCE.openSystemBrowser(FORUM_URL + "?version=" + URI.encodeQuery(SelfUpdate.getProductVersion(), false)); //$NON-NLS-1$ |
| } |
| }); |
| } |
| |
| if (!StringUtil.isEmpty(PROBLEM_REPORT_URL)) |
| { |
| SimpleInstallerMenu.InstallerMenuItem reportAProblemItem = new SimpleInstallerMenu.InstallerMenuItem(menu); |
| reportAProblemItem.setText(REPORT_A_PROBLEM_MENU_ITEM_TEXT); |
| reportAProblemItem.setToolTipText(Messages.SimpleInstallerDialog_ReportProblem_message); |
| reportAProblemItem.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| OS.INSTANCE.openSystemBrowser(PROBLEM_REPORT_URL + "?version=" + URI.encodeQuery(SelfUpdate.getProductVersion(), false)); //$NON-NLS-1$ |
| } |
| }); |
| } |
| |
| if (!StringUtil.isEmpty(CONTRIBUTE_URL)) |
| { |
| SimpleInstallerMenu.InstallerMenuItem reportAProblemItem = new SimpleInstallerMenu.InstallerMenuItem(menu); |
| reportAProblemItem.setText(CONTRIBUTE_MENU_ITEM_TEXT); |
| reportAProblemItem.setToolTipText(Messages.SimpleInstallerDialog_Contribute_message); |
| reportAProblemItem.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| OS.INSTANCE.openSystemBrowser(CONTRIBUTE_URL + "?version=" + URI.encodeQuery(SelfUpdate.getProductVersion(), false)); //$NON-NLS-1$ |
| } |
| }); |
| } |
| |
| SimpleInstallerMenu.InstallerMenuItem aboutItem = new SimpleInstallerMenu.InstallerMenuItem(menu); |
| aboutItem.setText(ABOUT_MENU_ITEM_TEXT); |
| aboutItem.setToolTipText(Messages.SimpleInstallerDialog_ShowAbout_message); |
| aboutItem.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| showAbout(); |
| } |
| }); |
| |
| SimpleInstallerMenu.InstallerMenuItem exitItem = new SimpleInstallerMenu.InstallerMenuItem(menu); |
| exitItem.setText(EXIT_MENU_ITEM_TEXT); |
| exitItem.setDividerVisible(false); |
| exitItem.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| exitSelected(); |
| } |
| }); |
| |
| return menu; |
| } |
| |
| public void setExtensionsAvailable(boolean available) |
| { |
| menuButton.setExtensionVisible(available); |
| } |
| |
| private void updateAvailable(boolean available) |
| { |
| menuButton.setNotificationVisible(available); |
| installerMenu.findMenuItemByName(UPDATE_MENU_ITEM_TEXT).setVisible(available); |
| installerMenu.layout(); |
| } |
| |
| private void manageBundlePools() |
| { |
| final boolean[] enabled = { poolEnabled }; |
| |
| AgentManagerDialog dialog = new AgentManagerDialog(getShell()) |
| { |
| @Override |
| protected void createUI(Composite parent) |
| { |
| final Button enabledButton = new Button(parent, SWT.CHECK); |
| enabledButton.setText(Messages.SimpleInstallerDialog_EnableBundlePool_label); |
| enabledButton.setSelection(poolEnabled); |
| enabledButton.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| enabled[0] = enabledButton.getSelection(); |
| getComposite().setEnabled(enabled[0]); |
| } |
| }); |
| |
| new Label(parent, SWT.NONE); |
| super.createUI(parent); |
| getComposite().setEnabled(poolEnabled); |
| } |
| |
| @Override |
| protected void createButtonsForButtonBar(Composite parent) |
| { |
| super.createButtonsForButtonBar(parent); |
| Button button = getButton(IDialogConstants.OK_ID); |
| if (button != null) |
| { |
| button.setEnabled(false); |
| } |
| } |
| |
| @Override |
| protected void elementChanged(Object element) |
| { |
| Button button = getButton(IDialogConstants.OK_ID); |
| if (button != null) |
| { |
| button.setEnabled(getSelectedBundlePool() != null || !enabled[0]); |
| } |
| } |
| }; |
| |
| if (pool != null) |
| { |
| dialog.setSelectedPool(pool); |
| } |
| |
| if (dialog.open() == AgentManagerDialog.OK) |
| { |
| enablePool(enabled[0]); |
| pool = dialog.getSelectedBundlePool(); |
| } |
| } |
| |
| @Override |
| public boolean refreshJREs() |
| { |
| if (variablePage != null) |
| { |
| return variablePage.refreshJREs(); |
| } |
| |
| return false; |
| } |
| |
| @Override |
| public void showAbout() |
| { |
| String version = SelfUpdate.getProductVersion(); |
| new AboutDialog(getShell(), version).open(); |
| } |
| |
| @Override |
| protected void runEventLoop() |
| { |
| getInstaller().runEventLoop(getShell()); |
| } |
| |
| public void productSelected(Product product) |
| { |
| variablePage.setProduct(product); |
| switchToPage(variablePage); |
| } |
| |
| public SimpleInstallerPage getTopPage() |
| { |
| return (SimpleInstallerPage)stackLayout.topControl; |
| } |
| |
| private void doSwitch(final SimpleInstallerPage oldPage, final SimpleInstallerPage newPage) |
| { |
| if (oldPage != null) |
| { |
| oldPage.aboutToHide(); |
| |
| if (newPage instanceof SimpleProductPage) |
| { |
| @SuppressWarnings("unchecked") |
| List<ProductCatalog> productCatalogs = (List<ProductCatalog>)catalogManager.getCatalogs(true); |
| notificationButton.setBrandingNotificationScope(productCatalogs); |
| } |
| } |
| |
| stackLayout.topControl = newPage; |
| stack.layout(); |
| |
| clearMessage(); |
| |
| newPage.aboutToShow(); |
| newPage.setFocus(); |
| } |
| |
| private void switchToPage(final SimpleInstallerPage newPage) |
| { |
| if (newPage != null) |
| { |
| SimpleInstallerPage oldPage = pageStack.peek(); |
| if (oldPage == null || oldPage != newPage) |
| { |
| pageStack.push(newPage); |
| doSwitch(oldPage, newPage); |
| } |
| } |
| } |
| |
| public void switchToAdvancedMode() |
| { |
| installer.setConfigurationResources(Collections.<Resource> emptySet()); |
| setReturnCode(RETURN_ADVANCED); |
| exitSelected(); |
| } |
| |
| public void restart() |
| { |
| setReturnCode(RETURN_RESTART); |
| exitSelected(); |
| } |
| |
| protected void exitQuiet() |
| { |
| super.exitSelected(); |
| } |
| |
| @Override |
| protected void exitSelected() |
| { |
| for (SimpleInstallerPage page : pageStack) |
| { |
| if (page instanceof SimpleVariablePage) |
| { |
| SimpleVariablePage variablePage = (SimpleVariablePage)page; |
| if (!variablePage.promptLaunchProduct(Messages.SimpleInstallerDialog_AboutToExit_message)) |
| { |
| return; |
| } |
| |
| break; |
| } |
| } |
| |
| exitQuiet(); |
| } |
| |
| public void backSelected() |
| { |
| if (pageStack.size() <= 1) |
| { |
| return; |
| } |
| |
| SimpleInstallerPage oldPage = pageStack.pop(); |
| SimpleInstallerPage newPage = pageStack.peek(); |
| |
| doSwitch(oldPage, newPage); |
| } |
| |
| public void showMessage(String message, SimpleMessageOverlay.Type type, boolean dismissAutomatically) |
| { |
| showMessage(message, type, dismissAutomatically, null); |
| } |
| |
| public void showMessage(String message, SimpleMessageOverlay.Type type, boolean dismissAutomatically, Runnable action) |
| { |
| showMessage(message, type, dismissAutomatically, action, null); |
| } |
| |
| public void showMessage(String message, SimpleMessageOverlay.Type type, boolean dismissAutomatically, Runnable action, Runnable closeAction) |
| { |
| // Check if we can reuse the current message to reduce flickering. |
| if (currentMessage == null || currentMessage.getType() != type || currentMessage.isDismissAutomatically() != dismissAutomatically |
| || currentMessage.getAction() != action || currentMessage.getCloseAction() != closeAction) |
| { |
| clearMessage(); |
| |
| final Control originalFocusControl = getShell().getDisplay().getFocusControl(); |
| if (originalFocusControl != null) |
| { |
| UIUtil.asyncExec(originalFocusControl, new Runnable() |
| { |
| @Override |
| public void run() |
| { |
| Control focusControl = getShell().getDisplay().getFocusControl(); |
| if (focusControl != originalFocusControl) |
| { |
| originalFocusControl.setFocus(); |
| } |
| } |
| }); |
| } |
| |
| currentMessage = new SimpleMessageOverlay(this, type, new ControlRelocator() |
| { |
| @Override |
| public void relocate(Control control) |
| { |
| Rectangle bounds = SimpleInstallerDialog.this.getBounds(); |
| int x = bounds.x + 5; |
| int y = bounds.y + 24; |
| |
| int width = bounds.width - 9; |
| |
| // Depending on the current page, the height varies. |
| int height = pageStack.peek() instanceof SimpleProductPage ? 87 : 70; |
| control.setBounds(x, y, width, height); |
| } |
| }, dismissAutomatically, action, closeAction); |
| } |
| |
| currentMessage.setMessage(message); |
| currentMessage.setVisible(true); |
| } |
| |
| public void clearMessage() |
| { |
| if (currentMessage != null) |
| { |
| if (!currentMessage.isDisposed()) |
| { |
| currentMessage.close(); |
| } |
| |
| currentMessage = null; |
| } |
| } |
| |
| public void showReadme(java.net.URI readmeURI) |
| { |
| if (readmePage != null) |
| { |
| readmePage.setReadmeURI(readmeURI); |
| switchToPage(readmePage); |
| } |
| else |
| { |
| OS.INSTANCE.openSystemBrowser(readmeURI.toString()); |
| } |
| } |
| |
| public void showInstallationLog(File installationLogFile) |
| { |
| installationLogPage.setInstallationLogFile(installationLogFile); |
| switchToPage(installationLogPage); |
| } |
| |
| public void showKeepInstaller(boolean startPermanentInstaller) |
| { |
| keepInstallerPage.setStartPermanentInstaller(startPermanentInstaller); |
| switchToPage(keepInstallerPage); |
| } |
| |
| @Override |
| public void dispose() |
| { |
| // Ensure that no Browser widget has the focus. See bug 466902. |
| menuButton.setFocus(); |
| super.dispose(); |
| } |
| |
| protected void handleBrandingNotificationURIOpen(URI uri) |
| { |
| Set<String> brandingNotificationURIs = new LinkedHashSet<String>(); |
| try |
| { |
| if (FILE_BRANDING_NOTIFICTION_URIS.isFile()) |
| { |
| brandingNotificationURIs.addAll(IOUtil.readLines(FILE_BRANDING_NOTIFICTION_URIS, "UTF-8")); //$NON-NLS-1$ |
| } |
| } |
| catch (RuntimeException ex) |
| { |
| // Ignore. |
| } |
| |
| brandingNotificationURIs.add(uri.toString()); |
| |
| try |
| { |
| IOUtil.writeLines(FILE_BRANDING_NOTIFICTION_URIS, "UTF-8", new ArrayList<String>(brandingNotificationURIs)); //$NON-NLS-1$ |
| } |
| catch (RuntimeException ex) |
| { |
| // Ignore. |
| } |
| } |
| |
| protected boolean hasOpenedBrandingNotificationURI(URI uri) |
| { |
| try |
| { |
| if (FILE_BRANDING_NOTIFICTION_URIS.isFile()) |
| { |
| return IOUtil.readLines(FILE_BRANDING_NOTIFICTION_URIS, "UTF-8").contains(uri.toString()); //$NON-NLS-1$ |
| } |
| } |
| catch (RuntimeException ex) |
| { |
| // Ignore. |
| } |
| |
| return false; |
| } |
| |
| static URI getBrandingSiteURI(Scope scope) |
| { |
| if (scope != null) |
| { |
| Annotation annotation = scope.getAnnotation(AnnotationConstants.ANNOTATION_BRANDING_INFO); |
| if (annotation != null) |
| { |
| String detail = annotation.getDetails().get(AnnotationConstants.KEY_SITE_URI); |
| if (detail != null) |
| { |
| return URI.createURI(detail); |
| } |
| } |
| |
| return getBrandingSiteURI(scope.getParentScope()); |
| } |
| |
| return null; |
| } |
| |
| public static Font getFont(int relativeHeight, String style) |
| { |
| String height = relativeHeight == 0 ? "" : relativeHeight > 0 ? "+" + relativeHeight : Integer.toString(relativeHeight); //$NON-NLS-1$ //$NON-NLS-2$ |
| return SetupInstallerPlugin.getFont(getDefaultFont(), org.eclipse.emf.common.util.URI.createURI("font:///" + height + "/" + style)); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| |
| static Font getDefaultFont() |
| { |
| if (defaultFont == null) |
| { |
| defaultFont = JFaceResources.getFont(SetupInstallerPlugin.FONT_LABEL_DEFAULT); |
| if (defaultFont == null) |
| { |
| defaultFont = UIUtil.getDisplay().getSystemFont(); |
| } |
| } |
| |
| return defaultFont; |
| } |
| |
| static Point getDefaultSize(Drawable drawable) |
| { |
| if (defaultSize == null) |
| { |
| defaultSize = computeSize(drawable, getDefaultFont(), 37, 38); |
| } |
| |
| return defaultSize; |
| } |
| |
| static Point computeSize(Drawable drawable, Font font, int x, int y) |
| { |
| GC gc = new GC(drawable); |
| gc.setFont(font); |
| |
| try |
| { |
| int height = gc.getFontMetrics().getHeight(); |
| int totalWidth = height * x; |
| int totalHeight = height * y; |
| Rectangle monitorArea = Display.getCurrent().getPrimaryMonitor().getClientArea(); |
| return new Point(Math.min(totalWidth, monitorArea.width / 3), Math.min(totalHeight, 2 * monitorArea.height / 3)); |
| } |
| finally |
| { |
| gc.dispose(); |
| } |
| } |
| |
| static String getCSS() |
| { |
| if (css == null) |
| { |
| try |
| { |
| css = readBundleResource("html/css/simpleInstaller.css"); //$NON-NLS-1$ |
| } |
| catch (IOException ex) |
| { |
| SetupInstallerPlugin.INSTANCE.log(ex); |
| } |
| } |
| |
| return css; |
| } |
| |
| static String getPageTemplate() |
| { |
| if (pageTemplate == null) |
| { |
| try |
| { |
| pageTemplate = readBundleResource("html/PageTemplate.html"); //$NON-NLS-1$ |
| |
| // Embed CSS |
| pageTemplate = pageTemplate.replace("%INSTALLER_CSS%", SimpleInstallerDialog.getCSS()); //$NON-NLS-1$ |
| } |
| catch (IOException ex) |
| { |
| SetupInstallerPlugin.INSTANCE.log(ex); |
| } |
| } |
| |
| return pageTemplate; |
| } |
| |
| static String getProductTemplate() |
| { |
| if (productTemplate == null) |
| { |
| try |
| { |
| productTemplate = readBundleResource("html/ProductTemplate.html"); //$NON-NLS-1$ |
| } |
| catch (IOException ex) |
| { |
| SetupInstallerPlugin.INSTANCE.log(ex); |
| } |
| } |
| |
| return productTemplate; |
| } |
| |
| static String getProductTemplateLarge() |
| { |
| if (productTemplateLarge == null) |
| { |
| try |
| { |
| productTemplateLarge = readBundleResource("html/ProductTemplateLarge.html"); //$NON-NLS-1$ |
| } |
| catch (IOException ex) |
| { |
| SetupInstallerPlugin.INSTANCE.log(ex); |
| } |
| } |
| |
| return productTemplateLarge; |
| } |
| |
| private static String readBundleResource(final String name) throws IOException |
| { |
| try |
| { |
| BundleFile root = SetupInstallerPlugin.INSTANCE.getRootFile(); |
| BundleFile child = root.getChild(name); |
| return child.getContentsString(); |
| } |
| catch (Exception ex) |
| { |
| throw new IOExceptionWithCause(ex); |
| } |
| } |
| |
| /** |
| * @author Ed Merks |
| */ |
| private static class NotifictionButton extends FlatButton |
| { |
| /** |
| * The color of the button if it's animated, hovered, for focused. |
| */ |
| private static final Color COLOR_INTENSE = SimpleInstallLaunchButton.COLOR_INSTALL; |
| |
| /** |
| * The color of the button if it's not animated. |
| */ |
| private static final Color COLOR_SUBTLE = SetupInstallerPlugin.getColor(210, 210, 210); |
| |
| /** |
| * The roundness of the button. |
| */ |
| private static final int CORNER_WIDTH = 10; |
| |
| /** |
| * The offset when the button is almost completely hidden. |
| */ |
| private static final int MAX_OFFSET = 22; |
| |
| /** |
| * The current offset that determines how much of the button is showing. |
| */ |
| private int offset = MAX_OFFSET; |
| |
| /** |
| * Whether the button should be animated. |
| */ |
| private AnimationStyle animationStyle; |
| |
| /** |
| * The timer executed runnable for animating this button. |
| */ |
| private Runnable animator; |
| |
| /** |
| * The URI to open. |
| */ |
| private URI uri; |
| |
| /** |
| * The direction in which the button animates. |
| */ |
| private int direction = -1; |
| |
| private Color buttonColor = COLOR_INTENSE; |
| |
| private boolean highlight; |
| |
| private String scopeLabel; |
| |
| public NotifictionButton(Composite parent) |
| { |
| super(parent, SWT.PUSH); |
| |
| setShowButtonDownState(false); |
| setCornerWidth(CORNER_WIDTH); |
| setAlignment(SWT.CENTER); |
| setImage(SetupInstallerPlugin.INSTANCE.getSWTImage("simple/star_white.png")); //$NON-NLS-1$ |
| setForeground(COLOR_WHITE); |
| setBackground(COLOR_SUBTLE); |
| setFont(SimpleInstallerDialog.getFont(1, "bold")); //$NON-NLS-1$ |
| setVisible(false); |
| addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| handleWidgetSelected(); |
| } |
| }); |
| } |
| |
| protected void handleWidgetSelected() |
| { |
| String resolvedURI = uri.toString().replace("${installer.version}", URI.encodeQuery(SelfUpdate.getProductVersion(), true)).replace("${scope}", //$NON-NLS-1$ //$NON-NLS-2$ |
| URI.encodeQuery(StringUtil.safe(scopeLabel), false).replace("+", "%2B").replace("&", "%26")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ |
| OS.INSTANCE.openSystemBrowser(resolvedURI); |
| update(getURI(), getText(), getToolTipText(), AnimationStyle.NONE, false, buttonColor, scopeLabel); |
| } |
| |
| public URI getURI() |
| { |
| return uri; |
| } |
| |
| public void update(URI uri, String text, String tooltip, AnimationStyle animationStyle, boolean highlight, Color color, String scopeLabel) |
| { |
| this.scopeLabel = scopeLabel; |
| if (!ObjectUtil.equals(uri, this.uri) || this.animationStyle != animationStyle || !ObjectUtil.equals(text, getText()) |
| || !ObjectUtil.equals(tooltip, getToolTipText()) || !ObjectUtil.equals(color, buttonColor) || this.highlight != highlight) |
| { |
| this.uri = uri; |
| this.highlight = highlight; |
| animator = null; |
| this.animationStyle = animationStyle; |
| buttonColor = color; |
| offset = animationStyle != AnimationStyle.NONE ? MAX_OFFSET : 0; |
| setVisible(uri != null); |
| setBackground(highlight ? buttonColor : COLOR_SUBTLE); |
| |
| setText(text); |
| setToolTipText(tooltip); |
| |
| getParent().getParent().layout(true); |
| |
| redraw(); |
| } |
| } |
| |
| @Override |
| protected void onHover() |
| { |
| if (isHover()) |
| { |
| animator = null; |
| offset = 0; |
| setBackground(buttonColor); |
| setImage(SetupInstallerPlugin.INSTANCE.getSWTImage("simple/star_black.png")); //$NON-NLS-1$ |
| } |
| else |
| { |
| setBackground(highlight ? buttonColor : COLOR_SUBTLE); |
| setImage(SetupInstallerPlugin.INSTANCE.getSWTImage("simple/star_white.png")); //$NON-NLS-1$ |
| offset = animationStyle == AnimationStyle.REPEAT ? MAX_OFFSET : 0; |
| } |
| } |
| |
| @Override |
| protected void onFocusIn(Event event) |
| { |
| animator = null; |
| offset = 0; |
| setBackground(buttonColor); |
| setImage(SetupInstallerPlugin.INSTANCE.getSWTImage("simple/star_black.png")); //$NON-NLS-1$ |
| } |
| |
| @Override |
| protected void onFocusOut(Event event) |
| { |
| setBackground(highlight ? buttonColor : COLOR_SUBTLE); |
| setImage(SetupInstallerPlugin.INSTANCE.getSWTImage("simple/star_white.png")); //$NON-NLS-1$ |
| offset = animationStyle == AnimationStyle.REPEAT ? MAX_OFFSET : 0; |
| redraw(); |
| } |
| |
| @Override |
| protected Point getTotalSize() |
| { |
| Point totalSize = super.getTotalSize(); |
| totalSize.x += 20; |
| totalSize.y += 8; |
| return totalSize; |
| } |
| |
| private int getEffectiveOffset() |
| { |
| return isHover() || isFocusControl() ? direction == 1 ? 0 : -CORNER_WIDTH : direction == 1 ? offset * direction : offset * direction - CORNER_WIDTH; |
| } |
| |
| @Override |
| protected void drawFocusState(GC gc, int x, int y, int width, int height) |
| { |
| super.drawFocusState(gc, x, y + getEffectiveOffset(), width, height + CORNER_WIDTH); |
| } |
| |
| @Override |
| public void drawBackground(GC gc, int x, int y, int width, int height, int offsetX, int offsetY) |
| { |
| if (animationStyle != AnimationStyle.NONE && animator == null) |
| { |
| animator = new Animator(); |
| UIUtil.timerExec(1000, animator); |
| } |
| |
| super.drawBackground(gc, x, y + getEffectiveOffset(), width, height + CORNER_WIDTH, offsetX, offsetY); |
| } |
| |
| @Override |
| protected void drawText(GC gc, int x, int y) |
| { |
| int effectiveOffset = getEffectiveOffset(); |
| if (effectiveOffset != MAX_OFFSET) |
| { |
| super.drawText(gc, x + 10, y + effectiveOffset + (direction == 0 ? 0 : CORNER_WIDTH - 1)); |
| } |
| } |
| |
| @Override |
| protected void drawImage(GC gc, int x, int y) |
| { |
| int effectiveOffset = getEffectiveOffset(); |
| if (effectiveOffset != MAX_OFFSET) |
| { |
| super.drawImage(gc, x + 10, y + effectiveOffset + (direction == 0 ? 0 : CORNER_WIDTH - 1)); |
| } |
| } |
| |
| protected boolean hasOpenedBrandingNotificationURI(URI uri) |
| { |
| return false; |
| } |
| |
| public void setBrandingNotificationScope(List<ProductCatalog> productCatalogs) |
| { |
| if (productCatalogs != null) |
| { |
| int targetPriority = Integer.MAX_VALUE; |
| ProductCatalog targetProductCatalog = null; |
| for (ProductCatalog productCatalog : productCatalogs) |
| { |
| if (SimpleProductPage.isIncluded(productCatalog)) |
| { |
| int priority = getBrandingNotificationPriority(productCatalog); |
| if (priority < targetPriority || targetProductCatalog == null && getBrandingNotificationURI(productCatalog) != null) |
| { |
| targetPriority = priority; |
| targetProductCatalog = productCatalog; |
| } |
| } |
| } |
| |
| if (targetProductCatalog != null) |
| { |
| setBrandingNotificationScope(targetProductCatalog); |
| } |
| } |
| } |
| |
| public void setBrandingNotificationScope(Scope scope) |
| { |
| URI notificationURI = getBrandingNotificationURI(scope); |
| String notificationLabel = getBrandingNotificationLabel(scope); |
| String notificationTooltip = getBrandingNotificationTooltip(scope); |
| String brandingNotificationScopeLabel = getBrandingNotificationScopeLabel(scope); |
| if (brandingNotificationScopeLabel == null) |
| { |
| brandingNotificationScopeLabel = getImplicitBrandingNotificationLabel(scope); |
| } |
| |
| boolean hasOpenedBrandingNotificationURI = hasOpenedBrandingNotificationURI(notificationURI); |
| update(notificationURI, notificationLabel, notificationTooltip, |
| hasOpenedBrandingNotificationURI ? AnimationStyle.NONE : getBrandingNotificationAnimationStyle(scope), !hasOpenedBrandingNotificationURI, |
| getBrandingNotificationColor(scope), brandingNotificationScopeLabel); |
| } |
| |
| private static int getBrandingNotificationPriority(Scope scope) |
| { |
| if (scope != null) |
| { |
| Annotation annotation = scope.getAnnotation(AnnotationConstants.ANNOTATION_BRANDING_INFO); |
| if (annotation != null) |
| { |
| String detail = annotation.getDetails().get(AnnotationConstants.KEY_NOTIFICATION_PRIORITY); |
| if (detail != null) |
| { |
| try |
| { |
| return Integer.parseInt(detail); |
| } |
| catch (RuntimeException ex) |
| { |
| } |
| } |
| } |
| } |
| |
| return Integer.MAX_VALUE; |
| } |
| |
| private static URI getBrandingNotificationURI(Scope scope) |
| { |
| if (scope != null) |
| { |
| Annotation annotation = scope.getAnnotation(AnnotationConstants.ANNOTATION_BRANDING_INFO); |
| if (annotation != null) |
| { |
| String detail = annotation.getDetails().get(AnnotationConstants.KEY_NOTIFICATION_URI); |
| if (detail != null) |
| { |
| return URI.createURI(detail); |
| } |
| } |
| |
| return getBrandingNotificationURI(scope.getParentScope()); |
| } |
| |
| return null; |
| } |
| |
| private static String getBrandingNotificationLabel(Scope scope) |
| { |
| if (scope != null) |
| { |
| Annotation annotation = scope.getAnnotation(AnnotationConstants.ANNOTATION_BRANDING_INFO); |
| if (annotation != null) |
| { |
| String detail = annotation.getDetails().get(AnnotationConstants.KEY_NOTIFICATION_LABEL); |
| if (detail != null) |
| { |
| return detail; |
| } |
| } |
| |
| return getBrandingNotificationLabel(scope.getParentScope()); |
| } |
| |
| return null; |
| } |
| |
| private static String getImplicitBrandingNotificationLabel(Scope scope) |
| { |
| if (scope != null) |
| { |
| String label = scope.getLabel(); |
| if (label != null) |
| { |
| Scope parentScope = scope.getParentScope(); |
| if (parentScope instanceof Product) |
| { |
| String projectLabel = parentScope.getLabel(); |
| if (projectLabel != null) |
| { |
| return projectLabel + "-" + label; //$NON-NLS-1$ |
| } |
| } |
| |
| return label; |
| } |
| } |
| |
| return null; |
| } |
| |
| private static String getBrandingNotificationScopeLabel(Scope scope) |
| { |
| if (scope != null) |
| { |
| Annotation annotation = scope.getAnnotation(AnnotationConstants.ANNOTATION_BRANDING_INFO); |
| if (annotation != null) |
| { |
| String detail = annotation.getDetails().get(AnnotationConstants.KEY_NOTIFICATION_SCOPE); |
| if (detail != null) |
| { |
| return detail; |
| } |
| } |
| |
| return getBrandingNotificationScopeLabel(scope.getParentScope()); |
| } |
| |
| return null; |
| } |
| |
| private static Color getBrandingNotificationColor(Scope scope) |
| { |
| if (scope != null) |
| { |
| Annotation annotation = scope.getAnnotation(AnnotationConstants.ANNOTATION_BRANDING_INFO); |
| if (annotation != null) |
| { |
| String detail = annotation.getDetails().get(AnnotationConstants.KEY_NOTIFICATION_COLOR); |
| if (detail != null) |
| { |
| try |
| { |
| return ExtendedColorRegistry.INSTANCE.getColor(COLOR_WHITE, COLOR_DEFAULT_FOCUS_FOREGROUND, URI.createURI(detail)); |
| } |
| catch (RuntimeException ex) |
| { |
| //$FALL-THROUGH$ |
| } |
| } |
| } |
| |
| return getBrandingNotificationColor(scope.getParentScope()); |
| } |
| |
| return COLOR_INTENSE; |
| } |
| |
| private static String getBrandingNotificationTooltip(Scope scope) |
| { |
| if (scope != null) |
| { |
| Annotation annotation = scope.getAnnotation(AnnotationConstants.ANNOTATION_BRANDING_INFO); |
| if (annotation != null) |
| { |
| String detail = annotation.getDetails().get(AnnotationConstants.KEY_NOTIFICATION_TOOLTIP); |
| if (detail != null) |
| { |
| return detail; |
| } |
| } |
| |
| return getBrandingNotificationTooltip(scope.getParentScope()); |
| } |
| |
| return null; |
| } |
| |
| private static AnimationStyle getBrandingNotificationAnimationStyle(Scope scope) |
| { |
| if (scope != null) |
| { |
| Annotation annotation = scope.getAnnotation(AnnotationConstants.ANNOTATION_BRANDING_INFO); |
| if (annotation != null) |
| { |
| String detail = annotation.getDetails().get(AnnotationConstants.KEY_NOTIFICATION_ANIMATION_STYLE); |
| if (detail != null) |
| { |
| try |
| { |
| return AnimationStyle.valueOf(detail); |
| } |
| catch (RuntimeException ex) |
| { |
| //$FALL-THROUGH$ |
| } |
| } |
| } |
| |
| return getBrandingNotificationAnimationStyle(scope.getParentScope()); |
| } |
| |
| return AnimationStyle.NONE; |
| } |
| |
| /** |
| * @author Ed Merks |
| */ |
| private class Animator implements Runnable |
| { |
| @Override |
| public void run() |
| { |
| if (animator == this && !isDisposed()) |
| { |
| redraw(); |
| offset -= 1; |
| if (offset == -1) |
| { |
| if (animationStyle == AnimationStyle.REPEAT) |
| { |
| offset = MAX_OFFSET; |
| UIUtil.timerExec(500, animator); |
| } |
| else |
| { |
| offset = 0; |
| } |
| } |
| else if (offset == 0) |
| { |
| if (animationStyle == AnimationStyle.REPEAT) |
| { |
| UIUtil.timerExec(2000, animator); |
| } |
| } |
| else |
| { |
| UIUtil.timerExec(100, animator); |
| } |
| } |
| } |
| } |
| |
| /** |
| * @author Ed Merks |
| */ |
| private enum AnimationStyle |
| { |
| NONE, ONCE, REPEAT |
| } |
| |
| } |
| |
| /** |
| * @author Eike Stepper |
| */ |
| private final class UpdateSearcher extends Thread |
| { |
| private Display display; |
| |
| public UpdateSearcher(Display display) |
| { |
| super(Messages.SimpleInstallerDialog_UpdateSearcher_job); |
| this.display = display; |
| } |
| |
| @Override |
| public void run() |
| { |
| try |
| { |
| User user = getInstaller().getUser(); |
| updateResolution = SelfUpdate.resolve(user, null); |
| if (updateResolution != null && !display.isDisposed()) |
| { |
| display.asyncExec(new Runnable() |
| { |
| @Override |
| public void run() |
| { |
| updateAvailable(true); |
| } |
| }); |
| } |
| } |
| catch (CoreException ex) |
| { |
| SetupInstallerPlugin.INSTANCE.log(ex); |
| } |
| } |
| } |
| |
| /** |
| * @author Eike Stepper |
| */ |
| private static final class PageStack extends LinkedList<SimpleInstallerPage> |
| { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public void push(SimpleInstallerPage page) |
| { |
| addLast(page); |
| } |
| |
| @Override |
| public SimpleInstallerPage pop() |
| { |
| return removeLast(); |
| } |
| |
| @Override |
| public SimpleInstallerPage peek() |
| { |
| return isEmpty() ? null : getLast(); |
| } |
| } |
| } |
