Application: gvSIG desktop » gvSIG scripting

from org.gvsig.fmap.dal.feature.impl.featureset import DefaultFeatureSet as JFeatureSet

class JavaIteratorWraper(object):

    def __init__(self, jiterator):

        self._jiterator = jiterator

def __len(self):

  return self.getSize()

#

# Inject new methods in the class JFeatureSet

#

JFeatureSet.__len__ = __len

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

def getProjectionCode(self):

  projection = self.getProjection()

JLayerVectorial.select = table._select

JLayerVectorial.deselect = table._deselect

JLayerVectorial.isSelected = table._isSelected

  return self.getFeatureStore().getFeatureSet().getSize()

def _edit(self):

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

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

def _updateSchema(self, schema):

  self.getFeatureStore().update(schema)

def _update(self, feature):

  self.getFeatureStore().update(feature)

def _getSelection(self):

  return self.getFeatureStore().getFeatureSelection()

def _select(self, selection):

  self.getFeatureStore().getFeatureSelection().select(selection)

def _call(self):

  return self

#

# Inject new methods in the class JTableDocument

#

JTableDocument.select = _select

JTableDocument.deselect = _deselect

JTableDocument.isSelected = _isSelected

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

def _geometry(self):

  return self.getDefaultGeometry()

def _getValues(self):

  items = dict()

  for name,value in self.iteritems():

    items[name] = value

def _edit(self):

  raise Exception("Deprecated method, use import gvSIG_2_0_0 for compatibilitty with gvSIG 2.0.0 or use getEditable method")

def _getattr(self,attributeName):

  # FIX console error when try to introspect feature object

      return dict()

      return self.getValues().keys()

  try:

    return v

  except Throwable, ex:

def _call(self):

  return self

    name = attr.getName()

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

    yield name,value

def _itervalues(self):

  descriptor = self.getType()

  for attr in descriptor.getAttributeDescriptors():

    name = attr.getName()

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

    yield value

def _iterkeys(self):

  descriptor = self.getType()

  for attr in descriptor.getAttributeDescriptors():

    name = attr.getName()

    yield name

#

# Inject new methods in the class JFeature

#

from java.awt import Color

def createFeatureType(schema = None):

  returns editable instance. Otherwise returns empty Schema.

  :param schema: Schema to make a copy

  :type schema: Schema

  """

  if isinstance(schema, FeatureType):

      s = schema.getCopy().getEditable()

      return s

    except:

      pass

  application = ApplicationLocator.getManager()

  datamanager =  application.getDataManager()

  return datamanager.createFeatureType()

  Returns new layer

  :param schema: layer data definition

  :type schema: Schema

  :type servertype: string

  :return: new layer

  :rtype: Layer

  if layertype == "Shape" :

    if schema.get("GEOMETRY",None) == None:

      raise RuntimeException("Shape need a field named GEOMETRY in the schema")

  if parameters["geometryType"] == None:

    raise RuntimeException("Invalid geometry type for new layer")

  try:

    application = ApplicationLocator.getManager()

    datamanager =  application.getDataManager()

    layer = mapcontextmanager.createLayer(store.getName(), store)

    return layer

  except Throwable, ex:

    raise RuntimeException("Can't create layer, "+ str(ex))

    """

    Add existing shape file to the view. Returns Layer shape file

    :param shpFile: absolute file path

    :return: the shape

    :type return: Layer

    """

    layer.setActive(True)

    return layer

def loadLayer(layerType, **parameters):

    try:

        application = ApplicationLocator.getManager()

        mapcontextmanager = application.getMapContextManager()

        store_parameters = datamanager.createStoreParameters(layerType)

        copyToDynObject(parameters, store_parameters)

    except Throwable, ex:

    return layer

  """

  :param definition: layer data definition

  :type definition: Schema

  :type filename: string

  :param geometryType: geometry type for shape

  :type geometryType: string

  :return: new shape layer

  :rtype: Layer

  """

  return createLayer(

    CRS=CRS,

    geometryType = geometryType

  )

  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 store

  except Throwable, ex:

    raise RuntimeException("Can't create table, "+ str(ex))

def createDBF(definition, DbfFile, CRS="CRS:84"):

  """

  :param definition: layer data definition

  :type definition: Schema

  :type DbfFile: string

  :return: new dbf

  """

  return createTable(

    CRS=CRS,

  )

#=====================#

# Simbology Functions #

COLORS = {

    'black': Color.black,

    'blue': Color.blue,

    'white': Color.white,

    'yellow': Color.yellow,

}

def simplePointSymbol(color=None):

  """

  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 = getDefaultColor()

  return MapContextLocator.getSymbolManager().createSymbol(

        Geometry.TYPES.POINT, color)

