Application: gvSIG desktop » gvSIG tools: Expression Field

#Mon Jun 06 01:58:03 CEST 2016

buildNumber=2112

<!--

    gvSIG. Desktop Geographic Information System.

    Copyright (C) 2007-2013 gvSIG Association.

    This program is free software; you can redistribute it and/or

    modify it under the terms of the GNU General Public License

    as published by the Free Software Foundation; either version 3

    of the License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

    MA  02110-1301, USA.

    For any additional information, do not hesitate to contact us

    at info AT gvsig.com, or visit our website www.gvsig.com.

-->

<assembly>

  <id>gvsig-plugin-package</id>

  <formats>

    <format>zip</format>

  </formats>

  <baseDirectory>${project.artifactId}</baseDirectory>

  <includeBaseDirectory>true</includeBaseDirectory>

  <files>

    <file>

      <source>target/${project.artifactId}-${project.version}.jar</source>

      <outputDirectory>lib</outputDirectory>

    </file>

    <file>

      <source>target/package.info</source>

    </file>

  </files>

  <fileSets>

    <fileSet>

      <directory>src/main/resources-plugin</directory>

      <outputDirectory>.</outputDirectory>

    </fileSet>

  </fileSets>

  <dependencySets>

    <dependencySet>

      <useProjectArtifact>false</useProjectArtifact>

      <useTransitiveDependencies>false</useTransitiveDependencies>

      <outputDirectory>lib</outputDirectory>

      <includes>

        <include>bsf:bsf</include>

        <include>org.python:jython</include>

        <include>com.fifesoft:rsyntaxtextarea</include>

      </includes>

    </dependencySet>

  </dependencySets>

</assembly>

/*******************************************************************************

 *

 *   gvSIG. Desktop Geographic Information System.

 *  

 *   Copyright (C) 2007-2013 gvSIG Association.

 *  

 *   This program is free software; you can redistribute it and/or

 *   modify it under the terms of the GNU General Public License

 *   as published by the Free Software Foundation; either version 3

 *   of the License, or (at your option) any later version.

 *  

 *   This program is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU General Public License for more details.

 *  

 *   You should have received a copy of the GNU General Public License

 *   along with this program; if not, write to the Free Software

 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 *   MA  02110-1301, USA.

 *  

 *   For any additional information, do not hesitate to contact us

 *   at info AT gvsig.com, or visit our website www.gvsig.com.

 *   

 *******************************************************************************/

package org.gvsig.expressionfield;

import org.gvsig.about.AboutManager;

import org.gvsig.about.AboutParticipant;

import org.gvsig.andami.plugins.Extension;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

/**

 * About extension.

 *

 * Add the about coments to the gvSIG About panel

 */

public class AboutExpressionFieldExtension extends Extension {

	public void initialize() {

		// TODO Auto-generated method stub

	}

	public void postInitialize() {

		ApplicationManager application = ApplicationLocator.getManager();

		AboutManager about = application.getAbout();

		about.addDeveloper(

				"IVER",

				this.getClass().getClassLoader().getResource("iver.html"),

				1

		);

		AboutParticipant participant = about.getDeveloper("IVER");

		participant.addContribution(

			"Expression field",

			"Extesi?n para el c?lculo de una expresi?n sobre una columna de la tabla.", 

			2007,1,1, 

			2007,12,31

		);

	}

	public void execute(String actionCommand) {

	}

	public boolean isEnabled() {

		return false;

	}

	public boolean isVisible() {

		return false;

	}

}

/**

 * *****************************************************************************

 *

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA 02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 *

 ******************************************************************************

 */

package org.gvsig.expressionfield;

import java.awt.Component;

import java.util.ArrayList;

import java.util.Iterator;

import javax.swing.JOptionPane;

import org.apache.bsf.BSFManager;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.andami.plugins.Extension;

import org.gvsig.app.project.documents.table.gui.FeatureTableDocumentPanel;

import org.gvsig.expressionfield.gui.FieldExpressionPage;

import org.gvsig.expressionfield.project.documents.table.IOperator;

import org.gvsig.expressionfield.project.documents.table.gui.EvalExpressionDialog;

import org.gvsig.expressionfield.project.documents.table.operators.Abs;

import org.gvsig.expressionfield.project.documents.table.operators.Acos;

import org.gvsig.expressionfield.project.documents.table.operators.After;

import org.gvsig.expressionfield.project.documents.table.operators.Area;

import org.gvsig.expressionfield.project.documents.table.operators.Asin;

import org.gvsig.expressionfield.project.documents.table.operators.Atan;

import org.gvsig.expressionfield.project.documents.table.operators.Before;

import org.gvsig.expressionfield.project.documents.table.operators.Ceil;

import org.gvsig.expressionfield.project.documents.table.operators.Cos;

import org.gvsig.expressionfield.project.documents.table.operators.DateToString;

import org.gvsig.expressionfield.project.documents.table.operators.Distinct;

import org.gvsig.expressionfield.project.documents.table.operators.Division;

import org.gvsig.expressionfield.project.documents.table.operators.E;

import org.gvsig.expressionfield.project.documents.table.operators.EndsWith;

import org.gvsig.expressionfield.project.documents.table.operators.Equal;

import org.gvsig.expressionfield.project.documents.table.operators.Equals;

import org.gvsig.expressionfield.project.documents.table.operators.Exp;

import org.gvsig.expressionfield.project.documents.table.operators.Floor;

import org.gvsig.expressionfield.project.documents.table.operators.Geometry;

