/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/name/e4/TaxonNameEditorE4.java - Annotate - EDIT - EDIT Project Management

| Branch: | Tag: | Revision:

taxeditor/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/name/e4/TaxonNameEditorE4.java @ c6d3ffdc

-ff11da5
+/**
  * Copyright (C) 2007 EDIT
  * European Distributed Institute of Taxonomy
  * http://www.e-taxonomy.eu
+ *
  * The contents of this file are subject to the Mozilla Public License Version 1.1
  * See LICENSE.TXT at the top of this package for the full license terms.
  */
 package eu.etaxonomy.taxeditor.editor.name.e4;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
 import javax.inject.Inject;
 import org.apache.commons.lang.StringUtils;
 import org.eclipse.core.commands.operations.IUndoContext;
-c8c
+import org.eclipse.core.commands.operations.UndoContext;
-ff11da5
+import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.OperationCanceledException;
-            b5b429af
+import org.eclipse.e4.core.contexts.IEclipseContext;
-            e9fa67ee
+import org.eclipse.e4.core.services.events.IEventBroker;
-ff11da5
+import org.eclipse.e4.ui.di.Focus;
 import org.eclipse.e4.ui.di.Persist;
 import org.eclipse.e4.ui.model.application.ui.MDirtyable;
-            e378d285
+import org.eclipse.e4.ui.model.application.ui.basic.MPart;
-ff11da5
+import org.eclipse.e4.ui.services.EMenuService;
 import org.eclipse.e4.ui.workbench.modeling.ESelectionService;
-c8c
+import org.eclipse.jface.dialogs.MessageDialog;
-ff11da5
+import org.eclipse.jface.viewers.ISelection;
 import org.eclipse.jface.viewers.ISelectionProvider;
 import org.eclipse.jface.viewers.StructuredSelection;
-b8f2f1
+import org.eclipse.swt.dnd.DND;
 import org.eclipse.swt.dnd.DropTarget;
 import org.eclipse.swt.dnd.Transfer;
-ff11da5
+import org.eclipse.swt.graphics.Color;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.ui.ISelectionListener;
 import org.eclipse.ui.IWorkbenchPart;
 import org.eclipse.ui.IWorkbenchPartReference;
 import org.eclipse.ui.forms.ManagedForm;
 import org.eclipse.ui.forms.widgets.FormToolkit;
 import org.eclipse.ui.forms.widgets.ScrolledForm;
 import org.eclipse.ui.forms.widgets.TableWrapLayout;
 import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
 import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
 import eu.etaxonomy.cdm.model.common.CdmBase;
 import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
 import eu.etaxonomy.cdm.model.taxon.Taxon;
 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
-            c8cdc672
+import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
-ff11da5
+import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
-b8f2f1
+import eu.etaxonomy.taxeditor.editor.CdmDataTransfer;
-ff11da5
+import eu.etaxonomy.taxeditor.editor.ISecuredEditor;
-            e9fa67ee
+import eu.etaxonomy.taxeditor.editor.ITaxonEditor;
-ff11da5
+import eu.etaxonomy.taxeditor.editor.e4.TaxonEditorInputE4;
 import eu.etaxonomy.taxeditor.editor.l10n.Messages;
 import eu.etaxonomy.taxeditor.editor.name.e4.container.AbstractGroupE4;
 import eu.etaxonomy.taxeditor.editor.name.e4.container.AbstractGroupedContainerE4;
 import eu.etaxonomy.taxeditor.editor.name.e4.container.AcceptedGroupE4;
 import eu.etaxonomy.taxeditor.editor.name.e4.container.AcceptedNameContainerE4;
 import eu.etaxonomy.taxeditor.editor.name.e4.container.ContainerFactoryE4;
 import eu.etaxonomy.taxeditor.editor.name.e4.container.HomotypicalSynonymGroupE4;
 import eu.etaxonomy.taxeditor.editor.name.e4.container.MisappliedGroupE4;
-b8f2f1
+import eu.etaxonomy.taxeditor.editor.name.e4.dnd.NameEditorDropTargetListenerE4;
-            e9fa67ee
+import eu.etaxonomy.taxeditor.event.WorkbenchEventConstants;
-ff11da5
+import eu.etaxonomy.taxeditor.model.AbstractUtility;
 import eu.etaxonomy.taxeditor.model.IDirtyMarkable;
 import eu.etaxonomy.taxeditor.model.IPartChangeListener;
 import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;
