/[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 468 by jonathan, Wed Mar 5 18:19:13 2003 UTC revision 798 by jonathan, Wed Apr 30 17:02:04 2003 UTC
# Line 12  from wxPython.wx import wxPoint, wxPen, Line 12  from wxPython.wx import wxPoint, wxPen,
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 _  from Thuban import _
18  from Thuban.UI.common import *  from Thuban.UI.common import *
# Line 25  from Thuban.Model.label import ALIGN_CEN Line 25  from Thuban.Model.label import ALIGN_CEN
25  from Thuban.Model.classification import Classification  from Thuban.Model.classification import Classification
26  from Thuban.Model.color import Color  from Thuban.Model.color import Color
27    
   
28  class MapRenderer:  class MapRenderer:
29    
30      """Class to render a map onto a wxDC"""      """Class to render a map onto a wxDC"""
# Line 48  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 79  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()          lc = layer.GetClassification()
84          field = lc.GetField()          field = lc.GetField()
85            defaultGroup = lc.GetDefaultGroup()
86    
         defaultProps = lc.GetDefaultGroup().GetProperties()  
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  
99    
100              if field is not None:              if field is None:
101                  try:                  group = defaultGroup
                     record = layer.table.read_record(i)  
                     if record is not None:  
                         value = record[field]  
                 except:  
                     pass  
   
                 #  
                 # if the above statements fail 'value' should  
                 # be null, at which point this call will  
                 # at least retreive the NullData  
                 #  
                 prop = lc.GetProperties(value)  
102              else:              else:
103                  prop = defaultProps                  record = layer.table.read_record(i)
104                    assert record is not None
105                    group = lc.FindGroup(record[field])
106    
107    
108                if not group.IsVisible():
109                    continue
110    
111    
112              # don't recreate new objects if they are the same as before              # don't recreate new objects if they are the same as before
113              if prop != old_prop:              if group is not old_group:
114                  old_prop = prop                  old_group = group
115    
116                  if shapetype == SHAPETYPE_ARC:                  prop = group.GetProperties()
117                      fill = Color.None  
118                  else:                  if prop != old_prop:
119                      fill = prop.GetFill()                      old_prop = prop
120        
121                  if fill is Color.None:                      if shapetype == SHAPETYPE_ARC:
122                      brush = wxTRANSPARENT_BRUSH                          fill = Color.Transparent
123                  else:                      else:
124                      color = Color2wxColour(fill)                          fill = prop.GetFill()
125                      brush = wxBrush(color, wxSOLID)  
126        
127                  stroke = prop.GetLineColor()                      if fill is Color.Transparent:
128                  stroke_width = prop.GetLineWidth()                          brush = wxTRANSPARENT_BRUSH
129                  if stroke is Color.None:                      else:
130                      pen = wxTRANSPARENT_PEN                          color = Color2wxColour(fill)
131                  else:                          brush = wxBrush(color, wxSOLID)
132                      color = Color2wxColour(stroke)  
133                      pen = wxPen(color, stroke_width, wxSOLID)                      stroke = prop.GetLineColor()
134                            stroke_width = prop.GetLineWidth()
135              if shapetype == SHAPETYPE_POINT:                      if stroke is Color.Transparent:
136                  self.dc.SetBrush(brush)                          pen = wxTRANSPARENT_PEN
137                  self.dc.SetPen(pen)                      else:
138                  self.draw_point_shape(layer, i)                          color = Color2wxColour(stroke)
139              else:                          pen = wxPen(color, stroke_width, wxSOLID)
140                  self.draw_polygon_shape(layer, i, pen, brush)  
141                        if shapetype == SHAPETYPE_POINT:
142                            self.dc.SetBrush(brush)
143                            self.dc.SetPen(pen)
144    
145                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 178  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 226  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.468  
changed lines
  Added in v.798
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26