/[thuban]/branches/WIP-pyshapelib-bramz/Thuban/UI/renderer.py
ViewVC logotype

Diff of /branches/WIP-pyshapelib-bramz/Thuban/UI/renderer.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 882 by jonathan, Fri May 9 16:34:28 2003 UTC revision 2587 by jonathan, Wed Mar 23 15:30:27 2005 UTC
# Line 1  Line 1 
1  # Copyright (c) 2001, 2002, 2003 by Intevation GmbH  # Copyright (c) 2001-2004 by Intevation GmbH
2  # Authors:  # Authors:
3  # Bernhard Herzog <[email protected]>  # Bernhard Herzog <[email protected]> (2001-2003)
4  # Jonathan Coles <[email protected]>  # Jonathan Coles <[email protected]> (2003)
5    # Frank Koormann <[email protected]> (2003)
6    # Jan-Oliver Wagner <[email protected]> (2003, 2004)
7  #  #
8  # This program is free software under the GPL (>=v2)  # This program is free software under the GPL (>=v2)
9  # Read the file COPYING coming with Thuban for details.  # Read the file COPYING coming with Thuban for details.
10    
11    from __future__ import generators
12    
13  __version__ = "$Revision$"  __version__ = "$Revision$"
14    # $Source$
15    # $Id$
16    
17    import cStringIO
18    
19    import array
20    
21  from Thuban import _  from Thuban import _
22    
23  from wxPython.wx import wxPoint, wxPen, wxBrush, wxFont, \  from wxPython.wx import wxPoint, wxRect, wxPen, wxBrush, wxFont, \
24       wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \      wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \
25       wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL      wxBLACK_PEN, wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL, \
26        wxBitmapFromImage, wxImageFromStream, wxBITMAP_TYPE_BMP, \
27        wxBITMAP_TYPE_JPEG, wxBITMAP_TYPE_PNG, wxBITMAP_TYPE_TIF, \
28        wxBITMAP_TYPE_GIF, wxEmptyImage, wxMask, wxBitmapFromBits
29    
30  from wxproj import draw_polygon_shape, draw_polygon_init  from wxproj import draw_polygon_shape, draw_polygon_init
31    
32  from Thuban.UI.common import Color2wxColour  from Thuban.UI.common import Color2wxColour
33    from Thuban.UI.classifier import ClassDataPreviewer
34    from Thuban.UI.scalebar import ScaleBar
35    
36  from Thuban.Model.layer import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \  from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
37       SHAPETYPE_POINT       SHAPETYPE_POINT, RAW_SHAPEFILE
 from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \  
      ALIGN_LEFT, ALIGN_RIGHT, ALIGN_BASELINE  
38    
39  from Thuban.Model.classification import Classification  from Thuban.Model.color import Transparent
40  from Thuban.Model.color import Color  import Thuban.Model.resource
41    
42  class MapRenderer:  from baserenderer import BaseRenderer
   
     """Class to render a map onto a wxDC"""  
43    
44      honor_visibility = 1  from math import floor
45    
46      def __init__(self, dc, scale, offset, resolution = 72.0,  from types import StringType
                  honor_visibility = None):  
         """Inititalize the renderer.  
   
         dc -- the wxPython DC to render on  
         scale, offset -- the scale factor and translation to convert  
                 between projected coordinates and the DC coordinates  
   
         resolution -- the assumed resolution of the DC. Used to convert  
                 absolute lengths like font sizes to DC coordinates  
   
         honor_visibility -- boolean. If true, honor the visibility flag  
                 of the layers, otherwise draw all layers. If None, use  
                 the renderer's default.  
         """  
         # resolution in pixel/inch  
47    
48          self.dc = dc  from Thuban.version import versions
         self.scale = scale  
         self.offset = offset  
         if honor_visibility is not None:  
             self.honor_visibility = honor_visibility  
         # store the resolution in pixel/point because it's more useful  
         # later.  
         self.resolution = resolution / 72.0  
   
     def render_map(self, map):  
         self.map = map  
         for layer in map.Layers():  
             # if honor_visibility is true, only draw visible layers,  
             # otherwise draw all layers  
             if not self.honor_visibility or layer.Visible():  
                 self.draw_shape_layer(layer)  
         self.draw_label_layer(map.LabelLayer())  
49    
50      def draw_shape_layer(self, layer):  if Thuban.Model.resource.has_gdal_support():
51          scale = self.scale      from gdalwarp import ProjectRasterFile
         offx, offy = self.offset  
