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

gvsig-scripting / org.gvsig.scripting.app / trunk / org.gvsig.scripting.app / org.gvsig.scripting.app.extension / src / main / resources / scripting / lib / gvsig.py @ 404

History | View | Annotate | Download (26.9 KB)

-            jjdelcerro
+# -*- coding: utf-8 -*-
+#
 # File: gvsig.py
+#
 # Copyright (c) 2011 by Model Driven Development sl and Antonio Carrasco Valero
+#
 # GNU General Public License (GPL)
+#
 # 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 2
 # 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.
+#
+#
-            vacevedo
+"""
 This module contains classes and functions to manage gvSIG Project,
 gvSIG DocumentView, gvSIG TableDocument and Layers.
 """
-            jjdelcerro
+__author__ = """Antonio Carrasco Valero
 Model Driven Development sl and Antonio Carrasco Valero
-            vacevedo
+<carrasco@modeldd.org>
-            vacevedo
+Victor Acevedo Royer <vacevedor@gvsig.com>, <vacevedor@gmail.com>
-            vacevedo
+"""
-            jjdelcerro
+__docformat__ = 'plaintext'
-            vacevedo
+from java.awt import Color
             jjdelcerro
 from java.lang import RuntimeException
 from java.lang import Throwable
-            vacevedo
+from java.util.prefs import Preferences
-            jjdelcerro
+from org.gvsig.app import ApplicationLocator
-            vacevedo
+from org.gvsig.app.project.documents.view import ViewDocument
-            vacevedo
+from org.gvsig.app.project.documents.table import TableDocument
             jjdelcerro
-            vacevedo
+from org.gvsig.fmap.mapcontext import MapContextLocator
 from org.gvsig.fmap.mapcontext.layers import FLayers
 from org.gvsig.fmap.dal import DALLocator, DataTypes
-            vacevedo
+from org.gvsig.fmap.dal.feature import EditableFeature,  EditableFeatureType, FeatureQueryOrder
 from org.gvsig.fmap.dal.feature.impl import DefaultEditableFeature
             jjdelcerro
 from org.gvsig.tools import ToolsLocator
-            vacevedo
+from org.gvsig.fmap.geom import Geometry
             jjdelcerro
 import thread
-            vacevedo
+import random
             jjdelcerro
             vacevedo
-            jjdelcerro
+def runTask(name, function, *args):
   manager = ToolsLocator.getTaskStatusManager()
   status = manager.createDefaultSimpleTaskStatus(name)
   status.add()
   args = list(args)
   args.append(status)
   try:
     thread.start_new_thread(function, tuple(args))
     status.terminate()
   except Exception,e:
     status.abort()
     raise e
 class WrapperToJava(object):
-            vacevedo
+  """
   Create a wrapper that allows python object access to the Java object
   properties and methods
   """
-            jjdelcerro
+  def __init__(self, javaobj):
     if javaobj == None:
       raise RuntimeException("Can't create "+ self.__class__.__name__)
     self._javaobj = javaobj
   def __call__(self):
     return self._javaobj
   def __getattr__(self,name):
     return getattr(self._javaobj,name)
 class Project(WrapperToJava):
-            vacevedo
+  """
   Represents a gvSIG project
   """
   def __init__(self, project):
     WrapperToJava.__init__(self, project)
-            jjdelcerro
+  def getView(self, name=None):
-            vacevedo
+    """
     Return active view, or view called 'name'  or None
       :param name: view name
       :type name: string
     """
-            jjdelcerro
+    if name == None:
-            vacevedo
+      try:
         activeDocument = self.getActiveDocument()
-            vacevedo
+        if activeDocument == None:
             return None
         if isinstance(activeDocument, ViewDocument):
             return View(activeDocument)
-            vacevedo
+      except Exception, ex:
         raise Exception("%s"%repr(ex))
     else:
       views = self.getViews()
       if len(views) >0:
         for view in views:
           if name == view.getName():
-            vacevedo
+            return View(view)
             jjdelcerro
-            vacevedo
+    return None
             vacevedo
   def getTable(self, name=None):
     """
     Return active Table Document, or Table Document called 'name'  or None
       :param name: Table Document name
       :type name: string
     """
     if name == None:
       try:
         activeDocument = self.getActiveDocument()
