gvSIG projects pool

package org.gvsig.report.lib.impl;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.URL;

import net.sf.jasperreports.engine.JRRuntimeException;

import net.sf.jasperreports.engine.util.JRLoader;

import net.sf.jasperreports.repo.InputStreamResource;

import net.sf.jasperreports.repo.ObjectResource;

import net.sf.jasperreports.repo.Resource;

import net.sf.jasperreports.repo.StreamRepositoryService;

import org.gvsig.report.lib.impl.commands.GetImage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class ResourcesRepositoryService implements StreamRepositoryService {

    private final ResourcesStorage resources;

    private final GetImage fetchFromField;

    private class GVResourceToJRInputStreamResourceAdapter extends InputStreamResource {

        private final ResourcesStorage.Resource resource;

        public GVResourceToJRInputStreamResourceAdapter(ResourcesStorage.Resource resource) {

            this.resource = resource;

        }

        @Override

        public InputStream getValue() {

            try {

                return this.resource.asInputStream();

            } catch (IOException ex) {

                return null;

            }

        }

    }

    private class URLToJRInputStreamResourceAdapter extends InputStreamResource {

        private final URL url;

        public URLToJRInputStreamResourceAdapter(URL url) {

            this.url = url;

        }

        @Override

        public InputStream getValue() {

            try {

                return this.url.openStream();

            } catch (IOException ex) {

                return null;

            }

        }

    }

    private class ByteArrayToJRInputStreamResourceAdapter extends InputStreamResource {

        private final byte[] data;

        public ByteArrayToJRInputStreamResourceAdapter(byte[] data) {

            this.data = data;

        }

        @Override

        public InputStream getValue() {

          ByteArrayInputStream is = new ByteArrayInputStream(this.data);

          return is;

        }

    }

    public ResourcesRepositoryService(ResourcesStorage resources) {

        this.resources = resources;

        this.fetchFromField = new GetImage();

    }

    @Override

    public InputStream getInputStream(String uri) {

        try {

            InputStream is;

            ResourcesStorage.Resource resource = this.resources.getResource(uri);

            if (resource != null) {

                is = resource.asInputStream();

            } else {

                URL url = new URL(uri);

                if( this.fetchFromField.canUse(url) ) {

                  byte[] image = this.fetchFromField.fetch(url);

                  is = new ByteArrayInputStream(image);

                } else {

                  is = url.openStream();

                }

            }

            return is;

        } catch (Exception ex) {

            throw new JRRuntimeException(ex);

        }

    }

    @Override

    public OutputStream getOutputStream(String uri) {

        return null;

    }

    @Override

    public Resource getResource(String uri) {

        try {

            Resource r;

            ResourcesStorage.Resource resource = this.resources.getResource(uri);

            if (resource != null) {

                r = new GVResourceToJRInputStreamResourceAdapter(resource);

                return r;

            } else {

                URL url = new URL(uri);

                if( this.fetchFromField.canUse(url) ) {

                  byte[] image = this.fetchFromField.fetch(url);

                  r = new ByteArrayToJRInputStreamResourceAdapter(image);

                } else {

                  r = new URLToJRInputStreamResourceAdapter(url);

                }

            }

            return r;

        } catch (Exception ex) {

            throw new JRRuntimeException(ex);

        }

    }

    @Override

    public void saveResource(String uri, Resource resource) {

    }

    @Override

    public <K extends Resource> K getResource(String uri, Class<K> resourceType) {

        try {

            ObjectResource r = (ObjectResource) resourceType.newInstance();

            r.setName(uri);

            ResourcesStorage.Resource resource = this.resources.getResource(uri);

            if (resource != null) {

                InputStream is = resource.asInputStream();

                if (is!=null) {

                    Object v = JRLoader.loadObject(is);

                    r.setValue(v);

                    return (K) r;

                }

            }

            URL url = new URL(uri);

            if (this.fetchFromField.canUse(url)) {

                byte[] image = this.fetchFromField.fetch(url);

                ByteArrayInputStream is = new ByteArrayInputStream(image);

                r.setValue(is);

            } else {

                r.setValue(url.openStream());

            }

            return (K) r;

        } catch (Throwable th) {

            return null;

        }

    }

}

package org.gvsig.report.lib.impl;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.json.JSONArray;

import org.json.JSONObject;

import org.gvsig.report.lib.api.ReportDataSet;

import org.gvsig.report.lib.api.ReportDataSets;

import org.gvsig.report.lib.api.ReportManager;

import org.gvsig.report.lib.api.ReportServerConfig;

import org.gvsig.report.lib.api.ReportServices;

import org.gvsig.report.lib.api.ReportViewCapture;

/**

 *

 * @author jjdelcerro

 */

public class DefaultReportServerConfig implements ReportServerConfig {

    private int port;

    private int timeout;

    private String serverInfo;

    private ReportDataSets datasets;

    private boolean locked;

    private DefaultReportViewCaptures viewCaptures;

    private final PropertyChangeSupport propertyChangeSupport;

