| /******************************************************************************* |
| * Copyright (c) 2011-2018 EclipseSource Muenchen GmbH 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: |
| * Clemens Elflein - initial API and implementation |
| * Johannes Faltermeier - initial API and implementation |
| * Christian W. Damus - bug 533568 |
| ******************************************************************************/ |
| package org.eclipse.emfforms.spi.swt.treemasterdetail; |
| |
| import java.util.Iterator; |
| import java.util.LinkedHashSet; |
| import java.util.Set; |
| |
| import org.eclipse.core.databinding.observable.ChangeEvent; |
| import org.eclipse.core.databinding.observable.IChangeListener; |
| import org.eclipse.core.internal.databinding.observable.DelayedObservableValue; |
| import org.eclipse.emf.common.command.Command; |
| import org.eclipse.emf.common.command.CompoundCommand; |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.common.notify.impl.AdapterImpl; |
| import org.eclipse.emf.ecore.EAttribute; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.emf.ecp.ui.view.ECPRendererException; |
| import org.eclipse.emf.ecp.ui.view.swt.ECPSWTView; |
| import org.eclipse.emf.ecp.ui.view.swt.ECPSWTViewRenderer; |
| import org.eclipse.emf.ecp.view.spi.common.callback.ViewModelPropertiesUpdateCallback; |
| import org.eclipse.emf.ecp.view.spi.context.ViewModelContext; |
| import org.eclipse.emf.ecp.view.spi.context.ViewModelContextFactory; |
| import org.eclipse.emf.ecp.view.spi.model.VView; |
| import org.eclipse.emf.ecp.view.spi.model.VViewFactory; |
| import org.eclipse.emf.ecp.view.spi.model.VViewModelProperties; |
| import org.eclipse.emf.ecp.view.spi.provider.ViewProviderHelper; |
| import org.eclipse.emf.ecp.view.treemasterdetail.model.VTreeMasterDetail; |
| import org.eclipse.emf.edit.command.AddCommand; |
| import org.eclipse.emf.edit.command.DeleteCommand; |
| import org.eclipse.emf.edit.command.SetCommand; |
| import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain; |
| import org.eclipse.emf.edit.domain.EditingDomain; |
| import org.eclipse.emf.edit.domain.IEditingDomainProvider; |
| import org.eclipse.emfforms.spi.swt.treemasterdetail.util.DetailPanelRenderingFinishedCallback; |
| import org.eclipse.emfforms.spi.swt.treemasterdetail.util.RootObject; |
| import org.eclipse.jface.databinding.viewers.IViewerObservableValue; |
| import org.eclipse.jface.databinding.viewers.ViewersObservables; |
| import org.eclipse.jface.layout.GridDataFactory; |
| import org.eclipse.jface.layout.GridLayoutFactory; |
| import org.eclipse.jface.resource.FontDescriptor; |
| import org.eclipse.jface.viewers.DoubleClickEvent; |
| import org.eclipse.jface.viewers.IDoubleClickListener; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.ScrolledComposite; |
| import org.eclipse.swt.events.DisposeEvent; |
| import org.eclipse.swt.events.DisposeListener; |
| import org.eclipse.swt.events.KeyAdapter; |
| import org.eclipse.swt.events.KeyEvent; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.graphics.RGB; |
| import org.eclipse.swt.layout.FormAttachment; |
| import org.eclipse.swt.layout.FormData; |
| import org.eclipse.swt.layout.FormLayout; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| 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 org.eclipse.swt.widgets.Listener; |
| import org.eclipse.swt.widgets.Sash; |
| import org.eclipse.swt.widgets.Shell; |
| |
| /** |
| * The Class MasterDetailRenderer. |
| * It is the base renderer for the editor. |
| * |
| * It takes any object as input and renders a tree on the left-hand side. |
| * When selecting an item in the tree (that is an EObject) EMF-Forms is used to render the detail pane on the right-hand |
| * side |
| * |
| * MasterDetailRenderer implements IEditingDomainProvider to allow Undo/Redo/Copy/Cut/Paste actions to be performed |
| * externally. |
| * |
| * MasterDetailRenderer provides an ISelectionProvider to get the currently selected items in the tree |
| * |
| */ |
| @SuppressWarnings("restriction") |
| public class TreeMasterDetailComposite extends Composite implements IEditingDomainProvider { |
| |
| /** The input. */ |
| private final Object input; |
| |
| /** The editing domain. */ |
| private final EditingDomain editingDomain; |
| |
| /** The tree viewer. */ |
| private TreeViewer treeViewer; |
| |
| /** The vertical sash. */ |
| private Sash verticalSash; |
| |
| /** The detail scrollable composite. */ |
| private Composite detailComposite; |
| |
| /** The detail panel. */ |
| private Composite detailPanel; |
| |
| /** The currently rendered ECPSWTView. */ |
| private ECPSWTView renderedView; |
| private final Shell limbo; |
| |
| private Object lastRenderedObject; |
| |
| private final TreeMasterDetailSWTCustomization customization; |
| private TreeMasterDetailCache cache = new TreeMasterDetailCache() { |
| |
| @Override |
| public boolean isChached(EObject selection) { |
| return false; |
| } |
| |
| @Override |
| public ECPSWTView getCachedView(EObject selection) { |
| return null; |
| } |
| |
| @Override |
| public void cache(ECPSWTView ecpView) { |
| ecpView.dispose(); |
| } |
| }; |
| |
| /** the delay between a selection change and the start of the rendering. */ |
| private final int renderDelay; |
| |
| private ViewModelPropertiesUpdateCallback viewModelPropertiesUpdateCallback; |
| private final Set<DetailPanelRenderingFinishedCallback> detailPanelRenderingFinishedCallbacks = new LinkedHashSet<DetailPanelRenderingFinishedCallback>(); |
| |
| /** The CreateElementCallback to allow modifications to the newly created element. */ |
| |
| /** |
| * The context. It is used in the same way as in TreeMasterDetail. |
| * It allows custom viewmodels for the detail panel |
| */ |
| private static VViewModelProperties context = VViewFactory.eINSTANCE.createViewModelLoadingProperties(); |
| |
| static { |
| context.addNonInheritableProperty("detail", true); |
| } |
| |
| /** |
| * Default constructor. |
| * |
| * @param parent the parent composite |
| * @param style the style bits |
| * @param input the input for the tree |
| * @param customization the customization |
| * @param renderDelay the delay between a selection change and updating the detail |
| */ |
| /* package */ TreeMasterDetailComposite(Composite parent, int style, Object input, |
| TreeMasterDetailSWTCustomization customization, int renderDelay) { |
| super(parent, style); |
| this.input = input; |
| if (input instanceof Resource) { |
| editingDomain = AdapterFactoryEditingDomain.getEditingDomainFor(((Resource) input).getContents().get(0)); |
| } else if (input instanceof RootObject) { |
| editingDomain = AdapterFactoryEditingDomain.getEditingDomainFor(RootObject.class.cast(input).getRoot()); |
| } else { |
| editingDomain = AdapterFactoryEditingDomain.getEditingDomainFor(input); |
| } |
| this.renderDelay = renderDelay; |
| this.customization = customization; |
| limbo = new Shell(Display.getCurrent(), SWT.NONE); |
| // Place the limbo shell 'off screen' |
| limbo.setLocation(0, 10000); |
| limbo.setBackground(Display.getDefault().getSystemColor(SWT.COLOR_WHITE)); |
| limbo.setBackgroundMode(SWT.INHERIT_FORCE); |
| renderControl(customization); |
| |
| parent.addDisposeListener(new DisposeListener() { |
| |
| @Override |
| public void widgetDisposed(DisposeEvent e) { |
| TreeMasterDetailComposite.this.dispose(); |
| } |
| }); |
| } |
| |
| private Control renderControl(TreeMasterDetailSWTCustomization buildBehaviour) { |
| // Create the Form with two panels and a header |
| setLayout(new FormLayout()); |
| |
| // Create the Separator |
| verticalSash = createSash(this, buildBehaviour); |
| |
| // Create the Tree |
| final Composite treeComposite = new Composite(this, SWT.NONE); |
| addTreeViewerLayoutData(treeComposite, verticalSash); |
| GridLayoutFactory.fillDefaults().numColumns(1).applyTo(treeComposite); |
| treeViewer = TreeViewerSWTFactory.createTreeViewer(treeComposite, input, customization); |
| |
| // Create detail composite |
| detailComposite = buildBehaviour.createDetailComposite(this); |
| addDetailCompositeLayoutData(detailComposite, verticalSash); |
| |
| /* enable delayed update mechanism */ |
| final IViewerObservableValue treeViewerSelectionObservable = ViewersObservables |
| .observeSingleSelection(treeViewer); |
| final DelayedObservableValue delayedObservableValue = new DelayedObservableValue(renderDelay, |
| treeViewerSelectionObservable); |
| delayedObservableValue.addChangeListener(new IChangeListener() { |
| |
| @Override |
| public void handleChange(ChangeEvent event) { |
| doUpdateDetailPanel(false); |
| } |
| }); |
| |
| treeComposite.addDisposeListener(new DisposeListener() { |
| @Override |
| public void widgetDisposed(DisposeEvent e) { |
| treeViewerSelectionObservable.dispose(); |
| delayedObservableValue.dispose(); |
| } |
| }); |
| |
| /* add key listener to switch focus on enter */ |
| treeViewer.getTree().addKeyListener(new KeyAdapter() { |
| |
| @Override |
| public void keyReleased(KeyEvent e) { |
| if (e.keyCode == SWT.CR || e.keyCode == SWT.LF) { |
| doUpdateDetailPanel(true); |
| } |
| } |
| |
| }); |
| |
| /* add double click listener to switch focus on enter */ |
| treeViewer.addDoubleClickListener(new IDoubleClickListener() { |
| |
| @Override |
| public void doubleClick(DoubleClickEvent event) { |
| doUpdateDetailPanel(true); |
| } |
| }); |
| |
| updateDetailPanel(false); |
| |
| return this; |
| } |
| |
| private void setFocusToDetail() { |
| if (renderedView == null || renderedView.getSWTControl().isDisposed()) { |
| return; |
| } |
| renderedView.getSWTControl().setFocus(); |
| } |
| |
| private void addDetailCompositeLayoutData(Composite detailComposite, Sash verticalSash) { |
| final FormData detailFormData = new FormData(); |
| detailFormData.left = new FormAttachment(verticalSash, 2); |
| detailFormData.top = new FormAttachment(0, 5); |
| detailFormData.bottom = new FormAttachment(100, -5); |
| detailFormData.right = new FormAttachment(100, -5); |
| detailComposite.setLayoutData(detailFormData); |
| } |
| |
| private void addTreeViewerLayoutData(Composite treeComposite, Sash verticalSash) { |
| final FormData treeFormData = new FormData(); |
| treeFormData.bottom = new FormAttachment(100, -5); |
| treeFormData.left = new FormAttachment(0, 5); |
| treeFormData.right = new FormAttachment(verticalSash, -2); |
| treeFormData.top = new FormAttachment(0, 5); |
| treeComposite.setLayoutData(treeFormData); |
| } |
| |
| private Sash createSash(final Composite parent, TreeWidthProvider buildBehaviour) { |
| final Sash sash = new Sash(parent, SWT.VERTICAL); |
| |
| // Make the left panel 300px wide and put it below the header |
| final FormData sashFormData = new FormData(); |
| sashFormData.bottom = new FormAttachment(100, -5); |
| sashFormData.left = new FormAttachment(0, buildBehaviour.getInitialTreeWidth()); |
| sashFormData.top = new FormAttachment(0, 5); |
| sash.setLayoutData(sashFormData); |
| |
| // As soon as the sash is moved, layout the parent to reflect the changes |
| sash.addListener(SWT.Selection, new Listener() { |
| @Override |
| public void handleEvent(Event e) { |
| sash.setLocation(e.x, e.y); |
| |
| final FormData sashFormData = new FormData(); |
| sashFormData.bottom = new FormAttachment(100, -5); |
| sashFormData.left = new FormAttachment(0, e.x); |
| sashFormData.top = new FormAttachment(0, 5); |
| sash.setLayoutData(sashFormData); |
| parent.layout(true); |
| } |
| }); |
| return sash; |
| } |
| |
| // TODO JF this needs to be refactored, when used as the replacement for the treemasterdetail renderer. |
| // selection modification required as well as adjusting the loading properties |
| /** |
| * Updates the detail panel of the tree master detail. |
| * |
| * @param setFocusToDetail <code>true</code> if the focus should be moved to the detail panel |
| * |
| * @since 1.11 |
| */ |
| public void updateDetailPanel(final boolean setFocusToDetail) { |
| // Create a new detail panel in the scrollable composite. Disposes any old panels. |
| // createDetailPanel(); |
| // TODO create detail panel at the right location |
| final IStructuredSelection selection = (StructuredSelection) treeViewer.getSelection(); |
| final Object selectedObject = getSelectedObject(selection); |
| |
| boolean asyncRendering = false; |
| if (selectedObject instanceof EObject) { |
| lastRenderedObject = selectedObject; |
| final EObject eObject = EObject.class.cast(selectedObject); |
| if (renderedView != null && !renderedView.getSWTControl().isDisposed()) { |
| renderedView.getSWTControl().setParent(limbo); |
| cache.cache(renderedView); |
| } |
| createDetailPanel(); |
| if (cache.isChached(eObject)) { |
| renderedView = cache.getCachedView(eObject); |
| renderedView.getSWTControl().setParent(detailPanel); |
| /* |
| * layout detail, since the size of the window might have changed (e.g. made smaller). layout is |
| * required to make sure that scrollbars, etc. are updated |
| */ |
| detailPanel.layout(); |
| renderedView.getViewModelContext().changeDomainModel(eObject); |
| updateScrolledComposite(); |
| } else { |
| if (viewModelPropertiesUpdateCallback != null) { |
| viewModelPropertiesUpdateCallback.updateViewModelProperties(context); |
| } |
| // Check, if the selected object would be rendered using a TreeMasterDetail. If so, render the provided |
| // detail view. |
| final VView view = ViewProviderHelper.getView((EObject) selectedObject, context); |
| if (view.getChildren().size() > 0 && view.getChildren().get(0) instanceof VTreeMasterDetail) { |
| // Yes, we need to render this node differently |
| final VTreeMasterDetail vTreeMasterDetail = (VTreeMasterDetail) view.getChildren().get(0); |
| try { |
| renderedView = ECPSWTViewRenderer.INSTANCE.render(detailPanel, (EObject) selectedObject, |
| vTreeMasterDetail.getDetailView()); |
| detailPanel.layout(true, true); |
| } catch (final ECPRendererException e) { |
| } |
| |
| } else { |
| // No, everything is fine |
| final Label label = new Label(detailPanel, SWT.NONE); |
| label.setText("loading..."); |
| GridDataFactory.fillDefaults().align(SWT.CENTER, SWT.CENTER).grab(true, true).applyTo(label); |
| detailPanel.layout(true, true); |
| asyncRendering = true; |
| Display.getDefault().asyncExec(new UpdateDetailRunnable(setFocusToDetail, eObject, label)); |
| } |
| // After rendering the Forms, compute the size of the form. So the scroll container knows when to scroll |
| updateScrolledComposite(); |
| } |
| } else { |
| renderEmptyDetailPanel(); |
| } |
| |
| /* |
| * Notify the callbacks that the rendering has been finished. |
| * In case of async rendering, the async process needs to notify the callbacks. |
| */ |
| if (!asyncRendering) { |
| for (final DetailPanelRenderingFinishedCallback callback : detailPanelRenderingFinishedCallbacks) { |
| callback.renderingFinished(selectedObject); |
| } |
| } |
| } |
| |
| private Object getSelectedObject(IStructuredSelection selection) { |
| // Get the selected object, if it is an EObject, render the details using EMF Forms |
| Object selectedObject = selection != null ? selection.getFirstElement() : null; |
| if (customization.enableVerticalCopy() && selectedObject instanceof EObject && selection.size() > 1) { |
| boolean allOfSameType = true; |
| final EObject dummy = EcoreUtil.create(((EObject) selectedObject).eClass()); |
| |
| final Iterator iterator = selection.iterator(); |
| final Set<EObject> selectedEObjects = new LinkedHashSet<EObject>(); |
| while (iterator.hasNext()) { |
| final EObject eObject = (EObject) iterator.next(); |
| allOfSameType &= eObject.eClass() == dummy.eClass(); |
| if (allOfSameType) { |
| for (final EAttribute attribute : dummy.eClass().getEAllAttributes()) { |
| if (eObject == selectedObject) { |
| dummy.eSet(attribute, eObject.eGet(attribute)); |
| } else if (dummy.eGet(attribute) != null |
| && !dummy.eGet(attribute).equals(eObject.eGet(attribute))) { |
| dummy.eUnset(attribute); |
| } |
| } |
| selectedEObjects.add(eObject); |
| } else { |
| break; |
| } |
| } |
| if (allOfSameType) { |
| selectedObject = dummy; |
| dummy.eAdapters().add(new MultiEditAdapter(selectedEObjects, dummy)); |
| } |
| } |
| return selectedObject; |
| } |
| |
| private void updateScrolledComposite() { |
| if (ScrolledComposite.class.isInstance(detailComposite)) { |
| ScrolledComposite.class.cast(detailComposite) |
| .setMinSize(detailPanel.computeSize(SWT.DEFAULT, SWT.DEFAULT)); |
| } |
| } |
| |
| private void renderEmptyDetailPanel() { |
| lastRenderedObject = null; |
| if (renderedView != null && !renderedView.getSWTControl().isDisposed()) { |
| renderedView.getSWTControl().setParent(limbo); |
| cache.cache(renderedView); |
| /* set renderedView to null so that it is not offered to the cache further times */ |
| renderedView = null; |
| } |
| createDetailPanel(); |
| final Label hint = new Label(detailPanel, SWT.CENTER); |
| final FontDescriptor boldDescriptor = FontDescriptor.createFrom(hint.getFont()).setHeight(18) |
| .setStyle(SWT.BOLD); |
| final Font boldFont = boldDescriptor.createFont(hint.getDisplay()); |
| hint.setFont(boldFont); |
| hint.setForeground(new Color(hint.getDisplay(), 190, 190, 190)); |
| hint.setText("Select a node in the tree to edit it"); |
| final GridData hintLayoutData = new GridData(); |
| hintLayoutData.grabExcessVerticalSpace = true; |
| hintLayoutData.grabExcessHorizontalSpace = true; |
| hintLayoutData.horizontalAlignment = SWT.CENTER; |
| hintLayoutData.verticalAlignment = SWT.CENTER; |
| hint.setLayoutData(hintLayoutData); |
| |
| detailPanel.pack(); |
| detailPanel.layout(true, true); |
| |
| updateScrolledComposite(); |
| } |
| |
| /** |
| * Creates the detail panel. |
| * |
| * @return the control |
| */ |
| private Control createDetailPanel() { |
| // Dispose old panels to avoid memory leaks |
| if (detailPanel != null) { |
| detailPanel.dispose(); |
| } |
| |
| detailPanel = new Composite(detailComposite, SWT.BORDER); |
| detailPanel.setLayout(new GridLayout()); |
| detailPanel.setBackground(new Color(Display.getDefault(), new RGB(255, 255, 255))); |
| detailPanel.setBackgroundMode(SWT.INHERIT_FORCE); |
| if (ScrolledComposite.class.isInstance(detailComposite)) { |
| ScrolledComposite.class.cast(detailComposite).setContent(detailPanel); |
| } |
| |
| detailComposite.layout(true, true); |
| return detailPanel; |
| } |
| |
| @Override |
| public void dispose() { |
| limbo.dispose(); |
| customization.dispose(); |
| super.dispose(); |
| } |
| |
| /** |
| * Gets the current selection. |
| * |
| * @return the current selection |
| */ |
| public Object getCurrentSelection() { |
| if (!(treeViewer.getSelection() instanceof StructuredSelection)) { |
| return null; |
| } |
| return ((StructuredSelection) treeViewer.getSelection()).getFirstElement(); |
| } |
| |
| /** |
| * Sets the selection. |
| * |
| * @param structuredSelection the new selection |
| * @since 1.9 |
| */ |
| public void setSelection(ISelection structuredSelection) { |
| treeViewer.setSelection(structuredSelection); |
| } |
| |
| /** |
| * Gets the selection provider. |
| * |
| * @return the selection provider |
| */ |
| public TreeViewer getSelectionProvider() { |
| return treeViewer; |
| } |
| |
| /** |
| * Gets the editing domain. |
| * |
| * @return the editing domain |
| */ |
| @Override |
| public EditingDomain getEditingDomain() { |
| return editingDomain; |
| } |
| |
| /** |
| * Allows to set a different input for the treeviewer. |
| * |
| * @param input the new input |
| */ |
| public void setInput(Object input) { |
| treeViewer.setInput(input); |
| } |
| |
| /** |
| * Allows to override the default cache implementation by the provided one. |
| * |
| * @param cache The {@link TreeMasterDetailCache} to use. |
| * @since 1.9 |
| */ |
| public void setCache(TreeMasterDetailCache cache) { |
| if (cache != null) { |
| this.cache = cache; |
| } |
| } |
| |
| private void doUpdateDetailPanel(boolean setFocusToDetail) { |
| if (lastRenderedObject == getCurrentSelection()) { |
| if (setFocusToDetail) { |
| setFocusToDetail(); |
| } |
| /* |
| * possible when e.g. a double click or enter has forced an instant rendering and the delay update kicks in. |
| */ |
| return; |
| } |
| updateDetailPanel(setFocusToDetail); |
| } |
| |
| /** |
| * Adapter which listens to changes and delegates the notification to other EObjects. |
| * |
| * @author Eugen Neufeld |
| * |
| */ |
| private final class MultiEditAdapter extends AdapterImpl { |
| private final Set<EObject> selectedEObjects; |
| private final EObject dummy; |
| |
| private MultiEditAdapter(Set<EObject> selectedEObjects, EObject dummy) { |
| this.selectedEObjects = selectedEObjects; |
| this.dummy = dummy; |
| } |
| |
| @Override |
| public void notifyChanged(Notification notification) { |
| if (dummy.eClass().getEAllAttributes().contains(notification.getFeature())) { |
| final CompoundCommand cc = new CompoundCommand(); |
| for (final EObject selected : selectedEObjects) { |
| Command command = null; |
| switch (notification.getEventType()) { |
| case Notification.SET: |
| command = SetCommand.create(editingDomain, selected, |
| notification.getFeature(), notification.getNewValue()); |
| break; |
| case Notification.UNSET: |
| command = SetCommand.create(editingDomain, selected, |
| notification.getFeature(), SetCommand.UNSET_VALUE); |
| break; |
| case Notification.ADD: |
| case Notification.ADD_MANY: |
| command = AddCommand.create(editingDomain, selected, |
| notification.getFeature(), notification.getNewValue()); |
| break; |
| case Notification.REMOVE: |
| case Notification.REMOVE_MANY: |
| command = DeleteCommand.create(editingDomain, notification.getOldValue()); |
| break; |
| default: |
| continue; |
| } |
| cc.append(command); |
| } |
| editingDomain.getCommandStack().execute(cc); |
| } |
| } |
| } |
| |
| /** |
| * Runnable which updates the detail panel. |
| */ |
| private final class UpdateDetailRunnable implements Runnable { |
| private final boolean setFocusToDetail; |
| private final EObject eObject; |
| private final Label label; |
| |
| UpdateDetailRunnable(boolean setFocusToDetail, EObject eObject, Label label) { |
| this.setFocusToDetail = setFocusToDetail; |
| this.eObject = eObject; |
| this.label = label; |
| } |
| |
| @Override |
| public void run() { |
| try { |
| if (viewModelPropertiesUpdateCallback != null) { |
| viewModelPropertiesUpdateCallback.updateViewModelProperties(context); |
| } |
| final VView view = ViewProviderHelper.getView(eObject, context); |
| final ViewModelContext modelContext = ViewModelContextFactory.INSTANCE |
| .createViewModelContext( |
| view, eObject, customization.getViewModelServices(view, eObject)); |
| if (limbo.isDisposed()) { |
| return; |
| } |
| renderedView = ECPSWTViewRenderer.INSTANCE.render(limbo, modelContext); |
| |
| label.dispose(); |
| if (detailPanel.isDisposed()) { |
| return; |
| } |
| renderedView.getSWTControl().setParent(detailPanel); |
| detailPanel.layout(true, true); |
| if (ScrolledComposite.class.isInstance(detailComposite)) { |
| ScrolledComposite.class.cast(detailComposite) |
| .setMinSize(detailPanel.computeSize(SWT.DEFAULT, SWT.DEFAULT)); |
| } |
| if (setFocusToDetail) { |
| setFocusToDetail(); |
| } |
| // notify callbacks that the rendering was finished |
| for (final DetailPanelRenderingFinishedCallback callback : detailPanelRenderingFinishedCallbacks) { |
| callback.renderingFinished(eObject); |
| } |
| } catch (final ECPRendererException e) { |
| } |
| } |
| } |
| |
| /** |
| * Adds a {@link ViewModelPropertiesUpdateCallback}. |
| * |
| * @param viewModelPropertiesUpdateCallback the callback |
| * @since 1.11 |
| */ |
| public void addViewModelPropertiesUpdateCallback( |
| ViewModelPropertiesUpdateCallback viewModelPropertiesUpdateCallback) { |
| this.viewModelPropertiesUpdateCallback = viewModelPropertiesUpdateCallback; |
| } |
| |
| /** |
| * Register a callback that is notified whenever the rendering of a detail panel is finished. |
| * |
| * @param detailPanelRenderingFinishedCallback the callback |
| * @return <code>true</code> if the callback has been added, <code>false</code> if it was already registered |
| * @since 1.13 |
| */ |
| public boolean registerDetailPanelRenderingFinishedCallback( |
| DetailPanelRenderingFinishedCallback detailPanelRenderingFinishedCallback) { |
| return detailPanelRenderingFinishedCallbacks.add(detailPanelRenderingFinishedCallback); |
| } |
| |
| /** |
| * Register a callback that is notified whenever the rendering of a detail panel is finished. |
| * |
| * @param detailPanelRenderingFinishedCallback the callback |
| * @return <code>true</code> if the callback has been removed, <code>false</code> if it was not registered |
| * @since 1.13 |
| */ |
| public boolean unregisterDetailPanelRenderingFinishedCallback( |
| DetailPanelRenderingFinishedCallback detailPanelRenderingFinishedCallback) { |
| return detailPanelRenderingFinishedCallbacks.remove(detailPanelRenderingFinishedCallback); |
| } |
| } |
