/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 424 org.gvsig.scripting.app/trunk/org.gvsig.scripting.app/org.gvsig.scripting.app.extension/src/main/resources/scripting/lib/gvsig.py

     """
     This module contains classes and functions to manage gvSIG Project,
     gvSIG DocumentView, gvSIG TableDocument and Layers.
     Also contais functions to manage vectorial data and other utility
     functions
     """
     __author__ = """Antonio Carrasco Valero
-...
     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, FeatureQueryOrder
     from org.gvsig.fmap.dal.feature import EditableFeature, \
         EditableFeatureType, FeatureQueryOrder
     from org.gvsig.fmap.dal.feature.impl import DefaultEditableFeature
     from org.gvsig.fmap.geom import Geometry
-...
     class WrapperToJava(object):
       """
       Create a wrapper that allows python object access to the Java object
       """Creates a wrapper that allows python object access to the Java object
       properties and methods
       """
       def __init__(self, javaobj):
-...
         return getattr(self._javaobj,name)
     class Project(WrapperToJava):
       """
       Represents a gvSIG project
       """
       """Represents a gvSIG project (org.gvsig.app.project.DefaultProject)"""
       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
         Returns active view, or view called 'name'  or None
         :param name: view name
         :type name: string
         """
         if name == None:
           try:
-...
       def getTable(self, name=None):
         """
         Return active Table Document, or Table Document called 'name'  or None
           :param name: Table Document name
           :type name: string
         Returns active Table Document, or Table Document called 'name'  or None
         :param name: Table Document name
         :type name: string
         """
         if name == None:
           try:
-...
         return None
       def getProjectionCode(self):
         """Returns Project projection code name string. This value is the
         projects default projection that is fixed in Preferences tool, View
         options. It's used when no view projection is defined.
         """
         return self.getProjection().getFullCode()
     class View(WrapperToJava):
       """
       Represents gvSIG view document.
       Represents gvSIG view document
       (org.gvsig.app.project.documents.view.DefaultViewDocument).
       """
       def __init__(self,view):
         WrapperToJava.__init__(self,view)
       def getLayer(self, name=None):
         """
         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
         Returns one view layer. If name is None returns active
         layer if the view has one, if name is not None returns layer called name
         else returns 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 None
           for layer in activeLayers:
             if not isinstance(layer, FLayers):
               return Layer(layer)
           #raise RuntimeException("The view has not an active layer")
           return None
         ls = self.getLayers()
-...
         return None
       def getMap(self):
         """
         Return view mapContext
         """
         # org.gvsig.fmap.mapcontext.MapContext
         """Returns view mapContext"""
         return self.getMapContext();
       def addLayer(self, layer):
         """
         Adds a new layer to the view
         :param layer: layer to add
         :type layer: Layer
         """
         if isinstance(layer, Layer):
           layer =layer()
         self.getMapContext().getLayers().addLayer(layer)
       def getLayers(self):
         """
         Return iterable view layers set
         """
         """Returns iterable view layers set"""
         map = self.getMapContext()
         return Layers(map.getLayers())
       def getGraphicsLayer(self):
         """Returns view graphics layer
         org.gvsig.fmap.mapcontext.layers.vectorial.impl.DefaultGraphicLayer
         """
         Return view graphics layer
         """
         return self.getMapContext().getGraphicsLayer()
       def getProjectionCode(self):
         """Returns string view projection code name"""
         return self.getProjection().getFullCode()
       def isProjected(self):
         """Returns if view projection is projected."""
         self.getProjection().isProjected():
     class Layers(WrapperToJava):
       """Iterable layers set
       (org.gvsig.fmap.mapcontext.layers.FLayers)
       """
       Iterable layers set
       """
       def __init__(self,layers):
         WrapperToJava.__init__(self, layers)
-...
         return Layer(self.__layers.getLayer(self.__index))
     class Store(WrapperToJava):
       """Represents gvsig store. It's used as Table/Layer objects store
       (org.gvsig.fmap.dal.feature.impl.DefaultFeatureStore)
       """
       Represents gvsig store
       """
       def __init__(self,store):
         WrapperToJava.__init__(self, store)
         #self.data = None
         self.fset = None
       def features(self, expresion = None, sortBy="", asc=True):
         """
         Return layer features set (FeatureSet)
             :param expresion: filter to apply to the feature set to select
         """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
         """
         :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:
           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 = data.getFeatureSet(query)
           self.fset = self.getFeatureSet(query)
           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 layer data store in edition mode
         """
         """Set 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
         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:
-...
+          )
       def updateSchema(self, schema):
         """
         Updates store FeatureType. If an error occurs raises
         RuntimeException.
         """
         try:
           self().update(schema._javaobj)
         except Throwable, ex:
