added all server files

3 files changed, 270 insertions, 0 deletions

diff --git a/lib/python2.7/site-packages/django/contrib/gis/admin/__init__.py b/lib/python2.7/site-packages/django/contrib/gis/admin/__init__.py
new file mode 100644
index 0000000..2b56276
--- /dev/null
+++ b/lib/python2.7/site-packages/django/contrib/gis/admin/__init__.py
@@ -0,0 +1,12 @@
+# Getting the normal admin routines, classes, and `site` instance.
+from django.contrib.admin import autodiscover, site, AdminSite, ModelAdmin, StackedInline, TabularInline, HORIZONTAL, VERTICAL
+
+# Geographic admin options classes and widgets.
+from django.contrib.gis.admin.options import GeoModelAdmin
+from django.contrib.gis.admin.widgets import OpenLayersWidget
+
+try:
+    from django.contrib.gis.admin.options import OSMGeoAdmin
+    HAS_OSM = True
+except ImportError:
+    HAS_OSM = False
diff --git a/lib/python2.7/site-packages/django/contrib/gis/admin/options.py b/lib/python2.7/site-packages/django/contrib/gis/admin/options.py
new file mode 100644
index 0000000..7e79be1
--- /dev/null
+++ b/lib/python2.7/site-packages/django/contrib/gis/admin/options.py
@@ -0,0 +1,139 @@
+from django.contrib.admin import ModelAdmin
+from django.contrib.gis.admin.widgets import OpenLayersWidget
+from django.contrib.gis.gdal import OGRGeomType
+from django.contrib.gis.db import models
+
+class GeoModelAdmin(ModelAdmin):
+    """
+    The administration options class for Geographic models. Map settings
+    may be overloaded from their defaults to create custom maps.
+    """
+    # The default map settings that may be overloaded -- still subject
+    # to API changes.
+    default_lon = 0
+    default_lat = 0
+    default_zoom = 4
+    display_wkt = False
+    display_srid = False
+    extra_js = []
+    num_zoom = 18
+    max_zoom = False
+    min_zoom = False
+    units = False
+    max_resolution = False
+    max_extent = False
+    modifiable = True
+    mouse_position = True
+    scale_text = True
+    layerswitcher = True
+    scrollable = True
+    map_width = 600
+    map_height = 400
+    map_srid = 4326
+    map_template = 'gis/admin/openlayers.html'
+    openlayers_url = 'http://openlayers.org/api/2.11/OpenLayers.js'
+    point_zoom = num_zoom - 6
+    wms_url = 'http://vmap0.tiles.osgeo.org/wms/vmap0'
+    wms_layer = 'basic'
+    wms_name = 'OpenLayers WMS'
+    wms_options = {'format': 'image/jpeg'}
+    debug = False
+    widget = OpenLayersWidget
+
+    @property
+    def media(self):
+        "Injects OpenLayers JavaScript into the admin."
+        media = super(GeoModelAdmin, self).media
+        media.add_js([self.openlayers_url])
+        media.add_js(self.extra_js)
+        return media
+
+    def formfield_for_dbfield(self, db_field, **kwargs):
+        """
+        Overloaded from ModelAdmin so that an OpenLayersWidget is used
+        for viewing/editing 2D GeometryFields (OpenLayers 2 does not support
+        3D editing).
+        """
+        if isinstance(db_field, models.GeometryField) and db_field.dim < 3:
+            request = kwargs.pop('request', None)
+            # Setting the widget with the newly defined widget.
+            kwargs['widget'] = self.get_map_widget(db_field)
+            return db_field.formfield(**kwargs)
+        else:
+            return super(GeoModelAdmin, self).formfield_for_dbfield(db_field, **kwargs)
+
+    def get_map_widget(self, db_field):
+        """
+        Returns a subclass of the OpenLayersWidget (or whatever was specified
+        in the `widget` attribute) using the settings from the attributes set
+        in this class.
+        """
+        is_collection = db_field.geom_type in ('MULTIPOINT', 'MULTILINESTRING', 'MULTIPOLYGON', 'GEOMETRYCOLLECTION')
+        if is_collection:
+            if db_field.geom_type == 'GEOMETRYCOLLECTION': collection_type = 'Any'
+            else: collection_type = OGRGeomType(db_field.geom_type.replace('MULTI', ''))
+        else:
+            collection_type = 'None'
+
+        class OLMap(self.widget):
+            template = self.map_template
+            geom_type = db_field.geom_type
+
+            wms_options = ''
+            if self.wms_options:
+                wms_options = ["%s: '%s'" % pair for pair in self.wms_options.items()]
+                wms_options = ', %s' % ', '.join(wms_options)
+
+            params = {'default_lon' : self.default_lon,
+                      'default_lat' : self.default_lat,
+                      'default_zoom' : self.default_zoom,
+                      'display_wkt' : self.debug or self.display_wkt,
+                      'geom_type' : OGRGeomType(db_field.geom_type),
+                      'field_name' : db_field.name,
+                      'is_collection' : is_collection,
+                      'scrollable' : self.scrollable,
+                      'layerswitcher' : self.layerswitcher,
+                      'collection_type' : collection_type,
+                      'is_generic' : db_field.geom_type == 'GEOMETRY',
+                      'is_linestring' : db_field.geom_type in ('LINESTRING', 'MULTILINESTRING'),
+                      'is_polygon' : db_field.geom_type in ('POLYGON', 'MULTIPOLYGON'),
+                      'is_point' : db_field.geom_type in ('POINT', 'MULTIPOINT'),
+                      'num_zoom' : self.num_zoom,
+                      'max_zoom' : self.max_zoom,
+                      'min_zoom' : self.min_zoom,
+                      'units' : self.units, #likely shoud get from object
+                      'max_resolution' : self.max_resolution,
+                      'max_extent' : self.max_extent,
+                      'modifiable' : self.modifiable,
+                      'mouse_position' : self.mouse_position,
+                      'scale_text' : self.scale_text,
+                      'map_width' : self.map_width,
+                      'map_height' : self.map_height,
+                      'point_zoom' : self.point_zoom,
+                      'srid' : self.map_srid,
+                      'display_srid' : self.display_srid,
+                      'wms_url' : self.wms_url,
+                      'wms_layer' : self.wms_layer,
+                      'wms_name' : self.wms_name,
+                      'wms_options' : wms_options,
+                      'debug' : self.debug,
+                      }
+        return OLMap
+
+from django.contrib.gis import gdal
+if gdal.HAS_GDAL:
+    # Use the official spherical mercator projection SRID on versions
+    # of GDAL that support it; otherwise, fallback to 900913.
+    if gdal.GDAL_VERSION >= (1, 7):
+        spherical_mercator_srid = 3857
+    else:
+        spherical_mercator_srid = 900913
+
+    class OSMGeoAdmin(GeoModelAdmin):
+        map_template = 'gis/admin/osm.html'
+        num_zoom = 20
+        map_srid = spherical_mercator_srid
+        max_extent = '-20037508,-20037508,20037508,20037508'
+        max_resolution = '156543.0339'
+        point_zoom = num_zoom - 6
+        units = 'm'
diff --git a/lib/python2.7/site-packages/django/contrib/gis/admin/widgets.py b/lib/python2.7/site-packages/django/contrib/gis/admin/widgets.py
new file mode 100644
index 0000000..056d259
--- /dev/null
+++ b/lib/python2.7/site-packages/django/contrib/gis/admin/widgets.py
@@ -0,0 +1,119 @@
+import logging
+
+from django.forms.widgets import Textarea
+from django.template import loader, Context
+from django.utils import six
+from django.utils import translation
+
+from django.contrib.gis.gdal import OGRException
+from django.contrib.gis.geos import GEOSGeometry, GEOSException
+
+# Creating a template context that contains Django settings
+# values needed by admin map templates.
+geo_context = Context({'LANGUAGE_BIDI' : translation.get_language_bidi()})
+logger = logging.getLogger('django.contrib.gis')
+
+
+class OpenLayersWidget(Textarea):
+    """
+    Renders an OpenLayers map using the WKT of the geometry.
+    """
+    def render(self, name, value, attrs=None):
+        # Update the template parameters with any attributes passed in.
+        if attrs: self.params.update(attrs)
+
+        # Defaulting the WKT value to a blank string -- this
+        # will be tested in the JavaScript and the appropriate
+        # interface will be constructed.
+        self.params['wkt'] = ''
+
+        # If a string reaches here (via a validation error on another
+        # field) then just reconstruct the Geometry.
+        if isinstance(value, six.string_types):
+            try:
+                value = GEOSGeometry(value)
+            except (GEOSException, ValueError) as err:
+                logger.error(
+                    "Error creating geometry from value '%s' (%s)" % (
+                    value, err)
+                )
+                value = None
+
+        if (value and value.geom_type.upper() != self.geom_type and
+                self.geom_type != 'GEOMETRY'):
+            value = None
+
+        # Constructing the dictionary of the map options.
+        self.params['map_options'] = self.map_options()
+
+        # Constructing the JavaScript module name using the name of
+        # the GeometryField (passed in via the `attrs` keyword).
+        # Use the 'name' attr for the field name (rather than 'field')
+        self.params['name'] = name
+        # note: we must switch out dashes for underscores since js
+        # functions are created using the module variable
+        js_safe_name = self.params['name'].replace('-','_')
+        self.params['module'] = 'geodjango_%s' % js_safe_name
+
+        if value:
+            # Transforming the geometry to the projection used on the
+            # OpenLayers map.
+            srid = self.params['srid']
+            if value.srid != srid:
+                try:
+                    ogr = value.ogr
+                    ogr.transform(srid)
+                    wkt = ogr.wkt
+                except OGRException as err:
+                    logger.error(
+                        "Error transforming geometry from srid '%s' to srid '%s' (%s)" % (
+                        value.srid, srid, err)
+                    )
+                    wkt = ''
+            else:
+                wkt = value.wkt
+
+            # Setting the parameter WKT with that of the transformed
+            # geometry.
+            self.params['wkt'] = wkt
+
+        return loader.render_to_string(self.template, self.params,
+                                       context_instance=geo_context)
+
+    def map_options(self):
+        "Builds the map options hash for the OpenLayers template."
+
+        # JavaScript construction utilities for the Bounds and Projection.
+        def ol_bounds(extent):
+            return 'new OpenLayers.Bounds(%s)' % str(extent)
+        def ol_projection(srid):
+            return 'new OpenLayers.Projection("EPSG:%s")' % srid
+
+        # An array of the parameter name, the name of their OpenLayers
+        # counterpart, and the type of variable they are.
+        map_types = [('srid', 'projection', 'srid'),
+                     ('display_srid', 'displayProjection', 'srid'),
+                     ('units', 'units', str),
+                     ('max_resolution', 'maxResolution', float),
+                     ('max_extent', 'maxExtent', 'bounds'),
+                     ('num_zoom', 'numZoomLevels', int),
+                     ('max_zoom', 'maxZoomLevels', int),
+                     ('min_zoom', 'minZoomLevel', int),
+                     ]
+
+        # Building the map options hash.
+        map_options = {}
+        for param_name, js_name, option_type in map_types:
+            if self.params.get(param_name, False):
+                if option_type == 'srid':
+                    value = ol_projection(self.params[param_name])
+                elif option_type == 'bounds':
+                    value = ol_bounds(self.params[param_name])
+                elif option_type in (float, int):
+                    value = self.params[param_name]
+                elif option_type in (str,):
+                    value = '"%s"' % self.params[param_name]
+                else:
+                    raise TypeError
+                map_options[js_name] = value
+        return map_options