/[thuban]/branches/WIP-pyshapelib-bramz/Thuban/UI/view.py

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

Parent Directory | Revision Log | View Patch Patch

-revision 122 by bh,
Mon Apr 29 18:04:54 2002 UTC
+revision 293 by bh,
Fri Aug 30 10:18:50 2002 UTC
 Line 129 
 class ZoomInTool(RectTool):
              Tool.MouseUp(self, event)
              sx, sy = self.start
              cx, cy = self.current
-             if sx == cx and sy == cy:
+             if sx == cx or sy == cy:
-                 # Just a mouse click. Simply zoom in by a factor of two
+                 # Just a mouse click or a degenerate rectangle. Simply
+                 # zoom in by a factor of two
+                 # FIXME: For a click this is the desired behavior but should we
+                 # really do this for degenrate rectagles as well or
+                 # should we ignore them?
                  self.view.ZoomFactor(2, center = (cx, cy))
              else:
                  # A drag. Zoom in to the rectangle
-Line 140 
 class ZoomInTool(RectTool):
+Line 144 
 class ZoomInTool(RectTool):
  class ZoomOutTool(RectTool):
      """The Zoom-Out Tool"""
      def Name(self):
          return "ZoomOutTool"
-Line 149 
 class ZoomOutTool(RectTool):
+Line 153 
 class ZoomOutTool(RectTool):
              Tool.MouseUp(self, event)
              sx, sy = self.start
              cx, cy = self.current
