taxeditor-store/src/main/java/eu/etaxonomy/taxeditor/datasource/wizard/CdmDataSourceTypeSelectionWizardPage.java -text
taxeditor-store/src/main/java/eu/etaxonomy/taxeditor/datasource/wizard/CdmDataSourceWizard.java -text
taxeditor-store/src/main/java/eu/etaxonomy/taxeditor/dialogs/LoginDialog.java -text
-taxeditor-store/src/main/java/eu/etaxonomy/taxeditor/dialogs/NewReferenceInputDialog.java -text
taxeditor-store/src/main/java/eu/etaxonomy/taxeditor/dialogs/UriDialog.java -text
taxeditor-store/src/main/java/eu/etaxonomy/taxeditor/featuretree/AvailableFeaturesWizard.java -text
taxeditor-store/src/main/java/eu/etaxonomy/taxeditor/featuretree/AvailableFeaturesWizardPage.java -text
taxeditor-store/src/main/java/eu/etaxonomy/taxeditor/featuretree/SelectFeatureTreeWizard.java -text
taxeditor-store/src/main/java/eu/etaxonomy/taxeditor/featuretree/SelectFeatureTreeWizardPage.java -text
taxeditor-store/src/main/java/eu/etaxonomy/taxeditor/handler/ShowDataSourceViewHandler.java -text
+taxeditor-store/src/main/java/eu/etaxonomy/taxeditor/handler/ShowErrorViewHandler.java -text
taxeditor-store/src/main/java/eu/etaxonomy/taxeditor/handler/ShowLoginWindowHandler.java -text
taxeditor-store/src/main/java/eu/etaxonomy/taxeditor/handler/ShowUserManagerViewHandler.java -text
taxeditor-store/src/main/java/eu/etaxonomy/taxeditor/io/AbstractIOHandler.java -text
Require-Bundle: org.eclipse.osgi,
eu.etaxonomy.cdmlib,
org.eclipse.ui,
- org.eclipse.jface.text
+ org.eclipse.jface.text,
+ org.eclipse.pde.runtime
Import-Package: junit.framework,
org.eclipse.core.commands,
org.eclipse.core.commands.operations,
name="User Manager"
restorable="true">
</view>
+ <view
+ name="Progress View"
+ icon="icons/pview.gif"
+ category="org.eclipse.ui"
+ class="org.eclipse.ui.ExtensionFactory:progressView"
+ id="org.eclipse.ui.views.ProgressView">
+ </view>
+ <view
+ name="Error View"
+ icon="icons/pview.gif"
+ category="org.eclipse.ui"
+ class="org.eclipse.ui.ExtensionFactory:logView"
+ id="org.eclipse.ui.views.LogView">
+ </view>
</extension>
<extension
point="org.eclipse.ui.menus">
label="User Manager"
style="push">
</command>
+ <command
+ commandId="eu.etaxonomy.taxeditor.store.operations.showErrorView"
+ label="Error"
+ style="push">
+ </command>
</menu>
<command
commandId="eu.etaxonomy.taxeditor.store.operations.showLoginWindow"
id="eu.etaxonomy.taxeditor.store.operations.showUserManagerView"
name="Show User Manager View">
</command>
+ <command
+ defaultHandler="eu.etaxonomy.taxeditor.handler.ShowErrorViewHandler"
+ id="eu.etaxonomy.taxeditor.store.operations.showErrorView"
+ name="Show Error View">
+ </command>
<command
defaultHandler="eu.etaxonomy.taxeditor.handler.ShowLoginWindowHandler"
id="eu.etaxonomy.taxeditor.store.operations.showLoginWindow"
name="testCategory">
</category>
</extension>
- <extension
- point="org.eclipse.ui.views">
- <view
- name="Progress View"
- icon="icons/pview.gif"
- category="org.eclipse.ui"
- class="org.eclipse.ui.ExtensionFactory:progressView"
- id="org.eclipse.ui.views.ProgressView">
- </view>
- </extension>
<extension
point="org.eclipse.ui.themes">
<themeElementCategory
import eu.etaxonomy.taxeditor.store.StoreUtil;\r
import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;\r
\r
-public class CdmDataSourceRepository{\r
- private static final Logger logger = Logger\r
- .getLogger(CdmDataSourceRepository.class);\r
+public class CdmDataSourceRepository{;\r
\r
public static final String TAG_DATASOURCE = "tagDataSource";\r
private static final String CURRENT_DATASOURCE = "currentDataSource";\r
try {\r
dataSources.add(CdmPersistentDataSource.NewInstance(dataSource.getName()));\r
} catch (DataSourceNotFoundException e) {\r
- logger.error("Could not find dataSource", e);\r
+ StoreUtil.error(CdmDataSourceRepository.class, "Could not find dataSource", e);\r
}\r
}\r
\r
return CdmPersistentDataSource.NewInstance(dataSource.getName());\r
}\r
} catch (DataSourceNotFoundException e) {\r
- logger.error("Could not find dataSource", e);\r
+ StoreUtil.error(CdmDataSourceRepository.class, "Could not find dataSource", e);\r
}\r
}\r
\r
try {\r
return CdmPersistentDataSource.update(strDataSourceName, dataSource);\r
} catch (Exception e) {\r
- logger.error("Error updating datasource", e);\r
+ StoreUtil.error(CdmDataSourceRepository.class, "Error updating datasource", e);\r
}\r
return null;\r
}\r
package eu.etaxonomy.taxeditor.datasource.handler;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.ui.PartInitException;
import org.eclipse.ui.handlers.HandlerUtil;
import eu.etaxonomy.taxeditor.datasource.view.CdmDataSourceViewPart;
* @version 1.0
*/
abstract class AbstractDataSourceHandler extends AbstractHandler {
- private static final Logger logger = Logger
- .getLogger(AbstractDataSourceHandler.class);
/* (non-Javadoc)
* @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)
CdmMetaDataAwareDataSourceContainer container = (CdmMetaDataAwareDataSourceContainer) ((IStructuredSelection) selection).getFirstElement();
if(!container.isRunning()){
- StoreUtil.warningDialog("Chosen datasource is not available", "This could mean that either the database server is " +
+ StoreUtil.warningDialog("Chosen datasource is not available", this, "This could mean that either the database server is " +
"not running or the machine is not reachable.\n\n" +
"Please also make sure that you are connected to the network when trying to connect to a remote datasource.");
return null;
package eu.etaxonomy.taxeditor.datasource.handler;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Shell;
-import org.eclipse.ui.IViewPart;
import org.eclipse.ui.handlers.HandlerUtil;
-import eu.etaxonomy.cdm.database.CdmDataSource;
import eu.etaxonomy.taxeditor.datasource.view.CdmDataSourceViewPart;
import eu.etaxonomy.taxeditor.store.CdmStore;
import eu.etaxonomy.taxeditor.store.StoreUtil;
* @version 1.0
*/
public class CloseConnectionHandler extends AbstractHandler {
- private static final Logger logger = Logger
- .getLogger(CloseConnectionHandler.class);
/* (non-Javadoc)
* @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)
package eu.etaxonomy.taxeditor.datasource.handler;
-import org.apache.log4j.Logger;
import org.eclipse.core.expressions.PropertyTester;
import org.eclipse.jface.viewers.IStructuredSelection;
* @version 1.0
*/
public class DataSourceMenuPropertyTester extends PropertyTester {
- private static final Logger logger = Logger
- .getLogger(DataSourceMenuPropertyTester.class);
private static final String COMPATIBLE = "isCompatible";
package eu.etaxonomy.taxeditor.datasource.handler;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
* @version 1.0
*/
public class UpdateDataSourceHandler extends AbstractDataSourceHandler {
- private static final Logger logger = Logger
- .getLogger(UpdateDataSourceHandler.class);
-
+
/* (non-Javadoc)
* @see eu.etaxonomy.taxeditor.datasource.handler.AbstractDataSourceHandler#specificExecute(org.eclipse.core.commands.ExecutionEvent)
*/
package eu.etaxonomy.taxeditor.datasource.view;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.swt.graphics.Image;
* @version 1.0
*/
public class CdmDataSourceLabelProvider extends LabelProvider implements ITableLabelProvider {
- private static final Logger logger = Logger
- .getLogger(CdmDataSourceLabelProvider.class);
-
-
/*
* (non-Javadoc)
import java.util.ArrayList;
import java.util.List;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.Command;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.NotEnabledException;
}
}
- private static final Logger logger = Logger.getLogger(CdmDataSourceViewPart.class);
-
public static String ID = "eu.etaxonomy.taxeditor.store.datasource.datasourceView";
private TableViewer viewer;
try {
handlerService.executeCommand(commandId, null);
} catch (ExecutionException e) {
- logger.error(e);
+ StoreUtil.error(this.getClass(), e);
} catch (NotDefinedException e) {
- logger.error(e);
+ StoreUtil.error(this.getClass(), e);
} catch (NotEnabledException e) {
- logger.error(e);
+ StoreUtil.error(this.getClass(), e);
} catch (NotHandledException e) {
- logger.error(e);
+ StoreUtil.error(this.getClass(), e);
}
}
}
try {
StoreUtil.runInUI(new DataSourceRunnable(Display.getCurrent(), CdmDataSourceRepository.getAll()), null);
} catch (InvocationTargetException e) {
- logger.error(e);
+ StoreUtil.error(this.getClass(), e);
} catch (InterruptedException e) {
- logger.error(e);
+ StoreUtil.error(this.getClass(), e);
}
}
import java.util.HashMap;
import java.util.Map;
-import org.apache.log4j.Logger;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import eu.etaxonomy.cdm.database.ICdmDataSource;
import eu.etaxonomy.cdm.model.common.CdmMetaData;
import eu.etaxonomy.cdm.model.common.CdmMetaData.MetaDataPropertyName;
+import eu.etaxonomy.taxeditor.store.StoreUtil;
/**
* @author n.hoffmann
* @version 1.0
*/
public class CdmMetaDataAwareDataSourceContainer {
- private static final Logger logger = Logger
- .getLogger(CdmMetaDataAwareDataSourceContainer.class);
private class MetaDataJob extends Job{
}
dataSource.closeOpenConnections();
} catch (SQLException e) {
- logger.error("SQLException when trying to access: " + dataSource.getName() + ". " + e.getMessage());
+ StoreUtil.error(this.getClass(), "SQLException when trying to access: " + dataSource.getName() + ". ", e);
}
}
} catch (Exception e) {
- logger.error(e);
+ StoreUtil.error(this.getClass(), e);
}
}
package eu.etaxonomy.taxeditor.datasource.wizard;
-import org.apache.log4j.Logger;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
* @version 1.0
*/
public class CdmDataSourceMySQLWizardPage extends CdmDataSourceCredentialsWizardPage {
-
-
- private static final Logger logger = Logger
- .getLogger(CdmDataSourceMySQLWizardPage.class);
private Text text_port;
private Text text_server;
package eu.etaxonomy.taxeditor.datasource.wizard;
-import org.apache.log4j.Logger;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
*/
public class CdmDataSourceSQLServerWizardPage extends CdmDataSourceCredentialsWizardPage {
-
- private static final Logger logger = Logger
- .getLogger(CdmDataSourceSQLServerWizardPage.class);
-
private Text text_port;
private Text text_server;
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.Combo;
import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import eu.etaxonomy.cdm.database.ICdmDataSource;
import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
import eu.etaxonomy.taxeditor.datasource.CdmDataSourceRepository;
-import eu.etaxonomy.taxeditor.model.NomenclaturalCodeHelper;
-import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
/**
* @author n.hoffmann
CdmStore.getLoginManager().authenticate(token);
}catch(BadCredentialsException e){
logger.error("Bad credentials", e);
- StoreUtil.warningDialog("Could not authenticate", "Could not authenticate. Reason: Bad Credentials.");
+ StoreUtil.warningDialog("Could not authenticate", this, "Could not authenticate. Reason: Bad Credentials.");
}catch(LockedException e){
logger.error("Account is locked", e);
- StoreUtil.warningDialog("Could not authenticate", "Could not authenticate. Reason: Account is locked.");
+ StoreUtil.warningDialog("Could not authenticate", this, "Could not authenticate. Reason: Account is locked.");
}catch(IllegalArgumentException e){
logger.error("Null argument for either user or password", e);
- StoreUtil.warningDialog("Could not authenticate", "Could not authenticate. Reason: Username and/or Password empty.");
+ StoreUtil.warningDialog("Could not authenticate", this, "Could not authenticate. Reason: Username and/or Password empty.");
}
super.okPressed();
+++ /dev/null
-/*******************************************************************************\r
- * Copyright (c) 2000, 2008 IBM Corporation and others.\r
- * All rights reserved. This program and the accompanying materials\r
- * are made available under the terms of the Eclipse Public License v1.0\r
- * which accompanies this distribution, and is available at\r
- * http://www.eclipse.org/legal/epl-v10.html\r
- *\r
- * Contributors:\r
- * IBM Corporation - initial API and implementation\r
- *******************************************************************************/\r
-package eu.etaxonomy.taxeditor.dialogs;\r
-\r
-import java.util.Arrays;\r
-import java.util.List;\r
-\r
-import org.apache.log4j.Logger;\r
-import org.eclipse.jface.dialogs.Dialog;\r
-import org.eclipse.jface.dialogs.IDialogConstants;\r
-import org.eclipse.jface.dialogs.IInputValidator;\r
-import org.eclipse.jface.resource.StringConverter;\r
-import org.eclipse.swt.SWT;\r
-import org.eclipse.swt.events.ModifyEvent;\r
-import org.eclipse.swt.events.ModifyListener;\r
-import org.eclipse.swt.layout.GridData;\r
-import org.eclipse.swt.widgets.Button;\r
-import org.eclipse.swt.widgets.Combo;\r
-import org.eclipse.swt.widgets.Composite;\r
-import org.eclipse.swt.widgets.Control;\r
-import org.eclipse.swt.widgets.Label;\r
-import org.eclipse.swt.widgets.Shell;\r
-import org.eclipse.swt.widgets.Text;\r
-\r
-import eu.etaxonomy.cdm.model.reference.ReferenceBase;\r
-import eu.etaxonomy.cdm.model.reference.ReferenceFactory;\r
-import eu.etaxonomy.cdm.model.reference.ReferenceType;\r
-\r
-/**\r
- * A simple input dialog for soliciting an input string from the user.\r
- * <p>\r
- * This concrete dialog class can be instantiated as is, or further subclassed as\r
- * required.\r
- * </p>\r
- * \r
- * TODO Replace this with a proper wizard that allows for sophisticated reference editing\r
- */\r
-public class NewReferenceInputDialog extends Dialog {\r
- private static final Logger logger = Logger\r
- .getLogger(NewReferenceInputDialog.class);\r
- \r
- /**\r
- * The title of the dialog.\r
- */\r
- private String title;\r
-\r
- /**\r
- * The message to display, or <code>null</code> if none.\r
- */\r
- private String message;\r
-\r
- /**\r
- * The input value; the empty string by default.\r
- */\r
- private String value = "";//$NON-NLS-1$\r
-\r
- /**\r
- * The input validator, or <code>null</code> if none.\r
- */\r
- private IInputValidator validator;\r
-\r
- /**\r
- * Ok button widget.\r
- */\r
- private Button okButton;\r
-\r
- /**\r
- * Input text widget.\r
- */\r
- private Text refText;\r
-\r
- /**\r
- * Error message label widget.\r
- */\r
- private Text errorMessageText;\r
- \r
- /**\r
- * Error message string.\r
- */\r
- private String errorMessage;\r
-\r
- private String message2;\r
-\r
- private ReferenceBase reference = null;\r
-\r
- /**\r
- * Creates an input dialog with OK and Cancel buttons. Note that the dialog\r
- * will have no visual representation (no widgets) until it is told to open.\r
- * <p>\r
- * Note that the <code>open</code> method blocks for input dialogs.\r
- * </p>\r
- * \r
- * @param parentShell\r
- * the parent shell, or <code>null</code> to create a top-level\r
- * shell\r
- * @param dialogTitle\r
- * the dialog title, or <code>null</code> if none\r
- * @param dialogMessage\r
- * the dialog message, or <code>null</code> if none\r
- * @param initialValue\r
- * the initial input value, or <code>null</code> if none\r
- * (equivalent to the empty string)\r
- * @param validator\r
- * an input validator, or <code>null</code> if none\r
- */\r
- public NewReferenceInputDialog(Shell parentShell) {\r
- super(parentShell);\r
- this.title = "Create reference";\r
- this.message = "Choose a reference type:";\r
- this.message2 = "Enter a title cache:";\r
- }\r
-\r
- /*\r
- * (non-Javadoc) Method declared on Dialog.\r
- */\r
- protected void buttonPressed(int buttonId) {\r
- if (buttonId == IDialogConstants.OK_ID) {\r
- createReference();\r
- value = refText.getText();\r
- } else {\r
- value = null;\r
- }\r
- super.buttonPressed(buttonId);\r
- }\r
-\r
- /**\r
- * \r
- */\r
- private void createReference() {\r
- String key = refCombo.getText();\r
- \r
- // TODO replace w more generic method when cdmlib matures accordingly\r
- if (ReferenceType.Article.getMessage().equals(key)) {\r
- reference = ReferenceFactory.newArticle();\r
- }\r
- else if (ReferenceType.Book.getMessage().equals(key)) {\r
- reference = ReferenceFactory.newBook();\r
- }\r
- else if (ReferenceType.BookSection.getMessage().equals(key)) {\r
- reference = ReferenceFactory.newBookSection();\r
- }\r
- else if (ReferenceType.CdDvd.getMessage().equals(key)) {\r
- reference = ReferenceFactory.newCdDvd();\r
- }\r
- else if (ReferenceType.Database.getMessage().equals(key)) {\r
- reference = ReferenceFactory.newDatabase();\r
- }\r
- else if (ReferenceType.Generic.getMessage().equals(key)) {\r
- reference = ReferenceFactory.newGeneric();\r
- }\r
- else if (ReferenceType.InProceedings.getMessage().equals(key)) {\r
- reference = ReferenceFactory.newInProceedings();\r
- }\r
- else if (ReferenceType.Journal.getMessage().equals(key)) {\r
- reference = ReferenceFactory.newJournal();\r
- }\r
- else if (ReferenceType.Map.getMessage().equals(key)) {\r
- reference = ReferenceFactory.newMap();\r
- }\r
- else if (ReferenceType.Patent.getMessage().equals(key)) {\r
- reference = ReferenceFactory.newPatent();\r
- }\r
- else if (ReferenceType.PersonalCommunication.getMessage().equals(key)) {\r
- reference = ReferenceFactory.newPersonalCommunication();\r
- }\r
- else if (ReferenceType.PrintSeries.getMessage().equals(key)) {\r
- reference = ReferenceFactory.newPrintSeries();\r
- }\r
- else if (ReferenceType.Proceedings.getMessage().equals(key)) {\r
- reference = ReferenceFactory.newProceedings();\r
- }\r
- else if (ReferenceType.Report.getMessage().equals(key)) {\r
- reference = ReferenceFactory.newReport();\r
- }\r
- else if (ReferenceType.Thesis.getMessage().equals(key)) {\r
- reference = ReferenceFactory.newThesis();\r
- }\r
- else if (ReferenceType.WebPage.getMessage().equals(key)) {\r
- reference = ReferenceFactory.newWebPage();\r
- }\r
- \r
- // fill the cache\r
- if (reference != null) {\r
- reference.setTitleCache(refText.getText(), true);\r
- }\r
- }\r
-\r
- /*\r
- * (non-Javadoc)\r
- * \r
- * @see org.eclipse.jface.window.Window#configureShell(org.eclipse.swt.widgets.Shell)\r
- */\r
- protected void configureShell(Shell shell) {\r
- super.configureShell(shell);\r
- if (title != null) {\r
- shell.setText(title);\r
- }\r
- }\r
-\r
- /*\r
- * (non-Javadoc)\r
- * \r
- * @see org.eclipse.jface.dialogs.Dialog#createButtonsForButtonBar(org.eclipse.swt.widgets.Composite)\r
- */\r
- protected void createButtonsForButtonBar(Composite parent) {\r
- // create OK and Cancel buttons by default\r
- okButton = createButton(parent, IDialogConstants.OK_ID,\r
- IDialogConstants.OK_LABEL, true);\r
- createButton(parent, IDialogConstants.CANCEL_ID,\r
- IDialogConstants.CANCEL_LABEL, false);\r
- //do this here because setting the text will set enablement on the ok\r
- // button\r
- refText.setFocus();\r
- if (value != null) {\r
- refText.setText(value);\r
- refText.selectAll();\r
- }\r
- }\r
-\r
- private Combo refCombo;\r
-\r
- private List<ReferenceType> refTypes;\r
- \r
- /*\r
- * (non-Javadoc) Method declared on Dialog.\r
- */\r
- protected Control createDialogArea(Composite parent) {\r
- // create composite\r
- Composite composite = (Composite) super.createDialogArea(parent);\r
- // create message\r
- Label label = new Label(composite, SWT.WRAP);\r
- label.setText(message);\r
- GridData data = new GridData(GridData.GRAB_HORIZONTAL\r
- | GridData.GRAB_VERTICAL | GridData.HORIZONTAL_ALIGN_FILL\r
- | GridData.VERTICAL_ALIGN_CENTER);\r
- data.widthHint = convertHorizontalDLUsToPixels(IDialogConstants.MINIMUM_MESSAGE_AREA_WIDTH);\r
- label.setLayoutData(data);\r
- label.setFont(parent.getFont());\r
- refCombo = new Combo(composite, SWT.NONE | SWT.READ_ONLY);\r
- refCombo.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL\r
- | GridData.HORIZONTAL_ALIGN_FILL));\r
- refCombo.addModifyListener(new ModifyListener() {\r
- public void modifyText(ModifyEvent e) {\r
- validateInput();\r
- }\r
- });\r
- // create message\r
- Label label2 = new Label(composite, SWT.WRAP);\r
- label2.setText(message2);\r
- GridData data2 = new GridData(GridData.GRAB_HORIZONTAL\r
- | GridData.GRAB_VERTICAL | GridData.HORIZONTAL_ALIGN_FILL\r
- | GridData.VERTICAL_ALIGN_CENTER);\r
- data2.widthHint = convertHorizontalDLUsToPixels(IDialogConstants.MINIMUM_MESSAGE_AREA_WIDTH);\r
- label2.setLayoutData(data);\r
- label2.setFont(parent.getFont());\r
- // create text\r
- refText = new Text(composite, getInputTextStyle());\r
- refText.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL\r
- | GridData.HORIZONTAL_ALIGN_FILL));\r
- refText.addModifyListener(new ModifyListener() {\r
- public void modifyText(ModifyEvent e) {\r
- validateInput();\r
- }\r
- });\r
- errorMessageText = new Text(composite, SWT.READ_ONLY | SWT.WRAP);\r
- errorMessageText.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL\r
- | GridData.HORIZONTAL_ALIGN_FILL));\r
- errorMessageText.setBackground(errorMessageText.getDisplay()\r
- .getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));\r
- // Set the error message text\r
- // See https://bugs.eclipse.org/bugs/show_bug.cgi?id=66292\r
- setErrorMessage(errorMessage);\r
- applyDialogFont(composite);\r
- \r
- populateReferences();\r
- \r
- return composite;\r
- }\r
-\r
- /**\r
- * \r
- */\r
- private void populateReferences() {\r
- refTypes = Arrays.asList(ReferenceType.values());\r
- for (ReferenceType type : refTypes) {\r
- refCombo.add(type.getMessage());\r
- }\r
- refCombo.select(0);\r
- }\r
-\r
- /**\r
- * Returns the error message label.\r
- * \r
- * @return the error message label\r
- * @deprecated use setErrorMessage(String) instead\r
- */\r
- protected Label getErrorMessageLabel() {\r
- return null;\r
- }\r
-\r
- /**\r
- * Returns the ok button.\r
- * \r
- * @return the ok button\r
- */\r
- protected Button getOkButton() {\r
- return okButton;\r
- }\r
-\r
- /**\r
- * Returns the text area.\r
- * \r
- * @return the text area\r
- */\r
- protected Text getText() {\r
- return refText;\r
- }\r
-\r
- /**\r
- * Returns the validator.\r
- * \r
- * @return the validator\r
- */\r
- protected IInputValidator getValidator() {\r
- return validator;\r
- }\r
-\r
- /**\r
- * Validates the input.\r
- * <p>\r
- * The default implementation of this framework method delegates the request\r
- * to the supplied input validator object; if it finds the input invalid,\r
- * the error message is displayed in the dialog's message line. This hook\r
- * method is called whenever the text changes in the input field.\r
- * </p>\r
- */\r
- protected void validateInput() {\r
- String errorMessage = null;\r
- if (validator != null) {\r
- errorMessage = validator.isValid(refText.getText());\r
- }\r
- // Bug 16256: important not to treat "" (blank error) the same as null\r
- // (no error)\r
- setErrorMessage(errorMessage);\r
- }\r
-\r
- /**\r
- * Sets or clears the error message.\r
- * If not <code>null</code>, the OK button is disabled.\r
- * \r
- * @param errorMessage\r
- * the error message, or <code>null</code> to clear\r
- * @since 3.0\r
- */\r
- public void setErrorMessage(String errorMessage) {\r
- this.errorMessage = errorMessage;\r
- if (errorMessageText != null && !errorMessageText.isDisposed()) {\r
- errorMessageText.setText(errorMessage == null ? " \n " : errorMessage); //$NON-NLS-1$\r
- // Disable the error message text control if there is no error, or\r
- // no error text (empty or whitespace only). Hide it also to avoid\r
- // color change.\r
- // See https://bugs.eclipse.org/bugs/show_bug.cgi?id=130281\r
- boolean hasError = errorMessage != null && (StringConverter.removeWhiteSpaces(errorMessage)).length() > 0;\r
- errorMessageText.setEnabled(hasError);\r
- errorMessageText.setVisible(hasError);\r
- errorMessageText.getParent().update();\r
- // Access the ok button by id, in case clients have overridden button creation.\r
- // See https://bugs.eclipse.org/bugs/show_bug.cgi?id=113643\r
- Control button = getButton(IDialogConstants.OK_ID);\r
- if (button != null) {\r
- button.setEnabled(errorMessage == null);\r
- }\r
- }\r
- }\r
- \r
- /**\r
- * Returns the style bits that should be used for the input text field.\r
- * Defaults to a single line entry. Subclasses may override.\r
- * \r
- * @return the integer style bits that should be used when creating the\r
- * input text\r
- * \r
- * @since 3.4\r
- */\r
- protected int getInputTextStyle() {\r
- return SWT.SINGLE | SWT.BORDER;\r
- }\r
-\r
- /**\r
- * @return\r
- */\r
- public ReferenceBase getReference() { \r
- return reference;\r
- }\r
-}\r
import java.util.Set;
-import org.apache.log4j.Logger;
import org.eclipse.jface.wizard.Wizard;
import eu.etaxonomy.cdm.model.description.Feature;
* @version 1.0
*/
public class AvailableFeaturesWizard extends Wizard {
- private static final Logger logger = Logger
- .getLogger(AvailableFeaturesWizard.class);
private FeatureTree featureTree;
import java.util.HashSet;
import java.util.Set;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
*/
public class AvailableFeaturesWizardPage extends WizardPage {
-
- private static final Logger logger = Logger
- .getLogger(AvailableFeaturesWizardPage.class);
private CheckboxTableViewer viewer;
protected AvailableFeaturesWizardPage(FeatureTree featureTree) {
import java.util.Collection;
-import org.apache.log4j.Logger;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
*/
public class EditFeatureTreeWizardPage extends WizardPage implements ModifyListener, ISelectionChangedListener{
- private static final Logger logger = Logger
- .getLogger(EditFeatureTreeWizardPage.class);
private TreeViewer viewer;
private Label label_title;
private Text text_title;
// cannot drop a feature node onto itself
for (FeatureNode droppedNode : droppedNodes) {
if (droppedNode == null){
- StoreUtil.warningDialog("Operation not supported yet", "We are currently unable to change the order of freshly created " +
+ StoreUtil.warningDialog("Operation not supported yet", this, "We are currently unable to change the order of freshly created " +
"feature trees nodes. Please close and reopen the dialog to change the order of features.");
return false;
}
import java.util.List;
import java.util.UUID;
-import org.apache.log4j.Logger;
import org.eclipse.swt.dnd.ByteArrayTransfer;
import org.eclipse.swt.dnd.TransferData;
* @version 1.0
*/
public class FeatureNodeTransfer extends ByteArrayTransfer {
- private static final Logger logger = Logger
- .getLogger(FeatureNodeTransfer.class);
private static FeatureNodeTransfer instance = new FeatureNodeTransfer();
private static final String TYPE_NAME = "featureNode-transfer-format";
import java.util.List;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;
* @version 1.0
*/
public class FeatureTreeContentProvider implements ITreeContentProvider {
- private static final Logger logger = Logger
- .getLogger(FeatureTreeContentProvider.class);
/* (non-Javadoc)
* @see org.eclipse.jface.viewers.IContentProvider#dispose()
package eu.etaxonomy.taxeditor.featuretree;
-import org.apache.log4j.Logger;
import org.eclipse.jface.wizard.Wizard;
import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
* @version 1.0
*/
public class FeatureTreeEditorWizard extends Wizard {
-
- private static final Logger logger = Logger
- .getLogger(FeatureTreeEditorWizard.class);
private SelectFeatureTreeWizardPage selectFeatureTreePage;
private EditFeatureTreeWizardPage editFeatureTreePage;
package eu.etaxonomy.taxeditor.featuretree;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.LabelProvider;
import eu.etaxonomy.cdm.model.description.Feature;
* @version 1.0
*/
public class FeatureTreeLabelProvider extends LabelProvider {
- private static final Logger logger = Logger
- .getLogger(FeatureTreeLabelProvider.class);
private Feature feature;
package eu.etaxonomy.taxeditor.featuretree;
-import org.apache.log4j.Logger;
import org.eclipse.jface.wizard.Wizard;
/**
* @version 1.0
*/
public class SelectFeatureTreeWizard extends Wizard {
- private static final Logger logger = Logger
- .getLogger(SelectFeatureTreeWizard.class);
public static final String PAGE_NAME = "Select Feature Tree";
import java.util.List;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ListViewer;
*/
public class SelectFeatureTreeWizardPage extends WizardPage implements ISelectionChangedListener, ModifyListener{
-
- private static final Logger logger = Logger
- .getLogger(SelectFeatureTreeWizardPage.class);
private ListViewer viewer;
private Text text_title;
private Button button_add;
package eu.etaxonomy.taxeditor.handler;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.ui.PartInitException;
import eu.etaxonomy.taxeditor.datasource.view.CdmDataSourceViewPart;
+import eu.etaxonomy.taxeditor.store.StoreUtil;
import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;
/**
* @version 1.0
*/
public class ShowDataSourceViewHandler extends AbstractHandler implements IHandler {
- private static final Logger logger = Logger
- .getLogger(ShowDataSourceViewHandler.class);
-
public Object execute(ExecutionEvent event) throws ExecutionException {
try {
.getActiveWorkbenchWindow().getActivePage().showView(CdmDataSourceViewPart.ID,
null, IWorkbenchPage.VIEW_VISIBLE);
} catch (PartInitException e) {
- logger.error("Error opening data source view.", e);
+ StoreUtil.error(this.getClass(), "Error opening data source view.", e);
}
return null;
}
--- /dev/null
+// $Id$
+/**
+* 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.handler;
+
+import org.eclipse.core.commands.AbstractHandler;
+import org.eclipse.core.commands.ExecutionEvent;
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.ui.IWorkbenchPage;
+import org.eclipse.ui.PartInitException;
+
+import eu.etaxonomy.taxeditor.store.StoreUtil;
+import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;
+
+/**
+ * @author n.hoffmann
+ * @created Oct 13, 2010
+ * @version 1.0
+ */
+public class ShowErrorViewHandler extends AbstractHandler {
+
+ /* (non-Javadoc)
+ * @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)
+ */
+ @Override
+ public Object execute(ExecutionEvent arg0) throws ExecutionException {
+ try {
+ TaxeditorStorePlugin.getDefault().getWorkbench()
+ .getActiveWorkbenchWindow().getActivePage().showView("org.eclipse.pde.runtime.LogView",
+ null, IWorkbenchPage.VIEW_VISIBLE);
+ } catch (PartInitException e) {
+ StoreUtil.error(this.getClass(), e);
+ }
+ return null;
+ }
+}
* @version 1.0
*/
public class ShowLoginWindowHandler extends AbstractHandler implements IHandler{
- private static final Logger logger = Logger
- .getLogger(ShowLoginWindowHandler.class);
/* (non-Javadoc)
* @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)
package eu.etaxonomy.taxeditor.handler;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PartInitException;
+import eu.etaxonomy.taxeditor.store.StoreUtil;
import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;
import eu.etaxonomy.taxeditor.user.view.UserManagerView;
* @version 1.0
*/
public class ShowUserManagerViewHandler extends AbstractHandler implements IHandler{
- private static final Logger logger = Logger
- .getLogger(ShowUserManagerViewHandler.class);
public Object execute(ExecutionEvent event) throws ExecutionException {
try {
.getActiveWorkbenchWindow().getActivePage().showView(UserManagerView.ID,
null, IWorkbenchPage.VIEW_VISIBLE);
} catch (PartInitException e) {
- logger.error("Error opening user management view.", e);
+ StoreUtil.error(this.getClass(), e);
}
return null;
}
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.swt.widgets.Display;
-import org.eclipse.ui.progress.IProgressConstants;
import eu.etaxonomy.cdm.api.application.CdmApplicationController;
import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
exporter.invoke(configurator);
monitor.worked(60);
}catch(RuntimeException e){
- StoreUtil.errorDialog("Error exporting data", "An error occured while" +
+ StoreUtil.errorDialog("Error exporting data", this, "An error occured while" +
"exporting to destination '" + configurator.getDestinationNameString() + "'.\n" +
- "Please check error log for details.");
- logger.error("Error exporting data", e);
+ "Please check error log for details.", e);
}
display.asyncExec(new Runnable() {
case Sdd:
return SDDExportConfigurator.NewInstance(null, null, null);
default:
- StoreUtil.notImplementedMessage();
+ StoreUtil.notImplementedMessage(this);
throw new IllegalArgumentException("Export not supported yet");
}
}
importer.invoke(configurator);
monitor.worked(60);
}catch(RuntimeException e){
- StoreUtil.errorDialog("Error importing data", "An error occured while" +
+ StoreUtil.errorDialog("Error importing data", this, "An error occured while" +
"importing from source '" + configurator.getSourceNameString() + "'.\n" +
- "Please check error log for details.");
- logger.error("Error importing data", e);
+ "Please check error log for details.", e);
}
display.asyncExec(new Runnable() {
case Sdd:
return SDDImportConfigurator.NewInstance(null, null);
default:
- StoreUtil.notImplementedMessage();
+ StoreUtil.notImplementedMessage(this);
throw new IllegalArgumentException("Import not supported yet");
}
}
import java.net.URI;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IWorkbench;
* @version 1.0
*/
public class AbcdImportWizard extends AbstractImportWizard<Abcd206ImportConfigurator> {
- private static final Logger logger = Logger
- .getLogger(AbcdImportWizard.class);
private Abcd206ImportConfigurator configurator;
private ImportFromFileDataSourceWizardPage dataSourcePage;
package eu.etaxonomy.taxeditor.io.wizard;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.ui.IExportWizard;
* @version 1.0
*/
public class AbstractExcelExportWizard extends Wizard implements IExportWizard {
- private static final Logger logger = Logger
- .getLogger(AbstractExcelExportWizard.class);
/* (non-Javadoc)
* @see org.eclipse.jface.wizard.Wizard#performFinish()
package eu.etaxonomy.taxeditor.io.wizard;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.ui.IImportWizard;
* @version 1.0
*/
public class AbstractExcelImportWizard extends Wizard implements IImportWizard {
- private static final Logger logger = Logger
- .getLogger(AbstractExcelImportWizard.class);
/* (non-Javadoc)
* @see org.eclipse.jface.wizard.Wizard#performFinish()
package eu.etaxonomy.taxeditor.io.wizard;
-import org.apache.log4j.Logger;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.ui.IExportWizard;
* @version 1.0
*/
public abstract class AbstractExportWizard<CONFIG extends IIoConfigurator> extends Wizard implements IExportWizard{
- private static final Logger logger = Logger
- .getLogger(AbstractExportWizard.class);
protected final String CONFIGURATION_PAGE = "CONFIGURATION_PAGE";
package eu.etaxonomy.taxeditor.io.wizard;
-import org.apache.log4j.Logger;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.ui.IImportWizard;
* @version 1.0
*/
public abstract class AbstractImportWizard<CONFIG extends IIoConfigurator> extends Wizard implements IImportWizard {
- private static final Logger logger = Logger
- .getLogger(AbstractImportWizard.class);
protected final String CONFIGURATION_PAGE = "CONFIGURATION_PAGE";
package eu.etaxonomy.taxeditor.io.wizard;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IWorkbench;
* @version 1.0
*/
public class BerlinModelExportWizard extends AbstractExportWizard<BerlinModelExportConfigurator> {
- private static final Logger logger = Logger
- .getLogger(BerlinModelExportWizard.class);
private CdmDataSourceSQLServerWizardPage pageDataSource;
package eu.etaxonomy.taxeditor.io.wizard;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IWorkbench;
import eu.etaxonomy.cdm.database.ICdmDataSource;
import eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportConfigurator;
import eu.etaxonomy.cdm.io.common.Source;
-import eu.etaxonomy.taxeditor.datasource.CdmDataSourceRepository;
import eu.etaxonomy.taxeditor.datasource.wizard.CdmDataSourceSQLServerWizardPage;
import eu.etaxonomy.taxeditor.store.CdmStore;
* @version 1.0
*/
public class BerlinModelImportWizard extends AbstractImportWizard<BerlinModelImportConfigurator> {
- private static final Logger logger = Logger
- .getLogger(BerlinModelImportWizard.class);
CdmDataSourceSQLServerWizardPage dataSourcePage;
package eu.etaxonomy.taxeditor.io.wizard;
import java.io.File;
-import java.net.URI;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IImportWizard;
import org.eclipse.ui.IWorkbench;
* @version 1.0
*/
public class EndnoteImportWizard extends AbstractImportWizard<EndnoteImportConfigurator> implements IImportWizard {
- private static final Logger logger = Logger
- .getLogger(EndnoteImportWizard.class);
private EndnoteImportConfigurator configurator;
import java.net.URI;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IWorkbench;
* @version 1.0
*/
public class ExcelNormalExplicitTaxaImportWizard extends AbstractImportWizard<NormalExplicitImportConfigurator>{
- private static final Logger logger = Logger
- .getLogger(ExcelNormalExplicitTaxaImportWizard.class);
private NormalExplicitImportConfigurator configurator;
import java.text.SimpleDateFormat;
import java.util.Calendar;
-import org.apache.log4j.Logger;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
public static final String SDD_EXPORT = "SDD_EXPORT";
- private static final Logger logger = Logger
- .getLogger(ExportToFileDestinationWizardPage.class);
private DirectoryDialog folderDialog;
private Text text_exportFileName;
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.CLabel;
import org.eclipse.swt.widgets.Composite;
import eu.etaxonomy.cdm.io.common.IIoConfigurator;
+import eu.etaxonomy.taxeditor.store.StoreUtil;
/**
* @author n.hoffmann
* @version 1.0
*/
public class GenericConfiguratorWizardPage extends WizardPage {
-
-
- private static final Logger logger = Logger
- .getLogger(GenericConfiguratorWizardPage.class);
private IIoConfigurator configurator;
break;
} catch (Exception e) {
- logger.warn("Could not invoke method");
+ StoreUtil.warn(this.getClass(), "Could not invoke method");
}
}
break;
} catch (Exception e) {
- logger.warn("Could not invoke method");
+ StoreUtil.warn(this.getClass(), "Could not invoke method");
}
}
}
import java.io.File;
import java.net.URI;
-import org.apache.log4j.Logger;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
* @version 1.0
*/
public class ImportFromFileDataSourceWizardPage extends WizardPage {
- private static final Logger logger = Logger
- .getLogger(ImportFromFileDataSourceWizardPage.class);
public static final String PAGE_NAME = "CdmXmlDataSourceWizardPage";
import java.io.File;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IWorkbench;
* @version 1.0
*/
public class JaxbExportWizard extends AbstractExportWizard<JaxbExportConfigurator> {
- private static final Logger logger = Logger
- .getLogger(JaxbExportWizard.class);
private ExportToFileDestinationWizardPage page;
package eu.etaxonomy.taxeditor.io.wizard;
-import org.apache.log4j.Logger;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.widgets.Composite;
// TODO Auto-generated constructor stub
}
- private static final Logger logger = Logger
- .getLogger(JaxbImportSourceWizardPage.class);
-
/* (non-Javadoc)
* @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
*/
package eu.etaxonomy.taxeditor.io.wizard;
-import java.io.File;
import java.net.URI;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IWorkbench;
* @version 1.0
*/
public class JaxbImportWizard extends AbstractImportWizard<JaxbImportConfigurator> {
- private static final Logger logger = Logger
- .getLogger(JaxbImportWizard.class);
private JaxbImportConfigurator configurator;
*/
public class NomenclaturalCodeWizardPage extends WizardPage {
-
-
private IImportConfigurator configurator;
/**
import java.io.File;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IWorkbench;
* @version 1.0
*/
public class SddExportWizard extends AbstractExportWizard<SDDExportConfigurator> {
- private static final Logger logger = Logger
- .getLogger(SddExportWizard.class);
private ExportToFileDestinationWizardPage page;
package eu.etaxonomy.taxeditor.io.wizard;
-import java.io.File;
import java.net.URI;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IWorkbench;
* @version 1.0
*/
public class SddImportWizard extends AbstractImportWizard<SDDImportConfigurator> {
- private static final Logger logger = Logger
- .getLogger(SddImportWizard.class);
private SDDImportConfigurator configurator;
import java.io.File;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IWorkbench;
* @version 1.0
*/
public class TcsExportWizard extends AbstractExportWizard<TcsXmlExportConfigurator> {
- private static final Logger logger = Logger
- .getLogger(TcsExportWizard.class);
private static final String TCS_EXPORT = "TCS_EXPORT";
private TcsXmlExportConfigurator configurator;
private ExportToFileDestinationWizardPage page;
import java.net.URI;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IWorkbench;
* @version 1.0
*/
public class TcsImportWizard extends AbstractImportWizard<TcsXmlImportConfigurator>{
- private static final Logger logger = Logger.getLogger(TcsImportWizard.class);
private TcsXmlImportConfigurator configurator;
package eu.etaxonomy.taxeditor.labels;\r
\r
import java.util.List;\r
-import java.util.SortedSet;\r
\r
import org.eclipse.swt.graphics.Image;\r
\r
*/\r
package eu.etaxonomy.taxeditor.labels;\r
\r
-import org.apache.log4j.Logger;\r
import org.eclipse.swt.graphics.Image;\r
\r
-import eu.etaxonomy.cdm.model.name.NameRelationship;\r
import eu.etaxonomy.cdm.model.name.NameRelationshipType;\r
import eu.etaxonomy.cdm.model.name.NomenclaturalCode;\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
*\r
*/\r
public class LabelImageProvider implements ILabelImageStrategy {\r
- private static final Logger logger = Logger.getLogger(LabelImageProvider.class);\r
\r
private ILabelImageStrategy strategy;\r
\r
*/\r
package eu.etaxonomy.taxeditor.labels;\r
\r
-import org.apache.log4j.Logger;\r
import org.eclipse.swt.graphics.Image;\r
\r
import eu.etaxonomy.cdm.model.name.NameRelationshipType;\r
*\r
*/\r
public class ZoologicalNameLabelStrategy extends DefaultLabelStrategy {\r
- private static final Logger logger = Logger.getLogger(ZoologicalNameLabelStrategy.class);\r
\r
/* (non-Javadoc)\r
* @see eu.etaxonomy.taxeditor.editor.labels.IEditorLabelStrategy#getNameRelationTypeLabel(eu.etaxonomy.cdm.model.name.NameRelationshipType)\r
package eu.etaxonomy.taxeditor.model;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.Viewer;
* @version 1.0
*/
public abstract class AbstractCdmViewPart extends ViewPart implements ISelectionListener, IPostOperationEnabled, IConversationEnabled{
- private static final Logger logger = Logger
- .getLogger(AbstractCdmViewPart.class);
protected ISelectionService selectionService;
import java.util.Vector;
-import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeEvent;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.IOperationHistory;
import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.core.runtime.ILog;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
* @version 1.0
*/
public abstract class AbstractUtility {
- private static final Logger logger = Logger.getLogger(AbstractUtility.class);
protected static IStatusLineManager statusLineManager;
return TaxeditorStorePlugin.getDefault().getWorkbench()
.getActiveWorkbenchWindow().getShell();
-
-// return Display.getDefault().getShells()[0];
}
public static IWorkbenchPage getActivePage(){
try {
return PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().showView(id);
} catch (PartInitException e) {
- logger.error("Could not open view: " + id, e);
+ error(AbstractUtility.class, "Could not open view: " + id, e);
throw new RuntimeException(e);
}
}
* Open a message box that informs the user about unimplemented functionality.
* This method is for developer convenience.
*/
- public static void notImplementedMessage(){
- warningDialog("Not yet implemented", "This functionality is not yet implemented.");
+ public static void notImplementedMessage(Object source){
+ warningDialog("Not yet implemented", source, "This functionality is not yet implemented.");
}
public static void informationDialog(final String title, final String message){
});
}
- public static void warningDialog(final String title, final String message){
+ /**
+ *
+ * @param title The dialogs title
+ * @param source The object where the warning was generated (used by log4j)
+ * @param message An informative String to be presented to the user
+ */
+ public static void warningDialog(final String title, final Object source, final String message){
Display.getDefault().asyncExec(new Runnable(){
public void run() {
MessageDialog.openWarning(getShell(), title, message);
+ warn(AbstractUtility.class, message);
}
});
}
- public static void errorDialog(final String title, final String message){
+ /**
+ *
+ * @param title The dialogs title
+ * @param source The object where the warning was generated (used by log4j)
+ * @param message An informative String to be presented to the user
+ * @param t a Throwable if one exists or null
+ */
+ public static void errorDialog(final String title, final Object source, final String message, final Throwable t){
Display.getDefault().asyncExec(new Runnable(){
public void run() {
MessageDialog.openError(getShell(), title, message);
+ error(AbstractUtility.class, message, t);
}
});
}
getProgressService().runInUI(getWorkbenchWindow(), runnable, rule);
}
+ /**
+ *
+ * @param fork
+ * @param cancelable
+ * @param runnable
+ * @throws InvocationTargetException
+ * @throws InterruptedException
+ */
public static void run(boolean fork, boolean cancelable, IRunnableWithProgress runnable) throws InvocationTargetException, InterruptedException{
getProgressService().run(fork, cancelable, runnable);
}
+ /**
+ *
+ * @return
+ */
public static IProgressService getProgressService(){
IWorkbench workbench = PlatformUI.getWorkbench();
return workbench.getProgressService();
}
+ /**
+ *
+ * @return
+ */
public static IWorkbenchSiteProgressService getProgressService2(){
return (IWorkbenchSiteProgressService) getService(IWorkbenchSiteProgressService.class);
}
-
+
+ /**
+ *
+ * @param source
+ * @param message
+ */
+ public static void info(Class source, String message){
+ IStatus status = new Status(IStatus.INFO, getPluginId(), message);
+ info(source, status);
+ }
+
+ /**
+ *
+ * @param source
+ * @param status
+ */
+ public static void info(Class source, IStatus status){
+ Logger.getLogger(source).info(status.getMessage());
+ log(status);
+ }
+
+ /**
+ *
+ * @param source
+ * @param message
+ */
+ public static void warn(Class source, String message){
+ IStatus status = new Status(IStatus.WARNING, getPluginId(), message);
+ Logger.getLogger(source).warn(message);
+ log(status);
+ }
+
+ /**
+ *
+ * @param source
+ * @param t
+ */
+ public static void error(Class source, Throwable t){
+ error(source.getClass(), t.getMessage(), t);
+ }
+
+ /**
+ *
+ * @param source
+ * @param message
+ * @param t
+ */
+ public static void error(Class source, String message, Throwable t){
+ IStatus status = new Status(IStatus.ERROR, getPluginId(), message, t);
+ Logger.getLogger(source).error(message, t);
+ log(status);
+ }
+
+ /**
+ * @see {@link ILog#log(IStatus)}
+ *
+ * @param status
+ */
+ private static void log(IStatus status){
+ TaxeditorStorePlugin.getDefault().getLog().log(status);
+ }
+
+ protected static String getPluginId(){
+ return "Override in subclasses";
+ }
}
package eu.etaxonomy.taxeditor.model;
-import org.apache.log4j.Logger;
-
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
import eu.etaxonomy.cdm.model.agent.Person;
import eu.etaxonomy.cdm.model.agent.Team;
* @version 1.0
*/
public class AuthorHelper {
- private static final Logger logger = Logger.getLogger(AuthorHelper.class);
public static Team getAuthor(Object object){
if(object == null){
*/
package eu.etaxonomy.taxeditor.model;
-import org.apache.log4j.Logger;
-
import eu.etaxonomy.cdm.common.IProgressMonitor;
import eu.etaxonomy.taxeditor.store.StoreUtil;
* @version 1.0
*/
public class CdmProgressMonitorAdapter implements IProgressMonitor {
-
- private static final Logger logger = Logger.getLogger(CdmProgressMonitorAdapter.class);
private org.eclipse.core.runtime.IProgressMonitor progressMonitor;
@Override
public void warning(String message) {
- logger.warn(message);
+ StoreUtil.warn(this.getClass(), message);
}
@Override
public void warning(String message, Throwable throwable) {
- logger.warn(message, throwable);
+ StoreUtil.error(this.getClass(), message, throwable);
}
}
package eu.etaxonomy.taxeditor.model;
-import org.apache.log4j.Logger;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.widgets.Text;
* @version 1.0
*/
public class CommonHelper {
- private static final Logger logger = Logger.getLogger(CommonHelper.class);
-
/**
*
* @param text
import java.util.Arrays;
import java.util.List;
-import org.apache.log4j.Logger;
import org.hibernate.LazyInitializationException;
import eu.etaxonomy.cdm.api.service.DefaultCategoricalDescriptionBuilder;
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.taxeditor.store.CdmStore;
+import eu.etaxonomy.taxeditor.store.StoreUtil;
/**
* @author p.ciardelli
* @version 1.0
*/
public class DescriptionHelper {
- private static final Logger logger = Logger
- .getLogger(DescriptionHelper.class);
/**
* Returns whatever the element's title cache equivalent is,
}
if(element instanceof Distribution){
- logger.warn("trying to set cache on distribution, don't know what to do at the moment.");
+ StoreUtil.warn(DescriptionHelper.class, "trying to set cache on distribution, don't know what to do at the moment.");
return;
}
- logger.warn("No matching subclass found for DescriptionElementBase object, 'cache' not set.");
+ StoreUtil.warn(DescriptionHelper.class, "No matching subclass found for DescriptionElementBase object, 'cache' not set.");
}
/**
return ((IdentifiableEntity) element).getTitleCache();
}catch(LazyInitializationException e){
String result = "No Session to initialize title cache for IdentifiableEntity";
- logger.error(result);
+ StoreUtil.error(DescriptionHelper.class, result, e);
return "TODO: " + result;
}
}
return CdmUtils.concat("; ", new String[]{originalSource.getIdNamespace(), originalSource.getIdInSource(), sourceObjectTitle});
}catch(LazyInitializationException e){
String result = "Error initializing title cache for ISourceable of an OriginalSourceBase";
- logger.error(result);
+ StoreUtil.error(DescriptionHelper.class, result, e);
return "TODO: " + result;
}
}
import java.util.Set;
import java.util.UUID;
-import org.apache.log4j.Logger;
import org.joda.time.DateTime;
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
* @version 1.0
*/
public class FeatureNodeContainer implements IAnnotatableEntity{
- private static final Logger logger = Logger
- .getLogger(FeatureNodeContainer.class);
-
public static Comparator<DescriptionElementBase> comparator = new Comparator<DescriptionElementBase>() {
import java.util.Iterator;\r
import java.util.List;\r
\r
-import org.apache.log4j.Logger;\r
import org.eclipse.jface.text.IDocument;\r
import org.eclipse.jface.text.ITextSelection;\r
import org.eclipse.jface.text.TextSelection;\r
* @version 1.0\r
*/\r
public class LineSelection extends TextSelection implements IStructuredSelection {\r
- @SuppressWarnings("unused")\r
- private static final Logger logger = Logger.getLogger(LineSelection.class);\r
\r
private StructuredSelection structuredSelection;\r
\r
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
-import org.apache.log4j.Logger;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.WorkbenchException;
import org.eclipse.ui.XMLMemento;
+import eu.etaxonomy.taxeditor.store.StoreUtil;
+
/**
* @author n.hoffmann
* @created Mar 29, 2010
* @version 1.0
*/
public class MementoHelper {
- private static final Logger logger = Logger.getLogger(MementoHelper.class);
-
public static IMemento readMementoFromFile(File stateFile) throws FileNotFoundException{
FileInputStream input;
new InputStreamReader(input, "utf-8")); //$NON-NLS-1$
return XMLMemento.createReadRoot(reader);
} catch (WorkbenchException e) {
- logger.error("Exception while reading the memento", e);
+ StoreUtil.error(MementoHelper.class, "Exception while reading the memento", e);
} catch (UnsupportedEncodingException e) {
- logger.error("Exception while reading the memento", e);
+ StoreUtil.error(MementoHelper.class, "Exception while reading the memento", e);
}
return null;
writer.close();
} catch (IOException e) {
stateFile.delete();
- logger.error("Could not save datasource state");
+ StoreUtil.error(MementoHelper.class, "Could not save datasource state", e);
return null;
}
import java.util.List;
import java.util.Map;
-import org.apache.log4j.Logger;
-
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.LanguageString;
import eu.etaxonomy.cdm.model.common.MultilanguageTextHelper;
* @version 1.0
*/
public class MultiLanguageText {
- private static final Logger logger = Logger
- .getLogger(MultiLanguageText.class);
private Map<Language, LanguageString> languageTextMap;
*/
public class NameHelper {
- @SuppressWarnings("unchecked")
public static String getDisplayName(TaxonNameBase name){
return name.getTitleCache();
}
return getDisplayName(taxon.getName());
}
- @SuppressWarnings("unchecked")
public static String getDisplayNameWithRef(TaxonBase taxonBase) {
TaxonNameBase name = (TaxonNameBase) HibernateProxyHelper.deproxy(taxonBase.getName());
if (name != null) {
package eu.etaxonomy.taxeditor.model;
-import org.apache.log4j.Logger;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.widgets.Control;
* @version 1.0
*/
public class TextHelper {
- private static final Logger logger = Logger.getLogger(TextHelper.class);
public static final String ELLIPSIS = "...";
package eu.etaxonomy.taxeditor.newWizards;
-import org.apache.log4j.Logger;
import org.eclipse.jface.wizard.WizardPage;
-import org.eclipse.swt.widgets.Composite;
/**
* @author n.hoffmann
*/
public abstract class AbstractSpecificReferenceWizardPage extends WizardPage {
-
- private static final Logger logger = Logger
- .getLogger(AbstractSpecificReferenceWizardPage.class);
-
protected AbstractSpecificReferenceWizardPage(String pageName) {
super(pageName);
}
package eu.etaxonomy.taxeditor.newWizards;
-import org.apache.log4j.Logger;
import org.eclipse.swt.widgets.Composite;
/**
*/
public class BookDetailsWizardPage extends AbstractSpecificReferenceWizardPage {
-
- private static final Logger logger = Logger
- .getLogger(BookDetailsWizardPage.class);
-
protected BookDetailsWizardPage(String pageName) {
super(pageName);
// TODO Auto-generated constructor stub
package eu.etaxonomy.taxeditor.newWizards;
-import org.apache.log4j.Logger;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
* @version 1.0
*/
public class NewGenericReferenceWizardPage extends WizardPage {
-
-
- private static final Logger logger = Logger
- .getLogger(NewGenericReferenceWizardPage.class);
private Combo combo_referenceType;
private Text text_title;
package eu.etaxonomy.taxeditor.newWizards;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.ui.INewWizard;
* @version 1.0
*/
public class NewNameWizard extends Wizard implements INewWizard {
- private static final Logger logger = Logger.getLogger(NewNameWizard.class);
public static final String NEW_NAME = "NEW_NAME";
\r
import java.util.UUID;\r
\r
-import org.apache.log4j.Logger;\r
import org.eclipse.core.commands.operations.AbstractOperation;\r
import org.eclipse.core.commands.operations.IUndoContext;\r
import org.eclipse.core.runtime.IStatus;\r
* @author n.hoffmann\r
*/\r
public abstract class AbstractPostOperation extends AbstractOperation {\r
-\r
- private static final Logger logger = Logger\r
- .getLogger(AbstractPostOperation.class);\r
\r
/**\r
* \r
*/\r
protected IStatus postExecute(CdmBase objectAffectedByOperation) { \r
if(postOperationEnabled != null){\r
- logger.trace("executing post operation");\r
return postOperationEnabled.postOperation(objectAffectedByOperation) ? Status.OK_STATUS : Status.CANCEL_STATUS;\r
}\r
return Status.OK_STATUS;\r
package eu.etaxonomy.taxeditor.operations;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.core.runtime.IAdaptable;
*/
public class ChangeAcceptedTaxonToSynonymOperation extends
AbstractPersistentPostOperation {
-
- private static final Logger logger = Logger
- .getLogger(ChangeAcceptedTaxonToSynonymOperation.class);
private TaxonNode newAcceptedTaxonNode;
\r
import java.util.Set;\r
\r
-import org.apache.log4j.Logger;\r
import org.eclipse.core.commands.ExecutionException;\r
import org.eclipse.core.commands.operations.IUndoContext;\r
import org.eclipse.core.runtime.IAdaptable;\r
* @version 1.0\r
*/\r
public class ChangeConceptRelationshipTypeOperation extends AbstractPostOperation {\r
-\r
-\r
- private static final Logger logger = Logger\r
- .getLogger(ChangeConceptRelationshipTypeOperation.class);\r
\r
private Taxon relatedTaxon;\r
\r
Set<TaxonRelationship> taxonRelationships = taxon.getTaxonRelations(relatedTaxon);\r
\r
if(taxonRelationships.size() > 1){\r
- StoreUtil.warningDialog("Multiple relations between taxa", "There are multiple relations between the " +\r
+ StoreUtil.warningDialog("Multiple relations between taxa", this, "There are multiple relations between the " +\r
"accepted and the related taxon. This case is not handled by the software yet");\r
return;\r
}\r
public IStatus undo(IProgressMonitor monitor, IAdaptable info)\r
throws ExecutionException {\r
// see FIXME in execute()\r
- logger.warn("Not implemented yet. See developer documentation for details");\r
+ StoreUtil.warn(this.getClass(), "Not implemented yet. See developer documentation for details");\r
return null;\r
}\r
}\r
import org.eclipse.core.runtime.IAdaptable;\r
import org.eclipse.core.runtime.IProgressMonitor;\r
import org.eclipse.core.runtime.IStatus;\r
-import org.eclipse.core.runtime.OperationCanceledException;\r
\r
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
-import eu.etaxonomy.cdm.model.taxon.Synonym;\r
import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;\r
-import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;\r
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;\r
Set<TaxonRelationship> taxonRelationships = taxon.getTaxonRelations(concept);\r
\r
if(taxonRelationships.size() > 1){\r
- StoreUtil.warningDialog("Multiple relations between taxa", "There are multiple relations between the " +\r
+ StoreUtil.warningDialog("Multiple relations between taxa", this, "There are multiple relations between the " +\r
"accepted and the related taxon. This case is not handled by the software yet");\r
return;\r
}\r
*/\r
package eu.etaxonomy.taxeditor.operations;\r
\r
-import java.lang.reflect.Method;\r
-\r
import org.eclipse.core.commands.ExecutionException;\r
import org.eclipse.core.commands.operations.IUndoContext;\r
import org.eclipse.core.runtime.IAdaptable;\r
\r
package eu.etaxonomy.taxeditor.operations;\r
\r
-import org.apache.log4j.Logger;\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.OperationCanceledException;\r
\r
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.model.taxon.Synonym;\r
import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
-import eu.etaxonomy.taxeditor.store.StoreUtil;\r
\r
/**\r
* Change the homotypical group of a given synonym.\r
* @version 1.0\r
*/\r
public class ChangeHomotypicGroupOperation extends AbstractPostOperation {\r
- \r
- @SuppressWarnings("unused")\r
- private static final Logger logger = Logger\r
- .getLogger(ChangeHomotypicGroupOperation.class);\r
\r
/**\r
* The synonym to be moved.\r
\r
package eu.etaxonomy.taxeditor.operations;\r
\r
-import org.apache.log4j.Logger;\r
import org.eclipse.core.commands.ExecutionException;\r
import org.eclipse.core.commands.operations.IUndoContext;\r
import org.eclipse.core.runtime.IAdaptable;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
import eu.etaxonomy.cdm.model.taxon.TaxonNode;\r
import eu.etaxonomy.taxeditor.store.CdmStore;\r
+import eu.etaxonomy.taxeditor.store.StoreUtil;\r
\r
/**\r
* Change the taxonomic parent of a given taxon.\r
*/\r
public class ChangeSynonymToAcceptedTaxonOperation extends AbstractPersistentPostOperation {\r
\r
- @SuppressWarnings("unused")\r
- private static final Logger logger = Logger.getLogger(ChangeSynonymToAcceptedTaxonOperation.class);\r
-\r
private Taxon newTaxon;\r
private Synonym synonym;\r
private ITreeNode parentNode;\r
throws ExecutionException {\r
\r
// TODO implement - biggest problem is that any window open for new taxon must be closed first\r
- logger.warn("Not yet implemented");\r
+ StoreUtil.warn(this.getClass(), "Not yet implemented");\r
\r
return postExecute(taxon);\r
}\r
import org.eclipse.core.runtime.IAdaptable;\r
import org.eclipse.core.runtime.IProgressMonitor;\r
import org.eclipse.core.runtime.IStatus;\r
-import org.eclipse.core.runtime.OperationCanceledException;\r
\r
-import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.model.taxon.Synonym;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;\r
import eu.etaxonomy.taxeditor.store.CdmStore;\r
-import eu.etaxonomy.taxeditor.store.StoreUtil;\r
\r
/**\r
* @author p.ciardelli\r
\r
package eu.etaxonomy.taxeditor.operations;\r
\r
-import org.apache.log4j.Logger;\r
import org.eclipse.core.commands.ExecutionException;\r
import org.eclipse.core.commands.operations.IUndoContext;\r
import org.eclipse.core.runtime.IAdaptable;\r
* @deprecated there will be an operation to set the basionym only that automatically unsets the former basionym\r
*/\r
public class ChangeSynonymToHomotypicalGroupBasionymOperation extends AbstractPostOperation {\r
- private static final Logger logger = Logger\r
- .getLogger(ChangeSynonymToHomotypicalGroupBasionymOperation.class);\r
\r
private Synonym synonym;\r
\r
import org.eclipse.core.runtime.IAdaptable;\r
import org.eclipse.core.runtime.IProgressMonitor;\r
import org.eclipse.core.runtime.IStatus;\r
-import org.eclipse.core.runtime.OperationCanceledException;\r
\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.model.taxon.Synonym;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;\r
import eu.etaxonomy.taxeditor.store.CdmStore;\r
-import eu.etaxonomy.taxeditor.store.StoreUtil;\r
\r
/**\r
* @author p.ciardelli\r
\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;\r
-import eu.etaxonomy.taxeditor.store.StoreUtil;\r
\r
/**\r
* @author p.ciardelli\r
import eu.etaxonomy.cdm.model.description.DescriptionBase;\r
import eu.etaxonomy.cdm.model.media.ImageFile;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
-import eu.etaxonomy.taxeditor.store.StoreUtil;\r
\r
/**\r
* @author p.ciardelli\r
package eu.etaxonomy.taxeditor.operations;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.core.runtime.IAdaptable;
*/
public class CreateNameRelationOperation extends AbstractPostOperation {
-
- private static final Logger logger = Logger
- .getLogger(CreateNameRelationOperation.class);
private TaxonBase taxonBase;
private TaxonNameBase relatedName;
private NameRelationshipType type;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
-import eu.etaxonomy.taxeditor.store.StoreUtil;\r
\r
/**\r
* @author n.hoffmann\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
-import eu.etaxonomy.taxeditor.store.StoreUtil;\r
\r
/**\r
* <ol>\r
import eu.etaxonomy.cdm.model.description.TextData;\r
import eu.etaxonomy.cdm.model.media.Media;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
-import eu.etaxonomy.taxeditor.store.StoreUtil;\r
\r
/**\r
* @author p.ciardelli\r
package eu.etaxonomy.taxeditor.operations;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.core.runtime.IAdaptable;
*/
public class CreateTaxonNodeOperation extends AbstractPersistentPostOperation {
- private static final Logger logger = Logger.getLogger(CreateTaxonNodeOperation.class);
-
private Taxon newTaxon;
private TaxonNode childTaxonNode;
return postExecute(childTaxonNode);
}catch(Exception e){
- StoreUtil.warningDialog("Could not create taxon node", e.getMessage());
+ StoreUtil.warningDialog("Could not create taxon node", this, e.getMessage());
return Status.CANCEL_STATUS;
}
}
public IStatus undo(IProgressMonitor monitor, IAdaptable info)
throws ExecutionException {
- logger.warn("Not yet implemented.");
+ StoreUtil.warn(this.getClass(), "Not yet implemented.");
return null;
}
}
package eu.etaxonomy.taxeditor.operations;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.core.runtime.IAdaptable;
* @version 1.0
*/
public class CreateUserOperation extends AbstractPersistentPostOperation {
-
- private static final Logger logger = Logger
- .getLogger(CreateUserOperation.class);
private User user;
Set<TaxonRelationship> taxonRelationships = taxon.getTaxonRelations(relatedTaxon);\r
\r
if(taxonRelationships.size() > 1){\r
- StoreUtil.warningDialog("Multiple relations between taxa", "There are multiple relations between the " +\r
+ StoreUtil.warningDialog("Multiple relations between taxa", this, "There are multiple relations between the " +\r
"accepted and the related taxon. This case is not handled by the software yet");\r
return;\r
}\r
\r
package eu.etaxonomy.taxeditor.operations;\r
\r
-import org.apache.log4j.Logger;\r
import org.eclipse.core.commands.ExecutionException;\r
import org.eclipse.core.commands.operations.IUndoContext;\r
import org.eclipse.core.runtime.IAdaptable;\r
\r
import eu.etaxonomy.cdm.model.description.DescriptionBase;\r
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;\r
+import eu.etaxonomy.taxeditor.store.StoreUtil;\r
\r
/**\r
* @author p.ciardelli\r
* @version 1.0\r
*/\r
public class DeleteDescriptionElementOperation extends AbstractPostOperation {\r
- private static final Logger logger = Logger\r
- .getLogger(DeleteDescriptionElementOperation.class);\r
\r
private DescriptionElementBase element;\r
private DescriptionBase description = null;\r
\r
// Remove element from description\r
if (description == null) {\r
- logger.error("Couldn't find element's description!");\r
+ StoreUtil.error(this.getClass(), "Couldn't find element's description!", null);\r
} else {\r
description.removeElement(element);\r
}\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;\r
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;\r
-import eu.etaxonomy.taxeditor.store.StoreUtil;\r
\r
/**\r
* @author p.ciardelli\r
package eu.etaxonomy.taxeditor.operations;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.core.runtime.IAdaptable;
*/
public class DeleteNameRelationOperation extends AbstractPostOperation {
-
- private static final Logger logger = Logger
- .getLogger(DeleteNameRelationOperation.class);
private NameRelationship nameRelationship;
public DeleteNameRelationOperation(String label, IUndoContext undoContext, NameRelationship nameRelationship,
import eu.etaxonomy.cdm.model.taxon.Synonym;\r
import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
-import eu.etaxonomy.taxeditor.store.CdmStore;\r
-import eu.etaxonomy.taxeditor.store.StoreUtil;\r
\r
/**\r
* @author p.ciardelli\r
import java.util.Set;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.core.runtime.IAdaptable;
*/
public class DeleteTreeNodeOperation extends AbstractPersistentPostOperation{
- private static final Logger logger = Logger
- .getLogger(DeleteTreeNodeOperation.class);
private Set<ITreeNode> treeNodes;
}else if(treeNode instanceof TaxonomicTree){
TaxonomicTree taxonomicTree = (TaxonomicTree) treeNode;
if(taxonomicTree.hasChildNodes()){
- StoreUtil.warningDialog("Tree is not empty", "It is not possible to delete a Taxonomic Tree that " +
+ StoreUtil.warningDialog("Tree is not empty", this, "It is not possible to delete a Taxonomic Tree that " +
"is not empty. Please delete included taxa first");
}else{
CdmStore.getTaxonTreeService().delete(taxonomicTree);
package eu.etaxonomy.taxeditor.operations;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.core.runtime.IAdaptable;
* @version 1.0
*/
public class EditTaxonomicTreeOperation extends AbstractPersistentPostOperation {
- private static final Logger logger = Logger
- .getLogger(EditTaxonomicTreeOperation.class);
private TaxonomicTree classification;
public EditTaxonomicTreeOperation(String label, IUndoContext undoContext, TaxonomicTree classification,
package eu.etaxonomy.taxeditor.operations;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.core.runtime.IAdaptable;
* @version 1.0
*/
public class EditUserOperation extends AbstractPersistentPostOperation {
- private static final Logger logger = Logger
- .getLogger(EditUserOperation.class);
private User user;
import java.util.List;\r
import java.util.Set;\r
\r
-import org.apache.log4j.Logger;\r
import org.eclipse.core.commands.ExecutionException;\r
import org.eclipse.core.commands.operations.IUndoContext;\r
import org.eclipse.core.runtime.IAdaptable;\r
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;\r
import eu.etaxonomy.cdm.model.media.Media;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
+import eu.etaxonomy.taxeditor.store.StoreUtil;\r
\r
/**\r
* @author p.ciardelli\r
* @version 1.0\r
*/\r
public class MoveMediaInListOperation extends AbstractPostOperation {\r
-\r
- private static final Logger logger = Logger\r
- .getLogger(MoveMediaInListOperation.class);\r
\r
public static final int UP = 1;\r
public static final int DOWN = -1;\r
Set<DescriptionElementBase> elements = description.getElements();\r
\r
if(elements.size() != 1){\r
- logger.error("More than one description element in this image gallery");\r
+ StoreUtil.error(this.getClass(), "More than one description element in this image gallery", null);\r
}\r
\r
DescriptionElementBase element = elements.iterator().next();\r
try{\r
Collections.swap(medias, newIndex, index);\r
}catch(ArrayIndexOutOfBoundsException e){\r
- logger.error("", e);\r
+ StoreUtil.error(this.getClass(), e);\r
}\r
} \r
}\r
import java.util.Map;\r
import java.util.Set;\r
\r
-import org.apache.log4j.Logger;\r
import org.eclipse.core.commands.ExecutionException;\r
import org.eclipse.core.commands.operations.IUndoContext;\r
import org.eclipse.core.runtime.IAdaptable;\r
*/\r
public class MoveTaxonOperation extends AbstractPersistentPostOperation {\r
\r
- @SuppressWarnings("unused")\r
- private static final Logger logger = Logger.getLogger(MoveTaxonOperation.class);\r
/**\r
* A reference to the new taxonomical parent.\r
*/\r
monitor.worked(2);\r
}\r
} catch(IllegalAncestryException e) {\r
- StoreUtil.warningDialog("Illegal ancestry", e.getMessage());\r
+ StoreUtil.warningDialog("Illegal ancestry", this, e.getMessage());\r
}\r
monitor.worked(40);\r
\r
@Override\r
public IStatus undo(IProgressMonitor monitor, IAdaptable info)\r
throws ExecutionException {\r
- logger.warn("Not implemented yet.");\r
+ StoreUtil.warn(this.getClass(), "Not implemented yet.");\r
\r
// iterate over oldParentTreeNodes, delete each TaxonNode from its actual parent and add to its former parent \r
\r
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;\r
import eu.etaxonomy.cdm.model.media.ImageFile;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
-import eu.etaxonomy.taxeditor.store.StoreUtil;\r
\r
/**\r
* @author p.ciardelli\r
package eu.etaxonomy.taxeditor.operations;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.core.runtime.IAdaptable;
*/
public class SaveClassificationOperation extends AbstractPersistentPostOperation {
- private static final Logger logger = Logger
- .getLogger(SaveClassificationOperation.class);
-
private TaxonomicTree classification;
/**
package eu.etaxonomy.taxeditor.operations;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
-import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.taxon.Synonym;
import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.taxeditor.store.CdmStore;
+import eu.etaxonomy.taxeditor.store.StoreUtil;
/**
* @author n.hoffmann
* @version 1.0
*/
public class SwapSynonymAndAcceptedOperation extends AbstractPostOperation {
- private static final Logger logger = Logger
- .getLogger(SwapSynonymAndAcceptedOperation.class);
private Synonym synonym;
// TODO store the old relationship for undo reasons
@Override
public IStatus undo(IProgressMonitor monitor, IAdaptable info)
throws ExecutionException {
- logger.error("Not yet implemented");
+ StoreUtil.error(this.getClass(), "Not yet implemented", null);
return null;
}
}
\ No newline at end of file
package eu.etaxonomy.taxeditor.operations;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.core.runtime.IAdaptable;
*/
public class ToggleUserEnablementOperation extends AbstractPersistentPostOperation {
- private static final Logger logger = Logger
- .getLogger(ToggleUserEnablementOperation.class);
private User user;
/**
import java.util.ArrayList;
import java.util.List;
-import org.apache.log4j.Logger;
import org.eclipse.swt.widgets.Control;
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl;
import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
import eu.etaxonomy.taxeditor.store.CdmStore;
+import eu.etaxonomy.taxeditor.store.StoreUtil;
/**
* @author n.hoffmann
*
*/
public class ParseHandler{
- private static final Logger logger = Logger.getLogger(ParseHandler.class);
private TaxonNameBase taxonNameBase;
unparsedNameString = (String) getText.invoke(textWidget, null);
} catch (Exception e) {
// we should never get here
- logger.error("Error trying to invoke getText method");
+ StoreUtil.error(this.getClass(), "Error trying to invoke getText method", e);
}
if(duplicateInReferences.size() > 0){
ReferenceBase inReference = (ReferenceBase) duplicateInReferences.iterator().next();
reference.setInReference(inReference);
- logger.warn(reference.generateTitle());
+ StoreUtil.warn(this.getClass(), reference.generateTitle());
// FIXME TODO resolve multiple duplications. We use first match for a start
- logger.warn(reference.getTitleCache());
+ StoreUtil.warn(this.getClass(), reference.getTitleCache());
}
}
try{
return CdmStore.getCommonService().findMatching(nomenclaturalReference, MatchStrategyConfigurator.ReferenceMatchStrategy());
}catch (MatchException e) {
- logger.error("Error finding matching references", e);
+ StoreUtil.error(this.getClass(), "Error finding matching references", e);
}
return null;
}
try{
return CdmStore.getCommonService().findMatching(authorTeam, MatchStrategyConfigurator.TeamOrPersonMatchStrategy());
}catch (MatchException e) {
- logger.error("Error finding matching authors", e);
+ StoreUtil.error(this.getClass(), "Error finding matching authors", e);
}
return null;
}
return CdmStore.getCommonService().findMatching(taxonNameBase, MatchStrategyConfigurator.NonViralNameMatchStrategy());
} catch (MatchException e) {
- logger.error("Error finding matching names", e);
+ StoreUtil.error(this.getClass(), "Error finding matching names", e);
}
return null;
}
import java.util.List;
-import org.apache.log4j.Logger;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
* @version 1.0
*/
public class DefaultFeatureTreePreferenecs extends PreferencePage implements IWorkbenchPreferencePage {
- private static final Logger logger = Logger
- .getLogger(DefaultFeatureTreePreferenecs.class);
private FeatureTree defaultFeatureTreeForTextualDescription;
private FeatureTree defaultFeatureTreeForStructuredDescription;
package eu.etaxonomy.taxeditor.preference;
-import org.apache.log4j.Logger;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.wizard.WizardDialog;
*/
public class FeatureTreePreferences extends PreferencePage implements
IWorkbenchPreferencePage {
- private static final Logger logger = Logger
- .getLogger(FeatureTreePreferences.class);
/**
*
package eu.etaxonomy.taxeditor.preference;
-import org.apache.log4j.Logger;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridLayout;
*/
public class MatchingPreferences extends PreferencePage implements
IWorkbenchPreferencePage {
- private static final Logger logger = Logger
- .getLogger(MatchingPreferences.class);
/* (non-Javadoc)
* @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite)
import java.util.Set;\r
import java.util.UUID;\r
\r
-import org.apache.log4j.Logger;\r
import org.eclipse.jface.dialogs.Dialog;\r
import org.eclipse.jface.dialogs.MessageDialog;\r
import org.eclipse.jface.preference.IPreferenceStore;\r
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;\r
import eu.etaxonomy.cdm.model.name.Rank;\r
import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;\r
+import eu.etaxonomy.cdm.model.occurrence.DeterminationModifier;\r
import eu.etaxonomy.cdm.model.occurrence.PreservationMethod;\r
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;\r
import eu.etaxonomy.cdm.strategy.match.DefaultMatchStrategy;\r
* @author n.hoffmann\r
*/\r
public class PreferencesUtil implements IPreferenceKeys{\r
- private static final Logger logger = Logger\r
- .getLogger(PreferencesUtil.class);\r
\r
/**\r
* \r
try {\r
matchStrategy.setMatchMode(fieldName, matchMode);\r
} catch (MatchException e) {\r
- logger.error(e);\r
+ StoreUtil.error(PreferencesUtil.class, e);\r
throw new RuntimeException(e);\r
}\r
}\r
/** @return a {@link List} containing user preferred {@link Scope} terms */\r
public static List<Scope> getPreferredScopes() { return getPreferredTerms(TermStore.getScopes()); }\r
\r
+ /** @return a {@link List} containing user preferred {@link DeterminationModifier} terms*/\r
+ public static List<DeterminationModifier> getPreferredDeterminationModifiers() { return getPreferredTerms(TermStore.getDeterminationModifiers()); }\r
+ \r
/**\r
* Generic method to set term preferences\r
* \r
. concat(".")\r
. concat(cdmBase.getUuid().toString());\r
if (key.contains("javassist")) {\r
- logger.info("proxy");\r
+ StoreUtil.info(PreferencesUtil.class, "proxy");\r
}\r
return key;\r
}\r
. concat(".")\r
. concat(definedTerm.getUuid().toString());\r
if (key.contains("javassist")) {\r
- logger.warn("Trying to persist a preference based on a proxy class.");\r
+ StoreUtil.warn(PreferencesUtil.class, "Trying to persist a preference based on a proxy class.");\r
}\r
return key;\r
}\r
// First time Editor is opened, no nomenclatural code has been set\r
if (PreferencesUtil.getPreferredNomenclaturalCode() == null) {\r
\r
- logger.info("No nomencatural code set.");\r
+ StoreUtil.info(PreferencesUtil.class, "No nomencatural code set.");\r
\r
Shell shell = StoreUtil.getShell();\r
\r
public static FeatureTree getDefaultFeatureTreeForStructuredDescription() {\r
String uuidString = getPreferenceStore().getString(FEATURE_TREE_DEFAULT_STRUCTURE);\r
return CdmUtils.isEmpty(uuidString) ? null : CdmStore.getFeatureTreeService().load(UUID.fromString(uuidString));\r
- }\r
- \r
+ } \r
}\r
package eu.etaxonomy.taxeditor.preference;
-import org.apache.log4j.Logger;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CLabel;
import org.eclipse.swt.events.ModifyListener;
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.layout.RowLayout;
*/
public class TaxonomicEditorGeneralPreferences extends PreferencePage implements
IWorkbenchPreferencePage {
- private static final Logger logger = Logger
- .getLogger(TaxonomicEditorGeneralPreferences.class);
boolean showUuidInSupplementalView;
import java.util.Map;
import java.util.UUID;
-import org.apache.log4j.Logger;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.ui.IMemento;
-import eu.etaxonomy.cdm.model.common.AnnotationType;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
-import eu.etaxonomy.cdm.model.common.ExtensionType;
-import eu.etaxonomy.cdm.model.common.Language;
-import eu.etaxonomy.cdm.model.common.MarkerType;
-import eu.etaxonomy.cdm.model.description.Feature;
-import eu.etaxonomy.cdm.model.description.MeasurementUnit;
-import eu.etaxonomy.cdm.model.description.Modifier;
-import eu.etaxonomy.cdm.model.description.PresenceAbsenceTermBase;
-import eu.etaxonomy.cdm.model.description.Scope;
-import eu.etaxonomy.cdm.model.description.Stage;
-import eu.etaxonomy.cdm.model.description.State;
-import eu.etaxonomy.cdm.model.description.StatisticalMeasure;
-import eu.etaxonomy.cdm.model.location.NamedAreaType;
-import eu.etaxonomy.cdm.model.media.RightsTerm;
-import eu.etaxonomy.cdm.model.name.NameRelationshipType;
-import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus;
-import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
-import eu.etaxonomy.cdm.model.name.Rank;
-import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
-import eu.etaxonomy.cdm.model.occurrence.PreservationMethod;
-import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
import eu.etaxonomy.taxeditor.model.ContextListenerAdapter;
import eu.etaxonomy.taxeditor.store.CdmStore;
-import eu.etaxonomy.taxeditor.store.TermStore;
import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;
/**
* @version 1.0
*/
public class TermPreferenceUtil implements IPreferenceKeys{
- private static final Logger logger = Logger
- .getLogger(TermPreferenceUtil.class);
protected static String DISABLED_TERMS = "disabledTerms";
import java.util.List;
import java.util.Map;
-import org.apache.log4j.Logger;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CLabel;
import eu.etaxonomy.cdm.strategy.match.MatchException;
import eu.etaxonomy.cdm.strategy.match.MatchMode;
import eu.etaxonomy.taxeditor.parser.MatchStrategyConfigurator;
+import eu.etaxonomy.taxeditor.store.StoreUtil;
/**
* @author n.hoffmann
*/
public abstract class AbstractMatchingPreferences<T extends IdentifiableEntity> extends PreferencePage implements
IWorkbenchPreferencePage {
- private static final Logger logger = Logger
- .getLogger(AbstractMatchingPreferences.class);
/**
* Fields that will be excluded from the display
* @see org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse.swt.events.SelectionEvent)
*/
@Override
- public void widgetSelected(SelectionEvent e) {
- super.widgetSelected(e);
+ public void widgetSelected(SelectionEvent event) {
+ super.widgetSelected(event);
MatchMode matchMode = getMatchModeList().get(matchModeCombo.getSelectionIndex());
try {
matchStrategy.setMatchMode(fieldName, matchMode);
- } catch (MatchException exception) {
- logger.error(e);
- throw new RuntimeException(exception);
+ } catch (MatchException e) {
+ StoreUtil.error(this.getClass(), e);
+ throw new RuntimeException(e);
}
}
}
}
} catch (MatchException e) {
- logger.error(e);
+ StoreUtil.error(this.getClass(), e);
throw new RuntimeException(e);
}
super.performDefaults();
package eu.etaxonomy.taxeditor.preference.matching;
-import org.apache.log4j.Logger;
import org.eclipse.ui.IWorkbench;
import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.strategy.match.IMatchStrategy;
import eu.etaxonomy.cdm.strategy.match.MatchException;
import eu.etaxonomy.taxeditor.parser.MatchStrategyConfigurator;
+import eu.etaxonomy.taxeditor.store.StoreUtil;
/**
* @author n.hoffmann
* @version 1.0
*/
public class NonViralNameMatchingPreference extends AbstractMatchingPreferences<NonViralName>{
- private static final Logger logger = Logger
- .getLogger(NonViralNameMatchingPreference.class);
/* (non-Javadoc)
* @see org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)
try {
matchStrategy = MatchStrategyConfigurator.NonViralNameMatchStrategy();
} catch (MatchException e) {
- logger.error(e);
+ StoreUtil.error(this.getClass(), e);
throw new RuntimeException(e);
}
}
package eu.etaxonomy.taxeditor.preference.matching;
-import org.apache.log4j.Logger;
import org.eclipse.ui.IWorkbench;
import eu.etaxonomy.cdm.model.reference.ReferenceBase;
import eu.etaxonomy.cdm.strategy.match.IMatchStrategy;
import eu.etaxonomy.cdm.strategy.match.MatchException;
import eu.etaxonomy.taxeditor.parser.MatchStrategyConfigurator;
+import eu.etaxonomy.taxeditor.store.StoreUtil;
/**
* @author n.hoffmann
* @version 1.0
*/
public class ReferenceMatchingPreference extends AbstractMatchingPreferences<ReferenceBase> {
- private static final Logger logger = Logger
- .getLogger(ReferenceMatchingPreference.class);
/* (non-Javadoc)
* @see org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)
try {
matchStrategy = MatchStrategyConfigurator.ReferenceMatchStrategy();
} catch (MatchException e) {
- logger.error(e);
+ StoreUtil.error(this.getClass(), e);
throw new RuntimeException(e);
}
}
package eu.etaxonomy.taxeditor.preference.matching;
-import org.apache.log4j.Logger;
import org.eclipse.ui.IWorkbench;
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
import eu.etaxonomy.cdm.strategy.match.IMatchStrategy;
import eu.etaxonomy.cdm.strategy.match.MatchException;
import eu.etaxonomy.taxeditor.parser.MatchStrategyConfigurator;
+import eu.etaxonomy.taxeditor.store.StoreUtil;
/**
* @author n.hoffmann
*/
public class TeamOrPersonMatchingPreference extends
AbstractMatchingPreferences<TeamOrPersonBase> {
- private static final Logger logger = Logger
- .getLogger(TeamOrPersonMatchingPreference.class);
/* (non-Javadoc)
* @see org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)
try {
matchStrategy = MatchStrategyConfigurator.TeamOrPersonMatchStrategy();
} catch (MatchException e) {
- logger.error(e);
+ StoreUtil.error(this.getClass(), e);
throw new RuntimeException(e);
}
}
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
-import java.util.Set;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.jface.viewers.CheckboxTableViewer;
@Override
public void widgetSelected(SelectionEvent e) {
super.widgetSelected(e);
- StoreUtil.notImplementedMessage();
+ StoreUtil.notImplementedMessage(this);
}
});
}
@Override
public void widgetSelected(SelectionEvent e) {
super.widgetSelected(e);
- StoreUtil.notImplementedMessage();
+ StoreUtil.notImplementedMessage(this);
}
});
}
@Override
public void widgetSelected(SelectionEvent e) {
super.widgetSelected(e);
- StoreUtil.notImplementedMessage();
+ StoreUtil.notImplementedMessage(this);
}
});
}
package eu.etaxonomy.taxeditor.preference.menu;
import java.util.Collection;
-import java.util.Set;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.Viewer;
*/
public class DefinedTermBaseContentProvider implements
IStructuredContentProvider {
- private static final Logger logger = Logger
- .getLogger(DefinedTermBaseContentProvider.class);
public Object[] getElements(Object inputElement) {
if(inputElement instanceof Collection){
package eu.etaxonomy.taxeditor.preference.menu;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.swt.graphics.Image;
*/
public class DefinedTermBaseLabelProvider extends LabelProvider implements
ITableLabelProvider {
- private static final Logger logger = Logger
- .getLogger(DefinedTermBaseLabelProvider.class);
/* (non-Javadoc)
* @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnImage(java.lang.Object, int)
package eu.etaxonomy.taxeditor.preference.menu;
-import org.apache.log4j.Logger;
import org.eclipse.jface.wizard.WizardDialog;
-import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
* @version 1.0
*/
public class ExtensionTypeMenuPreferences extends AbstractMenuPreferences<ExtensionType> {
- private static final Logger logger = Logger
- .getLogger(ExtensionTypeMenuPreferences.class);
-
+
/**
*
*/
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.wizard.WizardDialog;
-import org.eclipse.swt.events.MouseAdapter;
-import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
package eu.etaxonomy.taxeditor.preference.menu;
-import java.util.Set;
-
-import org.apache.log4j.Logger;
-
import eu.etaxonomy.cdm.model.common.MarkerType;
import eu.etaxonomy.taxeditor.store.TermStore;
*/
public class MarkerTypeMenuPreferences extends AbstractMenuPreferences<MarkerType>{
-
- private static final Logger logger = Logger
- .getLogger(MarkerTypeMenuPreferences.class);
-
/**
* @param initialVocabulary
* @param title
package eu.etaxonomy.taxeditor.preference.menu;
-import org.apache.log4j.Logger;
-
import eu.etaxonomy.cdm.model.location.NamedAreaType;
import eu.etaxonomy.taxeditor.store.TermStore;
*/
public class NamedAreaTypeMenuPreferences extends AbstractMenuPreferences<NamedAreaType> {
- private static final Logger logger = Logger
- .getLogger(NamedAreaTypeMenuPreferences.class);
-
public NamedAreaTypeMenuPreferences() {
super(TermStore.getNamedAreaTypes(),
"Named Area Types",
public class PresenceAbsenceMenuPreferences extends AbstractMenuPreferences<PresenceAbsenceTermBase> implements
IWorkbenchPreferencePage {
-
/**
* @param initialVocabulary
* @param preferedTerms
package eu.etaxonomy.taxeditor.preference.menu;
-import org.apache.log4j.Logger;
-
import eu.etaxonomy.cdm.model.occurrence.PreservationMethod;
import eu.etaxonomy.taxeditor.store.TermStore;
*/
public class PreservationMethodMenuPreferences extends AbstractMenuPreferences<PreservationMethod> {
- private static final Logger logger = Logger
- .getLogger(PreservationMethodMenuPreferences.class);
-
public PreservationMethodMenuPreferences() {
super(TermStore.getPreservationMethods(),
"Preservation Method Preferences",
package eu.etaxonomy.taxeditor.preference.menu;
-import java.util.Set;
-
-import org.apache.log4j.Logger;
-
import eu.etaxonomy.cdm.model.description.Stage;
import eu.etaxonomy.taxeditor.store.TermStore;
* @version 1.0
*/
public class StageMenuPreferences extends AbstractMenuPreferences<Stage> {
-
- private static final Logger logger = Logger
- .getLogger(StageMenuPreferences.class);
public StageMenuPreferences() {
super(TermStore.getStages(),
package eu.etaxonomy.taxeditor.preference.wizard;
-import org.apache.log4j.Logger;
import org.eclipse.jface.wizard.Wizard;
import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
import eu.etaxonomy.cdm.model.common.Representation;
import eu.etaxonomy.cdm.model.common.VocabularyEnum;
import eu.etaxonomy.taxeditor.store.CdmStore;
+import eu.etaxonomy.taxeditor.store.StoreUtil;
import eu.etaxonomy.taxeditor.store.TermStore;
/**
* @version 1.0
*/
public class VocabularyTermWizard<T extends DefinedTermBase> extends Wizard {
- private static final Logger logger = Logger.getLogger(VocabularyTermWizard.class);
public T term = null;
}
} catch (InstantiationException e) {
- logger.error("InstantiationException when setting term", e);
+ StoreUtil.error(this.getClass(), "InstantiationException when setting term", e);
} catch (IllegalAccessException e) {
- logger.error("IllegalAccessException when setting term", e);
+ StoreUtil.error(this.getClass(), "IllegalAccessException when setting term", e);
}
}
package eu.etaxonomy.taxeditor.preference.wizard;
-import org.apache.log4j.Logger;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CLabel;
super("VOCABULARY_TERM_WIZARD_PAGE");
}
- private static final Logger logger = Logger
- .getLogger(VocabularyTermWizardPage.class);
-
/* (non-Javadoc)
* @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
*/
* @see org.eclipse.swt.events.ModifyListener#modifyText(org.eclipse.swt.events.ModifyEvent)
*/
public void modifyText(ModifyEvent e) {
- logger.warn("modified");
if(text_label.getText().length() > 0){
setPageComplete(true);
import java.util.ArrayList;
import java.util.List;
-import org.apache.log4j.Logger;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
* @version 1.0
*/
public class CdmStore{
- private static final Logger logger = Logger.getLogger(CdmStore.class);
private static class CdmDataStoreConnector implements IRunnableWithProgress{
private ICdmDataSource dataSource;
try{
applicationController = CdmApplicationController.NewInstance(applicationContextBean, dataSource, dbSchemaValidation, false, subprogressMonitor);
}catch(Exception e){
- logger.error(e);
+ StoreUtil.error(this.getClass(), e.getMessage(), e);
}
}
getContextManager().notifyContextStart(monitor);
monitor.done();
- logger.info("Application context initialized.");
+ StoreUtil.info(this.getClass(), "Application context initialized.");
}else{
// Show datasource view if not shown yet
StoreUtil.showView(CdmDataSourceViewPart.ID);
if(!result){
// Show an error message
- StoreUtil.errorDialog("DatabaseCompatibilityCheck failed", "The database schema for the chosen " +
+ StoreUtil.errorDialog("DatabaseCompatibilityCheck failed", this, "The database schema for the chosen " +
"datasource '" + dataSource + "' \n is not valid for this version of the taxonomic editor. \n" +
- "Please update the chosen datasource or choose a new data source to connect to in the Datasource View.");
+ "Please update the chosen datasource or choose a new data source to connect to in the Datasource View.", null);
monitor.setCanceled(true);
}
return;
}
} catch (SQLException e) {
- StoreUtil.errorDialog("Error while trying to retrieve database metadata", "Something is utterly wrong with your database.");
- logger.error(e);
+ StoreUtil.errorDialog("Error while trying to retrieve database metadata", this, "Something is utterly wrong with your database.", e);
+ StoreUtil.error(this.getClass(), e.getMessage(), e);
}
}
dataSource.testConnection();
monitor.worked(1);
} catch (ClassNotFoundException e) {
- StoreUtil.errorDialog("Could not connect to chosen datasource", "Reason: " + e.getMessage());
+ StoreUtil.errorDialog("Could not connect to chosen datasource", this, "Reason: " + e.getMessage(), e);
monitor.setCanceled(true);
} catch (SQLException e) {
- StoreUtil.errorDialog("Could not connect to chosen datasource", "Reason: " + e.getMessage());
+ StoreUtil.errorDialog("Could not connect to chosen datasource", this, "Reason: " + e.getMessage(), e);
monitor.setCanceled(true);
}
return instance;
}else if(!instance.isConnected){
- StoreUtil.warningDialog("No datasource connection", "Application is not connected to a datastore.");
+ StoreUtil.warningDialog("No datasource connection", instance, "Application is not connected to a datastore.");
StoreUtil.showView(CdmDataSourceViewPart.ID);
* @param applicationContextBean
*/
private static void connect(final ICdmDataSource datasource, final DbSchemaValidation dbSchemaValidation, final Resource applicationContextBean){
- logger.info("Connecting to datasource: " + datasource);
+ StoreUtil.info(CdmStore.class, "Connecting to datasource: " + datasource);
try {
ProgressMonitorDialog dialog = new ProgressMonitorDialog(StoreUtil.getShell());
dialog.run(false, true, new CdmDataStoreConnector(datasource, dbSchemaValidation, applicationContextBean));
} catch (InvocationTargetException e) {
- logger.error(e);
+ StoreUtil.error(CdmStore.class, e);
} catch (InterruptedException e) {
- logger.error(e);
+ StoreUtil.error(CdmStore.class, e);
}
}
try{
return applicationController;
}catch(Exception e){
- logger.error("Exception thrown", e);
+ StoreUtil.error(CdmStore.class, e);
}
return null;
}
import java.io.File;
import java.io.FileNotFoundException;
-import org.apache.log4j.Logger;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.ListenerList;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.core.runtime.SubMonitor;
-import org.eclipse.core.runtime.jobs.Job;
-import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchListener;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.XMLMemento;
-import org.eclipse.ui.progress.UIJob;
import eu.etaxonomy.taxeditor.model.IContextListener;
import eu.etaxonomy.taxeditor.model.MementoHelper;
* @version 1.0
*/
public class ContextManager implements IWorkbenchListener{
- private static final Logger logger = Logger.getLogger(ContextManager.class);
private ListenerList contextListeners = new ListenerList();
IProgressMonitor subMonitor = StoreUtil.getSubProgressMonitor(monitor, 1);
subMonitor.beginTask("Starting context", contextListeners.size());
- logger.info("Notifying context listeners, that the context has started.");
+ StoreUtil.info(this.getClass(), "Notifying context listeners, that the context has started.");
readMemento();
IProgressMonitor subMonitor = StoreUtil.getSubProgressMonitor(monitor, 1);
subMonitor.beginTask("Stoping context", contextListeners.size());
- logger.info("Notifying context listeners, that the context has stopped.");
+ StoreUtil.info(this.getClass(), "Notifying context listeners, that the context has stopped.");
for(Object listener : contextListeners.getListeners()){
((IContextListener) listener).contextStop(memento, subMonitor);
memento = MementoHelper.readMementoFromFile(getStateFileForCurrentDatabase());
} catch (FileNotFoundException e) {
// no memento -> no previous state
- logger.info("No state file for datasource");
+ StoreUtil.info(this.getClass(), "No state file for datasource");
}
}
try {
memento = XMLMemento.createWriteRoot(CdmStore.getDataSource().getName());
- logger.info("DataSource found. Memento created.");
+ StoreUtil.info(this.getClass(), "DataSource found. Memento created.");
} catch (Exception e) {
// The memento could not be created, but a not closable editor is avoided for this case.
- logger.error("The memento could not be created: " + e.getMessage());
+ StoreUtil.error(this.getClass(), "The memento could not be created", e);
}
} else {
- logger.info("Not storing state data, because no DataSource present.");
+ StoreUtil.info(this.getClass(), "Not storing state data, because no DataSource present.");
}
}
import java.util.Observable;
-import org.apache.log4j.Logger;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
* @version 1.0
*/
public class LoginManager extends Observable{
- private static final Logger logger = Logger.getLogger(LoginManager.class);
/**
* @param token
package eu.etaxonomy.taxeditor.store;
-import org.apache.log4j.Logger;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.ui.IMemento;
* @version 1.0
*/
public class StoreStateManager extends ContextListenerAdapter {
- private static final Logger logger = Logger
- .getLogger(StoreStateManager.class);
/* (non-Javadoc)
* @see eu.etaxonomy.taxeditor.model.IContextListener#contextStart(org.eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
return IOperationHistory.GLOBAL_UNDO_CONTEXT;
}
-
+ protected static String getPluginId(){
+ return TaxeditorStorePlugin.PLUGIN_ID;
+ }
}
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
+import eu.etaxonomy.cdm.model.occurrence.DeterminationModifier;
import eu.etaxonomy.cdm.model.occurrence.PreservationMethod;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
return getTerms(Scope.class);
}
+ /**
+ * @return
+ */
+ public static List<DeterminationModifier> getDeterminationModifiers() {
+ return getTerms(DeterminationModifier.class);
+ }
+
/*************** save methods ******************************/
/**
* Adds a term to a vocabulary
return terms;
}
-
-
-
}
package eu.etaxonomy.taxeditor.store.internal;
-import org.apache.log4j.Logger;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.ui.plugin.AbstractUIPlugin;
* The activator class controls the plug-in life cycle
*/
public class TaxeditorStorePlugin extends AbstractUIPlugin {
-
- public static final Logger logger = Logger.getLogger(TaxeditorStorePlugin.class);
// The plug-in ID
public static final String PLUGIN_ID = "eu.etaxonomy.taxeditor.editor";
plugin = this;
PreferencesUtil.setDefaults();
-
- logger.trace("Plugin started: " + this.getBundle().getSymbolicName());
}
/*
public void stop(BundleContext context) throws Exception {
plugin = null;
super.stop(context);
- logger.trace("Plugin stopped");
}
/**
public ImageRegistry createImageRegistry(){
return super.createImageRegistry();
}
-
- /************************ ERROR CODES ****************************/
-
- /**
- * An attempt was made to save a taxon with a zero length name
- */
- public static final int ERROR_SAVING_ZERO_NAME = 52000;
}
package eu.etaxonomy.taxeditor.user.handler;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
* @version 1.0
*/
public class CreateUserHandler extends AbstractHandler {
- private static final Logger logger = Logger
- .getLogger(CreateUserHandler.class);
/* (non-Javadoc)
* @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)
package eu.etaxonomy.taxeditor.user.handler;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
* @version 1.0
*/
public class EditUserHandler extends AbstractHandler {
- private static final Logger logger = Logger
- .getLogger(EditUserHandler.class);
/* (non-Javadoc)
* @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)
package eu.etaxonomy.taxeditor.user.handler;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
* @version 1.0
*/
public class ToggleUserEnablementHandler extends AbstractHandler {
- private static final Logger logger = Logger
- .getLogger(ToggleUserEnablementHandler.class);
/* (non-Javadoc)
* @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)
StoreUtil.executeOperation(operation);
} catch (NotDefinedException e) {
- logger.warn("Command name not set");
+ StoreUtil.warn(this.getClass(), "Command name not set");
}
}
import java.util.List;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.Viewer;
* @version 1.0
*/
public class UserManagerContentProvider implements IStructuredContentProvider {
- private static final Logger logger = Logger
- .getLogger(UserManagerContentProvider.class);
/* (non-Javadoc)
* @see org.eclipse.jface.viewers.IContentProvider#dispose()
package eu.etaxonomy.taxeditor.user.view;
-import org.apache.log4j.Logger;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.swt.graphics.Image;
* @version 1.0
*/
public class UserManagerLabelProvider extends LabelProvider implements ITableLabelProvider {
- private static final Logger logger = Logger
- .getLogger(UserManagerLabelProvider.class);
public Image getColumnImage(Object element, int columnIndex) {
return null;
import java.util.List;
-import org.apache.log4j.Logger;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.action.GroupMarker;
import org.eclipse.jface.action.MenuManager;
* @version 1.0
*/
public class UserManagerView extends ViewPart implements IConversationEnabled, IPostOperationEnabled{
- private static final Logger logger = Logger
- .getLogger(UserManagerView.class);
private class ContextListener extends ContextListenerAdapter{
package eu.etaxonomy.taxeditor.user.wizard;
-import org.apache.log4j.Logger;
-import org.eclipse.core.commands.operations.IUndoableOperation;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.wizard.Wizard;
* @version 1.0
*/
public class UserWizard extends Wizard {
- private static final Logger logger = Logger.getLogger(UserWizard.class);
private User user;
private UserWizardPage page;
private UserManagerView view;
package eu.etaxonomy.taxeditor.user.wizard;
-import org.apache.log4j.Logger;
import org.eclipse.jface.dialogs.IInputValidator;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
BGBM BDI Projects / taxeditor.git / commitdiff