52    
         map_proj = self.map.projection  
         layer_proj = layer.projection  
53    
54          shapetype = layer.ShapeType()  # Map the strings used for the format parameter of the draw_raster_data
55    # method to the appropriate wxWindows constants
56    raster_format_map = {
57        "BMP": wxBITMAP_TYPE_BMP,
58        "JPEG": wxBITMAP_TYPE_JPEG,
59        "PNG": wxBITMAP_TYPE_PNG,
60        "TIFF": wxBITMAP_TYPE_TIF,
61        "GIF": wxBITMAP_TYPE_GIF,
62        }
63    
64          brush = wxTRANSPARENT_BRUSH  class MapRenderer(BaseRenderer):
         pen   = wxTRANSPARENT_PEN  
65    
66          old_prop = None      """Class to render a map onto a wxDC"""
         old_group = None  
         lc = layer.GetClassification()  
         field = lc.GetField()  
         defaultGroup = lc.GetDefaultGroup()  
67    
68        TRANSPARENT_PEN = wxTRANSPARENT_PEN
69        TRANSPARENT_BRUSH = wxTRANSPARENT_BRUSH
70    
71          if shapetype != SHAPETYPE_POINT:      def make_point(self, x, y):
72              polygon_render_param = self.polygon_render_param(layer)          return wxPoint(int(round(x)), int(round(y)))
73    
74          if shapetype == SHAPETYPE_POINT:      def tools_for_property(self, prop):
75              draw_func = lambda i: \          fill = prop.GetFill()
76                     self.draw_point_shape(layer, i)          if fill is Transparent:
77                brush = self.TRANSPARENT_BRUSH
78          else:          else:
79              draw_func = lambda i: \              brush = wxBrush(Color2wxColour(fill), wxSOLID)
                    self.draw_polygon_shape(polygon_render_param, i, pen, brush)  
               
         for i in self.layer_ids(layer):  
   
             if field is None:  
                 group = defaultGroup  
             else:  
                 record = layer.table.ReadRowAsDict(i)  
                 assert record is not None  
                 group = lc.FindGroup(record[field])  
   
   
             if not group.IsVisible():  
                 continue  
   
   
             # don't recreate new objects if they are the same as before  
             if group is not old_group:  
                 old_group = group  
   
                 prop = group.GetProperties()  
   
                 if prop != old_prop:  
                     old_prop = prop  
80    
81                      if shapetype == SHAPETYPE_ARC:          stroke = prop.GetLineColor()
82                          fill = Color.Transparent          if stroke is Transparent:
83                      else:              pen = self.TRANSPARENT_PEN
84                          fill = prop.GetFill()          else:
85                pen = wxPen(Color2wxColour(stroke), prop.GetLineWidth(), wxSOLID)
86            return pen, brush
                     if fill is Color.Transparent:  
                         brush = wxTRANSPARENT_BRUSH  
                     else:  
                         color = Color2wxColour(fill)  
                         brush = wxBrush(color, wxSOLID)  
   
                     stroke = prop.GetLineColor()  
                     stroke_width = prop.GetLineWidth()  
                     if stroke is Color.Transparent:  
                         pen = wxTRANSPARENT_PEN  
                     else:  
                         color = Color2wxColour(stroke)  
                         pen = wxPen(color, stroke_width, wxSOLID)  
   
                     if shapetype == SHAPETYPE_POINT:  
                         self.dc.SetBrush(brush)  
                         self.dc.SetPen(pen)  
   
             draw_func(i)  