def simpleLineSymbol(color=None):

  """

  :param color: String color name or 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 = getDefaultColor()

  return MapContextLocator.getSymbolManager().createSymbol(

        Geometry.TYPES.CURVE, color)

def simplePolygonSymbol(color = None):

  """

  :param color: String color name or Java awt Color

  :return: gvSIG polygon symbol

  """

  if not isinstance(color, Color):

      color = getDefaultColor()

  return MapContextLocator.getSymbolManager().createSymbol(

        Geometry.TYPES.SURFACE, color)

#=========================================#

# gvSIG Application Preferences Functions #

def getDataFolder():

  """

  preferences. If is not defined returns None.

  """

  return Preferences.userRoot().node("gvsig.foldering").get('DataFolder', None)

def getProjectsFolder():

  """

  preferences. If is not defined returns None.

  """

  return Preferences.userRoot().node("gvsig.foldering").get(

def getColorFromRGB(r, g, b, a=None):

  """

  (optional) values in the range (0 - 255).

  """

  if a:

    color = Color(r, g, b, a)

  else:

    color = Color(r, g, b)

  return color

def getDefaultColor(c = None):

  """Returns gvsig default symbol fill color or ramdom color"""

  if MapContextLocator.getSymbolManager().isDefaultSymbolFillColorAleatory():

                random.randint(0-255)

            )

  else:

    sp = MapContextLocator.getSymbolManager().getSymbolPreferences()

#================#

# OTHER          #

#================#

def getCRS(crs):

  """

  try:

    return CRSFactory.getCRS(crs)

# ====================================

#

MULTILINE = Geometry.TYPES.MULTICURVE

MULTIPOLYGON = Geometry.TYPES.MULTISURFACE

D2 = Geometry.SUBTYPES.GEOM2D

D2M = Geometry.SUBTYPES.GEOM2DM

D3 = Geometry.SUBTYPES.GEOM3D

D3M = Geometry.SUBTYPES.GEOM3DM

UNKNOWN = Geometry.SUBTYPES.UNKNOWN

def createGeometry(type, subtype=D2):

    """

    create geometry.

    :param type: geometry type

    :type type: string

    except:

        return None

    return geometry

def createPoint(x=0, y=0, subtype=D2):

    """

    coordinates (default 0,0) or None if can't create point

    :param y: Y coordinate value

    :type x: double

    :type y: double

    :return: Point

    """

    try:

        geometryManager = GeometryLocator.getGeometryManager()

        point = geometryManager.createPoint(x, y, subtype)

    except:

        return None

    return point

def createMultiPoint(subtype=D2, points=None):

    """

    geometry return None.

    :param points: list of points

    :type points: list

    multipoint = createGeometry(MULTIPOINT, subtype)

    if all(points, multipoint):

        try:

                multipoint.addPrimitive(point)

        except:

            return None

    """

    Returns a new polygon with a subtype. Or None if can't create the geometry

    :return: polygon

    polygon = createGeometry(SURFACE, subtype)

    if all(vertexes, polygon):

        try:

            for vertex in vertexes:

                polygon.addPoint(vertex)

        except:

    return polygon

    """

    Returns a new multipolygon with a subtype. or None if can't create geometry

    :return: multipolygon

    :rtype: Geometry

    multipolygon = createGeometry(MULTISURFACE, subtype)

    """

    Returns a new line with a subtype or None if can't create geometry

    :return: polygon

    :rtype: Geometry

    line = createGeometry(CURVE, subtype)

    return line

    """

    Create a new multiline with a subtype or None if can't create geometry

    :return: multiline

    :rtype: Geometry

    multiline = createGeometry(MULTILINE, subtype)

    return multiline

def createEnvelope(pointMax=None, pointMin=None, dimension=2):

    """

    :type pointMax: geometry POINT

    :type pointMin: geometry POINT

    """

    geometryManager = GeometryLocator.getGeometryManager()

    if all((pointMax, pointMin)):

        envelope = geometryManager.createEnvelope(pointMax, pointMin)

    else:

    return envelope

def main():

  point = createPoint(1,1)

import com.jeta.forms.components.panel.FormPanel

import java.io.FileInputStream

import javax.imageio.ImageIO

import javax.swing.JButton

import javax.swing.JComboBox

import java.awt.event.ActionListener

import javax.swing.SwingUtilities

import java.lang.Runnable

import inspect

  def __call__(self):

    self.__fn(*self.__args)

class ProgressBarWithTaskStatus(Observer):

  def __init__(self, name, progressBar, labelProgress=None):

    self.taskStatus = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus(name)

  def getTaskStatus(self):

    return self.taskStatus

  def update(self, taskStatus, notification):

    if not javax.swing.SwingUtilities.isEventDispatchThread():

      javax.swing.SwingUtilities.invokeLater(

        taskStatus.getCompleted(),

        taskStatus.getLabel()

      )

  def updateGUI(self, isRunning, current, label):

    if not isRunning:

        self.progressBar.setIndeterminate(False);

    self.progressBar.setValue(current)

    if self.labelProgress != None:

      self.labelProgress.setText(label)

class FormPanel(object):

  def __init__(self,formfile=None):

  def hide(self):

    self._panel.setVisible(False)

  def __getattr__(self, name):

    if name in ("__members__", "__methods__"):

      raise AttributeError("FormPanel",name)

    if attr == None:

      raise AttributeError("FormPanel",name)

    return attr

  def load(self, formfile):

    self._panel = com.jeta.forms.components.panel.FormPanel( java.io.FileInputStream(formfile) )

    members = inspect.getmembers(self)

          component.addActionListener(ComboBoxActionListener(value))

        else:

          print component

  def load_image(self, afile):

    return javax.imageio.ImageIO.read(afile)

    windowManager = ToolsSwingLocator.getWindowManager()

    windowManager.showWindow(self._panel,title, windowManager.MODE.WINDOW)

    windowManager = ToolsSwingLocator.getWindowManager()

    windowManager.showWindow(self._panel,title, windowManager.MODE.TOOL)