| /* |
| * Copyright (c) 2014-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 |
| */ |
| package org.eclipse.oomph.setup.ui.recorder; |
| |
| import org.eclipse.oomph.base.provider.BaseEditUtil; |
| import org.eclipse.oomph.internal.ui.AbstractPreferencePage; |
| import org.eclipse.oomph.setup.Installation; |
| import org.eclipse.oomph.setup.Product; |
| import org.eclipse.oomph.setup.Project; |
| import org.eclipse.oomph.setup.Scope; |
| import org.eclipse.oomph.setup.Stream; |
| import org.eclipse.oomph.setup.Workspace; |
| import org.eclipse.oomph.setup.internal.core.SetupContext; |
| import org.eclipse.oomph.setup.internal.core.util.SetupCoreUtil; |
| import org.eclipse.oomph.setup.ui.SetupEditorSupport; |
| import org.eclipse.oomph.setup.ui.SetupLabelProvider; |
| import org.eclipse.oomph.setup.ui.SetupUIPlugin; |
| import org.eclipse.oomph.setup.ui.synchronizer.SynchronizerManager; |
| import org.eclipse.oomph.ui.SearchField; |
| import org.eclipse.oomph.ui.SearchField.FilterHandler; |
| import org.eclipse.oomph.ui.ToolButton; |
| import org.eclipse.oomph.ui.UIUtil; |
| import org.eclipse.oomph.util.ObjectUtil; |
| |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.resource.URIConverter; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.emf.edit.provider.ComposedAdapterFactory; |
| import org.eclipse.emf.edit.provider.IItemLabelProvider; |
| import org.eclipse.emf.edit.provider.ItemProviderAdapter; |
| |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.jface.dialogs.Dialog; |
| import org.eclipse.jface.dialogs.IDialogConstants; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.preference.IPreferenceNode; |
| import org.eclipse.jface.preference.PreferenceDialog; |
| import org.eclipse.jface.preference.PreferenceManager; |
| import org.eclipse.jface.viewers.CheckStateChangedEvent; |
| import org.eclipse.jface.viewers.ICheckStateListener; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.jface.viewers.ViewerFilter; |
| import org.eclipse.nebula.widgets.tablecombo.TableCombo; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.graphics.Point; |
| 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.Label; |
| import org.eclipse.swt.widgets.TableItem; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.PlatformUI; |
| |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * @author Eike Stepper |
| */ |
| public class RecorderPreferencePage extends AbstractPreferencePage |
| { |
| private static RecorderPreferencePage instance; |
| |
| private final URIConverter uriConverter = SetupCoreUtil.createResourceSet().getURIConverter(); |
| |
| private RecorderTransaction transaction; |
| |
| private Button enableButton; |
| |
| private TableCombo targetCombo; |
| |
| private ToolButton editButton; |
| |
| private Label policiesLabel; |
| |
| private SearchField policiesFilter; |
| |
| private RecorderPoliciesComposite policiesComposite; |
| |
| private Button initializePreferencesButton; |
| |
| private Job openTransactionJob; |
| |
| public RecorderPreferencePage() |
| { |
| instance = this; |
| } |
| |
| @Override |
| public void dispose() |
| { |
| if (transaction != null) |
| { |
| closeRecorderTransaction(); |
| } |
| |
| instance = null; |
| super.dispose(); |
| } |
| |
| @Override |
| protected Control doCreateContents(Composite parent) |
| { |
| if (RecorderManager.INSTANCE.hasTemporaryRecorderTarget()) |
| { |
| Label label = new Label(parent, SWT.NONE); |
| label.setText("The preference recorder settings are unavailable while recording into the selected file."); |
| return label; |
| } |
| |
| int columns = 3; |
| |
| Composite composite = new Composite(parent, SWT.NONE); |
| composite.setLayout(UIUtil.createGridLayout(columns)); |
| |
| enableButton = new Button(composite, SWT.CHECK); |
| enableButton.setText("Record into:"); |
| enableButton.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| boolean enableRecorder = enableButton.getSelection(); |
| RecorderManager.INSTANCE.setRecorderEnabled(enableRecorder); |
| |
| if (!enableRecorder) |
| { |
| policiesFilter.getFilterControl().setText(""); |
| } |
| |
| updateEnablement(); |
| RecorderManager.updateRecorderToggleButton(); |
| |
| if (enableRecorder && SynchronizerManager.Availability.AVAILABLE) |
| { |
| boolean firstTime = SynchronizerManager.INSTANCE.offerFirstTimeConnect(getShell()); |
| RecorderManager.INSTANCE.startEarlySynchronization(firstTime); |
| } |
| } |
| }); |
| |
| targetCombo = new TableCombo(composite, SWT.BORDER | SWT.READ_ONLY); |
| targetCombo.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| targetCombo.defineColumns(2); |
| targetCombo.setToolTipText("Select the recorder target file"); |
| targetCombo.getTable().addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| if (e.item instanceof TableItem) |
| { |
| TableItem item = (TableItem)e.item; |
| URI uri = (URI)item.getData(); |
| |
| URI oldURI = RecorderManager.INSTANCE.setRecorderTarget(uri); |
| if (oldURI != null) |
| { |
| if (transaction != null) |
| { |
| int dirtyPolicies = transaction.getPolicies(false).size(); |
| if (dirtyPolicies != 0) |
| { |
| if (MessageDialog.openQuestion(getShell(), "Changed Recorder Policies", |
| "Do you want to save the changed policies before you change the recorder target?")) |
| { |
| transaction.commit(); |
| } |
| } |
| |
| closeRecorderTransaction(); |
| } |
| |
| openRecorderTransaction(null); |
| } |
| } |
| } |
| }); |
| |
| ComposedAdapterFactory adapterFactory = BaseEditUtil.createAdapterFactory(); |
| SetupContext setupContext = SetupContext.getSelf(); |
| Set<Scope> targets = new HashSet<Scope>(); |
| |
| addTarget(adapterFactory, targets, setupContext.getUser()); |
| |
| Installation installation = setupContext.getInstallation(); |
| addTarget(adapterFactory, targets, installation); |
| |
| Workspace workspace = setupContext.getWorkspace(); |
| addTarget(adapterFactory, targets, workspace); |
| |
| if (installation != null) |
| { |
| addTarget(adapterFactory, targets, installation.getProductVersion()); |
| } |
| |
| if (workspace != null) |
| { |
| for (Stream stream : workspace.getStreams()) |
| { |
| addTarget(adapterFactory, targets, stream); |
| } |
| } |
| |
| URI uri = RecorderManager.INSTANCE.getRecorderTarget(); |
| selectRecorderTarget(uri); |
| adapterFactory.dispose(); |
| |
| editButton = new ToolButton(composite, 0, SetupUIPlugin.INSTANCE.getSWTImage("edit.gif"), false); |
| editButton.setToolTipText("Open the recorder target file"); |
| editButton.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); |
| if (page != null) |
| { |
| SetupEditorSupport.getEditor(page, RecorderManager.INSTANCE.getRecorderTarget(), true); |
| |
| Map<String, Boolean> policies = null; |
| if (transaction != null) |
| { |
| policies = transaction.getPolicies(false); |
| closeRecorderTransaction(); |
| } |
| |
| openRecorderTransaction(policies); |
| updateEnablement(); |
| } |
| } |
| }); |
| |
| Label separator = new Label(composite, SWT.SEPARATOR | SWT.HORIZONTAL); |
| separator.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, columns, 1)); |
| |
| policiesLabel = new Label(composite, SWT.NONE); |
| policiesLabel.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, columns, 1)); |
| policiesLabel.setText("Check the preferences to record and uncheck those to ignore:"); |
| |
| FilterHandler filterHandler = new FilterHandler() |
| { |
| public void handleFilter(String filter) |
| { |
| ViewerFilter viewerFilter = null; |
| if (filter.length() != 0) |
| { |
| final String subString = filter.toLowerCase(); |
| viewerFilter = new ViewerFilter() |
| { |
| @Override |
| public boolean select(Viewer viewer, Object parentElement, Object element) |
| { |
| return ((String)element).toLowerCase().contains(subString); |
| } |
| }; |
| } |
| |
| policiesComposite.setFilter(viewerFilter); |
| policiesComposite.selectFirstPolicy(); |
| } |
| }; |
| |
| policiesFilter = new SearchField(composite, filterHandler) |
| { |
| @Override |
| protected void finishFilter() |
| { |
| policiesComposite.setFocus(); |
| policiesComposite.selectFirstPolicy(); |
| } |
| }; |
| |
| policiesFilter.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, columns, 1)); |
| |
| policiesComposite = new RecorderPoliciesComposite(composite, SWT.BORDER | SWT.FULL_SELECTION, true); |
| policiesComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, columns, 1)); |
| policiesComposite.addCheckStateListener(new ICheckStateListener() |
| { |
| public void checkStateChanged(CheckStateChangedEvent event) |
| { |
| updateEnablement(); |
| } |
| }); |
| |
| updateEnablement(); |
| openRecorderTransaction(null); |
| return composite; |
| } |
| |
| @Override |
| public void createControl(Composite parent) |
| { |
| super.createControl(parent); |
| ((GridLayout)initializePreferencesButton.getParent().getLayout()).numColumns += 1; |
| } |
| |
| @Override |
| protected void contributeButtons(Composite parent) |
| { |
| initializePreferencesButton = new Button(parent, SWT.PUSH); |
| initializePreferencesButton.setText("Initialize..."); |
| |
| int widthHint = convertHorizontalDLUsToPixels(IDialogConstants.BUTTON_WIDTH); |
| Dialog.applyDialogFont(initializePreferencesButton); |
| Point minButtonSize = initializePreferencesButton.computeSize(SWT.DEFAULT, SWT.DEFAULT, true); |
| GridData data = new GridData(GridData.HORIZONTAL_ALIGN_FILL); |
| data.widthHint = Math.max(widthHint, minButtonSize.x); |
| initializePreferencesButton.setLayoutData(data); |
| |
| final PreferenceManager preferenceManager = PlatformUI.getWorkbench().getPreferenceManager(); |
| initializePreferencesButton.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| new PreferenceInitializationDialog((PreferenceDialog)getContainer(), preferenceManager).open(); |
| } |
| }); |
| |
| Set<String> preferencePages = RecorderManager.INSTANCE.getInitializedPreferencePages(); |
| @SuppressWarnings("all") |
| List<IPreferenceNode> preferenceNodes = preferenceManager.getElements(PreferenceManager.PRE_ORDER); |
| for (IPreferenceNode element : preferenceNodes) |
| { |
| String id = element.getId(); |
| if (preferencePages.contains(id)) |
| { |
| initializePreferencesButton.setEnabled(false); |
| break; |
| } |
| } |
| } |
| |
| private void openRecorderTransaction(final Map<String, Boolean> policies) |
| { |
| if (openTransactionJob == null) |
| { |
| openTransactionJob = new Job("Open recorder transaction") |
| { |
| @Override |
| protected IStatus run(final IProgressMonitor monitor) |
| { |
| if (!monitor.isCanceled()) |
| { |
| final RecorderTransaction transaction = RecorderTransaction.open(); |
| transaction.setPolicies(policies); |
| |
| if (!monitor.isCanceled()) |
| { |
| UIUtil.syncExec(policiesComposite, new Runnable() |
| { |
| public void run() |
| { |
| if (!monitor.isCanceled()) |
| { |
| updateEnablement(); |
| policiesComposite.setRecorderTransaction(transaction); |
| RecorderPreferencePage.this.transaction = transaction; |
| } |
| } |
| }); |
| } |
| } |
| |
| return Status.OK_STATUS; |
| } |
| }; |
| |
| openTransactionJob.setSystem(true); |
| } |
| |
| openTransactionJob.cancel(); |
| openTransactionJob.schedule(); |
| } |
| |
| private void closeRecorderTransaction() |
| { |
| transaction.close(); |
| transaction = null; |
| } |
| |
| @Override |
| protected void performDefaults() |
| { |
| transaction.resetPolicies(); |
| policiesComposite.setRecorderTransaction(transaction); |
| super.performDefaults(); |
| } |
| |
| @Override |
| protected void performApply() |
| { |
| super.performApply(); |
| updateEnablement(); |
| } |
| |
| @Override |
| public boolean performOk() |
| { |
| if (transaction != null) |
| { |
| transaction.commit(); |
| closeRecorderTransaction(); |
| } |
| |
| return super.performOk(); |
| } |
| |
| private boolean needsApply() |
| { |
| return transaction != null && transaction.isDirty(); |
| } |
| |
| private void selectRecorderTarget(URI uri) |
| { |
| int i = 0; |
| for (TableItem item : targetCombo.getTable().getItems()) |
| { |
| URI itemURI = (URI)item.getData(); |
| if (ObjectUtil.equals(itemURI, uri)) |
| { |
| targetCombo.select(i); |
| return; |
| } |
| |
| ++i; |
| } |
| } |
| |
| private boolean addTarget(ComposedAdapterFactory adapterFactory, Set<Scope> targets, Scope target) |
| { |
| if (target != null && targets.add(target)) |
| { |
| URI uri = EcoreUtil.getURI(target); |
| if (uri != null) |
| { |
| Map<?, ?> options = Collections.singletonMap(URIConverter.OPTION_REQUESTED_ATTRIBUTES, Collections.singleton(URIConverter.ATTRIBUTE_READ_ONLY)); |
| Map<String, ?> attributes = uriConverter.getAttributes(uri.trimFragment(), options); |
| boolean writable = !Boolean.TRUE.equals(attributes.get(URIConverter.ATTRIBUTE_READ_ONLY)); |
| |
| if (writable) |
| { |
| Scope parentScope = target.getParentScope(); |
| if (parentScope instanceof Product || parentScope instanceof Project) |
| { |
| addTarget(adapterFactory, targets, parentScope); |
| } |
| |
| String location = uri.trimFragment().toString(); |
| ItemProviderAdapter itemProvider = (ItemProviderAdapter)adapterFactory.adapt(target, IItemLabelProvider.class); |
| |
| TableItem item = new TableItem(targetCombo.getTable(), SWT.NONE); |
| item.setData(uri); |
| item.setImage(0, SetupUIPlugin.INSTANCE.getSWTImage(SetupLabelProvider.getImageDescriptor(itemProvider, target))); |
| item.setText(0, SetupLabelProvider.getText(itemProvider, target)); |
| item.setText(1, location); |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| static void updateEnablement() |
| { |
| if (instance != null) |
| { |
| boolean recorderEnabled = RecorderManager.INSTANCE.isRecorderEnabled(); |
| if (instance.enableButton != null) |
| { |
| instance.enableButton.setSelection(recorderEnabled); |
| instance.targetCombo.setEnabled(recorderEnabled); |
| instance.editButton.setEnabled(recorderEnabled && (instance.transaction == null || instance.transaction.getEditor() == null)); |
| instance.policiesLabel.setEnabled(recorderEnabled); |
| instance.policiesFilter.setEnabled(recorderEnabled); |
| instance.policiesComposite.setEnabled(recorderEnabled); |
| } |
| |
| Button applyButton = instance.getApplyButton(); |
| if (applyButton != null) |
| { |
| boolean needsApply = instance.needsApply(); |
| applyButton.setEnabled(needsApply); |
| } |
| |
| Button defaultsButton = instance.getDefaultsButton(); |
| if (defaultsButton != null) |
| { |
| defaultsButton.setEnabled(recorderEnabled); |
| } |
| } |
| } |
| } |