-            vacevedo
+        if activeDocument == None:
             return None
         if isinstance(activeDocument, TableDocument):
             return Table(activeDocument)
-            vacevedo
+      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():
-            vacevedo
+            return Table(table)
             vacevedo
-            vacevedo
+    return None
             vacevedo
             vacevedo
-            vacevedo
+  def getProjectionCode(self):
     return self.getProjection().getFullCode()
             jjdelcerro
 class View(WrapperToJava):
-            vacevedo
+  """
   Represents gvSIG view document.
   """
-            jjdelcerro
+  def __init__(self,view):
     WrapperToJava.__init__(self,view)
             vacevedo
-            jjdelcerro
+  def getLayer(self, name=None):
-            vacevedo
+    """
     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();
-            jjdelcerro
+    if name == None:
       activeLayers = map.getLayers().getActives()
       if len(activeLayers) != 1 :
         raise RuntimeException("The view has not an active layer")
-            vacevedo
+      for layer in activeLayers:
         if not isinstance(layer, FLayers):
           return Layer(layer)
       raise RuntimeException("The view has not an active layer")
             jjdelcerro
-            vacevedo
+    ls = self.getLayers()
     for i in xrange(ls.getLayersCount()):
       l = ls.getLayer(i)
       if l.name == name:
-            jjdelcerro
+        return Layer(l)
-            vacevedo
+    return None
             jjdelcerro
   def getMap(self):
-            vacevedo
+    """
     Return view mapContext
     """
-            jjdelcerro
+    return self.getMapContext();
   def addLayer(self, layer):
-            vacevedo
+    if isinstance(layer, Layer):
       layer =layer()
-            jjdelcerro
+    self.getMapContext().getLayers().addLayer(layer)
   def getLayers(self):
-            vacevedo
+    """
     Return iterable view layers set
     """
-            jjdelcerro
+    map = self.getMapContext();
     return Layers(map.getLayers())
   def getGraphicsLayer(self):
-            vacevedo
+    """
     Return view graphics layer
     """
-            jjdelcerro
+    return self.getMapContext().getGraphicsLayer()
-            vacevedo
+  def getProjectionCode(self):
     return self.getProjection().getFullCode()
-            jjdelcerro
+class Layers(WrapperToJava):
-            vacevedo
+  """
   Iterable layers set
   """
-            jjdelcerro
+  def __init__(self,layers):
     WrapperToJava.__init__(self, layers)
   def __len__(self):
     return self.getLayersCount()
   def __getitem__(self, index):
     return self.getLayer(index)
   def __iter__(self):
     return LayersIterator(self)
 class LayersIterator(object):
   def __init__(self,layers):
     self.__layers = layers
-            vacevedo
+    self.__index = -1
             jjdelcerro
   def next(self):
-            vacevedo
+    self.__index+=1
     if self.__index >= self.__layers.getLayersCount() :
-            jjdelcerro
+      raise StopIteration()
-            vacevedo
+    return Layer(self.__layers.getLayer(self.__index))
             vacevedo
 class Store(WrapperToJava):
   """
   Represents gvsig store
   """
   def __init__(self,store):
     WrapperToJava.__init__(self, store)
     #self.data = None
     self.fset = None
-            vacevedo
+  def features(self, expresion = None, sortBy="", asc=True):
-            vacevedo
+    """
-            vacevedo
+    Return layer features set (FeatureSet)
             jjdelcerro
-            vacevedo
+        :param expresion: filter to apply to the feature set to select
 determinates features that match with expression
         :type expresion: string
-            vacevedo
+        :param sortBy: name of attribute to sort
         :type sortby: string
         :param: asc: order
         :type asc: boolean
-            vacevedo
+        :return: FeatureSet
     """
-            vacevedo
+    if expresion == None and sortBy =="":
-            vacevedo
+      self.fset = self.getFeatureSet()
     else:
       application = ApplicationLocator.getManager()
       datamanager =  application.getDataManager()
       query = self.createFeatureQuery()
-            vacevedo
+      if sortBy != "":
         order = FeatureQueryOrder()
         order.add(sortBy, asc)
         query.setOrder(order)
       if expresion != None:
         query.setFilter(datamanager.createExpresion(expresion))
-            vacevedo
+      #self.fset = data.getFeatureSet(query)
       self.fset = self.getFeatureSet(query)
-            vacevedo
+    return FeatureSet(self.fset)
             jjdelcerro
-            vacevedo
+  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
     """