import org.gvsig.expressionfield.project.documents.table.operators.GetTimeDate;

import org.gvsig.expressionfield.project.documents.table.operators.IndexOf;

import org.gvsig.expressionfield.project.documents.table.operators.IsNumber;

import org.gvsig.expressionfield.project.documents.table.operators.LastIndexOf;

import org.gvsig.expressionfield.project.documents.table.operators.Length;

import org.gvsig.expressionfield.project.documents.table.operators.LessEquals;

import org.gvsig.expressionfield.project.documents.table.operators.LessThan;

import org.gvsig.expressionfield.project.documents.table.operators.Log;

import org.gvsig.expressionfield.project.documents.table.operators.Max;

import org.gvsig.expressionfield.project.documents.table.operators.Min;

import org.gvsig.expressionfield.project.documents.table.operators.Minus;

import org.gvsig.expressionfield.project.documents.table.operators.MoreEquals;

import org.gvsig.expressionfield.project.documents.table.operators.MoreThan;

import org.gvsig.expressionfield.project.documents.table.operators.Perimeter;

import org.gvsig.expressionfield.project.documents.table.operators.Pi;

import org.gvsig.expressionfield.project.documents.table.operators.Plus;

import org.gvsig.expressionfield.project.documents.table.operators.PointX;

import org.gvsig.expressionfield.project.documents.table.operators.PointY;

import org.gvsig.expressionfield.project.documents.table.operators.Pow;

import org.gvsig.expressionfield.project.documents.table.operators.Random;

import org.gvsig.expressionfield.project.documents.table.operators.RecordIndex;

import org.gvsig.expressionfield.project.documents.table.operators.Replace;

import org.gvsig.expressionfield.project.documents.table.operators.Round;

import org.gvsig.expressionfield.project.documents.table.operators.SetTimeDate;

import org.gvsig.expressionfield.project.documents.table.operators.Sin;

import org.gvsig.expressionfield.project.documents.table.operators.Sqrt;

import org.gvsig.expressionfield.project.documents.table.operators.StartsWith;

import org.gvsig.expressionfield.project.documents.table.operators.SubString;

import org.gvsig.expressionfield.project.documents.table.operators.Tan;

import org.gvsig.expressionfield.project.documents.table.operators.Times;

import org.gvsig.expressionfield.project.documents.table.operators.ToDate;

import org.gvsig.expressionfield.project.documents.table.operators.ToDegrees;

import org.gvsig.expressionfield.project.documents.table.operators.ToLowerCase;

import org.gvsig.expressionfield.project.documents.table.operators.ToNumber;

import org.gvsig.expressionfield.project.documents.table.operators.ToRadians;

import org.gvsig.expressionfield.project.documents.table.operators.ToString;

import org.gvsig.expressionfield.project.documents.table.operators.ToUpperCase;

import org.gvsig.expressionfield.project.documents.table.operators.Trim;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

import org.gvsig.utils.swing.threads.AbstractMonitorableTask;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author Vicente Caballero Navarro

 */

public class ExpressionFieldExtension extends Extension {

    private static Logger logger = LoggerFactory.getLogger(ExpressionFieldExtension.class);

    public static final String JYTHON = "jython";

    private static BSFManager interpreter = new BSFManager();

    private FeatureTableDocumentPanel table = null;

    private static ArrayList<IOperator> operators = new ArrayList<IOperator>();

    public void initialize() {

        registerIcons();

        registerOperations();

    }

    public void execute(String actionCommand) {

        if ( "table-expression-field".equalsIgnoreCase(actionCommand) ) {

            org.gvsig.andami.ui.mdiManager.IWindow window = PluginServices.getMDIManager().getActiveWindow();

            table = (FeatureTableDocumentPanel) window;

            if ( !table.getModel().getStore().isEditing() ) {

                int option = JOptionPane.showConfirmDialog((Component) PluginServices.getMainFrame(), PluginServices.getText(this, "is_not_in_editing_are_you_sure"));

                if ( option != JOptionPane.OK_OPTION ) {

                    return;

                }

            }

            if ( operators.isEmpty() ) {

                PluginServices.cancelableBackgroundExecution(new EvalOperatorsTask());

            } else {

                EvalExpressionDialog eed = new EvalExpressionDialog(table, interpreter, operators);

                PluginServices.getMDIManager().addWindow(eed);

            }

        }

    }

    public void postInitialize() {

    }

    public boolean isEnabled() {

        org.gvsig.andami.ui.mdiManager.IWindow window = PluginServices.getMDIManager().getActiveWindow();

        if ( window instanceof FeatureTableDocumentPanel ) {

            FeatureTableDocumentPanel table = (FeatureTableDocumentPanel) window;

            int columnSelected = 0;

            try {

                columnSelected = table.getTablePanel().getTable().getSelectedColumnCount();

            } catch (DataException e) {

                logger.error("Can't get selected column in table.", e);

            }

            if ( columnSelected > 0 && table.getModel().getStore().isEditing() ) {

                return true;

            }

        }

        return false;

    }

    public boolean isVisible() {

        org.gvsig.andami.ui.mdiManager.IWindow window = PluginServices.getMDIManager().getActiveWindow();

        if ( window instanceof FeatureTableDocumentPanel ) {

            return true;

        }

        return false;

    }