-             if sx == cx and sy == cy:
+             if sx == cx or sy == cy:
-                 # Just a mouse click. Simply zoom out by a factor of two
+                 # Just a mouse click or a degenerate rectangle. Simply
-                 self.view.ZoomFactor(0.5, center = (cy, cy))
+                 # zoom out by a factor of two.
+                 # FIXME: For a click this is the desired behavior but should we
+                 # really do this for degenrate rectagles as well or
+                 # should we ignore them?
+                 self.view.ZoomFactor(0.5, center = (cx, cy))
              else:
                  # A drag. Zoom out to the rectangle
                  self.view.ZoomOutToRect((min(sx, cx), min(sy, cy),
-Line 167 
 class PanTool(Tool):
+Line 175 
 class PanTool(Tool):
      def MouseMove(self, event):
          if self.dragging:
-             x0, y0 = self.current
              Tool.MouseMove(self, event)
+             sx, sy = self.start
              x, y = self.current
              width, height = self.view.GetSizeTuple()
+             bitmapdc = wx.wxMemoryDC()
+             bitmapdc.SelectObject(self.view.bitmap)
              dc = self.view.drag_dc
-             dc.Blit(0, 0, width, height, dc, x0 - x, y0 - y)
+             dc.Blit(0, 0, width, height, bitmapdc, sx - x, sy - y)
      def MouseUp(self, event):
          if self.dragging:
-Line 180 
 class PanTool(Tool):
+Line 192 
 class PanTool(Tool):
              sx, sy = self.start
              cx, cy = self.current
              self.view.Translate(cx - sx, cy - sy)
  class IdentifyTool(Tool):
      """The "Identify" Tool"""
      def Name(self):
          return "IdentifyTool"
-Line 238 
 class MapPrintout(wx.wxPrintout):
+Line 250 
 class MapPrintout(wx.wxPrintout):
          renderer = PrinterRender(dc, scale, (offx, offy), resolution = resx)
          renderer.RenderMap(self.map)
          return wx.true
  class MapCanvas(wxWindow, Publisher):
-Line 247 
 class MapCanvas(wxWindow, Publisher):
+Line 259 
 class MapCanvas(wxWindow, Publisher):
      def __init__(self, parent, winid, interactor):
          wxWindow.__init__(self, parent, winid)
          self.SetBackgroundColour(wxColour(255, 255, 255))
+         # the map displayed in this canvas. Set with SetMap()
          self.map = None
+         # scale and offset describe the transformation from projected
+         # coordinates to window coordinates.
          self.scale = 1.0
          self.offset = (0, 0)
+         # whether the user is currently dragging the mouse, i.e. moving
+         # the mouse while pressing a mouse button
          self.dragging = 0
+         # the currently active tool
          self.tool = None
-         self.redraw_on_idle = 0
+         # The current mouse position of the last OnMotion event or None
+         # if the mouse is outside the window.
          self.current_position = None
+         # If true, OnIdle will call do_redraw to do the actual
+         # redrawing. Set by OnPaint to avoid some unnecessary redraws.
+         # To force a redraw call full_redraw().
+         self.redraw_on_idle = 0
+         # The region to update when idle
+         self.update_region = wx.wxRegion()
+         # the bitmap serving as backing store
+         self.bitmap = None
+         # the interactor
+         self.interactor = interactor
+         self.interactor.Subscribe(SELECTED_SHAPE, self.shape_selected)
+         # keep track of which layers/shapes are selected to make sure we
+         # only redraw when necessary
+         self.last_selected_layer = None
+         self.last_selected_shape = None
+         # subscribe the WX events we're interested in
          EVT_PAINT(self, self.OnPaint)
          EVT_LEFT_DOWN(self, self.OnLeftDown)
          EVT_LEFT_UP(self, self.OnLeftUp)
          EVT_MOTION(self, self.OnMotion)
          EVT_LEAVE_WINDOW(self, self.OnLeaveWindow)
+         wx.EVT_SIZE(self, self.OnSize)
          wx.EVT_IDLE(self, self.OnIdle)
-         self.interactor = interactor
-         self.interactor.Subscribe(SELECTED_SHAPE, self.shape_selected)
      def __del__(self):
          wxWindow.__del__(self)
-Line 272 
 class MapCanvas(wxWindow, Publisher):
+Line 317 
 class MapCanvas(wxWindow, Publisher):
          if self.map is not None and self.map.HasLayers():
              # We have a non-empty map. Redraw it in idle time
              self.redraw_on_idle = 1
+             # update the region that has to be redrawn
+             self.update_region.UnionRegion(self.GetUpdateRegion())
          else:
              # If we've got no map or if the map is empty, simply clear
              # the screen.
              # XXX it's probably possible to get rid of this. The
              # background color of the window is already white and the
              # only thing we may have to do is to call self.Refresh()
              # with a true argument in the right places.
              dc.BeginDrawing()
              dc.Clear()
              dc.EndDrawing()
+             # clear the region
+             self.update_region = wx.wxRegion()
      def do_redraw(self):
-         # This should only be called if we have a non-empty map. We draw
+         # This should only be called if we have a non-empty map.
-         # it into a memory DC and then blit it to the screen.
+         # get the update region and reset it. We're not actually using
+         # it anymore, though.
+         update_box = self.update_region.GetBox()
+         self.update_region = wx.wxRegion()
+         # Get the window size.
          width, height = self.GetSizeTuple()
-         bitmap = wx.wxEmptyBitmap(width, height)
-         dc = wx.wxMemoryDC()
-         dc.SelectObject(bitmap)
-         dc.BeginDrawing()
-         # clear the background
+         # If self.bitmap's still there, reuse it. Otherwise redraw it
-         dc.SetBrush(wx.wxWHITE_BRUSH)
+         if self.bitmap is not None:
-         dc.SetPen(wx.wxTRANSPARENT_PEN)
+             bitmap = self.bitmap
-         dc.DrawRectangle(0, 0, width, height)
-         if 1: #self.interactor.selected_map is self.map:
-             selected_layer = self.interactor.selected_layer
-             selected_shape = self.interactor.selected_shape
          else:
-             selected_layer = None
+             bitmap = wx.wxEmptyBitmap(width, height)
-             selected_shape = None
+             dc = wx.wxMemoryDC()
+             dc.SelectObject(bitmap)
+             dc.BeginDrawing()
-         # draw the map into the bitmap
+             # clear the background
-         renderer = ScreenRenderer(dc, self.scale, self.offset)
+             dc.SetBrush(wx.wxWHITE_BRUSH)
-         renderer.RenderMap(self.map, selected_layer, selected_shape)
+             dc.SetPen(wx.wxTRANSPARENT_PEN)
+             dc.DrawRectangle(0, 0, width, height)
+             if 1: #self.interactor.selected_map is self.map:
+                 selected_layer = self.interactor.selected_layer
+                 selected_shape = self.interactor.selected_shape
+             else:
+                 selected_layer = None
+                 selected_shape = None
-         dc.EndDrawing()
+             # draw the map into the bitmap
+             renderer = ScreenRenderer(dc, self.scale, self.offset)
+             # Pass the entire bitmap as update_region to the renderer.
+             # We're redrawing the whole bitmap, after all.
+             renderer.RenderMap(self.map, (0, 0, width, height),
+                                selected_layer, selected_shape)
+             dc.EndDrawing()
+             dc.SelectObject(wx.wxNullBitmap)
+             self.bitmap = bitmap
          # blit the bitmap to the screen
+         dc = wx.wxMemoryDC()
+         dc.SelectObject(bitmap)
          clientdc = wxClientDC(self)
          clientdc.BeginDrawing()
          clientdc.Blit(0, 0, width, height, dc, 0, 0)
-Line 322 
 class MapCanvas(wxWindow, Publisher):
+Line 391 
 class MapCanvas(wxWindow, Publisher):
          printout = MapPrintout(self.map)
          printer.Print(self, printout, wx.true)
          printout.Destroy()
      def SetMap(self, map):
          redraw_channels = (LAYERS_CHANGED, LAYER_LEGEND_CHANGED,
                             LAYER_VISIBILITY_CHANGED)
          if self.map is not None:
              for channel in redraw_channels:
-                 self.map.Unsubscribe(channel, self.redraw)
+                 self.map.Unsubscribe(channel, self.full_redraw)
              self.map.Unsubscribe(MAP_PROJECTION_CHANGED,
                                   self.projection_changed)
          self.map = map
          if self.map is not None:
              for channel in redraw_channels:
-                 self.map.Subscribe(channel, self.redraw)
+                 self.map.Subscribe(channel, self.full_redraw)
              self.map.Subscribe(MAP_PROJECTION_CHANGED, self.projection_changed)
          self.FitMapToWindow()
          # force a redraw. If map is not empty, it's already been called
          # by FitMapToWindow but if map is empty it hasn't been called
          # yet so we have to explicitly call it.
-         self.redraw()
+         self.full_redraw()
      def Map(self):
          return self.map
-Line 348 
 class MapCanvas(wxWindow, Publisher):
+Line 417 
 class MapCanvas(wxWindow, Publisher):
      def redraw(self, *args):
          self.Refresh(0)
+     def full_redraw(self, *args):
+         self.bitmap = None
+         self.redraw()
      def projection_changed(self, *args):
          self.FitMapToWindow()
-         self.redraw()
+         self.full_redraw()
      def set_view_transform(self, scale, offset):
          self.scale = scale
          self.offset = offset
-         self.redraw()
+         self.full_redraw()
      def proj_to_win(self, x, y):
          """\
-Line 372 
 class MapCanvas(wxWindow, Publisher):
+Line 445 
 class MapCanvas(wxWindow, Publisher):
          return ((x - offx) / self.scale, (offy - y) / self.scale)
      def FitRectToWindow(self, rect):
+         """Fit the rectangular region given by rect into the window.
+         Set scale so that rect (in projected coordinates) just fits into
+         the window and center it.
+         """
          width, height = self.GetSizeTuple()
          llx, lly, urx, ury = rect
          if llx == urx or lly == ury:
-Line 385 
 class MapCanvas(wxWindow, Publisher):
+Line 463 
 class MapCanvas(wxWindow, Publisher):
          self.set_view_transform(scale, (offx, offy))
      def FitMapToWindow(self):
-         """\
+         """Fit the map to the window
-         Set the scale and offset so that the map is centered in the
-         window
+         Set the scale so that the map fits exactly into the window and
+         center it in the window.
          """
          bbox = self.map.ProjectedBoundingBox()
          if bbox is not None:
-Line 413 
 class MapCanvas(wxWindow, Publisher):
+Line 492 
 class MapCanvas(wxWindow, Publisher):
          self.set_view_transform(scale, offset)
      def ZoomOutToRect(self, rect):
-         # rect is given in window coordinates
+         """Zoom out to fit the currently visible region into rect.
+         The rect parameter is given in window coordinates
+         """
          # determine the bbox of the displayed region in projected
          # coordinates
          width, height = self.GetSizeTuple()
-Line 487 
 class MapCanvas(wxWindow, Publisher):
+Line 568 
 class MapCanvas(wxWindow, Publisher):
              self.tool.MouseDown(event)
              self.tool.Show(self.drag_dc)
              self.dragging = 1
      def OnLeftUp(self, event):
-         self.ReleaseMouse()
          self.set_current_position(event)
          if self.dragging:
+             self.ReleaseMouse()
              self.tool.Hide(self.drag_dc)
              self.tool.MouseUp(event)
              self.drag_dc = None
-Line 512 
 class MapCanvas(wxWindow, Publisher):
+Line 593 
 class MapCanvas(wxWindow, Publisher):
              self.do_redraw()
          self.redraw_on_idle = 0
+     def OnSize(self, event):
+         # the window's size has changed. We have to get a new bitmap. If
+         # we want to be clever we could try to get by without throwing
+         # everything away. E.g. when the window gets smaller, we could
+         # either keep the bitmap or create the new one from the old one.
+         # Even when the window becomes larger some parts of the bitmap
+         # could be reused.
+         self.full_redraw()
      def shape_selected(self, layer, shape):
-         self.redraw()
+         """Redraw the map.
+         Receiver for the SELECTED_SHAPE messages. Try to redraw only
+         when necessary.
+         """
+         # A redraw is necessary when the display has to change, which
+         # means that either the status changes from having no selection
+         # to having a selection shape or vice versa, or when the fact
+         # whether there is a selection at all doesn't change, when the
+         # shape which is selected has changed (which means that layer or
+         # shapeid changes).
+         if ((shape is not None or self.last_selected_shape is not None)
+             and (shape != self.last_selected_shape
+                  or layer != self.last_selected_layer)):
+             self.full_redraw()
+         # remember the selection so we can compare when it changes again.
+         self.last_selected_layer = layer
+         self.last_selected_shape = shape
-     def find_shape_at(self, px, py, select_labels = 0, selected_layer = 1):
+     def unprojected_rect_around_point(self, x, y):
+         """return a rect a few pixels around (x, y) in unprojected corrdinates
+         The return value is a tuple (minx, miny, maxx, maxy) suitable a
+         parameter to a layer's ShapesInRegion method.
+         """
+         map_proj = self.map.projection
+         if map_proj is not None:
+             inverse = map_proj.Inverse
+         else:
+             inverse = None
+         xs = []
+         ys = []
+         for dx, dy in ((-1, -1), (1, -1), (1, 1), (-1, 1)):
+             px, py = self.win_to_proj(x + dx, y + dy)
+             if inverse:
+                 px, py = inverse(px, py)
+             xs.append(px)
+             ys.append(py)
+         return (min(xs), min(ys), max(xs), max(ys))
+     def find_shape_at(self, px, py, select_labels = 0, searched_layer = None):
          """Determine the shape at point px, py in window coords
          Return the shape and the corresponding layer as a tuple (layer,
-Line 525 
 class MapCanvas(wxWindow, Publisher):
+Line 655 
 class MapCanvas(wxWindow, Publisher):
          search through the labels. If a label is found return it's index
          as the shape and None as the layer.
-         If the optional parameter selected_layer is true (default), only
+         If the optional parameter searched_layer is given (or not None
-         search in the currently selected layer.
+         which it defaults to), only search in that layer.
          """
          map_proj = self.map.projection
          if map_proj is not None:
-Line 537 
 class MapCanvas(wxWindow, Publisher):
+Line 667 
 class MapCanvas(wxWindow, Publisher):
          scale = self.scale
          offx, offy = self.offset
+         box = self.unprojected_rect_around_point(px, py)
          if select_labels:
              labels = self.map.LabelLayer().Labels()
              if labels:
                  dc = wxClientDC(self)
                  font = wxFont(10, wx.wxSWISS, wx.wxNORMAL, wx.wxNORMAL)
-Line 571 
 class MapCanvas(wxWindow, Publisher):
+Line 703 
 class MapCanvas(wxWindow, Publisher):
                      if x <= px < x + width and y <= py <= y + height:
                          return None, i
-         if selected_layer:
+         if searched_layer:
-             layer = self.interactor.SelectedLayer()
+             layers = [searched_layer]
-             if layer is not None:
-                 layers = [layer]
-             else:
-                 # no layer selected. Use an empty list to effectively
-                 # ignore all layers.
-                 layers = []
          else:
              layers = self.map.Layers()
-Line 591 
 class MapCanvas(wxWindow, Publisher):
+Line 717 
 class MapCanvas(wxWindow, Publisher):
              filled = layer.fill is not None
              stroked = layer.stroke is not None
              layer_proj = layer.projection
              if layer_proj is not None:
                  inverse = layer_proj.Inverse
              else:
                  inverse = None
              shapetype = layer.ShapeType()
              select_shape = -1
+             shape_ids = layer.ShapesInRegion(box)
+             shape_ids.reverse()
              if shapetype == SHAPETYPE_POLYGON:
-                 for i in range(layer.NumShapes() - 1, -1, -1):
+                 for i in shape_ids:
                      result = point_in_polygon_shape(layer.shapefile.cobject(),
                                                      i,
                                                      filled, stroked,
-Line 613 
 class MapCanvas(wxWindow, Publisher):
+Line 743 
 class MapCanvas(wxWindow, Publisher):
                          select_shape = i
                          break
              elif shapetype == SHAPETYPE_ARC:
-                 for i in range(layer.NumShapes() - 1, -1, -1):
+                 for i in shape_ids:
                      result = point_in_polygon_shape(layer.shapefile.cobject(),
                                                      i, 0, 1,
                                                      map_proj, layer_proj,
-Line 623 
 class MapCanvas(wxWindow, Publisher):
+Line 753 
 class MapCanvas(wxWindow, Publisher):
                          select_shape = i
                          break
              elif shapetype == SHAPETYPE_POINT:
-                 for i in range(layer.NumShapes() - 1, -1, -1):
+                 for i in shape_ids:
                      shape = layer.Shape(i)
                      x, y = shape.Points()[0]
                      if inverse:
-Line 640 
 class MapCanvas(wxWindow, Publisher):
+Line 770 
 class MapCanvas(wxWindow, Publisher):
                  return layer, select_shape
          return None, None
-     def SelectShapeAt(self, x, y):
+     def SelectShapeAt(self, x, y, layer = None):
-         layer, shape = self.find_shape_at(x, y, selected_layer = 0)
+         """\
+         Select and return the shape and its layer at window position (x, y)
+         If layer is given, only search in that layer. If no layer is
+         given, search through all layers.
+         Return a tuple (layer, shapeid). If no shape is found, return
+         (None, None).
+         """
+         layer, shape = result = self.find_shape_at(x, y, searched_layer=layer)
          # If layer is None, then shape will also be None. We don't want
          # to deselect the currently selected layer, so we simply select
          # the already selected layer again.
          if layer is None:
              layer = self.interactor.SelectedLayer()
          self.interactor.SelectLayerAndShape(layer, shape)
+         return result
      def LabelShapeAt(self, x, y):
          ox = x; oy = y

 Legend:



Removed from v.122
 


changed lines


 
Added in v.293
 Legend:



Removed from v.122
 


changed lines


 
Added in v.293
-Removed from v.122
+Added in v.293

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26