*/
private static final String CHECKLIST_EDITOR_MEMENTO_KEY = "checklistEditor";
+
+
+
private class ChecklistJob extends Job {
private List<TaxonNode> taxonNodes;
super(title);
this.taxonNodes = listTaxonNodes;
+
}
/*
private final ICdmEntitySession cdmEntitySession;
+ private ChecklistLabelProvider labelProvider;
+
private SortedSet<DefinedTermBase> terms = null;
private ToolItem toolItem;
private ChecklistDropdownSelectionListener dropListener;
*/
public ChecklistEditor() {
cdmEntitySession = CdmStore.getCurrentSessionManager().newSession(this, true);
+
}
/** {@inheritDoc} */
taxonNodeService = CdmStore.getService(ITaxonNodeService.class);
selectionService = getSite().getWorkbenchWindow().getSelectionService();
selectionService.addSelectionListener(this);
+ viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION);
+ labelProvider = new ChecklistLabelProvider(this.viewer);
+ terms = labelProvider.getNamedAreas();
filter = new ChecklistEditorFilter();
- ChecklistLabelProvider labelProvider = new ChecklistLabelProvider();
- terms = (SortedSet<DefinedTermBase>) labelProvider.getTermsOrderedByLabels(labelProvider.getNamedAreas(),
- CdmStore.getDefaultLanguage());
createTopComposite(parent);
loadDataInput();
}
final Text searchText = createSearchBar(parent);
createToolbar(parent);
- viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION);
+
getSite().setSelectionProvider(viewer);
final ModifyListener modifyListener = new ChecklistModifyListener(viewer, filter, searchText);
createTable();
viewer.setContentProvider(new ChecklistContentProvider());
- viewer.setLabelProvider(new ChecklistLabelProvider(viewer));
+ viewer.setLabelProvider(this.labelProvider);
comparator = new ChecklistEditorComparator();
viewer.setComparator(comparator);
column.getColumn().setResizable(true);
column.getColumn().setMoveable(true);
column.getColumn().addSelectionListener(getSelectionAdapter(column.getColumn(), columnIndex));
- if (columnIndex == 1) {
+ if (columnIndex == 0) {
table.setSortColumn(column.getColumn());
}
if (columnIndex == 2) {
/** uncommented it for now because no rank editing is wanted **/
// column.setEditingSupport(new RankEditingSupport(viewer, this));
}
- if (columnIndex >= 4) {
+ if (columnIndex >= 3) {
//read PrefrenceStore to setWidth according to last saved state
if(restoreValuesForColumnWidth.get(columnIndex)){
column.getColumn().setWidth(100);
}else{
- column.getColumn().setWidth(0);
+ column.getColumn().setWidth(100);
}
column.setEditingSupport(new DistributionEditingSupport(viewer, this, columnIndex));
}
List<Integer> bounds) {
Map<Integer, Boolean> restoreColumnWidth = new HashMap<Integer, Boolean>();
if (terms != null) {
- int columnIndex = 4;
+ int columnIndex = 3;
for (DefinedTermBase<DefinedTermBase> term : terms) {
if(term != null){
restoreColumnWidth.put(columnIndex, PreferencesUtil.getPreferenceStore().getBoolean(term.getUuid().toString()));
- titles.add(term.getTitleCache());
+ if (PreferencesUtil.isShowIdInVocabularyInChecklistEditor()){
+ if (term.getIdInVocabulary() != null){
+ titles.add(term.getIdInVocabulary());
+ } else{
+ titles.add(term.getTitleCache());
+ }
+ }else{
+ titles.add(term.getTitleCache());
+ }
bounds.add(200);
columnIndex++;
}
TaxonNode taxonNode = checklistEditorInput.getTaxonNode();
if (classification != null && taxonNode == null) {
countNodes = taxonNodeService.countAllNodesForClassification(classification);
- statusLabel.setText("Anzahl der Elemente: " + (countNodes != null ? countNodes : "uknown"));
+ statusLabel.setText("Anzahl der Elemente: " + (countNodes != null ? countNodes : "unknown"));
// This should not kill the view nor the editor if something goes
// wrong
// TODO: don't load the whole taxonNode Object but rather a small
Table table = viewer.getTable();
table.setRedraw(false);
SortedSet<DefinedTermBase> oldTerms = terms;
- ChecklistLabelProvider labelProvider = new ChecklistLabelProvider();
- terms = (SortedSet<DefinedTermBase>) labelProvider.getTermsOrderedByLabels(labelProvider.getNamedAreas(), CdmStore.getDefaultLanguage());
- SortedSet<DefinedTermBase> newTerms = terms;
+
+// if (PreferencesUtil.isShowIdInVocabularyInChecklistEditor()){
+//
+// } else{
+// terms = (SortedSet<DefinedTermBase>) labelProvider.getTermsOrderedByLabels(labelProvider.getNamedAreas(), CdmStore.getDefaultLanguage());
+// }
+ SortedSet<DefinedTermBase> newTerms = labelProvider.getNamedAreas();
toolItem.removeSelectionListener(dropListener);
hideDistributionColumns(oldTerms);
createToolbarItems();
addTableViewerColumn(term.getTitleCache(), 200, count);
acitivateNewColumnInDropDownMenu(term);
}
- viewer.setLabelProvider(new ChecklistLabelProvider(viewer));
+ viewer.setLabelProvider(labelProvider);
getService().schedule(new ChecklistJob("loading Taxa", selectedTaxonNodes), Job.LONG);
table.setRedraw(true);
viewer.refresh();
// TODO Auto-generated method stub
return null;
}
+
+ /**
+ * @return the labelProvider
+ */
+ public ChecklistLabelProvider getLabelProvider() {
+ return labelProvider;
+ }
}
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.HashSet;
import java.util.List;
+import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.UUID;
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.Language;
+import eu.etaxonomy.cdm.model.common.TermIdInVocabularyComparator;
import eu.etaxonomy.cdm.model.common.TermLanguageComparator;
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
import eu.etaxonomy.cdm.model.description.Distribution;
public static final String DEFAULT_ENTRY = "";
private IDescriptionService descriptionService;
- private final List<DefinedTermBase<?>> namedAreas;
+ private final SortedSet<DefinedTermBase> namedAreas;
TableViewer viewer = null;
/**
//TODO load areas by this list
List<TaxonDescription> listTaxonDescriptions = descriptionService.listTaxonDescriptions(taxon, null, null, null, null, null, DESC_INIT_STRATEGY);;
- NonViralName<?> nonVirlaName = HibernateProxyHelper.deproxy(taxon.getName(), NonViralName.class);
+ NonViralName<?> nonViralName = HibernateProxyHelper.deproxy(taxon.getName(), NonViralName.class);
switch (columnIndex) {
case 0:
String taxonName = null;
- taxonName = (nonVirlaName != null) ? nonVirlaName.getNameCache() : null;
+ taxonName = (nonViralName != null) ? nonViralName.getNameCache() : null;
return (taxonName != null) ? taxonName : DEFAULT_ENTRY;
case 1:
String authorship = null;
- authorship = (nonVirlaName != null) ? nonVirlaName.getAuthorshipCache() : null;
+ authorship = (nonViralName != null) ? nonViralName.getAuthorshipCache() : null;
return (authorship != null) ? authorship : DEFAULT_ENTRY;
// case 2:
// String ref = null;
for (TaxonDescription td : listTaxonDescriptions) {
for (DescriptionElementBase deb : td.getElements()) {
if (deb instanceof Distribution) {
- Distribution distribution = (Distribution) deb;
- String area = distribution.toString();
+ Distribution distribution = HibernateProxyHelper.deproxy(deb, Distribution.class);
+ String area = null;
+ if (distribution.getArea() != null ){
+ if (PreferencesUtil.isShowIdInVocabularyInChecklistEditor()){
+ area = distribution.getArea().getIdInVocabulary();
+ }else{
+ area = distribution.getArea().getTitleCache();
+ }
+ }else{
+ continue;
+ }
+
if(viewer != null){
TableColumn column = viewer.getTable().getColumn(columnIndex);
if (area.equalsIgnoreCase(column.getText())) {
- return (distribution.getStatus().getTitleCache() != null)?distribution.getStatus().getTitleCache():DEFAULT_ENTRY;
- }
+ return (distribution.getStatus().getTitleCache() != null)?distribution.getStatus().getTitleCache():DEFAULT_ENTRY;
+ }
+
}
}
}
"descriptions.*", "description.state" });
- private List<DefinedTermBase<?>> loadNamedAreas() {
+ private SortedSet<DefinedTermBase> loadNamedAreas() {
IPreferenceStore preferenceStore = PreferencesUtil.getPreferenceStore();
String values = preferenceStore.getString(PreferencesUtil.DISTRIBUTION_AREA_OCCURENCE_STATUS);
if (values != null && values != "") {
String[] split = values.split(",");
List<String> listValue = Arrays.asList(split);
- ArrayList<DefinedTermBase<?>> termlist = new ArrayList<DefinedTermBase<?>>();
+ List<DefinedTermBase> termlist = new ArrayList<DefinedTermBase>();
+ Set<UUID> uuidList = new HashSet<UUID>();
+ UUID uuid;
for(String s : listValue){
- UUID uuid = UUID.fromString(s);
- ITermService service = CdmStore.getService(ITermService.class);
- DefinedTermBase definedTermBase = service.load(uuid);
- termlist.add(definedTermBase);
+ uuid = UUID.fromString(s);
+ uuidList.add(uuid);
+
}
- return termlist;
+ ITermService service = CdmStore.getService(ITermService.class);
+ termlist = service.find(uuidList);
+
+ return getTermsOrderedByIdInVocabulary(termlist);
}
return null;
}
/**
* @return the namedAreas
*/
- public List<DefinedTermBase<?>> getNamedAreas() {
+ public SortedSet<DefinedTermBase> getNamedAreas() {
return namedAreas;
}
+
+ /**
+ * @param namedAreas
+ * @param defaultLanguage
+ * @return
+ */
+ public SortedSet<DefinedTermBase> getTermsOrderedByIdInVocabulary(List<DefinedTermBase> namedAreas) {
+ TermIdInVocabularyComparator comp = new TermIdInVocabularyComparator();
+
+ SortedSet result = new TreeSet(comp);
+ if(namedAreas != null){
+ result.addAll(namedAreas);
+ }
+ return result;
+ }
}
import eu.etaxonomy.cdm.model.location.NamedArea;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.taxeditor.editor.view.checklist.ChecklistEditor;
-import eu.etaxonomy.taxeditor.editor.view.checklist.ChecklistLabelProvider;
+import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
import eu.etaxonomy.taxeditor.store.CdmStore;
public final class DistributionEditingSupport extends EditingSupport {
Taxon taxon = (Taxon) element;
Distribution distributionForColumn = getDistributionForColumn(taxon);
if (distributionForColumn != null) {
- distributionForColumn.getStatus().getTitleCache();
+ return distributionForColumn.getStatus().getTitleCache();
}
// return PresenceAbsenceTerms
}
createDistributionForColumn(taxon, occurenceStatus);
}
// viewer.update(distribution, null);
- viewer.update(element, null);
- viewer.refresh();
- editor.setDirty(true);
+// viewer.update(element, null);
+// viewer.refresh();
+// editor.setDirty(true);
editor.changed(element);
viewer.refresh();
}
for (DescriptionElementBase deb : td.getElements()) {
if (deb instanceof Distribution) {
Distribution distribution = (Distribution) deb;
- if (column.getText().equalsIgnoreCase(distribution.getArea().getTitleCache())) {
- return distribution;
+ if (distribution.getArea() != null){
+ if (PreferencesUtil.isShowIdInVocabularyInChecklistEditor()){
+ if (column.getText().equalsIgnoreCase(distribution.getArea().getIdInVocabulary())) {
+ return distribution;
+ }
+ }else{
+ if (column.getText().equalsIgnoreCase(distribution.getArea().getTitleCache())) {
+ return distribution;
+ }
+ }
}
}
}
private void createDistributionForColumn(Taxon taxon, PresenceAbsenceTerm occurenceStatus) {
TableColumn column = viewer.getTable().getColumn(columnIndex);
- ChecklistLabelProvider labelProvider = new ChecklistLabelProvider();
- List<DefinedTermBase<?>> namedAreas = labelProvider.getNamedAreas();
- SortedSet<DefinedTermBase<?>> terms = (SortedSet<DefinedTermBase<?>>) labelProvider.getTermsOrderedByLabels(
- namedAreas, CdmStore.getDefaultLanguage());
+ SortedSet<DefinedTermBase> namedAreas = this.editor.getLabelProvider().getNamedAreas();
- if (terms != null) {
- for (DefinedTermBase term : terms) {
- if (column.getText().equalsIgnoreCase(term.getTitleCache())) {
+
+ if (namedAreas != null) {
+ for (DefinedTermBase term : namedAreas) {
+ boolean sameArea = true;
+ if (!PreferencesUtil.isShowIdInVocabularyInChecklistEditor()){
+ sameArea = column.getText().equalsIgnoreCase(term.getTitleCache());
+ } else{
+ sameArea = column.getText().equalsIgnoreCase(term.getIdInVocabulary());
+ }
+ if (sameArea) {
NamedArea area = (NamedArea) term;
Distribution distribution = Distribution.NewInstance(area, occurenceStatus);
Set<TaxonDescription> descriptions = taxon.getDescriptions();
- if (descriptions != null) {
+ if (!descriptions.isEmpty()) {
for (TaxonDescription desc : descriptions) {
// add to first taxon description
desc.addElement(distribution);
} else {// there are no TaxonDescription yet.
TaxonDescription td = TaxonDescription.NewInstance(taxon);
td.addElement(distribution);
+ break;
}
}
}
public static final String DISTRIBUTION_AREA_OCCURENCE_STATUS_GRAYED = "eu.etaxonomy.taxeditor.checklist.distributionAreaStatusGrayed";
+ public static final String CHECKLIST_ID_IN_VOCABULARY = "eu.etaxonomy.taxeditor.checklist.checklistIdInVocabulary";
+
public static final String SHOW_ADVANCED_MEDIA_SECTION = "eu.etaxonomy.taxeditor.media.showAdvancedMedia";
public static final String SHOW_SIMPLE_NAME_DETAILS_SECTION = "eu.etaxonomy.taxeditor.name.showSimpleName";
public static final String P2_REPOSITORIES_DELIM = ",";
public static final String P2_REPOSITORY_FIELDS_DELIM = ";";
+
+
/**
* <p>
* getPreferenceStore
getPreferenceStore().setDefault(OPENURL_IMAGE_MAX_WIDTH, "1000");
getPreferenceStore().setDefault(OPENURL_IMAGE_MAX_HEIGHT, "1000");
getPreferenceStore().setDefault(IPreferenceKeys.DISTRIBUTION_AREA_PREFRENCES_ACTIVE, false);
+ getPreferenceStore().setDefault(CHECKLIST_ID_IN_VOCABULARY, true);
}
/**
getPreferenceStore().setValue(IS_SHOW_UP_WIDGET_IS_DISPOSED, selection);
}
+ /**
+ * @return
+ */
+ public static boolean isShowIdInVocabularyInChecklistEditor() {
+ return getPreferenceStore().getBoolean(IPreferenceKeys.CHECKLIST_ID_IN_VOCABULARY);
+ }
+ public static void setShowIdInVocabularyInChecklistEditor(boolean selection) {
+ getPreferenceStore().setValue(CHECKLIST_ID_IN_VOCABULARY, selection);
+ }
}
this.viewer.setGrayed(element, false);
int length = tcp.getChildren(element).length;
if(length>1){
+ this.viewer.expandToLevel(element, CheckboxTreeViewer.ALL_LEVELS);
this.viewer.setSubtreeChecked(element, checked);
}
}