    private void registerOperations() {

        ExtensionPointManager extensionPointsManager =ToolsLocator.getExtensionPointManager();

        ExtensionPoint ep = extensionPointsManager.add("AplicationPreferences", "");

        ep.append("fieldExpression", "", new FieldExpressionPage());

        ExtensionPoint extensionPoints = ToolsLocator.getExtensionPointManager().add(

                "ColumnOperators", "");

        extensionPoints.append(Abs.class.toString(), "", Abs.class);

        extensionPoints.append(Acos.class.toString(), "", Acos.class);

        extensionPoints.append(After.class.toString(), "", After.class);

        extensionPoints.append(Area.class.toString(), "", Area.class);

        extensionPoints.append(Asin.class.toString(), "", Asin.class);

        extensionPoints.append(Atan.class.toString(), "", Atan.class);

        extensionPoints.append(Acos.class.toString(), "", Acos.class);

        extensionPoints.append(Before.class.toString(), "", Before.class);

        extensionPoints.append(Ceil.class.toString(), "", Ceil.class);

        extensionPoints.append(Cos.class.toString(), "", Cos.class);

        extensionPoints.append(DateToString.class.toString(), "", DateToString.class);

        extensionPoints.append(Distinct.class.toString(), "", Distinct.class);

        extensionPoints.append(Division.class.toString(), "", Division.class);

        extensionPoints.append(E.class.toString(), "", E.class);

        extensionPoints.append(EndsWith.class.toString(), "", EndsWith.class);

        extensionPoints.append(Equal.class.toString(), "", Equal.class);

        extensionPoints.append(Equals.class.toString(), "", Equals.class);

        extensionPoints.append(Exp.class.toString(), "", Exp.class);

        extensionPoints.append(Floor.class.toString(), "", Floor.class);

        extensionPoints.append(Geometry.class.toString(), "", Geometry.class);

        extensionPoints.append(GetTimeDate.class.toString(), "", GetTimeDate.class);

        extensionPoints.append(IndexOf.class.toString(), "", IndexOf.class);

        extensionPoints.append(IsNumber.class.toString(), "", IsNumber.class);

        extensionPoints.append(LastIndexOf.class.toString(), "", LastIndexOf.class);

        extensionPoints.append(Length.class.toString(), "", Length.class);

        extensionPoints.append(LessEquals.class.toString(), "", LessEquals.class);

        extensionPoints.append(LessThan.class.toString(), "", LessThan.class);

        extensionPoints.append(Log.class.toString(), "", Log.class);

        extensionPoints.append(Max.class.toString(), "", Max.class);

        extensionPoints.append(Min.class.toString(), "", Min.class);

        extensionPoints.append(Minus.class.toString(), "", Minus.class);

        extensionPoints.append(MoreEquals.class.toString(), "", MoreEquals.class);

        extensionPoints.append(MoreThan.class.toString(), "", MoreThan.class);

        extensionPoints.append(Perimeter.class.toString(), "", Perimeter.class);

        extensionPoints.append(Pi.class.toString(), "", Pi.class);

        extensionPoints.append(Plus.class.toString(), "", Plus.class);

        extensionPoints.append(PointX.class.toString(), "", PointX.class);

        extensionPoints.append(PointY.class.toString(), "", PointY.class);

        extensionPoints.append(Pow.class.toString(), "", Pow.class);

        extensionPoints.append(Random.class.toString(), "", Random.class);

        // Added November 2013

        extensionPoints.append(RecordIndex.class.toString(), "", RecordIndex.class);

        extensionPoints.append(Replace.class.toString(), "", Replace.class);

        extensionPoints.append(Round.class.toString(), "", Round.class);

        extensionPoints.append(SetTimeDate.class.toString(), "", SetTimeDate.class);

        extensionPoints.append(Sin.class.toString(), "", Sin.class);

        extensionPoints.append(Sqrt.class.toString(), "", Sqrt.class);

        extensionPoints.append(StartsWith.class.toString(), "", StartsWith.class);

        extensionPoints.append(SubString.class.toString(), "", SubString.class);

        extensionPoints.append(Tan.class.toString(), "", Tan.class);

        extensionPoints.append(Times.class.toString(), "", Times.class);

        extensionPoints.append(ToDate.class.toString(), "", ToDate.class);

        extensionPoints.append(ToDegrees.class.toString(), "", ToDegrees.class);

        extensionPoints.append(ToLowerCase.class.toString(), "", ToLowerCase.class);

        extensionPoints.append(ToNumber.class.toString(), "", ToNumber.class);

        extensionPoints.append(ToRadians.class.toString(), "", ToRadians.class);

        extensionPoints.append(ToString.class.toString(), "", ToString.class);

        extensionPoints.append(ToUpperCase.class.toString(), "", ToUpperCase.class);

        extensionPoints.append(Trim.class.toString(), "", Trim.class);

    }

    private void registerIcons() {

        IconThemeHelper.registerIcon("action", "table-expression-field", this);

        IconThemeHelper.registerIcon("preferences", "expression-field-preferences", this);

    }

    private class EvalOperatorsTask extends AbstractMonitorableTask {

        private ExtensionPoint extensionPoint;

        public EvalOperatorsTask() {

            setInitialStep(0);

            setDeterminatedProcess(true);

            setStatusMessage(PluginServices.getText(this, "charging_operators") + "...");

            this.extensionPoint = ToolsLocator.getExtensionPointManager().get(

                    "ColumnOperators");

            setFinalStep(extensionPoint.getCount() + 1);

        }