87    
88      def layer_ids(self, layer):      def low_level_renderer(self, layer):
89          """Return the shape ids of the given layer that have to be drawn.          """Override inherited method to provide more efficient renderers
90    
91          The default implementation simply returns all ids in the layer.          If the underlying data format is not a shapefile or the layer
92          Override in derived classes to be more precise.          contains points shapes, simply use what the inherited method
93            returns.
94    
95            Otherwise, i.e. for arc and polygon use the more efficient
96            wxproj.draw_polygon_shape and its corresponding parameter
97            created with wxproj.draw_polygon_init.
98          """          """
99          return range(layer.NumShapes())          if (layer.ShapeStore().RawShapeFormat() == RAW_SHAPEFILE
100                and layer.ShapeType() in (SHAPETYPE_ARC, SHAPETYPE_POLYGON)):
101      def polygon_render_param(self, layer):              offx, offy = self.offset
102          """Return the low-lever render parameter for the layer"""              x = lambda a, b, c, d: None
103          offx, offy = self.offset              #return (True, x, None)
104          return draw_polygon_init(layer.shapefile, self.dc,              return (True, draw_polygon_shape,
105                                   self.map.projection,                      draw_polygon_init(layer.ShapeStore().Shapefile(),
106                                   layer.projection,                                        self.dc, self.map.projection,
107                                   self.scale, -self.scale,                                        layer.projection,
108                                   offx, offy)                                        self.scale, -self.scale, offx, offy))
109            else:
110                return BaseRenderer.low_level_renderer(self, layer)
111    
112      def draw_polygon_shape(self, draw_polygon_info, index, pen, brush):      def label_font(self):
113          draw_polygon_shape(draw_polygon_info, index, pen, brush)          return wxFont(int(round(self.resolution * 10)), wxSWISS, wxNORMAL,
114                          wxNORMAL)
115    
116        def projected_raster_layer(self, layer, srcProj, dstProj, extents,
117                                   resolution, dimensions, options):
118    
119            ret = None
120    
121            if Thuban.Model.resource.has_gdal_support():
122    
123                if versions['wxPython-tuple'] < (2,5,3):
124                    options = options | 4  # INVERT_MASK_BITS
125                    options = options & ~2 # ALPHA_MASK not supported
126    
127                try:
128                    ret = ProjectRasterFile(layer.GetImageFilename(),
129                                            srcProj, dstProj,
130                                            extents, resolution, dimensions,
131                                            options)
132                except (MemoryError, IOError, AttributeError, ValueError):
133                    # Why does this catch AttributeError and ValueError?
134                    # FIXME: The exception should be communicated to the user
135                    # better.
136                    traceback.print_exc()
137    
138            return ret
139    
140        def draw_raster_data(self, layer, x,y, data, format = 'BMP'):
141    
142            mask = None
143            alpha = None
144            width = data[0]
145            height = data[1]
146            image_data, mask_data, alpha_data = data[2]
147    
148            if versions['wxPython-tuple'] < (2,5,3):
149                alpha_data = None
150    
151            if format == 'RAW':
152                image = wxEmptyImage(width, height)
153                image.SetData(image_data)
154                if mask_data is not None:
155                    mask = wxBitmapFromBits(mask_data, width, height, 1)
156                    mask = wxMask(mask)
157                elif alpha_data is not None:
158                    # alpha_data is already in the right format
159                    alpha = alpha_data
160    
     def projected_points(self, layer, index):  
         proj = self.map.GetProjection()  
         if proj is not None:  
             forward = proj.Forward  
161          else:          else:
162              forward = None              stream = cStringIO.StringIO(image_data)
163          proj = layer.GetProjection()              image = wxImageFromStream(stream, raster_format_map[format])
164          if proj is not None:              if mask_data is not None:
165              inverse = proj.Inverse                  stream = cStringIO.StringIO(mask_data)
166          else:                  mask = wxImageFromStream(stream, raster_format_map[format])
167              inverse = None                  mask = wxMask(wxBitmapFromImage(mask, 1))
168          shape = layer.Shape(index)              elif alpha_data is not None:
169          points = []                  stream = cStringIO.StringIO(alpha_data)
170          scale = self.scale                  alpha = wxImageFromStream(stream, raster_format_map[format])
171          offx, offy = self.offset                  alpha = alpha.GetData()[:] # XXX: do we need to copy this?
172          for x, y in shape.Points():  
173              if inverse:          #
174                  x, y = inverse(x, y)          # if we are using the alpha_data then scale down the alpha values
175              if forward:          # by the layer's opacity using a string translation table
176                  x, y = forward(x, y)          #
177              points.append(wxPoint(x * scale + offx,          if alpha is not None:
178                                    -y * scale + offy))              lo = layer.Opacity()
179          return points              if lo == 0:
180                    return
181      def draw_arc_shape(self, layer, index):              elif lo == 1:
182          points = self.projected_points(layer, index)                  a = alpha
183          self.dc.DrawLines(points)              else:
184                    tr = [int(i*lo) for i in range(256)]
185      def draw_point_shape(self, layer, index):                  table = array.array('B', tr).tostring()
186          pp = self.projected_points(layer, index)                  a = alpha.translate(table)
   
         if len(pp) == 0: return # ignore Null Shapes which have no points  
   
         p = pp[0]  
         radius = self.resolution * 5  
         self.dc.DrawEllipse(p.x - radius, p.y - radius, 2*radius, 2*radius)  
