Application: gvSIG desktop

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

import org.gvsig.fmap.dal.feature.impl.DefaultEditableFeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.impl.DefaultFeatureAttributeDescriptor;

    @Override

    public EditableFeatureAttributeDescriptor createFeatureAttributeDescriptor() {

        DefaultEditableFeatureAttributeDescriptor edi = new DefaultEditableFeatureAttributeDescriptor(null, false);

        return edi;

    }

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

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

//    private List<FeatureAttributeDescriptor> descriptors;

    private FeatureExtraColumn extraColumn;

        this.extraColumn = new DefaultFeatureExtraColumn();

    @Override

    public FeatureExtraColumn getExtraColumn() {

        return extraColumn;

    }

    public void setExtraColumn(FeatureExtraColumn extraColumn) { //List<FeatureAttributeDescriptor> descriptors) {

          this.extraColumn = extraColumn;

    }

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.fmap.dal.feature.impl;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DALLocator;

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

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

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

/**

 *

 * @author osc

 */

public class DefaultFeatureExtraColumn implements FeatureExtraColumn {

    private List<EditableFeatureAttributeDescriptor> extraColumns;

    public DefaultFeatureExtraColumn() {

        this.extraColumns = new ArrayList();

    }

    @Override

    public EditableFeatureAttributeDescriptor get(String columnName) {

        for (EditableFeatureAttributeDescriptor extraColumn : this.extraColumns) {

            if (StringUtils.equals(extraColumn.getName(), columnName)) {

                return extraColumn;

            }

        }

        return null;

    }

    @Override

    public EditableFeatureAttributeDescriptor add(String name) {

        //TODO que no hayan dos columnas iguales

//        exi.addExtraColumn()

        EditableFeatureAttributeDescriptor newAttr = DALLocator.getDataManager().createFeatureAttributeDescriptor();

        newAttr.setName(name);

        extraColumns.add(newAttr);

        return newAttr;

    }

    @Override

    public List<EditableFeatureAttributeDescriptor> getColumns() {

        return this.extraColumns;

    }

    @Override

    public void merge(FeatureExtraColumn other) {

        this.extraColumns.addAll(other.getColumns());

    }

}

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

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

        // se mantienen

        List<EditableFeatureAttributeDescriptor> extraCols = targetFeatureType.getExtraColumn().getColumns();

        if (extraCols!=null & !extraCols.isEmpty()) {

            FeatureExtraColumn tmpExtraCols = tmpFType.getExtraColumn();

            tmpExtraCols.merge(targetFeatureType.getExtraColumn());

            ((DefaultFeatureType) tmpFType).setExtraColumn(tmpExtraCols);

        } 

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

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

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

import org.gvsig.fmap.dal.feature.impl.DefaultFeatureType;

    protected FeatureType defaultFeatureType;

            this.defaultFeatureType = this.store.getDefaultFeatureType();

            this.defaultFeatureType = this.store.getFeatureType(this.query);

            List<EditableFeatureAttributeDescriptor> cols = this.query.getExtraColumn().getColumns();

            if (this.query!=null && cols!=null && !cols.isEmpty()) {

                DefaultFeatureType featureTypeExtraCols = (DefaultFeatureType) this.defaultFeatureType.getCopy();

                featureTypeExtraCols.setExtraColumn(this.query.getExtraColumn());

                this.defaultFeatureType = featureTypeExtraCols;

            }

            this.featureTypes.add(this.defaultFeatureType);

            this.defatulFeatureTypeForProvider = this.defaultFeatureType;

            transformsToUse.getSourceFeatureTypeFrom(this.defaultFeatureType);

        return this.defaultFeatureType;

        this.defaultFeatureType = null;

        model.addElement(attr);

    // 

    //groupByPanel.setSelectedNames(query.getGroupByColumns());

    groupByPanel.setSelectedNames(query.getGroupByColumns());

import java.awt.event.ActionEvent;

import java.util.List;

import javax.swing.DefaultComboBoxModel;

import javax.swing.DefaultListModel;

import javax.swing.JList;

import javax.swing.ListModel;

import org.apache.commons.lang.StringUtils;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingLocator;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingManager;

