Application: gvSIG desktop

public class ReprojectDefaultGeometry

    extends AbstractFeatureStoreTransform {

    private IProjection targetSRS;

    private ICoordTrans ct;

    private IProjection sourceSRS;

    private FeatureType orgDefFeatureType;

    private List orgFeatureTypes;

    public ReprojectDefaultGeometry() {

    }

    public IProjection getTargetSRS() {

        return targetSRS;

    }

    public void setTargetSRS(IProjection targetSRS) {

        this.targetSRS = targetSRS;

    }

    /* (non-Javadoc)

     */

    public void applyTransform(Feature source, EditableFeature target)

        throws DataException {

        FeatureAttributeDescriptor attr;

        Iterator iter = target.getType().iterator();

        int defGeomIndex = target.getType().getDefaultGeometryAttributeIndex();

        while( iter.hasNext() ) {

            attr = (FeatureAttributeDescriptor) iter.next();

            if( attr.getIndex() == defGeomIndex ) {

                Geometry geom = source.getDefaultGeometry();

                geom.reProject(ct);

                target.setDefaultGeometry(geom);

            } else {

                target.set(attr.getIndex(), source.get(attr.getName()));

            }

        }

    }

    @Override

    public void setUp() {

        try {

            FeatureStore store = this.getFeatureStore();

            orgDefFeatureType = store.getDefaultFeatureType();

            orgFeatureTypes = store.getFeatureTypes();

            EditableFeatureType defFType = orgDefFeatureType

                .getEditable();

            EditableFeatureAttributeDescriptor attr = (EditableFeatureAttributeDescriptor) defFType

                .getAttributeDescriptor(defFType

                    .getDefaultGeometryAttributeName());

            sourceSRS = attr.getSRS();

            ct = sourceSRS.getCT(targetSRS);

            attr.setSRS(this.targetSRS);

            FeatureType defaultType = defFType.getNotEditableCopy();

            List types = new ArrayList();

            Iterator iter = orgFeatureTypes.iterator();

            FeatureType tmp;

            while( iter.hasNext() ) {

                tmp = (FeatureType) iter.next();

                if( tmp.getId().equals(defaultType.getId()) ) {

                    types.add(defaultType);

                } else {

                    types.add(tmp);

                }

            }

            this.setFeatureTypes(types, defaultType);

        } catch (DataException e) {

            // FIXME

            throw new RuntimeException(e);

        }

    }

    /* (non-Javadoc)

     */

    public FeatureType getSourceFeatureTypeFrom(FeatureType targetFeatureType) {

        EditableFeatureType result = null;

        FeatureType tmp;

        EditableFeatureAttributeDescriptor attr;

        Iterator iter = orgFeatureTypes.iterator();

        Iterator iterAttr;

        while( iter.hasNext() ) {

            tmp = (FeatureType) iter.next();

            if( tmp.getId().equals(targetFeatureType.getId()) ) {

                result = tmp.getEditable();

                iterAttr = result.iterator();

                while( iterAttr.hasNext() ) {

                    attr = (EditableFeatureAttributeDescriptor) iterAttr.next();

                    if( targetFeatureType.getIndex(attr.getName()) < 0 ) {

                        iterAttr.remove();

                    }

                }

                break;

            }

        }

        return result.getNotEditableCopy();

    }

    /* (non-Javadoc)

     */

    public boolean isTransformsOriginalValues() {

        return true;

    }

    /* (non-Javadoc)

     */

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("source_crs", this.sourceSRS);

        state.set("source_defaultFeatureType", this.orgDefFeatureType);

        state.set("source_featureTypes", this.orgFeatureTypes);

        state.set("target_crs", this.targetSRS);

        state.set("coordtrans", this.ct);

    }

    /* (non-Javadoc)

     */

    public void loadFromState(PersistentState state) throws PersistenceException {

        super.loadFromState(state);

        this.sourceSRS = (IProjection) state.get("source_crs");

        this.orgDefFeatureType = (FeatureType) state.get("source_defaultFeatureType");

        this.orgFeatureTypes = new ArrayList((List) state.get("source_featureTypes"));

        this.targetSRS = (IProjection) state.get("target_crs");

        this.ct = (ICoordTrans) state.get("coordtrans");

    }

    public static class RegisterPersistence

        implements Callable {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            DynStruct definition = manager.addDefinition(

                ReprojectDefaultGeometry.class,

                "ReprojectDefaultGeometry",

                "ReprojectDefaultGeometry Persistence definition",

                null,

                null

            );

            definition.extend(manager.getDefinition(AbstractFeatureStoreTransform.class));

            definition.addDynFieldObject("source_crs")

                .setClassOfValue(IProjection.class)

                .setMandatory(true);

            definition.addDynFieldObject("source_defaultFeatureType")

                .setClassOfValue(FeatureType.class)

                .setMandatory(true);

            definition.addDynFieldList("source_featureTypes")

                .setClassOfItems(FeatureType.class)

                .setMandatory(true);

            definition.addDynFieldObject("target_crs")

                .setClassOfValue(IProjection.class)

                .setMandatory(true);

            definition.addDynFieldObject("coordtrans")

                .setClassOfValue(ICoordTrans.class)

                .setMandatory(true);