[Schmitzm-commits] r1163 - in trunk: src/schmitzm/geotools/feature src/schmitzm/swing src/skrueger/geotools/io src_junit/skrueger/geotools/io
scm-commit@wald.intevation.org
scm-commit at wald.intevation.org
Mon Oct 25 00:55:44 CEST 2010
Author: alfonx
Date: 2010-10-25 00:55:43 +0200 (Mon, 25 Oct 2010)
New Revision: 1163
Added:
trunk/src_junit/skrueger/geotools/io/DbSettingsJComboBoxTest.java
trunk/src_junit/skrueger/geotools/io/WfsSettingsJComboBoxTest.java
Modified:
trunk/src/schmitzm/geotools/feature/FeatureTypeBuilderTableModel.java
trunk/src/schmitzm/swing/BooleanInputOption.java
trunk/src/schmitzm/swing/ManualInputOption.java
trunk/src/skrueger/geotools/io/DbServerSettings.java
trunk/src/skrueger/geotools/io/WfsServerList.java
trunk/src/skrueger/geotools/io/WfsServerSettings.java
trunk/src/skrueger/geotools/io/WfsSettingsJComboBox.java
trunk/src_junit/skrueger/geotools/io/WfsServerSettingsTest.java
Log:
Improved the AtlasStyler Import-Wizard GUIwise
Modified: trunk/src/schmitzm/geotools/feature/FeatureTypeBuilderTableModel.java
===================================================================
--- trunk/src/schmitzm/geotools/feature/FeatureTypeBuilderTableModel.java 2010-10-24 16:55:46 UTC (rev 1162)
+++ trunk/src/schmitzm/geotools/feature/FeatureTypeBuilderTableModel.java 2010-10-24 22:55:43 UTC (rev 1163)
@@ -64,347 +64,407 @@
import com.vividsolutions.jts.geom.Polygon;
/**
- * Diese Klasse stellt ein {@link TableModel} auf einem "unfertigen" {@link SimpleFeatureType}
- * dar. Dieses definiert vier Spalten:
+ * Diese Klasse stellt ein {@link TableModel} auf einem "unfertigen"
+ * {@link SimpleFeatureType} dar. Dieses definiert vier Spalten:
* <ol>
- * <li>Attribut-Name als Text-Eingabe</li>
- * <li>Attribut-Typ als Auswahl-Feld</li>
- * <li>"Nillable"-Eigenschaft als Check-Box</li>
- * <li>"AutoValue"-Eigenschaft als Check-Box</li>
- * <li>Standard-Wert als Text-Eingabe</li>
+ * <li>Attribut-Name als Text-Eingabe</li>
+ * <li>Attribut-Typ als Auswahl-Feld</li>
+ * <li>"Nillable"-Eigenschaft als Check-Box</li>
+ * <li>"AutoValue"-Eigenschaft als Check-Box</li>
+ * <li>Standard-Wert als Text-Eingabe</li>
* </ol>
* Da das {@link TableModel} auf einem {@link FeatureTypeBuilder} basiert,
* bietet es die Moeglichkeit, Attribute hinzuzufuegen oder zu loeschen.
- * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a> (University of Bonn/Germany)
+ *
+ * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a>
+ * (University of Bonn/Germany)
* @version 1.0
*/
public class FeatureTypeBuilderTableModel extends AbstractMutableTableModel {
- /** Zur Verfuegung stehende Attribut-Typen. */
- public static final Class<?>[] ATTR_TYPES = new Class[] {
- String.class,
- Integer.class,
- Long.class,
- Byte.class,
- Boolean.class,
- Double.class,
- Float.class,
- BigInteger.class,
- BigDecimal.class,
- Point.class,
- LineString.class,
- Polygon.class
- };
+ /** Zur Verfuegung stehende Attribut-Typen. */
+ public static final Class<?>[] ATTR_TYPES = new Class[] { String.class,
+ Integer.class, Long.class, Byte.class, Boolean.class, Double.class,
+ Float.class, BigInteger.class, BigDecimal.class, Point.class,
+ LineString.class, Polygon.class };
- public static final String[] ATTR_TYPES_DESC = new String[ATTR_TYPES.length];
- static {
- for (int i=0; i<ATTR_TYPES_DESC.length; i++)
- ATTR_TYPES_DESC[i] = ATTR_TYPES[i].getSimpleName();
- }
+ public static final String[] ATTR_TYPES_DESC = new String[ATTR_TYPES.length];
+ static {
+ for (int i = 0; i < ATTR_TYPES_DESC.length; i++)
+ ATTR_TYPES_DESC[i] = ATTR_TYPES[i].getSimpleName();
+ }
+ /** Die in der Tabelle dargestellten Attribute. */
+ protected Vector<AttributeDefinition> attrDefinitions = new Vector<AttributeDefinition>();
- /** Die in der Tabelle dargestellten Attribute. */
- protected Vector<AttributeDefinition> attrDefinitions = new Vector<AttributeDefinition>();
+ /** {@link SimpleFeatureTypeBuilder} der in der Tabelle dargestellt wird. */
+ protected SimpleFeatureTypeBuilder featureTypeBuilder = null;
- /** {@link SimpleFeatureTypeBuilder} der in der Tabelle dargestellt wird. */
- protected SimpleFeatureTypeBuilder featureTypeBuilder = null;
+ /**
+ * Erstellt ein leeres Tabellen-Modell.
+ */
+ public FeatureTypeBuilderTableModel() {
+ this(null, null);
+ }
- /**
- * Erstellt ein leeres Tabellen-Modell.
- */
- public FeatureTypeBuilderTableModel() {
- this(null,null);
- }
+ /**
+ * Erstellt ein neues Tabellen-Modell.
+ *
+ * @param type
+ * ein SimpleFeatureType, der editiert wird
+ * @param typeName
+ * (neuer) Name fuer via {@link #createFeatureType()} erzeugte
+ * {@link SimpleFeatureType} (wenn {@code null}, wird der Name
+ * von {@code type} verwendet oder ein Default!)
+ */
+ public FeatureTypeBuilderTableModel(SimpleFeatureType type, String typeName) {
+ super();
+ setFeatureType(type, typeName);
+ }
- /**
- * Erstellt ein neues Tabellen-Modell.
- * @param type ein SimpleFeatureType, der editiert wird
- * @param typeName (neuer) Name fuer via {@link #createFeatureType()}
- * erzeugte {@link SimpleFeatureType} (wenn {@code null}, wird
- * der Name von {@code type} verwendet oder ein Default!)
- */
- public FeatureTypeBuilderTableModel(SimpleFeatureType type, String typeName) {
- super();
- setFeatureType(type, typeName);
- }
+ /**
+ * Liefert die Spaltennamen der Tabelle.
+ */
+ public String[] createColumnNames() {
+ return new String[] {
+ GeotoolsGUIUtil.RESOURCE
+ .getString("schmitzm.geotools.gui.FeatureTypeBuilderTableModel.AttrName"),
+ GeotoolsGUIUtil.RESOURCE
+ .getString("schmitzm.geotools.gui.FeatureTypeBuilderTableModel.AttrType"),
+ GeotoolsGUIUtil.RESOURCE
+ .getString("schmitzm.geotools.gui.FeatureTypeBuilderTableModel.Nillable"),
+ GeotoolsGUIUtil.RESOURCE
+ .getString("schmitzm.geotools.gui.FeatureTypeBuilderTableModel.AutoValue"),
+ GeotoolsGUIUtil.RESOURCE
+ .getString("schmitzm.geotools.gui.FeatureTypeBuilderTableModel.DefValue") };
+ }
- /**
- * Liefert die Spaltennamen der Tabelle.
- */
- public String[] createColumnNames() {
- return new String[] {
- GeotoolsGUIUtil.RESOURCE.getString("schmitzm.geotools.gui.FeatureTypeBuilderTableModel.AttrName"),
- GeotoolsGUIUtil.RESOURCE.getString("schmitzm.geotools.gui.FeatureTypeBuilderTableModel.AttrType"),
- GeotoolsGUIUtil.RESOURCE.getString("schmitzm.geotools.gui.FeatureTypeBuilderTableModel.Nillable"),
- GeotoolsGUIUtil.RESOURCE.getString("schmitzm.geotools.gui.FeatureTypeBuilderTableModel.AutoValue"),
- GeotoolsGUIUtil.RESOURCE.getString("schmitzm.geotools.gui.FeatureTypeBuilderTableModel.DefValue")
- };
- }
+ /**
+ * Setzt {@link CellRenderer} und {@link CellEditor} fuer die Tabelle, sowie
+ * eine adaequate Zeilen-Hoehe.
+ */
+ @Override
+ public void initTable(JTable table) {
+ table.setRowHeight(new JComboBox(new String[] { "Dummy" })
+ .getPreferredSize().height);
+ table.getColumnModel().getColumn(0)
+ .setCellRenderer(new ComponentRenderer.JTextField());
+ table.getColumnModel().getColumn(1)
+ .setCellRenderer(new ComponentRenderer.JComboBox());
+ table.getColumnModel().getColumn(2)
+ .setCellRenderer(new ComponentRenderer.JCheckBox());
+ table.getColumnModel().getColumn(3)
+ .setCellRenderer(new ComponentRenderer.JCheckBox());
+ table.getColumnModel().getColumn(4)
+ .setCellRenderer(new ComponentRenderer.JTextField());
+ table.getColumnModel().getColumn(0)
+ .setCellEditor(new DefaultCellEditor(new JTextField()));
+ table.getColumnModel()
+ .getColumn(1)
+ .setCellEditor(
+ new DefaultCellEditor(new JComboBox(ATTR_TYPES_DESC)));
+ table.getColumnModel().getColumn(2)
+ .setCellEditor(new DefaultCellEditor(new JCheckBox() {
+ public int getHorizontalAlignment() {
+ return this.CENTER;
+ }
- /**
- * Setzt {@link CellRenderer} und {@link CellEditor} fuer die Tabelle, sowie
- * eine adaequate Zeilen-Hoehe.
- */
- @Override
- public void initTable(JTable table) {
- table.setRowHeight( new JComboBox(new String[] {"Dummy"}).getPreferredSize().height );
- table.getColumnModel().getColumn(0).setCellRenderer( new ComponentRenderer.JTextField() );
- table.getColumnModel().getColumn(1).setCellRenderer( new ComponentRenderer.JComboBox() );
- table.getColumnModel().getColumn(2).setCellRenderer( new ComponentRenderer.JCheckBox() );
- table.getColumnModel().getColumn(3).setCellRenderer( new ComponentRenderer.JCheckBox() );
- table.getColumnModel().getColumn(4).setCellRenderer( new ComponentRenderer.JTextField() );
- table.getColumnModel().getColumn(0).setCellEditor( new DefaultCellEditor( new JTextField() ) );
- table.getColumnModel().getColumn(1).setCellEditor( new DefaultCellEditor( new JComboBox( ATTR_TYPES_DESC ) ) );
- table.getColumnModel().getColumn(2).setCellEditor( new DefaultCellEditor( new JCheckBox() {
- public int getHorizontalAlignment() {
- return this.CENTER;
- }
- public int getVerticalAlignment() {
- return this.CENTER;
- }
- }));
- table.getColumnModel().getColumn(3).setCellEditor( new DefaultCellEditor( new JCheckBox() {
- public int getHorizontalAlignment() {
- return this.CENTER;
- }
- public int getVerticalAlignment() {
- return this.CENTER;
- }
- }));
- table.getColumnModel().getColumn(4).setCellEditor( new DefaultCellEditor( new JTextField() ) );
- }
+ public int getVerticalAlignment() {
+ return this.CENTER;
+ }
+ }));
+ table.getColumnModel().getColumn(3)
+ .setCellEditor(new DefaultCellEditor(new JCheckBox() {
+ public int getHorizontalAlignment() {
+ return this.CENTER;
+ }
- /**
- * Liefert die Anzahl an Attributen in der Tabelle.
- */
- public int getRowCount() {
- return attrDefinitions.size();
- }
+ public int getVerticalAlignment() {
+ return this.CENTER;
+ }
+ }));
+ table.getColumnModel().getColumn(4)
+ .setCellEditor(new DefaultCellEditor(new JTextField()));
+ }
- /**
- * Setzt den {@link FeatureTypeBuilder}, der in der Tabelle dargestellt wird.
- * Dieser wird mit den Attributen des angegebenen {@link SimpleFeatureType}
- * initialisiert
- * @param ftype {@link SimpleFeatureType}
- * @param typeName new name for the {@link SimpleFeatureType} (can be {@code null})
- */
- public void setFeatureType(SimpleFeatureType ftype, String typeName) {
- // Attribut-Typen in Array speichern
- attrDefinitions.clear();
- if ( featureTypeBuilder != null )
- for (AttributeDescriptor aDesc : ftype.getAttributeDescriptors()) {
- attrDefinitions.add( new AttributeDefinition(
- aDesc.getLocalName(),
- aDesc.getType().getBinding(),
- aDesc.isNillable(),
- false,
- aDesc.getDefaultValue()
- ) );
- }
-
- this.featureTypeBuilder = new SimpleFeatureTypeBuilder();
- this.featureTypeBuilder.init(ftype);
-
- // Set (new) name for FeatureType
- if ( typeName != null )
- this.featureTypeBuilder.setName(typeName);
- else if ( ftype != null )
- this.featureTypeBuilder.setName(ftype.getName());
- else
- this.featureTypeBuilder.setName("NewFeatureType");
-
- this.fireTableDataChanged();
- }
+ /**
+ * Liefert die Anzahl an Attributen in der Tabelle.
+ */
+ public int getRowCount() {
+ return attrDefinitions.size();
+ }
- /**
- * Erzeugt einen neuen {@link SimpleFeatureType}, aus den in der Tabelle dargestellen
- * Attributen.
- */
- public SimpleFeatureType createFeatureType() {
- featureTypeBuilder.init(null);
- for (AttributeDefinition aDef : attrDefinitions) {
- AttributeDescriptor aDesc = aDef.createAttributeType();
- featureTypeBuilder.add( aDesc );
- if ( featureTypeBuilder.getDefaultGeometry() == null &&
- aDesc instanceof GeometryAttributeType )
- featureTypeBuilder.setDefaultGeometry( aDesc.getLocalName() );
- }
- return this.featureTypeBuilder.buildFeatureType();
- }
+ /**
+ * Setzt den {@link FeatureTypeBuilder}, der in der Tabelle dargestellt
+ * wird. Dieser wird mit den Attributen des angegebenen
+ * {@link SimpleFeatureType} initialisiert
+ *
+ * @param ftype
+ * {@link SimpleFeatureType}
+ * @param typeName
+ * new name for the {@link SimpleFeatureType} (can be
+ * {@code null})
+ */
+ public void setFeatureType(SimpleFeatureType ftype, String typeName) {
+ // Attribut-Typen in Array speichern
+ attrDefinitions.clear();
+ if (featureTypeBuilder != null)
+ for (AttributeDescriptor aDesc : ftype.getAttributeDescriptors()) {
+ attrDefinitions.add(new AttributeDefinition(aDesc
+ .getLocalName(), aDesc.getType().getBinding(), aDesc
+ .isNillable(), false, aDesc.getDefaultValue()));
+ }
- /**
- * Prueft, ob eine Tabellen-Zelle editierbar ist.
- * @return {@code true} fuer jede Zelle
- */
- public boolean isCellEditable(int rowIndex, int columnIndex) {
- return true;
- }
+ this.featureTypeBuilder = new SimpleFeatureTypeBuilder();
+ this.featureTypeBuilder.init(ftype);
- /**
- * Liefert einen Wert der Tabelle.
- * @param rowIndex Zeilen-Index (beginnend bei 0)
- * @param columnIndex Spalten-Index (beginnend bei 0)
- */
- public Object getValueAt(int rowIndex, int columnIndex) {
- AttributeDefinition aDef = attrDefinitions.elementAt(rowIndex);
- switch ( columnIndex ) {
- case 0: return aDef.name.getValue();
- case 1: return aDef.type.getSelectedDisplayItem();
- case 2: return aDef.nillable.getValue();
- case 3: return aDef.autoValue.getValue();
- case 4: return aDef.defaultValue.getValue();
- }
- return null;
- }
+ // Set (new) name for FeatureType
+ if (typeName != null)
+ this.featureTypeBuilder.setName(typeName);
+ else if (ftype != null)
+ this.featureTypeBuilder.setName(ftype.getName());
+ else
+ this.featureTypeBuilder.setName("NewFeatureType");
- /**
- * Setzt einen Wert der Tabelle.
- * @param value neuer Wert
- * @param rowIndex Zeilen-Index (beginnend bei 0)
- * @param columnIndex Spalten-Index (beginnend bei 0)
- */
- public void setValueAt(Object value, int rowIndex, int columnIndex) {
- AttributeDefinition aDef = attrDefinitions.elementAt(rowIndex);
- switch ( columnIndex ) {
- case 0: // Attribut-Namen automatisch konvertieren
- try {
- FeatureUtil.checkAttributeNameRestrictionsAndError((String)value);
- value = FeatureUtil.applyAttributeNameRestrictions((String)value);
- aDef.name.setValue(value);
- } catch (Exception err) {
- ExceptionDialog.show(
- null,
- err,
- FeatureUtil.RESOURCE.getString("org.geotools.err.attr.name"),
- "<html><center><b>"+value+"</b></center>"+err.getMessage()+"</html>",
- false
- );
- }
- break;
- case 1: aDef.type.setSelectedDisplayItem(value); break;
- case 2: aDef.nillable.setValue(value); break;
- case 3: aDef.autoValue.setValue(value); break;
- case 4: aDef.defaultValue.setValue(value); break;
- }
- }
+ this.fireTableDataChanged();
+ }
- /**
- * Fuegt der Tabelle ein neues Standard-Attribut hinzu.
- */
- public void performAddRow() {
- AttributeDefinition newAttrDef = new AttributeDefinition();
- String presetName = GeotoolsGUIUtil.RESOURCE.getString("schmitzm.geotools.gui.FeatureTypeBuilderTableModel.NewAttr",getRowCount() );
- newAttrDef.name.setValue( presetName );
- attrDefinitions.add( newAttrDef );
- fireTableDataChanged();
- }
+ /**
+ * Erzeugt einen neuen {@link SimpleFeatureType}, aus den in der Tabelle
+ * dargestellen Attributen.
+ */
+ public SimpleFeatureType createFeatureType() {
+ featureTypeBuilder.init(null);
+ for (AttributeDefinition aDef : attrDefinitions) {
+ AttributeDescriptor aDesc = aDef.createAttributeType();
+ featureTypeBuilder.add(aDesc);
+ if (featureTypeBuilder.getDefaultGeometry() == null
+ && aDesc instanceof GeometryAttributeType)
+ featureTypeBuilder.setDefaultGeometry(aDesc.getLocalName());
+ }
+ return this.featureTypeBuilder.buildFeatureType();
+ }
- /**
- * Macht nichts.
- */
- public void performChangeData(int row, int col) {
- // does nothing
- }
+ /**
+ * Prueft, ob eine Tabellen-Zelle editierbar ist.
+ *
+ * @return {@code true} fuer jede Zelle
+ */
+ public boolean isCellEditable(int rowIndex, int columnIndex) {
+ return true;
+ }
- /**
- * Entfernt ein Attribut aus der Tabelle.
- */
- public void performRemoveRow(int row) {
- attrDefinitions.removeElementAt(row);
- fireTableDataChanged();
- }
+ /**
+ * Liefert einen Wert der Tabelle.
+ *
+ * @param rowIndex
+ * Zeilen-Index (beginnend bei 0)
+ * @param columnIndex
+ * Spalten-Index (beginnend bei 0)
+ */
+ public Object getValueAt(int rowIndex, int columnIndex) {
+ AttributeDefinition aDef = attrDefinitions.elementAt(rowIndex);
+ switch (columnIndex) {
+ case 0:
+ return aDef.name.getValue();
+ case 1:
+ return aDef.type.getSelectedDisplayItem();
+ case 2:
+ return aDef.nillable.getValue();
+ case 3:
+ return aDef.autoValue.getValue();
+ case 4:
+ return aDef.defaultValue.getValue();
+ }
+ return null;
+ }
- /**
- * Defines an Attribute displayed in the table. The advantage of this helper
- * class is that it does <b>not</b> check the consistency of the inputs
- * immediately on the input! This is importend richtig
- *
- * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a> (University of Bonn/Germany)
- *
- */
- protected class AttributeDefinition {
- /** Manual input field for the attribute name. */
- protected ManualInputOption.Text name;
- /** Choice input field for the attribute type.
- * @see FeatureTypeBuilderTableModel.ATTR_TYPES */
- protected SelectionInputOption.Combo<Class> type = null;
- /** Manual input field for the attribute's default value. */
- protected ManualInputOption.Text defaultValue;
- /** Checkbox for the attribute's nillable property. */
- protected BooleanInputOption nillable = null;
- /** Checkbox to indicate that the attribute value is generated
- * automatically. */
- protected BooleanInputOption autoValue = null;
+ /**
+ * Setzt einen Wert der Tabelle.
+ *
+ * @param value
+ * neuer Wert
+ * @param rowIndex
+ * Zeilen-Index (beginnend bei 0)
+ * @param columnIndex
+ * Spalten-Index (beginnend bei 0)
+ */
+ public void setValueAt(Object value, int rowIndex, int columnIndex) {
+ AttributeDefinition aDef = attrDefinitions.elementAt(rowIndex);
+ switch (columnIndex) {
+ case 0: // Attribut-Namen automatisch konvertieren
+ try {
+ FeatureUtil
+ .checkAttributeNameRestrictionsAndError((String) value);
+ value = FeatureUtil
+ .applyAttributeNameRestrictions((String) value);
+ aDef.name.setValue(value);
+ } catch (Exception err) {
+ ExceptionDialog.show(
+ null,
+ err,
+ FeatureUtil.RESOURCE
+ .getString("org.geotools.err.attr.name"),
+ "<html><center><b>" + value + "</b></center>"
+ + err.getMessage() + "</html>", false);
+ }
+ break;
+ case 1:
+ aDef.type.setSelectedDisplayItem(value);
+ break;
+ case 2:
+ aDef.nillable.setValue(value);
+ break;
+ case 3:
+ aDef.autoValue.setValue(value);
+ break;
+ case 4:
+ aDef.defaultValue.setValue(value);
+ break;
+ }
+ }
- /**
- * Creates an empty attribute definition.
- */
- public AttributeDefinition() {
- name = new ManualInputOption.Text(null, true);
- type = new SelectionInputOption.Combo<Class>(null,true,ATTR_TYPES,0,ATTR_TYPES_DESC);
- defaultValue = new ManualInputOption.Text(null,false); // Default value is not mandatory
- nillable = new BooleanInputOption(null,true);
- autoValue = new BooleanInputOption(null,false);
- }
+ /**
+ * Fuegt der Tabelle ein neues Standard-Attribut hinzu.
+ */
+ public void performAddRow() {
+ AttributeDefinition newAttrDef = new AttributeDefinition();
+ String presetName = GeotoolsGUIUtil.RESOURCE.getString(
+ "schmitzm.geotools.gui.FeatureTypeBuilderTableModel.NewAttr",
+ getRowCount());
+ newAttrDef.name.setValue(presetName);
+ attrDefinitions.add(newAttrDef);
+ fireTableDataChanged();
+ }
- /**
- * Creates a new attribute definition. The consistency of the inputs (e.g. type and default
- * value) is not checked before {@link #createAttributeType()} is called.
- * @param name name of the attribute
- * @param type value type of the attribute
- * @param nillable indicates whether the attribute is mandatory
- * @param defaultValue default value for the attribute
- */
- public AttributeDefinition(String name, Class type, boolean nillable, boolean autoValue, Object defaultValue) {
- this();
- this.name.setValue(name);
- this.type.setValue(type);
- this.nillable.setValue(nillable);
- this.autoValue.setValue(autoValue);
- this.defaultValue.setValue(defaultValue);
- }
+ /**
+ * Macht nichts.
+ */
+ public void performChangeData(int row, int col) {
+ // does nothing
+ }
- /**
- * Creates an {@link AttributeDescriptor} from the definition.
- * @return {@link DefaultAttributeType} or {@link GeometricAttributeType}
- */
- public AttributeDescriptor createAttributeType() {
- try {
- FeatureUtil.checkAttributeNameRestrictionsAndError( name.getValue() );
- } catch (Exception err) {
- throw new UnsupportedOperationException("<html><b><center>"+name.getValue()+"</b></center>"+err.getMessage()+"</html>",err);
- }
-
- Class type = (Class)this.type.getValue();
- boolean nillable = (Boolean)this.nillable.getValue();
- Object defaultValue = this.defaultValue.getValue();
- if ( "".equals(defaultValue) )
- defaultValue = null;
- if ( defaultValue != null && Number.class.isAssignableFrom(type) )
- defaultValue = BaseTypeUtil.convertFromString(defaultValue.toString(), type);
- if ( defaultValue == null && !nillable )
- defaultValue = FeatureUtil.getDefaultAttributeValue(type);
+ /**
+ * Entfernt ein Attribut aus der Tabelle.
+ */
+ public void performRemoveRow(int row) {
+ attrDefinitions.removeElementAt(row);
+ fireTableDataChanged();
+ }
- AttributeDescriptor aType = AttributeTypeFactory.newAttributeType(
- (String)name.getValue(),
- type,
- nillable,
- null,
- defaultValue,
- null
- );
+ /**
+ * Defines an Attribute displayed in the table. The advantage of this helper
+ * class is that it does <b>not</b> check the consistency of the inputs
+ * immediately on the input! This is importend richtig
+ *
+ * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a>
+ * (University of Bonn/Germany)
+ *
+ */
+ protected class AttributeDefinition {
+ /** Manual input field for the attribute name. */
+ protected ManualInputOption.Text name;
+ /**
+ * Choice input field for the attribute type.
+ *
+ * @see FeatureTypeBuilderTableModel.ATTR_TYPES
+ */
+ protected SelectionInputOption.Combo<Class> type = null;
+ /** Manual input field for the attribute's default value. */
+ protected ManualInputOption.Text defaultValue;
+ /** Checkbox for the attribute's nillable property. */
+ protected BooleanInputOption nillable = null;
+ /**
+ * Checkbox to indicate that the attribute value is generated
+ * automatically.
+ */
+ protected BooleanInputOption autoValue = null;
- AutoValueGenerator<?> valueGenerator = null;
- if ( autoValue.getValue() ) {
- if ( Number.class.isAssignableFrom(type) )
- valueGenerator = new NumberValueGenerator((Number)defaultValue);
- else
- throw new UnsupportedOperationException( GeotoolsGUIUtil.RESOURCE.getString("schmitzm.geotools.gui.JMapEditorToolBar.NewLayer.Err.AutoVal", type.getSimpleName()));
- FeatureUtil.registerAutoValueGenerator(aType, valueGenerator);
- } else
- FeatureUtil.unregisterAutoValueGenerator(aType);
+ /**
+ * Creates an empty attribute definition.
+ */
+ public AttributeDefinition() {
+ name = new ManualInputOption.Text(null, true);
+ type = new SelectionInputOption.Combo<Class>(null, true,
+ ATTR_TYPES, 0, ATTR_TYPES_DESC);
+ defaultValue = new ManualInputOption.Text(null, false); // Default
+ // value is
+ // not
+ // mandatory
+ nillable = new BooleanInputOption((String) null, true);
+ autoValue = new BooleanInputOption((String) null, false);
+ }
+ /**
+ * Creates a new attribute definition. The consistency of the inputs
+ * (e.g. type and default value) is not checked before
+ * {@link #createAttributeType()} is called.
+ *
+ * @param name
+ * name of the attribute
+ * @param type
+ * value type of the attribute
+ * @param nillable
+ * indicates whether the attribute is mandatory
+ * @param defaultValue
+ * default value for the attribute
+ */
+ public AttributeDefinition(String name, Class type, boolean nillable,
+ boolean autoValue, Object defaultValue) {
+ this();
+ this.name.setValue(name);
+ this.type.setValue(type);
+ this.nillable.setValue(nillable);
+ this.autoValue.setValue(autoValue);
+ this.defaultValue.setValue(defaultValue);
+ }
- return aType;
- }
- }
+ /**
+ * Creates an {@link AttributeDescriptor} from the definition.
+ *
+ * @return {@link DefaultAttributeType} or
+ * {@link GeometricAttributeType}
+ */
+ public AttributeDescriptor createAttributeType() {
+ try {
+ FeatureUtil.checkAttributeNameRestrictionsAndError(name
+ .getValue());
+ } catch (Exception err) {
+ throw new UnsupportedOperationException("<html><b><center>"
+ + name.getValue() + "</b></center>" + err.getMessage()
+ + "</html>", err);
+ }
+
+ Class type = (Class) this.type.getValue();
+ boolean nillable = (Boolean) this.nillable.getValue();
+ Object defaultValue = this.defaultValue.getValue();
+ if ("".equals(defaultValue))
+ defaultValue = null;
+ if (defaultValue != null && Number.class.isAssignableFrom(type))
+ defaultValue = BaseTypeUtil.convertFromString(
+ defaultValue.toString(), type);
+ if (defaultValue == null && !nillable)
+ defaultValue = FeatureUtil.getDefaultAttributeValue(type);
+
+ AttributeDescriptor aType = AttributeTypeFactory.newAttributeType(
+ (String) name.getValue(), type, nillable, null,
+ defaultValue, null);
+
+ AutoValueGenerator<?> valueGenerator = null;
+ if (autoValue.getValue()) {
+ if (Number.class.isAssignableFrom(type))
+ valueGenerator = new NumberValueGenerator(
+ (Number) defaultValue);
+ else
+ throw new UnsupportedOperationException(
+ GeotoolsGUIUtil.RESOURCE
+ .getString(
+ "schmitzm.geotools.gui.JMapEditorToolBar.NewLayer.Err.AutoVal",
+ type.getSimpleName()));
+ FeatureUtil.registerAutoValueGenerator(aType, valueGenerator);
+ } else
+ FeatureUtil.unregisterAutoValueGenerator(aType);
+
+ return aType;
+ }
+ }
}
Modified: trunk/src/schmitzm/swing/BooleanInputOption.java
===================================================================
--- trunk/src/schmitzm/swing/BooleanInputOption.java 2010-10-24 16:55:46 UTC (rev 1162)
+++ trunk/src/schmitzm/swing/BooleanInputOption.java 2010-10-24 22:55:43 UTC (rev 1163)
@@ -31,88 +31,121 @@
import javax.swing.JCheckBox;
+import org.geotools.data.DataAccessFactory.Param;
+
/**
- * Diese Klasse stellt eine boolsche Eingabe-Option fuer das {@link MultipleOptionPane}
- * dar. Diese wird durch eine {@link JCheckBox} dargestellt.
- * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a> (University of Bonn/Germany)
+ * Diese Klasse stellt eine boolsche Eingabe-Option fuer das
+ * {@link MultipleOptionPane} dar. Diese wird durch eine {@link JCheckBox}
+ * dargestellt.
+ *
+ * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a>
+ * (University of Bonn/Germany)
* @version 1.0
*/
public class BooleanInputOption extends InputOption {
- /**
- * Erzeugt eine neue Eingabe-Option.
- * @param label Beschreibung
- * @param defValue gibt an, ob die Checkbox standardmaessig aktiviert ist
- */
- public BooleanInputOption(String label, boolean defValue) {
- super(label,false);
- // Bei einer Checkbox soll die Beschreibung nicht oberhalb
- // des Eingabefeldes zu stehen, sondern mit der Checkbox in
- // einer Zeile
- // -> JLabel entfernen und statt dessen den Text der Checkbox setzen
- this.remove( this.descLabel );
- ((JCheckBox)inpComp).setText(label);
- // Standardwert setzen
- setValue( defValue );
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option.
+ *
+ * @param label
+ * Beschreibung
+ * @param defValue
+ * gibt an, ob die Checkbox standardmaessig aktiviert ist
+ */
+ public BooleanInputOption(String label, Boolean defValue) {
+ super(label, false);
+ // Bei einer Checkbox soll die Beschreibung nicht oberhalb
+ // des Eingabefeldes zu stehen, sondern mit der Checkbox in
+ // einer Zeile
+ // -> JLabel entfernen und statt dessen den Text der Checkbox setzen
+ this.remove(this.descLabel);
+ ((JCheckBox) inpComp).setText(label);
+ // Standardwert setzen
+ if (defValue != null)
+ setValue(defValue);
+ }
- /**
- * Erzeugt eine neue Eingabe-Option. Diese ist standardmaessig deaktiviert.
- * @param label Beschreibung
- */
- public BooleanInputOption(String label) {
- this(label,false);
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option. Diese ist standardmaessig deaktiviert.
+ *
+ * @param label
+ * Beschreibung
+ */
+ public BooleanInputOption(String label) {
+ this(label, false);
+ }
- /**
- * Erzeugt eine neue Instanz von {@link JCheckBox}.
- */
- protected JCheckBox createInputComponent() {
- return new JCheckBox();
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option.
+ */
+ public BooleanInputOption(Param param, Boolean defValue) {
+ this(param.title.toString(), defValue);
+ setToolTipText(param.description.toString());
+ }
- /**
- * Liefert den Wert, der in der Option eingegeben wurde. Prueft zuerst
- * auf Gueltigkeit und ruft dann {@link #performGetValue()} auf.
- * @return <code>null</code> wenn die aktuelle Eingabe nicht zulaessig ist
- * (siehe {@link #isInputValid()})
- */
- public Boolean getValue() {
- return (Boolean)super.getValue();
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option.
+ */
+ public BooleanInputOption(Param param) {
+ this(param.title.toString(), (Boolean) param.sample);
+ setToolTipText(param.description.toString());
+ }
- /**
- * Liefert immer <code>true</code>, da keine speziellen Anforderungen
- * an die Text-Eingabe gestellt werden.
- */
- protected boolean performIsInputValid() {
- return true;
- }
+ /**
+ * Erzeugt eine neue Instanz von {@link JCheckBox}.
+ */
+ protected JCheckBox createInputComponent() {
+ return new JCheckBox();
+ }
- /**
- * Liefert immer <code>false</code>, da es keine Leereingabe gibt. Eine nicht
- * aktivierte Checkbox bedeutet den Wert FALSE.
- */
- protected boolean performIsInputEmpty() {
- return false;
- }
+ /**
+ * Liefert den Wert, der in der Option eingegeben wurde. Prueft zuerst auf
+ * Gueltigkeit und ruft dann {@link #performGetValue()} auf.
+ *
+ * @return <code>null</code> wenn die aktuelle Eingabe nicht zulaessig ist
+ * (siehe {@link #isInputValid()})
+ */
+ public Boolean getValue() {
+ return (Boolean) super.getValue();
+ }
- /**
- * Liefert <code>true</code>, falls die Checkbox aktiviert ist.
- * @return einen <code>boolean</code>-Wert (<b>kein</b> {@link Boolean}-Objekt!)
- */
- protected Boolean performGetValue() {
- return ((JCheckBox)inpComp).isSelected();
- }
+ /**
+ * Liefert immer <code>true</code>, da keine speziellen Anforderungen an die
+ * Text-Eingabe gestellt werden.
+ */
+ protected boolean performIsInputValid() {
+ return true;
+ }
- /**
- * (De)aktiviert die Checkbox.
- * @param active definiert den neuen Status (muss vom Typ {@link Boolean} sein!)
- * @return <code>false</code> falls kein {@link Boolean} uebergeben wird.
- */
- protected boolean performSetValue(Object active) {
- if ( !(active instanceof Boolean) )
- return false;
- ((JCheckBox)inpComp).setSelected((Boolean)active);
- return true;
- }
+ /**
+ * Liefert immer <code>false</code>, da es keine Leereingabe gibt. Eine
+ * nicht aktivierte Checkbox bedeutet den Wert FALSE.
+ */
+ protected boolean performIsInputEmpty() {
+ return false;
+ }
+
+ /**
+ * Liefert <code>true</code>, falls die Checkbox aktiviert ist.
+ *
+ * @return einen <code>boolean</code>-Wert (<b>kein</b> {@link Boolean}
+ * -Objekt!)
+ */
+ protected Boolean performGetValue() {
+ return ((JCheckBox) inpComp).isSelected();
+ }
+
+ /**
+ * (De)aktiviert die Checkbox.
+ *
+ * @param active
+ * definiert den neuen Status (muss vom Typ {@link Boolean}
+ * sein!)
+ * @return <code>false</code> falls kein {@link Boolean} uebergeben wird.
+ */
+ protected boolean performSetValue(Object active) {
+ if (!(active instanceof Boolean))
+ return false;
+ ((JCheckBox) inpComp).setSelected((Boolean) active);
+ return true;
+ }
}
Modified: trunk/src/schmitzm/swing/ManualInputOption.java
===================================================================
--- trunk/src/schmitzm/swing/ManualInputOption.java 2010-10-24 16:55:46 UTC (rev 1162)
+++ trunk/src/schmitzm/swing/ManualInputOption.java 2010-10-24 22:55:43 UTC (rev 1163)
@@ -38,465 +38,612 @@
import javax.swing.JPasswordField;
import javax.swing.JTextField;
+import org.geotools.data.DataAccessFactory.Param;
+
/**
- * Diese Klasse stellt eine manuelle Eingabe-Option fuer das {@link MultipleOptionPane}
- * dar. Die Eingabe erfolgt ueber ein {@link JTextField}. Ausser der
- * "Input-Needed"-Restriktion, werden keine weiteren Anforderungen an die
- * Eingabe gestellt. Die Klasse kann nicht direkt instanziiert werden.
- * Statt dessen sind die eingebetteten Klassen
+ * Diese Klasse stellt eine manuelle Eingabe-Option fuer das
+ * {@link MultipleOptionPane} dar. Die Eingabe erfolgt ueber ein
+ * {@link JTextField}. Ausser der "Input-Needed"-Restriktion, werden keine
+ * weiteren Anforderungen an die Eingabe gestellt. Die Klasse kann nicht direkt
+ * instanziiert werden. Statt dessen sind die eingebetteten Klassen
* <ul>
- * <li>{@link ManualInputOption.Text ManualInputOption.Text}</li>
+ * <li>{@link ManualInputOption.Text ManualInputOption.Text}</li>
* <li>{@link ManualInputOption.Integer ManualInputOption.Integer}</li>
- * <li>{@link ManualInputOption.Double ManualInputOption.Double}</li>
+ * <li>{@link ManualInputOption.Double ManualInputOption.Double}</li>
* </ul>
* zu verwenden.
- * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a> (University of Bonn/Germany)
+ *
+ * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a>
+ * (University of Bonn/Germany)
* @version 1.0
*/
public class ManualInputOption extends InputOption {
- /**
- * Erzeugt eine neue Eingabe-Option.
- * @param label Beschreibung
- * @param inputNeeded gibt an, ob eine Eingabe erforderlich ist
- * @param defValue Wert der im Textfeld vorgeblendet wird
- */
- protected ManualInputOption(String label, boolean inputNeeded, Object defValue) {
- super(label,inputNeeded);
- ((JTextField)inpComp).setText( defValue != null ? defValue.toString() : "");
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option.
+ *
+ * @param label
+ * Beschreibung
+ * @param inputNeeded
+ * gibt an, ob eine Eingabe erforderlich ist
+ * @param defValue
+ * Wert der im Textfeld vorgeblendet wird
+ */
+ protected ManualInputOption(String label, boolean inputNeeded,
+ Object defValue) {
+ super(label, inputNeeded);
+ ((JTextField) inpComp).setText(defValue != null ? defValue.toString()
+ : "");
+ }
- /**
- * Erzeugt eine neue Instanz von {@link JTextField}.
- */
- protected JTextField createInputComponent() {
- return new JTextField();
- }
+ /**
+ * Erzeugt eine neue Instanz von {@link JTextField}.
+ */
+ protected JTextField createInputComponent() {
+ return new JTextField();
+ }
- /**
- * Liefert immer <code>true</code>, da keine speziellen Anforderungen
- * an die Text-Eingabe gestellt werden.
- */
- protected boolean performIsInputValid() {
- return true;
- }
+ /**
+ * Liefert immer <code>true</code>, da keine speziellen Anforderungen an die
+ * Text-Eingabe gestellt werden.
+ */
+ protected boolean performIsInputValid() {
+ return true;
+ }
- /**
- * Prueft, ob im Eingabefeld ein Leerstring eingegeben wurde.
- */
- protected boolean performIsInputEmpty() {
- return ((JTextField)inpComp).getText().trim().equals("");
- }
+ /**
+ * Prueft, ob im Eingabefeld ein Leerstring eingegeben wurde.
+ */
+ protected boolean performIsInputEmpty() {
+ return ((JTextField) inpComp).getText().trim().equals("");
+ }
- /**
- * Liefert die aktuelle Eingabe im {@link JTextField}.
- */
- protected Object performGetValue() {
- return ((JTextField)inpComp).getText();
- }
+ /**
+ * Liefert die aktuelle Eingabe im {@link JTextField}.
+ */
+ protected Object performGetValue() {
+ return ((JTextField) inpComp).getText();
+ }
- /**
- * Setzt die aktuelle Eingabe im {@link JTextField}.
- * @param newValue neuer Wert (muss vom Typ {@link String} sein!)
- * @return <code>false</code> wenn kein {@link String} uebergeben wird
- */
- protected boolean performSetValue(Object newValue) {
- if ( newValue == null )
- newValue = "";
- if ( !(newValue instanceof String) )
- return false;
- ((JTextField)inpComp).setText((String)newValue);
- return true;
- }
+ /**
+ * Setzt die aktuelle Eingabe im {@link JTextField}.
+ *
+ * @param newValue
+ * neuer Wert (muss vom Typ {@link String} sein!)
+ * @return <code>false</code> wenn kein {@link String} uebergeben wird
+ */
+ protected boolean performSetValue(Object newValue) {
+ if (newValue == null)
+ newValue = "";
+ if (!(newValue instanceof String))
+ return false;
+ ((JTextField) inpComp).setText((String) newValue);
+ return true;
+ }
- /**
- * Diese Klasse stellt eine Eingabe-Option dar, in der ein beliebigen Text
- * eingegeben werden kann.
- * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a> (University of Bonn/Germany)
- * @version 1.0
- */
- public static class Text extends ManualInputOption {
- /**
- * Erzeugt eine neue Eingabe-Option.
- * @param label Beschreibung
- * @param inputNeeded gibt an, ob eine Eingabe erforderlich ist
- * @param defValue Wert der im Textfeld vorgeblendet wird
- */
- public Text(String label, boolean inputNeeded, String defValue) {
- super(label,inputNeeded,defValue);
- }
+ /**
+ * Diese Klasse stellt eine Eingabe-Option dar, in der ein beliebigen Text
+ * eingegeben werden kann.
+ *
+ * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a>
+ * (University of Bonn/Germany)
+ * @version 1.0
+ */
+ public static class Text extends ManualInputOption {
+ /**
+ * Erzeugt eine neue Eingabe-Option.
+ *
+ * @param label
+ * Beschreibung
+ * @param inputNeeded
+ * gibt an, ob eine Eingabe erforderlich ist
+ * @param defValue
+ * Wert der im Textfeld vorgeblendet wird
+ */
+ public Text(String label, boolean inputNeeded, String defValue) {
+ super(label, inputNeeded, defValue);
+ }
- /**
- * Erzeugt eine neue Eingabe-Option.
- * @param label Beschreibung
- * @param inputNeeded gibt an, ob eine Eingabe erforderlich ist
- */
- public Text(String label, boolean inputNeeded) {
- this(label,inputNeeded,"");
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option.
+ *
+ * @param label
+ * Beschreibung
+ * @param inputNeeded
+ * gibt an, ob eine Eingabe erforderlich ist
+ */
+ public Text(String label, boolean inputNeeded) {
+ this(label, inputNeeded, "");
+ }
- /**
- * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend erforderlich
- * ist.
- * @param label Beschreibung
- */
- public Text(String label) {
- this(label,true,"");
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend
+ * erforderlich ist.
+ *
+ * @param label
+ * Beschreibung
+ */
+ public Text(String label) {
+ this(label, true, "");
+ }
- /**
- * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend erforderlich
- * ist.
- * @param label Beschreibung
- * @param defValue Wert der im Textfeld vorgeblendet wird
- */
- public Text(String label, String defValue) {
- this(label,true,defValue);
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend
+ * erforderlich ist.
+ *
+ * @param label
+ * Beschreibung
+ * @param defValue
+ * Wert der im Textfeld vorgeblendet wird
+ */
+ public Text(String label, String defValue) {
+ this(label, true, defValue);
+ }
+
+ /**
+ * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend
+ * erforderlich ist.
+ *
+ * @param label
+ * Beschreibung
+ */
+ public Text(Param param) {
+ this(param.title.toString(), param.required);
+ setToolTipText(param.description.toString());
+ }
- /**
- * Liefert den Wert, der in der Option eingegeben wurde. Prueft zuerst
- * auf Gueltigkeit und ruft dann {@link #performGetValue()} auf.
- * @return <code>null</code> wenn die aktuelle Eingabe nicht zulaessig ist
- * (siehe {@link #isInputValid()})
- */
- public String getValue() {
- return (String)super.getValue();
- }
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend
+ * erforderlich ist.
+ *
+ * @param label
+ * Beschreibung
+ * @param defValue
+ * Wert der im Textfeld vorgeblendet wird
+ */
+ public Text(Param param, String defValue) {
+ this(param.title.toString(), param.required, defValue);
+ setToolTipText(param.description.toString());
+ }
- /**
- * Diese Klasse stellt eine Eingabe-Option dar, in der ein Integer-Zahlen
- * eingegeben werden kann.
- * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a> (University of Bonn/Germany)
- * @version 1.0
- */
- public static class Integer extends ManualInputOption {
- /**
- * Erzeugt eine neue Eingabe-Option.
- * @param label Beschreibung
- * @param inputNeeded gibt an, ob eine Eingabe erforderlich ist
- * @param defValue Wert der im Textfeld vorgeblendet wird
- */
- public Integer(String label, boolean inputNeeded, int defValue) {
- super(label,inputNeeded,String.valueOf(defValue));
- }
+ /**
+ * Liefert den Wert, der in der Option eingegeben wurde. Prueft zuerst
+ * auf Gueltigkeit und ruft dann {@link #performGetValue()} auf.
+ *
+ * @return <code>null</code> wenn die aktuelle Eingabe nicht zulaessig
+ * ist (siehe {@link #isInputValid()})
+ */
+ public String getValue() {
+ return (String) super.getValue();
+ }
+ }
- /**
- * Erzeugt eine neue Eingabe-Option. Auch wenn die leere Eingabe u.U.
- * nicht zulaessig ist, wird ein Leerstring vorgeblendet.
- * @param label Beschreibung
- * @param inputNeeded gibt an, ob eine Eingabe erforderlich ist
- */
- public Integer(String label, boolean inputNeeded) {
- super(label,inputNeeded,"");
- }
+ /**
+ * Diese Klasse stellt eine Eingabe-Option dar, in der ein Integer-Zahlen
+ * eingegeben werden kann.
+ *
+ * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a>
+ * (University of Bonn/Germany)
+ * @version 1.0
+ */
+ public static class Integer extends ManualInputOption {
+ /**
+ * Erzeugt eine neue Eingabe-Option.
+ *
+ * @param label
+ * Beschreibung
+ * @param inputNeeded
+ * gibt an, ob eine Eingabe erforderlich ist
+ * @param defValue
+ * Wert der im Textfeld vorgeblendet wird
+ */
+ public Integer(String label, boolean inputNeeded, java.lang.Integer defValue) {
+ super(label, inputNeeded, defValue != null ? String.valueOf(defValue) : null);
+ }
- /**
- * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend erforderlich
- * ist. Auch wenn die leere Eingabe u.U. nicht zulaessig ist, wird ein
- * Leerstring vorgeblendet.
- * @param label Beschreibung
- */
- public Integer(String label) {
- super(label,true,"");
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option. Auch wenn die leere Eingabe u.U.
+ * nicht zulaessig ist, wird ein Leerstring vorgeblendet.
+ *
+ * @param label
+ * Beschreibung
+ * @param inputNeeded
+ * gibt an, ob eine Eingabe erforderlich ist
+ */
+ public Integer(String label, boolean inputNeeded) {
+ super(label, inputNeeded, "");
+ }
- /**
- * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend erforderlich
- * ist.
- * @param label Beschreibung
- * @param defValue Wert der im Textfeld vorgeblendet wird
- */
- public Integer(String label, int defValue) {
- this(label,true,defValue);
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend
+ * erforderlich ist. Auch wenn die leere Eingabe u.U. nicht zulaessig
+ * ist, wird ein Leerstring vorgeblendet.
+ *
+ * @param label
+ * Beschreibung
+ */
+ public Integer(String label) {
+ super(label, true, "");
+ }
- /**
- * Liefert den Wert, der in der Option eingegeben wurde. Prueft zuerst
- * auf Gueltigkeit und ruft dann {@link #performGetValue()} auf.
- * @return <code>null</code> wenn die aktuelle Eingabe nicht zulaessig ist
- * (siehe {@link #isInputValid()})
- */
- public java.lang.Integer getValue() {
- return (java.lang.Integer)super.getValue();
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend
+ * erforderlich ist.
+ *
+ * @param label
+ * Beschreibung
+ */
+ public Integer(String label, java.lang.Integer defValue) {
+ this(label, true, defValue);
+ }
- /**
- * Transformiert die Text-Eingabe in einen Integer.
- * @return <code>null</code> falls das Eingabefeld leer ist.
- */
- protected java.lang.Integer performGetValue() {
- if ( inputEmpty() )
- return null;
- return java.lang.Integer.parseInt(((JTextField)inpComp).getText());
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend
+ * erforderlich ist.
+ *
+ * @param label
+ * Beschreibung
+ * @param defValue
+ * Wert der im Textfeld vorgeblendet wird
+ */
+ public Integer(Param param) {
+ this(param.title.toString(), param.required);
+ setToolTipText(param.description.toString());
+ }
- /**
- * Prueft, ob ein gueltiger Integer-Wert im Feld eingegeben wurde.
- */
- protected boolean performIsInputValid() {
- try {
- java.lang.Integer.parseInt(((JTextField)inpComp).getText());
- } catch (NumberFormatException err) {
- return false;
- }
- return super.performIsInputValid();
- }
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend
+ * erforderlich ist.
+ *
+ * @param label
+ * Beschreibung
+ * @param defValue
+ * Wert der im Textfeld vorgeblendet wird
+ */
+ public Integer(Param param, java.lang.Integer defValue) {
+ this(param.title.toString(), param.required, defValue);
+ setToolTipText(param.description.toString());
+ }
- /**
- * Diese Klasse stellt eine Eingabe-Option dar, in der ein Double-Zahlen
- * eingegeben werden kann.
- * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a> (University of Bonn/Germany)
- * @version 1.0
- */
- public static class Double extends ManualInputOption {
- /**
- * Erzeugt eine neue Eingabe-Option.
- * @param label Beschreibung
- * @param inputNeeded gibt an, ob eine Eingabe erforderlich ist
- * @param defValue Wert der im Textfeld vorgeblendet wird
- */
- public Double(String label, boolean inputNeeded, double defValue) {
- super(label,inputNeeded,String.valueOf(defValue));
- }
+ /**
+ * Liefert den Wert, der in der Option eingegeben wurde. Prueft zuerst
+ * auf Gueltigkeit und ruft dann {@link #performGetValue()} auf.
+ *
+ * @return <code>null</code> wenn die aktuelle Eingabe nicht zulaessig
+ * ist (siehe {@link #isInputValid()})
+ */
+ public java.lang.Integer getValue() {
+ return (java.lang.Integer) super.getValue();
+ }
- /**
- * Erzeugt eine neue Eingabe-Option. Auch wenn die leere Eingabe u.U.
- * nicht zulaessig ist, wird ein Leerstring vorgeblendet.
- * @param label Beschreibung
- * @param inputNeeded gibt an, ob eine Eingabe erforderlich ist
- */
- public Double(String label, boolean inputNeeded) {
- super(label,inputNeeded,"");
- }
+ /**
+ * Transformiert die Text-Eingabe in einen Integer.
+ *
+ * @return <code>null</code> falls das Eingabefeld leer ist.
+ */
+ protected java.lang.Integer performGetValue() {
+ if (inputEmpty())
+ return null;
+ return java.lang.Integer.parseInt(((JTextField) inpComp).getText());
+ }
- /**
- * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend erforderlich
- * ist. Auch wenn die leere Eingabe u.U. nicht zulaessig ist, wird ein
- * Leerstring vorgeblendet.
- * @param label Beschreibung
- */
- public Double(String label) {
- super(label,true,"");
- }
+ /**
+ * Prueft, ob ein gueltiger Integer-Wert im Feld eingegeben wurde.
+ */
+ protected boolean performIsInputValid() {
+ try {
+ java.lang.Integer.parseInt(((JTextField) inpComp).getText());
+ } catch (NumberFormatException err) {
+ return false;
+ }
+ return super.performIsInputValid();
+ }
+ }
- /**
- * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend erforderlich
- * ist.
- * @param label Beschreibung
- * @param defValue Wert der im Textfeld vorgeblendet wird
- */
- public Double(String label, int defValue) {
- this(label,true,defValue);
- }
+ /**
+ * Diese Klasse stellt eine Eingabe-Option dar, in der ein Double-Zahlen
+ * eingegeben werden kann.
+ *
+ * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a>
+ * (University of Bonn/Germany)
+ * @version 1.0
+ */
+ public static class Double extends ManualInputOption {
+ /**
+ * Erzeugt eine neue Eingabe-Option.
+ *
+ * @param label
+ * Beschreibung
+ * @param inputNeeded
+ * gibt an, ob eine Eingabe erforderlich ist
+ * @param defValue
+ * Wert der im Textfeld vorgeblendet wird
+ */
+ public Double(String label, boolean inputNeeded, double defValue) {
+ super(label, inputNeeded, String.valueOf(defValue));
+ }
- /**
- * Liefert den Wert, der in der Option eingegeben wurde. Prueft zuerst
- * auf Gueltigkeit und ruft dann {@link #performGetValue()} auf.
- * @return <code>null</code> wenn die aktuelle Eingabe nicht zulaessig ist
- * (siehe {@link #isInputValid()})
- */
- public java.lang.Double getValue() {
- return (java.lang.Double)super.getValue();
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option. Auch wenn die leere Eingabe u.U.
+ * nicht zulaessig ist, wird ein Leerstring vorgeblendet.
+ *
+ * @param label
+ * Beschreibung
+ * @param inputNeeded
+ * gibt an, ob eine Eingabe erforderlich ist
+ */
+ public Double(String label, boolean inputNeeded) {
+ super(label, inputNeeded, "");
+ }
- /**
- * Transformiert die Text-Eingabe in einen Double.
- * @return <code>null</code> falls das Eingabefeld leer ist.
- */
- protected java.lang.Double performGetValue() {
- if ( inputEmpty() )
- return null;
- return java.lang.Double.parseDouble(((JTextField)inpComp).getText());
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend
+ * erforderlich ist. Auch wenn die leere Eingabe u.U. nicht zulaessig
+ * ist, wird ein Leerstring vorgeblendet.
+ *
+ * @param label
+ * Beschreibung
+ */
+ public Double(String label) {
+ super(label, true, "");
+ }
- /**
- * Prueft, ob ein gueltiger Double-Wert im Feld eingegeben wurde.
- */
- protected boolean performIsInputValid() {
- try {
- java.lang.Double.parseDouble(((JTextField)inpComp).getText());
- } catch (NumberFormatException err) {
- return false;
- }
- return super.performIsInputValid();
- }
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend
+ * erforderlich ist.
+ *
+ * @param label
+ * Beschreibung
+ * @param defValue
+ * Wert der im Textfeld vorgeblendet wird
+ */
+ public Double(String label, int defValue) {
+ this(label, true, defValue);
+ }
- /**
- * Diese Klasse stellt eine Eingabe-Option dar, in der ein (verdecktes) Passwort
- * eingegeben werden kann. Zu beachten ist, dass der Rueckgabewert dieser
- * {@link InputOption} kein {@link String} ist, sondern ein {@code char[]}.
- * @see JPasswordField#getPassword()
- * @see JPasswordField#getText()
- * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a> (University of Bonn/Germany)
- * @version 1.0
- */
- public static class Password extends ManualInputOption {
- /**
- * Erzeugt eine neue Eingabe-Option.
- * @param label Beschreibung
- * @param inputNeeded gibt an, ob eine Eingabe erforderlich ist
- * @param defValue Wert der im Textfeld vorgeblendet wird
- */
- public Password(String label, boolean inputNeeded, String defValue) {
- super(label,inputNeeded,defValue);
- }
+ /**
+ * Liefert den Wert, der in der Option eingegeben wurde. Prueft zuerst
+ * auf Gueltigkeit und ruft dann {@link #performGetValue()} auf.
+ *
+ * @return <code>null</code> wenn die aktuelle Eingabe nicht zulaessig
+ * ist (siehe {@link #isInputValid()})
+ */
+ public java.lang.Double getValue() {
+ return (java.lang.Double) super.getValue();
+ }
- /**
- * Erzeugt eine neue Eingabe-Option.
- * @param label Beschreibung
- * @param inputNeeded gibt an, ob eine Eingabe erforderlich ist
- */
- public Password(String label, boolean inputNeeded) {
- this(label,inputNeeded,"");
- }
+ /**
+ * Transformiert die Text-Eingabe in einen Double.
+ *
+ * @return <code>null</code> falls das Eingabefeld leer ist.
+ */
+ protected java.lang.Double performGetValue() {
+ if (inputEmpty())
+ return null;
+ return java.lang.Double.parseDouble(((JTextField) inpComp)
+ .getText());
+ }
- /**
- * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend erforderlich
- * ist.
- * @param label Beschreibung
- */
- public Password(String label) {
- this(label,true,"");
- }
+ /**
+ * Prueft, ob ein gueltiger Double-Wert im Feld eingegeben wurde.
+ */
+ protected boolean performIsInputValid() {
+ try {
+ java.lang.Double.parseDouble(((JTextField) inpComp).getText());
+ } catch (NumberFormatException err) {
+ return false;
+ }
+ return super.performIsInputValid();
+ }
+ }
- /**
- * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend erforderlich
- * ist.
- * @param label Beschreibung
- * @param defValue Wert der im Textfeld vorgeblendet wird
- */
- public Password(String label, String defValue) {
- this(label,true,defValue);
- }
-
- /**
- * Erzeugt eine neue Instanz von {@link JPasswordField}.
- */
- protected JPasswordField createInputComponent() {
- return new JPasswordField();
- }
+ /**
+ * Diese Klasse stellt eine Eingabe-Option dar, in der ein (verdecktes)
+ * Passwort eingegeben werden kann. Zu beachten ist, dass der Rueckgabewert
+ * dieser {@link InputOption} kein {@link String} ist, sondern ein
+ * {@code char[]}.
+ *
+ * @see JPasswordField#getPassword()
+ * @see JPasswordField#getText()
+ * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a>
+ * (University of Bonn/Germany)
+ * @version 1.0
+ */
+ public static class Password extends ManualInputOption {
+ /**
+ * Erzeugt eine neue Eingabe-Option.
+ *
+ * @param label
+ * Beschreibung
+ * @param inputNeeded
+ * gibt an, ob eine Eingabe erforderlich ist
+ * @param defValue
+ * Wert der im Textfeld vorgeblendet wird
+ */
+ public Password(String label, boolean inputNeeded, String defValue) {
+ super(label, inputNeeded, defValue);
+ }
- /**
- * Liefert die aktuelle Eingabe im {@link JPasswordField}.
- */
- protected Object performGetValue() {
- return ((JPasswordField)inpComp).getPassword();
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option.
+ *
+ * @param label
+ * Beschreibung
+ * @param inputNeeded
+ * gibt an, ob eine Eingabe erforderlich ist
+ */
+ public Password(String label, boolean inputNeeded) {
+ this(label, inputNeeded, "");
+ }
- /**
- * Liefert den Wert, der in der Option eingegeben wurde. Prueft zuerst
- * auf Gueltigkeit und ruft dann {@link #performGetValue()} auf.
- * @return <code>null</code> wenn die aktuelle Eingabe nicht zulaessig ist
- * (siehe {@link #isInputValid()})
- */
- public char[] getValue() {
- return (char[])super.getValue();
- }
- }
-
- /**
- * Diese Klasse stellt eine Eingabe-Option dar, in der ein (verdecktes) Passwort
- * eingegeben werden kann. Neben dem Textfeld fuer die Passwort-Eingabe enthaelt
- * die Eingabe-Option noch eine Checkbox, ueber die das Passwort im Klartext
- * angezeigt werden kann.<br>
- * Zu beachten ist, dass der Rueckgabewert dieser
- * {@link InputOption} kein {@link String} ist, sondern ein {@code char[]}.
- * @see JPasswordField#getPassword()
- * @see JPasswordField#getText()
- * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a> (University of Bonn/Germany)
- * @version 1.0
- */
- public static class PasswordViewable extends Password {
- private char oldEchoChar = '*';
+ /**
+ * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend
+ * erforderlich ist.
+ *
+ * @param label
+ * Beschreibung
+ */
+ public Password(String label) {
+ this(label, true, "");
+ }
- /** Container enthaelt das Text-Eingabefeld und die Checkbox, um das
- * Passwort sichtbar zu machen. */
- protected Container inpCompCont = new Container();
- /** Der Button fuer die Browse-Aktion. */
- protected JCheckBox visibleCheckBox = new JCheckBox(SwingUtil.R("ManualInputOption.PasswordVisible.visibility"),false);
-
- /**
- * Erzeugt eine neue Eingabe-Option.
- * @param label Beschreibung
- * @param inputNeeded gibt an, ob eine Eingabe erforderlich ist
- * @param defValue Wert der im Textfeld vorgeblendet wird
- */
- public PasswordViewable(String label, boolean inputNeeded, String defValue) {
- super(label,inputNeeded,defValue);
-
- visibleCheckBox.addActionListener( new ActionListener() {
- public void actionPerformed(ActionEvent e) {
- setPasswortVisible( visibleCheckBox.isSelected() );
- }
- });
+ /**
+ * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend
+ * erforderlich ist.
+ *
+ * @param label
+ * Beschreibung
+ * @param defValue
+ * Wert der im Textfeld vorgeblendet wird
+ */
+ public Password(String label, String defValue) {
+ this(label, true, defValue);
+ }
- // Neben dem Eingabefeld noch ein Browse-Button
- inpCompCont.setLayout( new BorderLayout() );
- inpCompCont.add(this.inpComp, BorderLayout.CENTER);
- inpCompCont.add(this.visibleCheckBox, BorderLayout.EAST);
- // normale Eingabe-Komponente durch Container ersetzen
- remove(inpComp);
- add(inpCompCont,BorderLayout.SOUTH);
- }
+ /**
+ * Erzeugt eine neue Instanz von {@link JPasswordField}.
+ */
+ protected JPasswordField createInputComponent() {
+ return new JPasswordField();
+ }
- /**
- * Erzeugt eine neue Eingabe-Option.
- * @param label Beschreibung
- * @param inputNeeded gibt an, ob eine Eingabe erforderlich ist
- */
- public PasswordViewable(String label, boolean inputNeeded) {
- this(label,inputNeeded,"");
- }
+ /**
+ * Liefert die aktuelle Eingabe im {@link JPasswordField}.
+ */
+ protected Object performGetValue() {
+ return ((JPasswordField) inpComp).getPassword();
+ }
- /**
- * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend erforderlich
- * ist.
- * @param label Beschreibung
- */
- public PasswordViewable(String label) {
- this(label,true,"");
- }
+ /**
+ * Liefert den Wert, der in der Option eingegeben wurde. Prueft zuerst
+ * auf Gueltigkeit und ruft dann {@link #performGetValue()} auf.
+ *
+ * @return <code>null</code> wenn die aktuelle Eingabe nicht zulaessig
+ * ist (siehe {@link #isInputValid()})
+ */
+ public char[] getValue() {
+ return (char[]) super.getValue();
+ }
+ }
- /**
- * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend erforderlich
- * ist.
- * @param label Beschreibung
- * @param defValue Wert der im Textfeld vorgeblendet wird
- */
- public PasswordViewable(String label, String defValue) {
- this(label,true,defValue);
- }
-
- /**
- * Erzeugt eine neue Instanz von {@link JPasswordField}.
- */
- protected JPasswordField createInputComponent() {
- JPasswordField pwField = super.createInputComponent();
- oldEchoChar = pwField.getEchoChar();
- return pwField;
- }
+ /**
+ * Diese Klasse stellt eine Eingabe-Option dar, in der ein (verdecktes)
+ * Passwort eingegeben werden kann. Neben dem Textfeld fuer die
+ * Passwort-Eingabe enthaelt die Eingabe-Option noch eine Checkbox, ueber
+ * die das Passwort im Klartext angezeigt werden kann.<br>
+ * Zu beachten ist, dass der Rueckgabewert dieser {@link InputOption} kein
+ * {@link String} ist, sondern ein {@code char[]}.
+ *
+ * @see JPasswordField#getPassword()
+ * @see JPasswordField#getText()
+ * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a>
+ * (University of Bonn/Germany)
+ * @version 1.0
+ */
+ public static class PasswordViewable extends Password {
+ private char oldEchoChar = '*';
- /**
- * Sets the passwort (in)visible in the component.
- */
- public void setPasswortVisible(boolean visible) {
- // remember old echo character
- if ( ((JPasswordField)inpComp).getEchoChar() != 0 )
- oldEchoChar = ((JPasswordField)inpComp).getEchoChar();
- ((JPasswordField)inpComp).setEchoChar( visible ? 0 : oldEchoChar );
- visibleCheckBox.setSelected(visible);
- }
+ /**
+ * Container enthaelt das Text-Eingabefeld und die Checkbox, um das
+ * Passwort sichtbar zu machen.
+ */
+ protected Container inpCompCont = new Container();
+ /** Der Button fuer die Browse-Aktion. */
+ protected JCheckBox visibleCheckBox = new JCheckBox(
+ SwingUtil.R("ManualInputOption.PasswordVisible.visibility"),
+ false);
- /**
- * Return whether the passwort is (in)visible in the component.
- */
- public boolean isPasswortVisible() {
- return ((JPasswordField)inpComp).getEchoChar() == 0;
- }
+ /**
+ * Erzeugt eine neue Eingabe-Option.
+ *
+ * @param label
+ * Beschreibung
+ * @param inputNeeded
+ * gibt an, ob eine Eingabe erforderlich ist
+ * @param defValue
+ * Wert der im Textfeld vorgeblendet wird
+ */
+ public PasswordViewable(String label, boolean inputNeeded,
+ String defValue) {
+ super(label, inputNeeded, defValue);
- }
+ visibleCheckBox.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ setPasswortVisible(visibleCheckBox.isSelected());
+ }
+ });
+ // Neben dem Eingabefeld noch ein Browse-Button
+ inpCompCont.setLayout(new BorderLayout());
+ inpCompCont.add(this.inpComp, BorderLayout.CENTER);
+ inpCompCont.add(this.visibleCheckBox, BorderLayout.EAST);
+ // normale Eingabe-Komponente durch Container ersetzen
+ remove(inpComp);
+ add(inpCompCont, BorderLayout.SOUTH);
+ }
+
+ /**
+ * Erzeugt eine neue Eingabe-Option.
+ *
+ * @param label
+ * Beschreibung
+ * @param inputNeeded
+ * gibt an, ob eine Eingabe erforderlich ist
+ */
+ public PasswordViewable(String label, boolean inputNeeded) {
+ this(label, inputNeeded, "");
+ }
+
+ /**
+ * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend
+ * erforderlich ist.
+ *
+ * @param label
+ * Beschreibung
+ */
+ public PasswordViewable(String label) {
+ this(label, true, "");
+ }
+
+ /**
+ * Erzeugt eine neue Eingabe-Option, in der eine Eingabe zwingend
+ * erforderlich ist.
+ *
+ * @param label
+ * Beschreibung
+ * @param defValue
+ * Wert der im Textfeld vorgeblendet wird
+ */
+ public PasswordViewable(String label, String defValue) {
+ this(label, true, defValue);
+ }
+
+ /**
+ * Erzeugt eine neue Instanz von {@link JPasswordField}.
+ */
+ protected JPasswordField createInputComponent() {
+ JPasswordField pwField = super.createInputComponent();
+ oldEchoChar = pwField.getEchoChar();
+ return pwField;
+ }
+
+ /**
+ * Sets the passwort (in)visible in the component.
+ */
+ public void setPasswortVisible(boolean visible) {
+ // remember old echo character
+ if (((JPasswordField) inpComp).getEchoChar() != 0)
+ oldEchoChar = ((JPasswordField) inpComp).getEchoChar();
+ ((JPasswordField) inpComp).setEchoChar(visible ? 0 : oldEchoChar);
+ visibleCheckBox.setSelected(visible);
+ }
+
+ /**
+ * Return whether the passwort is (in)visible in the component.
+ */
+ public boolean isPasswortVisible() {
+ return ((JPasswordField) inpComp).getEchoChar() == 0;
+ }
+
+ }
+
}
Modified: trunk/src/skrueger/geotools/io/DbServerSettings.java
===================================================================
--- trunk/src/skrueger/geotools/io/DbServerSettings.java 2010-10-24 16:55:46 UTC (rev 1162)
+++ trunk/src/skrueger/geotools/io/DbServerSettings.java 2010-10-24 22:55:43 UTC (rev 1163)
@@ -6,9 +6,11 @@
import java.util.regex.Pattern;
import org.apache.commons.lang.ArrayUtils;
+import org.apache.commons.lang.StringUtils;
import org.geotools.data.postgis.PostgisNGDataStoreFactory;
import org.geotools.jdbc.JDBCDataStore;
import org.geotools.jdbc.JDBCDataStoreFactory;
+import org.jfree.util.Log;
import schmitzm.swing.BooleanInputOption;
import schmitzm.swing.ManualInputOption;
@@ -236,28 +238,27 @@
if (propString == null || propString.isEmpty())
throw new IllegalArgumentException("parameter to parse was empty");
+ try {
- String[] split = propString.split(Pattern.quote(DELIMITER));
+ String[] split = propString.split(Pattern.quote(DELIMITER));
- // BaseUrl
- try {
DbType dbt = DbType.valueOf(split[0]);
DbServerSettings dbServer = new DbServerSettings(dbt);
dbServer.setHost(split[1]);
dbServer.setPort(java.lang.Integer.valueOf(split[2]));
- dbServer.setUsername(split[3]);
- dbServer.setPassword(split[4]);
+ dbServer.setUsername(StringUtils.stripToNull(split[3]));
+ dbServer.setPassword(split[4].equals("null") ? null : split[4]);
dbServer.setDatabase(split[5]);
dbServer.setExposePrimaryKey(Boolean.valueOf(split[6]));
dbServer.setSchema(split[7]);
return dbServer;
} catch (Exception e) {
- throw new IllegalArgumentException(e);
+ Log.warn("couldn't parse " + propString);
+ return null;
}
-
}
@Override
@@ -271,7 +272,7 @@
s.append(getHost());
- if (getPort() != 5432) {
+ if (getPort() != null && getPort() != 5432) {
s.append(":" + getPort());
}
@@ -333,7 +334,7 @@
dbServer.getUsername());
PasswordViewable passwdInput = new ManualInputOption.PasswordViewable(
- "Passwort", true, dbServer.getPassword());
+ "Password", true, dbServer.getPassword());
BooleanInputOption exposePkInput = new BooleanInputOption(
"Expose primary keys", dbServer.getExposePrimaryKey());
@@ -360,5 +361,6 @@
}
return dbServer;
+
}
}
Modified: trunk/src/skrueger/geotools/io/WfsServerList.java
===================================================================
--- trunk/src/skrueger/geotools/io/WfsServerList.java 2010-10-24 16:55:46 UTC (rev 1162)
+++ trunk/src/skrueger/geotools/io/WfsServerList.java 2010-10-24 22:55:43 UTC (rev 1163)
@@ -14,7 +14,7 @@
* Character used to separate the parameters when serializing settings to a
* String
*/
- private static final String DELIMITER = "@";
+ static final String DELIMITER = "@";
public WfsServerList(WfsServerSettings... wfss) {
for (WfsServerSettings wfs : wfss) {
Modified: trunk/src/skrueger/geotools/io/WfsServerSettings.java
===================================================================
--- trunk/src/skrueger/geotools/io/WfsServerSettings.java 2010-10-24 16:55:46 UTC (rev 1162)
+++ trunk/src/skrueger/geotools/io/WfsServerSettings.java 2010-10-24 22:55:43 UTC (rev 1163)
@@ -9,8 +9,12 @@
import org.apache.commons.lang.ArrayUtils;
import org.geotools.data.DataUtilities;
import org.geotools.data.wfs.WFSDataStoreFactory;
+import org.jfree.util.Log;
+import schmitzm.swing.BooleanInputOption;
import schmitzm.swing.ManualInputOption;
+import schmitzm.swing.ManualInputOption.Integer;
+import schmitzm.swing.ManualInputOption.PasswordViewable;
import schmitzm.swing.ManualInputOption.Text;
import schmitzm.swing.MultipleOptionPane;
import schmitzm.swing.SelectionInputOption;
@@ -34,8 +38,39 @@
BASE_URL, VERSION
}
+ public enum HttpProtocol {
+ AUTO(null), POST(Boolean.TRUE), GET(Boolean.FALSE);
+
+ private final Boolean value;
+
+ private HttpProtocol(Boolean value) {
+ this.value = value;
+ }
+
+ public Boolean getValue() {
+ return value;
+ }
+
+ public static HttpProtocol parse(String object) {
+ if (object.equalsIgnoreCase("true"))
+ return POST;
+ if (object.equals("false"))
+ return GET;
+ return AUTO;
+ }
+
+ public static HttpProtocol parse(Boolean object) {
+ if (object == Boolean.TRUE)
+ return POST;
+ if (object == Boolean.FALSE)
+ return GET;
+ return AUTO;
+ }
+
+ }
+
public enum WfsProtocollVersion {
- v1_1_1("1.1.1"), v1_1_0("1.1.0"), v1_0_0("1.0.0");
+ v1_0_0("1.0.0"), v1_1_0("1.1.0"), v1_1_1("1.1.1");
private final String versionString;
@@ -54,11 +89,147 @@
*/
private static final String DELIMITER = "|";
- public WfsServerSettings(URL baseUrl, WfsProtocollVersion version) {
- setVersion(version);
- setBaseUrl(baseUrl);
+ /**
+ * Opens a GUI that asks the use define a DB connection.
+ *
+ * @param wfsServer
+ * <code>null</code> to create a new instance, or an instance to
+ * edit.
+ * @return <code>null</code> if the user cancelled the creation of a new
+ * {@link DbServerSettings}, otherwise the edited instance.
+ */
+ public static WfsServerSettings createOrEdit(Component owner,
+ WfsServerSettings wfsServer) {
+ boolean newCreated = false;
+
+ if (wfsServer == null) {
+ newCreated = true;
+ wfsServer = new WfsServerSettings();
+ }
+
+ Text hostInput = new ManualInputOption.Text(
+ "BaseURL (without any paramters)", true, wfsServer.getBaseUrl()
+ .toString());
+
+ Combo<WfsProtocollVersion> versionInput = new SelectionInputOption.Combo<WfsProtocollVersion>(
+ "WFS Version", true, WfsProtocollVersion.values(),
+ ArrayUtils.indexOf(WfsProtocollVersion.values(),
+ wfsServer.getVersion()), WfsProtocollVersion.values());
+ versionInput
+ .setToolTipText("If you have problems with Curves in GML3, try version 1.0.0.");
+
+ Integer maxFeaturesInput = new ManualInputOption.Integer(
+ "Max. features per request (0=no limit)", false,
+ wfsServer.getMaxFeatures());
+ maxFeaturesInput
+ .setToolTipText(WFSDataStoreFactory.MAXFEATURES.description
+ .toString());
+
+ Integer timeoutInput = new ManualInputOption.Integer("Timout in ms:",
+ false, wfsServer.getTimeout());
+ timeoutInput.setToolTipText(WFSDataStoreFactory.TIMEOUT.description
+ .toString());
+
+ BooleanInputOption lenientInput = new BooleanInputOption(
+ "lenient (=ignore errors)", wfsServer.getLenient());
+ lenientInput.setToolTipText(WFSDataStoreFactory.LENIENT.description
+ .toString());
+
+ SelectionInputOption.Combo<HttpProtocol> httpInput = new SelectionInputOption.Combo<HttpProtocol>(
+ "Ust HTTP GET or POST:", true, HttpProtocol.values(),
+ ArrayUtils.indexOf(HttpProtocol.values(),
+ wfsServer.getHttpProtocol()), HttpProtocol.values());
+ httpInput.setToolTipText(WFSDataStoreFactory.PROTOCOL.description
+ .toString());
+
+ Text userInput = new ManualInputOption.Text(
+ "Optional HTTPAuth Username", false, wfsServer.getUsername());
+
+ PasswordViewable passwdInput = new ManualInputOption.PasswordViewable(
+ "Optional HTTPAuth Password", false, wfsServer.getPassword());
+
+ // Show the options
+ Object[] input = MultipleOptionPane.showMultipleInputDialog(owner,
+ "WFS Connection parameters", hostInput, versionInput,
+ maxFeaturesInput, timeoutInput, lenientInput, httpInput,
+ userInput, passwdInput);
+
+ if (input == null) {
+ if (newCreated)
+ return null;
+ else
+ return wfsServer;
+ } else {
+ wfsServer.setBaseUrl((String) input[0]);
+ wfsServer.setVersion(((WfsProtocollVersion) input[1]));
+ wfsServer.setMaxFeatures((java.lang.Integer) input[2]);
+ wfsServer.setTimeout((java.lang.Integer) input[3]);
+ wfsServer.setLenient((java.lang.Boolean) input[4]);
+ wfsServer.setHttpProtocol((HttpProtocol) input[5]);
+ wfsServer.setUsername((String) input[6]);
+ wfsServer.setPassword(String.valueOf((char[]) input[7]));
+ }
+
+ return wfsServer;
+
}
+ public HttpProtocol getHttpProtocol() {
+ return HttpProtocol
+ .parse((Boolean) get(WFSDataStoreFactory.PROTOCOL.key));
+ }
+
+ public void setHttpProtocol(HttpProtocol protocol) {
+ put(WFSDataStoreFactory.PROTOCOL.key, protocol.getValue());
+ }
+
+ private Boolean getLenient() {
+ return (Boolean) get(WFSDataStoreFactory.LENIENT.key);
+ }
+
+ private void setLenient(Boolean lenient) {
+ put(WFSDataStoreFactory.LENIENT.key, lenient);
+ }
+
+ /**
+ * @return transforms the settings to a String that can be stored in a
+ * .properties line. @see #parsePropertiesString
+ * @throws MalformedURLException
+ */
+ public static WfsServerSettings parsePropertiesString(String propString)
+ throws MalformedURLException {
+
+ try {
+ String[] split = propString.split(Pattern.quote(DELIMITER));
+
+ WfsServerSettings wfs = new WfsServerSettings();
+
+ int i = 0;
+ wfs.setTitle(split[i++]);
+ wfs.setBaseUrl(new URL(split[i++]));
+ wfs.setVersion(WfsProtocollVersion.valueOf(split[i++]));
+ wfs.setMaxFeatures(java.lang.Integer.valueOf(split[i++]));
+ wfs.setTimeout(java.lang.Integer.valueOf(split[i++]));
+ wfs.setLenient(java.lang.Boolean.valueOf(split[i++]));
+ wfs.setHttpProtocol(HttpProtocol.parse(split[i++]));
+
+ String userRaw = split[i++];
+ wfs.setUsername(userRaw.equals("null") ? null : userRaw);
+
+ String pwdRaw = split[i++];
+ wfs.setPassword(pwdRaw.equals("null") ? null : pwdRaw);
+
+ return wfs;
+ } catch (Exception e) {
+ Log.warn("couldn't parse " + propString);
+ return null;
+ }
+
+ }
+
+ private String[] cachedTypeNames = null;
+ private String title;
+
public WfsServerSettings() {
try {
setBaseUrl(new URL("http://localhost:8080/geoserver/ows"));
@@ -67,7 +238,46 @@
}
}
+ public WfsServerSettings(URL baseUrl, WfsProtocollVersion version) {
+ setVersion(version);
+ setBaseUrl(baseUrl);
+ }
+
+ public URL getBaseUrl() {
+ return (URL) get(Key.BASE_URL);
+ }
+
+ public String[] getCachedTypeNames() {
+ return cachedTypeNames;
+ }
+
/**
+ * @return <code>null</code> if not correctly defined, otherwise the URL of
+ * the GetCapabilites request.
+ */
+ public URL getCapabilitiesUrl() {
+ return (URL) get(WFSDataStoreFactory.URL.key);
+ }
+
+ public java.lang.Integer getMaxFeatures() {
+ return (java.lang.Integer) get(WFSDataStoreFactory.MAXFEATURES.key);
+ }
+
+ public java.lang.Integer getTimeout() {
+ return (java.lang.Integer) get(WFSDataStoreFactory.TIMEOUT.key);
+ }
+
+ public String getTitle() {
+ if (title == null)
+ return toString();
+ return title;
+ }
+
+ public WfsProtocollVersion getVersion() {
+ return (WfsProtocollVersion) get(Key.VERSION);
+ }
+
+ /**
* @return <code>true</code>, if all parameters look OK, without actually
* opening any connection.
*/
@@ -76,15 +286,20 @@
}
/**
- * @return <code>null</code> if not correctly defined, otherwise the URL of
- * the GetCapabilites request.
+ * Set the BaseUrl as a String. Any pending parameters are automatically cut
+ * of.
*/
- public URL getCapabilitiesUrl() {
- return (URL) get(WFSDataStoreFactory.URL.key);
- }
+ public void setBaseUrl(String urlString) {
+ try {
+ // Cutoff any parameters
+ if (urlString.indexOf("?") > -1) {
+ urlString = urlString.substring(0, urlString.indexOf("?"));
+ }
- public URL getBaseUrl() {
- return (URL) get(Key.BASE_URL);
+ setBaseUrl(new URL(urlString));
+ } catch (MalformedURLException e) {
+ throw new RuntimeException(e);
+ }
}
public void setBaseUrl(URL baseUrl) {
@@ -98,32 +313,19 @@
updateCapabilitesUrl();
}
- public boolean updateCapabilitesUrl() {
- remove(WFSDataStoreFactory.URL.key);
+ public void setCachedTypeNames(String[] cachedTypeNames) {
+ this.cachedTypeNames = cachedTypeNames;
+ }
- if (getBaseUrl() == null)
- return false;
+ public void setMaxFeatures(java.lang.Integer maxFeatures) {
+ put(WFSDataStoreFactory.MAXFEATURES.key, maxFeatures);
+ }
- if (getVersion() == null)
- return false;
+ public void setTimeout(java.lang.Integer timeout) {
+ put(WFSDataStoreFactory.TIMEOUT.key, timeout);
- try {
- URL fullUrl = DataUtilities.extendURL(getBaseUrl(),
- "?service=wfs&version=" + getVersion().getVersionString()
- + "&request=GetCapabilities");
-
- put(WFSDataStoreFactory.URL.key, fullUrl);
-
- return true;
- } catch (MalformedURLException e) {
- return false;
- }
}
- public WfsProtocollVersion getVersion() {
- return (WfsProtocollVersion) get(Key.VERSION);
- }
-
public void setVersion(WfsProtocollVersion version) {
if (get(Key.VERSION) != version) {
@@ -142,6 +344,10 @@
StringBuffer serialized = new StringBuffer(100);
+ // Title
+ serialized.append(getTitle());
+ serialized.append(DELIMITER);
+
// BaseUrl
serialized.append(getBaseUrl().toString());
serialized.append(DELIMITER);
@@ -150,26 +356,25 @@
serialized.append(getVersion().toString());
serialized.append(DELIMITER);
- return serialized.toString();
- }
+ serialized.append(getMaxFeatures());
+ serialized.append(DELIMITER);
- /**
- * @return transforms the settings to a String that can be stored in a
- * .properties line. @see #parsePropertiesString
- * @throws MalformedURLException
- */
- public static WfsServerSettings parsePropertiesString(String propString)
- throws MalformedURLException {
+ serialized.append(getTimeout());
+ serialized.append(DELIMITER);
- String[] split = propString.split(Pattern.quote(DELIMITER));
+ serialized.append(getLenient());
+ serialized.append(DELIMITER);
- // BaseUrl
- URL baseUrl = new URL(split[0]);
+ serialized.append(getHttpProtocol().getValue());
+ serialized.append(DELIMITER);
- // Version
- WfsProtocollVersion v = WfsProtocollVersion.valueOf(split[1]);
+ serialized.append(getUsername());
+ serialized.append(DELIMITER);
- return new WfsServerSettings(baseUrl, v);
+ serialized.append(getPassword());
+ serialized.append(DELIMITER);
+
+ return serialized.toString();
}
@Override
@@ -188,79 +393,58 @@
return s.toString();
}
- public void setCachedTypeNames(String[] cachedTypeNames) {
- this.cachedTypeNames = cachedTypeNames;
- }
+ public boolean updateCapabilitesUrl() {
+ remove(WFSDataStoreFactory.URL.key);
- public String[] getCachedTypeNames() {
- return cachedTypeNames;
- }
+ if (getBaseUrl() == null)
+ return false;
- private String[] cachedTypeNames = null;
+ if (getVersion() == null)
+ return false;
- public String getTitle() {
- // TODO
- return "" + getBaseUrl() + " " + getVersion();
- }
+ try {
+ URL fullUrl = DataUtilities.extendURL(getBaseUrl(),
+ "?service=wfs&version=" + getVersion().getVersionString()
+ + "&request=GetCapabilities");
- /**
- * Opens a GUI that asks the use define a DB connection.
- *
- * @param wfsServer
- * <code>null</code> to create a new instance, or an instance to
- * edit.
- * @return <code>null</code> if the user cancelled the creation of a new
- * {@link DbServerSettings}, otherwise the edited instance.
- */
- public static WfsServerSettings createOrEdit(Component owner,
- WfsServerSettings wfsServer) {
- boolean newCreated = false;
+ put(WFSDataStoreFactory.URL.key, fullUrl);
- if (wfsServer == null) {
- newCreated = true;
- wfsServer = new WfsServerSettings();
+ return true;
+ } catch (MalformedURLException e) {
+ return false;
}
+ }
- Text hostInput = new ManualInputOption.Text(
- "BaseURL (without any paramters)", true, wfsServer.getBaseUrl()
- .toString());
-
- Combo<WfsProtocollVersion> versionInput = new SelectionInputOption.Combo<WfsProtocollVersion>(
- "WFS Version", true, WfsProtocollVersion.values(),
- ArrayUtils.indexOf(WfsProtocollVersion.values(),
- wfsServer.getVersion()), WfsProtocollVersion.values());
-
- Object[] input = MultipleOptionPane.showMultipleInputDialog(owner,
- "WFS Connection parameters", hostInput, versionInput);
-
- if (input == null) {
- if (newCreated)
- return null;
- else
- return wfsServer;
- } else {
- wfsServer.setBaseUrl((String) input[0]);
- wfsServer.setVersion(((WfsProtocollVersion) input[1]));
+ public void setTitle(String title) {
+ if (title != null) {
+ if (title.contains(DELIMITER))
+ throw new IllegalArgumentException("Title may not contain "
+ + DELIMITER);
+ if (title.contains(WfsServerList.DELIMITER))
+ throw new IllegalArgumentException("Title may not contain "
+ + WfsServerList.DELIMITER);
}
+ this.title = title;
+ }
- return wfsServer;
+ public void setPassword(String password) {
+ if (password != null && password.isEmpty())
+ password = null;
+ put(WFSDataStoreFactory.PASSWORD.key, password);
+ }
+ public String getPassword() {
+ return (String) get(WFSDataStoreFactory.PASSWORD.key);
}
- /**
- * Set the BaseUrl as a String. Any pending parameters are automatically cut
- * of.
- */
- public void setBaseUrl(String urlString) {
- try {
- // Cutoff any parameters
- if (urlString.indexOf("?") > -1) {
- urlString = urlString.substring(0, urlString.indexOf("?"));
- }
+ public void setUsername(String username) {
+ if (username != null && username.isEmpty())
+ username = null;
+ put(WFSDataStoreFactory.USERNAME.key, username);
+ }
- setBaseUrl(new URL(urlString));
- } catch (MalformedURLException e) {
- throw new RuntimeException(e);
- }
+ public String getUsername() {
+ return (String) get(WFSDataStoreFactory.USERNAME.key);
}
+
}
Modified: trunk/src/skrueger/geotools/io/WfsSettingsJComboBox.java
===================================================================
--- trunk/src/skrueger/geotools/io/WfsSettingsJComboBox.java 2010-10-24 16:55:46 UTC (rev 1162)
+++ trunk/src/skrueger/geotools/io/WfsSettingsJComboBox.java 2010-10-24 22:55:43 UTC (rev 1163)
@@ -8,17 +8,18 @@
private final WfsServerList wfsList;
public WfsSettingsJComboBox(WfsServerList wfsList) {
- super(wfsList.toArray( new WfsServerSettings[0]));
+ super(wfsList.toArray(new WfsServerSettings[0]));
this.wfsList = wfsList;
}
public WfsServerList getWfsList() {
return wfsList;
}
-
+
public void listChanged() {
- setModel(new DefaultComboBoxModel(wfsList.toArray(new DbServerSettings[0])));
+ WfsServerSettings[] array = wfsList
+ .toArray(new WfsServerSettings[wfsList.size()]);
+ setModel(new DefaultComboBoxModel(array));
}
-
}
Added: trunk/src_junit/skrueger/geotools/io/DbSettingsJComboBoxTest.java
===================================================================
--- trunk/src_junit/skrueger/geotools/io/DbSettingsJComboBoxTest.java 2010-10-24 16:55:46 UTC (rev 1162)
+++ trunk/src_junit/skrueger/geotools/io/DbSettingsJComboBoxTest.java 2010-10-24 22:55:43 UTC (rev 1163)
@@ -0,0 +1,13 @@
+package skrueger.geotools.io;
+
+import org.junit.Test;
+
+public class DbSettingsJComboBoxTest {
+
+ @Test
+ public void testListChanged() {
+ new DbSettingsJComboBox(new DbServerList(new DbServerSettings()))
+ .listChanged();
+ }
+
+}
Property changes on: trunk/src_junit/skrueger/geotools/io/DbSettingsJComboBoxTest.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Name: svn:keywords
+ Id URL
Name: svn:eol-style
+ native
Modified: trunk/src_junit/skrueger/geotools/io/WfsServerSettingsTest.java
===================================================================
--- trunk/src_junit/skrueger/geotools/io/WfsServerSettingsTest.java 2010-10-24 16:55:46 UTC (rev 1162)
+++ trunk/src_junit/skrueger/geotools/io/WfsServerSettingsTest.java 2010-10-24 22:55:43 UTC (rev 1163)
@@ -8,6 +8,7 @@
import org.junit.Test;
+import skrueger.geotools.io.WfsServerSettings.HttpProtocol;
import skrueger.geotools.io.WfsServerSettings.WfsProtocollVersion;
public class WfsServerSettingsTest {
@@ -20,13 +21,39 @@
assertTrue(wfs1.isWellDefined());
- wfs1.toPropertiesString();
+ WfsServerSettings wfs2 = WfsServerSettings.parsePropertiesString(wfs1
+ .toPropertiesString());
+ assertEquals(wfs1.getBaseUrl(), wfs2.getBaseUrl());
+ assertEquals(wfs1.getVersion(), wfs2.getVersion());
+ assertEquals(wfs1.getCapabilitiesUrl(), wfs2.getCapabilitiesUrl());
+ assertEquals(wfs1.isWellDefined(), wfs2.isWellDefined());
+ }
+
+ @Test
+ public void testParseAndSerialize2() throws MalformedURLException {
+ WfsServerSettings wfs1 = new WfsServerSettings(new URL(
+ "http://localhost:8085/geoserver/ows"),
+ WfsProtocollVersion.v1_0_0);
+
+ wfs1.setHttpProtocol(HttpProtocol.GET);
+ wfs1.setUsername("hans");
+ wfs1.setPassword("***");
+ wfs1.setTimeout(12345);
+ wfs1.setMaxFeatures(54321);
+ wfs1.setTitle("sweety");
+
WfsServerSettings wfs2 = WfsServerSettings.parsePropertiesString(wfs1
.toPropertiesString());
assertEquals(wfs1.getBaseUrl(), wfs2.getBaseUrl());
assertEquals(wfs1.getVersion(), wfs2.getVersion());
+ assertEquals(HttpProtocol.GET, wfs2.getHttpProtocol());
+ assertEquals("hans", wfs2.getUsername());
+ assertEquals("***", wfs2.getPassword());
+ assertEquals(12345, wfs2.getTimeout(), 0.0001);
+ assertEquals(54321, wfs2.getMaxFeatures(), 0.0001);
+ assertEquals("sweety", wfs2.getTitle());
assertEquals(wfs1.getCapabilitiesUrl(), wfs2.getCapabilitiesUrl());
assertEquals(wfs1.isWellDefined(), wfs2.isWellDefined());
}
Added: trunk/src_junit/skrueger/geotools/io/WfsSettingsJComboBoxTest.java
===================================================================
--- trunk/src_junit/skrueger/geotools/io/WfsSettingsJComboBoxTest.java 2010-10-24 16:55:46 UTC (rev 1162)
+++ trunk/src_junit/skrueger/geotools/io/WfsSettingsJComboBoxTest.java 2010-10-24 22:55:43 UTC (rev 1163)
@@ -0,0 +1,13 @@
+package skrueger.geotools.io;
+
+import org.junit.Test;
+
+public class WfsSettingsJComboBoxTest {
+
+ @Test
+ public void testListChanged() {
+ new WfsSettingsJComboBox(new WfsServerList(new WfsServerSettings()))
+ .listChanged();
+ }
+
+}
Property changes on: trunk/src_junit/skrueger/geotools/io/WfsSettingsJComboBoxTest.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Name: svn:keywords
+ Id URL
Name: svn:eol-style
+ native
More information about the Schmitzm-commits
mailing list