import org.gvsig.expressionevaluator.swing.ExpressionPickerController;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.expressionevaluator.FeatureAttributeEmulatorExpression;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.swing.api.FilteredListModel;

import org.gvsig.tools.swing.api.ListElement;

import org.gvsig.tools.util.LabeledValueImpl;

    private EditableFeatureAttributeDescriptor actualEditableAttribute;

    private DefaultListModel lstAttributesModel;

    private static class ColumnController {

        private final JTextComponent txtName;

        private final JComboBox cboDataType;

        private final JButton btnDataType;

        private final JButton btnExpressionBookmarks;

        private final JButton btnExpressionHistory;

        private final JButton btnExpression;

        private final JTextComponent txtExpression;

        private ExpressionPickerController expPicker;

        private EditableFeatureAttributeDescriptor attr;

        public ColumnController(

                JTextComponent txtName,

                JComboBox cboDataType,

                JButton btnDataType,

                JTextComponent txtExpression,

                JButton btnExpression,

                JButton btnExpressionHistory,

                JButton btnExpressionBookmarks

        ) {

            this.txtName = txtName;

            this.cboDataType = cboDataType;

            this.btnDataType = btnDataType;

            this.txtExpression = txtExpression;

            this.btnExpression = btnExpression;

            this.btnExpressionHistory = btnExpressionHistory;

            this.btnExpressionBookmarks = btnExpressionBookmarks;

            this.initComponents();

            this.setEnabled(false);

        }

        public void initComponents() {

            List<DataType> dataTypes = DALLocator.getDataManager().getDataTypes();

            DefaultComboBoxModel<LabeledValueImpl<DataType>> modelColumn = new DefaultComboBoxModel<LabeledValueImpl<DataType>>();

            for (DataType dataType : dataTypes) {

                LabeledValueImpl<DataType> labeled = new LabeledValueImpl<DataType>(dataType.getName(), dataType);

                modelColumn.addElement(labeled);

            }

            this.cboDataType.setModel(modelColumn);

            ExpressionEvaluatorSwingManager managerExpSwing = ExpressionEvaluatorSwingLocator.getManager();

            this.expPicker = managerExpSwing.createExpressionPickerController(

                    txtExpression,

                    btnExpression,

                    btnExpressionBookmarks,

                    btnExpressionHistory

            );

        }

        public void setEnabled(boolean enabled) {

            this.txtName.setEnabled(enabled);

            this.expPicker.setEnabled(enabled);

            this.cboDataType.setEnabled(enabled);

        }

        public void clean() {

            this.txtName.setText("");

            this.expPicker.set(null);

            this.cboDataType.setSelectedIndex(0);

        }

        public void put(EditableFeatureAttributeDescriptor attr) {

            this.attr = attr;

            this.txtName.setName(attr.getName());

            FeatureAttributeEmulatorExpression emu = (FeatureAttributeEmulatorExpression) attr.getFeatureAttributeEmulator();

            if (emu!=null) {

                this.expPicker.set(emu.getExpression());

            }

            this.cboDataType.setSelectedItem(attr.getDataType());

        }

        public EditableFeatureAttributeDescriptor fetch(EditableFeatureAttributeDescriptor attr) {

            this.attr.setName(this.txtName.getText());

            this.attr.setFeatureAttributeEmulator(this.expPicker.get());

            LabeledValueImpl<DataType> dataTypeValue = (LabeledValueImpl<DataType>) this.cboDataType.getSelectedItem();

            this.attr.setDataType(dataTypeValue.getValue());

            return null;

        }

    private FeatureStore store;

    private FeatureType featureType;

    private FeatureQuery query;

    private ColumnController colummController;

    private JExpressionBuilder pckExpression;

    private static String COLUMN_DEFAULT_NAME = "Field";

    public DefaultFeatureQueryCalculatedColumnsPanel() {

        this.initComponents();

    @Override

    public JComponent asJComponent() {

        return this;

    @Override

    public ImageIcon loadImage(String imageName) {

        String name = FilenameUtils.getBaseName(imageName);

        IconTheme theme = ToolsSwingLocator.getIconThemeManager().getDefault();

        if (theme.exists(name)) {

            return theme.get(name);

        }

        URL url = this.getClass().getResource(name + ".png");

        if (url == null) {

            return null;

        }

        return new ImageIcon(url);

    @Override

    public void setStore(FeatureStore store) {

        try {

            this.featureType = store.getDefaultFeatureType();

            this.store = store;

            this.query = store.createFeatureQuery();

            this.pckExpression = DALSwingLocator.getManager().createQueryFilterExpresion(store);

        } catch (DataException ex) {

            throw new RuntimeException("Can't assign store", ex);

        }

    private void initComponents() {

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        this.colummController = new ColumnController(

                this.txtColumnName,

                this.cboColumnDataType,

                this.btnColumnDataType,

                this.txtColumnExpression,

                this.btnColumnExpression,

                this.btnColumnExpressionHistory,

                this.btnColumnExpressionBookmarks

        );

//        this.lstAttributes.setCellRenderer(new FeatureAttributeListCellRenderer());

        this.lstAttributes.addListSelectionListener((ListSelectionEvent e) -> {

            if (e.getValueIsAdjusting()) {

                return;

            }

      doSelectAttribute();

        });

        Dimension sz = this.getPreferredSize();

        if (sz.width < DEFAULT_WIDTH) {

            sz.width = DEFAULT_WIDTH;

        }

        if (sz.height < DEFAULT_HEIGHT) {

            sz.height = DEFAULT_HEIGHT;

        }

        this.setPreferredSize(sz);

        this.lstAttributesModel = new DefaultListModel<ListElement<EditableFeatureAttributeDescriptor>>();

//        this.lstAttributesModel = ToolsSwingLocator.getToolsSwingManager().createFilteredListModel();

        this.lstAttributes.setModel(lstAttributesModel);

        this.btnAdd.addActionListener((ActionEvent e) -> {

            doAdd();

        });

        this.btnRemove.addActionListener((ActionEvent e) -> {

            doRemove();

        });

        this.btnUp.addActionListener((ActionEvent e) -> {

            doUp(lstAttributes);

        });

        this.btnDown.addActionListener((ActionEvent e) -> {

            doDown(lstAttributes);

        });

        this.btnApplyChanges.addActionListener((ActionEvent e) -> {

            doApplyChanges();

        });

        this.btnColumnMore.addActionListener((ActionEvent e) -> {

            //

        });

    private void doSelectAttribute() {

        EditableFeatureAttributeDescriptor value = ((ListElement<EditableFeatureAttributeDescriptor>) this.lstAttributes.getSelectedValue()).getValue();

        if (value == null) {

            this.colummController.clean();

            this.colummController.setEnabled(false);

            this.actualEditableAttribute = null;

        } else {

            //EditableFeatureAttributeDescriptor value = node.getValue();

            this.actualEditableAttribute = value;

            colummController.put(value);

            colummController.setEnabled(true);

        }

    @Override

    public FeatureQuery fetch(FeatureQuery query) {

        if (query == null) {

            return this.query.getCopy();

        }

        return query;

    @Override

    public FeatureQuery fetch() {

        return this.fetch(null);

    }

    @Override

    public void put(FeatureQuery query) {

        this.query.copyFrom(query);

        addExtraColumns(this.query);

    private void addExtraColumns(FeatureQuery query) {

        List<EditableFeatureAttributeDescriptor> cols = query.getExtraColumn().getColumns();

        if (cols==null || cols.isEmpty()) {

            return;

        }

//        model = this.lstAttributes.getModel();

        for (EditableFeatureAttributeDescriptor col : cols) {

            //LabeledValueImpl<EditableFeatureAttributeDescriptor> lf = new LabeledValueImpl<EditableFeatureAttributeDescriptor>(col.getLabel(), col);

            this.lstAttributesModel.addElement(col);

        }

        if (this.lstAttributesModel.getSize() > 0) {

            this.lstAttributes.setSelectedIndex(0);

        }

    public static void selfRegister() {

        String[][] iconNames = new String[][]{

            new String[]{"dalswing", "common-applychanges"},

            new String[]{"dalswing", "common-more"},

            new String[]{"dalswing", "featurequery-column-add"},

            new String[]{"dalswing", "featurequery-column-remove"},

            new String[]{"dalswing", "featurequery-column-down"},

            new String[]{"dalswing", "featurequery-column-up"}

        };

        IconTheme theme = ToolsSwingLocator.getIconThemeManager().getCurrent();

        for (String[] icon : iconNames) {

            URL url = DefaultFeatureQueryOrderPanel.class.getResource(icon[1] + ".png");

            theme.registerDefault("DALSwing", icon[0], icon[1], null, url);

        }

    }

    private void doAdd() {

        EditableFeatureAttributeDescriptor newAttr = DALLocator.getDataManager().createFeatureAttributeDescriptor();

        newAttr.setName(COLUMN_DEFAULT_NAME);

        int id = 0;

        while (checkIfValueExistInModel(newAttr.getName(), this.lstAttributesModel)) {

            String newName = COLUMN_DEFAULT_NAME + "_" + id;

            id+=1;

            newAttr.setName(newName);

        }

        this.colummController.put(newAttr);

        this.lstAttributesModel.addElement(new ListElement(newAttr.getName(), newAttr));

    private boolean checkIfValueExistInModel(String name, ListModel<ListElement<EditableFeatureAttributeDescriptor>> model) {

        for (int i = 0; i < model.getSize(); i++) {

            EditableFeatureAttributeDescriptor element = model.getElementAt(i).getValue();

            if (StringUtils.equals(element.getLabel(), name)) {

                return true;

            }

        }

        return false;

    }

    private void doRemove() {

        throw new UnsupportedOperationException("Not supported yet.");

    private void doApplyChanges() {

        this.colummController.fetch(this.actualEditableAttribute);

    }

    private void doUp(JList lstColumns) {

        int moveMe = lstColumns.getSelectedIndex();

        if (moveMe != 0) {

            //not already at top

            swap(lstColumns, moveMe, moveMe - 1);

            lstColumns.setSelectedIndex(moveMe - 1);

            lstColumns.ensureIndexIsVisible(moveMe - 1);

        }

    }

    private void doDown(JList lstColumns) {

        int moveMe = lstColumns.getSelectedIndex();

        if (moveMe != lstColumns.getModel().getSize() - 1) {

            //not already at bottom

            swap(lstColumns, moveMe, moveMe + 1);

            lstColumns.setSelectedIndex(moveMe + 1);

            lstColumns.ensureIndexIsVisible(moveMe + 1);

        }

    }

    private void swap(JList lstColumns, int a, int b) {

        DefaultListModel model = (DefaultListModel) lstColumns.getModel();

        Object aObject = model.getElementAt(a);

        Object bObject = model.getElementAt(b);

        model.set(a, bObject);

        model.set(b, aObject);

    }

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

    public EditableFeatureAttributeDescriptor createFeatureAttributeDescriptor();

    public FeatureExtraColumn getExtraColumn();

package org.gvsig.fmap.dal.feature;

import java.util.List;

/**

 *

 * @author osc

 */

public interface FeatureExtraColumn {

public List<EditableFeatureAttributeDescriptor> getColumns();

  public EditableFeatureAttributeDescriptor get(String name);

  public EditableFeatureAttributeDescriptor add(String name);

  public void merge(FeatureExtraColumn other);

}

        process.setFeatureQuery(query);

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

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dataTypes.DataTypesManager;

    private FeatureQuery query = null;

    public void fillExportAttributes(FeatureType ftype, FeatureQuery query) {

                if (query == null || (query != null && query.getGroupByColumns().isEmpty())) {

                    exportAttribute.setExported(isShowableDataType(fad.getDataType().getType()));

                } else {

                    if (query.getAggregate(fad.getName()) != null || query.getGroupByColumns().contains(fad.getName())) {

                        exportAttribute.setExported(isShowableDataType(fad.getDataType().getType()));

                    } else {

                        exportAttribute.setExported(false);

                    }

                }

        if (query!=null && query.getExtraColumn().getColumns()!=null && !query.getExtraColumn().getColumns().isEmpty() ) {

            for (FeatureAttributeDescriptor fad : query.getExtraColumn().getColumns()) {

                DefaultExportAttribute exportAttribute = new DefaultExportAttribute(fad);

                String newName = this.getNamesTranslator().getNameSuggestion(fad.getName());

                exportAttribute.setNewName(newName);

                exportAttribute.setNewType(fad.getDataType().getType());

                exportAttribute.setSize(fad.getSize());

                exportAttribute.setExported(isShowableDataType(fad.getDataType().getType()));

                attrs.add(exportAttribute);

            }

        }

    protected boolean isShowableDataType(int dataType) {

        DataTypesManager dataTypemanager = ToolsLocator.getDataTypesManager();

        if (dataTypemanager.isContainer(dataType)

                || dataTypemanager.isObject(dataType)

                || dataType == DataTypes.ARRAY) {

            return false;

        } else {

            return true;

        }

    }

                this.fillExportAttributes(sourceFeatureType, this.query);

        if (this.query!=null && this.query.getExtraColumn().getColumns()!=null && !this.query.getExtraColumn().getColumns().isEmpty()) {

            for (EditableFeatureAttributeDescriptor attrExtra : this.query.getExtraColumn().getColumns()) {

                //FeatureAttributeDescriptor attr = targetFeatureType.getAttributeDescriptor(attrSource.getName());

                String name = attrExtra.getName();

                ExportAttribute exportAttr = this.getExportAttribute(name);

                if (!exportAttr.isExported()) {

                    //targetFeatureType.remove(name);

                    continue;

                }

                //EditableFeatureAttributeDescriptor eAttr = targetFeatureType.getEditableAttributeDescriptor(name);

//                if( eAttr.isComputed() && !exportAttr.isComputed() ) {

//                    eAttr.setFeatureAttributeEmulator((FeatureAttributeEmulator)null);

//                }

                if (this.getTargetName(name) == null && name != null && !this.getTargetName(name).equals(name)) {

                    attrExtra.setName(this.getTargetName(name));

                }

                int type = attrExtra.getDataType().getType();

                if (type != this.getTargetType(name)) {

                    attrExtra.setDataType(this.getTargetType(name));

                    attrExtra.setDefaultValue(null); // TODO: delete default value

                }

                int size = exportAttr.getSize();

                attrExtra.setSize(size);

            }        

        }

    public void setSourceFeatureType(FeatureType sourceFeatureType, FeatureQuery query) {

        this.query = query;

            this.fillExportAttributes(this.sourceFeatureType, query);

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

    private FeatureQuery featureQuery;

        this.parameters.setFeatureQuery(featureQuery);

             FeatureQuery exportFeatureQuery;

            if (this.featureQuery!=null) {

                exportFeatureQuery = this.featureQuery.getCopy();

                exportFeatureQuery.clearFilter();

                exportFeatureQuery.retrievesAllAttributes();

            } else {

                exportFeatureQuery = null;

            }

                    featureSet = this.parameters.getSourceFeatureStore().getFeatureSet(exportFeatureQuery);

                    if (exportFeatureQuery!=null) {

                        exportFeatureQuery.setFilter(this.parameters.getFeatureQuery().getExpressionFilter());

                    } else {

                        exportFeatureQuery = this.parameters.getFeatureQuery();

                    }

                    if (exportFeatureQuery!=null) {

                        exportFeatureQuery.retrievesAllAttributes();

                    }

                    featureSet = this.parameters.getSourceFeatureStore().getFeatureSet(exportFeatureQuery);

    @Override

    public void setFeatureQuery(FeatureQuery featureQuery) {

        this.featureQuery = featureQuery;

    }

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

    public void setFeatureQuery(FeatureQuery expression);

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

    public FeatureQuery getFeatureQuery();

    public void setFeatureQuery(FeatureQuery query);

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

    private FeatureQuery featureQuery;

        this.exportAttributes.setSourceFeatureType(sourceFeatureType, this.featureQuery);

            this.exportAttributes.setSourceFeatureType(sourceFeatureType, this.featureQuery);

    @Override

    public FeatureQuery getFeatureQuery() {

        return this.featureQuery;

    }

    public void setFeatureQuery(FeatureQuery query) {

        this.featureQuery = query;

    }

    @Override

        if (this.featureQuery!=null) {

            clone.setFeatureQuery(this.featureQuery.getCopy());

        }