        public void run() throws Exception {

            NotificationManager.addInfo(PluginServices.getText(this, "charging_operators"));

            long t1 = System.currentTimeMillis();

            Iterator iterator = extensionPoint.iterator();

            while ( iterator.hasNext() ) {

                try {

                    if ( isCanceled() ) {

                        return;

                    }

                    org.gvsig.tools.extensionpoint.ExtensionPoint.Extension obj = (org.gvsig.tools.extensionpoint.ExtensionPoint.Extension) iterator.next();

                    IOperator operator = (IOperator) extensionPoint.create(obj.getName());

                    operator.eval(interpreter);

                    operators.add(operator);

                    reportStep();

                    setNote(operator.getClass().getName());

                } catch (InstantiationException e) {

                    e.printStackTrace();

                } catch (IllegalAccessException e) {

                    e.printStackTrace();

                } catch (ClassCastException e) {

                    e.printStackTrace();

                }

            }

            long t2 = System.currentTimeMillis();

            System.out.println("Tiempo en evaluar y crear del extension point = " + (t2 - t1));

            long t3 = System.currentTimeMillis();

            System.out.println("Tiempo en a?adir los operadores correctos = " + (t3 - t2));

            reportStep();

        }

        public void finished() {

            if ( isCanceled() ) {

                return;

            }

            NotificationManager.addInfo(PluginServices.getText(this, "charged_operators"));

            EvalExpressionDialog eed = new EvalExpressionDialog(table, interpreter, operators);

            PluginServices.getMDIManager().addWindow(eed);

        }

    }

}

/*******************************************************************************

 *

 *   gvSIG. Desktop Geographic Information System.

 *  

 *   Copyright (C) 2007-2013 gvSIG Association.

 *  

 *   This program is free software; you can redistribute it and/or

 *   modify it under the terms of the GNU General Public License

 *   as published by the Free Software Foundation; either version 3

 *   of the License, or (at your option) any later version.

 *  

 *   This program is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU General Public License for more details.

 *  

 *   You should have received a copy of the GNU General Public License

 *   along with this program; if not, write to the Free Software

 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 *   MA  02110-1301, USA.

 *  

 *   For any additional information, do not hesitate to contact us

 *   at info AT gvsig.com, or visit our website www.gvsig.com.

 *   

 *******************************************************************************/

package org.gvsig.expressionfield.gui;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.util.prefs.Preferences;

import javax.swing.ImageIcon;

import javax.swing.JCheckBox;

import javax.swing.JPanel;

import javax.swing.JTextArea;

import javax.swing.JTextField;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.preferences.AbstractPreferencePage;

import org.gvsig.andami.preferences.StoreException;

/**

 * @author Vicente Caballero Navarro

 */

public class FieldExpressionPage extends AbstractPreferencePage {

	private static Preferences prefs = Preferences.userRoot().node( "fieldExpressionOptions" );

	private JTextArea jTextArea = null;

	private JTextField txtLimit;

	private JCheckBox ckLimit=null;

	private ImageIcon icon;

	public FieldExpressionPage() {

		super();

		icon = IconThemeHelper.getImageIcon("expression-field-preferences");

		addComponent(getJTextArea());

		addComponent(PluginServices.getText(this, "limit_rows_in_memory") + ":",

			txtLimit = new JTextField("", 15));

		addComponent(ckLimit = new JCheckBox(PluginServices.getText(this, "without_limit")));

		ckLimit.addMouseListener(new MouseListener() {

			public void mouseClicked(MouseEvent e) {

				if (ckLimit.isSelected()) {

					txtLimit.setText(PluginServices.getText(this, "without_limit"));

				}else {

					if (txtLimit.getText().equals(PluginServices.getText(this, "without_limit")))

					txtLimit.setText("500000");

				}

			}

			public void mouseEntered(MouseEvent e) {

			}

			public void mouseExited(MouseEvent e) {

			}

			public void mousePressed(MouseEvent e) {

			}

			public void mouseReleased(MouseEvent e) {

			}

		});

	}

	public void initializeValues() {

		int limit = prefs.getInt("limit_rows_in_memory",-1);

		if (limit==-1) {

			ckLimit.setSelected(true);

			txtLimit.setText(PluginServices.getText(this,"without_limit"));

		}else {

			ckLimit.setSelected(false);

			txtLimit.setText(String.valueOf(limit));

		}

	}

	public String getID() {

		return this.getClass().getName();

	}

	public String getTitle() {

		return PluginServices.getText(this, "limit_rows_in_memory");

	}

	public JPanel getPanel() {

		return this;

	}

	public void storeValues() throws StoreException {

		int limit;

		try{

			if (ckLimit.isSelected()) {

				limit=-1;

			}else {

//			if (txtLimit.getText().equals(PluginServices.getText(this,"without_limit"))) {

//				limit=-1;

//			}else {

				limit=Integer.parseInt(txtLimit.getText());

			}

		}catch (Exception e) {

			throw new StoreException(PluginServices.getText(this,"limit_rows_in_memory")+PluginServices.getText(this,"error"));

		}

		prefs.putInt("limit_rows_in_memory", limit);

	}

	public void initializeDefaults() {

		int limit=prefs.getInt("limit_rows_in_memory",-1);

		if (limit==-1) {

			ckLimit.setSelected(true);

			txtLimit.setText(PluginServices.getText(this,"without_limit"));

		}else {

			ckLimit.setSelected(false);

			txtLimit.setText(String.valueOf(limit));

		}

	}

	public ImageIcon getIcon() {

		return icon;

	}

	/**

	 * This method initializes jTextArea

	 *

	 * @return javax.swing.JTextArea

	 */

