Application: gvSIG desktop » gvSIG scripting

      <artifactId>org.gvsig.scripting</artifactId>

      <version>1.0.0-SNAPSHOT</version>

import java.util.List;

import org.gvsig.andami.IconThemeHelper;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

		if( "tools-scripting-launcher".equalsIgnoreCase(command) ) {

		} else if( "tools-scripting-composer".equalsIgnoreCase(command) ) {

		IconThemeHelper.registerIcon("action", "tools-scripting-launcher", this);

		IconThemeHelper.registerIcon("action", "tools-scripting-composer", this);

		IconThemeHelper.registerIcon("action", "tools-scripting-console-jython", this);

	    List<File> pluginsFolders = pluginManager.getPluginsFolders();

	    for( File pluginsFolder : pluginsFolders ) {

		    File[] folders = pluginsFolder.listFiles();

		    for (File folder : folders) {

			    File scriptsFolder = new File(folder,"scripting/scripts");

			    if( scriptsFolder.exists() ) {

			    	manager.registerSystemFolder(folder.getName(), scriptsFolder);

			    }

			    File libFolder = new File(folder,"scripting/lib");

			    if( libFolder.exists() ) {

			    	manager.addLibFolder(libFolder);

			    }

			}

	    }

	    File autorun_file = null;

	    ScriptingBaseScript autorun = null;

	    for( File pluginsFolder : pluginsFolders ) {

		    File[] folders = pluginsFolder.listFiles();

		    for (File folder : folders) {

		    	autorun_file = new File(folder,"scripting/scripts/autorun.inf");

			    if( autorun_file.exists() ) {

			    	autorun = manager.getScript(autorun_file);

			    	try {

			    		autorun.run();

			    	} catch(Exception ex) {

			    		logger.warn("Can't execute autorun from '"+autorun_file.getAbsolutePath()+"'.",ex);

			    	}

			    }

			}

	    }

    	try {

    		autorun_file = new File( manager.getRootUserFolder(),"autorun.inf" );

    		if( autorun_file.exists() ) {

	    	    autorun = (ScriptingBaseScript) manager.getUserFolder().getUnit(new File("autorun.inf"));

	    	    if( autorun!=null) {

	    	    	autorun.run();

	    	    }

    		}

    	} catch(Exception ex) {

    		logger.warn("Can't execute autorun in home.",ex);

    	}

__docformat__ = "restructuredtext en"

from org.gvsig.app.project.documents.table import TableDocument as JTableDocument

class DataTable(object):

  """

  This is the base class to TableDocument_ and LayerVectorial_

  .. _TableDocument : FIXME_URL

  .. _LayerVectorial : FIXME_URL

  """

  def features(self, filter = None, sortby="", asc=True):

    """

    Return a set of features

    Opcionalmente puede especificarse una expresion de filtrado,

    los campos por los que se quiere que se ordene y si este

    orden es ascendente o descendente.

    :paramters:

      filter : string

        es una expresion que deben cumplir los registros de la tabla a devolver.

      sortby : string

        es una lista de nombres de campos de la tabla por los que queremos que 

        se ordene separados por comas. 

      asc : boolean

        True para ordenar de forma ascendente, que es el valor por defecto, 

        False para ordenar descendentemete.

    :return:

      the set of features.

    :returntype:

      FeatureSet_

    .. _FeatureSet : FIXME_URL

    """

    return self.getFeatureStore().features(filter, sortby, asc)

  def edit(self):

    """

    Set the data table in edition mode

    """

    self.getFeatureStore().edit() 

  def append(self, *valuesList, **values):

    """

    Creates a new feature.

    Creates a new feature from given values and insert it in the feature set.

    This method can receibe as parameters a list of pair name=value where name

    is the name of an attribute of the feature and value the value of this attribute.

    Alternativement can receibe a list of values that can be asigned to the attributes

    of the feature in sequential order.

    The changes are delayed until the method commit is invoked.

    If calling the method abort the changes arent discarded.    

    """

    self.getFeatureStore().append(*valuesList, **values)

  def updateSchema(self, schema):

    """

    Updates the schema of the DataTable.

    """

    self.getFeatureStore().updateSchema(schema)

  def update(self, feature):

    """

    Updates the feature in the DataTable.

    If the feature exists in the DataTable this is updated with the

    values of the feature pased as parameter.

    The feature changes are delayed until the method commit is invoked.

    If calling the method abort the changes arent discarded.

    :Parameters:

      feature : EditableFeature_

        the feature to be updated.

    """

    self.getFeatureStore().update(feature)

  def getSchema(self):

    """

    Returns schema of the DataTable.

    The schema of the DataTable constains information about the columns of 

    the DataTable, name, type, mandatory...

    """

    return self.getFeatureStore().getSchema()

  def commit(self):

    """

    Saves all changes pending in the DataTable.

    """

    self.getFeatureStore().commit()

  def abort(self):

    """

    Discard all pending changes in the DataTable.

    """

    self.getFeatureStore().abort()

  def getSelection(self):

    """

    Returns features selected set

    """

    return self.getFeatureStore().getFeatureSelection()

  def select(self, selection):

    """

    Inserts features in the features selection set

    """

    self.getSelection().select(selection)

  def deselect(self, selection):

    """

    Remove features in the features selection set

    """

    self.getSelection().deselect(selection)

  def isSelected(feature):

    """Returns True if given feature is selected"""

    self.getSelection().isSelect(feature)

class TableDocument(JTableDocument, DataTable):

  """

  Represents gvSIG view document 

  Extends the `java TableDocument`_

  .. _`java TableDocument` : FIXME_URL

  """

  def getFeatureStore(self):

    """

    Returns the FeatureStore_ associted to this TableDocument.

    :return:

      The FeatureStore_ associated to the TableDocument

    :returntype:

      FeatureStore_

    .. _FeatureStore : FIXME_URL

    """

    return self.getStore()

  def __call__(self):

    """

    Return the java object represented by this object.

    This method is for compatibility with scripting API of gvSIG 2.0

    :ReturnType:

      TableDocument

    :deprecated: 

      With gvSIG 2.1 the call this method isn't necesary

    """

    return self

#

# Inject new methods in the class JTableDocument

#

JTableDocument.getFeatureStore = TableDocument.getFeatureStore

JTableDocument.__call__ = TableDocument.__call__

JTableDocument.features = DataTable.features

JTableDocument.edit = DataTable.edit

JTableDocument.append = DataTable.append

JTableDocument.updateSchema = DataTable.updateSchema

JTableDocument.update = DataTable.update

JTableDocument.getSchema = DataTable.getSchema

JTableDocument.commit = DataTable.commit

JTableDocument.abort = DataTable.abort

JTableDocument.getSelection = DataTable.getSelection

JTableDocument.select = DataTable.select

JTableDocument.deselect = DataTable.deselect

JTableDocument.isSelected = DataTable.isSelected

__docformat__ = "restructuredtext en"

from org.gvsig.app.project.documents.view import DefaultViewDocument as JViewDocument

class ViewDocument(JViewDocument):

  """

  Represents gvSIG view document 

  Extends the java class DefaultViewDocument_

  .. _DefaultViewDocument : FIXME_URL

  """

  def getLayer(self, name=None):

    """

    Return a layer of the view document.

    If don't pecified a layer name, return the current layer of

    the view. If has more than one active layer return None.

    If spacified a layer name and exists a layer with this name,

    return this, otherwise return None.

    :parameters:

      name : string

        optional name of the layer to retrieve, if not pased return active layer.

    :returns:

      the layer or None

    :returntype:

      Layer_

    .. _layer : FIXME_URL

    """

    mapContext = self.getMapContext();

    if name == None:

      activeLayers = mapContext.getLayers().getActives()

      if len(activeLayers) != 1 :

        return None

      for layer in activeLayers:

        if not isinstance(layer, FLayers):

          return layer

      return None

    layers = self.getLayers()

    for i in xrange(layers.getLayersCount()):

      layer = layers.getLayer(i)

      if layer.name == name:

        return layer

    return None

  def getMap(self):

    """

    Return the map definition asociated to the view.

    This contains the layers, projection and definition

    of the area to view.

    :returns:

      the map definition

    :returntype:

      MapContext_

    .. _MapContext : FIXME_URL

    """

    return self.getMapContext();

  def addLayer(self, layer):

    """

    Add a new layer to the view.

    Don't return any thing.

    :parameters:

      layer : Layer_

        the layer to add to the view

    .. _Layer : FIXME_URL

    """

    self.getMapContext().getLayers().addLayer(layer)

  def getLayers(self):

    """

    Return a iterable set of \p Layers from the view.

    :returns:

      a Layers object

    :returntype:

      Layers_

    .. _Layers : FIXME_URL

    """

    mapContext = self.getMapContext()

    return mapContext.getLayers()

  def getGraphicsLayer(self):

    """

    Return the graphics layer of the view.

    :returns:

      a the graphics layer

    :returntype:

       DefaultGraphicLayer_

    .. _DefaultGraphicLayer : FIXME_URL

    """    

    return self.getMapContext().getGraphicsLayer()

  def getProjectionCode(self):

    """

    Returns Project projection code name of the view as a string. 

    :return:

      the projection code as a string.

    :returntype:

      String

    """  

    return self.getProjection().getFullCode()

  def isProjected(self):

    """

    Returns if the coordinate system of the view is projected.

    :return:

      true if the coordinate system of the view is projected, otherwise return false.

    :returntype:

      boolean

    """  

    self.getProjection().isProjected()

  def __call__(self):

    """

    Return the java object represented by this object.

    This method is for compatibility with scripting API of gvSIG 2.0

    :ReturnType:

      ViewDocument

    :deprecated: 

      With gvSIG 2.1 the call this method isn't necesary

    """

    return self

#

# Inject new methods in the class JViewDocument

#

JViewDocument.getLayer = ViewDocument.getLayer

JViewDocument.getMap = ViewDocument.getMap

JViewDocument.addLayer = ViewDocument.addLayer

JViewDocument.getGraphicsLayer = ViewDocument.getGraphicsLayer

JViewDocument.getProjectionCode = ViewDocument.getProjectionCode

JViewDocument.isProjected = ViewDocument.isProjected

JViewDocument.__call__ = ViewDocument.__call__

from org.gvsig.fmap.dal.feature.impl import DefaultFeatureStore

class FeatureStore(DefaultFeatureStore):

  """Represents gvsig store. It's used as Table/Layer objects store  

  (org.gvsig.fmap.dal.feature.impl.DefaultFeatureStore)

  """

  def __init__(self,store):

    WrapperToJava.__init__(self, store)

    #self.data = None

    self.fset = None

  def features(self, expresion = None, sortBy="", asc=True):

    """Returns layer features set (FeatureSet class), with all layer features, 

    or selected featured if there are (could be empty feature set) or None if

    gets an Exception.

    :param expresion: filter to apply to the feature set to select

        determinates features that match with expression

    :type expresion: string

    :param sortBy: name of attribute to sort

    :type sortby: string

    :param: asc: order

    :type asc: boolean

    :return: FeatureSet

    """   

    if expresion == None and sortBy =="":

      self.fset = self.getFeatureSet()         

    else:

      try:

        application = ApplicationLocator.getManager()

        datamanager =  application.getDataManager()

        query = self.createFeatureQuery()

        if sortBy != "":

            order = FeatureQueryOrder()

            order.add(sortBy, asc)

            query.setOrder(order)

        if expresion != None:

            query.setFilter(datamanager.createExpresion(expresion))

        self.fset = self.getFeatureSet(query)

      except Exception, e:

        return None

    return FeatureSet(self.fset)    

  def edit(self):

    """Set store in edition mode"""     

    if not self.isEditing():

        self().edit() 

  def append(self, *valuesList, **values):

    """

    Creates a new feature from given values and insert it in the feature 

    set. If an error occurs raises RuntimeException.

    :param values: dictionary with name property value or list named params

    :type values: dict

    """

    try:

      if len(valuesList) ==1:

        values.update(valuesList[0])

      if not self.isEditing():

        self.edit() 

      f = self.createNewFeature()

      if f == None:

        raise RuntimeError("Failed to create a new Feature")

      for k,v in values.iteritems():

        f.set(k,v)

        self.insert(f)

    except Throwable, ex:

      raise RuntimeException("Can't append values %s to layer %s (%s)" % (

        repr(values), 

        self.getName(), 

        str(ex)

        )

      )

  def updateSchema(self, schema):

    """

    Updates store FeatureType. If an error occurs raises 

    RuntimeException.

    """

    try:

      self().update(schema._javaobj)

    except Throwable, ex:

      raise RuntimeException(repr(ex))

  def update(self, feature):

    """

    Updates exist feature in the layer featureSet

    :param editableFeature: editableFeature

    :type editableFeature: Java editableFeature

    """

    if not self.isEditing():

      self.edit() 

    if not isinstance(feature, EditableFeature):

      feature = feature._javaobj

    self.fset.update(feature)

  def getSchema(self):

    """Returns store data attributtes"""

    return Schema(self.getDefaultFeatureType())

  def commit(self):

    """

    Finish store edition saving changes. If an error occurs raises Throwable 

    Exception.

    """

    try:

      self.finishEditing()          

    except Throwable, ex:

      self.abort()

      raise Throwable("Can't finish layer edition, cancelling changes. %s" % repr(ex))

  def abort(self):

    """Finish store edition withoout saving changes and disposes itself"""

    self.cancelEditing() 

    self.dispose()

  def getSelection(self):

    """Returns store features selected set"""

    return FeatureSet(self().getSelection())

from project import Project, currentProject, currentDocument, currentView, currentTable

from table import TableDocument

from view import ViewDocument, currentLayer

from vectorial import Feature, Featureset, FeatureStore, LayerVectorial, Schema, Selection

__docformat__ = "restructuredtext en"

from org.gvsig.fmap.mapcontext.layers import FLayers as JLayers

class Layers(JLayers):

  """

  Set of layers.

  Extends the `java FLayers`_.

  .. _`java FLayers` : FIXME_URL

  """

  def __len__(self):

    """

    Allow get the len of the set of layers in a python maner.

    :return:

      The len of the set of layers

    :returntype:

      int

    """

    return self.getLayersCount()

  def __getitem__(self, index):

    """

    Allow get items of the set of layers in a python maner.

    It return the layer of position *index* of the set of layers.

    :return:

      The layer requiered of the set.

    :returntype:

      Layer_

    .. _Layer : FIXME_URL

    """

    return self.getLayer(index)

  def __iter__(self):

    """

    Allow iterate over the set of layers in a python maner.

    Return an iterator over the set of layers.

    :return:

      The layers iterator

    :returntype:

      LayersIterator

    """

    return LayersIterator(self)

  def __call__(self):

    """

    Return the java object represented by this object.

    This method is for compatibility with scripting API of gvSIG 2.0

    :ReturnType:

      Layers

    :deprecated: 

      With gvSIG 2.1 the call this method isn't necesary

    """

    return self

class LayersIterator(object):

  """

  Iterator over a set of layers.

  This class can't be created, is used internaly by the class Layers

  when a iterator is required.

  """

  def __init__(self,layers):

    self.__layers = layers

    self.__index = -1

  def next(self):

    self.__index+=1

    if self.__index >= self.__layers.getLayersCount() :

      raise StopIteration()

    return self.__layers.getLayer(self.__index)

#

# Inject new methods in the class JLayers

#

JLayers.__call__ = Layers.__call__

JLayers.__len__ = Layers.__len__

JLayers.__getitem__ = Layers.__getitem__

JLayers.__iter__ = Layers.__iter__

from org.gvsig.fmap.dal.feature.impl import DefaultFeatureStore

class FeatureStore(DefaultFeatureStore):

  """Represents gvsig store. It's used as Table/Layer objects store  

  (org.gvsig.fmap.dal.feature.impl.DefaultFeatureStore)

  """

  def __init__(self,store):

    WrapperToJava.__init__(self, store)

    #self.data = None

    self.fset = None

  def features(self, expresion = None, sortBy="", asc=True):

    """Returns layer features set (FeatureSet class), with all layer features, 

    or selected featured if there are (could be empty feature set) or None if

    gets an Exception.

    :param expresion: filter to apply to the feature set to select

        determinates features that match with expression

    :type expresion: string

    :param sortBy: name of attribute to sort

    :type sortby: string

    :param: asc: order

    :type asc: boolean

    :return: FeatureSet

    """   

    if expresion == None and sortBy =="":

      self.fset = self.getFeatureSet()         

    else:

      try:

        application = ApplicationLocator.getManager()

        datamanager =  application.getDataManager()

        query = self.createFeatureQuery()

        if sortBy != "":

            order = FeatureQueryOrder()

            order.add(sortBy, asc)

            query.setOrder(order)

        if expresion != None:

            query.setFilter(datamanager.createExpresion(expresion))

        self.fset = self.getFeatureSet(query)

      except Exception, e:

        return None

    return FeatureSet(self.fset)    

  def edit(self):

    """Set store in edition mode"""     

    if not self.isEditing():

        self().edit() 

  def append(self, *valuesList, **values):

    """

    Creates a new feature from given values and insert it in the feature 

    set. If an error occurs raises RuntimeException.

    :param values: dictionary with name property value or list named params

    :type values: dict

    """

    try:

      if len(valuesList) ==1:

        values.update(valuesList[0])

      if not self.isEditing():

        self.edit() 

      f = self.createNewFeature()

      if f == None:

        raise RuntimeError("Failed to create a new Feature")

      for k,v in values.iteritems():

        f.set(k,v)

        self.insert(f)

    except Throwable, ex:

      raise RuntimeException("Can't append values %s to layer %s (%s)" % (

        repr(values), 

        self.getName(), 

        str(ex)

        )

      )

  def updateSchema(self, schema):

    """

    Updates store FeatureType. If an error occurs raises 

    RuntimeException.

    """

    try:

      self().update(schema._javaobj)

    except Throwable, ex:

      raise RuntimeException(repr(ex))

  def update(self, feature):

    """

    Updates exist feature in the layer featureSet

    :param editableFeature: editableFeature

    :type editableFeature: Java editableFeature

    """

    if not self.isEditing():

      self.edit() 

    if not isinstance(feature, EditableFeature):

      feature = feature._javaobj

    self.fset.update(feature)

  def getSchema(self):

    """Returns store data attributtes"""

    return Schema(self.getDefaultFeatureType())

  def commit(self):

    """

    Finish store edition saving changes. If an error occurs raises Throwable 

    Exception.

    """

    try:

      self.finishEditing()          

    except Throwable, ex:

      self.abort()

      raise Throwable("Can't finish layer edition, cancelling changes. %s" % repr(ex))

  def abort(self):

    """Finish store edition withoout saving changes and disposes itself"""

    self.cancelEditing() 

    self.dispose()

  def getSelection(self):

    """Returns store features selected set"""

    return FeatureSet(self().getSelection())

class FeatureSet(WrapperToJava):

  """Represents gvSIG FeatureSet 

  (org.gvsig.fmap.dal.feature.impl.featureset.DefaultFeatureSet)

  """

  def __init__(self,featureSet):

    WrapperToJava.__init__(self,featureSet)

  def getCount(self):

    """Returns the number of elements in the featureSet"""

    return self.getSize()

  def update(self, feature):

    """

    Updates exist feature in the featureSet

    :param editableFeature: editableFeature

    :type editableFeature: Java editableFeature

    """

    if not isinstance(feature, EditableFeature) and \

            not isinstance(feature, DefaultEditableFeature):

      feature = feature._javaobj

    self().update(feature)

  def __iter__(self):

    return  Iterator(self.fastIterator())

class Selection(FeatureSet):

  """Manage selected features set from a store. Represents gvSIG 

  org.gvsig.fmap.dal.feature.impl.DefaultFeatureSelection.  

  """

  def __init__(self, featureSet):

    FeatureSet.__init__(self, featureSet)

  def select(self, selection):

    """Inserts features in the features selection set"""

    if isinstance(selection,Feature) or isinstance(selection, FeatureSet):

      self._javaobj.select(selection._javaobj)

    else:

      self._javaobj.select(selection)

  def deselect(self, selection):

    """Removes features in the features selection set"""

    if isinstance(selection,Feature) or isinstance(selection, FeatureSet):

      self._javaobj.deselect(selection._javaobj)

    else:

      self._javaobj.deselect(selection)

  def isSelected(feature):

    """Returns True if given feature is selected"""

    if isinstance(feature, Feature):

      self._javaobj.isSelect(feature._javaobj)

    else:

      self._javaobj.isSelect(feature)

  def getCount(self):

    """Returns the number of elements in the selection"""

    return self.getSelectedCount()

class Feature(WrapperToJava):

  """Represents feature data It's a wrapper from gvSIG 

  org.gvsig.fmap.dal.feature.impl.DefaultFeature class

  """

  def __init__(self,feature):

    WrapperToJava.__init__(self,feature)

    self.featureNoEditable = None

  def geometry(self):

    """Returns feature geometry"""

    return self.getDefaultGeometry()

  def getValues(self):

    """Returns dictionary with the pair name, value, feature attributes"""

    descriptor = self.getType()

    items = dict()

    for attr in descriptor.getAttributeDescriptors():

      name = attr.getName()

      value = self.get(attr.getName())

      items[name] = value

    return items 

  def edit(self):

    """Returns editable feature instance"""

    if not isinstance(self._javaobj, EditableFeature):

      self.featureNoEditable = self._javaobj

      self._javaobj = self._javaobj.getEditable()

  def __getitem__(self,key):

    return self.get(key)

  def __getattr__(self,name):

    #

    #FIX console error when try to introspect feature object

    if name in ('__methods__'):

        return dict()

    elif name in ('__members__'):

        return self.getValues().keys()

    elif name == '__dict__':

        return self.getValues()      

    try:

      v = getattr(self._javaobj, name, None)

      if v == None:

        v = self().get(name)        

      return v

    except Throwable, ex:

      raise RuntimeException("Can't access to attribute %s of feature (%s)" % (name, str(ex)))    

class Schema(WrapperToJava):

  """Stores data properties definition. Represents gvSIG FeatureType

  (org.gvsig.fmap.dal.feature.impl.DefaultFeatureType)

  """

  def __init__(self, featureType):

    WrapperToJava.__init__(self,featureType)

    self.featureTypeNoEditable = None

  def append(self, name, type, size=None, default=None, precision=4):

    """Adds new property to feature properties definition. If error occurs 

    raises RuntimeError.    

    :param name: Feature property name

    :type name: String

    :param type: Feature property type

    :type name: String

    :param size: Feature property size

    :type size: int

    :param default: Feature property default value

    :return: new atribute

    """

    if not isinstance(self._javaobj, EditableFeatureType):

        self.modify()

    if isinstance(type, str):

      try:

        application = ApplicationLocator.getManager()

        datamanager =  application.getDataManager()

        dataTypes = application.getDataTypesManager()

        type = dataTypes.getType(type) #dataType constant value from string

      except:

        raise RuntimeError(

            "Feature Property Data type (%s) is not valid.  name=%s, type=%s, size=%s, default=%s)" % (

                type, 

                name, 

                type, 

                size, 

                default

            )

        )

    if isinstance(type, int):

      try:

        type = dataTypes.get(type)

      except:

        raise RuntimeError(

            "Data type (%s) is not valid.  name=%s, type=%s, size=%s, default=%s)" % (

                type, 

                name, 

                type, 

                size, 

                default

            )

        )

    attribute = self.add(name, type.getType())

    if size != None: 

      attribute.setSize(size)

    if default != None:

      attribute.setDefaultValue(default)

    if precision != None and type.getType() in (DataTypes.DOUBLE, DataTypes.FLOAT):

      attribute.setPrecision(precision)

    if type.getType() == DataTypes.GEOMETRY and self.getDefaultGeometryAttributeName()==None:

      self.setDefaultGeometryAttributeName(name)

    return attribute

  def __getitem__(self, name):

    return self.getAttributeDescriptor(name)

  def get(self, name, default=None):

    """Returns a feature attribute descriptor that contains information about 

    one feature attribute, such as its name, data type or precision. 

    :param name: Attribute name

    :type name: string

    :param default: Value to return if no attribute name found. 

    :return: AttributeDescriptor

    """

    x = self.getAttributeDescriptor(name)

    if x == None:

      return default

    return x

  def getAttrNames(self):

    """Returns a list with attributes names"""

    if not self.getAttributeDescriptors():

      return None

    return [attr.getName() for attr in self.getAttributeDescriptors()]

  def getCopy(self):

    """Returns a itself clone"""

    return Schema(self().getCopy())

  def modify(self):

    """Sets edit mode"""

    if not isinstance(self._javaobj, EditableFeatureType):

      self.featureTypeNoEditable = self._javaobj

      self._javaobj = self._javaobj.getEditable()

from org.gvsig.fmap.dal.feature.impl import DefaultFeature as JFeature

class Feature(JFeature):

  """Represents feature data It's a wrapper from gvSIG 

  """

  def __init__(self,feature):

    WrapperToJava.__init__(self,feature)

    self.featureNoEditable = None

  def geometry(self):

    """Returns feature geometry"""

    return self.getDefaultGeometry()

  def getValues(self):

    """Returns dictionary with the pair name, value, feature attributes"""

    descriptor = self.getType()

    items = dict()

    for attr in descriptor.getAttributeDescriptors():

      name = attr.getName()

      value = self.get(attr.getName())

      items[name] = value

    return items 

  def edit(self):

    """Returns editable feature instance"""

    if not isinstance(self._javaobj, EditableFeature):

      self.featureNoEditable = self._javaobj

      self._javaobj = self._javaobj.getEditable()

  def __getitem__(self,key):

    return self.get(key)

  def __getattr__(self,name):

    #

    #FIX console error when try to introspect feature object

    if name in ('__methods__'):

        return dict()

    elif name in ('__members__'):

        return self.getValues().keys()

    elif name == '__dict__':

        return self.getValues()      

    try:

      v = getattr(self._javaobj, name, None)

      if v == None:

        v = self().get(name)        

      return v

    except Throwable, ex:

      raise RuntimeException("Can't access to attribute %s of feature (%s)" % (name, str(ex)))    

from org.gvsig.fmap.dal.feature.impl import DefaultFeatureType as JSchema

class Schema(JSchema):

  """

  Stores data properties definition. Represents gvSIG FeatureType

  """

  def append(self, name, type, size=None, default=None, precision=4):

    """Adds new property to feature properties definition. If error occurs 

    raises RuntimeError.    

    :param name: Feature property name

    :type name: String

    :param type: Feature property type

    :type name: String

    :param size: Feature property size

    :type size: int

    :param default: Feature property default value

    :return: new atribute

    """

    if not isinstance(self._javaobj, EditableFeatureType):

        self.modify()

    if isinstance(type, str):

      try:

        application = ApplicationLocator.getManager()

        datamanager =  application.getDataManager()

        dataTypes = application.getDataTypesManager()

        type = dataTypes.getType(type) #dataType constant value from string

      except:

        raise RuntimeError(

            "Feature Property Data type (%s) is not valid.  name=%s, type=%s, size=%s, default=%s)" % (

                type, 

                name, 

                type, 

                size, 

                default

            )

        )

    if isinstance(type, int):

      try:

        type = dataTypes.get(type)

      except:

        raise RuntimeError(

            "Data type (%s) is not valid.  name=%s, type=%s, size=%s, default=%s)" % (

                type, 

                name, 

                type, 

                size, 

                default

            )

        )

    attribute = self.add(name, type.getType())

    if size != None: 

      attribute.setSize(size)

    if default != None:

      attribute.setDefaultValue(default)

    if precision != None and type.getType() in (DataTypes.DOUBLE, DataTypes.FLOAT):

      attribute.setPrecision(precision)

    if type.getType() == DataTypes.GEOMETRY and self.getDefaultGeometryAttributeName()==None:

      self.setDefaultGeometryAttributeName(name)

    return attribute

  def __getitem__(self, name):

    return self.getAttributeDescriptor(name)

  def get(self, name, default=None):

    """Returns a feature attribute descriptor that contains information about 

    one feature attribute, such as its name, data type or precision. 

    :param name: Attribute name

    :type name: string

    :param default: Value to return if no attribute name found. 

    :return: AttributeDescriptor

    """

    x = self.getAttributeDescriptor(name)

    if x == None:

      return default

    return x

  def getAttrNames(self):

    """Returns a list with attributes names"""

    if not self.getAttributeDescriptors():

      return None

    return [attr.getName() for attr in self.getAttributeDescriptors()]

  def getCopy(self):

    """Returns a itself clone"""

    return Schema(self().getCopy())

  def modify(self):

    """Sets edit mode"""

    if not isinstance(self._javaobj, EditableFeatureType):

      self.featureTypeNoEditable = self._javaobj

      self._javaobj = self._javaobj.getEditable()

from org.gvsig.fmap.mapcontext.layers.vectorial import FLyrVect as JLayerVectorial

from table import DataTable

class LayerVectorial(JLayerVectorial,DataTable):

  """

  This class represent a vectorial layer.

  Extends the `java FLyrVect`_ class.

  .. _`java FLyrVect` : FIXME_URL

  """

  def getProjectionCode(self):

    """

    Returns projection code name of the layer.

    :return:

      the projection code name of the layer.

    :returntype:

      String

    """

    return self.getProjection().getFullCode()

  def __call__(self):

    """

    Return the java object represented by this object.

    This method is for compatibility with scripting API of gvSIG 2.0

    :ReturnType:

      LayerVectorial

    :deprecated: 

      With gvSIG 2.1 the call this method isn't necesary

    """

    return self    

#

# Inject new methods in the class JLayerVectorial

#

JLayerVectorial.getProjectionCode = LayerVectorial.getProjectionCode

JLayerVectorial.__call__ = LayerVectorial.__call__

JLayerVectorial.features = DataTable.features

JLayerVectorial.edit = DataTable.edit

JLayerVectorial.append = DataTable.append

JLayerVectorial.updateSchema = DataTable.updateSchema

JLayerVectorial.update = DataTable.update

JLayerVectorial.getSchema = DataTable.getSchema

JLayerVectorial.commit = DataTable.commit

JLayerVectorial.abort = DataTable.abort

JLayerVectorial.getSelection = DataTable.getSelection

JLayerVectorial.select = DataTable.select

JLayerVectorial.deselect = DataTable.deselect

JLayerVectorial.isSelected = DataTable.isSelected

class Selection(FeatureSet):

  """Manage selected features set from a store. Represents gvSIG 

  org.gvsig.fmap.dal.feature.impl.DefaultFeatureSelection.  

  """

  def __init__(self, featureSet):

    FeatureSet.__init__(self, featureSet)

  def select(self, selection):

    """Inserts features in the features selection set"""

    if isinstance(selection,Feature) or isinstance(selection, FeatureSet):

      self._javaobj.select(selection._javaobj)

    else:

      self._javaobj.select(selection)

  def deselect(self, selection):