import org.eclipse.ui.PartInitException;
import org.eclipse.ui.handlers.HandlerUtil;
-import eu.etaxonomy.taxeditor.editor.group.authority.CdmAuthorityEditorInput;
import eu.etaxonomy.taxeditor.editor.group.authority.CdmAuthorityEditor;
+import eu.etaxonomy.taxeditor.editor.group.authority.CdmAuthorityEditorInput;
import eu.etaxonomy.taxeditor.editor.internal.TaxeditorEditorPlugin;
import eu.etaxonomy.taxeditor.editor.key.KeyEditor;
import eu.etaxonomy.taxeditor.editor.key.polytomous.PolytomousKeyEditorInput;
import eu.etaxonomy.cdm.model.taxon.Synonym;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeEvent;
-import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeEvent.EventType;
+import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
import eu.etaxonomy.taxeditor.model.AbstractDataChangeBehaviour;
import eu.etaxonomy.taxeditor.model.IDataChangeBehavior;
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.
*/
import eu.etaxonomy.cdm.api.service.ITaxonService;
import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
-import eu.etaxonomy.cdm.model.taxon.ITreeNode;
+import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.Synonym;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
import eu.etaxonomy.taxeditor.store.CdmStore;
+
/**
* <p>TaxonEditorInput class.</p>
*
public class TaxonEditorInput implements IEditorInput, IConversationEnabled, IPersistableElement {
private ConversationHolder conversation;
-
+
private TaxonNode taxonNode;
private TaxonEditorInputDataChangeBehaviour dataChangeBehavior;
-
+
private TaxonBase initiallySelectedTaxonBase;
-
+
private TaxonEditorInput(TaxonNode taxonNode, ConversationHolder conversation){
this.conversation = conversation;
this.taxonNode = taxonNode;
}
-
-
+
+
/**
* <p>NewInstance</p>
*
throw e;
}
}
-
+
/**
- *
+ *
* @param taxonNodeUuid
* @param conversation
* @return
*/
private static TaxonEditorInput NewInstance(UUID taxonNodeUuid, ConversationHolder conversation){
-
-
+
+
TaxonNode taxonNode = CdmStore.getService(ITaxonNodeService.class).load(taxonNodeUuid, null);
-
+
if(taxonNode == null){
EditorUtil.warningDialog("Not yet implemented", TaxonEditorInput.class, "Selected element is not type TaxonBase.");
return null;
- }
-
+ }
+
return new TaxonEditorInput(taxonNode, conversation);
}
-
+
/**
* <p>NewInstanceFromTaxonBase</p>
*
*/
public static TaxonEditorInput NewInstanceFromTaxonBase(UUID taxonBaseUuid){
ConversationHolder conversation = CdmStore.createConversation();
-
+
TaxonEditorInput input = null;
-
+
TaxonBase taxonBase = CdmStore.getService(ITaxonService.class).find(taxonBaseUuid);
if(taxonBase.isOrphaned()) {
EditorUtil.warningDialog("Orphaned Taxon", TaxonEditorInput.class, "This is an orphaned taxon i.e. a taxon that is not connected to a classification and not having any taxonomic relationships. Editing of orphaned taxon is currently not supported.");
}
else if(taxonBase.isInstanceOf(Taxon.class)){
Taxon taxon = CdmBase.deproxy(taxonBase, Taxon.class);
-
+
if (taxon.isMisapplication()){
// TODO get accepted taxon
EditorUtil.info("trying to open Mispplied Name ");
-
+
Set<Taxon> acceptedTaxa = new HashSet<Taxon>();
Set<TaxonRelationship> relations = taxon.getRelationsFromThisTaxon();
for(TaxonRelationship relation : relations){
}
}
input = getInputForMultipleTaxa(conversation, acceptedTaxa);
-
+
}else{
input = getInputForMultipleNodes(conversation, taxon.getTaxonNodes());
}
}else if(taxonBase instanceof Synonym){
Synonym synonym = (Synonym) taxonBase;
-
+
Set<Taxon> taxa = synonym.getAcceptedTaxa();
input = getInputForMultipleTaxa(conversation, taxa);
}
-
+
input.setInitiallySelectedTaxonBase(taxonBase);
-
+
return input;
}
-
+
private static TaxonEditorInput getInputForMultipleNodes(ConversationHolder conversation, Set<TaxonNode> taxonNodes){
if(taxonNodes.size() == 1){
TaxonNode taxonNode = taxonNodes.iterator().next();
}else if(taxonNodes.size() > 1){
TaxonNode taxonNode = ChooseFromMultipleTaxonNodesDialog.choose(taxonNodes);
if(taxonNode != null){
- return NewInstance(taxonNode.getUuid(), conversation);
+ return NewInstance(taxonNode.getUuid(), conversation);
}
}else if(taxonNodes.size() == 0){
// this is an undesired state
}
return null;
}
-
+
private static TaxonEditorInput getInputForMultipleTaxa(ConversationHolder conversation, Set<Taxon> taxa){
if(taxa.size() == 1){
Taxon taxon = taxa.iterator().next();
}
return null;
}
-
+
/**
* <p>NewEmptyInstance</p>
*
*/
public static TaxonEditorInput NewEmptyInstance(UUID parentNodeUuid){
ConversationHolder conversation = CdmStore.createConversation();
-
+
TaxonNameBase<?, ?> name = PreferencesUtil.getPreferredNomenclaturalCode().getNewTaxonNameInstance(null);
- ITreeNode parentNode = CdmStore.getService(IClassificationService.class).getTreeNodeByUuid(parentNodeUuid);
-
+ ITaxonTreeNode parentNode = CdmStore.getService(IClassificationService.class).getTreeNodeByUuid(parentNodeUuid);
+
Taxon newTaxon = Taxon.NewInstance(name, parentNode.getReference());
TaxonNode newTaxonNode = parentNode.addChildTaxon(newTaxon, parentNode.getReference(), parentNode.getMicroReference());
-
+
// add the new taxon to the editors persistence context
UUID newTaxonNodeUuid = CdmStore.getService(ITaxonNodeService.class).save(newTaxonNode);
-
+
return new TaxonEditorInput(newTaxonNode, conversation);
}
-
+
/* (non-Javadoc)
* @see org.eclipse.ui.IEditorInput#exists()
*/
*
* @return a boolean.
*/
- public boolean exists() {
+ @Override
+ public boolean exists() {
return taxonNode != null;
}
*
* @return a {@link org.eclipse.jface.resource.ImageDescriptor} object.
*/
- public ImageDescriptor getImageDescriptor() {
+ @Override
+ public ImageDescriptor getImageDescriptor() {
return null;
}
*
* @return a {@link java.lang.String} object.
*/
- public String getName() {
+ @Override
+ public String getName() {
if(getTaxon() == null){
return null;
}
return "New taxon";
} else {
return name.getTitleCache();
- }
+ }
}
/* (non-Javadoc)
*
* @return a {@link org.eclipse.ui.IPersistableElement} object.
*/
- public IPersistableElement getPersistable() {
+ @Override
+ public IPersistableElement getPersistable() {
// if(CdmStore.isActive()){
// TaxonNode test = CdmStore.getTaxonTreeService().getTaxonNodeByUuid(taxonNode.getUuid());
// boolean isPersistable = CdmStore.getTaxonTreeService().getTaxonNodeByUuid(taxonNode.getUuid()) != null;
*
* @return a {@link java.lang.String} object.
*/
- public String getToolTipText() {
+ @Override
+ public String getToolTipText() {
return getName();
}
* @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
*/
/** {@inheritDoc} */
- public Object getAdapter(Class adapter) {
+ @Override
+ public Object getAdapter(Class adapter) {
if (adapter == Taxon.class) {
return taxonNode.getTaxon();
}
-
+
if (adapter == TaxonNode.class) {
return taxonNode;
}
-
+
return null;
}
-
+
/**
* {@inheritDoc}
*
* Overrides equals to ensure that a taxon can only be edited by
* one editor at a time.
*/
- public boolean equals(Object obj) {
- if (TaxonEditorInput.class.equals(obj.getClass())
+ @Override
+ public boolean equals(Object obj) {
+ if (TaxonEditorInput.class.equals(obj.getClass())
&& getTaxon() != null
&& getTaxon().equals(((TaxonEditorInput) obj).getTaxon())){
if(((TaxonEditorInput) obj).getInitiallySelectedTaxonBase() != null){
public Taxon getTaxon(){
return taxonNode.getTaxon();
}
-
+
/**
* <p>Getter for the field <code>taxonNode</code>.</p>
*
public TaxonNode getTaxonNode() {
return taxonNode;
}
-
+
/*
* (non-Javadoc)
* @see eu.etaxonomy.cdm.api.conversation.IConversationEnabled#getConversationHolder()
*
* @return a {@link eu.etaxonomy.cdm.api.conversation.ConversationHolder} object.
*/
- public ConversationHolder getConversationHolder() {
+ @Override
+ public ConversationHolder getConversationHolder() {
return conversation;
}
* @see eu.etaxonomy.cdm.persistence.hibernate.ICdmPostCrudObserver#update(eu.etaxonomy.cdm.persistence.hibernate.CdmCrudEvent)
*/
/** {@inheritDoc} */
- public void update(CdmDataChangeMap events) {
+ @Override
+ public void update(CdmDataChangeMap events) {
if(dataChangeBehavior == null){
dataChangeBehavior = new TaxonEditorInputDataChangeBehaviour(this);
}
-
+
DataChangeBridge.handleDataChange(events, dataChangeBehavior);
}
*
* @return a {@link java.lang.String} object.
*/
- public String getFactoryId() {
+ @Override
+ public String getFactoryId() {
return TaxonEditorInputFactory.getFactoryId();
}
* @see org.eclipse.ui.IPersistable#saveState(org.eclipse.ui.IMemento)
*/
/** {@inheritDoc} */
- public void saveState(IMemento memento) {
+ @Override
+ public void saveState(IMemento memento) {
TaxonEditorInputFactory.saveState(memento, this);
}
-
+
/**
* <p>Setter for the field <code>initiallySelectedTaxonBase</code>.</p>
*
public TaxonBase getInitiallySelectedTaxonBase() {
return initiallySelectedTaxonBase;
}
-
+
@Override
public String toString() {
return String.format("%s[%s]", this.getClass().getSimpleName(), getTaxon());
import eu.etaxonomy.cdm.model.description.FeatureNode;\r
import eu.etaxonomy.cdm.model.description.FeatureTree;\r
import eu.etaxonomy.cdm.model.description.State;\r
-import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;\r
import eu.etaxonomy.taxeditor.model.ContextListenerAdapter;\r
import eu.etaxonomy.taxeditor.store.CdmStore;\r
import eu.etaxonomy.taxeditor.store.StoreUtil;\r
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DropTarget;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorSite;
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.name.operation.SwapSynonymAndAcceptedOperation;
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.
*/
import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
import eu.etaxonomy.cdm.api.service.ITaxonService;
import eu.etaxonomy.cdm.api.service.exception.HomotypicalGroupChangeException;
-import eu.etaxonomy.cdm.model.taxon.ITreeNode;
+import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.Synonym;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
* @version 1.0
*/
public class ChangeSynonymToAcceptedTaxonOperation extends AbstractPersistentPostOperation {
-
+
private Taxon newTaxon;
private Synonym synonym;
- private ITreeNode parentNode;
+ private ITaxonTreeNode parentNode;
private TaxonNode newNode;
private Synonym[] synonymsInHomotypicalGroup;
-
+
/**
* <p>Constructor for ChangeSynonymToAcceptedTaxonOperation.</p>
*
* @param label a {@link java.lang.String} object.
* @param undoContext a {@link org.eclipse.core.commands.operations.IUndoContext} object.
* @param taxon a {@link eu.etaxonomy.cdm.model.taxon.Taxon} object.
- * @param parentNode a {@link eu.etaxonomy.cdm.model.taxon.ITreeNode} object.
+ * @param parentNode a {@link eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode} object.
* @param synonym a {@link eu.etaxonomy.cdm.model.taxon.Synonym} object.
* @param synonymsInHomotypicalGroup an array of {@link eu.etaxonomy.cdm.model.taxon.Synonym} objects.
* @param postOperationEnabled a {@link eu.etaxonomy.taxeditor.operation.IPostOperationEnabled} object.
* @param conversationEnabled a {@link eu.etaxonomy.cdm.api.conversation.IConversationEnabled} object.
*/
public ChangeSynonymToAcceptedTaxonOperation(String label, IUndoContext undoContext,
- Taxon taxon, ITreeNode parentNode, Synonym synonym, Synonym[] synonymsInHomotypicalGroup, IPostOperationEnabled postOperationEnabled, IConversationEnabled conversationEnabled) {
+ Taxon taxon, ITaxonTreeNode parentNode, Synonym synonym, Synonym[] synonymsInHomotypicalGroup, IPostOperationEnabled postOperationEnabled, IConversationEnabled conversationEnabled) {
super(label, undoContext, postOperationEnabled, conversationEnabled);
this.taxon = taxon;
this.parentNode = parentNode;
- this.synonym = synonym;
+ this.synonym = synonym;
this.synonymsInHomotypicalGroup = synonymsInHomotypicalGroup;
}
-
+
/* (non-Javadoc)
* @see org.eclipse.core.commands.operations.AbstractOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
*/
@Override
public IStatus execute(IProgressMonitor monitor, IAdaptable info)
throws ExecutionException {
-
+
try {
newTaxon = CdmStore.getService(ITaxonService.class).changeSynonymToAcceptedTaxon(synonym, taxon, true, true, null, null);
} catch (HomotypicalGroupChangeException e) {
return postExecute(null);
}
monitor.worked(20);
-
+
synonym.setSec(null);
newNode = parentNode.addChildTaxon(newTaxon, null, null);
-
+
if(synonymsInHomotypicalGroup != null){
Taxon taxon = newNode.getTaxon();
for (Synonym synonym : synonymsInHomotypicalGroup){
taxon.addHomotypicSynonym(synonym, null, null);
}
}
-
+
monitor.worked(40);
return postExecute(newNode);
@Override
public IStatus undo(IProgressMonitor monitor, IAdaptable info)
throws ExecutionException {
-
+
// TODO implement - biggest problem is that any window open for new taxon must be closed first
StoreUtil.warn(this.getClass(), "Not yet implemented");
-
+
return postExecute(taxon);
}
// $Id$
/**
* Copyright (C) 2007 EDIT
- * European Distributed Institute of Taxonomy
+ * 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.
*/
import eu.etaxonomy.cdm.model.description.FeatureTree;
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.taxeditor.editor.EditorUtil;
-import eu.etaxonomy.taxeditor.editor.UsageTermCollection;
import eu.etaxonomy.taxeditor.editor.view.descriptive.DescriptiveViewPart;
import eu.etaxonomy.taxeditor.editor.view.descriptive.operation.CreateDescriptionElementOperation;
import eu.etaxonomy.taxeditor.model.FeatureNodeContainer;
* <p>
* DynamicFeatureMenu class.
* </p>
- *
+ *
* @author n.hoffmann
* @created 17.04.2009
* @version 1.0
/*
* (non-Javadoc)
- *
+ *
* @see
* org.eclipse.ui.actions.CompoundContributionItem#getContributionItems()
*/
protected IContributionItem[] getContributionItems() {
return new IContributionItem[] { new ContributionItem() {
- public void fill(Menu menu, int index) {
+ @Override
+ public void fill(Menu menu, int index) {
ISelection selection = selectionService
.getSelection(DescriptiveViewPart.ID);
createMenuItem(menu, featureNode.getFeature());
// add possible children to the menu
- for (FeatureNode childNode : featureNode.getChildren()) {
+ for (FeatureNode childNode : featureNode.getChildNodes()) {
createMenuItem(menu, childNode.getFeature());
}
} else if (selectedElement instanceof DescriptionElementBase) {
menuItem.setText(deproxiedFeature.getLabel());
menuItem.addSelectionListener(new SelectionListener() {
- public void widgetDefaultSelected(SelectionEvent e) {
+ @Override
+ public void widgetDefaultSelected(SelectionEvent e) {
}
- public void widgetSelected(SelectionEvent ev) {
+ @Override
+ public void widgetSelected(SelectionEvent ev) {
Event event = new Event();
event.data = deproxiedFeature;
try {
/**
* Retrieves the feature tree associated with the given description
- *
+ *
* TODO as of now this is always the same thing because feature trees may
* not be associated to descriptions yet.
- *
+ *
* @param description
* @return
*/
import org.eclipse.swt.graphics.Image;
import org.eclipse.ui.navigator.IDescriptionProvider;
-import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
-import eu.etaxonomy.cdm.model.common.LanguageString;
import eu.etaxonomy.cdm.model.taxon.Classification;
/**
import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.ColumnLabelProvider;
+import org.eclipse.jface.viewers.DelegatingStyledCellLabelProvider.IStyledLabelProvider;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.StyledString;
-import org.eclipse.jface.viewers.DelegatingStyledCellLabelProvider.IStyledLabelProvider;
import org.eclipse.swt.graphics.Image;
import org.eclipse.ui.navigator.IDescriptionProvider;
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.
*/
import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
-import eu.etaxonomy.cdm.model.taxon.ITreeNode;
+import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeEvent;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeEvent.EventType;
* @created 01.04.2009
* @version 1.0
*/
-public class TaxonNavigatorDataChangeBehavior extends AbstractDataChangeBehaviour implements
+public class TaxonNavigatorDataChangeBehavior extends AbstractDataChangeBehaviour implements
IDataChangeBehavior {
private TaxonNavigator source;
private Set<CdmBase> staleObjects;
-
+
/**
* <p>Constructor for TaxonNavigatorDataChangeBehavior.</p>
*
public TaxonNavigatorDataChangeBehavior(TaxonNavigator taxonNavigator) {
source = taxonNavigator;
}
-
+
/* (non-Javadoc)
* @see eu.etaxonomy.taxeditor.store.model.IDataChangeBehavior#isRelevant(java.lang.Object, eu.etaxonomy.cdm.persistence.hibernate.CdmCrudEvent)
*/
* @return a boolean.
*/
public boolean isRelevant(CdmDataChangeMap events) {
-
+
// TODO react only on insert/update/delete of taxon and synonym objects
// and on update of name objects
boolean relevant = false;
staleObjects = new HashSet<CdmBase>();
-
+
for(CdmDataChangeEvent event : events.getAllEvents()){
EventType eventType = event.getEventType();
CdmBase eventEntity = event.getEntity();
-
+
// all tree node changes are relevant
- if((eventType == EventType.INSERT || eventType == EventType.DELETE || eventType == EventType.UPDATE)
- && event.getEntity() instanceof ITreeNode){
+ if((eventType == EventType.INSERT || eventType == EventType.DELETE || eventType == EventType.UPDATE)
+ && event.getEntity() instanceof ITaxonTreeNode){
return true;
}
-
+
// name updates of the accepted taxon of open editors are relevant
if(eventType == EventType.UPDATE){
TaxonNameBase name = null;
}else{
continue;
}
-
+
Set<IEditorPart> openEditors = NavigationUtil.getOpenEditors();
for(IEditorPart editor : openEditors){
-
+
if(name.equals(((TaxonEditorInput) editor.getEditorInput()).getTaxon().getName())){
return true;
}
}
}
-
-
+
+
// if(eventType == EventType.UPDATE){
// relevant = true;
// CdmBase entity = event.getEntity();
// }
// }
}
-
+
return false;
-
+
// @deprecated
// react on everything except load
// if(events.sizeByEventType(EventType.INSERT) > 0){
* @see eu.etaxonomy.taxeditor.store.model.IDataChangeBehavior#reactOnDataChange(java.lang.Object, eu.etaxonomy.cdm.persistence.hibernate.CdmCrudEvent)
*/
/** {@inheritDoc} */
- public void reactOnDataChange(CdmDataChangeMap events) {
+ @Override
+ public void reactOnDataChange(CdmDataChangeMap events) {
if(isRelevant(events)){
final Display display = Display.getCurrent();
Job job = new Job("Updating Taxon Navigator") {
-
+
@Override
protected IStatus run(IProgressMonitor monitor) {
monitor.beginTask("Updating Taxon Navigator", 3);
monitor.worked(1);
-
+
// clear the session completely
monitor.subTask("Clearing Taxon Navigators session");
display.asyncExec(new Runnable() {
- public void run() {
+ @Override
+ public void run() {
source.getConversationHolder().clear();
}
- });
- // FIXME completely clearing the session is a brute force approach.
+ });
+ // FIXME completely clearing the session is a brute force approach.
// It would be much more elegant to clear only those elements that have been changed.
// I could not get that to work but we should consider workin on this because we might
// run into serious performance issues, especially when it comes to large trees
// at least, we moved this to a job so it can run in a background thred
// seems to improve the situation but not sure if final solution
monitor.worked(1);
-
+
monitor.subTask("Refreshing viewer");
-
+
display.asyncExec(new Runnable() {
- public void run() {
+ @Override
+ public void run() {
source.refresh();
}
});
-
-
-
+
+
+
monitor.worked(1);
monitor.done();
return Status.OK_STATUS;
}
};
-
+
job.setPriority(Job.SHORT);
job.schedule();
-
+
}
}
}
// $Id$
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.
*/
import org.eclipse.jface.viewers.Viewer;
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
-import eu.etaxonomy.cdm.model.taxon.ITreeNode;
+import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
/**
.getLogger(TaxonNodeContentProvider.class);
private static final Object[] NO_CHILDREN = new Object[0];
-
+
/** {@inheritDoc} */
- public Object[] getChildren(Object parentElement) {
- Object[] children = null;
-
- if(parentElement instanceof ITreeNode){
- ITreeNode treeNode = (ITreeNode) HibernateProxyHelper.deproxy(parentElement);
+ @Override
+ public Object[] getChildren(Object parentElement) {
+ Object[] children = null;
+
+ if(parentElement instanceof ITaxonTreeNode){
+ ITaxonTreeNode treeNode = (ITaxonTreeNode) HibernateProxyHelper.deproxy(parentElement);
children = treeNode.getChildNodes().toArray();
}
-
+
return children != null ? children : NO_CHILDREN;
}
/** {@inheritDoc} */
- public Object getParent(Object element) {
+ @Override
+ public Object getParent(Object element) {
if(element instanceof TaxonNode){
return ((TaxonNode) element).getParent();
- }
+ }
return null;
}
/** {@inheritDoc} */
- public boolean hasChildren(Object element) {
+ @Override
+ public boolean hasChildren(Object element) {
if(element instanceof TaxonNode){
return ((TaxonNode) element).getCountChildren() > 0;
}
}
/** {@inheritDoc} */
- public Object[] getElements(Object inputElement) {
+ @Override
+ public Object[] getElements(Object inputElement) {
return this.getChildren(inputElement);
}
/**
* <p>dispose</p>
*/
- public void dispose() {
+ @Override
+ public void dispose() {
}
/** {@inheritDoc} */
- public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
+ @Override
+ public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
}
}
package eu.etaxonomy.taxeditor.navigation.navigator;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.ColumnLabelProvider;
+import org.eclipse.jface.viewers.DelegatingStyledCellLabelProvider.IStyledLabelProvider;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.StyledString;
-import org.eclipse.jface.viewers.DelegatingStyledCellLabelProvider.IStyledLabelProvider;
import org.eclipse.jface.viewers.StyledString.Styler;
-import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.TextStyle;
import org.eclipse.ui.navigator.IDescriptionProvider;
import eu.etaxonomy.cdm.model.common.IIdentifiableEntity;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
-import eu.etaxonomy.cdm.persistence.hibernate.permission.Operation;
import eu.etaxonomy.taxeditor.navigation.NavigationUtil;
import eu.etaxonomy.taxeditor.preference.Resources;
import eu.etaxonomy.taxeditor.security.RequiredPermissions;
// $Id$
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.
*/
import org.eclipse.ui.navigator.CommonDropAdapterAssistant;
import eu.etaxonomy.cdm.model.common.CdmBase;
-import eu.etaxonomy.cdm.model.taxon.ITreeNode;
+import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.taxeditor.navigation.NavigationUtil;
import eu.etaxonomy.taxeditor.navigation.navigator.operation.MoveTaxonOperation;
/** Constant <code>ID="eu.etaxonomy.taxeditor.navigation.navig"{trunked}</code> */
public static final String ID = "eu.etaxonomy.taxeditor.navigation.navigator.dropassistant"; //$NON-NLS-1$
-
+
/* (non-Javadoc)
* @see org.eclipse.ui.navigator.CommonDropAdapterAssistant#handleDrop(org.eclipse.ui.navigator.CommonDropAdapter, org.eclipse.swt.dnd.DropTargetEvent, java.lang.Object)
*/
@Override
public IStatus handleDrop(CommonDropAdapter dropAdapter,
DropTargetEvent dropTargetEvent, Object target) {
-
- if (target instanceof ITreeNode) {
+
+ if (target instanceof ITaxonTreeNode) {
Set<TaxonNode> taxonNodes = getSelectedTaxa();
- ITreeNode targetTreeNode = (ITreeNode) target;
- if(taxonNodes != null)
- return moveTaxon(taxonNodes, targetTreeNode);
+ ITaxonTreeNode targetTreeNode = (ITaxonTreeNode) target;
+ if(taxonNodes != null) {
+ return moveTaxon(taxonNodes, targetTreeNode);
+ }
}
-
+
return Status.CANCEL_STATUS;
}
-
+
private Set<TaxonNode> getSelectedTaxa(){
- HashSet<TaxonNode> taxonNodes = new HashSet<TaxonNode>();
-
+ HashSet<TaxonNode> taxonNodes = new HashSet<TaxonNode>();
+
ISelection selection = LocalSelectionTransfer.getTransfer().getSelection();
if (selection instanceof TreeSelection) {
-
+
Iterator selectionIterator = ((TreeSelection) selection).iterator();
-
+
while (selectionIterator.hasNext()){
Object object = selectionIterator.next();
if(object instanceof TaxonNode){
/** {@inheritDoc} */
@Override
public IStatus validateDrop(Object target, int operation,
- TransferData transferType) {
- if (target instanceof ITreeNode) {
+ TransferData transferType) {
+ if (target instanceof ITaxonTreeNode) {
// do not allow to drop onto itself
for(TaxonNode taxonNode : getSelectedTaxa()){
if (taxonNode.equals(target)) {
}
}
return Status.OK_STATUS;
- }
+ }
return Status.CANCEL_STATUS;
}
-
+
/**
* @param childTaxonNode
* @param parentTaxon
* @return
*/
- private IStatus moveTaxon(Set<TaxonNode> taxonNodes, ITreeNode targetITreeNode) {
-
+ private IStatus moveTaxon(Set<TaxonNode> taxonNodes, ITaxonTreeNode targetITaxonTreeNode) {
+
TaxonNavigator taxonNavigator;
taxonNavigator = (TaxonNavigator) NavigationUtil.showView(TaxonNavigator.ID);
-
- if(targetITreeNode instanceof TaxonNode){
-
- TaxonNode targetTaxonNode = (TaxonNode) targetITreeNode;
-
+
+ if(targetITaxonTreeNode instanceof TaxonNode){
+
+ TaxonNode targetTaxonNode = (TaxonNode) targetITaxonTreeNode;
+
// for(TaxonNode taxonNode : taxonNodes){
// if (taxonNode.equals(targetTaxonNode)) {
// return Status.CANCEL_STATUS;
// }
// }
-
+
// Make sure parent taxon does not have unsaved changes
if (NavigationUtil.isDirty(targetTaxonNode)){
MessageDialog.openWarning(NavigationUtil.getShell(), "Unsaved Parent Taxon", "There are unsaved " +
"changes in the parent taxon. Pleas save first.");
return Status.CANCEL_STATUS;
}
-
-
+
+
// Make sure parentTaxon is not the drop target
// if (!childTaxonNode.isTopmostNode() && childTaxonNode.getParent().equals(targetTaxonNode)){
// return Status.CANCEL_STATUS;
// }
-
+
// Make sure taxon is not being dropped onto itself
// if (childTaxonNode.equals(targetTaxonNode)) {
// return Status.CANCEL_STATUS;
// }
-
-
- }
-
+
+
+ }
+
IUndoContext workspaceUndoContext = NavigationUtil.getWorkbenchUndoContext();
if (workspaceUndoContext == null) {
logger.error("Workspace undo context is null. DND operation cancelled");
}
AbstractPostOperation operation = new MoveTaxonOperation
- ("Move Taxon", workspaceUndoContext, taxonNodes, targetITreeNode, this, taxonNavigator);
- NavigationUtil.executeOperation(operation);
-
- logger.info("Moved taxa to new parent " + targetITreeNode);
+ ("Move Taxon", workspaceUndoContext, taxonNodes, targetITaxonTreeNode, this, taxonNavigator);
+ NavigationUtil.executeOperation(operation);
+
+ logger.info("Moved taxa to new parent " + targetITaxonTreeNode);
return Status.OK_STATUS;
}
* @see eu.etaxonomy.taxeditor.operations.IPostOperationEnabled#postOperation(eu.etaxonomy.cdm.model.common.CdmBase)
*/
/** {@inheritDoc} */
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ @Override
+ public boolean postOperation(CdmBase objectAffectedByOperation) {
return true;
}
*
* @return a boolean.
*/
- public boolean onComplete() {
+ @Override
+ public boolean onComplete() {
// TODO Auto-generated method stub
return false;
}
*/\r
package eu.etaxonomy.taxeditor.navigation.navigator.handler;\r
\r
-import java.util.Iterator;\r
-\r
import org.eclipse.core.commands.AbstractHandler;\r
import org.eclipse.core.commands.ExecutionEvent;\r
import org.eclipse.core.commands.ExecutionException;\r
import org.eclipse.jface.viewers.IStructuredSelection;\r
import org.eclipse.ui.handlers.HandlerUtil;\r
\r
-import eu.etaxonomy.cdm.model.common.TermBase;\r
-import eu.etaxonomy.cdm.model.taxon.Taxon;\r
-import eu.etaxonomy.cdm.model.taxon.TaxonBase;\r
import eu.etaxonomy.cdm.model.taxon.TaxonNode;\r
-import eu.etaxonomy.taxeditor.editor.definedterm.DefinedTermEditor;\r
import eu.etaxonomy.taxeditor.navigation.NavigationUtil;\r
import eu.etaxonomy.taxeditor.navigation.navigator.TaxonNavigator;\r
import eu.etaxonomy.taxeditor.navigation.navigator.operation.CopyOperation;\r
// $Id$
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.
*/
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.handlers.HandlerUtil;
-import eu.etaxonomy.cdm.model.taxon.ITreeNode;
+import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.taxeditor.editor.TaxonEditorInput;
import eu.etaxonomy.taxeditor.navigation.NavigationUtil;
private TaxonNavigator taxonNavigator;
/** {@inheritDoc} */
- public Object execute(ExecutionEvent event) throws ExecutionException {
-
+ @Override
+ public Object execute(ExecutionEvent event) throws ExecutionException {
+
activePage = HandlerUtil.getActiveWorkbenchWindow(event).getActivePage();
-
+
taxonNavigator = NavigationUtil.showNavigator();
-
+
TreeSelection selection = (TreeSelection) HandlerUtil.getCurrentSelection(event);
-
+
String plural = selection.size() > 1 ? "s" : "";
// Prompt user for confirmation
if(! MessageDialog.openConfirm(HandlerUtil.getActiveShell(event), "Confirm Deletion", "Are you sure you want to delete the selected node" + plural +"?")){
return null;
}
-
+
Iterator selectionIterator = selection.iterator();
- Set<ITreeNode> treeNodes = new HashSet<ITreeNode>();
-
+ Set<ITaxonTreeNode> treeNodes = new HashSet<ITaxonTreeNode>();
+
while (selectionIterator.hasNext()){
Object object = selectionIterator.next();
- if(object instanceof ITreeNode)
- treeNodes.add((ITreeNode) object);
+ if(object instanceof ITaxonTreeNode) {
+ treeNodes.add((ITaxonTreeNode) object);
+ }
}
-
+
AbstractPostOperation operation = null;
try {
operation = new DeleteOperation(
- event.getCommand().getName(), NavigationUtil.getUndoContext(),
+ event.getCommand().getName(), NavigationUtil.getUndoContext(),
treeNodes, taxonNavigator, taxonNavigator);
-
+
IStatus status = NavigationUtil.executeOperation(operation);
-
-
+
+
// FIXME is there a better place for this code?
if (status == Status.OK_STATUS){
- for (ITreeNode treeNode : treeNodes){
+ for (ITaxonTreeNode treeNode : treeNodes){
if(treeNode instanceof TaxonNode) {
closeObsoleteEditor((TaxonNode) treeNode);
}
}
}
-
+
} catch (NotDefinedException e) {
NavigationUtil.warn(getClass(), "Command name not set");
}
return null;
}
-
+
private void closeObsoleteEditor(TaxonNode taxonNode){
for (IEditorReference ref : activePage.getEditorReferences()) {
try {
- IEditorInput input = ref.getEditorInput();
+ IEditorInput input = ref.getEditorInput();
if (input instanceof TaxonEditorInput) {
TaxonNode node = ((TaxonEditorInput) input).getTaxonNode();
if (taxonNode.equals(node)) {
\r
import org.eclipse.core.commands.ExecutionException;\r
import org.eclipse.core.commands.operations.IUndoContext;\r
-\r
-import eu.etaxonomy.cdm.model.taxon.TaxonNode;\r
-import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;\r
-import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;\r
-\r
import org.eclipse.core.runtime.IAdaptable;\r
import org.eclipse.core.runtime.IProgressMonitor;\r
import org.eclipse.core.runtime.IStatus;\r
import org.eclipse.swt.dnd.TextTransfer;\r
import org.eclipse.swt.dnd.Transfer;\r
\r
+import eu.etaxonomy.cdm.model.taxon.TaxonNode;\r
+import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;\r
+import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;\r
+\r
\r
/**\r
* @author l.morris\r
// $Id$
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.
*/
import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
import eu.etaxonomy.cdm.api.service.IClassificationService;
import eu.etaxonomy.cdm.model.taxon.Classification;
-import eu.etaxonomy.cdm.model.taxon.ITreeNode;
+import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.taxeditor.operation.AbstractPersistentPostOperation;
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
* @version 1.0
*/
public class DeleteOperation extends AbstractPersistentPostOperation{
-
- private Set<ITreeNode> treeNodes;
-
+ private Set<ITaxonTreeNode> treeNodes;
+
+
/**
* <p>Constructor for DeleteTreeNodeOperation.</p>
*
* @param treeNodes a {@link java.util.Set} object.
*/
public DeleteOperation(String label, IUndoContext undoContext,
- Set<ITreeNode> treeNodes,
+ Set<ITaxonTreeNode> treeNodes,
IPostOperationEnabled postOperationEnabled,
IConversationEnabled conversationEnabled) {
super(label, undoContext, postOperationEnabled, conversationEnabled);
this.treeNodes = treeNodes;
}
-
+
/* (non-Javadoc)
* @see org.eclipse.core.commands.operations.AbstractOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
*/
bind();
monitor.worked(20);
- for (ITreeNode treeNode : treeNodes){
+ for (ITaxonTreeNode treeNode : treeNodes){
if(treeNode instanceof TaxonNode){
((TaxonNode) treeNode).delete();
}else if(treeNode instanceof Classification){
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.
*/
import org.eclipse.core.runtime.Status;
import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
-import eu.etaxonomy.cdm.model.taxon.ITreeNode;
+import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.IllegalAncestryException;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.taxeditor.operation.AbstractPersistentPostOperation;
* @version 1.0
*/
public class MoveTaxonOperation extends AbstractPersistentPostOperation {
-
+
/**
* A reference to the new taxonomical parent.
*/
- private ITreeNode newParentTreeNode;
+ private ITaxonTreeNode newParentTreeNode;
/**
* A reference to the former taxonomical parents
*/
- private Map<TaxonNode, ITreeNode> oldParentTreeNodes;
-
+ private Map<TaxonNode, ITaxonTreeNode> oldParentTreeNodes;
+
private Set<TaxonNode> taxonNodes;
/**
* @param label a {@link java.lang.String} object.
* @param undoContext a {@link org.eclipse.core.commands.operations.IUndoContext} object.
* @param taxonNodes a {@link java.util.Set} object.
- * @param newParentTreeNode a {@link eu.etaxonomy.cdm.model.taxon.ITreeNode} object.
+ * @param newParentTreeNode a {@link eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode} object.
* @param postOperationEnabled a {@link eu.etaxonomy.taxeditor.operation.IPostOperationEnabled} object.
* @param conversationEnabled a {@link eu.etaxonomy.cdm.api.conversation.IConversationEnabled} object.
*/
public MoveTaxonOperation(String label, IUndoContext undoContext,
- Set<TaxonNode> taxonNodes, ITreeNode newParentTreeNode, IPostOperationEnabled postOperationEnabled, IConversationEnabled conversationEnabled) {
+ Set<TaxonNode> taxonNodes, ITaxonTreeNode newParentTreeNode, IPostOperationEnabled postOperationEnabled, IConversationEnabled conversationEnabled) {
super(label, undoContext, postOperationEnabled, conversationEnabled);
this.taxonNodes = taxonNodes;
-
+
this.newParentTreeNode = newParentTreeNode;
-
- // Save old parent ITreeNodes for undo
- oldParentTreeNodes = new HashMap<TaxonNode, ITreeNode>();
+
+ // Save old parent ITaxonTreeNodes for undo
+ oldParentTreeNodes = new HashMap<TaxonNode, ITaxonTreeNode>();
for(TaxonNode taxonNode : taxonNodes){
this.oldParentTreeNodes.put(taxonNode, taxonNode.getParent());
}
}
-
+
/* (non-Javadoc)
* @see org.eclipse.core.commands.operations.AbstractOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
*/
throws ExecutionException {
bind();
monitor.worked(20);
-
+
try {
for (TaxonNode taxonNode : taxonNodes){
- TaxonNode newTaxonNode = newParentTreeNode.addChildNode(taxonNode,
+ TaxonNode newTaxonNode = newParentTreeNode.addChildNode(taxonNode,
newParentTreeNode.getReference(), newParentTreeNode.getMicroReference());
taxonNodes.add(newTaxonNode);
monitor.worked(2);
StoreUtil.warningDialog("Illegal ancestry", this, e.getMessage());
}
monitor.worked(40);
-
+
return postExecute(null);
}
public IStatus undo(IProgressMonitor monitor, IAdaptable info)
throws ExecutionException {
StoreUtil.warn(this.getClass(), "Not implemented yet.");
-
- // iterate over oldParentTreeNodes, delete each TaxonNode from its actual parent and add to its former parent
-
+
+ // iterate over oldParentTreeNodes, delete each TaxonNode from its actual parent and add to its former parent
+
return Status.OK_STATUS;
}
}
// $Id$
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.
*/
import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
import eu.etaxonomy.cdm.api.service.ITaxonNodeService;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
-import eu.etaxonomy.cdm.model.taxon.ITreeNode;
+import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.taxeditor.navigation.NavigationUtil;
*/
@Deprecated // we do not undo creation of elements
public class CreateTaxonNode extends AbstractPersistentPostOperation {
-
+
private Taxon newTaxon;
-
+
private TaxonNode childTaxonNode;
-
+
/**
* Add a name to a taxonomic tree
*
* @param undoContext a {@link org.eclipse.core.commands.operations.IUndoContext} object.
* @param name a {@link eu.etaxonomy.cdm.model.name.TaxonNameBase} object.
* @param postOperationEnabled a {@link eu.etaxonomy.taxeditor.operation.IPostOperationEnabled} object.
- * @param parentNode a {@link eu.etaxonomy.cdm.model.taxon.ITreeNode} object.
+ * @param parentNode a {@link eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode} object.
* @param conversationEnabled a {@link eu.etaxonomy.cdm.api.conversation.IConversationEnabled} object.
*/
public CreateTaxonNode(String label, IUndoContext undoContext,
- ITreeNode parentNode, TaxonNameBase<?, ?> name, IPostOperationEnabled postOperationEnabled,
+ ITaxonTreeNode parentNode, TaxonNameBase<?, ?> name, IPostOperationEnabled postOperationEnabled,
IConversationEnabled conversationEnabled) {
super(label, undoContext, parentNode, postOperationEnabled, conversationEnabled);
-
+
newTaxon = Taxon.NewInstance(name, null);
}
-
+
/**
* Add a taxon to a taxonomic tree
*
* @param undoContext a {@link org.eclipse.core.commands.operations.IUndoContext} object.
* @param taxon a {@link eu.etaxonomy.cdm.model.taxon.Taxon} object.
* @param postOperationEnabled a {@link eu.etaxonomy.taxeditor.operation.IPostOperationEnabled} object.
- * @param parentNode a {@link eu.etaxonomy.cdm.model.taxon.ITreeNode} object.
+ * @param parentNode a {@link eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode} object.
* @param conversationEnabled a {@link eu.etaxonomy.cdm.api.conversation.IConversationEnabled} object.
*/
public CreateTaxonNode(String label, IUndoContext undoContext,
- ITreeNode parentNode, Taxon taxon, IPostOperationEnabled postOperationEnabled,
+ ITaxonTreeNode parentNode, Taxon taxon, IPostOperationEnabled postOperationEnabled,
IConversationEnabled conversationEnabled) {
super(label, undoContext, parentNode, postOperationEnabled, conversationEnabled);
-
+
this.newTaxon = taxon;
}
bind();
monitor.worked(20);
childTaxonNode = parentNode.addChildTaxon(newTaxon, parentNode.getReference(), parentNode.getMicroReference());
-
+
monitor.worked(40);
CdmStore.getService(ITaxonNodeService.class).saveOrUpdate(childTaxonNode);
-
+
return postExecute(childTaxonNode);
}catch(Exception e){
NavigationUtil.errorDialog("Could not create taxon node", getClass(), e.getLocalizedMessage(), e);
return Status.CANCEL_STATUS;
- }
+ }
}
/* (non-Javadoc)
@Override
public IStatus undo(IProgressMonitor monitor, IAdaptable info)
throws ExecutionException {
-
+
StoreUtil.warn(this.getClass(), "Not yet implemented.");
return null;
}
// $Id$
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.
*/
List<FeatureNode> children = ((FeatureTree) parentElement).getRootChildren();
return children.toArray();
}else if(parentElement instanceof FeatureNode){
- List<FeatureNode> children = ((FeatureNode) parentElement).getChildren();
+ List<FeatureNode> children = ((FeatureNode) parentElement).getChildNodes();
return children.toArray();
}else if(parentElement instanceof List){
return ((List) parentElement).toArray();
// $Id$
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.io.wizard;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
import java.net.URI;
+import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IWorkbench;
*/
public class AbcdImportWizard extends AbstractImportWizard<Abcd206ImportConfigurator> {
+ private static final Logger logger = Logger.getLogger(AbcdImportWizard.class);
+
private Abcd206ImportConfigurator configurator;
private ImportFromFileDataSourceWizardPage dataSourcePage;
-
+
/* (non-Javadoc)
* @see eu.etaxonomy.taxeditor.io.wizard.AbstractImportWizard#getConfigurator()
*/
@Override
public boolean performFinish() {
URI source = dataSourcePage.getUri();
- configurator.setSource(source);
+ try {
+ configurator.setSource(new FileInputStream(new File(source)));
+ } catch (FileNotFoundException e) {
+ logger.error("File not found!", e);
+ return false;
+ }
configurator.setDbSchemaValidation(DbSchemaValidation.CREATE);
-
+
CdmStore.getImportManager().run(configurator);
return true;
-
+
}
/* (non-Javadoc)
* @see org.eclipse.ui.IWorkbenchWizard#init(org.eclipse.ui.IWorkbench, org.eclipse.jface.viewers.IStructuredSelection)
*/
/** {@inheritDoc} */
- public void init(IWorkbench workbench, IStructuredSelection selection) {
+ @Override
+ public void init(IWorkbench workbench, IStructuredSelection selection) {
super.init(workbench, selection);
configurator = CdmStore.getImportManager().AbcdConfigurator();
}
-
+
/* (non-Javadoc)
* @see eu.etaxonomy.taxeditor.io.AbstractImportWizard#addPages()
*/
@Override
public void addPages() {
super.addPages();
-
+
dataSourcePage = ImportFromFileDataSourceWizardPage.XML();
addPage(dataSourcePage);
}
import org.eclipse.ui.themes.ITheme;
import org.eclipse.ui.themes.IThemeManager;
-import eu.etaxonomy.cdm.model.common.TermBase;
import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;
import eu.etaxonomy.cdm.api.service.DefaultQuantitativeDescriptionBuilder;
import eu.etaxonomy.cdm.api.service.DescriptionBuilder;
import eu.etaxonomy.cdm.common.CdmUtils;
-import eu.etaxonomy.cdm.model.description.DescriptionElementSource;
import eu.etaxonomy.cdm.model.common.IIdentifiableEntity;
import eu.etaxonomy.cdm.model.common.ISourceable;
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
import eu.etaxonomy.cdm.model.description.CommonTaxonName;
import eu.etaxonomy.cdm.model.description.DescriptionBase;
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
+import eu.etaxonomy.cdm.model.description.DescriptionElementSource;
import eu.etaxonomy.cdm.model.description.Distribution;
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.description.IndividualsAssociation;
// $Id$
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.
*/
* @version 1.0
*/
public class FeatureNodeContainer{
-
-
-
+
+
+
private FeatureNodeContainer parent;
-
+
private FeatureNode featureNode;
private FeatureNodeContainerTree containerTree;
-
+
/**
* @param description
*/
protected FeatureNodeContainer(FeatureNodeContainerTree containerTree) {
- this.containerTree = containerTree;
+ this.containerTree = containerTree;
this.containerTree.addContainer(this);
}
-
-
+
+
/**
- * Recursively traverse a branch of a feature tree and check if there are
- *
+ * Recursively traverse a branch of a feature tree and check if there are
+ *
* @param featureNode
- * @param description
+ * @param description
* @return
*/
protected void findLeaves(FeatureNode featureNode) {
if(featureNode.isLeaf()){
buildLeaf(featureNode);
}else{
- for(FeatureNode childNode : featureNode.getChildren()){
+ for(FeatureNode childNode : featureNode.getChildNodes()){
findLeaves(childNode);
}
}
}
-
+
/**
- *
+ *
* @param featureNode
* @param description
* @return
if(featureNode.getFeature() == null){
throw new IllegalArgumentException("The given feature node does not have a feature.");
}
-
+
Feature feature = (Feature) HibernateProxyHelper.deproxy(featureNode.getFeature());
-
+
// get feature node container for the given feature
FeatureNodeContainer container = containerTree.getFeatureNodeContainer(feature);
-
+
// get description elements for the given feature
List<DescriptionElementBase> elements = containerTree.getDescriptionsElementsForFeature(feature);
// no description elements, so we should also remove the feature node container
container.buildBranch();
}
// add description elements to the feature node container
- container.setDescriptionElements(elements);
+ container.setDescriptionElements(elements);
}
}
-
+
/**
- *
+ *
*/
private void remove() {
if(getParent() != null){
/**
- * Recursively
- *
+ * Recursively
+ *
* @param featureNodeMap
* @return
*/
- private void buildBranch(){
+ private void buildBranch(){
if(getParent() == null){
FeatureNode parentFeatureNode = getFeatureNode().getParent();
-
+
if(parentFeatureNode.isRoot()){
containerTree.getRoot().addChild(this);
}else{
parentContainer = new FeatureNodeContainer(containerTree);
parentContainer.setFeatureNode(parentFeatureNode);
}
-
+
parentContainer.addChild(this);
-
+
parentContainer.buildBranch();
-
+
}
}
}
-
+
/**
* <p>Getter for the field <code>children</code>.</p>
*
throw new IllegalStateException("Container may not have a description element set when setting children.");
}
}
-
+
/**
* Adds a child container to the list of this containers children
*
public void addDescriptionElement(DescriptionElementBase descriptionElement){
descriptionElements.add(descriptionElement);
}
-
+
public void removeDescriptionElement(DescriptionElementBase descriptionElement){
descriptionElements.remove(descriptionElement);
}
-
+
/**
* If {@link #isLeaf()} is true, i.e. this container should have elements, returns the list of description elements.
*
public List<DescriptionElementBase> getDescriptionElementsForEntireBranch(){
return getDescriptionElementsRecursively(new ArrayList<DescriptionElementBase>());
}
-
+
private List<DescriptionElementBase> getDescriptionElementsRecursively(List<DescriptionElementBase> descriptionElements){
if(isLeaf()){
descriptionElements.addAll(getDescriptionElements());
}
return descriptionElements;
}
-
+
protected List<FeatureNodeContainer> getLeafs(){
List<FeatureNodeContainer> leafs = new ArrayList<FeatureNodeContainer>();
-
+
if(isLeaf()){
leafs.add(this);
}else{
for(FeatureNodeContainer container : getChildren()){
leafs.addAll(container.getLeafs());
- }
+ }
}
return leafs;
}
-
+
/**
* Set the description element
*
throw new IllegalStateException("Container may not contain child container when adding description elements.");
}
}
-
+
/**
* If the container is a leaf, it will hold a description element and no child containers
*
public boolean isLeaf(){
return ! descriptionElements.isEmpty() && children.isEmpty();
}
-
+
/**
* <p>Setter for the field <code>featureNode</code>.</p>
*
public FeatureNode getFeatureNode() {
return featureNode;
}
-
+
/**
* <p>getFeature</p>
*
public DescriptionBase getDescription(){
return containerTree.getDescription();
}
-
+
public FeatureNodeContainerTree getContainerTree(){
return containerTree;
}
/**
- *
+ *
*/
public void clear() {
children.clear();
import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.swt.graphics.Image;
-import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
import eu.etaxonomy.taxeditor.store.StoreUtil;
import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;
package eu.etaxonomy.taxeditor.newWizard;
import eu.etaxonomy.cdm.api.service.IGrantedAuthorityService;
-import eu.etaxonomy.cdm.api.service.IGroupService;
import eu.etaxonomy.cdm.model.common.GrantedAuthorityImpl;
import eu.etaxonomy.taxeditor.store.CdmStore;
import eu.etaxonomy.taxeditor.ui.section.grantedAuthority.GrantedAuthorityDetailWizardPage;
-import eu.etaxonomy.taxeditor.ui.section.group.GroupDetailWizardPage;
/**
* @author a.kohlbecker
/**
- *
+ *
*/
package eu.etaxonomy.taxeditor.newWizard;
import eu.etaxonomy.cdm.api.service.IClassificationService;
import eu.etaxonomy.cdm.api.service.ITaxonNodeService;
import eu.etaxonomy.cdm.model.taxon.Classification;
-import eu.etaxonomy.cdm.model.taxon.ITreeNode;
+import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.taxeditor.store.CdmStore;
* @created Sep 15, 2009
* @version 1.0
*/
-public class NewTaxonNodeWizard extends AbstractNewEntityWizard<ITreeNode>{
+public class NewTaxonNodeWizard extends AbstractNewEntityWizard<ITaxonTreeNode>{
private TaxonNodeWizardPage taxonNodePage;
private boolean openEmptyEditor;
taxonNodePage = new TaxonNodeWizardPage(formFactory, getConversationHolder(), getEntity());
addPage(taxonNodePage);
}
-
+
@Override
protected void saveEntity() {
if(taxonNodePage.getTaxon() == null || StringUtils.isEmpty(taxonNodePage.getTaxon().getName().getFullTitleCache())){
openEmptyEditor = true;
}else{
getConversationHolder().bind();
- ITreeNode parent = getParentTreeNode();
+ ITaxonTreeNode parent = getParentTreeNode();
Taxon taxon = taxonNodePage.getTaxon();
try{
TaxonNode taxonNode = parent.addChildTaxon(taxon, parent.getReference(), parent.getMicroReference());
}
@Override
- protected ITreeNode createNewEntity() {
+ protected ITaxonTreeNode createNewEntity() {
if(getSelection() != null){
Object selectedObject = getSelection().getFirstElement();
- if(selectedObject instanceof ITreeNode){
- ITreeNode treeNode = (ITreeNode) selectedObject;
-
+ if(selectedObject instanceof ITaxonTreeNode){
+ ITaxonTreeNode treeNode = (ITaxonTreeNode) selectedObject;
+
if(treeNode instanceof Classification){
return CdmStore.getService(IClassificationService.class).load(treeNode.getUuid());
}
}
}
}
-
+
return null;
}
-
+
/**
* <p>openInEditor</p>
*
public boolean openInEditor(){
return taxonNodePage.openInEditor();
}
-
+
/**
* <p>openEmpty</p>
*
public boolean openEmpty(){
return openInEditor() && openEmptyEditor;
}
-
+
/**
* <p>getTaxonNode</p>
*
*/
public TaxonNode getTaxonNode(){
if(generatedTaxonNodeUuid != null){
- return CdmStore.getService(ITaxonNodeService.class).load(generatedTaxonNodeUuid);
+ return CdmStore.getService(ITaxonNodeService.class).load(generatedTaxonNodeUuid);
}
return null;
}
-
- public ITreeNode getParentTreeNode(){
+
+ public ITaxonTreeNode getParentTreeNode(){
return taxonNodePage.getParentTreeNode();
}
protected String getEntityName() {
return "Taxon";
}
-
+
}
\ No newline at end of file
// $Id$
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.
*/
import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
import eu.etaxonomy.cdm.model.common.CdmBase;
-import eu.etaxonomy.cdm.model.taxon.ITreeNode;
+import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
/**
*/
public abstract class AbstractPersistentPostOperation extends AbstractPostOperation {
private IConversationEnabled conversationEnabled;
-
- protected ITreeNode parentNode;
-
+
+ protected ITaxonTreeNode parentNode;
+
/**
* <p>Constructor for AbstractPersistentPostOperation.</p>
*
super(label, undoContext, postOperationEnabled);
this.conversationEnabled = conversationEnabled;
}
-
+
/**
* <p>Constructor for AbstractPersistentPostOperation.</p>
*
super(label, undoContext, taxonNode, postOperationEnabled);
this.conversationEnabled = conversationEnabled;
}
-
+
/**
* <p>Constructor for AbstractPersistentPostOperation.</p>
*
* @param undoContext a {@link org.eclipse.core.commands.operations.IUndoContext} object.
* @param postOperationEnabled a {@link eu.etaxonomy.taxeditor.operation.IPostOperationEnabled} object.
* @param conversationEnabled a {@link eu.etaxonomy.cdm.api.conversation.IConversationEnabled} object.
- * @param parentNode a {@link eu.etaxonomy.cdm.model.taxon.ITreeNode} object.
+ * @param parentNode a {@link eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode} object.
*/
public AbstractPersistentPostOperation(String label,
- IUndoContext undoContext, ITreeNode parentNode,
+ IUndoContext undoContext, ITaxonTreeNode parentNode,
IPostOperationEnabled postOperationEnabled,
IConversationEnabled conversationEnabled) {
super(label, undoContext, postOperationEnabled);
* @see eu.etaxonomy.taxeditor.operations.AbstractPostOperation#postExecute(eu.etaxonomy.cdm.model.common.CdmBase)
*/
/** {@inheritDoc} */
- protected IStatus postExecute(CdmBase objectAffectedByOperation) {
+ @Override
+ protected IStatus postExecute(CdmBase objectAffectedByOperation) {
Assert.isNotNull(conversationEnabled, "Operation has to have a valid conversation attached.");
-
+
conversationEnabled.getConversationHolder().commit(true);
-
+
IStatus status = super.postExecute(objectAffectedByOperation);
-
+
return status;
}
-
+
/**
* Binds the conversation that was attached to this operation.
*/
public void bind(){
- conversationEnabled.getConversationHolder().bind();
+ conversationEnabled.getConversationHolder().bind();
}
}
import java.util.ArrayList;
import java.util.HashMap;
-import java.util.Iterator;
import java.util.List;
import org.eclipse.core.commands.Command;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
-import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.ui.IWorkbenchPreferencePage;
import org.eclipse.ui.commands.ICommandService;
import org.eclipse.ui.handlers.IHandlerService;
-import org.eclipse.ui.internal.commands.Parameter;
import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
-import eu.etaxonomy.cdm.api.service.ITermService;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
import eu.etaxonomy.taxeditor.editor.definedterm.DefinedTermEditor;
import java.lang.reflect.Field;
import java.text.Collator;
import java.util.Comparator;
-import java.util.HashSet;
import java.util.List;
-import java.util.Set;
-import java.util.UUID;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
-import eu.etaxonomy.cdm.model.common.CdmBase;
-import eu.etaxonomy.cdm.model.common.ICdmBase;
import eu.etaxonomy.cdm.model.common.IEnumTerm;
-import eu.etaxonomy.cdm.model.common.IIdentifiableEntity;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
import eu.etaxonomy.taxeditor.newWizard.AbstractNewEntityWizard;
import eu.etaxonomy.taxeditor.store.StoreUtil;
import eu.etaxonomy.cdm.model.common.IIdentifiableEntity;
import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
+import eu.etaxonomy.taxeditor.model.AbstractUtility;
import eu.etaxonomy.taxeditor.newWizard.AbstractNewEntityWizard;
-import eu.etaxonomy.taxeditor.store.StoreUtil;
import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;
/**
public abstract class AbstractFilteredCdmResourceSelectionDialog<T extends ICdmBase> extends
FilteredItemsSelectionDialog implements IConversationEnabled {
- private ConversationHolder conversation;
+ private final ConversationHolder conversation;
protected List<UuidAndTitleCache<T>> model;
- private Set<T> transientCdmObjects = new HashSet<T>();
- private String settings;
+ private final Set<T> transientCdmObjects = new HashSet<T>();
+ private final String settings;
protected T cdmBaseToBeFiltered;
lastCompletedFilter.setAccessible(true);
lastCompletedFilter.set(this, null);
} catch (SecurityException e) {
- StoreUtil.error(getClass(), e);
+ AbstractUtility.error(getClass(), e);
} catch (NoSuchFieldException e) {
- StoreUtil.error(getClass(), e);
+ AbstractUtility.error(getClass(), e);
} catch (IllegalArgumentException e) {
- StoreUtil.error(getClass(), e);
+ AbstractUtility.error(getClass(), e);
} catch (IllegalAccessException e) {
- StoreUtil.error(getClass(), e);
+ AbstractUtility.error(getClass(), e);
}
// this also is not the nicest way to do it.
progressMonitor.worked(1);
}
}else{
- StoreUtil.warn(getClass(), "Model for Filtered Selection is null:" + this.getClass().getSimpleName());
+ AbstractUtility.warn(getClass(), "Model for Filtered Selection is null:" + this.getClass().getSimpleName());
}
}
finally {
@Override
protected Comparator getItemsComparator() {
return new Comparator<UuidAndTitleCache>() {
+ @Override
public int compare(UuidAndTitleCache entity1,
UuidAndTitleCache entity2) {
Collator collator = Collator.getInstance();
/*
* @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog.SelectionHistory#restoreItemFromMemento(org.eclipse.ui.IMemento)
*/
+ @Override
protected Object restoreItemFromMemento(IMemento element) {
return element.getString("resource"); //$NON-NLS-1$
}
* @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog.SelectionHistory#storeItemToMemento(java.lang.Object,
* org.eclipse.ui.IMemento)
*/
+ @Override
protected void storeItemToMemento(Object item, IMemento element) {
element.putString("resource", item.toString()); //$NON-NLS-1$
}
protected abstract AbstractNewEntityWizard getNewEntityWizard(String parameter);
public class FilteredCdmResourceLabelProvider extends LabelProvider {
+ @Override
public String getText(Object element) {
if (element == null) {
return null;
/** {@inheritDoc} */
@Override
protected Control createExtendedContentArea(Composite parent) {
- if(getNewWizardLinkText() != null){
+ String newWizardLinkText = getNewWizardLinkText();
+ if(newWizardLinkText != null){
Link link = new Link(parent, SWT.NONE);
- link.setText(getNewWizardLinkText());
+ link.setText(newWizardLinkText);
link.addSelectionListener(getNewWizardLinkSelectionListener());
return link;
}
*
* @return a {@link eu.etaxonomy.cdm.api.conversation.ConversationHolder} object.
*/
+ @Override
public ConversationHolder getConversationHolder() {
return conversation;
}
/** {@inheritDoc} */
+ @Override
public void update(CdmDataChangeMap changeEvents) {}
/**
// $Id$
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.
*/
*/
public class CollectionSelectionDialog extends
AbstractFilteredCdmResourceSelectionDialog<Collection> {
-
+
/**
* <p>select</p>
*
"Choose Collection", false, CollectionSelectionDialog.class.getCanonicalName(), collection);
return getSelectionFromDialog(dialog);
}
-
+
/**
* <p>Constructor for FilteredCollectionSelectionDialog.</p>
*
/** {@inheritDoc} */
@Override
protected String getNewWizardLinkText() {
- return "Click link to create a new <A>Collection</A>.";
+ return String.format("Click link to create a new <a>%1s</a>", "Collection ");
}
/* (non-Javadoc)
return new NewCollectionWizard();
}
-
+
}
import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
import eu.etaxonomy.cdm.api.service.IGrantedAuthorityService;
-import eu.etaxonomy.cdm.api.service.IGroupService;
-import eu.etaxonomy.cdm.api.service.IUserService;
import eu.etaxonomy.cdm.model.common.GrantedAuthorityImpl;
import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.taxeditor.newWizard.AbstractNewEntityWizard;
import eu.etaxonomy.taxeditor.newWizard.NewGrantedAuthorityWizard;
-import eu.etaxonomy.taxeditor.newWizard.NewGroupWizard;
import eu.etaxonomy.taxeditor.store.CdmStore;
/**
// $Id$
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.
*/
"Choose Institution", false, TeamSelectionDialog.class.getCanonicalName(), institution);
return getSelectionFromDialog(dialog);
}
-
+
/**
* @param shell
* @param conversation
@Override
protected Institution getPersistentObject(UUID uuid) {
AgentBase agentBase = CdmStore.getService(IAgentService.class).load(uuid);
-
+
if(agentBase instanceof Institution){
return (Institution) agentBase;
}
*/
@Override
protected String getNewWizardLinkText() {
- return "Create a new <A>Institution</A>.";
+ return "Create a new <a>Institution</a>.";
}
/* (non-Javadoc)
// $Id$
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.
*/
super(vocabulary.getTitleCache(), IAction.AS_CHECK_BOX);
this.vocabulary = vocabulary;
}
-
- public void run(){
+
+ @Override
+ public void run(){
if(isChecked()){
selectedVocabularies.add(vocabulary);
}else{
selectedVocabularies.remove(vocabulary);
}
-
+
initModel();
}
}
-
+
private Collection<TermVocabulary<NamedArea>> selectedVocabularies;
-
-
+
+
/**
* Creates a filtered selection dialog to select a named area.
*
"Choose an area", false, namedArea);
return getSelectionFromDialog(dialog);
}
-
+
/**
* <p>Constructor for FilteredNamedAreaSelectionDialog.</p>
*
* @param namedArea a {@link eu.etaxonomy.cdm.model.location.NamedArea} object.
*/
protected NamedAreaSelectionDialog(Shell shell, ConversationHolder conversation, String title, boolean multi, NamedArea namedArea) {
- super(shell, conversation, title, multi, NamedAreaSelectionDialog.class.getCanonicalName(), namedArea);
+ super(shell, conversation, title, multi, NamedAreaSelectionDialog.class.getCanonicalName(), namedArea);
}
-
+
/** {@inheritDoc} */
@Override
protected void fillViewMenu(IMenuManager menuManager) {
-
+
super.fillViewMenu(menuManager);
-
+
for(TermVocabulary<NamedArea> vocabulary : getVocabularies()){
IncludeNamedAreaVocabulary action = new IncludeNamedAreaVocabulary(vocabulary);
menuManager.add(action);
action.setChecked(true);
}
}
-
+
/** {@inheritDoc} */
@Override
protected NamedArea getPersistentObject(UUID uuid) {
}
return null;
}
-
+
/** {@inheritDoc} */
@Override
protected void init() {
selectedVocabularies = getVocabularies();
}
-
+
private List<TermVocabulary<NamedArea>> getVocabularies(){
List<TermVocabulary<NamedArea>> vocabularies = CdmStore.getService(IVocabularyService.class).listByTermClass(NamedArea.class, null, null, null, null);
vocabularies.add(CdmStore.getService(IVocabularyService.class).getVocabulary(VocabularyEnum.TdwgArea));
- vocabularies.add(CdmStore.getService(IVocabularyService.class).getVocabulary(VocabularyEnum.WaterbodyOrCountry));
+ vocabularies.add(CdmStore.getService(IVocabularyService.class).getVocabulary(VocabularyEnum.Country));
+ vocabularies.add(CdmStore.getService(IVocabularyService.class).getVocabulary(VocabularyEnum.Waterbody));
vocabularies.add(CdmStore.getService(IVocabularyService.class).getVocabulary(VocabularyEnum.Continent));
return vocabularies;
}
/** {@inheritDoc} */
@Override
protected void initModel() {
-
+
Set<NamedArea> terms = new HashSet<NamedArea>();
for(TermVocabulary<NamedArea> vocabulary : selectedVocabularies){
terms.addAll(vocabulary.getTermsOrderedByLabels(CdmStore.getDefaultLanguage()));
}
-
+
if(model == null){
model = new ArrayList<UuidAndTitleCache<NamedArea>>();
}
model.clear();
for(Object areaObject : terms){
NamedArea area = (NamedArea) HibernateProxyHelper.deproxy(areaObject);
- UuidAndTitleCache<NamedArea> element = new UuidAndTitleCache<NamedArea>(NamedArea.class, area.getUuid(), getTitle(area));
+ UuidAndTitleCache<NamedArea> element = new UuidAndTitleCache<NamedArea>(NamedArea.class, area.getUuid(), getTitle(area));
model.add(element);
}
}
protected Control createExtendedContentArea(Composite parent) {
return null;
}
-
+
/** {@inheritDoc} */
@Override
protected String getTitle(NamedArea namedArea) {
return namedArea.getTitleCache();
}
}
-
+
/** {@inheritDoc} */
@Override
protected AbstractNewEntityWizard getNewEntityWizard(String parameter) {
// $Id$
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.
*/
import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
import eu.etaxonomy.cdm.api.service.IReferenceService;
import eu.etaxonomy.cdm.model.reference.Reference;
-import eu.etaxonomy.cdm.strategy.cache.reference.ReferenceBaseDefaultCacheStrategy;
+import eu.etaxonomy.cdm.strategy.cache.reference.ReferenceDefaultCacheStrategy;
import eu.etaxonomy.taxeditor.newWizard.AbstractNewEntityWizard;
import eu.etaxonomy.taxeditor.newWizard.NewReferenceWizard;
import eu.etaxonomy.taxeditor.store.CdmStore;
* @version 1.0
*/
public class ReferenceSelectionDialog extends AbstractFilteredCdmResourceSelectionDialog<Reference> {
-
+
/**
* <p>select</p>
*
*/
public static Reference select(Shell shell, ConversationHolder conversation, Reference reference) {
ReferenceSelectionDialog dialog = new ReferenceSelectionDialog(shell, conversation,
- "Choose a reference", false, (Reference) reference);
+ "Choose a reference", false, reference);
return getSelectionFromDialog(dialog);
}
-
+
/**
* <p>Constructor for FilteredReferenceSelectionDialog.</p>
*
protected ReferenceSelectionDialog(Shell shell, ConversationHolder conversation, String title, boolean multi, Reference reference) {
super(shell, conversation, title, multi, ReferenceSelectionDialog.class.getCanonicalName(), null);
}
-
+
/* (non-Javadoc)
* @see eu.etaxonomy.taxeditor.dialogs.AbstractFilteredCdmResourceSelectionDialog#getPersistentObject(java.util.UUID)
*/
/** {@inheritDoc} */
@Override
- protected void initModel() {
+ protected void initModel() {
model = CdmStore.getService(IReferenceService.class).getUuidAndTitleCache();
}
-
+
/** {@inheritDoc} */
@Override
}else if(cdmObject.getAuthorTeam() == null){
return super.getTitle(cdmObject);
}else{
- return ReferenceBaseDefaultCacheStrategy.putAuthorToEndOfString(cdmObject.getTitleCache(), cdmObject.getAuthorTeam().getTitleCache());
+ return ReferenceDefaultCacheStrategy.putAuthorToEndOfString(cdmObject.getTitleCache(), cdmObject.getAuthorTeam().getTitleCache());
}
}
-
+
/** {@inheritDoc} */
@Override
protected AbstractNewEntityWizard getNewEntityWizard(String parameter) {
protected String getNewWizardLinkText() {
return "Click <A>here</A> to create a new reference.";
}
-
+
}
import eu.etaxonomy.cdm.model.common.Credit;
import eu.etaxonomy.cdm.model.common.DefinedTerm;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
-import eu.etaxonomy.cdm.model.description.DescriptionElementSource;
import eu.etaxonomy.cdm.model.common.Extension;
import eu.etaxonomy.cdm.model.common.GrantedAuthorityImpl;
import eu.etaxonomy.cdm.model.common.Group;
import eu.etaxonomy.cdm.model.common.ICdmBase;
-import eu.etaxonomy.cdm.model.common.IDefinedTerm;
import eu.etaxonomy.cdm.model.common.IEnumTerm;
import eu.etaxonomy.cdm.model.common.IdentifiableSource;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.description.CategoricalData;
import eu.etaxonomy.cdm.model.description.CommonTaxonName;
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
+import eu.etaxonomy.cdm.model.description.DescriptionElementSource;
import eu.etaxonomy.cdm.model.description.Distribution;
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.description.IndividualsAssociation;
import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;
import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
import eu.etaxonomy.cdm.model.occurrence.DeterminationEvent;
-import eu.etaxonomy.cdm.model.occurrence.GatheringEvent;
import eu.etaxonomy.cdm.model.reference.Reference;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
getEntity().setEnd(end);
} else if (eventSource == text_parseText) {
cursorPosition = ((Text) text_parseText.getMainControl())
- .getCaretPosition();
+ .getCaretPosition();
setEntityInternally(TimePeriodParser.parseString(text_parseText.getText()));
} else if (eventSource == text_freeText) {
getEntity().setFreeText(text_freeText.getText());
// $Id$
/**
* Copyright (C) 2007 EDIT
- * European Distributed Institute of Taxonomy
+ * 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.
*/
import org.eclipse.ui.forms.widgets.Section;
import eu.etaxonomy.cdm.api.facade.DerivedUnitFacade;
-import eu.etaxonomy.cdm.model.common.TimePeriod;
-import eu.etaxonomy.cdm.model.occurrence.GatheringEvent;
/**
* <p>
* GatheringEventUnitElement class.
* </p>
- *
+ *
* @author c.mathew
* @created 23 Jul. 2013
* @version 1.0
*/
public class GatheringEventUnitElement extends AbstractCdmFormElement implements ISelectable {
-
+
private final Label label;
private final MinMaxTextSection section_minMaxText;
* <p>
* Constructor for TimePeriodElement.
* </p>
- *
+ *
* @param style
* a int.
* @param formFactory
* a {@link eu.etaxonomy.cdm.model.common.TimePeriod} object.
*/
public GatheringEventUnitElement(CdmFormFactory formFactory,
- ICdmFormElement parentElement,
+ ICdmFormElement parentElement,
String labelString,
- DerivedUnitFacade gatheringEvent,
+ DerivedUnitFacade gatheringEvent,
MinMaxTextSection.UnitType unitType,
final int style) {
super(formFactory, parentElement);
section_minMaxText = formFactory.createMinMaxTextSection(this,
unitType,
Section.TWISTIE);
-
- addControl(section_minMaxText);
+
+ addControl(section_minMaxText);
section_minMaxText.setEntity(gatheringEvent);
-
+
formFactory.addPropertyChangeListener(this);
}
}
private void handleEvent(Object eventSource) {
- if (eventSource == section_minMaxText) {
+ if (eventSource == section_minMaxText) {
firePropertyChangeEvent(new CdmPropertyChangeEvent(this, null));
}
}
label.setBackground(color);
section_minMaxText.setBackground(color);
}
-
+
@Override
public void setSelected(boolean selected) {
setBackground(selected ? SELECTED : getPersistentBackground());
package eu.etaxonomy.taxeditor.ui.element;
+
/**
* Any composite that represent a cdm entity should implement
* this interface. Selection of CdmEntity data will rely on this
package eu.etaxonomy.taxeditor.ui.element;
import org.eclipse.jface.util.PropertyChangeEvent;
-import org.eclipse.swt.layout.RowLayout;
import eu.etaxonomy.cdm.api.facade.DerivedUnitFacade;
-import eu.etaxonomy.cdm.common.CdmUtils;
-import eu.etaxonomy.cdm.model.common.TimePeriod;
-import eu.etaxonomy.cdm.model.occurrence.GatheringEvent;
/**
* <p>
}catch(NumberFormatException e){
text.setBackground(Display.getCurrent().getSystemColor(SWT.COLOR_RED));
firePropertyChangeEvent(new CdmPropertyChangeEvent(this, e));
+ exception = e;
return;
}
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.reference.Reference;
import eu.etaxonomy.cdm.model.taxon.Classification;
-import eu.etaxonomy.cdm.model.taxon.ITreeNode;
+import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.taxeditor.parser.ParseHandler;
* @created Sep 27, 2010
* @version 1.0
*/
-public class TaxonNodeDetailElement extends AbstractCdmDetailElement<ITreeNode> {
+public class TaxonNodeDetailElement extends AbstractCdmDetailElement<ITaxonTreeNode> {
private EntitySelectionElement<Classification> selection_classification;
private TaxonNodeSelectionElement selection_parentTaxonNode;
- private ITreeNode parentTreeNode;
+ private ITaxonTreeNode parentTreeNode;
private EntitySelectionElement<Taxon> selection_reuseExistingTaxon;
/** {@inheritDoc} */
@Override
protected void createControls(ICdmFormElement formElement,
- ITreeNode entity, int style) {
+ ITaxonTreeNode entity, int style) {
selection_classification = formFactory
.createSelectionElement(Classification.class,
getConversationHolder(), formElement, "Classification",
* Getter for the field <code>parentTreeNode</code>.
* </p>
*
- * @return a {@link eu.etaxonomy.cdm.model.taxon.ITreeNode} object.
+ * @return a {@link eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode} object.
*/
- public ITreeNode getParentTreeNode() {
+ public ITaxonTreeNode getParentTreeNode() {
return parentTreeNode;
}
* @param parentTreeNode
* the parentTreeNode to set
*/
- private void setParentTreeNode(ITreeNode parentTreeNode) {
+ private void setParentTreeNode(ITaxonTreeNode parentTreeNode) {
this.parentTreeNode = parentTreeNode;
if (parentTreeNode instanceof Classification) {
import org.eclipse.jface.util.PropertyChangeEvent;
import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
-import eu.etaxonomy.cdm.model.taxon.ITreeNode;
+import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.taxeditor.ui.element.AbstractCdmEntityWizardPage;
import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;
* @created Sep 15, 2009
* @version 1.0
*/
-public class TaxonNodeWizardPage extends AbstractCdmEntityWizardPage<ITreeNode> {
+public class TaxonNodeWizardPage extends AbstractCdmEntityWizardPage<ITaxonTreeNode> {
/**
* <p>
* a {@link eu.etaxonomy.cdm.api.conversation.ConversationHolder}
* object.
* @param entity
- * a {@link eu.etaxonomy.cdm.model.taxon.ITreeNode} object.
+ * a {@link eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode} object.
*/
public TaxonNodeWizardPage(CdmFormFactory formFactory,
- ConversationHolder conversation, ITreeNode entity) {
+ ConversationHolder conversation, ITaxonTreeNode entity) {
super(formFactory, conversation, entity);
setTitle("Create a new Taxon");
}
* Getter for the field <code>parentTreeNode</code>.
* </p>
*
- * @return a {@link eu.etaxonomy.cdm.model.taxon.ITreeNode} object.
+ * @return a {@link eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode} object.
*/
- public ITreeNode getParentTreeNode() {
+ public ITaxonTreeNode getParentTreeNode() {
return ((TaxonNodeDetailElement) getDetailElement())
.getParentTreeNode();
}