	private JTextArea getJTextArea() {

		if (jTextArea == null) {

			jTextArea = new JTextArea();

			jTextArea.setBounds(new java.awt.Rectangle(13,7,285,57));

			jTextArea.setForeground(java.awt.Color.black);

			jTextArea.setBackground(java.awt.SystemColor.control);

			jTextArea.setRows(3);

			jTextArea.setWrapStyleWord(true);

			jTextArea.setLineWrap(true);

			jTextArea.setEditable(false);

			jTextArea.setText(PluginServices.getText(this,"specifies_the_limit_rows_in_memory_when_the_program_eval_the_expression"));

		}

		return jTextArea;

	}

	public boolean isValueChanged() {

		return super.hasChanged();

	}

	public void setChangesApplied() {

		setChanged(false);

	}

}

/*******************************************************************************

 *

 *   gvSIG. Desktop Geographic Information System.

 *  

 *   Copyright (C) 2007-2013 gvSIG Association.

 *  

 *   This program is free software; you can redistribute it and/or

 *   modify it under the terms of the GNU General Public License

 *   as published by the Free Software Foundation; either version 3

 *   of the License, or (at your option) any later version.

 *  

 *   This program is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU General Public License for more details.

 *  

 *   You should have received a copy of the GNU General Public License

 *   along with this program; if not, write to the Free Software

 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 *   MA  02110-1301, USA.

 *  

 *   For any additional information, do not hesitate to contact us

 *   at info AT gvsig.com, or visit our website www.gvsig.com.

 *   

 *******************************************************************************/

package org.gvsig.expressionfield.project.documents.table;

/**

 * Utility class to use in Jython bean

 * 

 * @author jldominguez

 * 

 */

public class FeatureIndex {

	private long index = -1;

	public void next() {

		index++;

	}

	public void previous() {

		index--;

	}

	public long get() {

		return index;

	}

	public void set(long i) {

		index = i;

	}

}

/*******************************************************************************

 *

 *   gvSIG. Desktop Geographic Information System.

 *  

 *   Copyright (C) 2007-2013 gvSIG Association.

 *  

 *   This program is free software; you can redistribute it and/or

 *   modify it under the terms of the GNU General Public License

 *   as published by the Free Software Foundation; either version 3

 *   of the License, or (at your option) any later version.

 *  

 *   This program is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU General Public License for more details.

 *  

 *   You should have received a copy of the GNU General Public License

 *   along with this program; if not, write to the Free Software

 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 *   MA  02110-1301, USA.

 *  

 *   For any additional information, do not hesitate to contact us

 *   at info AT gvsig.com, or visit our website www.gvsig.com.

 *   

 *******************************************************************************/

package org.gvsig.expressionfield.project.documents.table;

import org.apache.bsf.BSFException;

import org.apache.bsf.BSFManager;

/**

 * @author Vicente Caballero Navarro

 */

public interface IOperator {

	int NUMBER = 0;

	int STRING = 1;

	int DATE = 2;

	public String addText(String s);

	public String toString();

	public void eval(BSFManager interpreter) throws BSFException ;

	public boolean isEnable();

	public void setType(int fieldType);

	public String getTooltip();

}

/*******************************************************************************

 *

 *   gvSIG. Desktop Geographic Information System.

 *  

 *   Copyright (C) 2007-2013 gvSIG Association.

 *  

 *   This program is free software; you can redistribute it and/or

 *   modify it under the terms of the GNU General Public License

 *   as published by the Free Software Foundation; either version 3

 *   of the License, or (at your option) any later version.

 *  

 *   This program is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU General Public License for more details.

 *  

 *   You should have received a copy of the GNU General Public License

 *   along with this program; if not, write to the Free Software

 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 *   MA  02110-1301, USA.

 *  

 *   For any additional information, do not hesitate to contact us

 *   at info AT gvsig.com, or visit our website www.gvsig.com.

 *   

 *******************************************************************************/

package org.gvsig.expressionfield.project.documents.table.gui;

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

public class FeatureContainer {

private Feature feature = null;

public Feature getFeature() {

	return feature;

}

public void setFeature(Feature feature) {

	this.feature = feature;

}

public boolean containsFeature() {

	return feature!=null;

}

}

package org.gvsig.expressionfield.project.documents.table.gui.syntaxhighlight;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.KeyListener;

import javax.swing.JScrollPane;

import javax.swing.event.CaretEvent;

import javax.swing.event.CaretListener;

import javax.swing.text.JTextComponent;

import org.fife.ui.rsyntaxtextarea.RSyntaxTextArea;

import org.fife.ui.rsyntaxtextarea.SyntaxConstants;

import org.fife.ui.rtextarea.RTextScrollPane;

public class JRSyntaxTextArea implements SyntaxtHighlightTextComponent {

	public class DefaultUpdateCaretPositionActionEvent extends ActionEvent implements UpdateCaretPositionActionEvent {

		/**

		 * 

		 */

		private static final long serialVersionUID = 8238486105726094074L;

		int line = -1;

		int column = -1;

		public DefaultUpdateCaretPositionActionEvent(Object source, int id,

				String command, int line, int column) {

			super(source, id, command);

			this.line = line;

			this.column = column;

		}

		public int getLine() {

			return this.line+1;

		}

		public int getColumn() {

			return this.column;

		}

		public boolean hasLineAndColumn() {

			return this.line >=0 && this.column >= 0;

		}

	}

	protected ActionListener updateCaretPosition = null;

	protected RSyntaxTextArea textArea = null;

	public JRSyntaxTextArea() {

		this.textArea = new RSyntaxTextArea(20, 60);

		this.init();

	}