-            jjdelcerro
+    try:
-            vacevedo
+      if len(valuesList) ==1:
         values.update(valuesList[0])
       if not self.isEditing():
         self.edit()
       f = self.createNewFeature()
-            jjdelcerro
+      if f == None:
         raise RuntimeError("Failed to create a new Feature")
       for k,v in values.iteritems():
         f.set(k,v)
-            vacevedo
+        self.insert(f)
-            jjdelcerro
+    except Throwable, ex:
       raise RuntimeException("Can't append values %s to layer %s (%s)" % (
         repr(values),
         self.getName(),
         str(ex)
+        )
+      )
-            vacevedo
+  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
     """
     if not isinstance(feature, EditableFeature):
       feature = feature._javaobj
     self.fset.update(feature)
   def getSchema(self):
     """
     Return layer schema definition
     """
     return Schema(self.getDefaultFeatureType())
-            jjdelcerro
+  def commit(self):
-            vacevedo
+    """
     Finish layer edition
     """
     try:
       self.finishEditing()
     except Throwable, ex:
       self.abort()
       raise Throwable("Can't finish layer edition, cancelling changes. %s" % repr(ex))
             jjdelcerro
   def abort(self):
-            vacevedo
+    """
     Cancel layer edition
     """
     self.cancelEditing()
     self.dispose()
             jjdelcerro
   def getSelection(self):
-            vacevedo
+    """
     Return layer feature selected set
     """
-            vacevedo
+    return FeatureSet(self().getSelection())
             vacevedo
 class __DefaultTable__(WrapperToJava):
   def __init__(self,document, data):
     self.data = Store(data)
     WrapperToJava.__init__(self,document)
-            vacevedo
+    self.selection = None
             vacevedo
-            vacevedo
+  def features(self, expresion = None, sortBy="", asc=True):
-            vacevedo
+    """
-            vacevedo
+    Return data features set
             jjdelcerro
-            vacevedo
+        :param expresion: filter to apply to the feature set to select
 determinates features that match with expression
         :type expresion: string
         :return: FeatureSet
     """
-            vacevedo
+    return self.data.features(expresion, sortBy, asc)
             vacevedo
   def edit(self):
     """
-            vacevedo
+    Set data in edition mode
-            vacevedo
+    """
     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):
-            vacevedo
+    """
     Update data schema definition with the given schema
     """
-            vacevedo
+    self.data.updateSchema(schema)
   def update(self, feature):
     """
-            vacevedo
+    Update exist feature in the featureSet
             vacevedo
       :param editableFeature: editableFeature
       :type editableFeature: Java editableFeature
     """
     self.data.update(feature)
   def getSchema(self):
     """
-            vacevedo
+    Return schema definition
-            vacevedo
+    """
     return self.data.getSchema()
   def commit(self):
     """
-            vacevedo
+    Finish edition
-            vacevedo
+    """
     self.data.commit()
   def abort(self):
     """
-            vacevedo
+    Cancel edition
-            vacevedo
+    """
     self.data.abort()
   def getSelection(self):
     """