    private final ReportServices services;

    private final ReportManager manager;

    private boolean autostart;

    public DefaultReportServerConfig(ReportManager manager, ReportServices services) {

        this.services = services;

        this.manager = manager;

        this.port = 9876;

        this.timeout = 15000;

        this.serverInfo = "Test/1.1";

        this.locked = false;

        this.autostart = false;

        this.propertyChangeSupport = new PropertyChangeSupport(this);

        this.viewCaptures = new DefaultReportViewCaptures();

        this.viewCaptures.addPropertyChangeListener(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                propertyChangeSupport.firePropertyChange("viewCaptures", null, null);

            }

        });

        this.datasets = new DefaultReportDataSets(manager, services);

        this.datasets.addPropertyChangeListener(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                propertyChangeSupport.firePropertyChange("datasets", null, null);

            }

        });

    }

    @Override

    public ReportServices getServices() {

        return this.services;

    }

    public boolean isLocked() {

        return locked;

    }

    public void setLocked(boolean locked) {

        this.locked = locked;

    }

    @Override

    public int getPort() {

        return this.port;

    }

    @Override

    public ReportServerConfig setPort(int port) {

        int oldValue = this.port;

        this.port = port;

        this.propertyChangeSupport.firePropertyChange("port", oldValue, port);

        return this;

    }

    @Override

    public int getTimeout() {

        return this.timeout;

    }

    @Override

    public ReportServerConfig setTimeout(int timeout) {

        int oldValue = this.timeout;

        this.timeout = timeout;

        this.propertyChangeSupport.firePropertyChange("timeout", oldValue, timeout);

        return this;

    }

    @Override

    public String getServerInfo() {

        return this.serverInfo;

    }

    @Override

    public ReportServerConfig setServerInfo(String serverInfo) {

        String oldValue = this.serverInfo;

        this.serverInfo = serverInfo;

        this.propertyChangeSupport.firePropertyChange("serverInfo", oldValue, serverInfo);

        return this;

    }

    @Override

    public ReportDataSets getDatasets() {

        return this.datasets;

    }

    @Override

    public ReportDataSet getDataset(String name) {

        ReportDataSet dataset = this.datasets.get(name);

        if( dataset == null ) {

          DataManager dataManager = DALLocator.getDataManager();

          DataStore store = dataManager.getStoresRepository().getStore(name);

          if( store == null || !(store instanceof FeatureStore)) {

            return null;

          }

          dataset = new DefaultReportDataSet(services, name, (FeatureStore) store, null);

        }

        return dataset;

    }

    @Override

    public String toJSON() {

        JSONObject jsonconfig = new JSONObject();

        jsonconfig.put("port", this.port);

        jsonconfig.put("timeout", this.timeout);

        jsonconfig.put("serverInfo", this.serverInfo);

        jsonconfig.put("autostart", this.autostart);

        JSONArray jsondatasets = new JSONArray();

        jsonconfig.put("datasets", jsondatasets);

        for (ReportDataSet dataset : this.datasets) {

            jsondatasets.put(((DefaultReportDataSet) dataset).toJSON());

        }

        JSONArray jsonviewcaptures = new JSONArray();

        jsonconfig.put("viewcaptures", jsonviewcaptures);

        for (ReportViewCapture viewcapture : this.viewCaptures) {

            jsonviewcaptures.put(((DefaultReportViewCapture) viewcapture).toJSON());

        }

        return jsonconfig.toString();

    }

    public void fromJSON(JSONObject jsonConfig) {

        DefaultReportDataSets theDatasets = new DefaultReportDataSets(manager, services);

        DefaultReportViewCaptures theViewCaptures = new DefaultReportViewCaptures();

        if (jsonConfig.has("port")) {

            this.port = jsonConfig.getInt("port");

        }

        if (jsonConfig.has("timeout")) {

            this.timeout = jsonConfig.getInt("timeout");

        }

        if (jsonConfig.has("serverInfo")) {

            this.serverInfo = jsonConfig.getString("serverInfo");

        }

        if (jsonConfig.has("autostart")) {

            this.autostart = jsonConfig.getBoolean("autostart");

        }

        if (jsonConfig.has("datasets")) {

            JSONArray jsonDatasets = jsonConfig.getJSONArray("datasets");

            for (Object jsonDataset : jsonDatasets) {

                if( !(jsonDataset instanceof JSONObject) ) {

                    jsonDataset = new JSONObject(jsonDataset.toString());

                }

                ReportDataSet dataset = new DefaultReportDataSet(

                        this.getServices(),

                        (JSONObject) jsonDataset

                );

                theDatasets.add(dataset);

            }

        }

        theDatasets.addPropertyChangeListener(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                propertyChangeSupport.firePropertyChange("datasets", null, null);

            }

        });

        this.datasets = theDatasets;

        if (jsonConfig.has("viewcaptures")) {

            JSONArray jsonViewCaptures = jsonConfig.getJSONArray("viewcaptures");

            for (Object jsonViewCapture : jsonViewCaptures) {

                if( !(jsonViewCapture instanceof JSONObject) ) {

                    jsonViewCapture = new JSONObject(jsonViewCapture.toString());

                }

                ReportViewCapture viewCapture = new DefaultReportViewCapture(

                        this,

                        (JSONObject) jsonViewCapture

                );

                theViewCaptures.add(viewCapture);

            }

        }

        theViewCaptures.addPropertyChangeListener(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                propertyChangeSupport.firePropertyChange("viewcaptures", null, null);

            }

        });

        this.viewCaptures = theViewCaptures;

    }

    @Override

    public List<ReportViewCapture> getViewCaptures() {

        return this.viewCaptures;

    }

    @Override

    public ReportViewCapture getViewCapture(String name) {

        for (ReportViewCapture viewCapture : viewCaptures) {

            if( StringUtils.equalsIgnoreCase(name, viewCapture.getName()) ) {

                return viewCapture;

            }

        }

        return null;

    }

    @Override

    public void addPropertyChangeListener(PropertyChangeListener listener) {

        this.propertyChangeSupport.addPropertyChangeListener(listener);

    }

    @Override

    public void removePropertyChangeListener(PropertyChangeListener listener) {

        this.propertyChangeSupport.removePropertyChangeListener(listener);

    }

    @Override

    public boolean getAutostart() {

        return this.autostart;

    }

    @Override

    public void setAutostart(boolean autostart) {

        boolean oldValue = this.autostart;

        this.autostart = autostart;

        this.propertyChangeSupport.firePropertyChange("autostart", oldValue, this.autostart);

    }

}