	protected void init() {

		textArea.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_PYTHON);

		textArea.setCodeFoldingEnabled(true);

		textArea.setClearWhitespaceLinesEnabled(true);

		textArea.setAutoIndentEnabled(true);

		textArea.setCloseCurlyBraces(true);

		textArea.setWhitespaceVisible(true);

		textArea.setAnimateBracketMatching(true);

		textArea.setBracketMatchingEnabled(true);

		textArea.setAutoIndentEnabled(true);

		textArea.setTabsEmulated(true);

		textArea.setTabSize(2);

		textArea.setAntiAliasingEnabled(true);

		textArea.addCaretListener(new CaretListener() {

			public void caretUpdate(CaretEvent e) {

				if( updateCaretPosition== null ) {

					return;

				}

				updateCaretPosition.actionPerformed(

						new DefaultUpdateCaretPositionActionEvent(textArea, 1, "position", textArea.getCaretLineNumber(), textArea.getCaretOffsetFromLineStart() ) 

				);

			}

		});

	}

	public void setContentType(String contentType) {

		this.textArea.setSyntaxEditingStyle(contentType);

	}

	public JScrollPane getJScrollPane() {

		return  new RTextScrollPane(this.textArea);

	}

	public JTextComponent getJTextComponent() {

		return this.textArea;

	}

	public String getContentType() {

		return this.textArea.getSyntaxEditingStyle();

	}

	public void addUpdateCaretPositionActionListener(ActionListener updateCaretPosition) {

		this.updateCaretPosition = updateCaretPosition;  

	}

	public void setText(String text) {

		this.textArea.setText(text);

	}

	public String getText() {

		return this.textArea.getText();

	}

	public void addKeyListener(KeyListener keyListener) {

		this.textArea.addKeyListener(keyListener);

	}

}

package org.gvsig.expressionfield.project.documents.table.gui.syntaxhighlight.styles;

import java.awt.Color;

import java.util.HashSet;

import java.util.Set;

import javax.swing.text.AttributeSet;

import javax.swing.text.BadLocationException;

import javax.swing.text.DefaultEditorKit;

import javax.swing.text.DefaultStyledDocument;

import javax.swing.text.Element;

import javax.swing.text.MutableAttributeSet;

import javax.swing.text.SimpleAttributeSet;

import javax.swing.text.StyleConstants;

public class JavaStyledDocument extends DefaultStyledDocument {

	/**

	 * 

	 */

	private static final long serialVersionUID = 2859530660266127826L;

	private final DefaultStyledDocument doc;

	private final Element rootElement;

	private boolean multiLineComment;

	private final MutableAttributeSet normal;

	private final MutableAttributeSet keyword;

	private final MutableAttributeSet comment;

	private final MutableAttributeSet quote;

    private final Set<String> keywords;

	public JavaStyledDocument()

	{

		doc = this;

		rootElement = doc.getDefaultRootElement();

		putProperty( DefaultEditorKit.EndOfLineStringProperty, "\n" );

		normal = new SimpleAttributeSet();

		StyleConstants.setForeground(normal, Color.black);

		comment = new SimpleAttributeSet();

		StyleConstants.setForeground(comment, Color.gray);

		StyleConstants.setItalic(comment, true);

		keyword = new SimpleAttributeSet();

		StyleConstants.setForeground(keyword, Color.blue);

		quote = new SimpleAttributeSet();

		StyleConstants.setForeground(quote, Color.red);

        keywords = new HashSet<String>();

		keywords.add( "abstract" );

		keywords.add( "boolean" );

		keywords.add( "break" );

		keywords.add( "byte" );

		keywords.add( "byvalue" );

		keywords.add( "case" );

		keywords.add( "cast" );

		keywords.add( "catch" );

		keywords.add( "char" );

		keywords.add( "class" );

		keywords.add( "const" );

		keywords.add( "continue" );

		keywords.add( "default" );

		keywords.add( "do" );

		keywords.add( "double" );

		keywords.add( "else" );

		keywords.add( "extends" );

		keywords.add( "false" );

		keywords.add( "final" );

		keywords.add( "finally" );

		keywords.add( "float" );

		keywords.add( "for" );

		keywords.add( "future" );

		keywords.add( "generic" );

		keywords.add( "goto" );

		keywords.add( "if" );

		keywords.add( "implements" );

		keywords.add( "import" );

		keywords.add( "inner" );

		keywords.add( "instanceof" );

		keywords.add( "int" );

		keywords.add( "interface" );

		keywords.add( "long" );

		keywords.add( "native" );

		keywords.add( "new" );

		keywords.add( "null" );

		keywords.add( "operator" );

		keywords.add( "outer" );

		keywords.add( "package" );

		keywords.add( "private" );

		keywords.add( "protected" );

		keywords.add( "public" );

		keywords.add( "rest" );

		keywords.add( "return" );

		keywords.add( "short" );

		keywords.add( "static" );

		keywords.add( "super" );

		keywords.add( "switch" );

		keywords.add( "synchronized" );

		keywords.add( "this" );

		keywords.add( "throw" );

		keywords.add( "throws" );

		keywords.add( "transient" );

		keywords.add( "true" );

		keywords.add( "try" );

		keywords.add( "var" );

		keywords.add( "void" );

		keywords.add( "volatile" );

		keywords.add( "while" );

	}

	/*

	 *  Override to apply syntax highlighting after the document has been updated

	 */

	@Override

    public void insertString(int offset, String str, AttributeSet a) throws BadLocationException