-c8c
+import eu.etaxonomy.taxeditor.model.IPartContentHasFactualData;
 import eu.etaxonomy.taxeditor.model.IPartContentHasMedia;
 import eu.etaxonomy.taxeditor.model.IPartContentHasSupplementalData;
-f2d1a4
+import eu.etaxonomy.taxeditor.model.MessagingUtils;
-ff11da5
+import eu.etaxonomy.taxeditor.model.TaxeditorPartService;
 import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
 import eu.etaxonomy.taxeditor.preference.Resources;
 import eu.etaxonomy.taxeditor.security.RequiredPermissions;
 import eu.etaxonomy.taxeditor.store.CdmStore;
-            c8cdc672
+import eu.etaxonomy.taxeditor.workbench.part.IE4SavablePart;
-ff11da5
+            pplitzner
 /**
+ *
  * @author pplitzner
  * @date Aug 24, 2017
+ *
  */
-c8c
+public class TaxonNameEditorE4 implements IConversationEnabled, IDirtyMarkable, IPartContentHasDetails,
         IPartContentHasSupplementalData, IPartContentHasMedia, IPartContentHasFactualData, IPartChangeListener,
-b8f2f1
+        ISelectionListener, ISecuredEditor, IPostOperationEnabled, IE4SavablePart, ITaxonEditor, IDropTargetableE4 {
-ff11da5
+            pplitzner
 	private Taxon taxon;
 	private ManagedForm managedForm;
 	private ScrolledForm scrolledForm;
 	private Composite parent;
 	private ISelectionProvider simpleSelectionProvider;
 	private TaxonBase selection;
 	private ConversationHolder conversation;
 	private AcceptedGroupE4 acceptedGroup;
 	private List<HomotypicalSynonymGroupE4> heterotypicSynonymGroups = new ArrayList<>();
 	private MisappliedGroupE4 misappliedGroup;
-b8f2f1
+	private DropTarget target;
-ef209
+            Patrick Plitzner
-ff11da5
+	private TaxonBase objectAffectedByLastOperation;
-c8c
+	@Inject
 	private EMenuService menuService;
-ff11da5
+            pplitzner
 	@Inject
 	private ESelectionService selService;
-            b5b429af
+	@Inject
 	private IEclipseContext context;
-ff11da5
+	@Inject
 	private MDirtyable dirty;
-            e378d285
+	private MPart thisPart;
-ff11da5
+    private TaxonEditorInputE4 input;
-c8c
+    private UndoContext undoContext;
-            e9fa67ee
+    @Inject
     private IEventBroker eventBroker;
-ff11da5
+	@Inject
 	public TaxonNameEditorE4() {
-c8c
+	    undoContext = new UndoContext();
-ff11da5
+            pplitzner
 	@PostConstruct
-            e378d285
+    public void createPartControl(Composite parent, MPart thisPart) {
 	    this.thisPart = thisPart;
-ff11da5
+            pplitzner
-ef209
+        createManagedForm(parent);
-ff11da5
+            pplitzner
 		TaxeditorPartService.getInstance().addListener(
 				TaxeditorPartService.PART_ACTIVATED, this);
+	}
 	protected void createManagedForm(Composite composite) {
 		managedForm = new ManagedForm(composite) {
 			@Override
 			public void dirtyStateChanged() {
 			    dirty.setDirty(true);
+			}
 			@Override
 			public boolean setInput(Object input) {
-c8c
+				if (input instanceof AbstractGroupedContainerE4) {
-d94a7a
+				    TaxonBase newSelection = ((AbstractGroupedContainerE4) input).getData();
-f199310
+				    if(selection!=newSelection || TaxonNameEditorE4.this.isDirty()){
-d94a7a
+				        selection = newSelection;
 				        selService.setSelection(new StructuredSelection(selection));
+				    }
-ff11da5
+				}else if(input == null){
 					selection = null;
-c8c
+                    selService.setSelection(new StructuredSelection());
-ff11da5
+            pplitzner
 				return super.setInput(input);
+			}
 		};
 		scrolledForm = managedForm.getForm();
 		parent = scrolledForm.getBody();
 		parent.setData(taxon);
 		TableWrapLayout layout = new TableWrapLayout();
 		layout.leftMargin = 0;
 		layout.rightMargin = 0;
 		layout.topMargin = 0;
 		layout.bottomMargin = 0;
 		layout.verticalSpacing = 0;
 		layout.horizontalSpacing = 0;
 		parent.setLayout(layout);
 		parent.setBackground(AbstractUtility
 				.getColor(Resources.COLOR_COMPOSITE_BACKGROUND));
+	}
 	public void createOrUpdateNameComposites() {
 		ContainerFactoryE4.createOrUpdateAcceptedTaxonsHomotypicGroup(this);
 		ContainerFactoryE4.createOrUpdateHeterotypicSynonymyGroups(this);
 		ContainerFactoryE4.createOrUpdateMisapplicationsGroup(this);
 		// Redraw composite
 		managedForm.reflow(true);
-ef209
+		managedForm.refresh();
-ff11da5
+            pplitzner
-            e9fa67ee
+	@Override
     public Taxon getTaxon() {
-ff11da5
+		return HibernateProxyHelper.deproxy(taxon);
+	}
 	public void setDirty() {
 		managedForm.dirtyStateChanged();
+	}
 	@Focus
 	public void setFocus() {
-c8c
+	    //make sure to bind again if maybe in another view the conversation was unbound
         if(conversation!=null && !conversation.isBound()){
             conversation.bind();
+        }
-ff11da5
+	    if(input!=null){
 	        if (getSelectedContainer() == null) {
 	            throw new IllegalStateException(
 	                    Messages.TaxonNameEditor_THERE_SHOULD_ALWAYS_BE);
+	        }
 	        getSelectedContainer().setSelected();
 	        // check permissions
 	        boolean doEnable = permissionsSatisfied();
 	        managedForm.getForm().setEnabled(doEnable);
+	    }
-            e9fa67ee
+        eventBroker.post(WorkbenchEventConstants.CURRENT_ACTIVE_EDITOR, this);
-ff11da5
+            pplitzner
 	@Override
 	public boolean permissionsSatisfied() {
 		TaxonNode taxonNode = input.getTaxonNode();
 		boolean doEnable = CdmStore.currentAuthentiationHasPermission(taxonNode, RequiredPermissions.TAXONNODE_EDIT);
 		return doEnable;
+	}
 	@Override
     public ConversationHolder getConversationHolder() {
 		return conversation;
+	}
 	/** {@inheritDoc} */
 	@Override
     public void update(CdmDataChangeMap events) {
 		// redraw();
+	}
 	/**
 	 * Redraws this editor return true on success
+	 *
 	 * @return a boolean.
 	 */
     public boolean redraw() {
 		return redraw(true);
+	}
 	/**
 	 * {@inheritDoc}
+	 *
 	 * Redraws the editor controls
 	 */
     public boolean redraw(boolean focus) {
 		createOrUpdateNameComposites();
 		if (focus) {
 			setFocus();
+		}
 		return true;
+	}
 	@Override
     public boolean postOperation(CdmBase objectAffectedByOperation) {
 		changed(objectAffectedByOperation);
 		redraw(false);
 		if (objectAffectedByOperation instanceof TaxonBase) {
 			objectAffectedByLastOperation = (TaxonBase) objectAffectedByOperation;
+		}
 		return true;
+	}
 	public ManagedForm getManagedForm() {
 		return managedForm;
+	}
 	/**
 	 * <p>
 	 * checkForEmptyNames
 	 * </p>
+	 *
 	 * @return true if there are empty names
 	 */
 	public boolean checkForEmptyNames() {
 		for (AbstractGroupedContainerE4 container : getGroupedContainers()) {
 			if (container.getName() == null
 					|| StringUtils.isEmpty(container.getName().getTitleCache())) {
 				return true;
+			}
+		}
 		return false;
+	}
 	public Set<AbstractGroupedContainerE4> getEmptyContainers() {
 		Set<AbstractGroupedContainerE4> containersWithEmptyNames = new HashSet<>();
 		for (AbstractGroupedContainerE4 container : getGroupedContainers()) {
 			if (container.getName() == null
 					|| StringUtils.isEmpty(container.getName().getTitleCache())) {
 				containersWithEmptyNames.add(container);
+			}
+		}
 		return containersWithEmptyNames;
+	}
 	/** {@inheritDoc} */
-            c8cdc672
+	@Override
     @Persist
 	public void save(IProgressMonitor monitor) {
-ff11da5
+            pplitzner
-c8c
+	    monitor.beginTask(Messages.TaxonNameEditor_SAVING_NAMES, getGroupedContainers().size());
 	    if (!conversation.isBound()) {
 	        conversation.bind();
+	    }
 	    monitor.worked(1);
-ff11da5
+            pplitzner
-c8c
+	    // check for empty names
 	    if (checkForEmptyNames()) {
 	        MessageDialog.openWarning(AbstractUtility.getShell(), Messages.MultiPageTaxonEditor_NO_NAME_SPECIFIED,
 	                Messages.MultiPageTaxonEditor_NO_NAME_SPECIFIED_MESSAGE);
 	        return;
+	    }
 	    for (AbstractGroupedContainerE4 container : getGroupedContainers()) {
-ff11da5
+            pplitzner
-c8c
+	        monitor.subTask(Messages.TaxonNameEditor_SAVING_COMPOSITES
 	                + container.getTaxonBase().getTitleCache());
 	        container.persistName();
-ff11da5
+            pplitzner
-c8c
+	        // In case the progress monitor was canceled throw an exception.
 	        if (monitor.isCanceled()) {
 	            throw new OperationCanceledException();
+	        }
-ff11da5
+            pplitzner
-            a692bc7b
+	     // Otherwise declare this step as done.
-c8c
+	        monitor.worked(1);
+	    }
-            a692bc7b
+	    input.merge();
 	    // commit the conversation and start a new transaction immediately
         conversation.commit(true);
         dirty.setDirty(false);
-ff11da5
+            pplitzner
-c8c
+	    // Stop the progress monitor.
 	    monitor.done();
-ff11da5
+            pplitzner
-f2d1a4
+	public void init(TaxonEditorInputE4 input) {
-ff11da5
+            pplitzner
 		if (!(input != null)) {
-f2d1a4
+            MessagingUtils.error(this.getClass(), new Exception(Messages.TaxonNameEditor_INVALID_INPUT));
             return;
-ff11da5
+            pplitzner
 		if (input.getAdapter(Taxon.class) != null) {
 			taxon = CdmBase.deproxy(input.getAdapter(Taxon.class), Taxon.class);
 		} else {
-f2d1a4
+		    MessagingUtils.error(this.getClass(), new Exception(Messages.TaxonNameEditor_INVALID_INPUT_TAXON_NULL));
 		    return;
-ff11da5
+            pplitzner
 		this.input = input;
-            c6d3ffdc
+		conversation = input.getConversationHolder();
-ff11da5
+            pplitzner
         createOrUpdateNameComposites();
-b8f2f1
+        createDragSupport();
-            e378d285
+        setPartName();
-            b4730c9a
+            Patrick Plitzner
         //set initial selection
-fd7ed16
+        TaxonBase initiallySelectedTaxonBase = input.getInitiallySelectedTaxonBase();
         if(initiallySelectedTaxonBase!=null){
             selService.setSelection(new StructuredSelection(initiallySelectedTaxonBase));
             getContainer(initiallySelectedTaxonBase).setSelected();
-            e34c0af1
+            Patrick Plitzner
-ff11da5
+            pplitzner
-b8f2f1
+   private void createDragSupport() {
        // Listen for names being dragged outside of existing homotypic groups -
        // user wants to create a new group
        Transfer[] types = new Transfer[] { CdmDataTransfer.getInstance() };
        int operations = DND.DROP_MOVE;
        if (target == null) {
            target = new DropTarget(parent, operations);
            target.setTransfer(types);
            target.addDropListener(new NameEditorDropTargetListenerE4(this));
+       }
+   }
-ff11da5
+            pplitzner
 	public AcceptedNameContainerE4 getAcceptedNameContainer() {
 		return getAcceptedGroup().getAcceptedNameContainer();
+	}
 	public HomotypicalSynonymGroupE4 getHomotypicalGroupContainer(
 			HomotypicalGroup homotypicalGroup) {
 		for (HomotypicalSynonymGroupE4 group : getHeterotypicSynonymGroups()) {
 			if (group.getGroup().equals(homotypicalGroup)) {
 				return group;
+			}
+		}
 		return null;
+	}
 	/**
 	 * <p>
 	 * getDirtyNames
 	 * </p>
+	 *
 	 * @return a Set containing all composites that have been edited
 	 */
 	public Set<AbstractGroupedContainerE4> getDirtyNames() {
 		Set<AbstractGroupedContainerE4> dirtyNames = new HashSet<>();
 		for (AbstractGroupedContainerE4 composite : getGroupedContainers()) {
 			if (composite.isDirty()) {
 				dirtyNames.add(composite);
+			}
+		}
 		return dirtyNames;
+	}
 	public List<AbstractGroupedContainerE4> getGroupedContainers() {
 		List<AbstractGroupedContainerE4> groupedComposites = new ArrayList<>();
 		for (AbstractGroupE4 group : getAllGroups()) {
-e5785c
+		    if (group!= null){
 		        groupedComposites.addAll(group.getGroupedContainers());
+		    }
-ff11da5
+            pplitzner
 		return groupedComposites;
+	}
 	public List<AbstractGroupE4> getAllGroups() {
 		List<AbstractGroupE4> allGroups = new ArrayList<>();
 		allGroups.add(getAcceptedGroup());
 		heterotypicSynonymGroups = getHeterotypicSynonymGroups();
 		if (heterotypicSynonymGroups != null) {
 			allGroups.addAll(heterotypicSynonymGroups);
+		}
 		if (misappliedGroup != null) {
 			allGroups.add(misappliedGroup);
+		}
 		return allGroups;
+	}
-            b5b429af
+	@Override
 	public IEclipseContext getContext() {
 	    return context;
+	}
-ff11da5
+	public boolean isDirty() {
 		return dirty.isDirty();
+	}
 	@PreDestroy
 	public void dispose() {
-c8c
+        if(conversation!=null){
             conversation.unregisterForDataStoreChanges(this);
             conversation.close();
+        }
-            d6d945d2
+        eventBroker.post(WorkbenchEventConstants.CURRENT_ACTIVE_EDITOR, null);
-ff11da5
+            pplitzner
 	/** {@inheritDoc} */
 	@Override
     public void selectionChanged(IWorkbenchPart part, ISelection selection) {
+	}
 	public AbstractGroupedContainerE4 getSelectedContainer() {
-d94a7a
+		return (selection != null) ? getContainer(selection)
-ff11da5
+				: getAcceptedNameContainer();
+	}
-b8f2f1
+    @Override
     public void dragEntered() {
         // TODO change this
         getControl().setBackground(
                 AbstractUtility.getColor(Resources.COLOR_DRAG_ENTER));
+    }
     @Override
     public void dragLeft() {
         getControl().setBackground(
                 AbstractUtility.getColor(Resources.COLOR_COMPOSITE_BACKGROUND));
+    }
-ef209
+            Patrick Plitzner
-ff11da5
+	public void setMisapplicationsGroup(MisappliedGroupE4 misappliedGroup) {
 		this.misappliedGroup = misappliedGroup;
+	}
 	public FormToolkit getToolkit() {
 		return managedForm.getToolkit();
+	}
 	public List<HomotypicalSynonymGroupE4> getHeterotypicSynonymGroups() {
 		return heterotypicSynonymGroups;
+	}
 	public void addHeterotypicSynonymGroup(HomotypicalSynonymGroupE4 group) {
 		heterotypicSynonymGroups.add(group);
+	}
 	public AcceptedGroupE4 getAcceptedGroup() {
 		return acceptedGroup;
+	}
 	public void setAcceptedGroup(AcceptedGroupE4 acceptedGroup) {
 		this.acceptedGroup = acceptedGroup;
+	}
 	public MisappliedGroupE4 getMisappliedGroup() {
 		return misappliedGroup;
+	}
 	public boolean isActive() {
-            cf2f4360
+		return this.equals(AbstractUtility.getActivePart());
-ff11da5
+            pplitzner
     @Override
     public boolean onComplete() {
 		getContainer(objectAffectedByLastOperation).setSelected();
 		return true;
+	}
 	/** {@inheritDoc} */
 	@Override
     public void partChanged(Integer eventType, IWorkbenchPartReference partRef) {
 		if (!partRef.getPart(false).equals(this)) {
 			// getSelectedObject().colorSelected(AbstractGroupedContainer.SELECTED_NO_FOCUS);
+		}
+	}
 	public void removeGroup(AbstractGroupE4 group) {
 		if (group != null) {
 			group.dispose();
 			//if (heterotypicSynonymGroups != null) {
 			heterotypicSynonymGroups.remove(group);
 			//}
+		}
+	}
 	public AbstractGroupedContainerE4 getContainer(TaxonBase taxonBase) {
 		List<AbstractGroupedContainerE4> groupedContainers = getGroupedContainers();
 		for (AbstractGroupedContainerE4 container : groupedContainers) {
 			if (container.getData().equals(taxonBase)
 					&& container.getNameViewer().getTextWidget() != null) {
 				return container;
+			}
+		}
 		return getAcceptedNameContainer();
+	}
     public void setOnError() {
 		Color disabledColor =  AbstractUtility.getColor(Resources.COLOR_EDITOR_ERROR);
 		setEnabled(false, disabledColor);
+	}
 	public void setDisabled(){
 		Color disabledColor =  AbstractUtility.getColor(Resources.COLOR_TEXT_DISABLED_BACKGROUND);
 		setEnabled(false, disabledColor);
+	}
 	protected void setEnabled(boolean enabled, Color background) {
 		for(AbstractGroupedContainerE4 groupedContainer : getGroupedContainers()){
 			groupedContainer.setEnabled(enabled);
+		}
 		// send an empty selection to the current provider - TODO only on error ???
 		if (!enabled) {
 			getManagedForm().setInput(null);
 			for (AbstractGroupedContainerE4 groupedContainer : getGroupedContainers()) {
 				groupedContainer.setBackground(background);
+			}
+		}
-ef209
+		getControl().setBackground(background);
-ff11da5
+            pplitzner
     @Override
     public void changed(Object element) {
-            c8cdc672
+        // setDirty(true);
         // if the attribute is null then do not set the dirty flag -> hotfix for the problem that for tasks done in service methods the changes are saved automatically
         if (element != null){
             dirty.setDirty(true);
-            e378d285
+            //refresh part title
             //TODO: refresh taxon node in taxon navigator
             setPartName();
-            c8cdc672
+            Patrick Plitzner
-ff11da5
+            pplitzner
-            c8cdc672
+        if (element instanceof TaxonBase) {
             AbstractGroupedContainerE4 container = getContainer((TaxonBase) element);
             if (container != null) {
                 container.refresh();
+            }
+        }
         if (element instanceof TaxonRelationship) {
             AbstractGroupedContainerE4 container = getContainer(((TaxonRelationship) element).getFromTaxon());
             if (container != null) {
                 container.refresh();
+            }
+        }
-            e378d285
+            Patrick Plitzner
     public void setPartName(){
-            c175c2ff
+        thisPart.setLabel(this.taxon.getName().getFullTitleCache());
-ff11da5
+            pplitzner
     @Override
     public void forceDirty() {
         setDirty();
+    }
     public IUndoContext getUndoContext() {
-c8c
+        return undoContext;
-ff11da5
+            pplitzner
-b8f2f1
+    @Override
-ef209
+    public Composite getControl(){
         return managedForm.getForm().getBody();
+    }
-c8c
+    public EMenuService getMenuService() {
         return menuService;
+    }
     public ESelectionService getSelectionService() {
         return selService;
+    }
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean canAttachMedia() {
         return true;
+    }
-            a7d1d751
+    public TaxonEditorInputE4 getEditorInput() {
         return input;
+    }
-b8f2f1
+    /**
      * {@inheritDoc}
      */
     @Override
     public TaxonNameEditorE4 getEditor() {
         return this;
+    }
-ff11da5
+            pplitzner

Project

General

Profile

EDIT