package org.gvsig.report.lib.impl;

import java.awt.Dimension;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

import java.io.UnsupportedEncodingException;

import java.net.URLEncoder;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.report.lib.api.ReportDataSet;

import org.gvsig.report.lib.api.ReportServerConfig;

import org.gvsig.report.lib.api.ReportViewCapture;

import org.json.JSONObject;

/**

 *

 * @author jjdelcerro

 */

public class DefaultReportViewCapture implements ReportViewCapture {

    private static int counter = 0;

    private class DefaultReportViewCaptureFilter implements ReportViewCaptureFilter {

        private Expression expression;

        private String datasetName;

        private final PropertyChangeSupport propertyChangeSupport;

        public DefaultReportViewCaptureFilter() {

            this.propertyChangeSupport = new PropertyChangeSupport(this);

        }

        public DefaultReportViewCaptureFilter(JSONObject json) {

            this();

            if( json.has("expression") ) {

                this.expression = ExpressionUtils.createExpressionFromJSON(

                        json.getString("expression")

                );

            }

            if( json.has("datasetName") ) {

                this.datasetName = json.getString("datasetName");

            }

        }

        public JSONObject toJSON() {

            JSONObject me = new JSONObject();

            if( this.expression!=null ) {

                me.put("expression", this.expression.toJSON());

            }

            me.put("datasetName", StringUtils.defaultIfEmpty(this.datasetName,null));

            return me;

        }

        public String getURLPart() {

            if( StringUtils.isBlank(reportDataSetName) ) {

                return null;

            }

            ReportDataSet dataset = config.getDataset(reportDataSetName);

            if( dataset == null ) {

                return null;

            }

            Formatter reportformatter = new ReportExpressionCodeFormatter(

                    dataset.getFeatureType()

            );

            String s = expression.getCode().toString(reportformatter);

            s = s.replace(" ","+");

            return s;

        }

        @Override

        public String getDataSet() {

            return this.datasetName;

        }

        @Override

        public Expression getExpression() {

            return this.expression;

        }

        @Override

        public void setDataSet(String dataset) {

            this.datasetName = dataset;

            this.propertyChangeSupport.firePropertyChange("dataset", null, null);

        }

        @Override

        public void setDataSet(ReportDataSet dataset) {

            if( dataset == null ) {

                this.datasetName = null;

            } else {

                this.datasetName = dataset.getName();

            }

            this.propertyChangeSupport.firePropertyChange("dataset", null, null);

        }

        @Override

        public void setExpression(Expression expression) {

            this.expression = expression;

            this.propertyChangeSupport.firePropertyChange("expression", null, null);

        }

        @Override

        public boolean isEmpty() {

            return StringUtils.isEmpty(this.datasetName) || 

                    ExpressionUtils.isPhraseEmpty(this.expression);

        }

        public void addPropertyChangeListener(PropertyChangeListener listener) {

            this.propertyChangeSupport.addPropertyChangeListener(listener);

        }

        public void removePropertyChangeListener(PropertyChangeListener listener) {

            this.propertyChangeSupport.removePropertyChangeListener(listener);

        }

    }

    private DefaultReportViewCaptureFilter zoomFilter;

    private DefaultReportViewCaptureFilter centerFilter;

    private DefaultReportViewCaptureFilter selectFilter;

    private String name;

    private String viewName;

    private String reportDataSetName;

    private int margins;

    private boolean clearSelection;

    private Dimension dimensions;

    private int resolution;

