From b8cf1abb9e056c2db5d0cf5d4376c7a331d5f6f5 Mon Sep 17 00:00:00 2001 From: "p.ciardelli" Date: Mon, 15 Sep 2008 08:59:00 +0000 Subject: [PATCH] Cleaning up SVN mess from package re-org --- .gitattributes | 6 + .../ChooseRelatedNameWizardPage.java | 243 ++++++++++++++++++ .../ChooseRelationTypeWizardPage.java | 223 ++++++++++++++++ .../ListNameRelationsWizardPage.java | 222 ++++++++++++++++ .../NameRelationWizard.java | 75 ++++++ .../NameRelationWizardModel.java | 130 ++++++++++ .../NameRelationsListWizard.java | 47 ++++ 7 files changed, 946 insertions(+) create mode 100644 eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/ChooseRelatedNameWizardPage.java create mode 100644 eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/ChooseRelationTypeWizardPage.java create mode 100644 eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/ListNameRelationsWizardPage.java create mode 100644 eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/NameRelationWizard.java create mode 100644 eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/NameRelationWizardModel.java create mode 100644 eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/NameRelationsListWizard.java diff --git a/.gitattributes b/.gitattributes index 62e3a9e51..e3ba982fd 100644 --- a/.gitattributes +++ b/.gitattributes @@ -523,3 +523,9 @@ eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/ eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/name/NomStatusPropertySource.java -text eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/name/NonViralNamePropertySource.java -text eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/name/ZoologicalNamePropertySource.java -text +eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/ChooseRelatedNameWizardPage.java -text +eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/ChooseRelationTypeWizardPage.java -text +eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/ListNameRelationsWizardPage.java -text +eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/NameRelationWizard.java -text +eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/NameRelationWizardModel.java -text +eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/NameRelationsListWizard.java -text diff --git a/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/ChooseRelatedNameWizardPage.java b/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/ChooseRelatedNameWizardPage.java new file mode 100644 index 000000000..e7307d32a --- /dev/null +++ b/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/ChooseRelatedNameWizardPage.java @@ -0,0 +1,243 @@ +/** + * Copyright (C) 2007 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.propertysheet.namerelationswizard; + +import java.util.Set; + +import org.apache.log4j.Logger; +import org.eclipse.core.databinding.beans.BeansObservables; +import org.eclipse.core.databinding.observable.list.WritableList; +import org.eclipse.core.databinding.observable.map.IObservableMap; +import org.eclipse.jface.databinding.viewers.ObservableListContentProvider; +import org.eclipse.jface.databinding.viewers.ObservableMapLabelProvider; +import org.eclipse.jface.viewers.DoubleClickEvent; +import org.eclipse.jface.viewers.IDoubleClickListener; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.viewers.StructuredSelection; +import org.eclipse.jface.viewers.TableViewer; +import org.eclipse.jface.viewers.ViewerComparator; +import org.eclipse.jface.wizard.WizardPage; +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.ModifyEvent; +import org.eclipse.swt.events.ModifyListener; +import org.eclipse.swt.events.SelectionAdapter; +import org.eclipse.swt.events.SelectionEvent; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.widgets.Button; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Event; +import org.eclipse.swt.widgets.Label; +import org.eclipse.swt.widgets.Listener; +import org.eclipse.swt.widgets.Table; +import org.eclipse.swt.widgets.TableItem; +import org.eclipse.swt.widgets.Text; + +import eu.etaxonomy.cdm.model.name.NonViralName; +import eu.etaxonomy.cdm.model.name.TaxonNameBase; +import eu.etaxonomy.taxeditor.ITaxEditorConstants; +import eu.etaxonomy.taxeditor.TaxEditorPlugin; +import eu.etaxonomy.taxeditor.model.CdmUtil; + +/** + * An all-in-one relation wizard page where the user chooses a related name, a + * relationship type, and the relation's directionality. + * + * Note: does not yet return relation to wizard. + * + * @author p.ciardelli + * @created 04.06.2008 + * @version 1.0 + */ +public class ChooseRelatedNameWizardPage extends WizardPage { + private static final Logger logger = Logger + .getLogger(ChooseRelatedNameWizardPage.class); + + private NameRelationWizardModel relationModel; + + private Text txtNewName; + private Text txtName; + private boolean nameSelected = false; + + private Table searchResultsTable; + private WritableList observableSearchResultsList = new WritableList(); + private NonViralName noResultsDummyName = NonViralName.NewInstance(null); + + public ChooseRelatedNameWizardPage(NameRelationWizardModel relationModel) { + super(""); + + this.relationModel = relationModel; + + setTitle("Choose related name for '" + relationModel.getBaseName() + "\"."); + setDescription("You can either choose from search results or create a new name. Use \"*\" for wildcard searching."); + } + + @Override + public void createControl(Composite parent) { + Composite container = new Composite(parent, SWT.NULL); + final GridLayout gridLayout = new GridLayout(); + gridLayout.numColumns = 3; + container.setLayout(gridLayout); + + setControl(container); + + final Label lblChooseName = new Label(container, SWT.NONE); + lblChooseName.setText("Choose name for relation:"); + new Label(container, SWT.NONE); + new Label(container, SWT.NONE); + + txtName = new Text(container, SWT.BORDER); + txtName.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false)); + + final Button btnSearch = new Button(container, SWT.NONE); + btnSearch.setEnabled(false); + btnSearch.setLayoutData(new GridData()); + btnSearch.setText("Search"); + btnSearch.addSelectionListener(new SelectionAdapter() { + public void widgetSelected(SelectionEvent e) { + String searchText = txtName.getText(); + btnSearch.setEnabled(false); + Set results = CdmUtil.getNameByName(searchText); + + observableSearchResultsList.clear(); + if (results.size() == 0) { + // Populate observable list with dummy name + observableSearchResultsList.add(noResultsDummyName); + } else { + observableSearchResultsList.addAll(results); + } + btnSearch.setEnabled(true); + } + }); + + final Button btnNewName = new Button(container, SWT.NONE); + btnNewName.setEnabled(false); + btnNewName.setText("Create New Name"); + btnNewName.addSelectionListener(new SelectionAdapter() { + public void widgetSelected(SelectionEvent e) { + setRawNewName(txtName.getText()); + btnNewName.setEnabled(false); + } + }); + createSearchResultsViewer(container); + + txtName.addModifyListener(new ModifyListener() { + @Override + public void modifyText(ModifyEvent e) { + if (txtName.getText().length() > 0) { + btnNewName.setEnabled(true); + btnSearch.setEnabled(true); + } else { + btnNewName.setEnabled(false); + btnSearch.setEnabled(false); + } + } + }); + + txtNewName = new Text(container, SWT.BORDER); + final GridData gd_txtNewName = new GridData(SWT.FILL, SWT.CENTER, true, + false, 3, 1); + txtNewName.setLayoutData(gd_txtNewName); + txtNewName.setFont(TaxEditorPlugin.getDefault().getFont + (ITaxEditorConstants.CHOOSE_NAME_TEXT_FONT)); + txtNewName.setBackground(Display.getCurrent().getSystemColor( + SWT.COLOR_WHITE)); + txtNewName.setEditable(false); + + if (relationModel.getRelatedName() != null) { + txtNewName.setText(CdmUtil.getDisplayName(relationModel.getRelatedName())); + nameSelected = true; + } + } + + private void createSearchResultsViewer(Composite parent) { + TableViewer searchResultsViewer = new TableViewer(parent, SWT.BORDER); + + // Add content provider + ObservableListContentProvider searchResultsProviderList = new ObservableListContentProvider(); + searchResultsViewer.setContentProvider(searchResultsProviderList); + + // Label provider that listens for changes to name cache + IObservableMap[] searchResultsLabelProviderMaps = BeansObservables + .observeMaps(searchResultsProviderList.getKnownElements(), + TaxonNameBase.class, new String[] { "titleCache" }); + searchResultsViewer.setLabelProvider(new ObservableMapLabelProvider( + searchResultsLabelProviderMaps)); + + // Listens for new taxa opened for editing + searchResultsViewer.setInput(observableSearchResultsList); + + // Sort alphabetically + searchResultsViewer.setComparator(new ViewerComparator()); + + // On double click, open name editor + searchResultsViewer.addDoubleClickListener(new IDoubleClickListener() { + + public void doubleClick(DoubleClickEvent event) { + IStructuredSelection selection = (StructuredSelection) event + .getSelection(); + Object element = selection.getFirstElement(); + if (element instanceof TaxonNameBase) { + setNewName((TaxonNameBase) element); + } + } + }); + + searchResultsTable = searchResultsViewer.getTable(); + searchResultsTable.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, + true, 3, 1)); + searchResultsTable.addListener(SWT.PaintItem, new Listener() { + /** + * If MenuItem with dummy name is being drawn, put it in italics. + * + * @see org.eclipse.swt.widgets.Listener#handleEvent(org.eclipse.swt.widgets.Event) + */ + public void handleEvent(Event event) { + Object data = event.item.getData(); + if (data instanceof TaxonNameBase + && ((TaxonNameBase) data).equals(noResultsDummyName)) { + TableItem item = (TableItem) event.item; + item.setFont(TaxEditorPlugin.getDefault().getFont( + ITaxEditorConstants.MENU_ITEM_ITALICS_FONT)); + item.setText("Search returned no results."); + } + } + }); + } + + @Override + public boolean canFlipToNextPage() { + return isPageComplete(); + } + + public boolean isPageComplete() { + return (nameSelected); + } + + private void updatePage() { + getWizard().getContainer().updateButtons(); + } + + private void setNewName(TaxonNameBase name) { + nameSelected = true; + relationModel.setRelatedName(name); + txtNewName.setText(CdmUtil.getDisplayName(name)); + updatePage(); + } + + private void setRawNewName(String rawName) { + nameSelected = true; + TaxonNameBase newName = CdmUtil.parseFullReference(rawName, null, null); + relationModel.setRelatedName(newName); + txtNewName.setText(rawName + " (new)"); + updatePage(); + } +} \ No newline at end of file diff --git a/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/ChooseRelationTypeWizardPage.java b/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/ChooseRelationTypeWizardPage.java new file mode 100644 index 000000000..21e742a32 --- /dev/null +++ b/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/ChooseRelationTypeWizardPage.java @@ -0,0 +1,223 @@ +/** + * Copyright (C) 2007 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.propertysheet.namerelationswizard; + +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; +import java.util.ArrayList; +import java.util.List; + +import org.apache.log4j.Logger; +import org.eclipse.jface.wizard.WizardPage; +import org.eclipse.swt.SWT; +import org.eclipse.swt.custom.CCombo; +import org.eclipse.swt.events.SelectionAdapter; +import org.eclipse.swt.events.SelectionEvent; +import org.eclipse.swt.events.SelectionListener; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.widgets.Button; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Group; +import org.eclipse.swt.widgets.Label; + +import eu.etaxonomy.cdm.model.name.NameRelationshipType; +import eu.etaxonomy.taxeditor.TaxEditorPlugin; +import eu.etaxonomy.taxeditor.model.CdmUtil; + +/** + * An all-in-one relation wizard page where the user chooses a related name, a + * relationship type, and the relation\"s directionality. + * + * Note: does not yet return relation to wizard. + * + * @author p.ciardelli + * @created 04.06.2008 + * @version 1.0 + */ +public class ChooseRelationTypeWizardPage extends WizardPage { + private static final Logger logger = Logger + .getLogger(ChooseRelationTypeWizardPage.class); + + private List relationTypes; + + private CCombo combo; + private Label lblDirection; + private Button btnFromRelatedToBase; + private Button btnFromBaseToRelated; + + private boolean typeSelected = false; + private boolean directionSelected = false; + + private SelectionListener radioSelectionListener = new SelectionAdapter() { + public void widgetSelected(SelectionEvent e) { + directionSelected = true; + updatePage(); + + if (e.widget.equals(btnFromRelatedToBase)) { + relationModel.setFromName(relationModel.getRelatedName()); + relationModel.setToName(relationModel.getBaseName()); + } + + if (e.widget.equals(btnFromBaseToRelated)) { + relationModel.setFromName(relationModel.getBaseName()); + relationModel.setToName(relationModel.getRelatedName()); + } + } + }; + + private NameRelationWizardModel relationModel; + + public ChooseRelationTypeWizardPage(final NameRelationWizardModel relationModel) { + super(""); + setTitle("Choose relationship type and direction."); + + this.relationModel = relationModel; + + setDescription(); + + relationModel.addPropertyChangeListener(new PropertyChangeListener() { + @Override + public void propertyChange(PropertyChangeEvent evt) { + if (evt.getPropertyName().equals(NameRelationWizardModel.RELATEDNAME)) { + setDescription(); + setDirectionLabels(); + } + if (evt.getPropertyName().equals(NameRelationWizardModel.RELATIONTYPE)) { + if (relationModel.getType() != null) { + typeSelected = true; + enableDirection(); + } else { + typeSelected = false; + disableDirection(); + } + updatePage(); + } + } + }); + } + + @Override + public void createControl(Composite parent) { + Composite container = new Composite(parent, SWT.NULL); + container.setLayout(new GridLayout()); + + setControl(container); + + relationTypes = new ArrayList(); + + final Label lblType = new Label(container, SWT.NONE); + lblType.setText("Choose relationship type:"); + + combo = new CCombo(container, SWT.BORDER); + combo.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false)); + for (NameRelationshipType relationType : TaxEditorPlugin.getDefault() + .getSortedNameRelationshipTypes()) { + relationTypes.add(relationType); + combo.add(relationType.getLabel()); + } + combo.setVisibleItemCount(relationTypes.size()); + + combo.addSelectionListener(new SelectionAdapter() { + @Override + public void widgetSelected(SelectionEvent e) { + int typeIndex = combo.getSelectionIndex(); + relationModel.setType(relationTypes.get(typeIndex)); + } + }); + + final Group group = new Group(container, SWT.NONE); + group.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true)); + final GridLayout gridLayout = new GridLayout(); + group.setLayout(gridLayout); + + lblDirection = new Label(group, SWT.NONE); + final GridData gd_lblDirection = new GridData(SWT.FILL, SWT.CENTER, true, false); + gd_lblDirection.heightHint = 32; + gd_lblDirection.minimumHeight = 40; + lblDirection + .setLayoutData(gd_lblDirection); + lblDirection.setEnabled(false); + lblDirection.setText("Choose relationship direction:"); + + btnFromRelatedToBase = new Button(group, SWT.RADIO); + btnFromRelatedToBase + .setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false)); + btnFromRelatedToBase.setVisible(false); + btnFromRelatedToBase.addSelectionListener(radioSelectionListener); + + btnFromBaseToRelated = new Button(group, SWT.RADIO); + btnFromBaseToRelated + .setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false)); + btnFromBaseToRelated.setVisible(false); + btnFromBaseToRelated.addSelectionListener(radioSelectionListener); + new Label(group, SWT.NONE); + + } + + private void setDescription() { + setDescription("Choose relationship type and direction for the name relation between \"" + + CdmUtil.getDisplayName(relationModel.getBaseName()) + "\" and \"" + + CdmUtil.getDisplayName(relationModel.getRelatedName()) + "\"."); + } + + private void setDirectionLabels() { + String strDirection1 = "\"" + CdmUtil.getDisplayName(relationModel.getRelatedName()) + "\" " + + "is \"" + combo.getText() + "\" of " + "\"" + + CdmUtil.getDisplayName(relationModel.getBaseName()) + "\""; + String strDirection2 = "\"" + CdmUtil.getDisplayName(relationModel.getBaseName()) + "\" " + + "is \"" + combo.getText() + "\" of " + "\"" + + CdmUtil.getDisplayName(relationModel.getRelatedName()) + "\""; + + btnFromRelatedToBase.setText(strDirection1); + btnFromBaseToRelated.setText(strDirection2); + } + + @Override + public boolean canFlipToNextPage() { + // Last page + return false; + } + + public boolean isPageComplete() { + return (typeSelected && directionSelected); + } + + private void updatePage() { + if (typeSelected) { + if (!directionSelected) { + enableDirection(); + } + } else { + disableDirection(); + } + getWizard().getContainer().updateButtons(); + } + + private void enableDirection() { + setDirectionLabels(); + + lblDirection.setEnabled(true); + btnFromRelatedToBase.setEnabled(true); + btnFromBaseToRelated.setEnabled(true); + + btnFromRelatedToBase.setVisible(true); + btnFromBaseToRelated.setVisible(true); + } + + private void disableDirection() { + lblDirection.setEnabled(false); + btnFromRelatedToBase.setEnabled(false); + btnFromBaseToRelated.setEnabled(false); + + btnFromRelatedToBase.setSelection(false); + btnFromBaseToRelated.setSelection(false); + } +} \ No newline at end of file diff --git a/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/ListNameRelationsWizardPage.java b/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/ListNameRelationsWizardPage.java new file mode 100644 index 000000000..ab0f2553a --- /dev/null +++ b/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/ListNameRelationsWizardPage.java @@ -0,0 +1,222 @@ +/** + * Copyright (C) 2007 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.propertysheet.namerelationswizard; + +import org.apache.log4j.Logger; +import org.eclipse.core.databinding.beans.BeansObservables; +import org.eclipse.core.databinding.observable.list.WritableList; +import org.eclipse.core.databinding.observable.map.IObservableMap; +import org.eclipse.jface.databinding.viewers.ObservableListContentProvider; +import org.eclipse.jface.databinding.viewers.ObservableMapLabelProvider; +import org.eclipse.jface.viewers.DoubleClickEvent; +import org.eclipse.jface.viewers.IDoubleClickListener; +import org.eclipse.jface.viewers.StructuredSelection; +import org.eclipse.jface.viewers.TableViewer; +import org.eclipse.jface.wizard.WizardPage; +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.SelectionAdapter; +import org.eclipse.swt.events.SelectionEvent; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.widgets.Button; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Table; +import org.eclipse.swt.widgets.TableItem; + +import eu.etaxonomy.cdm.model.name.NameRelationship; +import eu.etaxonomy.cdm.model.name.NameRelationshipType; +import eu.etaxonomy.cdm.model.name.TaxonNameBase; +import eu.etaxonomy.cdm.model.taxon.Taxon; +import eu.etaxonomy.taxeditor.ITaxEditorConstants; +import eu.etaxonomy.taxeditor.TaxEditorPlugin; +import eu.etaxonomy.taxeditor.actions.cdm.DeleteNameRelationAction; +import eu.etaxonomy.taxeditor.actions.ui.OpenNameRelationWizardAction; +import eu.etaxonomy.taxeditor.model.CdmUtil; + +/** + * @author p.ciardelli + * @created 06.06.2008 + * @version 1.0 + */ +public class ListNameRelationsWizardPage extends WizardPage { + private static final Logger logger = Logger + .getLogger(ListNameRelationsWizardPage.class); + + private Table nameRelationsTable; + private WritableList nameRelationsList = new WritableList(); + private TaxonNameBase name; + + private Button btnRemove; + private Button btnEdit; + + private NameRelationship selectedRelation; + + public ListNameRelationsWizardPage(TaxonNameBase name) { + super(""); + + this.name = name; + + this.nameRelationsList.addAll(name.getNameRelations()); + + setTitle("Nomenclatural relations for \"" + + CdmUtil.getDisplayName(name) + "\"."); + setDescription("Select a relation and click \"Edit ...\" or \"Remove\", or click \"Add ...\" to create a new relation."); + } + + @Override + public void createControl(Composite parent) { + Composite container = new Composite(parent, SWT.NULL); + final GridLayout gridLayout = new GridLayout(); + gridLayout.numColumns = 3; + container.setLayout(gridLayout); + + setControl(container); + + btnEdit = new Button(container, SWT.NONE); + btnEdit.setText("Edit ..."); + + btnRemove = new Button(container, SWT.NONE); + btnRemove.setText("Remove"); + btnRemove.addSelectionListener(new SelectionAdapter() { + public void widgetSelected(SelectionEvent e) { + if (getSelectedRelation() != null) { + new DeleteNameRelationAction(name, getSelectedRelation()).run(); + nameRelationsList.remove(getSelectedRelation()); + setSelectedRelation(null); + } + } + }); + + setEnableExistingRelationButtons(false); + + final Button btnAdd = new Button(container, SWT.NONE); + final GridData gd_btnAdd = new GridData(SWT.RIGHT, SWT.CENTER, true, + false); + btnAdd.setLayoutData(gd_btnAdd); + btnAdd.setText("Add ..."); + btnAdd.addSelectionListener(new SelectionAdapter() { + public void widgetSelected(SelectionEvent e) { + createRelationWizard(null); + } + }); + + final TableViewer tableViewer = new TableViewer(container, SWT.BORDER | SWT.SINGLE); + + nameRelationsTable = tableViewer.getTable(); + nameRelationsTable.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, + true, 3, 1)); + nameRelationsTable.addSelectionListener(new SelectionAdapter() { + public void widgetSelected(SelectionEvent e) { + setEnableExistingRelationButtons(true); + TableItem[] selectedItem = nameRelationsTable.getSelection(); + if (e.item.getData() instanceof NameRelationship) { + setSelectedRelation((NameRelationship) e.item.getData()); + } + } + }); + + ObservableListContentProvider providerList = new ObservableListContentProvider(); + tableViewer.setContentProvider(providerList); + + IObservableMap[] providerMaps = BeansObservables.observeMaps( + providerList.getKnownElements(), NameRelationship.class, + new String[] { "fromName", "toName", "type" }); + tableViewer.setLabelProvider(new ObservableMapLabelProvider( + providerMaps) { + public String getColumnText(Object element, int columnIndex) { + if (element instanceof NameRelationship) { + NameRelationship nameRelationship = (NameRelationship) element; + return getRelationshipString(nameRelationship); + } + return ""; + } + + public Image getColumnImage(Object element, int columnIndex) { + if (element instanceof NameRelationship) { + NameRelationship nameRelationship = (NameRelationship) element; + return getRelationshipImage(nameRelationship); + } + return null; + } + }); + // TODO try name.getNameRelations() + tableViewer.setInput(nameRelationsList); + tableViewer.addDoubleClickListener(new IDoubleClickListener() { + @Override + public void doubleClick(DoubleClickEvent event) { + if (((StructuredSelection) event.getSelection()) + .getFirstElement() instanceof NameRelationship) { + NameRelationship relation = (NameRelationship) ((StructuredSelection) event + .getSelection()).getFirstElement(); + createRelationWizard(relation); + } + } + }); + } + + private void setSelectedRelation(NameRelationship selectedRelation) { + this.selectedRelation = selectedRelation; + } + + private NameRelationship getSelectedRelation() { + return selectedRelation; + } + + private void createRelationWizard(NameRelationship relation) { + if (relation == null) { + new OpenNameRelationWizardAction(name, nameRelationsList).run(); + } else { +// new OpenNameRelationWizardAction(name, relation).run(); + } + } + + protected void setEnableExistingRelationButtons(boolean enabled) { + btnRemove.setEnabled(enabled); + btnEdit.setEnabled(false); + } + + private Image getRelationshipImage(NameRelationship nameRelationship) { + if (nameRelationship.getType().equals(NameRelationshipType.BASIONYM())) { + return TaxEditorPlugin.getDefault().getImage( + ITaxEditorConstants.BASIONYM_ICON); + } + if (nameRelationship.getType().equals( + NameRelationshipType.ORTHOGRAPHIC_VARIANT())) { + return TaxEditorPlugin.getDefault().getImage( + ITaxEditorConstants.ORTHOGRAPHIC_VARIANT_ICON); + } +// return TaxEditorPlugin.getDefault().getImage( +// ITaxEditorConstants.EDIT_ICON); + return null; + } + + private String getRelationshipString(NameRelationship nameRelationship) { + String fromName = null; + String type = null; + String toName = null; + if (nameRelationship.getFromName() == null) { + fromName = ""; + } else { + fromName = CdmUtil.getDisplayName(nameRelationship.getFromName()); + } + if (nameRelationship.getType() == null) { + type = ""; + } else { + type = nameRelationship.getType().getLabel(); + } + if (nameRelationship.getToName() == null) { + toName = ""; + } else { + toName = CdmUtil.getDisplayName(nameRelationship.getToName()); + } + return "\"" + fromName + "\" is \"" + type + "\" of \"" + toName + "\""; + } +} diff --git a/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/NameRelationWizard.java b/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/NameRelationWizard.java new file mode 100644 index 000000000..b139d9124 --- /dev/null +++ b/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/NameRelationWizard.java @@ -0,0 +1,75 @@ +/** + * Copyright (C) 2007 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.propertysheet.namerelationswizard; + +import org.apache.log4j.Logger; +import org.eclipse.jface.util.IPropertyChangeListener; +import org.eclipse.jface.util.PropertyChangeEvent; +import org.eclipse.jface.wizard.IWizardPage; +import org.eclipse.jface.wizard.Wizard; + +import eu.etaxonomy.taxeditor.ITaxEditorConstants; +import eu.etaxonomy.taxeditor.actions.cdm.CreateNameRelationAction; + +/** + * @author p.ciardelli + * @created 04.06.2008 + * @version 1.0 + */ +public class NameRelationWizard extends Wizard { + private static final Logger logger = Logger + .getLogger(NameRelationWizard.class); + + public static final String ID = "eu.etaxonomy.taxeditor.namerelationwizard"; + + private NameRelationWizardModel relationModel; + + public NameRelationWizard(NameRelationWizardModel relationModel) { + super(); + + this.relationModel = relationModel; + } + + public void addPages() { + IWizardPage chooseNamePage = new ChooseRelatedNameWizardPage(relationModel); + addPage(chooseNamePage); + IWizardPage chooseRelationPage = new ChooseRelationTypeWizardPage(relationModel); + addPage(chooseRelationPage); + } + + @Override + public boolean performFinish() { + CreateNameRelationAction nameRelationAction = new CreateNameRelationAction(relationModel.getFromName(), + relationModel.getType(), + relationModel.getToName()); +// if (relationModel.getNameRelationsList() != null) { + + // Action will notify when relation has been created + nameRelationAction.addPropertyChangeListener(new IPropertyChangeListener() { + @Override + public void propertyChange(PropertyChangeEvent event) { + logger.warn(event.getProperty()); + if (event.getProperty().equals( + ITaxEditorConstants.NAMERELATION)) { + logger.warn("checking name relations list"); + if (relationModel.getNameRelationsList() != null) { + logger.warn("clearing name relations"); + relationModel.getNameRelationsList().clear(); + relationModel.getNameRelationsList().addAll(relationModel.getBaseName().getNameRelations()); + } + } + + } + }); +// } + nameRelationAction.run(); + return true; + } +} diff --git a/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/NameRelationWizardModel.java b/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/NameRelationWizardModel.java new file mode 100644 index 000000000..34be929f8 --- /dev/null +++ b/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/NameRelationWizardModel.java @@ -0,0 +1,130 @@ +/** + * Copyright (C) 2007 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.propertysheet.namerelationswizard; + +import java.beans.PropertyChangeListener; +import java.beans.PropertyChangeSupport; +import java.util.List; + +import org.apache.log4j.Logger; + +import eu.etaxonomy.cdm.model.name.NameRelationship; +import eu.etaxonomy.cdm.model.name.NameRelationshipType; +import eu.etaxonomy.cdm.model.name.TaxonNameBase; +import eu.etaxonomy.taxeditor.model.CdmUtil; + +/** + * @author p.ciardelli + * @created 05.06.2008 + * @version 1.0 + */ +public class NameRelationWizardModel { + private static final Logger logger = Logger + .getLogger(NameRelationWizardModel.class); + + protected static final String RELATEDNAME = "relatedname"; + protected static final String RELATIONTYPE = "relationtype"; + + private TaxonNameBase baseName; + private TaxonNameBase relatedName; + + private TaxonNameBase fromName; + private TaxonNameBase toName; + private NameRelationshipType type; + + // Stores pre-existing relation, if any exists + private NameRelationship nameRelationship; + // List of the base name's relations + private List nameRelationsList; + + private PropertyChangeSupport propertyChangeSupport; + + + public NameRelationWizardModel(TaxonNameBase baseName) { + this.baseName = baseName; + this.propertyChangeSupport = new PropertyChangeSupport(this); + } + + private void firePropertyChange(String propertyName, Object oldValue, + Object newValue) { + propertyChangeSupport.firePropertyChange(propertyName, oldValue, + newValue); + } + + public void addPropertyChangeListener(String propertyName, + PropertyChangeListener listener) { + propertyChangeSupport.addPropertyChangeListener(propertyName, listener); + } + + public void addPropertyChangeListener(PropertyChangeListener listener) { + propertyChangeSupport.addPropertyChangeListener(listener); + } + + public TaxonNameBase getBaseName() { + return baseName; + } + + public void setBaseName(TaxonNameBase baseName) { + this.baseName = baseName; + } + + public TaxonNameBase getRelatedName() { + return relatedName; + } + + public void setRelatedName(TaxonNameBase relatedName) { + this.relatedName = relatedName; + firePropertyChange(RELATEDNAME, null, relatedName); + } + + public TaxonNameBase getFromName() { + return fromName; + } + + public void setFromName(TaxonNameBase fromName) { + this.fromName = fromName; + logger.warn("Setting from name: " + CdmUtil.getDisplayName(fromName)); + } + + public TaxonNameBase getToName() { + return toName; + } + + public void setToName(TaxonNameBase toName) { + this.toName = toName; + logger.warn("Setting to name: " + CdmUtil.getDisplayName(toName)); + } + + public NameRelationshipType getType() { + return type; + } + + public void setType(NameRelationshipType type) { + this.type = type; + firePropertyChange(RELATIONTYPE, null, type); + } + + public void setRelation(NameRelationship nameRelationship) { + this.nameRelationship = nameRelationship; + } + + public NameRelationship getRelation() { + return nameRelationship; + } + + public void setNameRelationsList(List nameRelationsList) { + this.nameRelationsList = nameRelationsList; + } + + public List getNameRelationsList() { + return nameRelationsList; + } + +} diff --git a/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/NameRelationsListWizard.java b/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/NameRelationsListWizard.java new file mode 100644 index 000000000..7152a1b31 --- /dev/null +++ b/eclipseprojects/eu.etaxonomy.taxeditor/src/eu/etaxonomy/taxeditor/propertysheet/namerelationswizard/NameRelationsListWizard.java @@ -0,0 +1,47 @@ +/** +* Copyright (C) 2007 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.propertysheet.namerelationswizard; + +import org.apache.log4j.Logger; +import org.eclipse.jface.wizard.IWizardPage; +import org.eclipse.jface.wizard.Wizard; + +import eu.etaxonomy.cdm.model.name.TaxonNameBase; + +/** + * @author p.ciardelli + * @created 06.06.2008 + * @version 1.0 + */ +public class NameRelationsListWizard extends Wizard { + private static final Logger logger = Logger + .getLogger(NameRelationsListWizard.class); + + private TaxonNameBase name; + + public NameRelationsListWizard(TaxonNameBase name) { + super(); + + this.name = name; + } + + public void addPages() { + IWizardPage chooseNamePage = new ListNameRelationsWizardPage(name); + addPage(chooseNamePage); + } + + /* (non-Javadoc) + * @see org.eclipse.jface.wizard.Wizard#performFinish() + */ + @Override + public boolean performFinish() { + return true; + } +} -- 2.34.1