-...
       def update(self, feature):
         """
         Update exist feature in the layer featureSet
         Updates exist feature in the layer featureSet
         :param editableFeature: editableFeature
         :type editableFeature: Java editableFeature
         """
         if not self.isEditing():
           self.edit()
           :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
         """
         """Returns store data attributtes"""
         return Schema(self.getDefaultFeatureType())
       def commit(self):
         """
         Finish layer edition
         Finish store edition saving changes. If an error occurs raises Throwable
         Exception.
         """
         try:
           self.finishEditing()
-...
           raise Throwable("Can't finish layer edition, cancelling changes. %s" % repr(ex))
       def abort(self):
         """
         Cancel layer edition
         """
         """Finish store edition withoout saving changes and disposes itself"""
         self.cancelEditing()
         self.dispose()
       def getSelection(self):
         """
         Return layer feature selected set
         """
         """Returns store features selected set"""
         return FeatureSet(self().getSelection())
     class __DefaultTable__(WrapperToJava):
-...
       def features(self, expresion = None, sortBy="", asc=True):
         """
         Return data features set
             :param expresion: filter to apply to the feature set to select
         Returns data features set
         :param expresion: filter to apply to the feature set to select
              determinates features that match with expression
             :type expresion: string
             :return: FeatureSet
         :type expresion: string
         :return: FeatureSet
         """
         return self.data.features(expresion, sortBy, asc)
       def edit(self):
         """
         Set data in edition mode
         """
         """Sets data 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
         Creates 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):
         """
         Update data schema definition with the given schema
         Updates data data attributes properties with the given schema
         """
         self.data.updateSchema(schema)
       def update(self, feature):
         """
         Update exist feature in the featureSet
           :param editableFeature: editableFeature
           :type editableFeature: Java editableFeature
         Updates exist feature in the featureSet with the given feature
         :param editableFeature: editableFeature
         :type editableFeature: Java editableFeature
         """
         self.data.update(feature)
       def getSchema(self):
         """
         Return schema definition
         """
         """Returns data attributes definition"""
         return self.data.getSchema()
       def commit(self):
         """
         Finish edition
         """
         """Finish edition saving changes"""
         self.data.commit()
       def abort(self):
         """
         Cancel edition
         """
         """Finish edition without saving changes"""
         self.data.abort()
       def getSelection(self):
         """
         Return features selected set
         """
         """Returns features selected set"""
         if self.selection == None:
           self.selection = self.data.getSelection()
           self.selection = Selection(self.data.getSelection())
         return self.selection
       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)
         """Inserts features in the features selection set"""
         self.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)
         """Remove features in the features selection set"""
         self.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)
         """Returns True if given feature is selected"""
         self.getSelection().isSelect(feature)
       def getProjectionCode(self):
         """
         Return layer projection code
         """
         """Returns projection code name"""
         return self.getProjection().getFullCode()
     class Table(__DefaultTable__):
       """Represents gvsig table document
       (org.gvsig.app.project.documents.table.TableDocument)
       """
       Represents gvsig layer document
       """
       def __init__(self,table):
         __DefaultTable__.__init__(self, table, table.getStore())
       def getAssociatedLayer(self):
         """Returns table associated layer or None if there're not associated
         layer
         """
         if self._javaobj.getAssociatedLayer():
           return Layer(self._javaobj.getAssociatedLayer())
         return None
     class Layer(__DefaultTable__):
       """Represents gvsig layer document. It's a wrapper from
       org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect class
       """
       Represents gvsig layer document
       """
       def __init__(self,layer):
         __DefaultTable__.__init__(self, layer, layer.getFeatureStore())
         #WrapperToJava.__init__(self,layer)
       def getTypeVectorLayer(self):
         """
         Returns layer DefaultGeometryType class
         To get the geometryType use DefaultGeometryType getType() method
         To get the geometrySubType use DefaultGeometryType getSubType() method
         """
         return self().getTypeVectorLayer()
     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):
         """
         Update exist feature in the featureSet
           :param editableFeature: editableFeature
           :type editableFeature: Java editableFeature
         Updates exist feature in the featureSet
         :param editableFeature: editableFeature
         :type editableFeature: Java editableFeature
         """
         if not isinstance(feature, EditableFeature) and not isinstance(feature, DefaultEditableFeature):
         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 Iterator(WrapperToJava):
       def __init__(self,iterator):