    private final PropertyChangeSupport propertyChangeSupport;

    private final ReportServerConfig config;

    public DefaultReportViewCapture(ReportServerConfig config) {

        this.config = config;

        this.centerFilter = new DefaultReportViewCaptureFilter();

        this.centerFilter.addPropertyChangeListener(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                propertyChangeSupport.firePropertyChange("centerFilter", null, null);

            }

        });

        this.zoomFilter = new DefaultReportViewCaptureFilter();

        this.zoomFilter.addPropertyChangeListener(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                propertyChangeSupport.firePropertyChange("zoomFilter", null, null);

            }

        });

        this.selectFilter = new DefaultReportViewCaptureFilter();

        this.selectFilter.addPropertyChangeListener(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                propertyChangeSupport.firePropertyChange("selectFilter", null, null);

            }

        });

        this.resolution = 72;

        this.clearSelection = false;

        this.name = "capture"+counter++;

        this.viewName = null;

        this.margins = 0;

        this.dimensions = new Dimension();

        this.propertyChangeSupport = new PropertyChangeSupport(this);

    }

    public DefaultReportViewCapture(ReportServerConfig config, JSONObject json) {

        this(config);

        this.fromJSON(json);

    }

    @Override

    public boolean isEmpty() {

        return StringUtils.isBlank(this.viewName);

    }

    @Override

    public String getReportDataSet() {

        return reportDataSetName;

    }

    @Override

    public void setReportDataSet(String reportDataSet) {

        this.reportDataSetName = reportDataSet;

    }

    @Override

    public String toString() {

        return this.getName();

    }

    @Override

    public String getName() {

        return this.name;

    }

    @Override

    public void setName(String name) {

        this.name = name;

        this.propertyChangeSupport.firePropertyChange("name", null, null);

    }

    @Override

    public String getView() {

        return this.viewName;

    }

    @Override

    public void setView(String view) {

        this.viewName = view;

        this.propertyChangeSupport.firePropertyChange("view", null, null);

    }

    private static String encodeForURL(String s) {

        try {

            return URLEncoder.encode(s, "UTF8");

        } catch (UnsupportedEncodingException ex) {

            return s;

        }

    }

    @Override

    public String getFullURLPath() {

        StringBuilder builder = new StringBuilder();

        builder.append("/captureview/captureName/");

        builder.append(encodeForURL(this.name));

        builder.append("/viewName/");

        builder.append(encodeForURL(this.viewName));

        if( this.getResolution()>0 ) {

            builder.append("/DPI/");

            builder.append(this.getResolution());

        }

        if (!this.centerFilter.isEmpty()) {

            builder.append("/center/");

            builder.append(this.centerFilter.getDataSet());

            builder.append("/");

            builder.append(this.centerFilter.getURLPart());

        }

        if (!this.zoomFilter.isEmpty()) {

            builder.append("/zoom/");

            builder.append(this.zoomFilter.getDataSet());

            builder.append("/");

            builder.append(this.zoomFilter.getURLPart());

        }

        if (!this.selectFilter.isEmpty()) {

            builder.append("/select/");

            builder.append(this.selectFilter.getDataSet());

            builder.append("/");

            builder.append(this.selectFilter.getURLPart());

        }

        if (this.margins > 0) {

            builder.append("/margins/");

            builder.append(this.margins);

        }

        if (this.clearSelection) {

            builder.append("/clearselection");

        }

        if (this.hasDimensions()) {

            builder.append("/width/");

            builder.append(this.dimensions.width);

            builder.append("/height/");

            builder.append(this.dimensions.height);

        }

        return builder.toString();

    }

    @Override

    public boolean hasDimensions() {

        return this.dimensions.height > 0 || this.dimensions.width > 0;

    }

    @Override

    public Dimension getDimensions() {

        return this.dimensions;

    }

    @Override

    public ReportViewCaptureFilter getZoomFilter() {

        return this.zoomFilter;

    }

    @Override

    public ReportViewCaptureFilter getCenterFilter() {

        return this.centerFilter;

    }

    @Override

    public ReportViewCaptureFilter getSelectionFilter() {

        return this.selectFilter;

    }

    @Override

    public int getMargins() {

        return this.margins;

    }

    @Override

    public void setMargins(int margins) {

        this.margins = margins;

        this.propertyChangeSupport.firePropertyChange("margins", null, null);

    }

    @Override

    public boolean getClearSelection() {

        return this.clearSelection;

    }

    @Override

    public void setClearSelection(boolean clearSelection) {

        this.clearSelection = clearSelection;

        this.propertyChangeSupport.firePropertyChange("clearSelection", null, null);

    }

    public void addPropertyChangeListener(PropertyChangeListener listener) {

        this.propertyChangeSupport.addPropertyChangeListener(listener);

    }

    public void removePropertyChangeListener(PropertyChangeListener listener) {

        this.propertyChangeSupport.removePropertyChangeListener(listener);

    }

    public JSONObject toJSON() {

        JSONObject me = new JSONObject();

        me.put("zoomFilter", this.zoomFilter.toJSON());

        me.put("centerFilter", this.centerFilter.toJSON());

        me.put("selectFilter", this.selectFilter.toJSON());

        me.put("viewName", this.viewName);

        me.put("reportDataSetName", this.reportDataSetName);

        me.put("clearSelection", this.clearSelection);

        me.put("dimension.width", this.dimensions.width);

        me.put("dimension.height", this.dimensions.height);

        return me;

    }

    public void fromJSON(JSONObject json) {

        this.zoomFilter = new DefaultReportViewCaptureFilter(json.getJSONObject("zoomFilter"));

        this.centerFilter = new DefaultReportViewCaptureFilter(json.getJSONObject("centerFilter"));

        this.selectFilter = new DefaultReportViewCaptureFilter(json.getJSONObject("selectFilter"));

        if( json.has("viewName") ) {

            this.viewName = json.getString("viewName");

        }

        if( json.has("reportDataSetName") ) {

            this.reportDataSetName = json.getString("reportDataSetName");

        }

        if( json.has("clearSelection") ) {

            this.clearSelection = json.getBoolean("clearSelection");

        }

        int width = 0;

        int height = 0;

        if( json.has("dimension.width") ) {

            width = json.getInt("dimension.width");

        }

        if( json.has("dimension.height") ) {

            height = json.getInt("dimension.height");

        }

        this.dimensions = new Dimension(width, height);

    }

    @Override

    public int getResolution() {

        return this.resolution;

    }

    @Override

    public void setResolution(int resolution) {

        this.resolution = resolution;

    }

}