-            vacevedo
+    Return features selected set
-            vacevedo
+    """
-            vacevedo
+    if self.selection == None:
       self.selection = self.data.getSelection()
     return self.selection
             vacevedo
-            vacevedo
+  def select(self, selection):
     """
     Insert features in the features selection set
     """
     if isinstance(selection,Feature) or isinstance(selection, FeatureSet):
       self.data.getSelection().select(selection._javaobj)
     else:
       self.data.getSelection().select(selection)
   def deselect(self, selection):
     """
     Remove features in the features selection set
     """
     if isinstance(selection,Feature) or isinstance(selection, FeatureSet):
       self.data.getSelection().deselect(selection._javaobj)
     else:
       self.data.getSelection().deselect(selection)
   def isSelected(feature):
     """
     Returns if feature is selected
     """
     if isinstance(feature, Feature):
       self.data.getSelection().deselect(feature._javaobj)
     else:
       self.data.getSelection().deselect(feature)
-            vacevedo
+  def getProjectionCode(self):
     """
     Return layer projection code
     """
     return self.getProjection().getFullCode()
             vacevedo
             vacevedo
-            vacevedo
+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)
             vacevedo
   def getTypeVectorLayer(self):
     return self().getTypeVectorLayer()
             vacevedo
-            jjdelcerro
+class FeatureSet(WrapperToJava):
   def __init__(self,featureSet):
     WrapperToJava.__init__(self,featureSet)
             vacevedo
   def getCount(self):
     return self.getSize()
   def update(self, feature):
     """
     Update exist feature in the featureSet
       :param editableFeature: editableFeature
       :type editableFeature: Java editableFeature
     """
     #FIXME
-            vacevedo
+    if not isinstance(feature, EditableFeature) and not isinstance(feature, DefaultEditableFeature):
-            vacevedo
+      feature = feature._javaobj
     self().update(feature)
-            jjdelcerro
+  def __iter__(self):
     return  Iterator(self.fastIterator())
             vacevedo
-            jjdelcerro
+class Iterator(WrapperToJava):
   def __init__(self,iterator):
     WrapperToJava.__init__(self,iterator)
   def next(self):
     if not self.hasNext():
       raise StopIteration()
     return Feature(self().next())
 class Feature(WrapperToJava):
-            vacevedo
+  """
   Represents layer feature data
   """
-            jjdelcerro
+  def __init__(self,feature):
     WrapperToJava.__init__(self,feature)
-            vacevedo
+    self.featureNoEditable = None
             jjdelcerro
   def geometry(self):
-            vacevedo
+    """
     Return feature default geometry
     """
-            jjdelcerro
+    return self.getDefaultGeometry()
             vacevedo
   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
             jjdelcerro
-            vacevedo
+  def edit(self):
     """
     Return editable feature
     """
     if not isinstance(self._javaobj, EditableFeature):
       self.featureNoEditable = self._javaobj
       self._javaobj = self._javaobj.getEditable()
-            jjdelcerro
+  def __getitem__(self,key):
     return self.get(key)
   def __getattr__(self,name):
             vacevedo
     #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().items()
-            jjdelcerro
+    try:
-            vacevedo
+      v = getattr(self._javaobj, name, None)
-            jjdelcerro
+      if v == None:
-            vacevedo
+        v = self().get(name)
-            jjdelcerro
+      return v
     except Throwable, ex:
-            vacevedo
+      raise RuntimeException("Can't access to attribute %s of feature (%s)" % (name, str(ex)))
             jjdelcerro
 class Schema(WrapperToJava):
-            vacevedo
+  """
   Layer feature definition
   """
             jjdelcerro
   def __init__(self, featureType):
     WrapperToJava.__init__(self,featureType)
-            vacevedo
+    self.featureTypeNoEditable = None
             jjdelcerro
-            vacevedo
+  def append(self, name, type, size=None, default=None, precision=4):
     """
     Adds property to feature properties definition.
             jjdelcerro
-            vacevedo
+        :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
+            )
+        )
-            jjdelcerro
+    attribute = self.add(name, type.getType())
             vacevedo
     if size != None:
-            jjdelcerro
+      attribute.setSize(size)
             vacevedo
     if default != None:
       attribute.setDefaultValue(default)
     if precision != None and type.getType() in (DataTypes.DOUBLE, DataTypes.FLOAT):
       attribute.setPrecision(precision)
-            jjdelcerro
+    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):
-            vacevedo
+    """
     Return a feature attribute descriptor that contains information about
     one of the attributes in a feature, 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
     """
-            jjdelcerro
+    x = self.getAttributeDescriptor(name)
     if x == None:
       return default
     return x
             vacevedo
-            vacevedo
+  def getAttrNames(self):
-            vacevedo
+    """
-            vacevedo
+    Return list with definition schema atribute names
-            vacevedo
+    """
-            vacevedo
+    names = list(attr.getName() for attr in self.getAttributeDescriptors())
     return names
             vacevedo
   def getCopy(self):
     return Schema(self().getCopy())
-            vacevedo
+  def modify(self):
     if not isinstance(self._javaobj, EditableFeatureType):
       self.featureTypeNoEditable = self._javaobj
       self._javaobj = self._javaobj.getEditable()
             vacevedo
 #=====================#
 # Vectorial Functions #
 #=====================#
-            vacevedo
+def createSchema(schema = None):
   """
   Return empty layer definition
   """
   if schema != None:
-            vacevedo
+    s = schema.getCopy()
     s.modify()
     return s
             vacevedo
-            jjdelcerro
+  application = ApplicationLocator.getManager()
   datamanager =  application.getDataManager()
   return Schema(datamanager.createFeatureType())
 def createLayer(schema, servertype, layertype=None, **parameters):
-            vacevedo
+  """
   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
   """
-            jjdelcerro
+  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")
             vacevedo
   #parameters["geometryType"] = getGeometryType(parameters["geometryType"])
   if parameters["geometryType"] == None:
     raise RuntimeException("Invalid geometry type for new layer")
-            jjdelcerro
+  try:
     application = ApplicationLocator.getManager()
     datamanager =  application.getDataManager()
     mapcontextmanager = application.getMapContextManager()
     server_parameters = datamanager.createServerExplorerParameters(servertype)
     copyToDynObject(parameters, server_parameters)
     server = datamanager.openServerExplorer(servertype, server_parameters)
     store_parameters = server.getAddParameters(layertype)
     copyToDynObject(parameters, store_parameters)
     store_parameters.setDefaultFeatureType(schema())
     server.add(layertype, store_parameters, True)
     store = datamanager.openStore(layertype, store_parameters)
     layer = mapcontextmanager.createLayer(store.getName(), store)
     return Layer(layer)
   except Throwable, ex:
     raise RuntimeException("Can't create layer, "+ str(ex))
-            vacevedo
+def loadShapeFile(shpFile, CRS="wgs86"):
     """
     Add existing shape file to the view
     Return Layer
       :param shpFile: absolute file path
       :type: shpFile: string
       :param CRS: projection code
       :type CRS: string
       :return: the shape
       :type return: Layer
     """
     layer = loadLayer('Shape', shpFile=shpFile, CRS=CRS)
     currentView().addLayer(layer)
     return Layer(layer)
 def loadLayer(layerType, **parameters):
     try:
         application = ApplicationLocator.getManager()
         datamanager =  application.getDataManager()
         mapcontextmanager = application.getMapContextManager()
         store_parameters = datamanager.createStoreParameters(layerType)
         copyToDynObject(parameters, store_parameters)
         store = datamanager.openStore(layerType, store_parameters)
         layer = mapcontextmanager.createLayer(store.getName(), store)
         return layer
     except Throwable, ex:
         raise RuntimeException("Can't load layer, "+ str(ex))
-            vacevedo
+def createShape(definition, filename, geometryType, CRS="wgs86"):
-            vacevedo
+  """
   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)
             jjdelcerro
-            vacevedo
+  except Throwable, ex:
     raise RuntimeException("Can't create table, "+ str(ex))
 def createDBF(definition, DbfFile, CRS="wsg86"):
   """
-            vacevedo
+  Create a new dbf document
             vacevedo
       :param definition: layer data definition
       :type definition: Schema
       :param DbfFile: absolute path for shape files.
       :type DbfFile: string
-            vacevedo
+      :return: new dbf
       :rtype: Table
-            vacevedo
+  """
   return createTable(
     definition,
     "FilesystemExplorer",
     "DBF",
     DbfFile=DbfFile,
     CRS=CRS,
+  )
             vacevedo
 #=====================#
 # Documents Functions #
 #=====================#
-            jjdelcerro
+def currentProject():
-            vacevedo
+  """
   Return the current gvSIG proyect
     :return: Proyect
   """
-            jjdelcerro
+  application = ApplicationLocator.getManager()
   project = application.getCurrentProject()
   return Project(project)
-            vacevedo
+def currentDocument(documentClass = None):
-            vacevedo
+  """
   Return the current active document if it's a DocumentTable or DocumentView2D
     :return: Active document, None
   """
-            jjdelcerro
+  application = ApplicationLocator.getManager()
             vacevedo
-            vacevedo
+  if documentClass == None:
     doc = application.getActiveDocument()
   else:
     doc = application.getActiveDocument(documentClass)
   if isinstance(doc, TableDocument): #doc.getTypeName() == "project.document.table":
-            vacevedo
+    return Table(doc)
-            vacevedo
+  if isinstance(doc, ViewDocument): #doc.getTypeName() == "project.document.view2d":
-            vacevedo
+    return View(doc)
             jjdelcerro
-            vacevedo
+  return None
-            vacevedo
+def currentTable():
   """
   Return the current active table document or None
     :return: Table or None
   """
-            vacevedo
+  return currentDocument(TableDocument)
             vacevedo
-            vacevedo
+def currentView():
   """
   Return the current active view document or None
     :return: View or None