	{

		if (str.equals("{"))

			str = addMatchingBrace(offset);

		super.insertString(offset, str, a);

		processChangedLines(offset, str.length());

	}

	/*

	 *  Override to apply syntax highlighting after the document has been updated

	 */

	@Override

    public void remove(int offset, int length) throws BadLocationException

	{

		super.remove(offset, length);

		processChangedLines(offset, 0);

	}

	/*

	 *  Determine how many lines have been changed,

	 *  then apply highlighting to each line

	 */

	public void processChangedLines(int offset, int length)

		throws BadLocationException

	{

		String content = doc.getText(0, doc.getLength());

		//  The lines affected by the latest document update

		int startLine = rootElement.getElementIndex( offset );

		int endLine = rootElement.getElementIndex( offset + length );

		//  Make sure all comment lines prior to the start line are commented

		//  and determine if the start line is still in a multi line comment

		setMultiLineComment( commentLinesBefore( content, startLine ) );

		//  Do the actual highlighting

		for (int i = startLine; i <= endLine; i++)

		{

			applyHighlighting(content, i);

		}

		//  Resolve highlighting to the next end multi line delimiter

		if (isMultiLineComment())

			commentLinesAfter(content, endLine);

		else

			highlightLinesAfter(content, endLine);

	}

	/*

	 *  Highlight lines when a multi line comment is still 'open'

	 *  (ie. matching end delimiter has not yet been encountered)

	 */

	private boolean commentLinesBefore(String content, int line)

	{

		int offset = rootElement.getElement( line ).getStartOffset();

		//  Start of comment not found, nothing to do

		int startDelimiter = lastIndexOf( content, getStartDelimiter(), offset - 2 );

		if (startDelimiter < 0)

			return false;

		//  Matching start/end of comment found, nothing to do

		int endDelimiter = indexOf( content, getEndDelimiter(), startDelimiter );

		if (endDelimiter < offset & endDelimiter != -1)

			return false;

		//  End of comment not found, highlight the lines

		doc.setCharacterAttributes(startDelimiter, offset - startDelimiter + 1, comment, false);

		return true;

	}

	/*

	 *  Highlight comment lines to matching end delimiter

	 */

	private void commentLinesAfter(String content, int line)

	{

		int offset = rootElement.getElement( line ).getEndOffset();

		//  End of comment not found, nothing to do

		int endDelimiter = indexOf( content, getEndDelimiter(), offset );

		if (endDelimiter < 0)

			return;

		//  Matching start/end of comment found, comment the lines

		int startDelimiter = lastIndexOf( content, getStartDelimiter(), endDelimiter );

		if (startDelimiter < 0 || startDelimiter <= offset)

		{

			doc.setCharacterAttributes(offset, endDelimiter - offset + 1, comment, false);

		}

	}

	/*

	 *  Highlight lines to start or end delimiter

	 */

	private void highlightLinesAfter(String content, int line)

		throws BadLocationException

	{

		int offset = rootElement.getElement( line ).getEndOffset();

		//  Start/End delimiter not found, nothing to do

		int startDelimiter = indexOf( content, getStartDelimiter(), offset );

		int endDelimiter = indexOf( content, getEndDelimiter(), offset );

		if (startDelimiter < 0)

			startDelimiter = content.length();

		if (endDelimiter < 0)

			endDelimiter = content.length();

		int delimiter = Math.min(startDelimiter, endDelimiter);

		if (delimiter < offset)

			return;

		//	Start/End delimiter found, reapply highlighting

		int endLine = rootElement.getElementIndex( delimiter );

		for (int i = line + 1; i < endLine; i++)

		{

			Element branch = rootElement.getElement( i );

			Element leaf = doc.getCharacterElement( branch.getStartOffset() );

			AttributeSet as = leaf.getAttributes();

			if ( as.isEqual(comment) )

				applyHighlighting(content, i);

		}

	}

	/*

	 *  Parse the line to determine the appropriate highlighting

	 */

	private void applyHighlighting(String content, int line)

		throws BadLocationException

	{

		int startOffset = rootElement.getElement( line ).getStartOffset();

		int endOffset = rootElement.getElement( line ).getEndOffset() - 1;

		int lineLength = endOffset - startOffset;

		int contentLength = content.length();

		if (endOffset >= contentLength)

			endOffset = contentLength - 1;

		//  check for multi line comments

		//  (always set the comment attribute for the entire line)

		if (endingMultiLineComment(content, startOffset, endOffset)

		||  isMultiLineComment()

		||  startingMultiLineComment(content, startOffset, endOffset) )

		{

			doc.setCharacterAttributes(startOffset, endOffset - startOffset + 1, comment, false);

			return;

		}

		//  set normal attributes for the line

		doc.setCharacterAttributes(startOffset, lineLength, normal, true);

		//  check for single line comment

		int index = content.indexOf(getSingleLineDelimiter(), startOffset);

		if ( (index > -1) && (index < endOffset) )

		{

			doc.setCharacterAttributes(index, endOffset - index + 1, comment, false);

			endOffset = index - 1;

		}

		//  check for tokens

		checkForTokens(content, startOffset, endOffset);

	}

	/*

	 *  Does this line contain the start delimiter

	 */

	private boolean startingMultiLineComment(String content, int startOffset, int endOffset)

		throws BadLocationException

	{

		int index = indexOf( content, getStartDelimiter(), startOffset );

		if ( (index < 0) || (index > endOffset) )

			return false;

		else

		{

			setMultiLineComment( true );

			return true;

		}

	}

	/*

	 *  Does this line contain the end delimiter

	 */