package org.gvsig.report.lib.impl.reportbuilder;

import ar.com.fdvs.dj.domain.constants.Border;

import java.awt.Color;

import org.gvsig.report.lib.api.ReportBuilder;

import org.gvsig.report.lib.api.ReportBuilder.BorderBuilder;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 *

 * @author jjdelcerro

 */

public class DefaultBorderBuilder implements ReportBuilder.BorderBuilder {

    private Color color;

    private int lineStyle;

    private int width;

    public DefaultBorderBuilder() {

        this.color = Color.BLACK;

        this.width = 0;

        this.lineStyle = BorderBuilder.WIDTH_1POINT;

    }

    @Override

    public BorderBuilder clone() throws CloneNotSupportedException {

        DefaultBorderBuilder other = (DefaultBorderBuilder) super.clone();

        return other;

    }

    @Override

    public void copyFrom(BorderBuilder other) {

        this.color = other.getColor();

        this.width = other.getWidth();

        this.lineStyle = other.getLineStyle();

    }

    @Override

    public Color getColor() {

        return this.color;

    }

    @Override

    public ReportBuilder.BorderBuilder color(Color color) {

        this.color = color;

        return this;

    }

    @Override

    public int getWidth() {

        return this.width;

    }

    @Override

    public ReportBuilder.BorderBuilder width(int width) {

        this.width = width;

        return this;

    }

    @Override

    public int getLineStyle() {

        return this.lineStyle;

    }

    @Override

    public ReportBuilder.BorderBuilder lineStyle(int lineStyle) {

        this.lineStyle = lineStyle;

        return this;

    }

    @Override

    public void saveToState(PersistentState ps) throws PersistenceException {

        // TODO

    }

    @Override

    public void loadFromState(PersistentState ps) throws PersistenceException {

        // TODO

    }

    public static void registerPersistence() {

        // TODO

    }

    Border build() {

        float theWidth;

        byte theLineStyle;

        switch (this.width) {

            case STYLE_SOLID:

            default:

                theLineStyle = Border.BORDER_STYLE_SOLID;

                break;

            case STYLE_DASHED:

                theLineStyle = Border.BORDER_STYLE_DASHED;

                break;

            case STYLE_DOTTED:

                theLineStyle = Border.BORDER_STYLE_DOTTED;

                break;

            case STYLE_DOUBLE:

                theLineStyle = Border.BORDER_STYLE_DOUBLE;

                break;

        }

        switch (this.lineStyle) {

            case WIDTH_NONE:

            default:

                theWidth = Border.BORDER_WIDTH_NONE;

                break;

            case WIDTH_1POINT:

                theWidth = Border.BORDER_WIDTH_1POINT;

                break;

            case WIDTH_2POINT:

                theWidth = Border.BORDER_WIDTH_2POINT;

                break;

            case WIDTH_4POINT:

                theWidth = Border.BORDER_WIDTH_4POINT;

                break;

            case WIDTH_THIN:

                theWidth = Border.BORDER_WIDTH_THIN;

                break;

        }

        Border border = new Border(

                theWidth,

                theLineStyle,

                this.color

        );

        return border;

    }

}

package org.gvsig.report.lib.impl.reportbuilder;

import ar.com.fdvs.dj.domain.CustomExpression;

import ar.com.fdvs.dj.domain.entities.columns.AbstractColumn;

import java.util.HashMap;

import java.util.Map;