187    
188      def draw_label_layer(self, layer):              image.SetAlphaData(a)
         scale = self.scale  
         offx, offy = self.offset  
189    
190          font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)          bitmap = wxBitmapFromImage(image)
         self.dc.SetFont(font)  
191    
192          map_proj = self.map.projection          if mask is not None:
193          if map_proj is not None:              bitmap.SetMask(mask)
             forward = map_proj.Forward  
         else:  
             forward = None  
194    
195          for label in layer.Labels():          self.dc.DrawBitmap(bitmap, int(round(x)), int(round(y)), True)
             x = label.x  
             y = label.y  
             text = label.text  
             if forward:  
                 x, y = forward(x, y)  
             x = x * scale + offx  
             y = -y * scale + offy  
             width, height = self.dc.GetTextExtent(text)  
             if label.halign == ALIGN_LEFT:  
                 # nothing to be done  
                 pass  
             elif label.halign == ALIGN_RIGHT:  
                 x = x - width  
             elif label.halign == ALIGN_CENTER:  
                 x = x - width/2  
             if label.valign == ALIGN_TOP:  
                 # nothing to be done  
                 pass  
             elif label.valign == ALIGN_BOTTOM:  
                 y = y - height  
             elif label.valign == ALIGN_CENTER:  
                 y = y - height/2  
             self.dc.DrawText(text, x, y)  