-            vacevedo
+  """
   return currentDocument(ViewDocument)
             vacevedo
-            jjdelcerro
+def currentLayer():
-            vacevedo
+  """
   Return current view active layer
     :return: gvSIG active layer
   """
-            jjdelcerro
+  return currentView().getLayer()
-            vacevedo
+#=====================#
 # Simbology Functions #
 #=====================#
-            vacevedo
+def simplePointSymbol(color=None):
-            jjdelcerro
+  """
-            vacevedo
+  Return simple point symbol using parameter color. If no color use a ramdom color
             vacevedo
-            vacevedo
+    :param color: Java awt Color
-            vacevedo
+    :return: gvSIG point symbol
-            jjdelcerro
+  """
-            vacevedo
+  if not isinstance(color, Color):
       color = getColor()
-            vacevedo
+  return MapContextLocator.getSymbolManager().createSymbol(Geometry.TYPES.POINT, color)
             jjdelcerro
-            vacevedo
+def simpleLineSymbol(color=None):
-            vacevedo
+  """
-            vacevedo
+  Return simple line symbol using parameter color. If no color use a ramdom color
             vacevedo
-            vacevedo
+    :param color: Java awt Color
-            vacevedo
+    :return: gvSIG line symbol
   """
-            vacevedo
+  if not isinstance(color, Color):
       color = getColor()
-            vacevedo
+  return MapContextLocator.getSymbolManager().createSymbol(Geometry.TYPES.CURVE, color)
             vacevedo
-            vacevedo
+def simplePolygonSymbol(color = None):
-            vacevedo
+  """
-            vacevedo
+  Return simple polygon symbol using parameter color. If no color use a ramdom color.
             vacevedo
-            vacevedo
+    :param color: Java awt Color
-            vacevedo
+    :return: gvSIG poligon symbol
   """
-            vacevedo
+  if not isinstance(color, Color):
       color = getColor()
             vacevedo
-            vacevedo
+  return MapContextLocator.getSymbolManager().createSymbol(Geometry.TYPES.SURFACE, color)
             vacevedo
             vacevedo
-            vacevedo
+#=========================================#
 # gvSIG Application Preferences Functions #
 #=========================================#
 def getDataFolder():
   """
   Return gvSIG data folder. This folder is defined in application preferences
   If not defined return None
   """
   return Preferences.userRoot().node("gvsig.foldering").get('DataFolder', None)
 def getProjectsFolder():
   """
   Return gvSIG projects folder. This folder is defined in application preferences.
   If not defined return None
   """
   return Preferences.userRoot().node("gvsig.foldering").get('ProjectsFolder', None)
             vacevedo
 def getColor():
   if MapContextLocator.getSymbolManager().isDefaultSymbolFillColorAleatory():
     color = Color(random.randint(0-255),
               random.randint(0-255),
               random.randint(0-255)
+            )
   else:
     color = MapContextLocator.getSymbolManager().getSymbolPreferences().getDefaultSymbolFillColor()
   return color
             vacevedo
-            vacevedo
+#================#
 # OTHER          #
 #================#
-            vacevedo
+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])
-            vacevedo
+        break
-            jjdelcerro
+# ====================================
+#
 def main():
   layer = currentLayer()
   schema = createSchema()
   schema.append("ID", "String", 50)
   schema.append("GEOMETRY", "Geometry")
   output = createLayer(
       schema,
       "FilesystemExplorer",
       "Shape",
       shpFile="/tmp/pp.shp",
       CRS="EPSG:23030",
-            vacevedo
+      geometryType=POINT
             jjdelcerro
   for feature in layer.features():
-            vacevedo
+    point = feature.geometry().centroid()
     output.append(ID=feature.ID, GEOMETRY=point)
-            jjdelcerro
+  output.commit()
-            vacevedo
+  currentView().addLayer(output())

Application: gvSIG desktop » gvSIG scripting

gvsig-scripting / org.gvsig.scripting.app / trunk / org.gvsig.scripting.app / org.gvsig.scripting.app.extension / src / main / resources / scripting / lib / gvsig.py @ 404