import net.sf.jasperreports.engine.fill.JRFillField;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.spi.AbstractSymbolTable;

import org.gvsig.report.lib.api.ReportBuilder;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 *

 * @author jjdelcerro

 */

public class DefaultColumnBuilder implements ReportBuilder.ColumnBuilder {

    private String title;

    private ReportBuilder.StyleBuilder titleStyle;

    private String field;

    private ReportBuilder.StyleBuilder fieldStyle;

    private Expression expression;

    private ReportBuilder.StyleBuilder expressionStyle;

    private DataType dataType;

    private int width;

    private boolean fixedWidth;

    private String pattern;

    private String truncateSuffix;

    private boolean groupByField;

    private int groupByOperation;

    private String columnName;

    public DefaultColumnBuilder() {

        this.expressionStyle = new DefaultStyleBuilder();

        this.fieldStyle = new DefaultStyleBuilder();

        this.titleStyle = new DefaultStyleBuilder();

        this.truncateSuffix = "...";

        this.expression = null;

        this.pattern = null;

        this.width = 10;

        this.dataType = ToolsLocator.getDataTypesManager().get(DataTypes.STRING);

        this.groupByField = false;

        this.groupByOperation = 7;

        this.columnName = "";

    }

    @Override

    public ReportBuilder.ColumnBuilder clone() throws CloneNotSupportedException {

        DefaultColumnBuilder other = (DefaultColumnBuilder) super.clone();

        other.expressionStyle = this.expressionStyle.clone();

        other.fieldStyle = this.fieldStyle.clone();

        other.titleStyle = this.titleStyle.clone();

        if (this.expression != null) {

            other.expression = this.expression.clone();

        }

        // TODO: Usar aqui el metodo clone de DataType

        other.dataType = ToolsLocator.getDataTypesManager().get(this.dataType.getType());

        return other;

    }

    @Override

    public void copyFrom(ReportBuilder.ColumnBuilder other) {

        try {

            this.columnName = other.getColumnName();

            this.title = other.getTitle();

            this.width = other.getWidth();

            this.fixedWidth = other.getFixedWidth();

            this.pattern = other.getPattern();

            this.truncateSuffix = other.getTruncateSuffix();

            this.titleStyle = other.titleStyle().clone();

            if (other.getExpression() != null) { //TODO FIX PHARSE GETTERS

                this.expression = other.getExpression().clone();

                this.field = "";

                this.expressionStyle = other.expressionStyle().clone();

            } else {

                this.expression = null;

                this.field = other.getField();

                this.fieldStyle = other.fieldStyle().clone();

            }

            this.dataType = other.getDataType().clone();

            this.groupByField = other.showGroupByField();

            this.groupByOperation = other.getGroupByOperation();

        } catch (CloneNotSupportedException ex) {

            throw new RuntimeException("Can't copy ColumnBuilder", ex);

        }

    }

    @Override

    public String getColumnName() {

        return this.columnName;

    }

    @Override

    public ReportBuilder.ColumnBuilder columnName(String columnName) {

        this.columnName = columnName;

        return this;

    }

    @Override

    public String getTitle() {

        return this.title;

    }

    @Override

    public ReportBuilder.StyleBuilder titleStyle() {

        return this.titleStyle;

    }

    @Override

    public ReportBuilder.ColumnBuilder title(String title) {

        this.title = title;

        return this;

    }

    @Override

    public String getField() {

        return this.field;

    }

    @Override

    public ReportBuilder.StyleBuilder fieldStyle() {

        return this.fieldStyle;

    }

    @Override

    public ReportBuilder.ColumnBuilder field(String field) {

        this.field = field;

        return this;

    }

    @Override

    public Expression getExpression() {

        return this.expression;

    }

    @Override

    public ReportBuilder.StyleBuilder expressionStyle() {

        return this.expressionStyle;

    }

    @Override

    public ReportBuilder.ColumnBuilder expression(Expression expression) {

        this.expression = expression;

        return this;

    }

    @Override

    public DataType getDataType() {

        return this.dataType;

    }

    @Override

    public ReportBuilder.ColumnBuilder dataType(DataType dataType) {

        this.dataType = dataType;

        return this;

    }

    @Override

    public int getWidth() {

        return this.width;

    }

    @Override

    public ReportBuilder.ColumnBuilder width(int width) {

        this.width = width;

        return this;

    }

    @Override

    public boolean getFixedWidth() {

        return this.fixedWidth;

    }

    @Override

    public ReportBuilder.ColumnBuilder fixedWidth(boolean fixedWidth) {

        this.fixedWidth = fixedWidth;

        return this;

    }

    @Override

    public String getPattern() {

        return this.pattern;

    }

    @Override

    public ReportBuilder.ColumnBuilder pattern(String pattern) {

        this.pattern = pattern;

        return this;

    }

    @Override

    public String getTruncateSuffix() {

        return this.truncateSuffix;

    }

    @Override

    public ReportBuilder.ColumnBuilder truncateSuffix(String truncateSuffix) {

        this.truncateSuffix = truncateSuffix;

        return this;

    }

