}
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ public boolean postOperation(Object objectAffectedByOperation) {
return false;
}
--- /dev/null
+/**
+* Copyright (C) 2018 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.descriptiveDataSet;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.eclipse.jface.dialogs.Dialog;
+import org.eclipse.jface.layout.GridLayoutFactory;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Shell;
+
+import eu.etaxonomy.cdm.api.service.IVocabularyService;
+import eu.etaxonomy.cdm.model.common.TermType;
+import eu.etaxonomy.cdm.model.common.TermVocabulary;
+import eu.etaxonomy.cdm.model.location.NamedArea;
+import eu.etaxonomy.cdm.persistence.dto.TermDto;
+import eu.etaxonomy.taxeditor.editor.definedterm.TermDtoContentProvider;
+import eu.etaxonomy.taxeditor.editor.definedterm.TermDtoLabelProvider;
+import eu.etaxonomy.taxeditor.preference.wizard.CheckBoxTreeComposite;
+import eu.etaxonomy.taxeditor.store.CdmStore;
+
+/**
+ * @author pplitzner
+ * @since Oct 29, 2018
+ *
+ */
+public class AreasSelectionDialog extends Dialog{
+
+ private CheckBoxTreeComposite treeComposite;
+
+ private Set<TermDto> selectedAreas = new HashSet<>();
+
+ private Collection<TermVocabulary<NamedArea>> areaVocabularies;
+
+
+ protected AreasSelectionDialog(Shell parentShell, Set<TermDto> selectedAreas) {
+ super(parentShell);
+ this.selectedAreas = selectedAreas;
+ this.areaVocabularies = CdmStore.getService(IVocabularyService.class).findByTermType(TermType.NamedArea, null);
+ }
+
+ @Override
+ protected Control createDialogArea(Composite parent) {
+ parent.setLayout(new GridLayout());
+ treeComposite = new CheckBoxTreeComposite(parent, new TermDtoContentProvider(), new TermDtoLabelProvider(), SWT.NONE);
+ treeComposite.getViewer().setInput(areaVocabularies);
+ treeComposite.setCheckedElements(selectedAreas.toArray());
+ GridLayoutFactory.fillDefaults().applyTo(treeComposite);
+ return treeComposite;
+ }
+
+ @Override
+ protected void configureShell(Shell newShell) {
+ super.configureShell(newShell);
+ newShell.setText("Choose areas");
+ newShell.setSize(400, 600);
+ }
+
+ @Override
+ protected void okPressed() {
+ selectedAreas.clear();
+ List<Object> checkedElements = Arrays.asList(treeComposite.getViewer().getCheckedElements());
+ checkedElements = checkedElements.stream().filter(element->element instanceof TermDto).collect(Collectors.toList());
+ Collections.sort(checkedElements, (o1, o2)->((TermDto)o1).getOrderIndex()-((TermDto)o2).getOrderIndex());
+ selectedAreas = new HashSet(checkedElements);
+ super.okPressed();
+ }
+
+ @Override
+ protected boolean isResizable() {
+ return true;
+ }
+
+ public Set<TermDto> getSelectedAreas(){
+ return selectedAreas;
+ }
+}
*/
package eu.etaxonomy.taxeditor.editor.descriptiveDataSet;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import eu.etaxonomy.cdm.model.common.TermType;
import eu.etaxonomy.cdm.model.description.FeatureTree;
-import eu.etaxonomy.cdm.model.location.NamedArea;
import eu.etaxonomy.cdm.model.name.Rank;
+import eu.etaxonomy.cdm.persistence.dto.TermDto;
+import eu.etaxonomy.cdm.remote.l10n.TermRepresentation_L10n;
import eu.etaxonomy.taxeditor.editor.l10n.Messages;
import eu.etaxonomy.taxeditor.featuretree.e4.FeatureTreeEditorComposite;
import eu.etaxonomy.taxeditor.model.ImageResources;
private TermUuidComboViewer comboRankMax;
private FeatureTreeEditorComposite featureTreeEditorComposite;
private TreeViewer taxonNodeTree;
- private NamedArea area;
+ private Set<TermDto> areas = new HashSet<>();
private Text textAreaText;
private Button btnChooseArea;
- private Button btnRemoveArea;
private Button btnRemoveRankMin;
private Button btnRemoveRankMax;
Composite composite = new Composite(this, SWT.NONE);
composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false, 1, 1));
- GridLayout gl_composite = new GridLayout(3, false);
+ GridLayout gl_composite = new GridLayout(2, false);
gl_composite.horizontalSpacing = 0;
gl_composite.verticalSpacing = 0;
gl_composite.marginHeight = 0;
btnChooseArea = new Button(composite, SWT.NONE);
btnChooseArea.setImage(ImageResources.getImage(ImageResources.BROWSE_ICON));
- btnRemoveArea = new Button(composite, SWT.NONE);
- btnRemoveArea.setImage(ImageResources.getImage(ImageResources.TRASH_ICON));
-
featureTreeEditorComposite = new FeatureTreeEditorComposite(this, SWT.NONE);
featureTreeEditorComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1));
}
public TreeViewer getTaxonNodeTree() {
return taxonNodeTree;
}
-
- public NamedArea getArea(){
- return area;
+ public Set<TermDto> getAreas() {
+ return areas;
}
- public void setArea(NamedArea area) {
- this.area = area;
- textAreaText.setText(area.getLabel());
- }
- public void removeArea() {
- this.area = null;
- textAreaText.setText(""); //$NON-NLS-1$
+ public void setAreas(Set<TermDto> areas) {
+ this.areas = areas;
+ textAreaText.setText(areas.stream().map(area->{
+ area.localize(new TermRepresentation_L10n());
+ return area.getRepresentation_L10n();
+ }).collect(Collectors.joining(", ")));
}
public Button getBtnChooseArea() {
return btnChooseArea;
}
- public Button getBtnRemoveArea() {
- return btnRemoveArea;
- }
public Button getBtnRemoveRankMin() {
return btnRemoveRankMin;
}
import java.util.Map;
import java.util.Set;
import java.util.UUID;
+import java.util.stream.Collectors;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.Transfer;
import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.cdm.persistence.dto.TaxonNodeDto;
+import eu.etaxonomy.cdm.persistence.dto.TermDto;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
import eu.etaxonomy.taxeditor.editor.l10n.Messages;
import eu.etaxonomy.taxeditor.model.IDirtyMarkable;
import eu.etaxonomy.taxeditor.session.ICdmEntitySession;
import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
import eu.etaxonomy.taxeditor.store.CdmStore;
-import eu.etaxonomy.taxeditor.ui.dialog.selection.NamedAreaSelectionDialog;
import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;
import eu.etaxonomy.taxeditor.workbench.part.IE4SavablePart;
@Override
public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
- NamedArea area = NamedAreaSelectionDialog.select(shell, null, null);
- if(area!=null){
- composite.setArea(area);
+ AreasSelectionDialog areasSelectionDialog = new AreasSelectionDialog(composite.getShell(), composite.getAreas());
+ if(areasSelectionDialog.open()==Window.OK){
+ Set<TermDto> selectedAreas = areasSelectionDialog.getSelectedAreas();
+ if(selectedAreas!=null){
+ composite.setAreas(selectedAreas);
+ dirty.setDirty(true);
+ }
}
- dirty.setDirty(true);
- }
- });
- composite.getBtnRemoveArea().addSelectionListener(new SelectionAdapter() {
-
- @Override
- public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
- composite.removeArea();
- dirty.setDirty(true);
}
});
}
Set<NamedArea> geoFilter = descriptiveDataSet.getGeoFilter();
if(geoFilter!=null && !geoFilter.isEmpty()){
- composite.setArea(geoFilter.iterator().next());
+ Set<TermDto> terms = geoFilter.stream().map(filter->new TermDto(
+ filter.getUuid(),
+ filter.getRepresentations(),
+ filter.getPartOf()!=null?filter.getPartOf().getUuid():null,
+ filter.getVocabulary().getUuid(),
+ filter.getOrderIndex())).collect(Collectors.toSet());
+ composite.setAreas(terms);
}
Set<TaxonNode> taxonSubtreeFilter = descriptiveDataSet.getTaxonSubtreeFilter();
if(taxonSubtreeFilter!=null){
@Persist
@Override
public void save(IProgressMonitor monitor) {
- NamedArea area = composite.getArea();
- Set<NamedArea> areas = new HashSet<>();
- if(area!=null){
- areas.add(area);
- }
+ Set<TermDto> areas = composite.getAreas();
Object input = composite.getTaxonNodeTree().getInput();
if(input!=null){
descriptiveDataSet.setTaxonSubtreeFilter(new HashSet<>());//clear existing filter
descriptiveDataSet.setMaxRank(rankMax);
descriptiveDataSet.setMinRank(rankMin);
descriptiveDataSet.setDescriptiveSystem(characters);
- descriptiveDataSet.setGeoFilter(areas);
+ List<DefinedTermBase> terms = CdmStore.getService(ITermService.class)
+ .load(areas.stream().map(area -> area.getUuid()).collect(Collectors.toList()), null);
+ Set<NamedArea> areaTerms = new HashSet<>();
+ terms.forEach(term->areaTerms.add((NamedArea) term));
+ descriptiveDataSet.setGeoFilter(areaTerms);
conversation.commit();
CdmStore.getService(IDescriptiveDataSetService.class).merge(descriptiveDataSet, true);
import org.eclipse.zest.layouts.algorithms.TreeLayoutAlgorithm;
import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
-import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.description.IIdentificationKey;
import eu.etaxonomy.cdm.model.description.PolytomousKeyNode;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
}
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ public boolean postOperation(Object objectAffectedByOperation) {
setDirty(true);
refresh();
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.description.PolytomousKey;
import eu.etaxonomy.cdm.model.description.PolytomousKeyNode;
import eu.etaxonomy.cdm.model.taxon.Taxon;
}
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ public boolean postOperation(Object objectAffectedByOperation) {
viewer.refresh();
if (objectAffectedByOperation != null) {
}
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ public boolean postOperation(Object objectAffectedByOperation) {
changed(objectAffectedByOperation);
import org.eclipse.ui.forms.widgets.TableWrapData;
import org.eclipse.ui.forms.widgets.TableWrapLayout;
-import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.taxeditor.editor.CdmDataTransfer;
import eu.etaxonomy.taxeditor.editor.name.e4.IDropTargetableE4;
import eu.etaxonomy.taxeditor.editor.name.e4.TaxonNameEditorE4;
/** {@inheritDoc} */
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ public boolean postOperation(Object objectAffectedByOperation) {
editor.changed(objectAffectedByOperation);
redraw();
return true;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.widgets.Shell;
-import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
import eu.etaxonomy.cdm.model.name.TaxonName;
import eu.etaxonomy.cdm.model.taxon.Synonym;
/** {@inheritDoc} */
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ public boolean postOperation(Object objectAffectedByOperation) {
// Redraw existing editor
((IPostOperationEnabled) editor).postOperation(null);
import eu.etaxonomy.cdm.api.service.config.SynonymDeletionConfigurator;
import eu.etaxonomy.cdm.api.service.config.TaxonBaseDeletionConfigurator;
import eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator;
-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.TaxonBase;
}
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ public boolean postOperation(Object objectAffectedByOperation) {
editor.redraw();
return true;
}
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.widgets.Shell;
-import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.taxon.Synonym;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.taxeditor.editor.EditorUtil;
}
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ public boolean postOperation(Object objectAffectedByOperation) {
editor.redraw();
return false;
}
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
-import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.taxon.Synonym;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.taxeditor.editor.EditorUtil;
}
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ public boolean postOperation(Object objectAffectedByOperation) {
// Redraw existing editor
// ((IPostOperationEnabled) editor).postOperation(null);
import eu.etaxonomy.cdm.api.service.IOccurrenceService;
import eu.etaxonomy.cdm.api.service.ITaxonService;
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
-import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.molecular.SingleRead;
import eu.etaxonomy.cdm.model.occurrence.FieldUnit;
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
}
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ public boolean postOperation(Object objectAffectedByOperation) {
refreshTree();
if(objectAffectedByOperation!=null){
changed(objectAffectedByOperation);
import eu.etaxonomy.cdm.api.service.IDescriptionService;
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
-import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.description.DescriptionBase;
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
import eu.etaxonomy.cdm.model.description.TaxonDescription;
/** {@inheritDoc} */
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ public boolean postOperation(Object objectAffectedByOperation) {
editor.getConversationHolder().bind();
editor.getConversationHolder().commit(true);
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
-import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.description.DescriptionBase;
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.taxon.Classification;
/** {@inheritDoc} */
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ public boolean postOperation(Object objectAffectedByOperation) {
Display.getDefault().asyncExec(new Runnable(){
@Override
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Tree;
-import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.taxeditor.editor.l10n.Messages;
import eu.etaxonomy.taxeditor.editor.view.descriptive.DescriptionElementDragListener;
import eu.etaxonomy.taxeditor.editor.view.descriptive.DescriptionElementDropAdapter;
/** {@inheritDoc} */
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ public boolean postOperation(Object objectAffectedByOperation) {
viewer.refresh();
return super.postOperation(objectAffectedByOperation);
}
import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
import eu.etaxonomy.cdm.api.service.IPolytomousKeyService;
-import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.description.PolytomousKey;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
import eu.etaxonomy.taxeditor.model.ContextListenerAdapter;
}
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ public boolean postOperation(Object objectAffectedByOperation) {
getConversationHolder().bind();
getConversationHolder().commit(true);
viewer.refresh();
/** {@inheritDoc} */
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ public boolean postOperation(Object objectAffectedByOperation) {
viewer.refresh();
return true;
}
package eu.etaxonomy.taxeditor.editor.definedterm;
import org.eclipse.jface.viewers.Viewer;
-import org.eclipse.jface.viewers.ViewerSorter;
+import org.eclipse.jface.viewers.ViewerComparator;
import eu.etaxonomy.cdm.model.common.OrderedTermBase;
+import eu.etaxonomy.cdm.persistence.dto.TermDto;
/**
* @author pplitzner
* @date 13.02.2018
*
*/
-public class DefinedTermSorter extends ViewerSorter {
+public class DefinedTermSorter extends ViewerComparator {
@Override
public int compare(Viewer viewer, Object e1, Object e2) {
- // the comparison value in this method determines the
+ // the comparison value in this method determines the
// location <-> add term method used in the MoveDefinedTermOperation
// execute call
+ //FIXME: remove this when all viewer are changed to use DTOs
if(e1 instanceof OrderedTermBase && e2 instanceof OrderedTermBase) {
OrderedTermBase otbe1 = (OrderedTermBase)e1;
OrderedTermBase otbe2 = (OrderedTermBase)e2;
} else{
return 1;
}
- } else {
+ }
+ else if(e1 instanceof TermDto && e2 instanceof TermDto) {
+ TermDto termDto1 = (TermDto)e1;
+ TermDto termDto2 = (TermDto)e2;
+ if(termDto1.getOrderIndex() == termDto2.getOrderIndex()) {
+ return 0;
+ } else if (termDto1.getOrderIndex() < termDto2.getOrderIndex()){
+ return -1;
+ } else{
+ return 1;
+ }
+ }
+ else {
return super.compare(viewer, e1, e2);
}
}
/**\r
* Copyright (C) 2009 EDIT\r
-* European Distributed Institute of Taxonomy \r
+* European Distributed Institute of Taxonomy\r
* http://www.e-taxonomy.eu\r
-* \r
+*\r
* The contents of this file are subject to the Mozilla Public License Version 1.1\r
* See LICENSE.TXT at the top of this package for the full license terms.\r
*/\r
import org.eclipse.core.expressions.PropertyTester;\r
import org.eclipse.jface.viewers.IStructuredSelection;\r
\r
+import eu.etaxonomy.cdm.api.service.IVocabularyService;\r
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;\r
import eu.etaxonomy.cdm.model.common.DefinedTermBase;\r
import eu.etaxonomy.cdm.model.common.Marker;\r
import eu.etaxonomy.cdm.model.common.MarkerType;\r
import eu.etaxonomy.cdm.model.common.TermBase;\r
import eu.etaxonomy.cdm.model.common.TermVocabulary;\r
+import eu.etaxonomy.cdm.persistence.dto.TermDto;\r
+import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;\r
+import eu.etaxonomy.taxeditor.store.CdmStore;\r
\r
/**\r
* @author l.morris\r
public class TermBasePropertyTester extends PropertyTester {\r
\r
private static final String IS_MODIFIABLE = "isModifiable";\r
- \r
+\r
\r
/* (non-Javadoc)\r
* @see org.eclipse.core.expressions.IPropertyTester#test(java.lang.Object, java.lang.String, java.lang.Object[], java.lang.Object)\r
@Override\r
public boolean test(Object receiver, String property, Object[] args,\r
Object expectedValue) {\r
- \r
+\r
IStructuredSelection selection = (IStructuredSelection) receiver;\r
Object selectedElement = selection.getFirstElement();\r
if (selectedElement != null && HibernateProxyHelper.isInstanceOf(selectedElement, TermBase.class)){\r
return isModifiable(term);\r
}\r
}\r
- \r
+\r
return false;\r
}\r
\r
\r
/**\r
* Checks whether there is a {@link Marker} with the type {@link MarkerType#MODIFIABLE()} and if there is then return its value.\r
- * \r
- * @return The markers value if it exists \r
+ *\r
+ * @return The markers value if it exists\r
*/\r
- public static boolean isModifiable(TermBase termBase) {\r
- if (termBase == null){\r
+ public static boolean isModifiable(Object object) {\r
+ if (object == null){\r
return true;\r
}\r
- \r
+\r
TermVocabulary vocabulary = null;\r
- \r
- if(termBase instanceof DefinedTermBase){\r
- vocabulary = ((DefinedTermBase) termBase).getVocabulary();\r
- }else if(termBase instanceof TermVocabulary){\r
- vocabulary = (TermVocabulary) termBase;\r
- }\r
- \r
+\r
+ if(object instanceof DefinedTermBase){\r
+ vocabulary = ((DefinedTermBase) object).getVocabulary();\r
+ }else if(object instanceof TermVocabulary){\r
+ vocabulary = (TermVocabulary) object;\r
+ }else if(object instanceof TermDto){\r
+ vocabulary = CdmStore.getService(IVocabularyService.class).load(((TermDto) object).getVocabularyUuid());\r
+ }else if(object instanceof TermVocabularyDto){\r
+ vocabulary = CdmStore.getService(IVocabularyService.class).load(((TermVocabularyDto) object).getUuid());\r
+ }\r
+\r
if(vocabulary == null){\r
return true;\r
}\r
- \r
+\r
for(Marker vocabularyMarker : vocabulary.getMarkers()){\r
if(vocabularyMarker.getMarkerType().equals(MarkerType.MODIFIABLE())){\r
- return vocabularyMarker.getValue(); \r
+ return vocabularyMarker.getValue();\r
}\r
}\r
- \r
+\r
return true;\r
}\r
\r
--- /dev/null
+/**
+* Copyright (C) 2009 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.definedterm;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.UUID;
+
+import org.eclipse.jface.viewers.TreeNodeContentProvider;
+
+import eu.etaxonomy.cdm.api.service.IVocabularyService;
+import eu.etaxonomy.cdm.persistence.dto.TermDto;
+import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
+import eu.etaxonomy.taxeditor.store.CdmStore;
+
+/**
+ *
+ * @author pplitzner
+ * @since Oct 29, 2018
+ *
+ */
+public class TermDtoContentProvider extends TreeNodeContentProvider {
+
+ @Override
+ public Object[] getElements(Object inputElement) {
+ Collection<TermVocabularyDto> inputElements = (Collection<TermVocabularyDto>) inputElement;
+ return inputElements.toArray();
+ }
+
+ @Override
+ public Object[] getChildren(Object parentElement) {
+ Collection<Object> children = new HashSet<>();
+ if(parentElement instanceof TermVocabularyDto){
+ children.addAll(CdmStore.getService(IVocabularyService.class).getCompleteTermHierarchy(((TermVocabularyDto)parentElement).getUuid()));
+ } else if(parentElement instanceof TermDto){
+ if(((TermDto) parentElement).getIncludes()!=null){
+ children.addAll(((TermDto) parentElement).getIncludes());
+ }
+ if(((TermDto) parentElement).getGeneralizationOf()!=null){
+ children.addAll(((TermDto) parentElement).getGeneralizationOf());
+ }
+ }
+ return children.toArray();
+ }
+
+ @Override
+ public Object getParent(Object element) {
+ if(element instanceof TermDto){
+ UUID partOfUuid = ((TermDto) element).getPartOfUuid();
+ if(partOfUuid==null){
+ return CdmStore.getService(IVocabularyService.class).load(((TermDto) element).getVocabularyUuid());
+ }
+ return new TermDto(partOfUuid, null, null);
+ }
+ return null;
+
+ }
+
+ @Override
+ public boolean hasChildren(Object element) {
+ if(element instanceof TermVocabularyDto){
+ //performance optimization
+ return true;
+ }
+ if (getChildren(element) != null){
+ return getChildren(element).length > 0;
+ }
+ return false;
+ }
+
+}
--- /dev/null
+/**
+ * Copyright (C) 2009 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.definedterm;
+
+import org.eclipse.jface.viewers.StyledCellLabelProvider;
+import org.eclipse.jface.viewers.StyledString;
+import org.eclipse.jface.viewers.StyledString.Styler;
+import org.eclipse.jface.viewers.ViewerCell;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.custom.StyleRange;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.TextStyle;
+import org.eclipse.swt.widgets.Display;
+
+import eu.etaxonomy.cdm.common.CdmUtils;
+import eu.etaxonomy.cdm.persistence.dto.AbstractTermDto;
+import eu.etaxonomy.cdm.persistence.dto.TermDto;
+import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
+import eu.etaxonomy.cdm.remote.l10n.TermRepresentation_L10n;
+
+/**
+ *
+ * @author pplitzner
+ * @since Oct 29, 2018
+ *
+ */
+public class TermDtoLabelProvider extends StyledCellLabelProvider {
+
+ private static Color vocColor = Display.getCurrent().getSystemColor(SWT.COLOR_BLUE);
+ private static Color kindOfColor = Display.getCurrent().getSystemColor(SWT.COLOR_DARK_GRAY);
+ private Styler vocStyler;
+ private Styler kindOfStyler;
+
+ public TermDtoLabelProvider() {
+ }
+
+ public TermDtoLabelProvider(Styler vocStyler){
+ this.vocStyler = vocStyler;
+ }
+
+ @Override
+ public void update(ViewerCell cell) {
+ Object element = cell.getElement();
+
+ String text = getText(element);
+ cell.setText(text);
+
+ Styler styler = null;
+ if (element instanceof TermVocabularyDto && text != null) {
+ styler = getVocabularyStyler();
+ }
+ else if(element instanceof TermDto && ((TermDto) element).getKindOfUuid()!=null){
+ styler = getKindOfStyler();
+ }
+ if(styler!=null){
+ StyledString styledString = new StyledString(text, styler);
+ StyleRange[] styleRanges;
+ styleRanges = styledString.getStyleRanges();
+ cell.setStyleRanges(styleRanges);
+ }
+ super.update(cell);
+ }
+
+ public String getText(Object element) {
+ String label = null;
+ if(element instanceof AbstractTermDto){
+ AbstractTermDto termDto = (AbstractTermDto)element;
+ termDto.localize(new TermRepresentation_L10n());
+ label = termDto.getRepresentation_L10n();
+
+ if(element instanceof TermDto && ((TermDto) termDto).getIdInVocabulary()!=null){
+ label = CdmUtils.concat(" : ", ((TermDto) termDto).getIdInVocabulary(), label);
+ }
+ }
+ // TODO add fallback for label
+ if(label==null){
+ label = element.toString();
+ }
+ return label;
+ }
+
+ protected Styler getVocabularyStyler() {
+ if (vocStyler == null) {
+ vocStyler = new Styler() {
+ @Override
+ public void applyStyles(TextStyle textStyle) {
+ textStyle.foreground = vocColor;
+ }
+ };
+ }
+ return vocStyler;
+ }
+
+ protected Styler getKindOfStyler() {
+ if (kindOfStyler == null) {
+ kindOfStyler = new Styler() {
+ @Override
+ public void applyStyles(TextStyle textStyle) {
+ textStyle.foreground = kindOfColor;
+ }
+ };
+ }
+ return kindOfStyler;
+ }
+
+}
private Styler kindOfStyler;
public TermLabelProvider() {
+ this.vocStyler = new Styler() {
+ @Override
+ public void applyStyles(TextStyle textStyle) {
+ textStyle.foreground = Display.getCurrent().getSystemColor(SWT.COLOR_BLACK);
+ }
+ };
}
public TermLabelProvider(Styler vocStyler){
*/
package eu.etaxonomy.taxeditor.editor.definedterm.e4;
-import java.util.ArrayList;
import java.util.List;
+import org.eclipse.jface.util.LocalSelectionTransfer;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.dnd.DragSourceAdapter;
import org.eclipse.swt.dnd.DragSourceEvent;
-import eu.etaxonomy.cdm.model.common.DefinedTermBase;
-import eu.etaxonomy.taxeditor.editor.definedterm.TermTransfer;
+import eu.etaxonomy.cdm.persistence.dto.TermDto;
/**
*
IStructuredSelection selection = (IStructuredSelection) viewer.getSelection();
List list = selection.toList();
for (Object object : list) {
- if(!(object instanceof DefinedTermBase)){
+ if(!(object instanceof TermDto)){
event.doit = false;
return;
}
@Override
public void dragSetData(DragSourceEvent event) {
+ IStructuredSelection selection = (IStructuredSelection) viewer.getSelection();
+ if (LocalSelectionTransfer.getTransfer().isSupportedType(event.dataType)) {
+ LocalSelectionTransfer.getTransfer().setSelection(selection);
+ }
- IStructuredSelection selection = (IStructuredSelection) viewer.getSelection();
- List<DefinedTermBase> definedTerms = new ArrayList<DefinedTermBase>();
-
- for (Object object : selection.toList()){
- definedTerms.add((DefinedTermBase)object);
- }
-
- if (TermTransfer.getInstance().isSupportedType(
- event.dataType)) {
- event.data = definedTerms.toArray(new DefinedTermBase[definedTerms.size()]);
- }
}
}
import javax.inject.Inject;
import org.eclipse.e4.ui.di.UISynchronize;
+import org.eclipse.jface.util.LocalSelectionTransfer;
+import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.swt.dnd.DND;
-import org.eclipse.swt.dnd.DropTargetEvent;
import org.eclipse.swt.dnd.TransferData;
-import eu.etaxonomy.cdm.model.common.DefinedTermBase;
-import eu.etaxonomy.cdm.model.common.OrderedTermBase;
-import eu.etaxonomy.cdm.model.common.TermBase;
-import eu.etaxonomy.taxeditor.editor.definedterm.TermTransfer;
+import eu.etaxonomy.cdm.persistence.dto.AbstractTermDto;
+import eu.etaxonomy.cdm.persistence.dto.TermDto;
import eu.etaxonomy.taxeditor.editor.definedterm.operation.MoveDefinedTermOperation;
+import eu.etaxonomy.taxeditor.model.AbstractUtility;
import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
import eu.etaxonomy.taxeditor.store.StoreUtil;
import eu.etaxonomy.taxeditor.ui.EditViewerDropAdapter;
@Override
public boolean performDrop(Object data) {
-
- TermBase target = (TermBase) getCurrentTarget();//can be vocab
+ if(editor.checkDirty()){
+ return false;
+ }
+ AbstractTermDto target = (AbstractTermDto) getCurrentTarget();//can be vocab
int currentLocation = getCurrentLocation();
- Object[] droppedTerms = (Object[]) data;
- Collection<DefinedTermBase> sourceTerms = new ArrayList<DefinedTermBase>(); //Arrays.asList(droppedElements)
+ IStructuredSelection droppedTerms = (IStructuredSelection) data;
+ Collection<TermDto> sourceTerms = new ArrayList<>(); //Arrays.asList(droppedElements)
- for (Object droppedTerm : droppedTerms) {
- DefinedTermBase term = (DefinedTermBase) droppedTerm;
+ for (Object droppedTerm : droppedTerms.toList()) {
+ TermDto term = (TermDto) droppedTerm;
sourceTerms.add(term);
}
sourceTerms,
editor,
currentLocation);
- //TODO: implement execute
- StoreUtil.executeOperation(operation, sync);
+ AbstractUtility.executeOperation(operation, sync);
// select the newly moved objects
- editor.getViewer().setSelection(new StructuredSelection(sourceTerms.toArray(new TermBase[sourceTerms.size()])));
+ editor.getViewer().setSelection(new StructuredSelection(sourceTerms));
return true;
}
@Override
public boolean validateDrop(Object target, int operation,
TransferData transferType) {
- boolean transferDataIsSupported = TermTransfer.getInstance().isSupportedType(transferType);
- // maybe don't need this - they will be all TermBase anyway
- return target instanceof TermBase && transferDataIsSupported;
- }
-
- @Override
- public void dragOver(DropTargetEvent event) {
- super.dragOver(event);
- TermBase target = (TermBase) getCurrentTarget();
- if(!(target instanceof OrderedTermBase)) {
- // this is to only disable insert between items
- event.feedback = DND.FEEDBACK_SELECT | DND.FEEDBACK_SCROLL;
- }
-
-
+ return LocalSelectionTransfer.getTransfer().isSupportedType(transferType) && target instanceof AbstractTermDto;
}
}
*/
package eu.etaxonomy.taxeditor.editor.definedterm.e4;
+import java.util.ArrayList;
+import java.util.List;
+
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import org.eclipse.e4.ui.services.EMenuService;
import org.eclipse.e4.ui.workbench.modeling.EPartService;
import org.eclipse.e4.ui.workbench.modeling.ESelectionService;
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.jface.util.LocalSelectionTransfer;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
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.api.service.ITermService;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
+import eu.etaxonomy.cdm.persistence.dto.TermDto;
+import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
import eu.etaxonomy.taxeditor.editor.definedterm.DefinedTermSorter;
-import eu.etaxonomy.taxeditor.editor.definedterm.TermContentProvider;
-import eu.etaxonomy.taxeditor.editor.definedterm.TermLabelProvider;
-import eu.etaxonomy.taxeditor.editor.definedterm.TermTransfer;
+import eu.etaxonomy.taxeditor.editor.definedterm.TermDtoContentProvider;
+import eu.etaxonomy.taxeditor.editor.definedterm.TermDtoLabelProvider;
import eu.etaxonomy.taxeditor.editor.definedterm.input.TermEditorInput;
import eu.etaxonomy.taxeditor.event.EventUtility;
import eu.etaxonomy.taxeditor.event.WorkbenchEventConstants;
+import eu.etaxonomy.taxeditor.l10n.Messages;
import eu.etaxonomy.taxeditor.model.IContextListener;
import eu.etaxonomy.taxeditor.model.IDirtyMarkable;
import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;
public class DefinedTermEditorE4 implements IConversationEnabled, IDirtyMarkable, IPostOperationEnabled,
IPartContentHasDetails, IPartContentHasSupplementalData, IE4SavablePart, IContextListener {
- public static final String OPEN_COMMAND_ID = "eu.etaxonomy.taxeditor.store.openDefinedTermEditor";
+ public static final String OPEN_COMMAND_ID = "eu.etaxonomy.taxeditor.store.openDefinedTermEditor"; //$NON-NLS-1$
protected TreeViewer viewer;
@Inject
private MPart thisPart;
+ private List<DefinedTermBase> changedTerms = new ArrayList<>();
+
@Inject
public DefinedTermEditorE4() {
CdmStore.getContextManager().addContextListener(this);
parent.setLayout(layout);
viewer = new TreeViewer(new Tree(parent, SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.MULTI));
viewer.getControl().setLayoutData(LayoutConstants.FILL());
- viewer.setContentProvider(new TermContentProvider());
- viewer.setLabelProvider(new TermLabelProvider());
- viewer.setSorter(new DefinedTermSorter());
+ viewer.setContentProvider(new TermDtoContentProvider());
+ viewer.setLabelProvider(new TermDtoLabelProvider());
+ viewer.setComparator(new DefinedTermSorter());
- Transfer[] transfers = new Transfer[] { TermTransfer.getInstance() };
+ Transfer[] transfers = new Transfer[] { LocalSelectionTransfer.getTransfer() };
viewer.addDragSupport(dndOperations, transfers, new DefinedTermDragListenerE4(viewer));
DefinedTermDropAdapterE4 dropListener = new DefinedTermDropAdapterE4(this);
ContextInjectionFactory.inject(dropListener, context);
viewer.addSelectionChangedListener(selectionChangedListener);
//create context menu
- menuService.registerContextMenu(viewer.getControl(), "eu.etaxonomy.taxeditor.store.popupmenu.termeditor");
+ menuService.registerContextMenu(viewer.getControl(), "eu.etaxonomy.taxeditor.store.popupmenu.termeditor"); //$NON-NLS-1$
}
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
- if(objectAffectedByOperation.isInstanceOf(DefinedTermBase.class)){
- TermVocabulary vocabulary = HibernateProxyHelper.deproxy(objectAffectedByOperation, DefinedTermBase.class).getVocabulary();
- viewer.refresh(vocabulary);
- }
- else{
- viewer.refresh();
- }
-
+ public boolean postOperation(Object objectAffectedByOperation) {
+ viewer.refresh();
if(objectAffectedByOperation != null){
- viewer.setSelection(new StructuredSelection(objectAffectedByOperation));
+ StructuredSelection selection = new StructuredSelection(objectAffectedByOperation);
+ viewer.setSelection(selection);
+ viewer.expandToLevel(objectAffectedByOperation, 1);
}
- setDirty(true);
-
return true;
}
thisPart.setLabel(input.getName());
}
+ /**
+ * Checks the dirty flag and, if set, prompts the user to optionally save
+ * the editor
+ *
+ * @return <code>false</code> if the editor is not dirty anymore, either
+ * because it wasn't beforehand or because it has been saved.
+ * <code>true</code> otherwise
+ */
+ public boolean checkDirty(){
+ if (isDirty()){
+ boolean proceed = MessageDialog.openQuestion(null,
+ Messages.DefinedTermEditorE4_SAVE_TITLE, Messages.DefinedTermEditorE4_SAVE_MESSAGE);
+ if (proceed) {
+ save(null);
+ return false;
+ }
+ else{
+ return true;
+ }
+ }
+ else{
+ return false;
+ }
+ }
+
@Override
@Persist
public void save(IProgressMonitor monitor) {
getConversationHolder().commit();
+ changedTerms.forEach(term->CdmStore.getService(ITermService.class).merge(term));
+ changedTerms.clear();
input.merge();
setDirty(false);
input.initialiseVocabularies();
@Override
public void changed(Object element) {
+ if(element instanceof DefinedTermBase){
+ DefinedTermBase definedTermBase = (DefinedTermBase) element;
+ TermDto termDto = new TermDto(definedTermBase.getUuid(),
+ definedTermBase.getRepresentations(),
+ null,
+ null,
+ null);
+ viewer.update(termDto, null);
+ changedTerms.add(definedTermBase);
+ }
+ else if(element instanceof TermVocabulary){
+ TermVocabulary vocabulary = (TermVocabulary)element;
+ TermVocabularyDto vocabularyDto = new TermVocabularyDto(vocabulary.getUuid(), vocabulary.getRepresentations());
+ viewer.update(vocabularyDto, null);
+ }
setDirty(true);
viewer.update(element, null);
}
*/
package eu.etaxonomy.taxeditor.editor.definedterm.e4.handler;
+import java.util.UUID;
+
import javax.inject.Named;
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.e4.ui.services.IServiceConstants;
import org.eclipse.jface.viewers.IStructuredSelection;
-import eu.etaxonomy.cdm.model.common.DefinedTermBase;
-import eu.etaxonomy.cdm.model.common.TermBase;
-import eu.etaxonomy.cdm.model.common.TermVocabulary;
+import eu.etaxonomy.cdm.persistence.dto.AbstractTermDto;
+import eu.etaxonomy.cdm.persistence.dto.TermDto;
+import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
import eu.etaxonomy.taxeditor.editor.definedterm.e4.DefinedTermEditorE4;
import eu.etaxonomy.taxeditor.editor.definedterm.operation.CreateDefinedTermOperation;
import eu.etaxonomy.taxeditor.model.AbstractUtility;
import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
+import eu.etaxonomy.taxeditor.store.AppModelId;
import eu.etaxonomy.taxeditor.store.StoreUtil;
/**
public void execute(@Named(IServiceConstants.ACTIVE_PART) MPart activePart,
@Named(IServiceConstants.ACTIVE_SELECTION) IStructuredSelection selection, MHandledMenuItem menuItem,
UISynchronize sync) {
-
DefinedTermEditorE4 termEditor = (DefinedTermEditorE4) activePart.getObject();
-
+ if(termEditor.checkDirty()){
+ return;
+ }
boolean addTermAsKindOf =
- menuItem.getCommand().getElementId().equals("eu.etaxonomy.taxeditor.editor.definedTerms.newKindOfTerm")?true:false;
+ menuItem.getCommand().getElementId()
+ .equals(AppModelId.COMMAND_EU_ETAXONOMY_TAXEDITOR_EDITOR_DEFINEDTERMS_NEWKINDOFTERM)?true:false;
String label = menuItem.getLocalizedLabel();
IUndoContext undoContext = StoreUtil.getUndoContext();
+ AbstractTermDto parent = (AbstractTermDto) selection.getFirstElement();
AbstractPostOperation operation =
new CreateDefinedTermOperation(label,
undoContext,
- (TermBase) selection.getFirstElement(),
+ parent,
termEditor.getDefinedTermEditorInput(),
termEditor, addTermAsKindOf);
AbstractUtility.executeOperation(operation, sync);
Object firstElement = selection.getFirstElement();
canExecute = selection.size()==1
&&
- (firstElement instanceof DefinedTermBase
- || firstElement instanceof TermVocabulary);
- TermVocabulary vocabulary = null;
+ (firstElement instanceof TermDto
+ || firstElement instanceof TermVocabularyDto);
+ UUID vocabularyUuid = null;
- if(firstElement instanceof DefinedTermBase){
- vocabulary = ((DefinedTermBase) firstElement).getVocabulary();
- }else if(firstElement instanceof TermVocabulary){
- vocabulary = (TermVocabulary) firstElement;
+ if(firstElement instanceof TermDto){
+ vocabularyUuid = ((TermDto) firstElement).getVocabularyUuid();
+ }else if(firstElement instanceof TermVocabularyDto
+ && !menuItem.getCommand().getElementId()
+ .equals(AppModelId.COMMAND_EU_ETAXONOMY_TAXEDITOR_EDITOR_DEFINEDTERMS_NEWKINDOFTERM)){
+ vocabularyUuid = ((TermVocabularyDto) firstElement).getUuid();
}
- canExecute &= vocabulary!=null;
+ canExecute &= vocabularyUuid!=null;
menuItem.setVisible(canExecute);
return canExecute;
}
public void execute(@Named(IServiceConstants.ACTIVE_PART) MPart activePart,
MMenuItem menuItem,
UISynchronize sync) {
-
DefinedTermEditorE4 termEditor = (DefinedTermEditorE4) activePart.getObject();
-
+ if(termEditor.checkDirty()){
+ return;
+ }
String label = menuItem.getLocalizedLabel();
IUndoContext undoContext = StoreUtil.getUndoContext();
*/
package eu.etaxonomy.taxeditor.editor.definedterm.e4.handler;
+import java.util.UUID;
+
import javax.inject.Named;
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.e4.ui.model.application.ui.menu.MHandledMenuItem;
import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;
import org.eclipse.e4.ui.services.IServiceConstants;
-import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.IStructuredSelection;
-import eu.etaxonomy.cdm.model.common.DefinedTermBase;
-import eu.etaxonomy.cdm.model.common.TermBase;
-import eu.etaxonomy.cdm.model.common.TermVocabulary;
+import eu.etaxonomy.cdm.persistence.dto.AbstractTermDto;
+import eu.etaxonomy.cdm.persistence.dto.TermDto;
+import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
import eu.etaxonomy.taxeditor.editor.definedterm.e4.DefinedTermEditorE4;
import eu.etaxonomy.taxeditor.editor.definedterm.operation.DeleteTermBaseOperation;
import eu.etaxonomy.taxeditor.model.AbstractUtility;
public void execute(@Named(IServiceConstants.ACTIVE_PART) MPart activePart,
@Named(IServiceConstants.ACTIVE_SELECTION) IStructuredSelection selection, MMenuItem menuItem,
UISynchronize sync) {
-
DefinedTermEditorE4 termEditor = (DefinedTermEditorE4) activePart.getObject();
-
- if (termEditor.isDirty()){
- boolean proceed = MessageDialog.openQuestion(null,
- "Save changes", "You have made changes that must be saved before this query can be executed. Would you like to proceed?");
- if (proceed) {
- termEditor.save(null);
- } else {
- return;
- }
+ if(termEditor.checkDirty()){
+ return;
}
String label = menuItem.getLocalizedLabel();
IUndoContext undoContext = StoreUtil.getUndoContext();
AbstractPostOperation operation =
new DeleteTermBaseOperation(label,
undoContext,
- (TermBase) selection.getFirstElement(),
+ (AbstractTermDto) selection.getFirstElement(),
termEditor.getDefinedTermEditorInput(),
termEditor);
AbstractUtility.executeOperation(operation, sync);
boolean canExecute = false;
Object firstElement = selection.getFirstElement();
canExecute = selection.size()==1
- &&
- (firstElement instanceof DefinedTermBase
- || firstElement instanceof TermVocabulary);
- TermVocabulary vocabulary = null;
- if(firstElement instanceof DefinedTermBase){
- vocabulary = ((DefinedTermBase) firstElement).getVocabulary();
- }else if(firstElement instanceof TermVocabulary){
- vocabulary = (TermVocabulary) firstElement;
+ && (firstElement instanceof AbstractTermDto);
+ UUID vocabularyUuid = null;
+ if(firstElement instanceof TermDto){
+ vocabularyUuid = ((TermDto) firstElement).getVocabularyUuid();
+ }else if(firstElement instanceof TermVocabularyDto){
+ vocabularyUuid = ((TermVocabularyDto) firstElement).getUuid();
}
- canExecute &= vocabulary!=null;
+ canExecute &= vocabularyUuid!=null;
menuItem.setVisible(canExecute);
return canExecute;
}
import eu.etaxonomy.cdm.api.service.IVocabularyService;
import eu.etaxonomy.cdm.model.common.DefinedTerm;
-import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.TermType;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.description.FeatureTree;
+import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
import eu.etaxonomy.taxeditor.store.CdmStore;
import eu.etaxonomy.taxeditor.store.TermStore;
public class TermEditorInput extends AbstractDefinedTermEditorInput<DefinedTerm> {
private TermType termType;
- private Set<TermVocabulary<DefinedTermBase>> vocabularies;
+ private Set<TermVocabularyDto> vocabularies;
// FIXME: the default feature should be move to CdmApplicationState
// where it is a singleton instance variable
public TermEditorInput(TermType termType) {
this.termType = termType;
- vocabularies = new HashSet<TermVocabulary<DefinedTermBase>>();
+ vocabularies = new HashSet<TermVocabularyDto>();
initialiseVocabularies();
}
public String getName() {
if(vocabularies != null) {
vocabularies.clear();
}
- List<TermVocabulary<DefinedTermBase>> vocs = CdmStore.getService(IVocabularyService.class).findByTermType(termType,
- Arrays.asList("terms", "terms.level"));
+ List<TermVocabularyDto> vocs = CdmStore.getService(IVocabularyService.class).findVocabularyDtoByTermType(termType);
vocabularies.addAll(vocs);
}
- public Set<TermVocabulary<DefinedTermBase>> getVocabularies() {
+ public Set<TermVocabularyDto> getVocabularies() {
return vocabularies;
}
public void updateDefaultFeatureTree() {
- for(TermVocabulary vocab : getVocabularies()) {
+ for(TermVocabularyDto vocab : getVocabularies()) {
if(vocab != null && TermType.Feature.equals(vocab.getTermType())) {
defaultFeatureTree = null;
return;
}
@Override
- public Set<TermVocabulary<DefinedTermBase>> getRootEntities() {
+ public Set<TermVocabularyDto> getRootEntities() {
return getVocabularies();
}
@Override
public void merge() {
- CdmStore.getService(IVocabularyService.class).merge(new ArrayList<TermVocabulary>(getRootEntities()), true);
+ List<TermVocabulary> vocabularies = new ArrayList<>();
+ getRootEntities().forEach(vocDto->vocabularies.add(CdmStore.getService(IVocabularyService.class).load(vocDto.getUuid())));
+ CdmStore.getService(IVocabularyService.class).merge(vocabularies, true);
updateDefaultFeatureTree();
}
import org.eclipse.core.runtime.IAdaptable;\r
import org.eclipse.core.runtime.IProgressMonitor;\r
import org.eclipse.core.runtime.IStatus;\r
-import org.eclipse.core.runtime.Status;\r
\r
-import eu.etaxonomy.cdm.model.common.DefinedTermBase;\r
-import eu.etaxonomy.cdm.model.common.TermBase;\r
-import eu.etaxonomy.cdm.model.common.TermVocabulary;\r
+import eu.etaxonomy.cdm.api.service.ITermService;\r
+import eu.etaxonomy.cdm.api.service.IVocabularyService;\r
+import eu.etaxonomy.cdm.persistence.dto.AbstractTermDto;\r
+import eu.etaxonomy.cdm.persistence.dto.TermDto;\r
+import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;\r
import eu.etaxonomy.taxeditor.editor.definedterm.input.TermEditorInput;\r
-import eu.etaxonomy.taxeditor.model.MessagingUtils;\r
-import eu.etaxonomy.taxeditor.operation.AbstractPostTaxonOperation;\r
+import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;\r
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;\r
import eu.etaxonomy.taxeditor.store.CdmStore;\r
-import eu.etaxonomy.taxeditor.store.StoreUtil;\r
\r
/**\r
* @author l.morris\r
* @date 21 Dec 2011\r
*\r
*/\r
-public class CreateDefinedTermOperation extends AbstractPostTaxonOperation {\r
+public class CreateDefinedTermOperation extends AbstractPostOperation {\r
\r
-\r
-\r
- private final TermBase parentTermBase;\r
+ private final AbstractTermDto parent;\r
private final TermEditorInput definedTermInput;\r
private boolean addTermAsKindOf;\r
\r
\r
- /**\r
- * @param label\r
- * @param undoContext\r
- * @param postOperationEnabled\r
- * @param addTermAsKindOf\r
- */\r
public CreateDefinedTermOperation(String label,\r
IUndoContext undoContext,\r
- TermBase termBase,\r
+ AbstractTermDto parent,\r
TermEditorInput definedTermInput,\r
IPostOperationEnabled postOperationEnabled, boolean addTermAsKindOf) {\r
- super(label, undoContext, postOperationEnabled);\r
- this.parentTermBase = termBase;\r
+ super(label, undoContext, null, postOperationEnabled);\r
+ this.parent = parent;\r
this.definedTermInput = definedTermInput;\r
this.addTermAsKindOf = addTermAsKindOf;\r
}\r
\r
- /* (non-Javadoc)\r
- * @see org.eclipse.core.commands.operations.AbstractOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)\r
- */\r
@Override\r
public IStatus execute(IProgressMonitor monitor, IAdaptable info)\r
throws ExecutionException {\r
-\r
- DefinedTermBase newTerm = definedTermInput.getTermType().getEmptyDefinedTermBase();\r
- if (newTerm == null) {\r
- IStatus status =\r
- new Status(IStatus.CANCEL,\r
- StoreUtil.getPluginId(),\r
- "Creation of term corresponding to type '" + definedTermInput.getTermType().getMessage() + "' is not yet supported");\r
- MessagingUtils.warningDialog("Cannot create term", newTerm, status);\r
- return status;\r
- }\r
- newTerm = CdmStore.getCurrentApplicationConfiguration().getTermService().save(newTerm);\r
-\r
- if (parentTermBase instanceof TermVocabulary){\r
- TermVocabulary vocabulary = (TermVocabulary) parentTermBase;\r
- vocabulary.addTerm(newTerm);\r
- } else if (parentTermBase instanceof DefinedTermBase) {\r
- DefinedTermBase parent = (DefinedTermBase) parentTermBase;\r
- if(addTermAsKindOf){\r
- parent.addGeneralizationOf(newTerm);\r
- }\r
- else{\r
- parent.addIncludes(newTerm);\r
- }\r
- TermVocabulary vocabulary = parent.getVocabulary();\r
- vocabulary.addTerm(newTerm);\r
- }\r
-\r
- return postExecute(newTerm);\r
+ if(parent instanceof TermDto){\r
+ CdmStore.getService(ITermService.class).addNewTerm(definedTermInput.getTermType(), parent.getUuid(), addTermAsKindOf);\r
+ }\r
+ else if(parent instanceof TermVocabularyDto){\r
+ CdmStore.getService(IVocabularyService.class).addNewTerm(definedTermInput.getTermType(), parent.getUuid());\r
+ }\r
+ return postExecute(parent);\r
}\r
\r
- /* (non-Javadoc)\r
- * @see org.eclipse.core.commands.operations.AbstractOperation#redo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)\r
- */\r
@Override\r
public IStatus redo(IProgressMonitor monitor, IAdaptable info)\r
throws ExecutionException {\r
- // TODO Auto-generated method stub\r
return null;\r
}\r
\r
- /* (non-Javadoc)\r
- * @see org.eclipse.core.commands.operations.AbstractOperation#undo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)\r
- */\r
@Override\r
public IStatus undo(IProgressMonitor monitor, IAdaptable info)\r
throws ExecutionException {\r
- // TODO Auto-generated method stub\r
return null;\r
}\r
\r
}\r
\r
termVocabulary = CdmStore.getService(IVocabularyService.class).save(termVocabulary);\r
- definedEditorInput.getVocabularies().add(termVocabulary);\r
+ //FIXME: implement creation of term vocabularies\r
+// definedEditorInput.getVocabularies().add(termVocabulary);\r
\r
return postExecute(termVocabulary);\r
}\r
import eu.etaxonomy.cdm.api.service.DeleteResult;\r
import eu.etaxonomy.cdm.api.service.ITermService;\r
import eu.etaxonomy.cdm.api.service.IVocabularyService;\r
-import eu.etaxonomy.cdm.model.common.DefinedTermBase;\r
-import eu.etaxonomy.cdm.model.common.TermBase;\r
-import eu.etaxonomy.cdm.model.common.TermVocabulary;\r
+import eu.etaxonomy.cdm.persistence.dto.AbstractTermDto;\r
+import eu.etaxonomy.cdm.persistence.dto.TermDto;\r
+import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;\r
import eu.etaxonomy.taxeditor.editor.definedterm.input.TermEditorInput;\r
import eu.etaxonomy.taxeditor.l10n.Messages;\r
import eu.etaxonomy.taxeditor.model.MessagingUtils;\r
public class DeleteTermBaseOperation extends AbstractPostTaxonOperation {\r
\r
private final TermEditorInput definedEditorInput;\r
- private final TermBase termBase;\r
+ private final AbstractTermDto termBase;\r
\r
public DeleteTermBaseOperation(String label,\r
IUndoContext undoContext,\r
- TermBase termBase,\r
+ AbstractTermDto termBase,\r
TermEditorInput definedEditorInput,\r
IPostOperationEnabled postOperationEnabled) {\r
super(label, undoContext, postOperationEnabled);\r
@Override\r
public IStatus execute(IProgressMonitor monitor, IAdaptable info)\r
throws ExecutionException {\r
- if (termBase instanceof TermVocabulary) {\r
- if (((TermVocabulary)termBase).getCreatedBy() == null) {\r
- IStatus status = new Status(IStatus.CANCEL, StoreUtil.getPluginId(), Messages.DeleteTermBaseOperation_SYSTEM_VOC);\r
- MessagingUtils.warningDialog(Messages.DeleteTermBaseOperation_CANNOT_DELETE_VOC, termBase, status);\r
- return status;\r
- }\r
-\r
- if (!((TermVocabulary)termBase).getTerms().isEmpty()) {\r
- IStatus status = new Status(IStatus.CANCEL, StoreUtil.getPluginId(), Messages.DeleteTermBaseOperation_DELETE_ALL_TERMS_BEFORE);\r
- MessagingUtils.warningDialog(Messages.DeleteTermBaseOperation_VOC_NOT_EMPTY, termBase, status);\r
- return status;\r
- }\r
-\r
+ if (termBase instanceof TermVocabularyDto) {\r
definedEditorInput.getVocabularies().remove(termBase);\r
\r
DeleteResult result = CdmStore.getService(IVocabularyService.class).delete(termBase.getUuid());\r
return showErrorMessage(result);\r
}\r
\r
- } else if (termBase instanceof DefinedTermBase) {\r
-\r
-\r
- DefinedTermBase definedTermBase = (DefinedTermBase) termBase;\r
-\r
- if (((DefinedTermBase)termBase).getCreatedBy() == null) {\r
- IStatus status = new Status(IStatus.CANCEL, StoreUtil.getPluginId(), Messages.DeleteTermBaseOperation_SYSTEM_TERM);\r
- MessagingUtils.warningDialog(Messages.DeleteTermBaseOperation_CANNOT_DELETE_TERM, termBase, status);\r
- return status;\r
- }\r
- if(!definedTermBase.getIncludes().isEmpty()){\r
- IStatus status = new Status(IStatus.CANCEL, StoreUtil.getPluginId(), Messages.DeleteTermBaseOperation_TERM_INCLUDES_OTHERS);\r
- MessagingUtils.warningDialog(Messages.DeleteTermBaseOperation_TERM_INLCUDES, termBase, status);\r
- return status;\r
- }\r
-\r
+ } else if (termBase instanceof TermDto) {\r
DeleteResult result = CdmStore.getService(ITermService.class).delete(termBase.getUuid());\r
if (!result.isOk()){\r
return showErrorMessage(result);\r
}\r
}\r
-\r
return postExecute(termBase);\r
}\r
\r
package eu.etaxonomy.taxeditor.editor.definedterm.operation;\r
\r
import java.util.Collection;\r
+import java.util.UUID;\r
\r
import org.eclipse.core.commands.ExecutionException;\r
import org.eclipse.core.commands.operations.IUndoContext;\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.core.runtime.Status;\r
import org.eclipse.jface.viewers.ViewerDropAdapter;\r
\r
-import eu.etaxonomy.cdm.model.common.DefinedTermBase;\r
-import eu.etaxonomy.cdm.model.common.OrderedTermBase;\r
-import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary;\r
-import eu.etaxonomy.cdm.model.common.TermBase;\r
-import eu.etaxonomy.cdm.model.common.TermVocabulary;\r
-import eu.etaxonomy.taxeditor.model.MessagingUtils;\r
+import eu.etaxonomy.cdm.api.service.ITermService;\r
+import eu.etaxonomy.cdm.api.service.TermServiceImpl.TermMovePosition;\r
+import eu.etaxonomy.cdm.persistence.dto.AbstractTermDto;\r
+import eu.etaxonomy.cdm.persistence.dto.TermDto;\r
import eu.etaxonomy.taxeditor.operation.AbstractPostTaxonOperation;\r
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;\r
-import eu.etaxonomy.taxeditor.store.StoreUtil;\r
+import eu.etaxonomy.taxeditor.store.CdmStore;\r
\r
/**\r
* @author l.morris\r
*/\r
public class MoveDefinedTermOperation extends AbstractPostTaxonOperation {\r
\r
- private final Collection<DefinedTermBase> sourceTerms;// the actual DefinedTermBase(s) we are moving\r
- private final TermBase targetTermOrVocabulary;// the target VOCABULARY or DefinedTerm we are moving these to\r
+ private final Collection<TermDto> sourceTerms;// the actual DefinedTermBase(s) we are moving\r
+ private final AbstractTermDto targetTermOrVocabulary;// the target VOCABULARY or DefinedTerm we are moving these to\r
private final int currentLocation;\r
\r
public MoveDefinedTermOperation(String label,\r
IUndoContext undoContext,\r
- TermBase target,\r
- Collection<DefinedTermBase> sourceTerms,\r
+ AbstractTermDto target,\r
+ Collection<TermDto> sourceTerms,\r
IPostOperationEnabled postOperationEnabled,\r
int currentLocation) {\r
super(label, undoContext, postOperationEnabled);\r
@Override\r
public IStatus execute(IProgressMonitor monitor, IAdaptable info)\r
throws ExecutionException {\r
-\r
- // need to make the moved DefinedTerm part of another DefinedTerm or Vocabulary (target)\r
- // and remove it from old associations\r
-\r
- //TODO move to ITermService\r
-\r
- for (DefinedTermBase term : sourceTerms) {\r
- // do nothing when moving it on itself\r
- if(targetTermOrVocabulary.equals(term)){\r
- Status status = new Status(IStatus.CANCEL, StoreUtil.getPluginId(), "Term can not be added to itself");\r
- MessagingUtils.informationDialog("", status);\r
- return status;\r
- }\r
-\r
- if (targetTermOrVocabulary instanceof TermVocabulary) {\r
- TermVocabulary termVocabulary = (TermVocabulary)targetTermOrVocabulary;\r
-\r
- // do nothing when term is top level and gets added to the same vocabulary\r
- if(term.getPartOf() == null && termVocabulary.equals(term.getVocabulary())){\r
- Status status = new Status(IStatus.CANCEL, StoreUtil.getPluginId(), "Term is already in this vocabulary");\r
- MessagingUtils.informationDialog("", status);\r
- return status;\r
- }\r
-\r
- cleanTerm(term);\r
- termVocabulary.addTerm(term);\r
-\r
- } else if (targetTermOrVocabulary instanceof DefinedTermBase) {\r
- cleanTerm(term);\r
- DefinedTermBase targetDefinedTerm = (DefinedTermBase) targetTermOrVocabulary;\r
-\r
- if(targetDefinedTerm instanceof OrderedTermBase && term instanceof OrderedTermBase) {\r
- OrderedTermBase targetOrderedDefinedTerm = (OrderedTermBase)targetDefinedTerm;\r
- TermVocabulary tVoc = targetOrderedDefinedTerm.getVocabulary();\r
- if(tVoc instanceof OrderedTermVocabulary) {\r
- OrderedTermVocabulary otVoc = (OrderedTermVocabulary)tVoc;\r
- // the link between the location and the add term (below / above)\r
- // method is determined by the compare method in the\r
- // DefinedTermEditor's ViewerSorter (DefinedTermSorter) class\r
- if(currentLocation == ViewerDropAdapter.LOCATION_BEFORE) {\r
- otVoc.addTermAbove((OrderedTermBase)term, (OrderedTermBase)targetTermOrVocabulary);\r
- if (targetOrderedDefinedTerm.getPartOf() != null){\r
- targetOrderedDefinedTerm.getPartOf().addIncludes(term);\r
- }\r
- }\r
-\r
- if(currentLocation == ViewerDropAdapter.LOCATION_AFTER) {\r
- otVoc.addTermBelow((OrderedTermBase)term, (OrderedTermBase)targetTermOrVocabulary);\r
- if (targetOrderedDefinedTerm.getPartOf() != null){\r
- targetOrderedDefinedTerm.getPartOf().addIncludes(term);\r
- }\r
- }\r
- if(currentLocation == ViewerDropAdapter.LOCATION_ON) {\r
- targetOrderedDefinedTerm.addIncludes(term);\r
- targetOrderedDefinedTerm.getVocabulary().addTerm(term);\r
- }\r
- }\r
- } else{\r
- targetDefinedTerm.addIncludes(term);\r
- targetDefinedTerm.getVocabulary().addTerm(term);\r
- }\r
-\r
- }\r
-\r
- }\r
+ sourceTerms.forEach(term->\r
+ {\r
+ UUID parentUuid = targetTermOrVocabulary.getUuid();\r
+ TermMovePosition termMovePosition = TermMovePosition.ON;\r
+ if(currentLocation == ViewerDropAdapter.LOCATION_BEFORE) {\r
+ termMovePosition = TermMovePosition.BEFORE;\r
+ }\r
+ else if(currentLocation == ViewerDropAdapter.LOCATION_AFTER) {\r
+ termMovePosition = TermMovePosition.AFTER;\r
+ }\r
+ CdmStore.getService(ITermService.class).moveTerm(term, parentUuid, termMovePosition);\r
+ });\r
return postExecute(targetTermOrVocabulary);\r
}\r
\r
- private DefinedTermBase cleanTerm(DefinedTermBase term){\r
-\r
- DefinedTermBase partOf = term.getPartOf();\r
- if(partOf != null){\r
- partOf.removeIncludes(term);\r
- }\r
- DefinedTermBase kindOf = term.getKindOf();\r
- if(kindOf!=null){\r
- kindOf.removeGeneralization(term);\r
- }\r
-\r
-\r
- TermVocabulary vocabulary = term.getVocabulary();\r
- if(vocabulary != null){\r
- vocabulary.removeTerm(term);\r
- }\r
-\r
- return term;\r
- }\r
-\r
@Override\r
public IStatus redo(IProgressMonitor monitor, IAdaptable info)\r
throws ExecutionException {\r
viewer.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
- viewer.setSorter(new DefinedTermSorter());
+ viewer.setComparator(new DefinedTermSorter());
viewer.setContentProvider(new TermContentProvider());
viewer.setLabelProvider(new TermLabelProvider());
import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
-import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.description.FeatureNode;
import eu.etaxonomy.cdm.model.description.FeatureTree;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
* {@inheritDoc}
*/
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ public boolean postOperation(Object objectAffectedByOperation) {
return false;
}
public static String ConfiguratorComposite_CONFIGURE;
- public static String DefinedTermMenu_FEATURE_TREE;
+ public static String DefinedTermEditorE4_SAVE_MESSAGE;
+
+
+ public static String DefinedTermEditorE4_SAVE_TITLE;
+
+
+ public static String DefinedTermMenu_FEATURE_TREE;
public static String DefinedTermMenu_MENU;
SearchManager_LONG_SEARCH_WARNING=The current search will return %s objects. This will take a long time and/or might render the editor unusable. Please consider refining your search.\nSearch anyway?
SupplementalDataViewPart_VIEWER_NAME=Supplemental Data
+DefinedTermEditorE4_SAVE_MESSAGE=You have made changes that must be saved before this query can be executed. Would you like to save?
+DefinedTermEditorE4_SAVE_TITLE=Save changes
DefinedTermMenu_FEATURE_TREE=Feature Tree
DefinedTermMenu_MENU=Menu
DefinedTermMenu_OTHER_S=Other %ss
SearchManager_LONG_SEARCH_WARNING=Die aktuelle Suche wird %s Objekte laden. Dies kann einige Zeit dauern und den Editor währenddessen unbedienbar machen. Bitte erstellen sie eine detailliertere Suche.\nTrotzdem suchen?
SupplementalDataViewPart_VIEWER_NAME=Zusatzdaten
+DefinedTermEditorE4_SAVE_MESSAGE=Sie haben Änderungen, die gespeichert werden müssen, bevor die Operation ausgeführt werden kann. Möchten Sie speichern?
+DefinedTermEditorE4_SAVE_TITLE=Änderungen speichern
DefinedTermMenu_FEATURE_TREE=Merkmalsbaum
DefinedTermMenu_MENU=Menü
DefinedTermMenu_OTHER_S=Weitere %ss
import org.eclipse.core.runtime.IStatus;
import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
-import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.persistence.dto.TaxonNodeDto;
import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
*/
/** {@inheritDoc} */
@Override
- protected IStatus postExecute(CdmBase objectAffectedByOperation) {
+ protected IStatus postExecute(Object objectAffectedByOperation) {
Assert.isNotNull(conversationEnabled, "Operation has to have a valid conversation attached.");
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
-import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.common.ICdmBase;
import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
* @param objectAffectedByOperation the affected object. Should be <code>null</code> if not needed
* @return a {@link org.eclipse.core.runtime.IStatus} object.
*/
- protected IStatus postExecute(CdmBase objectAffectedByOperation) {
+ protected IStatus postExecute(Object objectAffectedByOperation) {
if(postOperationEnabled != null){
return postOperationEnabled.postOperation(objectAffectedByOperation) ? Status.OK_STATUS : Status.CANCEL_STATUS;
/**
* 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.model.common.CdmBase;
-
/**
* Implementors may register to operations. The postOperation method will get
* called after any post operation
- *
+ *
* @author n.hoffmann
* @created 24.03.2009
* @version 1.0
* created a new object and the {@link IPostOperationEnabled} has to know
* about the object it should be passed to the {@link IPostOperationEnabled}
* </p>
- *
+ *
* @param objectAffectedByOperation
* a newly created object for example. May be <code>null</code>
* @return true if the method executed successfully. Returning false will
* set the operations status to {@link Status.CANCEL_STATUS} which
* might not be what you want.
*/
- public boolean postOperation(CdmBase objectAffectedByOperation);
-
+ public boolean postOperation(Object 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();
-
+
}
*/
public class AreaLabelProvider extends TermLabelProvider implements ILabelProvider{
+ public AreaLabelProvider(){
+ super();
+ }
+
public AreaLabelProvider(Styler vocStyler){
super(vocStyler);
}
import org.eclipse.jface.viewers.CheckboxTreeViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ITreeViewerListener;
-import org.eclipse.jface.viewers.StyledString.Styler;
import org.eclipse.jface.viewers.TreeExpansionEvent;
import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.TextStyle;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Display;
import eu.etaxonomy.cdm.api.service.IVocabularyService;
import eu.etaxonomy.cdm.model.common.CdmBase;
setViewer(new CheckboxTreeViewer(composite, SWT.NULL));
((CheckboxTreeViewer)getViewer()).getTree().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
getViewer().setContentProvider(new DistributionContentProvider());
- Styler styler = new Styler() {
- @Override
- public void applyStyles(TextStyle textStyle) {
- textStyle.foreground = Display.getCurrent().getSystemColor(SWT.COLOR_BLACK);
- }
- };
- getViewer().setLabelProvider(new AreaLabelProvider(styler));
+ getViewer().setLabelProvider(new AreaLabelProvider());
getViewer().setComparator(new AreaViewerComparator());
((CheckboxTreeViewer)getViewer()).addCheckStateListener(new ICheckStateListener() {
import org.eclipse.jface.viewers.CheckboxTreeViewer;
import org.eclipse.jface.viewers.ColumnViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
-import org.eclipse.jface.viewers.StyledString.Styler;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.TextStyle;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Display;
import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
setViewer(new CheckboxTreeViewer(composite, SWT.NULL));
((CheckboxTreeViewer)getViewer()).getTree().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
// viewer.setContentProvider(new TermContentProvider());
- Styler styler = new Styler() {
- @Override
- public void applyStyles(TextStyle textStyle) {
- textStyle.foreground = Display.getCurrent().getSystemColor(SWT.COLOR_BLACK);
- }
- };
getViewer().setContentProvider(new TermContentProvider());
- getViewer().setLabelProvider(new TermLabelProvider(styler));
+ getViewer().setLabelProvider(new TermLabelProvider());
getViewer().setComparator(new ViewerComparator());
((CheckboxTreeViewer)getViewer()).addCheckStateListener(new ICheckStateListener() {
--- /dev/null
+/**
+ * Copyright (C) 2018 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.preference.wizard;
+
+import org.eclipse.jface.viewers.AbstractTreeViewer;
+import org.eclipse.jface.viewers.CheckboxTreeViewer;
+import org.eclipse.jface.viewers.IBaseLabelProvider;
+import org.eclipse.jface.viewers.ITreeContentProvider;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Tree;
+import org.eclipse.swt.widgets.TreeItem;
+
+/**
+ * @author pplitzner
+ * @since Oct 26, 2018
+ *
+ */
+public class CheckBoxTreeComposite extends Composite {
+
+ private CheckboxTreeViewer viewer;
+
+ public CheckBoxTreeComposite(Composite parent, ITreeContentProvider contentProvider, IBaseLabelProvider labelProvider, int style) {
+ super(parent, style);
+ Composite composite = new Composite(parent, SWT.NULL);
+ composite.setLayout(new GridLayout());
+ Tree tree = new Tree(parent, SWT.BORDER | SWT.CHECK);
+ tree.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+ tree.addListener(SWT.Selection, event -> {
+ if (event.detail == SWT.CHECK) {
+ TreeItem item = (TreeItem) event.item;
+ Object data = item.getData();
+ boolean checked = item.getChecked();
+ if(checked){
+ viewer.expandToLevel(data, AbstractTreeViewer.ALL_LEVELS);
+ }
+ checkItems(item, checked);
+ checkPath(item.getParentItem(), checked, false);
+ }
+ });
+ viewer = new CheckboxTreeViewer(tree);
+ viewer.setContentProvider(contentProvider);
+ viewer.setLabelProvider(labelProvider);
+ }
+
+ private void checkPath(TreeItem item, boolean checked, boolean grayed) {
+ if (item == null) {
+ return;
+ }
+ if (grayed) {
+ checked = true;
+ } else {
+ int index = 0;
+ TreeItem[] items = item.getItems();
+ while (index < items.length) {
+ TreeItem child = items[index];
+ if (child.getGrayed() || checked != child.getChecked()) {
+ checked = grayed = true;
+ break;
+ }
+ index++;
+ }
+ }
+ item.setChecked(checked);
+ item.setGrayed(grayed);
+ checkPath(item.getParentItem(), checked, grayed);
+ }
+
+ private void checkItems(TreeItem item, boolean checked) {
+ item.setGrayed(false);
+ item.setChecked(checked);
+ TreeItem[] items = item.getItems();
+ for (int i = 0; i < items.length; i++) {
+ checkItems(items[i], checked);
+ }
+ }
+
+ public CheckboxTreeViewer getViewer() {
+ return viewer;
+ }
+
+ /**
+ * Checks the tree items corresponding to the given elements.<br>
+ * <br>
+ * <b>Note:</b> In order to fully reveal the checked elements they
+ * have to be sorted according to the tree hierarchy.
+ * @param elements
+ */
+ public void setCheckedElements(Object[] elements) {
+ for (Object object : elements) {
+ viewer.reveal(object);
+ viewer.setChecked(object, true);
+ }
+ }
+
+}
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.api.service.IVocabularyService;
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
-import eu.etaxonomy.cdm.model.common.CdmBase;
-import eu.etaxonomy.cdm.model.description.Distribution;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
+import eu.etaxonomy.cdm.persistence.dto.TermDto;
+import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
-import eu.etaxonomy.taxeditor.editor.IDistributionEditor;
import eu.etaxonomy.taxeditor.editor.ITaxonEditor;
import eu.etaxonomy.taxeditor.model.IDirtyMarkable;
import eu.etaxonomy.taxeditor.model.MessagingUtils;
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
+import eu.etaxonomy.taxeditor.store.CdmStore;
import eu.etaxonomy.taxeditor.view.e4.details.DetailsViewerE4;
import eu.etaxonomy.taxeditor.workbench.WorkbenchUtility;
import eu.etaxonomy.taxeditor.workbench.part.ISelectionElementEditingPart;
}
}
- if (element instanceof Distribution && part instanceof IDistributionEditor && viewer instanceof DetailsViewerE4){
-
+ //unwrap term DTOs
+ if(element instanceof TermDto){
+ element = CdmStore.getService(ITermService.class).load(((TermDto) element).getUuid());
+ }
+ else if(element instanceof TermVocabularyDto){
+ element = CdmStore.getService(IVocabularyService.class).load(((TermVocabularyDto) element).getUuid());
+ }
+ if (viewer instanceof DetailsViewerE4){
((DetailsViewerE4)viewer).setInput(element, part);
- }else{
+ ((DetailsViewerE4)viewer).setDetailsEnabled(true);
+ }
+ else{
viewer.setInput(element);
- if (viewer instanceof DetailsViewerE4){
- ((DetailsViewerE4)viewer).setDetailsEnabled(true);
- }
}
selectionProvidingPart = activePart;
}
* {@inheritDoc}
*/
@Override
- public boolean postOperation(CdmBase objectAffectedByOperation) {
+ public boolean postOperation(Object objectAffectedByOperation) {
changed(objectAffectedByOperation);
return true;
}
/**
*
* The DetailsViewer handles the content of the details view (
- * {@link DetailsViewerE4}).<br>
+ * {@link DetailsPartE4}).<br>
* Depending on the type of the selected element the section of the details view
* are created.
*
BGBM BDI Projects / taxeditor.git / commitdiff