import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
@Override
public void populate(SelectedSymbol selectedSymbol) {

    if (selectedSymbol != null) {
        StyledLayer styledLayer = selectedSymbol.getStyledLayer();
        if (styledLayer instanceof NamedLayerImpl) {
            NamedLayerImpl namedLayer = (NamedLayerImpl) styledLayer;

            fieldConfigVisitor.populateTextField(FieldIdEnum.NAME, namedLayer.getName());

            // Feature layer constraint
            List<FeatureTypeConstraint> ftcList = namedLayer.layerFeatureConstraints();

            fieldConfigVisitor.populateFieldTypeConstraint(
                    FieldIdEnum.LAYER_FEATURE_CONSTRAINTS, ftcList);
        }
    }
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
/**
 * Populate field.
 *
 * @param valueList the value list
 */
@Override
public void populateField(List<FeatureTypeConstraint> valueList) {
    if (filterModel != null) {
        if (valueList != null) {
            filterModel.populate(valueList);

            UndoManager.getInstance()
                    .addUndoEvent(new UndoEvent(this, getFieldId(), oldValueObj, valueList));

            oldValueObj = valueList;

            valueUpdated();
        }
    }
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
/**
 * Update extents of a feature type constraint.
 *
 * @param ftc the feature type constraint to update
 */
public void updateExtent(FeatureTypeConstraint ftc) {
    if (ftc == null) {
        return;
    }

    if (!extentList.isEmpty()) {
        Extent[] extentArray = new Extent[extentList.size()];
        int index = 0;
        for (Extent extent : extentList) {
            Extent newExtent = styleFactory.createExtent(extent.getName(), extent.getValue());

            extentArray[index] = newExtent;

            index++;
        }

        ftc.setExtents(extentArray);
    }
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
@Override
public Object getValueAt(int rowIndex, int columnIndex) {
    if ((rowIndex < 0) || (rowIndex >= getRowCount())) {
        return null;
    }

    if ((columnIndex < 0) || (columnIndex >= getColumnCount())) {
        return null;
    }

    FeatureTypeConstraint ftc = ftcList.get(rowIndex);

    switch (columnIndex) {
    case COL_NAME:
        return ftc.getFeatureTypeName();
    case COL_FILTER:
        if (ftc.getFilter() != null) {
            return ftc.getFilter().toString();
        }
        break;
    default:
        break;
    }
    return null;
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
/**
 * Test method for
 * {@link com.sldeditor.ui.detail.config.featuretypeconstraint.ExtentModel#updateExtent(org.geotools.styling.FeatureTypeConstraint)}.
 */
@Test
public void testUpdateExtent() {
    ExtentModel model = new ExtentModel(null);

    Extent[] extentArray = null;
    model.populate(extentArray);

    extentArray = new Extent[2];
    StyleFactoryImpl styleFactory = (StyleFactoryImpl) CommonFactoryFinder.getStyleFactory();
    extentArray[0] = styleFactory.createExtent("extent 1", "1 1 1 1");
    extentArray[1] = styleFactory.createExtent("extent 2", "2 2 2 2");
    model.populate(extentArray);

    FeatureTypeConstraint ftc = styleFactory.createFeatureTypeConstraint("feature type name",
            Filter.INCLUDE, null);

    model.updateExtent(null);
    model.updateExtent(ftc);

    assertNotNull(ftc.getExtents());
    assertEquals(2, ftc.getExtents().length);
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
/**
 * Update symbol.
 */
private void updateSymbol() {
    if (!Controller.getInstance().isPopulating()) {
        String name = fieldConfigVisitor.getText(FieldIdEnum.NAME);
        NamedLayer namedLayer = getStyleFactory().createNamedLayer();
        namedLayer.setName(name);

        // Feature type constraints
        List<FeatureTypeConstraint> ftcList = fieldConfigVisitor
                .getFeatureTypeConstraint(FieldIdEnum.LAYER_FEATURE_CONSTRAINTS);
        if ((ftcList != null) && !ftcList.isEmpty()) {
            FeatureTypeConstraint[] ftcArray = new FeatureTypeConstraint[ftcList.size()];
            namedLayer.setLayerFeatureConstraints(ftcList.toArray(ftcArray));
        }

        StyledLayer existingStyledLayer = SelectedSymbol.getInstance().getStyledLayer();
        if (existingStyledLayer instanceof NamedLayerImpl) {
            NamedLayerImpl existingNamedLayer = (NamedLayerImpl) existingStyledLayer;

            for (Style style : existingNamedLayer.styles()) {
                namedLayer.addStyle(style);
            }
        }
        SelectedSymbol.getInstance().replaceStyledLayer(namedLayer);

        this.fireUpdateSymbol();
    }
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
/**
 * Undo action.
 *
 * @param undoRedoObject the undo/redo object
 */
@Override
public void undoAction(UndoInterface undoRedoObject) {
    if ((filterTable != null) && (undoRedoObject != null)) {
        try {
            @SuppressWarnings("unchecked")
            List<FeatureTypeConstraint> oldValue = (List<FeatureTypeConstraint>) undoRedoObject
                    .getOldValue();

            populateField(oldValue);
        } catch (ClassCastException e) {
            // Ignore
        }
    }
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
/**
 * Redo action.
 *
 * @param undoRedoObject the undo/redo object
 */
@Override
public void redoAction(UndoInterface undoRedoObject) {
    if ((filterTable != null) && (undoRedoObject != null)) {
        try {
            @SuppressWarnings("unchecked")
            List<FeatureTypeConstraint> newValue = (List<FeatureTypeConstraint>) undoRedoObject
                    .getNewValue();

            populateField(newValue);
        } catch (ClassCastException e) {
            // Ignore
        }
    }
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
@Override
public void extentUpdated() {
    if (filterTable != null) {
        FeatureTypeConstraint ftc = filterModel
                .getFeatureTypeConstraint(filterTable.getSelectedRow());
        if (ftc != null) {
            extentModel.updateExtent(ftc);
        }

        featureTypeConstraintUpdated();
    }
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
/**
 * Adds the new entry.
 */
public void addNewEntry() {

    FeatureTypeConstraint ftc = styleFactory.createFeatureTypeConstraint(DEFAULT_NAME,
            Filter.INCLUDE, new Extent[0]);
    ftcList.add(ftc);

    this.fireTableDataChanged();

    if (parentObj != null) {
        parentObj.featureTypeConstraintUpdated();
    }
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
/**
 * Sets the value at.
 *
 * @param aValue the a value
 * @param rowIndex the row index
 * @param columnIndex the column index
 */
@Override
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
    if ((rowIndex < 0) || (rowIndex >= getRowCount())) {
        return;
    }

    if ((columnIndex < 0) || (columnIndex >= getColumnCount())) {
        return;
    }

    FeatureTypeConstraint ftc = ftcList.get(rowIndex);

    switch (columnIndex) {
    case COL_NAME: {
        String name = (String) aValue;
        ftc.setFeatureTypeName(name);
    }
        break;
    case COL_FILTER:
        break;
    default:
        break;
    }

    this.fireTableDataChanged();

    if (parentObj != null) {
        parentObj.featureTypeConstraintUpdated();
    }
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
/**
 * Populate.
 *
 * @param ftcList the ftc list
 */
public void populate(List<FeatureTypeConstraint> ftcList) {
    this.ftcList.clear();

    if (ftcList != null) {
        for (FeatureTypeConstraint ftc : ftcList) {
            FeatureTypeConstraint newFTC = styleFactory.createFeatureTypeConstraint(
                    ftc.getFeatureTypeName(), ftc.getFilter(), new Extent[0]);

            this.ftcList.add(newFTC);
        }
    }
    this.fireTableDataChanged();
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
/**
 * Gets the feature type constraint.
 *
 * @param row the row
 * @return the feature type constraint
 */
public FeatureTypeConstraint getFeatureTypeConstraint(int row) {
    if ((row >= 0) && (row < ftcList.size())) {
        FeatureTypeConstraint ftc = ftcList.get(row);

        return ftc;
    }
    return null;
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
/**
 * Populate feature type constraint field.
 *
 * @param fieldId the field id
 * @param ftcList the ftc list
 */
public void populateFieldTypeConstraint(FieldIdEnum fieldId,
        List<FeatureTypeConstraint> ftcList) {
    if (fieldConfigManager == null) {
        return;
    }
    FieldConfigBase fieldConfig = fieldConfigManager.get(fieldId);
    if (fieldConfig != null) {
        fieldConfig.populateField(ftcList);
    }
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
/**
 * Gets the list of feature type constraints.
 *
 * @param fieldId the field id
 * @return the list of feature type constraints
 */
public List<FeatureTypeConstraint> getFeatureTypeConstraint(FieldIdEnum fieldId) {
    if (fieldConfigManager != null) {
        FieldConfigValuePopulateInterface fieldConfig = fieldConfigManager.get(fieldId);

        if (fieldConfig != null) {
            return fieldConfig.getFeatureTypeConstraint();
        }
    }
    return null;
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
/** (non-Javadoc)
 * @see org.geotools.styling.visitor.DuplicatingStyleVisitor#visit(org.geotools.styling.UserLayer)
 */
public void visit(UserLayer layer) {

    Style[] style = layer.getUserStyles();
    int length = style.length;
    Style[] styleCopy = new Style[length];
    for (int i = 0; i < length; i++) {
        if (style[i] != null) {
            style[i].accept(this);
            styleCopy[i] = (Style) pages.pop();
        }
    }

    FeatureTypeConstraint[] lfc = layer.getLayerFeatureConstraints();
    FeatureTypeConstraint[] lfcCopy = new FeatureTypeConstraint[lfc.length];

    length = lfc.length;
    for (int i = 0; i < length; i++) {
        if (lfc[i] != null) {
            lfc[i].accept(this);
            lfcCopy[i] = (FeatureTypeConstraint) pages.pop();
        }
    }

    UserLayer copy = sf.createUserLayer();
    copy.setName(layer.getName());
    copy.setUserStyles(styleCopy);
    copy.setLayerFeatureConstraints(lfcCopy);

    // Reuse the existing inline feature data store
    copy.setInlineFeatureDatastore(layer.getInlineFeatureDatastore());
    copy.setInlineFeatureType(layer.getInlineFeatureType());

    if (STRICT && !copy.equals(layer)) {
        throw new IllegalStateException("Was unable to duplicate provided UserLayer:" + layer);
    }
    pages.push(copy);
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
/**
 * Test method for
 * {@link com.sldeditor.ui.detail.config.FieldConfigPopulation#FieldConfigPopulation(com.sldeditor.ui.detail.GraphicPanelFieldManager)}.
 */
@Test
public void testFieldConfigPopulation() {
    FieldIdEnum fieldId = FieldIdEnum.UNKNOWN;
    FieldConfigPopulation obj = new FieldConfigPopulation(null);
    obj.populateBooleanField(fieldId, Boolean.TRUE);
    obj.populateComboBoxField(fieldId, "");
    obj.populateColourField(fieldId, null);
    obj.populateColourMapField(FieldIdEnum.ANCHOR_POINT_V, (ColorMap) null);
    obj.populateFontField(FieldIdEnum.ANCHOR_POINT_V, (Font) null);
    obj.populateTextField(fieldId, (String) null);
    obj.populateDoubleField(fieldId, (Double) null);
    obj.populateIntegerField(fieldId, (Integer) null);
    obj.populateField(fieldId, (Expression) null);
    obj.populateUserLayer(fieldId, (UserLayer) null);
    obj.populateFieldTypeConstraint(fieldId, (List<FeatureTypeConstraint>) null);

    assertNull(obj.getExpression(fieldId));
    assertFalse(obj.getBoolean(fieldId));
    assertEquals(0, obj.getInteger(fieldId));
    assertTrue(Math.abs(obj.getDouble(fieldId) - 0.0) < 0.001);
    assertTrue(obj.getText(fieldId).compareTo("") == 0);
    assertNull(obj.getComboBox(fieldId));
    assertNull(obj.getColourMap(fieldId));
    assertNull(obj.getFieldConfig(fieldId));
    assertNull(obj.getFeatureTypeConstraint(fieldId));
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
/**
 * Test method for
 * {@link com.sldeditor.ui.detail.config.featuretypeconstraint.FieldConfigFeatureTypeConstraint#generateExpression()}.
 * Test method for
 * {@link com.sldeditor.ui.detail.config.featuretypeconstraint.FieldConfigFeatureTypeConstraint#populateExpression(java.lang.Object)}.
 * Test method for
 * {@link com.sldeditor.ui.detail.config.featuretypeconstraint.FieldConfigFeatureTypeConstraint#setTestValue(com.sldeditor.ui.detail.config.FieldId, java.util.List)}.
 * Test method for
 * {@link com.sldeditor.ui.detail.config.featuretypeconstraint.FieldConfigFeatureTypeConstraint#populateField(java.util.List)}.
 * Test method for
 * {@link com.sldeditor.ui.detail.config.featuretypeconstraint.FieldConfigFeatureTypeConstraint#getFeatureTypeConstraint()}.
 */
@Test
public void testGenerateExpression() {
    FieldConfigFeatureTypeConstraint field = new FieldConfigFeatureTypeConstraint(
            new FieldConfigCommonData(Geometry.class, FieldIdEnum.NAME, "label", true));
    List<FeatureTypeConstraint> testValue = null;
    field.populate(null);
    field.setTestValue(FieldIdEnum.UNKNOWN, testValue);
    field.populateField(testValue);

    field.createUI();
    assertNull(field.getStringValue());

    StyleFactoryImpl styleFactory = (StyleFactoryImpl) CommonFactoryFinder.getStyleFactory();
    FeatureTypeConstraint expectedValue1 = styleFactory.createFeatureTypeConstraint("Feature",
            Filter.INCLUDE, new Extent[0]);

    testValue = new ArrayList<FeatureTypeConstraint>();
    testValue.add(expectedValue1);
    field.populateField(testValue);
    assertEquals(expectedValue1, field.getFeatureTypeConstraint().get(0));

    field.setTestValue(FieldIdEnum.UNKNOWN, testValue);
    assertEquals(expectedValue1, field.getFeatureTypeConstraint().get(0));

    field.populateExpression((String) null);
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
/**
 * Test method for
 * {@link com.sldeditor.ui.detail.config.featuretypeconstraint.FieldConfigFeatureTypeConstraint#undoAction(com.sldeditor.common.undo.UndoInterface)}.
 * Test method for
 * {@link com.sldeditor.ui.detail.config.featuretypeconstraint.FieldConfigFeatureTypeConstraint#redoAction(com.sldeditor.common.undo.UndoInterface)}.
 */
@Test
public void testUndoAction() {
    FieldConfigFeatureTypeConstraint field = new FieldConfigFeatureTypeConstraint(
            new FieldConfigCommonData(Geometry.class, FieldIdEnum.NAME, "label", true));
    field.undoAction(null);
    field.redoAction(null);
    field.createUI();

    StyleFactoryImpl styleFactory = (StyleFactoryImpl) CommonFactoryFinder.getStyleFactory();
    FeatureTypeConstraint expectedValue1 = styleFactory.createFeatureTypeConstraint("Feature",
            Filter.INCLUDE, new Extent[0]);

    List<FeatureTypeConstraint> testValue = new ArrayList<FeatureTypeConstraint>();

    testValue.add(expectedValue1);
    field.populateField(testValue);
    assertEquals(expectedValue1, field.getFeatureTypeConstraint().get(0));

    FeatureTypeConstraint expectedValue2 = styleFactory.createFeatureTypeConstraint("Feature2",
            Filter.INCLUDE, new Extent[0]);
    List<FeatureTypeConstraint> testValue2 = new ArrayList<FeatureTypeConstraint>();
    testValue2.add(expectedValue1);
    testValue2.add(expectedValue2);
    field.populateField(testValue2);

    UndoManager.getInstance().undo();
    assertEquals(1, field.getFeatureTypeConstraint().size());
    assertEquals(expectedValue1, field.getFeatureTypeConstraint().get(0));
    UndoManager.getInstance().redo();
    assertEquals(2, field.getFeatureTypeConstraint().size());
    assertEquals(expectedValue2, field.getFeatureTypeConstraint().get(1));

    // Increase the code coverage
    field.undoAction(null);
    field.undoAction(new UndoEvent(null, FieldIdEnum.NAME, "", "new"));
    field.redoAction(null);
    field.redoAction(new UndoEvent(null, FieldIdEnum.NAME, "", "new"));
}
 

import org.geotools.styling.FeatureTypeConstraint; //导入依赖的package包/类
/**
 * Converts a style to its string representation to be written to file.
 * 
 * @param style
 *            the style to convert.
 * @return the style string.
 * @throws Exception
 */
public static String styleToString(final Style style) throws Exception {
	final StyledLayerDescriptor sld = sf.createStyledLayerDescriptor();
	final UserLayer layer = sf.createUserLayer();
	layer.setLayerFeatureConstraints(new FeatureTypeConstraint[] { null });
	sld.addStyledLayer(layer);
	layer.addUserStyle(style);

	final SLDTransformer aTransformer = new SLDTransformer();
	aTransformer.setIndentation(4);
	final String xml = aTransformer.transform(sld);
	return xml;
}