    @Override

    public void saveToState(PersistentState ps) throws PersistenceException {

        // TODO

    }

    @Override

    public void loadFromState(PersistentState ps) throws PersistenceException {

        // TODO

    }

    public static void registerPersistence() {

        // TODO

    }

    @Override

    public boolean showGroupByField() {

        return this.groupByField;

    }

    @Override

    public void groupByField(boolean groupByField) {

        this.groupByField = groupByField;

    }

    @Override

    public int getGroupByOperation() {

        return this.groupByOperation;

    }

    @Override

    public void groupByOperation(int groupByOperation) {

        this.groupByOperation = groupByOperation;

    }

    private static class MapSymbolTable extends AbstractSymbolTable {

        public MapSymbolTable() {

        }

        public void setVars(Map<String, Object> vars) {

            Map<String, Object> map1 = getVars();

            for (Map.Entry<String, Object> var : vars.entrySet()) {

                JRFillField value = (JRFillField) var.getValue();

                map1.put(var.getKey(), value.getValue());

            }

        }

    }

    public AbstractColumn build() {

        ar.com.fdvs.dj.domain.builders.ColumnBuilder colBuilder = ar.com.fdvs.dj.domain.builders.ColumnBuilder.getNew();

        if (this.expression == null || this.expression.isPhraseEmpty()) {

            colBuilder.setColumnProperty(

                    this.field,

                    this.dataType.getDefaultClass().getName()

            );

            if (this.fieldStyle != null) {

                colBuilder.setStyle(((DefaultStyleBuilder) this.fieldStyle).build());

            }

        } else {

            final Expression exp;

            final GvsigCustomExpression expGvsig;

            try {

                exp = this.expression.clone();

                expGvsig = new GvsigCustomExpression(exp, dataType);

            } catch (CloneNotSupportedException ex) {

                throw new RuntimeException("Can't clone expression.", ex);

            }

            colBuilder.setCustomExpression(expGvsig);

            if (this.expressionStyle != null) {

                colBuilder.setStyle(((DefaultStyleBuilder) this.expressionStyle).build());

            }

        }

        if (!StringUtils.isBlank(this.title)) {

            colBuilder.setTitle(this.title);

            if (this.titleStyle != null) {

                colBuilder.setHeaderStyle(((DefaultStyleBuilder) this.titleStyle).build());

            }

        }

        colBuilder.setWidth(this.width);

        colBuilder.setFixedWidth(this.fixedWidth);

        if (!StringUtils.isBlank(this.pattern)) {

            colBuilder.setPattern(this.pattern);

        }

        if (!StringUtils.isBlank(this.truncateSuffix)) {

            colBuilder.setTruncateSuffix(this.truncateSuffix);

        }

        AbstractColumn columnBuild = colBuilder.build();

        return columnBuild;

    }

}

package org.gvsig.report.lib.impl.reportbuilder;

import ar.com.fdvs.dj.domain.CustomExpression;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

import net.sf.jasperreports.engine.fill.JRFillField;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.impl.DefaultSymbolTable;

import org.gvsig.expressionevaluator.spi.AbstractSymbolTable;

import org.gvsig.tools.dataTypes.DataType;

/**

 *

 * @author osc

 */

public class GvsigCustomExpression implements CustomExpression {

    public final Expression expression;

    private final DataType dataType;

    GvsigCustomExpression(Expression exp, DataType dataType) {

        this.expression = exp;

        this.dataType = dataType;

    }

    @Override

    public Object evaluate(Map fields, Map variables, Map parameters) {

        DefaultSymbolTable symbolTable = (DefaultSymbolTable) this.expression.getSymbolTable();

        Map<String, Object> fieldsVars = (Map<String, Object>) fields;

        for (Map.Entry<String, Object> var : fieldsVars.entrySet()) {

            JRFillField value = (JRFillField) var.getValue();

            symbolTable.setVar(var.getKey(), value.getValue());

        }

        return expression.execute(symbolTable);

    }

    @Override

    public String getClassName() {

        return dataType.getDefaultClass().getName();

    }

}

package org.gvsig.report.lib.impl.reportbuilder;

import ar.com.fdvs.dj.domain.Style;

import ar.com.fdvs.dj.domain.constants.Font;

import ar.com.fdvs.dj.domain.constants.HorizontalAlign;

import ar.com.fdvs.dj.domain.constants.Rotation;

import ar.com.fdvs.dj.domain.constants.Stretching;

import ar.com.fdvs.dj.domain.constants.Transparency;

import ar.com.fdvs.dj.domain.constants.VerticalAlign;

import java.awt.Color;

import org.gvsig.report.lib.api.ReportBuilder;

import org.gvsig.report.lib.api.ReportBuilder.StyleBuilder;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 *

 * @author jjdelcerro

 */

public class DefaultStyleBuilder implements ReportBuilder.StyleBuilder {

    private Color textColor;

    private Color backgroundColor;

    private int rotation;

    private int stretching;

    private boolean stretchingWithOverflow;

