/org.gvsig.scripting.app/trunk/org.gvsig.scripting.app/org.gvsig.scripting.app.extension/src/main/resources/scripting/lib/gvsig.py - Diff - gvSIG scripting - gvSIG

Revision 362 org.gvsig.scripting.app/trunk/org.gvsig.scripting.app/org.gvsig.scripting.app.extension/src/main/resources/scripting/lib/gvsig.py

     __author__ = """Antonio Carrasco Valero
     Model Driven Development sl and Antonio Carrasco Valero
     <carrasco@modeldd.org>"""
     <carrasco@modeldd.org>
     Victor Acevedo Royer <vacevedor@gmail.com>
     """
     __docformat__ = 'plaintext'
     from org.gvsig.fmap.mapcontext import MapContextLocator
     from java.lang import RuntimeException
     from java.lang import Throwable
     from org.gvsig.app import ApplicationLocator
     from org.gvsig.app.project.documents.view import ViewDocument
     from org.gvsig.fmap.dal import DALLocator
     from org.gvsig.fmap.dal import DataTypes
     from org.gvsig.fmap.geom import Geometry
     from org.gvsig.fmap.mapcontext import MapContextLocator
     from org.gvsig.fmap.mapcontext.layers import FLayers
     from org.gvsig.fmap.dal import DALLocator, DataTypes
     from org.gvsig.fmap.dal.feature import EditableFeature, EditableFeatureType
     #from org.gvsig.fmap.geom import Geometry, GeometryLocator
     from org.gvsig.tools import ToolsLocator
     from org.gvsig.fmap.geom import DataTypes
     from geom import *
     import thread
     """
     ARRAY, BOOLEAN, BYTE, BYTEARRAY, CHAR, CONTAINER, DATE, DOUBLE, DYNOBJECT, FILE,
     FLOAT, FOLDER, INT, INVALID, LIST, LONG, MAP, MAX_TYPE_VALUE, OBJECT, SET,
     STRING, SUBTYPE_DATE, SUBTYPE_FILE, SUBTYPE_FOLDER, TIME, TIMESTAMP, UNKNOWN,
     URI, URL
     """
     def runTask(name, function, *args):
       manager = ToolsLocator.getTaskStatusManager()
       status = manager.createDefaultSimpleTaskStatus(name)
-...
     class WrapperToJava(object):
       """
       Create a wrapper that allows python object access to the Java object
       properties and methods
       """
       def __init__(self, javaobj):
         if javaobj == None:
           raise RuntimeException("Can't create "+ self.__class__.__name__)
-...
         return getattr(self._javaobj,name)
     class Project(WrapperToJava):
       def __init__(self,project):
         WrapperToJava.__init__(self,project)
       """
       Represents a gvSIG project
       """
       def __init__(self, project):
         WrapperToJava.__init__(self, project)
       def getView(self, name=None):
         """
         Return active view, or view called 'name'  or None
           :param name: view name
           :type name: string
         """
         v = None
         if name == None:
           return View(self.getActiveDocument("project.document.view2d"))
           try:
             activeDocument = self.getActiveDocument()
             #if v.__class__ == "project.document.view2d":
             if activeDocument.getTypeName() == "project.document.view2d":
               v = View(activeDocument)
           except Exception, ex:
             raise Exception("%s"%repr(ex))
         views = self.getViews()
         else:
           views = self.getViews()
           if len(views) >0:
             for view in views:
               if name == view.getName():
                 v = View(view)
         if len(views) >0:
           for v in views:
             if name == v.getName():
               return View(v)
         return v
       def getTable(self, name=None):
         """
         Return active Table Document, or Table Document called 'name'  or None
           :param name: Table Document name
           :type name: string
         """
         t = None
         if name == None:
           try:
             activeDocument = self.getActiveDocument()
             if activeDocument.getTypeName() == "project.document.table":
               t = Table(activeDocument)
           except Exception, ex:
             raise Exception("%s"%repr(ex))
         else:
           tables = self.getDocuments("project.document.table")
           if len(tables) >0:
             for table in tables:
               if name == table.getName():
                 t = Table(table)
         return t
         return None
     class View(WrapperToJava):
       """
       Represents gvSIG view document.
       """
       def __init__(self,view):
         WrapperToJava.__init__(self,view)
       def refresh(self):
         map = self.getMapContext()
         map.invalidate()
       def getLayer(self, name=None):
         map = self.getMapContext()
         """
         Return one of the view layers documents. If name is None return view active
         layer if the view has one, if name is not None return view called name else
         return None.
           :param name: view name in Table Of Contents
           :type name: string
           :return: View
           :return: None
         """
         map = self.getMapContext();
         if name == None:
           activeLayers = map.getLayers().getActives()
           if len(activeLayers) != 1 :
             raise RuntimeException("The view has not an active layer")
           return Layer(activeLayers[0])
         #FIXME
         try:
           return Layer(layers.getLayer(name))
         except Exception, ex:
           print "View.getLayer Error. %s"%repr(ex)
           for layer in activeLayers:
             if not isinstance(layer, FLayers):
               return Layer(layer)
           raise RuntimeException("The view has not an active layer")
         layers = map.getLayers()
         """
         for i in xrange(len(ls)):
           l = layers.getLayer(i)
           if name == l.getName():
         ls = self.getLayers()
         for i in xrange(ls.getLayersCount()):
           l = ls.getLayer(i)
           if l.name == name:
             return Layer(l)
         """
         return layers
         return None
       def getMap(self):
         """
         Return view mapContext
         """
         return self.getMapContext();
       def addLayer(self, layer):
         #FIXME: Comprobar si es un Layer de python y convertirlo al de
         # java automaticmente para que acepte los dos
         if isinstance(layer, Layer):
           layer =layer()
         self.getMapContext().getLayers().addLayer(layer)
       def getLayers(self):
         """
         Return iterable view layers set
         """
         map = self.getMapContext();
         return Layers(map.getLayers())
       def getGraphicsLayer(self):
         """
         Return view graphics layer
         """
         return self.getMapContext().getGraphicsLayer()
     class Layers(WrapperToJava):
       """
       Iterable layers set
       """
       def __init__(self,layers):
         WrapperToJava.__init__(self, layers)
-...
       def __iter__(self):
         return LayersIterator(self)
     #class LayersIterator(WrapperToJava):
     class LayersIterator(object):
       def __init__(self,layers):
         #WrapperToJava.__init__(self, layers)
         self.__layers = layers
         self.__index = 0
       def next(self):
         if self.__index > self.__layers.getLayersCount() :
           raise StopIteration()
         #FIXME
         #return Layer(self.__layers.getLayer(self.__index))
         return Layer(self.__layers.get(self.__index))
         return Layer(self.__layers.get(self.__index))
     class Store(WrapperToJava):
       """
       Represents gvsig store
       """
       def __init__(self,store):
         WrapperToJava.__init__(self, store)
         #self.data = None
         self.fset = None
       def features(self, expresion = None):
         """
         Return layer features set
     class Layer(WrapperToJava):
       def __init__(self,layer):
         WrapperToJava.__init__(self,layer)
             :param expresion: filter to apply to the feature set to select
     determinates features that match with expression
             :type expresion: string
             :return: FeatureSet
         """
         if expresion == None:
           self.fset = self.getFeatureSet()
         else:
           application = ApplicationLocator.getManager()
           datamanager =  application.getDataManager()
           query = self.createFeatureQuery()
           query.setFilter( datamanager.createExpresion(expresion) )
           #self.fset = data.getFeatureSet(query)
           self.fset = self.getFeatureSet(query)
         return FeatureSet(self.fset)
       def features(self):
         data = self.getDataStore()
         fset = data.getFeatureSet()
         return FeatureSet(fset)
       def append(self, **values):
       def edit(self):
         """
         Set layer data store in edition mode
         """
         if not self.isEditing():
             self().edit()
       def append(self, *valuesList, **values):
         """
         Create a new feature from given values and insert it in the feature set
           :param values: dictionary with name property value or list named params
           :type values: dict
         """
         try:
           data = self.getDataStore()
           if not data.isEditing():
             data.edit()
           f = self.getFeatureStore().createNewFeature()
           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)
             data.insert(f)
             self.insert(f)
         except Throwable, ex:
           raise RuntimeException("Can't append values %s to layer %s (%s)" % (
             repr(values),
-...
+            )
+          )
       def updateSchema(self, schema):
         try:
           self().update(schema._javaobj)
         except Throwable, ex:
           raise RuntimeException(repr(ex))
       def update(self, feature):
         """
         Update exist feature in the layer featureSet
           :param editableFeature: editableFeature
           :type editableFeature: Java editableFeature
         """
         #fset = self.data.getFeatureSet()
         #fset.update(editableFeature)
         if not isinstance(feature, EditableFeature):
           feature = feature._javaobj
         self.fset.update(feature)
       def getSchema(self):
         """
         Return layer schema definition
         """
         return Schema(self.getDefaultFeatureType())
       def commit(self):
         data = self.getDataStore()
         data.finishEditing()
         """
         Finish layer edition
         """
         try:
           self.finishEditing()
         except Throwable, ex:
           self.abort()
           raise Throwable("Can't finish layer edition, cancelling changes. %s" % repr(ex))
       def abort(self):
         data = self.getDataStore()
         data.cancelEditing()
         """
         Cancel layer edition
         """
         #data = self.getDataStore()
         self.cancelEditing()
         self.dispose()
       def getSelection(self):
         data = self.getDataStore()
         return data.getSelection()
         """
         Return layer feature selected set
         """
         return self().getSelection()
     class __DefaultTable__(WrapperToJava):
       def __init__(self,document, data):
         self.data = Store(data)
         WrapperToJava.__init__(self,document)
       def features(self, expresion = None):
         """
         Return table features set
             :param expresion: filter to apply to the feature set to select
     determinates features that match with expression
             :type expresion: string
             :return: FeatureSet
         """
         return self.data.features(expresion = None)
       def edit(self):
         """
         Set layer data store in edition mode
         """
         self.data.edit()
       def append(self, *valuesList, **values):
         """
         Create a new feature from given values and insert it in the feature set
           :param values: dictionary with name property value or list named params
           :type values: dict
         """
         self.data.append(*valuesList, **values)
       def updateSchema(self, schema):
         self.data.updateSchema(schema)
       def update(self, feature):
         """
         Update exist feature in the layer featureSet
           :param editableFeature: editableFeature
           :type editableFeature: Java editableFeature
         """
         self.data.update(feature)
       def getSchema(self):
         """
         Return layer schema definition
         """
         return self.data.getSchema()
       def commit(self):
         """
         Finish layer edition
         """
         self.data.commit()
       def abort(self):
         """
         Cancel layer edition
         """
         self.data.abort()
       def getSelection(self):
         """
         Return layer feature selected set
         """
         return self.data.getSelection()
     class Table(__DefaultTable__):
       """
       Represents gvsig layer document
       """
       def __init__(self,table):
         __DefaultTable__.__init__(self, table, table.getStore())
     class Layer(__DefaultTable__):
       """
       Represents gvsig layer document
       """
       def __init__(self,layer):
         __DefaultTable__.__init__(self, layer, layer.getFeatureStore())
         #WrapperToJava.__init__(self,layer)
     class FeatureSet(WrapperToJava):
       def __init__(self,featureSet):
         WrapperToJava.__init__(self,featureSet)
       def getCount(self):
         return self.getSize()
       def update(self, feature):
         """
         Update exist feature in the featureSet
           :param editableFeature: editableFeature
           :type editableFeature: Java editableFeature
         """
         #FIXME
         if not isinstance(feature, EditableFeature) and \
         feature.__class__ != "org.gvsig.fmap.dal.feature.impl.DefaultEditableFeature":
           feature = feature._javaobj
         self().update(feature)
       def __iter__(self):
         return  Iterator(self.fastIterator())
     class Iterator(WrapperToJava):
       def __init__(self,iterator):
-...
         return Feature(self().next())
     class Feature(WrapperToJava):
       """
       Represents layer feature data
       """
       def __init__(self,feature):
         WrapperToJava.__init__(self,feature)
         self.featureNoEditable = None
       def geometry(self):
         """
         Return feature default geometry
         """
         return self.getDefaultGeometry()
       def getValues(self):
         """
         Return dictionary with name value 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):
         """
         Return editable feature
         """
         if not isinstance(self._javaobj, EditableFeature):
           self.featureNoEditable = self._javaobj
           self._javaobj = self._javaobj.getEditable()
         #return self.getEditable()
       def __getitem__(self,key):
         return self.get(key)