196    
197    
198  class ScreenRenderer(MapRenderer):  class ScreenRenderer(MapRenderer):
199    
200      # On the screen we want to see only visible layers by default      # On the screen we want to see only visible layers by default
201      honor_visibility = 1      honor_visibility = 1
202        
203      def RenderMap(self, map, region, selected_layer, selected_shapes):      def RenderMap(self, selected_layer, selected_shapes):
204          """Render the map.          """Render the map.
205    
206          Only the given region (a tuple in window coordinates as returned          Only the given region (a tuple in window coordinates as returned
# Line 254  class ScreenRenderer(MapRenderer): Line 208  class ScreenRenderer(MapRenderer):
208          shapes given by the ids in selected_shapes in the          shapes given by the ids in selected_shapes in the
209          selected_layer.          selected_layer.
210          """          """
         self.update_region = region  
211          self.selected_layer = selected_layer          self.selected_layer = selected_layer
212          self.selected_shapes = selected_shapes          self.selected_shapes = selected_shapes
213          self.render_map(map)          self.render_map()
214    
215      def draw_shape_layer(self, layer):      def RenderMapIncrementally(self):
216          MapRenderer.draw_shape_layer(self, layer)          """Render the map.
217          if layer is self.selected_layer and self.selected_shapes:  
218              pen = wxPen(wxBLACK, 3, wxSOLID)          Only the given region (a tuple in window coordinates as returned
219              brush = wxBrush(wxBLACK, wxCROSS_HATCH)          by a wxrect's asTuple method) needs to be redrawn. Highlight the
220            shapes given by the ids in selected_shapes in the
221              shapetype = layer.ShapeType()          selected_layer.
222              if shapetype == SHAPETYPE_POLYGON:          """
223                  offx, offy = self.offset          return self.render_map_incrementally()
224                  renderparam = self.polygon_render_param(layer)  
225                  func = self.draw_polygon_shape      def draw_selection_incrementally(self, layer, selected_shapes):
226                  args = (pen, brush)          """Draw the selected shapes in a emphasized way (i.e.
227              elif shapetype == SHAPETYPE_ARC:          with a special pen and brush.
228                  renderparam = self.polygon_render_param(layer)          The drawing is performed incrementally, that means every
229                  func = self.draw_polygon_shape          n shapes, the user can have interactions with the map.
230                  args = (pen, None)          n is currently fixed to 500.
231              elif shapetype == SHAPETYPE_POINT:  
232                  renderparam = layer          layer -- the layer where the shapes belong to.
233                  self.dc.SetBrush(brush)          selected_shapes -- a list of the shape-ids representing the
234                  self.dc.SetPen(pen)                             selected shapes for the given layer.
235                  func = self.draw_point_shape          """
236                  args = ()          pen = wxPen(wxBLACK, 3, wxSOLID)
237              else:          brush = wxBrush(wxBLACK, wxCROSS_HATCH)
238                  raise TypeError(_("Unhandled shape type %s") % shapetype)  
239            shapetype = layer.ShapeType()
240            useraw, func, param = self.low_level_renderer(layer)
241            args = (pen, brush)
242    
243              for index in self.selected_shapes:          # for point shapes we need to find out the properties
244                  func(renderparam, index, *args)          # to determine the size. Based on table and field,
245            # we can find out the properties for object - see below.
246            if shapetype == SHAPETYPE_POINT:
247                lc = layer.GetClassification()
248                field = layer.GetClassificationColumn()
249                table = layer.ShapeStore().Table()
250    
251            count = 0
252            for index in selected_shapes:
253                count += 1
254                shape = layer.Shape(index)
255    
256                # Get the size of the specific property for this
257                # point
258                if shapetype == SHAPETYPE_POINT and field is not None:
259                    value = table.ReadValue(shape.ShapeID(), field)
260                    group = lc.FindGroup(value)
261                    size = group.GetProperties().GetSize()
262                    args = (pen, brush, size)
263    
264                if useraw:
265                    data = shape.RawData()
266                else:
267                    data = shape.Points()
268                func(param, data, *args)
269                if count % 500 == 0:
270                    yield True
271    
272      def layer_ids(self, layer):      def layer_shapes(self, layer):
273          """Return the shapeids covered by the region that has to be redrawn          """Return the shapeids covered by the region that has to be redrawn
274    
275          Call the layer's ShapesInRegion method to determine the ids so          Call the layer's ShapesInRegion method to determine the ids so
# Line 309  class ScreenRenderer(MapRenderer): Line 290  class ScreenRenderer(MapRenderer):
290          offx, offy = self.offset          offx, offy = self.offset
291          xs = []          xs = []
292          ys = []          ys = []
293          x, y, width, height = self.update_region          x, y, width, height = self.region
294          for winx, winy in ((x, y), (x + width, y),          for winx, winy in ((x, y), (x + width, y),
295                             (x + width, y + height), (x, y + height)):                             (x + width, y + height), (x, y + height)):
296              px = (winx - offx) / scale              px = (winx - offx) / scale
# Line 326  class ScreenRenderer(MapRenderer): Line 307  class ScreenRenderer(MapRenderer):
307          return layer.ShapesInRegion((left, bottom, right, top))          return layer.ShapesInRegion((left, bottom, right, top))
308    
309    
310  class PrinterRender(MapRenderer):  class ExportRenderer(ScreenRenderer):
311    
312        honor_visibility = 1
313    
314      # When printing we want to see all layers      def __init__(self, *args, **kw):
315      honor_visibility = 0          """Initialize the ExportRenderer.
316    
317            In addition to all parameters of the the ScreenRender
318            constructor, this class requires and additional keyword argument
319            destination_region with a tuple (minx, miny, maxx, maxy) giving
320            the region in dc coordinates which is to contain the map.
321            """
322            self.destination_region = kw["destination_region"]
323            del kw["destination_region"]
324            ScreenRenderer.__init__(self, *args, **kw)
325    
326        def RenderMap(self, selected_layer, selected_shapes):
327            """Render the map.
328    
329            The rendering device has been specified during initialisation.
330            The device border distance was set in
331            Thuban.UI.viewport.output_transform().
332    
333            RenderMap renders a frame set (one page frame, one around
334            legend/scalebar and one around the map), the map, the legend and
335            the scalebar on the given DC. The map is rendered with the
336            region displayed in the canvas view, centered on the area
337            available for map display.
338            """
339    
340            self.selected_layer = selected_layer
341            self.selected_shapes = selected_shapes
342    
343            # Get some dimensions
344            llx, lly, urx, ury = self.region
345            mminx, mminy, mmaxx, mmaxy = self.destination_region
346    
347            # Manipulate the offset to position the map
348            offx, offy = self.offset
349            # 1. Shift to corner of map drawing area
350            offx = offx + mminx
351            offy = offy + mminy
352    
353            # 2. Center the map on the map drawing area:
354            # region identifies the region on the canvas view:
355            # center of map drawing area - half the size of region: rendering origin
356            self.shiftx = (mmaxx - mminx)*0.5 - (urx - llx)*0.5
357            self.shifty = (mmaxy - mminy)*0.5 - (ury - lly)*0.5
358    
359            self.offset = (offx+self.shiftx, offy+self.shifty)
360            self.region = (llx + self.shiftx, lly + self.shifty, urx, ury)
361    
362            # Draw the map
363            self.dc.BeginDrawing()
364            self.dc.DestroyClippingRegion()
365            self.dc.SetClippingRegion(mminx+self.shiftx, mminy+self.shifty,
366                                      urx, ury)
367            self.render_map()
368            self.dc.EndDrawing()
369    
370            # Draw the rest (frames, legend, scalebar)
371            self.dc.BeginDrawing()
372            self.dc.DestroyClippingRegion()
373    
374            # Force the font for Legend drawing
375            font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
376            self.dc.SetFont(font)
377    
378            self.render_frame()
379            self.render_legend()
380            self.render_scalebar()
381            self.dc.EndDrawing()
382    
383        def render_frame(self):
384            """Render the frames for map and legend/scalebar."""
385    
386            dc = self.dc
387            dc.SetPen(wxBLACK_PEN)
388            dc.SetBrush(wxTRANSPARENT_BRUSH)
389    
390            # Dimension stuff
391            width, height = dc.GetSizeTuple()
392            mminx, mminy, mmaxx, mmaxy = self.destination_region
393    
394            # Page Frame
395            dc.DrawRectangle(15,15,width-30, (mmaxy-mminy)+10)
396    
397            # Map Frame
398            llx, lly, urx, ury = self.region
399            dc.DrawRectangle(mminx + self.shiftx, mminy + self.shifty, urx, ury)
400    
401            # Legend Frame
402            dc.DrawRectangle(mmaxx+10,mminy,(width-20) - (mmaxx+10), mmaxy-mminy)
403    
404            dc.DestroyClippingRegion()
405            dc.SetClippingRegion(mmaxx+10,mminy,
406                                 (width-20) - (mmaxx+10), mmaxy-mminy)
407    
408        def render_legend(self):
409            """Render the legend on the Map."""
410    
411            previewer = ClassDataPreviewer()
412            dc = self.dc
413            dc.SetPen(wxBLACK_PEN)
414            dc.SetBrush(wxTRANSPARENT_BRUSH)
415    
416            # Dimension stuff
417            width, height = dc.GetSizeTuple()
418            mminx, mminy, mmaxx, mmaxy = self.destination_region
419            textwidth, textheight = dc.GetTextExtent("0")
420            iconwidth  = textheight
421            iconheight = textheight
422            stepy = textheight+3
423            dx = 10
424            posx = mmaxx + 10 + 5   # 10 pix distance mapframe/legend frame,
425                                    # 5 pix inside legend frame
426            posy = mminy + 5        # 5 pix inside legend frame
427    
428            # Render the legend
429            dc.SetTextForeground(wxBLACK)
430            if self.map.HasLayers():
431                layers = self.map.Layers()[:]
432                layers.reverse()
433                for l in layers:
434                    if l.Visible():
435                        # Render title
436                        dc.DrawText(l.Title(), posx, posy)
437                        posy+=stepy
438                        if l.HasClassification():
439                            # Render classification
440                            clazz = l.GetClassification()
441                            shapeType = l.ShapeType()
442                            for g in clazz:
443                                if g.IsVisible():
444                                    previewer.Draw(dc,
445                                        wxRect(posx+dx, posy,
446                                               iconwidth, iconheight),
447                                        g.GetProperties(), shapeType)
448                                    dc.DrawText(g.GetDisplayText(),
449                                                posx+2*dx+iconwidth, posy)
450                                    posy+=stepy
451    
452        def render_scalebar(self):
453            """Render the scalebar."""
454    
455            scalebar = ScaleBar(self.map)
456    
457            # Dimension stuff
458            width, height = self.dc.GetSizeTuple()
459            mminx, mminy, mmaxx, mmaxy = self.destination_region
460    
461            # Render the scalebar
462            scalebar.DrawScaleBar(self.scale, self.dc,
463                                 (mmaxx+10+5, mmaxy-25),
464                                 ((width-15-5) - (mmaxx+10+5),20)
465                                )
466            # 10 pix between map and legend frame, 5 pix inside legend frame
467            # 25 pix from the legend frame bottom line
468            # Width: 15 pix from DC border, 5 pix inside frame, 10, 5 as above
469            # Height: 20
470    
471    class PrinterRenderer(ExportRenderer):
472    
473        # Printing as well as Export / Screen display only the visible layer.
474        honor_visibility = 1
475    
     RenderMap = MapRenderer.render_map  
       
Legend:
Removed from v.882  
changed lines
  Added in v.2587
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26