Application: gvSIG desktop » gvSIG data provider for DXF

public class DXFFilesystemServerProvider extends AbstractFilesystemServerExplorerProvider

        implements FilesystemServerExplorerProvider, ResourceConsumer {

    private FilesystemServerExplorerProviderServices serverExplorer;

    @Override

    public String getDataStoreProviderName() {

        return DXFStoreProvider.NAME;

    }

    @Override

    public int getMode() {

        return DataServerExplorer.MODE_FEATURE | DataServerExplorer.MODE_GEOMETRY;

    }

    @Override

    public boolean accept(File pathname) {

        return (pathname.getName().toLowerCase().endsWith(".dxf"));

    }

    @Override

    public String getDescription() {

        return DXFStoreProvider.DESCRIPTION;

    }

    @Override

    public boolean canCreate() {

        return true;

    }

    @Override

    public boolean canCreate(NewDataStoreParameters parameters) {

        if (!(parameters instanceof DXFOpenStoreParameters)) {

            throw new IllegalArgumentException(); // FIXME ???

        }

        DXFOpenStoreParameters dxfParams = (DXFOpenStoreParameters) parameters;

        // TODO comporbar si el ftype es correcto (para este formato es fijo)

        File file = new File(dxfParams.getFileName());

        if (dxfParams.getCRS() == null) {

            return false;

        }

        // TODO comprobamos extension del fichero ??

        if (file.exists()) {

            return file.canWrite();

        } else {

            return file.getParentFile().canWrite();

        }

    }

    @Override

    public void create(NewDataStoreParameters parameters, boolean overwrite)

            throws CreateException {

        final IProjection projection = null;

        DXFNewStoreParameters params = (DXFNewStoreParameters) parameters;

        File file = params.getFile();

        if (!file.isAbsolute()) {

            throw new AbsolutePathRequiredException(file.getPath());

        }

        if (file.exists()) {

            if (overwrite) {

                if (!file.delete()) {

                    throw new CreateException(this.getDataStoreProviderName(),

                            new IOException(

                                    "cannot delete file"));

                }

            } else {

                throw new CreateException(this.getDataStoreProviderName(),

                        new IOException(

                                "file already exist"));

            }

        }

        final FileResource resource;

        try {

            resource = (FileResource) this.serverExplorer

                    .getServerExplorerProviderServices().createResource(

                            FileResource.NAME,

                            new Object[]{file.getAbsolutePath()});

        } catch (InitializeException e1) {

            throw new CreateException(params.getFileName(), e1);

        }

        resource.addConsumer(this);

        try {

            resource.execute(new ResourceAction() {

                public Object run() throws Exception {

                    Builder builder

                            = new Builder().initialice(resource.getFileName(),

                                    projection);

                    resource.notifyOpen();

                    builder.begin();

                    builder.create();

                    builder.end();

                    resource.notifyClose();

                    resource.setData(null); // FIXME: Seguro que hay que ponerlo

                    // a null ??

                    resource.notifyChanges();

                    return null;

                }

            });

        } catch (Exception e) {

            throw new CreateException(params.getFileName(), e);

        } finally {

            resource.removeConsumer(this);

        }

    }

    public class Builder {

        private String fileName;

        private IProjection projection;

        public Builder initialice(String fileName, IProjection projection) {

            this.fileName = fileName;

            this.projection = projection;

            return this;

        }

        public void begin() {

        }

        public void end() {

        }

        public void create() throws IOException {

            DxfEntityMaker entityMaker = new DxfEntityMaker(projection);

            DxfFile dxfFile = new DxfFile(null, fileName, entityMaker);

            dxfFile.setCadFlag(true);

            dxfFile.setDxf3DFlag(false);

            dxfFile.save(fileName);

        }

    }

    @Override

    public NewDataStoreParameters getCreateParameters() throws DataException {

        return new DXFNewStoreParameters();

    }

    @Override

    public void initialize(

            FilesystemServerExplorerProviderServices serverExplorer) {

        this.serverExplorer = serverExplorer;

    }

    @Override

    public void remove(DataStoreParameters parameters) throws RemoveException {

        File file = new File(((DXFOpenStoreParameters) parameters).getFileName());

        if (!file.exists()) {

            throw new RemoveException(this.getDataStoreProviderName(),

                    new FileNotFoundException(file));

        }

        if (!file.delete()) {

            // FIXME throws ???

        }

    }

    public boolean closeResourceRequested(ResourceProvider resource) {

        // while it is using a resource anyone can't close it

        return false;

    }

    @Override

    public void resourceChanged(ResourceProvider resource) {

        //Do nothing

    }