-// $Id$
/**
* Copyright (C) 2007 EDIT
* European Distributed Institute of Taxonomy
package eu.etaxonomy.taxeditor.ui.section.classification;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+
import org.apache.commons.lang.StringUtils;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Text;
import eu.etaxonomy.cdm.common.CdmUtils;
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
-import eu.etaxonomy.cdm.model.name.NonViralName;
-import eu.etaxonomy.cdm.model.name.TaxonNameBase;
+import eu.etaxonomy.cdm.model.common.Language;
+import eu.etaxonomy.cdm.model.common.LanguageString;
+import eu.etaxonomy.cdm.model.metadata.CdmPreference;
+import eu.etaxonomy.cdm.model.metadata.PreferencePredicate;
+import eu.etaxonomy.cdm.model.metadata.PublishEnum;
+import eu.etaxonomy.cdm.model.name.TaxonName;
import eu.etaxonomy.cdm.model.reference.Reference;
import eu.etaxonomy.cdm.model.taxon.Classification;
-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;
+import eu.etaxonomy.taxeditor.preference.CdmPreferenceCache;
+import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
+import eu.etaxonomy.taxeditor.store.CdmStore;
+import eu.etaxonomy.taxeditor.store.StoreUtil;
import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;
import eu.etaxonomy.taxeditor.ui.element.CheckboxElement;
import eu.etaxonomy.taxeditor.ui.element.ICdmFormElement;
+import eu.etaxonomy.taxeditor.ui.element.IEnableableFormElement;
+import eu.etaxonomy.taxeditor.ui.element.LayoutConstants;
+import eu.etaxonomy.taxeditor.ui.element.MultilanguageTextElement;
import eu.etaxonomy.taxeditor.ui.element.TextWithLabelElement;
import eu.etaxonomy.taxeditor.ui.section.AbstractCdmDetailElement;
import eu.etaxonomy.taxeditor.ui.selection.EntitySelectionElement;
import eu.etaxonomy.taxeditor.ui.selection.TaxonNodeSelectionElement;
/**
- * <p>
- * TaxonNodeDetailElement class.
- * </p>
*
* @author n.hoffmann
* @created Sep 27, 2010
* @version 1.0
*/
-public class TaxonNodeDetailElement extends AbstractCdmDetailElement<ITaxonTreeNode> {
-
- private EntitySelectionElement<Classification> selection_classification;
+public class TaxonNodeDetailElement extends AbstractCdmDetailElement<TaxonNode> {
+ private boolean createNew = false;
private Classification classification;
+ private TaxonNode parentNode;
+ private Taxon taxon;
private TaxonNodeSelectionElement selection_parentTaxonNode;
+ private EntitySelectionElement<Taxon> selection_reuseExistingTaxon;
+ private EntitySelectionElement<TaxonName> selection_reuseExistingName;
- private ITaxonTreeNode parentTreeNode;
+ private EntitySelectionElement<Reference> selection_SecRef;
+ private EntitySelectionElement<Reference> selection_Ref;
- private EntitySelectionElement<Taxon> selection_reuseExistingTaxon;
- private EntitySelectionElement<Reference> selection_SecRef;
- private Taxon taxon;
+ TextWithLabelElement textTaxonSec;
+
+ private TextWithLabelElement microReference;
+
- private Reference secReference;
+ private TextWithLabelElement textNewTaxonName;
- private TextWithLabelElement textNewTaxonName;
+ private TaxonNodeAgentRelationCollectionSection selectionNodeAgentRelation;
- private CheckboxElement checkbox_openInEditor;
+ private CheckboxElement checkbox_unplaced;
+ private CheckboxElement checkbox_excluded;
+ private CheckboxElement checkbox_publish;
+ private CheckboxElement checkbox_placementDoubtful;
+
+ private MultilanguageTextElement multiLanguageTextExcludedNotes;
- private boolean openInEditor;
private boolean complete;
- private EntitySelectionElement<TaxonNameBase> selection_reuseExistingName;
-
- /**
- * <p>
- * Constructor for TaxonNodeDetailElement.
- * </p>
- *
- * @param formFactory
- * a {@link eu.etaxonomy.taxeditor.ui.element.CdmFormFactory}
- * object.
- * @param formElement
- * a {@link eu.etaxonomy.taxeditor.ui.element.ICdmFormElement}
- * object.
- */
+ private boolean excluded = false;
+ private boolean unplaced = false;
+ private boolean placementDoubtful = false;
+
+
+
public TaxonNodeDetailElement(CdmFormFactory formFactory,
- ICdmFormElement formElement) {
+ ICdmFormElement formElement, boolean isCreateNew) {
super(formFactory, formElement);
+ createNew = isCreateNew;
}
+
+ public Map<Language, LanguageString> getMultiLanguageTextExcludedNotes() {
+ return multiLanguageTextExcludedNotes.getMultilanguageText();
+ }
+
+
+
+ public boolean isExcluded() {
+ return excluded;
+ }
+
+
+
+ public boolean isUnplaced() {
+ return unplaced;
+ }
+
+
+
+ public boolean isPlacementDoubtful() {
+ return placementDoubtful;
+ }
+
+ public Reference getRef() {
+ return selection_Ref.getEntity();
+ }
+ public TaxonName getExistingName() {
+ return selection_reuseExistingName.getEntity();
+ }
+ public String getMicroReference() {
+ return microReference.getText();
+ }
+
/** {@inheritDoc} */
@Override
protected void createControls(ICdmFormElement formElement,
- ITaxonTreeNode entity, int style) {
- selection_classification = formFactory
- .createSelectionElement(Classification.class,
- getConversationHolder(), formElement, "Classification",
- null, EntitySelectionElement.DELETABLE, style);
- selection_parentTaxonNode = formFactory
- .createTaxonNodeSelectionElement(getConversationHolder(), formElement, "Parent", null,
- EntitySelectionElement.DELETABLE, style);
-
- selection_reuseExistingTaxon = formFactory
- .createSelectionElement(Taxon.class,
- getConversationHolder(), formElement,
- "Reuse existing taxon", null,
- EntitySelectionElement.DELETABLE, style);
-
- selection_reuseExistingName = formFactory
- .createSelectionElement(TaxonNameBase.class,
- getConversationHolder(), formElement,
- "Reuse existing name", null,
- EntitySelectionElement.DELETABLE, style);
- selection_SecRef = formFactory
- .createSelectionElement(Reference.class,getConversationHolder(), formElement, "Secundum Reference", null,
- EntitySelectionElement.DELETABLE, style);
- textNewTaxonName = formFactory.createTextWithLabelElement(formElement,
- "New Taxon", "", style);
- textNewTaxonName.setFocus();
- preFillParentTaxonName();
-
- checkbox_openInEditor = formFactory.createCheckbox(formElement,
- "Open in Editor", true, style);
- setOpenInEditor(true);
- setParentTreeNode(entity);
+ TaxonNode entity, int style) {
+// taxon = entity.getTaxon();
+
+ if (isCreateNew()){
+// setParentTreeNode(entity);
+ selection_parentTaxonNode = formFactory
+ .createTaxonNodeSelectionElement(getConversationHolder(), formElement, "Parent", parentNode,
+ EntitySelectionElement.DELETABLE, style, 100);
+
+ selection_Ref = formFactory
+ .createSelectionElement(Reference.class,
+ formElement, "Parent Child Relation Source", null,
+ EntitySelectionElement.DELETABLE, style, 100);
+
+ microReference = formFactory.createTextWithLabelElement(formElement,"Detail", "", style);
+ microReference.setText(parentNode.getMicroReference());
+
+ selection_reuseExistingTaxon = formFactory
+ .createSelectionElement(Taxon.class,//getConversationHolder(),
+ formElement,
+ "Reuse existing taxon", null,
+ EntitySelectionElement.DELETABLE, style);
+
+ selection_reuseExistingName = formFactory
+ .createSelectionElement(TaxonName.class,//getConversationHolder(),
+ formElement,
+ "Reuse existing name", taxon != null? taxon.getName(): null,
+ EntitySelectionElement.DELETABLE, style);
+ selection_SecRef = formFactory
+ .createSelectionElement(Reference.class,//getConversationHolder(),
+ formElement, "Secundum Reference", taxon != null? taxon.getSec(): null,
+ EntitySelectionElement.DELETABLE, style, 100);
+
+ if (isCreateNew()){
+ textNewTaxonName = formFactory.createTextWithLabelElement(formElement,"New Taxon", "", style);
+ textNewTaxonName.setFocus();
+ } else{
+ textNewTaxonName = formFactory.createTextWithLabelElement(formElement,"Taxon", "", style);
+
+ }
+ }else{
+ taxon = getEntity().getTaxon();
+ if (entity.getParent().getTaxon() == null){
+ TextWithLabelElement textParent = formFactory.createTextWithLabelElement(formElement,"Classification", entity.getClassification().getTitleCache(), style);
+ textParent.setEnabled(false);
+ }else{
+ TextWithLabelElement textParent = formFactory.createTextWithLabelElement(formElement,"Parent", entity.getParent().getTaxon().getTitleCache(), style);
+ textParent.setEnabled(false);
+ }
+
+ selection_Ref = formFactory
+ .createSelectionElement(Reference.class,
+ formElement, "Parent Child Relation Source", null,
+ EntitySelectionElement.DELETABLE, style);
+
+ selection_reuseExistingTaxon = formFactory
+ .createSelectionElement(Taxon.class,//getConversationHolder(),
+ formElement,
+ "Taxon", taxon,
+ EntitySelectionElement.DELETABLE, style);
+
+ textTaxonSec = formFactory.createTextWithLabelElement(formElement,"Secundum Reference", "", style);
+ if (entity.getTaxon().getSec() != null){
+ textTaxonSec.setText(taxon.getSec().getTitleCache());
+ }
+ textTaxonSec.setEnabled(false);
+
+
+
+ }
+
+
+ if (!isCreateNew()){
+ if (entity.getReference() != null){
+ selection_Ref.setEntity(entity.getReference());
+ }
+
+ }
+
+
+ Taxon tax = null;
+ if (entity.getTaxon() != null){
+ tax = entity.getTaxon();
+ }
+ checkbox_publish = formFactory.createCheckbox(formElement,
+ "Taxon is published", tax != null? tax.isPublish(): true, style);
+
+
+ checkbox_publish.setEnabled(isCreateNew());
+
+ checkbox_placementDoubtful = formFactory.createCheckbox(formElement,
+ "Placement is doubtful", tax!= null? entity.isDoubtful(): false, style);
+
+
+
+ if(isCreateNew()){
+
+
+ String defaultPublish = PreferencesUtil.getStringValue(PreferencePredicate.DefaultBehaviourForPublishFlag.getKey());
+ if (defaultPublish != null && defaultPublish.equals(PublishEnum.Publish.getKey())){
+ checkbox_publish.setSelection(true);
+ } else if (defaultPublish != null && defaultPublish.equals(PublishEnum.NotPublish.getKey())){
+ checkbox_publish.setSelection(false);
+ }else{
+ if(this.getParentTreeNode() != null && this.getParentTreeNode().isInstanceOf(TaxonNode.class) && this.getParentTreeNode().getTaxon() != null){
+ checkbox_publish.setSelection(this.getParentTreeNode().getTaxon().isPublish());
+ }else{
+ checkbox_publish.setSelection(true);
+ }
+ }
+
+ } else{
+ setTreeNode(entity);
+ complete = true;
+ }
+
+ checkbox_unplaced = formFactory.createCheckbox(formElement,
+ "Taxon is unplaced", entity.isUnplaced(), style);
+
+ if (isCreateNew()){
+ preFillTaxonName();
+ }
+
+ checkbox_excluded = formFactory.createCheckbox(formElement,
+ "Taxon is excluded", entity.isExcluded(), style);
+ multiLanguageTextExcludedNotes = formFactory.createMultiLanguageTextElement(formElement, "Excluded Notes", entity.getExcludedNote(), 50, style);
+ multiLanguageTextExcludedNotes.setEnabled(entity.isExcluded());
+
+ if (!isCreateNew()){
+ selectionNodeAgentRelation = formFactory.createTaxonNodeAgentRelationCollectionSection(formElement, getConversationHolder(), StoreUtil.getSectionStyle(TaxonNodeAgentRelationCollectionSection.class, entity.getClass().getCanonicalName()));
+ selectionNodeAgentRelation.setEntity(entity);
+ selectionNodeAgentRelation.setLayoutData(LayoutConstants.FILL_HORIZONTALLY(2, 1));
+ }
+
}
- private void preFillParentTaxonName() {
- if(getEntity() instanceof TaxonNode){
- TaxonNode node = (TaxonNode)getEntity();
- if(node.getTaxon()!=null){
- Taxon taxon = HibernateProxyHelper.deproxy(node.getTaxon(), Taxon.class);
- if(taxon.getName()!=null && taxon.getName().isInstanceOf(NonViralName.class)){
- NonViralName<?> name = HibernateProxyHelper.deproxy(node.getTaxon().getName(), NonViralName.class);
- if( ! name.isSupraGeneric() && name.getRank() != null){
- String taxonName = "";
- if(name.isGenus() || name.isInfraGeneric()|| name.isSpeciesAggregate() ){
- taxonName = name.getGenusOrUninomial();
- }
- else if(name.isSpecies() || name.isInfraSpecific() ){
- taxonName = CdmUtils.concat(" ", name.getGenusOrUninomial(),name.getSpecificEpithet());
- }
- if (StringUtils.isNotBlank(taxonName)){
- textNewTaxonName.setText(taxonName + " ");
- if(textNewTaxonName.getMainControl() instanceof Text){
- Text text = (Text)textNewTaxonName.getMainControl();
- text.setSelection(textNewTaxonName.getText().length());
- }
- }
+ private void preFillTaxonName() {
+ TaxonNode node = parentNode;
+ if(node.getTaxon()!=null){
+ Taxon taxon = HibernateProxyHelper.deproxy(node.getTaxon(), Taxon.class);
+ if(taxon.getName()!=null){
+ TaxonName name = HibernateProxyHelper.deproxy(node.getTaxon().getName());
+ if (!isCreateNew()){
+ textNewTaxonName.setText(name.getNameCache());
+ } else if( ! name.isSupraGeneric() && name.getRank() != null){
+ String taxonName = "";
+ if(name.isGenus() || name.isInfraGeneric()|| name.isSpeciesAggregate() ){
+ taxonName = name.getGenusOrUninomial();
+ }
+ else if(name.isSpecies() || name.isInfraSpecific() ){
+ taxonName = CdmUtils.concat(" ", name.getGenusOrUninomial(),name.getSpecificEpithet());
+ }
+ if (StringUtils.isNotBlank(taxonName)){
+ textNewTaxonName.setText(taxonName + " ");
+ if(textNewTaxonName.getMainControl() instanceof Text){
+ Text text = (Text)textNewTaxonName.getMainControl();
+ text.setSelection(textNewTaxonName.getText().length());
+ }
}
}
}
}
+
}
/** {@inheritDoc} */
@Override
public void handleEvent(Object eventSource) {
- if (eventSource == selection_classification) {
- setClassification(selection_classification.getEntity());
- } else if (eventSource == selection_parentTaxonNode) {
- setParentTreeNode(selection_parentTaxonNode.getEntity());
- } else if (eventSource == selection_SecRef) {
- setSecReference(selection_SecRef.getEntity());
+ if (eventSource == selection_parentTaxonNode) {
+ setParentTreeNode(selection_parentTaxonNode.getEntity());
} else if (eventSource == selection_reuseExistingTaxon) {
- boolean enabled = selection_reuseExistingTaxon.getEntity() == null;
- selection_reuseExistingName.setEnabled(enabled);
- textNewTaxonName.setEnabled(enabled);
- if (!enabled){
- setTaxon(selection_reuseExistingTaxon.getEntity());
- } else{
- textNewTaxonName.setText(null);
- }
- complete = !textNewTaxonName.getText().isEmpty();
-
-
+ if (selection_reuseExistingTaxon.getEntity() != null){
+ setTaxon(selection_reuseExistingTaxon.getEntity());
+ if (getTaxon().getSec()!= null){
+ if (isCreateNew()){
+ selection_SecRef.setEntity(getTaxon().getSec());
+ }else{
+ textTaxonSec.setText((getTaxon().getSec().getTitleCache()));
+ }
+ }else{
+ if (isCreateNew()){
+ selection_SecRef.setEntity(null);
+ }else{
+ textTaxonSec.setText("");
+ }
+ }
+ checkbox_publish.setSelected(getTaxon().isPublish());
+ }
+ boolean enabled = selection_reuseExistingTaxon.getEntity() == null;
+ if (selection_reuseExistingName != null){
+ selection_reuseExistingName.setEnabled(enabled);
+ }
+ if (textNewTaxonName != null){
+ textNewTaxonName.setEnabled(enabled);
+ }
+ complete = true;
} else if (eventSource == selection_reuseExistingName) {
boolean enabled = selection_reuseExistingName.getEntity() == null;
- setTaxon(selection_reuseExistingName.getEntity());
- selection_reuseExistingTaxon.setEnabled(enabled);
+ setTaxon(HibernateProxyHelper.deproxy(selection_reuseExistingName.getEntity()));
+ if (selection_reuseExistingTaxon != null){
+ selection_reuseExistingTaxon.setEnabled(enabled);
+ }
textNewTaxonName.setEnabled(enabled);
+ complete = !textNewTaxonName.getText().isEmpty();
+ }
- setTaxon(selection_reuseExistingName.getEntity());
+ if (eventSource == selection_Ref) {
+ if(!isCreateNew()){
+ getEntity().setReference(selection_Ref.getEntity());
+ }
+ }else if (eventSource == selection_SecRef) {
+ if (taxon != null){
+ taxon.setSec(selection_SecRef.getEntity());
+ }
+ }else if (eventSource == microReference) {
+ if(!isCreateNew()){
+ getEntity().setMicroReference(microReference.getText());
+ }
+ } else if (eventSource == checkbox_publish) {
+ if (taxon != null){
+ taxon.setPublish(checkbox_publish.getSelection());
+ }
+ }
- complete = !textNewTaxonName.getText().isEmpty();
- } else if (eventSource == textNewTaxonName) {
- boolean enabled = CdmUtils.isBlank(textNewTaxonName.getText());
- selection_reuseExistingTaxon.setEnabled(enabled);
- selection_reuseExistingName.setEnabled(enabled);
+ if (eventSource == checkbox_excluded) {
+ excluded = checkbox_excluded.getSelection();
+ if (!isCreateNew()){
+ getEntity().setExcluded(excluded);
+ }
- setTaxon(textNewTaxonName.getText());
- complete = !textNewTaxonName.getText().isEmpty();
- } else if (eventSource == checkbox_openInEditor) {
- setOpenInEditor(checkbox_openInEditor.getSelection());
+ multiLanguageTextExcludedNotes.setEnabled(excluded);
+ }
+ if (eventSource == checkbox_unplaced) {
+ unplaced = checkbox_unplaced.getSelection();
+ if (!isCreateNew()){
+ getEntity().setUnplaced(unplaced);
+ }
+
+ }
+
+ if (eventSource == checkbox_placementDoubtful) {
+ placementDoubtful = checkbox_placementDoubtful.getSelection();
+ if (!isCreateNew()){
+ getEntity().setDoubtful(placementDoubtful);
+ }
+
+ }
+ if (eventSource == textNewTaxonName) {
+ boolean enabled = CdmUtils.isBlank(textNewTaxonName.getText());
+ if (selection_reuseExistingTaxon != null){
+ selection_reuseExistingTaxon.setEnabled(enabled);
+ }
+ selection_reuseExistingName.setEnabled(enabled);
+
+ complete = CdmUtils.isNotBlank(textNewTaxonName.getText());
+ }
+
+ if (eventSource == selectionNodeAgentRelation){
+ boolean allComplete = true;
+ for (ICdmFormElement element : selectionNodeAgentRelation.getElements()){
+ allComplete &=((TaxonNodeAgentRelationCollectionElement)element).isComplete();
+ }
+ complete = !isCreateNew() && allComplete;
}
}
- /**
- * <p>
- * Getter for the field <code>classification</code>.
- * </p>
- *
- * @return the classification
- */
public Classification getClassification() {
return classification;
}
- public boolean isOpenInEditor() {
- return openInEditor;
- }
- /**
- * <p>
- * Getter for the field <code>parentTreeNode</code>.
- * </p>
- *
- * @return a {@link eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode} object.
- */
- public ITaxonTreeNode getParentTreeNode() {
- return parentTreeNode;
- }
- /**
- * <p>
- * Getter for the field <code>taxon</code>.
- * </p>
- *
- * @return the taxon
- */
- public Taxon getTaxon() {
- return taxon;
+ public TaxonNode getParentTreeNode() {
+ return parentNode;
}
- private void setClassification(Classification classification) {
- this.classification = classification;
- setParentTreeNode(classification);
- }
+ public void setParentTreeNode(TaxonNode parentTreeNode) {
+ this.parentNode = parentTreeNode;
+ updateContent();
+ if (parentTreeNode.getTaxon() == null) {
+ classification = parentTreeNode.getClassification();
+ if (selection_parentTaxonNode != null){
+ selection_parentTaxonNode.setEntity(classification.getRootNode());
+ selection_parentTaxonNode.setClassification(classification);
+ selection_SecRef.setEntity(classification.getReference());
+ }
+ } else {
+ classification = HibernateProxyHelper
+ .deproxy(parentTreeNode.getClassification());
+ if (selection_parentTaxonNode != null){
+ selection_parentTaxonNode.setEntity(HibernateProxyHelper.deproxy(parentTreeNode));
+ selection_parentTaxonNode.setClassification(classification);
+ selection_SecRef.setEntity(parentTreeNode.getTaxon().getSec());
+ }
+
- private void setParentTreeNode(ITaxonTreeNode parentTreeNode) {
- this.parentTreeNode = parentTreeNode;
-
- if (parentTreeNode instanceof Classification) {
- classification = (Classification) parentTreeNode;
- selection_classification.setEntity(classification);
- selection_parentTaxonNode.setEntity(null);
- selection_parentTaxonNode.setClassification(classification);
- selection_SecRef.setEntity(classification.getReference());
- } else if (parentTreeNode instanceof TaxonNode) {
- classification = (Classification) HibernateProxyHelper
- .deproxy(((TaxonNode) parentTreeNode).getClassification());
- selection_classification.setEntity(classification);
- selection_parentTaxonNode.setEntity((TaxonNode) parentTreeNode);
- selection_parentTaxonNode.setClassification(classification);
- selection_SecRef.setEntity(((TaxonNode)parentTreeNode).getTaxon().getSec());
- } else if(parentTreeNode == null){
- this.parentTreeNode = selection_classification.getEntity();
}
}
+ @Override
+ protected void updateControlStates(){
+ Collection<Object> except = new ArrayList<Object>();
+ for(ICdmFormElement formElement:getElements()){
+ if(formElement instanceof IEnableableFormElement && !((IEnableableFormElement) formElement).isEnabled()){
+ except.add(formElement);
+ }
+ }
+ if (isCreateNew() ){
+ enabled = true;
+ }else{
+ enabled = getEntity() != null && CdmStore.currentAuthentiationHasPermission(StoreUtil.getCdmEntity(getEntity()), requiredCrud);
+ }
+ setEnabled(enabled, except);
+ }
- private void setSecReference(Reference secRef){
- this.secReference = secRef;
- setTaxon(textNewTaxonName.getText());
+ private void setTreeNode(TaxonNode treeNode) {
+ classification = HibernateProxyHelper
+ .deproxy(treeNode.getClassification());
+ if (isCreateNew()){
+ selection_parentTaxonNode.setEntity(treeNode.getParent());
+ selection_parentTaxonNode.setClassification(treeNode.getParent().getClassification());
+ selection_SecRef.setEntity(treeNode.getTaxon().getSec());
+ }
}
private void setTaxon(Taxon taxon) {
this.taxon = taxon;
- textNewTaxonName.setText(taxon.getName().getTitleCache());
- selection_SecRef.setEntity(taxon.getSec());
- }
+ if (!isCreateNew()){
+ getEntity().setTaxon(taxon);
+ }
+ this.set_publish(taxon.isPublish());
+ if (isCreateNew()){
+ textNewTaxonName.setText(taxon.getName().getTitleCache());
+ if (taxon.getSec() != null){
+ selection_SecRef.setEntity(taxon.getSec());
+ }
+ }else{
+ if (taxon.getSec() != null) {
+ this.textTaxonSec.setText(taxon.getSec().getTitleCache());
+ }
+ }
+
- private void setTaxon(String taxonNameString) {
- TaxonNameBase taxonName = ParseHandler.parseReferencedName(
- taxonNameString, null);
- setTaxon(taxonName);
}
- private void setTaxon(TaxonNameBase taxonName) {
+ private void setTaxon(TaxonName taxonName) {
Reference secundum = null;
if (getParentTreeNode() != null) {
- if (this.secReference != null){
- secundum = this.secReference;
- } /*else if (getParentTreeNode() instanceof Classification) {
- secundum = ((Classification) getParentTreeNode())
- .getReference();
- } else if (getParentTreeNode() instanceof TaxonNode) {
- secundum = ((TaxonNode) getParentTreeNode()).getTaxon()
- .getSec();
- }*/
+ if (this.selection_SecRef.getEntity() != null){
+ secundum = this.selection_SecRef.getEntity();
+ }
}
if (taxonName != null){
taxon = Taxon.NewInstance(taxonName, secundum);
- if (!taxonName.getTitleCache().trim().equals(textNewTaxonName.getText().trim())){
- textNewTaxonName.setText(taxonName.getTitleCache());
+ if (textNewTaxonName.getText() == null || !taxonName.getTitleCache().trim().equals(textNewTaxonName.getText().trim())){
+ textNewTaxonName.setText(taxonName.getTitleCache());
}
+ if (!isCreateNew()){
+ getEntity().setTaxon(taxon);
+ }
+
} else {
textNewTaxonName.setText(null);
}
}
- private void setOpenInEditor(boolean openInEditor) {
- this.openInEditor = openInEditor;
+ public String getTaxonName() {
+ return textNewTaxonName.getText();
+ }
+ public Taxon getTaxon() {
+ return taxon;
+ }
+
+ public Reference getSecReference(){
+ return selection_SecRef.getSelection();
}
- public TextWithLabelElement getTextNewTaxonName() {
- return textNewTaxonName;
- }
+ public Control getMainControl(){
+ return textNewTaxonName.getMainControl();
+ }
public boolean isComplete() {
+ boolean allComplete = true;
+ if (!isCreateNew()){
+ for (ICdmFormElement element : selectionNodeAgentRelation.getElements()){
+ allComplete &=((TaxonNodeAgentRelationCollectionElement)element).isComplete();
+ }
+ complete = allComplete;
+ }
return complete;
}
+ public boolean isCreateNew() {
+ return createNew;
+ }
+
+ public boolean is_publish() {
+ boolean isPublishPreference = true;
+ CdmPreference defaultPublish = CdmPreferenceCache.instance().get(PreferencePredicate.DefaultBehaviourForPublishFlag.getKey());
+ if (defaultPublish != null && defaultPublish.getValue()!= null && defaultPublish.getValue().equals(PublishEnum.NotPublish.getKey())){
+ isPublishPreference = false;
+ }
+ return checkbox_publish!=null?checkbox_publish.getSelection():isPublishPreference;
+ }
+
+ public void set_publish(boolean publish) {
+ this.checkbox_publish.setSelection(publish);
+ }
+
+ /**
+ * Updates all widgets to display the latest data
+ */
+ @Override
+ protected void updateContent() {
+ removeElements();
+ if (isCreateNew()){
+ createControls(this, parentNode, SWT.NONE);
+ }else{
+ createControls(this, getEntity(), SWT.NONE);
+ }
+ updateControlStates();
+ }
+
+
}