	private boolean endingMultiLineComment(String content, int startOffset, int endOffset)

		throws BadLocationException

	{

		int index = indexOf( content, getEndDelimiter(), startOffset );

		if ( (index < 0) || (index > endOffset) )

			return false;

		else

		{

			setMultiLineComment( false );

			return true;

		}

	}

	/*

	 *  We have found a start delimiter

	 *  and are still searching for the end delimiter

	 */

	private boolean isMultiLineComment()

	{

		return multiLineComment;

	}

	private void setMultiLineComment(boolean value)

	{

		multiLineComment = value;

	}

	/*

	 *	Parse the line for tokens to highlight

	 */

	private void checkForTokens(String content, int startOffset, int endOffset)

	{

		while (startOffset <= endOffset)

		{

			//  skip the delimiters to find the start of a new token

			while ( isDelimiter( content.substring(startOffset, startOffset + 1) ) )

			{

				if (startOffset < endOffset)

					startOffset++;

				else

					return;

			}

			//  Extract and process the entire token

			if ( isQuoteDelimiter( content.substring(startOffset, startOffset + 1) ) )

				startOffset = getQuoteToken(content, startOffset, endOffset);

			else

				startOffset = getOtherToken(content, startOffset, endOffset);

		}

	}

	/*

	 *

	 */

	private int getQuoteToken(String content, int startOffset, int endOffset)

	{

		String quoteDelimiter = content.substring(startOffset, startOffset + 1);

		String escapeString = getEscapeString(quoteDelimiter);

		int index;

		int endOfQuote = startOffset;

		//  skip over the escape quotes in this quote

		index = content.indexOf(escapeString, endOfQuote + 1);

		while ( (index > -1) && (index < endOffset) )

		{

			endOfQuote = index + 1;

			index = content.indexOf(escapeString, endOfQuote);

		}

		// now find the matching delimiter

		index = content.indexOf(quoteDelimiter, endOfQuote + 1);

		if ( (index < 0) || (index > endOffset) )

			endOfQuote = endOffset;

		else

			endOfQuote = index;

		doc.setCharacterAttributes(startOffset, endOfQuote - startOffset + 1, quote, false);

		return endOfQuote + 1;

	}

	/*

	 *

	 */

	private int getOtherToken(String content, int startOffset, int endOffset)

	{

		int endOfToken = startOffset + 1;

		while ( endOfToken <= endOffset )

		{

			if ( isDelimiter( content.substring(endOfToken, endOfToken + 1) ) )

				break;

			endOfToken++;

		}

		String token = content.substring(startOffset, endOfToken);

		if ( isKeyword( token ) )

		{

			doc.setCharacterAttributes(startOffset, endOfToken - startOffset, keyword, false);

		}

		return endOfToken + 1;

	}

	/*

	 *  Assume the needle will the found at the start/end of the line

	 */

	private int indexOf(String content, String needle, int offset)

	{

		int index;

		while ( (index = content.indexOf(needle, offset)) != -1 )

		{

			String text = getLine( content, index ).trim();

			if (text.startsWith(needle) || text.endsWith(needle))

				break;

			else

				offset = index + 1;

		}

		return index;

	}

	/*

	 *  Assume the needle will the found at the start/end of the line

	 */

	private int lastIndexOf(String content, String needle, int offset)

	{

		int index;

		while ( (index = content.lastIndexOf(needle, offset)) != -1 )

		{

			String text = getLine( content, index ).trim();

			if (text.startsWith(needle) || text.endsWith(needle))

				break;

			else

				offset = index - 1;

		}

		return index;

	}

	private String getLine(String content, int offset)

	{

		int line = rootElement.getElementIndex( offset );

		Element lineElement = rootElement.getElement( line );

		int start = lineElement.getStartOffset();

		int end = lineElement.getEndOffset();

		return content.substring(start, end - 1);

	}

	/*

	 *  Override for other languages

	 */

	protected boolean isDelimiter(String character)

	{

		String operands = ";:{}()[]+-/%<=>!&|^~*";

		if (Character.isWhitespace( character.charAt(0) ) ||

			operands.indexOf(character) != -1 )

			return true;

		else

			return false;

	}

	/*

	 *  Override for other languages

	 */

	protected boolean isQuoteDelimiter(String character)

	{

		String quoteDelimiters = "\"'";

		if (quoteDelimiters.indexOf(character) < 0)

			return false;

		else

			return true;

	}

	/*

	 *  Override for other languages

	 */

	protected boolean isKeyword(String token)

	{

		return keywords.contains( token );

	}

	/*

	 *  Override for other languages

	 */

	protected String getStartDelimiter()

	{

		return "/*";

	}

	/*

	 *  Override for other languages

	 */

	protected String getEndDelimiter()

	{

		return "*/";

	}

	/*

	 *  Override for other languages

	 */

	protected String getSingleLineDelimiter()

	{

		return "//";

	}

	/*

	 *  Override for other languages

	 */

	protected String getEscapeString(String quoteDelimiter)

	{

		return "\\" + quoteDelimiter;

	}

	/*

	 *

	 */

	protected String addMatchingBrace(int offset) throws BadLocationException

	{

		StringBuffer whiteSpace = new StringBuffer();

		int line = rootElement.getElementIndex( offset );

		int i = rootElement.getElement(line).getStartOffset();

		while (true)

		{

			String temp = doc.getText(i, 1);

			if (temp.equals(" ") || temp.equals("\t"))

			{

				whiteSpace.append(temp);

				i++;

			}