-...
         try:
           v = getattr(self._javaobj,name, None)
           if v == None:
             v = self().get(name)
             v = self().get(name)
           return v
         except Throwable, ex:
           raise RuntimeException("Can't access to attribute %s of feature (%s)" % (name, str(ex)))
           raise RuntimeException("Can't access to attribute %s of feature (%s)" % (name, str(ex)))
     class Schema(WrapperToJava):
       """
       Layer feature definition
       """
       def __init__(self, featureType):
         WrapperToJava.__init__(self,featureType)
         self.featureTypeNoEditable = None
       def append(self, name, type, size=None):
         application = ApplicationLocator.getManager()
         datamanager =  application.getDataManager()
         dataTypes = application.getDataTypesManager()
         type = dataTypes.get( dataTypes.getType(type) )
       def append(self, name, type, size=None, default=None, precision=4):
         """
         Adds property to feature properties definition.
             :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()
           #self.featureTypeNoEditable = self._javaobj
           #self._javaobj = self._javaobj.getEditable()
         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:
         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)
-...
         if x == None:
           return default
         return x
     def createSchema():
       def modify(self):
         #FIXME comprobar si es un DefaultFeatureType
         if not isinstance(self._javaobj, EditableFeatureType):
           self.featureTypeNoEditable = self._javaobj
           self._javaobj = self._javaobj.getEditable()
     def createSchema(schema = None):
       """
       Return empty layer definition
       """
       if schema != None:
         return Schema(schema.getCopy())
       application = ApplicationLocator.getManager()
       datamanager =  application.getDataManager()
       return Schema(datamanager.createFeatureType())
     def copyToDynObject(values, target):
       definition = target.getDynClass();
       fields = definition.getDynFields();
       for field in fields:
         name = field.getName()
         #FIXME: Esta comparacion deberia ser case insensitibe
         if values.has_key(name):
           #print "set %s = %s (%s)" % (name, values[name], target)
           target.setDynValue(name, values[name])
     def createLayer(schema, servertype, layertype=None, **parameters):
       """ Create a new layer and return it """
       """
       Create a new layer and return it
           :param schema: layer data definition
           :type schema: Schema
           :param servertype:
           :type servertype: string
           :return: new layer
           :rtype: Layer
           :raise: RuntimeException
       """
       if layertype == None:
         layertype = servertype
         servertype = "FilesystemExplorer"
-...
       if layertype == "Shape" :
         if schema.get("GEOMETRY",None) == None:
           raise RuntimeException("Shape need a field named GEOMETRY in the schema")
       #parameters["geometryType"] = getGeometryType(parameters["geometryType"])
       if parameters["geometryType"] == None:
         raise RuntimeException("Invalid geometry type for new layer")
       try:
         application = ApplicationLocator.getManager()
         datamanager =  application.getDataManager()
-...
       except Throwable, ex:
         raise RuntimeException("Can't create layer, "+ str(ex))
     def createShape(definition, filename, CRS="wsg86"):
       """ Create a new shape layer """
       return createLayer(definition, "FilesystemExplorer", "Shape", shpFile=filename, CRS=CRS)
     def createShape(definition, filename, geometryType, CRS="wsg86"):
       """
       Create a new shape layer
           :param definition: layer data definition
           :type definition: Schema
           :param filename: absolute path for shape files.
           :type filename: string
           :param geometryType: geometry type for shape
           :type geometryType: string
           :return: new shape layer
           :rtype: Layer
       """
       return createLayer(
         definition,
         "FilesystemExplorer",
         "Shape",
         shpFile=filename,
         CRS=CRS,
         geometryType = geometryType
+      )
     def createTable(schema, servertype, tableType=None, **parameters):
       if tableType == None:
         tableType = servertype
         servertype = "FilesystemExplorer"
       try:
         application = ApplicationLocator.getManager()
         datamanager =  application.getDataManager()
         server_parameters = datamanager.createServerExplorerParameters(servertype)
         copyToDynObject(parameters, server_parameters)
         server = datamanager.openServerExplorer(servertype, server_parameters)
         store_parameters = server.getAddParameters(tableType)
         copyToDynObject(parameters, store_parameters)
         store_parameters.setDefaultFeatureType(schema())
         server.add(tableType, store_parameters, True)
         store = datamanager.openStore(tableType, store_parameters)
         return Table(store)
       except Throwable, ex:
         raise RuntimeException("Can't create table, "+ str(ex))
     def createDBF(definition, DbfFile, CRS="wsg86"):
       """
       Create a new shape layer
           :param definition: layer data definition
           :type definition: Schema
           :param DbfFile: absolute path for shape files.
           :type DbfFile: string
           :param geometryType: geometry type for shape
           :type geometryType: string
           :return: new shape layer
           :rtype: Layer
       """
       return createTable(
         definition,
         "FilesystemExplorer",
         "DBF",
         DbfFile=DbfFile,
         CRS=CRS,
+      )
     def currentProject():
       """ Return the current proyect of gvSIG """
       """
       Return the current gvSIG proyect
         :return: Proyect
       """
       application = ApplicationLocator.getManager()
       project = application.getCurrentProject()
       return Project(project)
     def currentView():
       """ Return the current active view document or None """
     def currentDocument():
       """
       Return the current active document if it's a DocumentTable or DocumentView2D
         :return: Active document, None
       """
       application = ApplicationLocator.getManager()
       doc = application.getActiveDocument()
       return View(doc)
       if doc.getTypeName() == "project.document.table":
         return Table(doc)
       if doc.getTypeName() == "project.document.view2d":
         return View(doc)
       return None
     def currentView():
       """
       Return the current active view document or None
         :return: View or None
       """
       return View(currentProject().getView())
     def currentLayer():
       """ Return the first active layer of the current view """
       """
       Return current view active layer
         :return: gvSIG active layer
       """
       return currentView().getLayer()
     def SimplePointSymbol(color):
       """
       Return simple point symbol using parameter color
         :param color: Color name
         :return: gvSIG point symbol
       """
       return MapContextLocator.getSymbolManager().createSymbol(Geometry.TYPES.POINT, color)
+    #
     def SimpleLineSymbol(color):
       """
       Return simple line symbol using parameter color
         :param color: Color name
         :return: gvSIG line symbol
       """
       return MapContextLocator.getSymbolManager().createSymbol(Geometry.TYPES.CURVE, color)
     def SimplePoligonSymbol(color):
       """
       Return simple poligon symbol using parameter color
         :param color: Color name
         :return: gvSIG poligon symbol
       """
       return MapContextLocator.getSymbolManager().createSymbol(Geometry.TYPES.SURFACE, color)
     def copyToDynObject(values, target):
       definition = target.getDynClass();
       fields = definition.getDynFields();
       for field in fields:
         name = field.getName()
         keys = values.keys()
         for k in keys:
           if k.lower() == name.lower():
             target.setDynValue(name, values[name])
             break#
     # ====================================
+    #
-...
+      )
       for feature in layer.features():
           point = feature.geometry().centroid()
           #output.append(ID=feature.CODIGO, GEOMETRY=point)
           output.append(ID=feature.ID, GEOMETRY=point)
           #print feature.CODIGO, point
           print feature.ID, point
         point = feature.geometry().centroid()
         output.append(ID=feature.ID, GEOMETRY=point)
       output.commit()
       currentView().addLayer(output())
     def main2():
       layer = currentLayer()
       for feature in layer.features():
         if feature.TIPO == "COPUT":
           layer.getFeatureStore().getSelection().add(feature)
       currentView().addLayer(output())

Also available in: Unified diff

Application: gvSIG desktop » gvSIG scripting

Revision 362 org.gvsig.scripting.app/trunk/org.gvsig.scripting.app/org.gvsig.scripting.app.extension/src/main/resources/scripting/lib/gvsig.py