    private boolean transparent;

    private int verticalAlign;

    private int horizontalAlign;

    private ReportBuilder.BorderBuilder borderTop;

    private ReportBuilder.BorderBuilder borderBottom;

    private ReportBuilder.BorderBuilder borderLeft;

    private ReportBuilder.BorderBuilder borderRight;

    private int paddingTop;

    private int paddingBottom;

    private int paddingLeft;

    private int paddingRight;

    private int font;

    private int fontSize;

    private int transparency;

    public DefaultStyleBuilder() {

        this.borderTop = new DefaultBorderBuilder();

        this.borderBottom = new DefaultBorderBuilder();

        this.borderLeft = new DefaultBorderBuilder();

        this.borderRight = new DefaultBorderBuilder();

        this.textColor = Color.BLACK;

        this.backgroundColor = Color.WHITE;

        this.transparency = StyleBuilder.TRANSPARENCY_OPAQUE;

        this.transparent = false;

        this.font = StyleBuilder.FONT_ARIAL;

        this.fontSize = 10;

        this.paddingBottom = 2;

        this.paddingLeft = 2;

        this.paddingRight = 2;

        this.paddingTop = 2;

        this.stretching = StyleBuilder.STRETCHING_RELATIVE_TO_TALLEST_OBJECT;

        this.stretchingWithOverflow = true;

    }

    @Override

    public ReportBuilder.StyleBuilder clone() throws CloneNotSupportedException {

        DefaultStyleBuilder other = (DefaultStyleBuilder) super.clone();

        other.borderTop = this.borderTop.clone();

        other.borderBottom = this.borderBottom.clone();

        other.borderLeft = this.borderLeft.clone();

        other.borderRight = this.borderRight.clone();

        return other;

    }

    @Override

    public void copyFrom(ReportBuilder.StyleBuilder other) {

        try {

            this.font = other.getFont();

            this.fontSize = other.getFontSize();

            this.textColor = other.getTextColor();

            this.backgroundColor = other.getBackgroundColor();

            this.rotation = other.getRotation();

            this.stretching = other.getStretching();

            this.stretchingWithOverflow = other.getStretchingWithOverflow();

            this.transparency = other.getTransparency();

            this.transparent = other.getTransparent();

            this.verticalAlign = other.getVerticalAlign();

            this.horizontalAlign = other.getHorizontalAlign();

            this.paddingTop = other.getPaddingTop();

            this.paddingBottom = other.getPaddingBottom();

            this.paddingLeft = other.getPaddingLeft();

            this.paddingRight = other.getPaddingRight();

            this.borderTop = other.getBorderTop().clone();

            this.borderBottom = other.getBorderBottom().clone();

            this.borderLeft = other.getBorderLeft().clone();

            this.borderRight = other.getBorderRight().clone();

        } catch (CloneNotSupportedException ex) {

            throw new RuntimeException("Can't copy Style", ex);

        }

    }

    @Override

    public Color getTextColor() {

        return this.textColor;

    }

    @Override

    public ReportBuilder.StyleBuilder textColor(Color textColor) {

        this.textColor = textColor;

        return this;

    }

    @Override

    public Color getBackgroundColor() {

        return this.backgroundColor;

    }

    @Override

    public ReportBuilder.StyleBuilder backgroundColor(Color backgroundColor) {

        this.backgroundColor = backgroundColor;

        return this;

    }

    @Override

    public int getRotation() {

        return this.rotation;

    }

    @Override

    public ReportBuilder.StyleBuilder rotation(int rotation) {

        this.rotation = rotation;

        return this;

    }

    @Override

    public int getStretching() {

        return this.stretching;

    }

    @Override

    public ReportBuilder.StyleBuilder stretching(int stretching) {

        this.stretching = stretching;

        return this;

    }

    @Override

    public boolean getStretchingWithOverflow() {

        return this.stretchingWithOverflow;

    }

    @Override

    public ReportBuilder.StyleBuilder stretchingWithOverflow(boolean stretchingWithOverflow) {

        this.stretchingWithOverflow = stretchingWithOverflow;

        return this;

    }

    @Override

    public boolean getTransparent() {

        return this.transparent;

    }

    @Override

    public ReportBuilder.StyleBuilder transparent(boolean transparent) {

        this.transparent = transparent;

        return this;

    }

    @Override

    public int getTransparency() {

        return this.transparency;

    }

    @Override

    public ReportBuilder.StyleBuilder transparency(int transparency) {

        this.transparency = transparency;

        return this;

    }

    @Override

    public int getVerticalAlign() {

        return this.verticalAlign;

    }

    @Override

    public ReportBuilder.StyleBuilder verticalAlign(int verticalAlign) {

        this.verticalAlign = verticalAlign;

        return this;

    }

    @Override

    public int getHorizontalAlign() {

        return this.horizontalAlign;

    }

    @Override

    public ReportBuilder.StyleBuilder horizontalAlign(int horizontalAlign) {

        this.horizontalAlign = horizontalAlign;

        return this;

    }