-...
         return Feature(self().next())
     class Feature(WrapperToJava):
       """Represents feature data It's a wrapper from gvSIG
       org.gvsig.fmap.dal.feature.impl.DefaultFeature class
       """
       Represents layer feature data
       """
       def __init__(self,feature):
         WrapperToJava.__init__(self,feature)
         self.featureNoEditable = None
       def geometry(self):
         """
         Return feature default geometry
         """
         """Returns feature geometry"""
         return self.getDefaultGeometry()
       def getValues(self):
         """
         Return dictionary with name value attributes
         """
         """Returns dictionary with the pair name, value, feature attributes"""
         descriptor = self.getType()
         items = dict()
         for attr in descriptor.getAttributeDescriptors():
-...
         return items
       def edit(self):
         """
         Return editable feature
         """
         """Returns editable feature instance"""
         if not isinstance(self._javaobj, EditableFeature):
           self.featureNoEditable = self._javaobj
           self._javaobj = self._javaobj.getEditable()
-...
           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)
       """
       Layer feature definition
       """
       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
         """
         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()
             self.modify()
         if isinstance(type, str):
           try:
-...
         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
         """
         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
         """
         x = self.getAttributeDescriptor(name)
         if x == None:
           return default
         return x
       def getAttrNames(self):
         """
         Return list with definition schema atribute names
         """
         names = list(attr.getName() for attr in self.getAttributeDescriptors())
         return names
         """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()
-...
     #=====================#
     def createSchema(schema = None):
       """Returns attributes definition. If Schema is recived then makes a copy and
       returns editable instance. Otherwise returns empty Schema.
       :param schema: Schema to make a copy
       :type schema: Schema
       """
       Return empty layer definition
       """
       if schema != None:
         s = schema.getCopy()
         s.modify()
         return s
       if isinstance(schema, Schema):
         try:
           s = schema.getCopy()
           s.modify()
           return s
         except:
           pass
       application = ApplicationLocator.getManager()
       datamanager =  application.getDataManager()
       return Schema(datamanager.createFeatureType())
     def createLayer(schema, servertype, layertype=None, **parameters):
       """
       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
       """
       Returns new layer
       :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")
-...
     def loadShapeFile(shpFile, CRS="CRS:84"):
         """
         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
         Add existing shape file to the view. Returns Layer shape file
         :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 currentView().getLayer(layer.getName())
         layer.setActive(True)
         return Layer(layer)
-...
         return layer
     def createShape(definition, filename, geometryType, CRS="CRS:84"):
       """
       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 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",
-...
+      )
     def createTable(schema, servertype, tableType=None, **parameters):
       """Creates a new Table document"""
       if tableType == None:
         tableType = servertype
         servertype = "FilesystemExplorer"
-...
       except Throwable, ex:
         raise RuntimeException("Can't create table, "+ str(ex))
     def createDBF(definition, DbfFile, CRS="wsg86"):
       """
       Create a new dbf document
           :param definition: layer data definition
           :type definition: Schema
           :param DbfFile: absolute path for shape files.
           :type DbfFile: string
           :return: new dbf
           :rtype: Table
     def createDBF(definition, DbfFile, CRS="CRS:84"):
       """
       Creates a new dbf document
       :param definition: layer data definition
       :type definition: Schema
       :param DbfFile: absolute path for shape files.
       :type DbfFile: string
       :return: new dbf
       :rtype: Table
       """
       return createTable(
         definition,
         "FilesystemExplorer",
-...
     def currentProject():
       """
       Return the current gvSIG proyect
         :return: Proyect
       Returns current gvSIG proyect
       :return: Proyect
       """
       application = ApplicationLocator.getManager()
       project = application.getCurrentProject()
       return Project(project)
     def currentDocument(documentClass = None):
       """
       Return the current active document if it's a DocumentTable or DocumentView2D
         :return: Active document, None
       Returns the current active document if it's a DocumentTable or
       DocumentView2D return None
       :return: Active document, None
       """
       application = ApplicationLocator.getManager()
       if documentClass == None:
         doc = application.getActiveDocument()
       else:
         doc = application.getActiveDocument(documentClass)
       if isinstance(doc, TableDocument): #doc.getTypeName() == "project.document.table":
       if isinstance(doc, TableDocument):
         return Table(doc)
       if isinstance(doc, ViewDocument): #doc.getTypeName() == "project.document.view2d":
       if isinstance(doc, ViewDocument):
         return View(doc)
       return None
     def currentTable():
       """
       Return the current active table document or None
         :return: Table or None
       Returns active table document or None
       :return: Table or None
       """
       return currentDocument(TableDocument)
     def currentView():
       """
       Return the current active view document or None
         :return: View or None
       Returns the current active view document or None
       :return: View or None
       """
       return currentDocument(ViewDocument)
     def currentLayer():
       """
       Return current view active layer
         :return: gvSIG active layer
       """
       Returns current view active layer or None
       :return: gvSIG active layer
       """
       try:
         return currentView().getLayer()
       except:
-...
     #=====================#
     # Simbology Functions #
     #=====================#
     COLORS = {
         'black': Color.black,
         'blue': Color.blue,
         'cyan': Color.cyan,
         'darkGray': Color.darkGray,
         'gray': Color.gray,
         'green': Color.green,
         'lightGray': Color.lightGray,
         'magenta': Color.magenta,
         'orange': Color.orange,
         'pink': Color.pink,
         'red': Color.red,
         'white': Color.white,
         'yellow': Color.yellow,
+    }
     def simplePointSymbol(color=None):
       """
       Return simple point symbol using parameter color. If no color use a ramdom color
         :param color: Java awt Color
         :return: gvSIG point symbol
       Returns simple point symbol using parameter color. If no color
       use a ramdom color
       :param color: String color name or Java awt Color
       :return: gvSIG point symbol
       """
       if isinstance(color, str) and COLORS.has_key(color.lower()):
         color = COLORS.get(color)
       if not isinstance(color, Color):
           color = getColor()
           color = getDefaultColor()
       return MapContextLocator.getSymbolManager().createSymbol(Geometry.TYPES.POINT, color)
       return MapContextLocator.getSymbolManager().createSymbol(
             Geometry.TYPES.POINT, color)
     def simpleLineSymbol(color=None):
       """
       Return simple line symbol using parameter color. If no color use a ramdom color
       Returns simple line symbol using parameter color. If no color use a
       ramdom color
       :param color: String color name or Java awt Color
       :return: gvSIG line symbol
         :param color: Java awt Color
         :return: gvSIG line symbol
       """
       if isinstance(color, str) and COLORS.has_key(color.lower()):
         color = COLORS.get(color)
       if not isinstance(color, Color):
           color = getColor()
           color = getDefaultColor()
       return MapContextLocator.getSymbolManager().createSymbol(Geometry.TYPES.CURVE, color)
       return MapContextLocator.getSymbolManager().createSymbol(
             Geometry.TYPES.CURVE, color)
     def simplePolygonSymbol(color = None):
       """
       Return simple polygon symbol using parameter color. If no color use a ramdom color.
         :param color: Java awt Color
         :return: gvSIG poligon symbol
       Returns simple polygon symbol using parameter color. If no color
       use a ramdom color.
       :param color: String color name or Java awt Color
       :return: gvSIG polygon symbol
       """
       if isinstance(color, str) and COLORS.has_key(color.lower()):
         color = COLORS.get(color)
       if not isinstance(color, Color):
           color = getColor()
           color = getDefaultColor()
       return MapContextLocator.getSymbolManager().createSymbol(Geometry.TYPES.SURFACE, color)
       return MapContextLocator.getSymbolManager().createSymbol(
             Geometry.TYPES.SURFACE, color)
     #=========================================#
-...
     def getDataFolder():
       """
       Return gvSIG data folder. This folder is defined in application preferences
       If not defined return None
       Returns gvSIG data folder. This folder is defined in application
       preferences. If is not defined returns 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
       Returns gvSIG projects folder. This folder is defined in application
       preferences. If is not defined returns None.
       """
       return Preferences.userRoot().node("gvsig.foldering").get(
             'ProjectsFolder', None)
     def getColorFromRGB(r, g, b, a=None):
       """
       Returns an sRGB color with the specified red, green, blue, and alpha
       (optional) values in the range (0 - 255).
       """
       if a:
         color = Color(r, g, b, a)
       else:
         color = Color(r, g, b)
       return Preferences.userRoot().node("gvsig.foldering").get('ProjectsFolder', None)
     def getColor():
       return color
     def getDefaultColor(c = None):
       """Returns gvsig default symbol fill color or ramdom color"""
       if MapContextLocator.getSymbolManager().isDefaultSymbolFillColorAleatory():
         color = Color(random.randint(0-255),
                   random.randint(0-255),
                   random.randint(0-255)
                     random.randint(0-255),
                     random.randint(0-255)
+                )
       else:
         color = MapContextLocator.getSymbolManager().getSymbolPreferences().getDefaultSymbolFillColor()
         sp = MapContextLocator.getSymbolManager().getSymbolPreferences()
         color = sp.getDefaultSymbolFillColor()
       return color
     #================#
-...
     #================#
     def getCRS(crs):
       """Returns Projection from string code (i.e. CRS:84) if exist or None if
       not.
       """
       Return Projection from string code (i.e. CRS:84) if exist.
       """
       try:
         return CRSFactory.getCRS(crs)
       except:

Also available in: Unified diff

Application: gvSIG desktop » gvSIG scripting

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