// TODO Auto-generated method stub
return false;
}
+
}
public boolean onComplete() {
return false;
}
+
+
}
boolean doSave = MessageDialog
.openConfirm(shell, "Confirm save",
- "The current editor must be saved before this action can be executed.");
+ "Warning - this operation will save the editor. This will also save all other unsaved changes " +
+ "in your working editor to the database. Please 'Cancel' if you are not ready to do this.");
if (!doSave) {
return false;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.SWT;
import eu.etaxonomy.taxeditor.editor.name.container.AbstractGroupedContainer;
import eu.etaxonomy.taxeditor.editor.name.container.AcceptedGroup;
import eu.etaxonomy.taxeditor.editor.name.container.AcceptedNameContainer;
-import eu.etaxonomy.taxeditor.editor.name.container.ConceptGroup;
import eu.etaxonomy.taxeditor.editor.name.container.ContainerFactory;
import eu.etaxonomy.taxeditor.editor.name.container.HomotypicalSynonymGroup;
import eu.etaxonomy.taxeditor.editor.name.container.MisappliedGroup;
private final ConversationHolder conversation;
private MenuManager menuManager;
-
private Menu menu;
+ private AcceptedGroup acceptedGroup;
+ private List<HomotypicalSynonymGroup> heterotypicSynonymGroups = new ArrayList<HomotypicalSynonymGroup>();
private MisappliedGroup misappliedGroup;
- private ConceptGroup conceptGroup;
-
- private final List<HomotypicalSynonymGroup> heterotypicSynonymGroups = new ArrayList<HomotypicalSynonymGroup>();
-
private DropTarget target;
private ISelectionService selectionService;
- private AcceptedGroup acceptedGroup;
-
private TaxonBase objectAffectedByLastOperation;
/**
ContainerFactory.createOrUpdateAcceptedTaxonsHomotypicGroup(this);
ContainerFactory.createOrUpdateHeterotypicSynonymyGroups(this);
ContainerFactory.createOrUpdateMisapplicationsGroup(this);
- ContainerFactory.createOrUpdateConceptGroup(this);
// Redraw composite
managedForm.reflow(true);
public boolean postOperation(CdmBase objectAffectedByOperation) {
editor.changed(objectAffectedByOperation);
-
+
redraw(false);
if (objectAffectedByOperation instanceof TaxonBase) {
return null;
}
- /**
- * <p>
- * Getter for the field <code>conceptGroup</code>.
- * </p>
- *
- * @return a
- * {@link eu.etaxonomy.taxeditor.editor.name.container.ConceptGroup}
- * object.
- */
- public ConceptGroup getConceptGroup() {
- return conceptGroup;
- }
-
/**
* <p>
* getDirtyNames
allGroups.add(getAcceptedGroup());
- allGroups.addAll(getHeterotypicSynonymGroups());
+ List<HomotypicalSynonymGroup> grps = getHeterotypicSynonymGroups();
+
+ heterotypicSynonymGroups = getHeterotypicSynonymGroups();
+
+ if (heterotypicSynonymGroups != null) {
+ allGroups.addAll(heterotypicSynonymGroups);
+ }
if (misappliedGroup != null) {
allGroups.add(misappliedGroup);
}
- if (conceptGroup != null) {
- allGroups.add(conceptGroup);
- }
-
return allGroups;
}
EditorUtil.getColor(Resources.COLOR_COMPOSITE_BACKGROUND));
}
- /**
- * <p>
- * Setter for the field <code>conceptGroup</code>.
- * </p>
- *
- * @param conceptGroup
- * a
- * {@link eu.etaxonomy.taxeditor.editor.name.container.ConceptGroup}
- * object.
- */
- public void setConceptGroup(ConceptGroup conceptGroup) {
- this.conceptGroup = conceptGroup;
- }
/**
* <p>
public void removeGroup(AbstractGroup group) {
if (group != null) {
group.dispose();
- getHeterotypicSynonymGroups().remove(group);
+
+ //if (heterotypicSynonymGroups != null) {
+ heterotypicSynonymGroups.remove(group);
+ //}
}
}
TaxonNameEditor taxonNameEditor) {
List<HomotypicalSynonymGroup> retainedGroups = new ArrayList<HomotypicalSynonymGroup>();
- for(HomotypicalSynonymGroup group : taxonNameEditor.getHeterotypicSynonymGroups()){
- retainedGroups.add(group);
+ List<HomotypicalSynonymGroup> heterotypicSynonymGroups = taxonNameEditor.getHeterotypicSynonymGroups();
+
+ if (heterotypicSynonymGroups != null) {
+
+ for(HomotypicalSynonymGroup group : heterotypicSynonymGroups){
+ retainedGroups.add(group);
+ }
}
for(HomotypicalGroup homotypicalGroup : taxonNameEditor.getTaxon().getHeterotypicSynonymyGroups()){
}
- /**
- * @param taxonNameEditor
- */
- public static void createOrUpdateConceptGroup(
- TaxonNameEditor taxonNameEditor) {
- Set<TaxonRelationship> filteredTaxonRelations = new HashSet<TaxonRelationship>();
-
- for (TaxonRelationship relationship : taxonNameEditor.getTaxon().getTaxonRelations()) {
- if (! relationship.getType().equals(TaxonRelationshipType.MISAPPLIED_NAME_FOR()) ||
- relationship.getType().equals(TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN())) {
- filteredTaxonRelations.add(relationship);
- }
- }
-
- if(! filteredTaxonRelations.isEmpty()){
- taxonNameEditor.setConceptGroup(new ConceptGroup(taxonNameEditor));
- }
- }
-
}
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.IHandler;
import org.eclipse.core.commands.common.NotDefinedException;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.ui.PartInitException;
+import org.eclipse.ui.forms.editor.FormEditor;
+import org.eclipse.ui.handlers.HandlerUtil;
+import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.taxon.Synonym;
+import eu.etaxonomy.cdm.model.taxon.Taxon;
+import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.taxeditor.editor.EditorUtil;
import eu.etaxonomy.taxeditor.editor.MultiPageTaxonEditor;
-import eu.etaxonomy.taxeditor.editor.Page;
-import eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor;
import eu.etaxonomy.taxeditor.editor.name.operation.SwapSynonymAndAcceptedOperation;
+import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
/**
* <p>SwapSynonymAndAcceptedHandler class.</p>
* @version 1.0
*/
public class SwapSynonymAndAcceptedHandler extends AbstractHandler implements
- IHandler {
+ IHandler, IPostOperationEnabled {
private static final Logger logger = Logger
.getLogger(SwapSynonymAndAcceptedHandler.class);
+ private MultiPageTaxonEditor editor;
+ private Taxon taxon;
/* (non-Javadoc)
* @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)
*/
/** {@inheritDoc} */
public Object execute(ExecutionEvent event) throws ExecutionException {
- MultiPageTaxonEditor multiEditor = EditorUtil.getActiveMultiPageTaxonEditor();
-
- TaxonNameEditor editor = (TaxonNameEditor) multiEditor.getPage(Page.NAME);
-
+ editor = EditorUtil.getActiveMultiPageTaxonEditor();
+ Shell shell = HandlerUtil.getActiveShell(event);
Synonym synonym = (Synonym) EditorUtil.getSelection(event).getFirstElement();
-
- SwapSynonymAndAcceptedOperation operation;
+
+ // Force user to save taxon - not really necessary though, is it?
+ if (!EditorUtil.forceUserSave(editor, shell)) {
+ return null;
+ }
try {
- operation = new SwapSynonymAndAcceptedOperation(event.getCommand().getName(), editor.getUndoContext(),
- editor.getTaxon(), synonym, editor);
+ SwapSynonymAndAcceptedOperation operation = new SwapSynonymAndAcceptedOperation(event.getCommand().getName(), editor.getUndoContext(),
+ editor.getTaxon(), synonym, this);
+
EditorUtil.executeOperation(operation);
} catch (NotDefinedException e) {
return null;
}
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.taxeditor.operation.IPostOperationEnabled#postOperation(eu.etaxonomy.cdm.model.common.CdmBase, boolean)
+ */
+ @Override
+ public boolean postOperation(CdmBase objectAffectedByOperation) {
+ // Redraw existing editor
+ //((IPostOperationEnabled) editor).postOperation(null);
+
+ editor.doSave(EditorUtil.getMonitor());
+ editor.close(true);
+
+ if (objectAffectedByOperation instanceof Taxon) {
+
+ taxon = (Taxon) objectAffectedByOperation;
+
+
+ }
+ return true;
+ }
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.taxeditor.operation.IPostOperationEnabled#onComplete()
+ */
+ @Override
+ public boolean onComplete() {
+ Display display = Display.getCurrent();
+ display.asyncExec(new Runnable() {
+ public void run() {
+ try {
+ EditorUtil.openTaxonBase(taxon.getUuid());
+
+ } catch (Exception e) {
+ EditorUtil.warningDialog("Could not open editor for taxon", this, e.getMessage());
+ }
+
+ }
+ });
+ return true;
+ }
}
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
import eu.etaxonomy.cdm.api.service.ITaxonService;
+import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.taxon.Synonym;
import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
import eu.etaxonomy.cdm.model.taxon.Taxon;
+import eu.etaxonomy.taxeditor.editor.EditorUtil;
import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
import eu.etaxonomy.taxeditor.store.CdmStore;
@Override
public IStatus execute(IProgressMonitor monitor, IAdaptable info)
throws ExecutionException {
-
+
monitor.worked(20);
CdmStore.getService(ITaxonService.class).swapSynonymAndAcceptedTaxon(synonym, taxon);
* might not be what you want.
*/
public boolean postOperation(CdmBase objectAffectedByOperation);
-
+
/**
* This method will get called after the execution took place and occasional
* cleanups were performed. This is typically the last thing to happen.
* @return a boolean.
*/
public boolean onComplete();
+
}
BGBM BDI Projects / taxeditor.git / commitdiff