/[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 148 by bh, Tue May 7 16:40:29 2002 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 63  class MapRenderer: Line 70  class MapRenderer:
70          scale = self.scale          scale = self.scale
71          offx, offy = self.offset          offx, offy = self.offset
72    
         fill = layer.fill  
         if fill is None:  
             brush = wxTRANSPARENT_BRUSH  
         else:  
             color = wxColour(fill.red * 255,  
                              fill.green * 255,  
                              fill.blue * 255)  
             brush = wxBrush(color, wxSOLID)  
         stroke = layer.stroke  
         stroke_width = layer.stroke_width  
         if stroke is None:  
             pen = wxTRANSPARENT_PEN  
         else:  
             color = wxColour(stroke.red * 255,  
                              stroke.green * 255,  
                              stroke.blue * 255)  
             pen = wxPen(color, stroke_width, wxSOLID)  
   
73          map_proj = self.map.projection          map_proj = self.map.projection
74          layer_proj = layer.projection          layer_proj = layer.projection
75    
76          shapetype = layer.ShapeType()          shapetype = layer.ShapeType()
77    
78          if shapetype == SHAPETYPE_POLYGON:          brush = wxTRANSPARENT_BRUSH
79              for i in self.layer_ids(layer):          pen   = wxTRANSPARENT_PEN
80                  self.draw_polygon_shape(layer, i, pen, brush)  
81          elif shapetype == SHAPETYPE_ARC:          old_prop = None
82              for i in self.layer_ids(layer):          old_group = None
83                  self.draw_polygon_shape(layer, i, pen, None)          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:          else:
95              self.dc.SetBrush(brush)              draw_func = lambda i: \
96              self.dc.SetPen(pen)                     self.draw_polygon_shape(polygon_render_param, i, pen, brush)
97              if shapetype == SHAPETYPE_ARC:              
98                  f = self.draw_arc_shape          for i in self.layer_ids(layer):
99              elif shapetype == SHAPETYPE_POINT:  
100                  f = self.draw_point_shape              if field is None:
101              for i in self.layer_ids(layer):                  group = defaultGroup
102                  f(layer, i)              else:
103                    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
113                if group is not old_group:
114                    old_group = group
115    
116                    prop = group.GetProperties()
117    
118                    if prop != old_prop:
119                        old_prop = prop
120    
121                        if shapetype == SHAPETYPE_ARC:
122                            fill = Color.Transparent
123                        else:
124                            fill = prop.GetFill()
125    
126    
127                        if fill is Color.Transparent:
128                            brush = wxTRANSPARENT_BRUSH
129                        else:
130                            color = Color2wxColour(fill)
131                            brush = wxBrush(color, wxSOLID)
132    
133                        stroke = prop.GetLineColor()
134                        stroke_width = prop.GetLineWidth()
135                        if stroke is Color.Transparent:
136                            pen = wxTRANSPARENT_PEN
137                        else:
138                            color = Color2wxColour(stroke)
139                            pen = wxPen(color, stroke_width, wxSOLID)
140    
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 146  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 194  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              else:                  renderparam = self.polygon_render_param(layer)
271                    func = self.draw_polygon_shape
272                    args = (pen, brush)
273                elif shapetype == SHAPETYPE_ARC:
274                    renderparam = self.polygon_render_param(layer)
275                    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_ARC:                  func = self.draw_point_shape
282                      f = self.draw_arc_shape                  args = ()
283                  elif shapetype == SHAPETYPE_POINT:              else:
284                      f = self.draw_point_shape                  raise TypeError(_("Unhandled shape type %s") % shapetype)
285                  f(layer, index)  
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.148  
changed lines
  Added in v.798
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26