/[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 362 by jonathan, Mon Jan 27 11:39:03 2003 UTC revision 798 by jonathan, Wed Apr 30 17:02:04 2003 UTC
# Line 1  Line 1 
1  # Copyright (c) 2001, 2002 by Intevation GmbH  # Copyright (c) 2001, 2002, 2003 by Intevation GmbH
2  # Authors:  # Authors:
3  # Bernhard Herzog <[email protected]>  # Bernhard Herzog <[email protected]>
4    # Jonathan Coles <[email protected]>
5  #  #
6  # This program is free software under the GPL (>=v2)  # This program is free software under the GPL (>=v2)
7  # Read the file COPYING coming with Thuban for details.  # Read the file COPYING coming with Thuban for details.
8    
9  __version__ = "$Revision$"  __version__ = "$Revision$"
10    
11  from wxPython.wx import wxPoint, wxColour, wxPen, wxBrush, wxFont, \  from wxPython.wx import wxPoint, wxPen, wxBrush, wxFont, \
12       wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \       wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \
13       wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL       wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL
14    
15  from wxproj import draw_polygon_shape  from wxproj import draw_polygon_shape, draw_polygon_init
16    
17    from Thuban import _
18    from Thuban.UI.common import *
19    
20  from Thuban.Model.layer import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \  from Thuban.Model.layer import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
21       SHAPETYPE_POINT       SHAPETYPE_POINT
22  from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \  from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \
23       ALIGN_LEFT, ALIGN_RIGHT, ALIGN_BASELINE       ALIGN_LEFT, ALIGN_RIGHT, ALIGN_BASELINE
24    
25    from Thuban.Model.classification import Classification
26    from Thuban.Model.color import Color
27    
28  class MapRenderer:  class MapRenderer:
29    
# Line 41  class MapRenderer: Line 47  class MapRenderer:
47                  the renderer's default.                  the renderer's default.
48          """          """
49          # resolution in pixel/inch          # resolution in pixel/inch
50    
51          self.dc = dc          self.dc = dc
52          self.scale = scale          self.scale = scale
53          self.offset = offset          self.offset = offset
# Line 72  class MapRenderer: Line 79  class MapRenderer:
79          pen   = wxTRANSPARENT_PEN          pen   = wxTRANSPARENT_PEN
80    
81          old_prop = None          old_prop = None
82            old_group = None
83            lc = layer.GetClassification()
84            field = lc.GetField()
85            defaultGroup = lc.GetDefaultGroup()
86    
87    
88            if shapetype != SHAPETYPE_POINT:
89                polygon_render_param = self.polygon_render_param(layer)
90    
91            if shapetype == SHAPETYPE_POINT:
92                draw_func = lambda i: \
93                       self.draw_point_shape(layer, i)
94            else:
95                draw_func = lambda i: \
96                       self.draw_polygon_shape(polygon_render_param, i, pen, brush)
97                
98          for i in self.layer_ids(layer):          for i in self.layer_ids(layer):
             value = None  
             shape = layer.Shape(i)  
             field = layer.classification.field  
99    
100              if field is not None:              if field is None:
101                    group = defaultGroup
102                else:
103                  record = layer.table.read_record(i)                  record = layer.table.read_record(i)
104                  if record is not None:                  assert record is not None
105                      value = record[field]                  group = lc.FindGroup(record[field])
106    
107              #  
108              # if the above statements fail 'value' should              if not group.IsVisible():
109              # be null, at which point this call will                  continue
110              # at least retreive the NullData  
111              #  
112              prop = layer.classification.getProperties(value)              # don't recreate new objects if they are the same as before
113                if group is not old_group:
114              if prop != old_prop:                  old_group = group
115                  old_prop = prop  
116                    prop = group.GetProperties()
117                  if shapetype == SHAPETYPE_ARC:  
118                      fill = None                  if prop != old_prop:
119                  else:                      old_prop = prop
120                      fill = prop['fill']  
121                            if shapetype == SHAPETYPE_ARC:
122                  if fill is None:                          fill = Color.Transparent
123                      brush = wxTRANSPARENT_BRUSH                      else:
124                  else:                          fill = prop.GetFill()
125                      color = wxColour(fill.red * 255,  
126                                       fill.green * 255,  
127                                       fill.blue * 255)                      if fill is Color.Transparent:
128                      brush = wxBrush(color, wxSOLID)                          brush = wxTRANSPARENT_BRUSH
129                            else:
130                  stroke = prop['stroke']                          color = Color2wxColour(fill)
131                  stroke_width = prop['stroke_width']                          brush = wxBrush(color, wxSOLID)
132                  if stroke is None:  
133                      pen = wxTRANSPARENT_PEN                      stroke = prop.GetLineColor()
134                  else:                      stroke_width = prop.GetLineWidth()
135                      color = wxColour(stroke.red * 255,                      if stroke is Color.Transparent:
136                                       stroke.green * 255,                          pen = wxTRANSPARENT_PEN
137                                       stroke.blue * 255)                      else:
138                      pen = wxPen(color, stroke_width, wxSOLID)                          color = Color2wxColour(stroke)
139                                pen = wxPen(color, stroke_width, wxSOLID)
140              if shapetype == SHAPETYPE_POINT:  
141                  self.dc.SetBrush(brush)                      if shapetype == SHAPETYPE_POINT:
142                  self.dc.SetPen(pen)                          self.dc.SetBrush(brush)
143                  self.draw_point_shape(layer, i)                          self.dc.SetPen(pen)
144              else:  
145                  self.draw_polygon_shape(layer, i, pen, brush)              draw_func(i)
146    
147      def layer_ids(self, layer):      def layer_ids(self, layer):
148          """Return the shape ids of the given layer that have to be drawn.          """Return the shape ids of the given layer that have to be drawn.
149            
150          The default implementation simply returns all ids in the layer.          The default implementation simply returns all ids in the layer.
151          Override in derived classes to be more precise.          Override in derived classes to be more precise.
152          """          """
153          return range(layer.NumShapes())          return range(layer.NumShapes())
154    
155      def draw_polygon_shape(self, layer, index, pen, brush):      def polygon_render_param(self, layer):
156          offx, offy = self.offset                  """Return the low-lever render parameter for the layer"""
157          draw_polygon_shape(layer.shapefile.cobject(), index,          offx, offy = self.offset
158                             self.dc, pen, brush,          return draw_polygon_init(layer.shapefile, self.dc,
159                             self.map.projection, layer.projection,                                   self.map.projection,
160                             self.scale, -self.scale, offx, offy)                                   layer.projection,
161                                     self.scale, -self.scale,
162                                     offx, offy)
163    
164        def draw_polygon_shape(self, draw_polygon_info, index, pen, brush):
165            draw_polygon_shape(draw_polygon_info, index, pen, brush)
166    
167      def projected_points(self, layer, index):      def projected_points(self, layer, index):
168          proj = self.map.projection          proj = self.map.GetProjection()
169          if proj is not None:          if proj is not None:
170              forward = proj.Forward              forward = proj.Forward
171          else:          else:
172              forward = None              forward = None
173          proj = layer.projection          proj = layer.GetProjection()
174          if proj is not None:          if proj is not None:
175              inverse = proj.Inverse              inverse = proj.Inverse
176          else:          else:
# Line 166  class MapRenderer: Line 193  class MapRenderer:
193          self.dc.DrawLines(points)          self.dc.DrawLines(points)
194    
195      def draw_point_shape(self, layer, index):      def draw_point_shape(self, layer, index):
196          p = self.projected_points(layer, index)[0]          pp = self.projected_points(layer, index)
197    
198            if len(pp) == 0: return # ignore Null Shapes which have no points
199    
200            p = pp[0]
201          radius = self.resolution * 5          radius = self.resolution * 5
202          self.dc.DrawEllipse(p.x - radius, p.y - radius, 2*radius, 2*radius)          self.dc.DrawEllipse(p.x - radius, p.y - radius, 2*radius, 2*radius)
203    
# Line 214  class ScreenRenderer(MapRenderer): Line 245  class ScreenRenderer(MapRenderer):
245      # On the screen we want to see only visible layers by default      # On the screen we want to see only visible layers by default
246      honor_visibility = 1      honor_visibility = 1
247            
248      def RenderMap(self, map, region, selected_layer, selected_shape):      def RenderMap(self, map, region, selected_layer, selected_shapes):
249          """Render the map.          """Render the map.
250    
251          Only the given region (a tuple in window coordinates as returned          Only the given region (a tuple in window coordinates as returned
252          by a wxrect's asTuple method) needs to be redrawn. Highlight the          by a wxrect's asTuple method) needs to be redrawn. Highlight the
253          shape with id selected_shape in the selected_layer.          shapes given by the ids in selected_shapes in the
254            selected_layer.
255          """          """
256          self.update_region = region          self.update_region = region
257          self.selected_layer = selected_layer          self.selected_layer = selected_layer
258          self.selected_shape = selected_shape          self.selected_shapes = selected_shapes
259          self.render_map(map)          self.render_map(map)
260    
261      def draw_shape_layer(self, layer):      def draw_shape_layer(self, layer):
262          MapRenderer.draw_shape_layer(self, layer)          MapRenderer.draw_shape_layer(self, layer)
263          if layer is self.selected_layer and self.selected_shape is not None:          if layer is self.selected_layer and self.selected_shapes:
264              pen = wxPen(wxBLACK, 3, wxSOLID)              pen = wxPen(wxBLACK, 3, wxSOLID)
265              brush = wxBrush(wxBLACK, wxCROSS_HATCH)              brush = wxBrush(wxBLACK, wxCROSS_HATCH)
266                
267              shapetype = layer.ShapeType()              shapetype = layer.ShapeType()
             index = self.selected_shape  
268              if shapetype == SHAPETYPE_POLYGON:              if shapetype == SHAPETYPE_POLYGON:
269                  self.draw_polygon_shape(layer, index, pen, brush)                  offx, offy = self.offset
270                    renderparam = self.polygon_render_param(layer)
271                    func = self.draw_polygon_shape
272                    args = (pen, brush)
273              elif shapetype == SHAPETYPE_ARC:              elif shapetype == SHAPETYPE_ARC:
274                  self.draw_polygon_shape(layer, index, pen, None)                  renderparam = self.polygon_render_param(layer)
275              else:                  func = self.draw_polygon_shape
276                    args = (pen, None)
277                elif shapetype == SHAPETYPE_POINT:
278                    renderparam = layer
279                  self.dc.SetBrush(brush)                  self.dc.SetBrush(brush)
280                  self.dc.SetPen(pen)                  self.dc.SetPen(pen)
281                  if shapetype == SHAPETYPE_POINT:                  func = self.draw_point_shape
282                      self.draw_point_shape(layer, index)                  args = ()
283                  else:              else:
284                      raise TypeError("Unhandled shape type %s" % shapetype)                  raise TypeError(_("Unhandled shape type %s") % shapetype)
285    
286                for index in self.selected_shapes:
287                    func(renderparam, index, *args)
288    
289    
290      def layer_ids(self, layer):      def layer_ids(self, layer):
291          """Return the shapeids covered by the region that has to be redrawn          """Return the shapeids covered by the region that has to be redrawn
Legend:
Removed from v.362  
changed lines
  Added in v.798
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26