/[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 6 by bh,
Tue Aug 28 15:41:52 2001 UTC
+revision 926 by frank,
Mon May 19 12:09:01 2003 UTC
 Line 1
- # Copyright (c) 2001 by Intevation GmbH
+ # Copyright (c) 2001, 2002, 2003 by Intevation GmbH
  # Authors:
  # Bernhard Herzog <[email protected]>
+ # Frank Koormann <[email protected]>
  #
  # This program is free software under the GPL (>=v2)
  # Read the file COPYING coming with Thuban for details.
-Line 11 
 Classes for display of a map and interac
+Line 12 
 Classes for display of a map and interac
  __version__ = "$Revision$"
+ from Thuban import _
+ import sys
+ import os.path
  from math import hypot
  from wxPython.wx import wxWindow,\
       wxPaintDC, wxColour, wxClientDC, wxINVERT, wxTRANSPARENT_BRUSH, wxFont,\
-      EVT_PAINT, EVT_LEFT_DOWN, EVT_LEFT_UP, EVT_MOTION
+      EVT_PAINT, EVT_LEFT_DOWN, EVT_LEFT_UP, EVT_MOTION, EVT_LEAVE_WINDOW, \
+      wxBITMAP_TYPE_XPM, wxBeginBusyCursor, wxEndBusyCursor, wxCursor, \
+      wxImageFromBitmap, wxPlatform
+ # Export related stuff
+ if wxPlatform == '__WXMSW__':
+     from wxPython.wx import wxMetaFileDC
+ from wxPython.wx import wxFileDialog, wxSAVE, wxOVERWRITE_PROMPT, wxID_OK
  from wxPython import wx
-Line 24 
 from wxproj import point_in_polygon_shap
+Line 36 
 from wxproj import point_in_polygon_shap
  from Thuban.Model.messages import MAP_PROJECTION_CHANGED, \
-      LAYERS_CHANGED, LAYER_LEGEND_CHANGED, LAYER_VISIBILITY_CHANGED
+      MAP_LAYERS_CHANGED, LAYER_CHANGED, LAYER_VISIBILITY_CHANGED
  from Thuban.Model.layer import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
       SHAPETYPE_POINT
  from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \
       ALIGN_LEFT, ALIGN_RIGHT
+ from Thuban.Lib.connector import Publisher
+ from Thuban.Model.color import Color
+ import resource
- from renderer import ScreenRenderer, PrinterRender
+ from selection import Selection
+ from renderer import ScreenRenderer, ExportRenderer, PrinterRenderer
  import labeldialog
- from messages import SELECTED_SHAPE
+ from messages import LAYER_SELECTED, SHAPES_SELECTED, VIEW_POSITION, \
+                      SCALE_CHANGED
  #
-Line 127 
 class ZoomInTool(RectTool):
+Line 144 
 class ZoomInTool(RectTool):
      def MouseUp(self, event):
          if self.dragging:
              Tool.MouseUp(self, event)
-             self.view.FitRectToWindow(self.proj_rect())
+             sx, sy = self.start
+             cx, cy = self.current
+             if sx == cx or sy == cy:
+                 # 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
+                 self.view.FitRectToWindow(self.proj_rect())
  class ZoomOutTool(RectTool):
      """The Zoom-Out Tool"""
      def Name(self):
          return "ZoomOutTool"
-Line 142 
 class ZoomOutTool(RectTool):
+Line 170 
 class ZoomOutTool(RectTool):
              Tool.MouseUp(self, event)
              sx, sy = self.start
              cx, cy = self.current
-             self.view.ZoomOutToRect((min(sx, cx), min(sy, cy),
+             if sx == cx or sy == cy:
-                                      max(sx, cx), max(sy, cy)))
+                 # Just a mouse click or a degenerate rectangle. Simply
+                 # 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),
+                                          max(sx, cx), max(sy, cy)))
  class PanTool(Tool):
-Line 155 
 class PanTool(Tool):
+Line 192 
 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 168 
 class PanTool(Tool):
+Line 209 
 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 191 
 class LabelTool(Tool):
+Line 232 
 class LabelTool(Tool):
          self.view.LabelShapeAt(event.m_x, event.m_y)
  class MapPrintout(wx.wxPrintout):
      """
      wxPrintout class for printing Thuban maps
      """
-     def __init__(self, map):
+     def __init__(self, canvas, map, region, selected_layer, selected_shapes):
          wx.wxPrintout.__init__(self)
+         self.canvas = canvas
          self.map = map
+         self.region = region
+         self.selected_layer = selected_layer
+         self.selected_shapes = selected_shapes
      def GetPageInfo(self):
          return (1, 1, 1, 1)
-Line 215 
 class MapPrintout(wx.wxPrintout):
+Line 258 
 class MapPrintout(wx.wxPrintout):
      def draw_on_dc(self, dc):
          width, height = self.GetPageSizePixels()
-         llx, lly, urx, ury = self.map.ProjectedBoundingBox()
+         scale, offset, mapregion = OutputTransform(self.canvas.scale,
-         scalex = width / (urx - llx)
+                                                    self.canvas.offset,
-         scaley = height / (ury - lly)
+                                                    self.canvas.GetSizeTuple(),
-         scale = min(scalex, scaley)
+                                                    self.GetPageSizePixels())
-         offx = 0.5 * (width - (urx + llx) * scale)
-         offy = 0.5 * (height + (ury + lly) * scale)
          resx, resy = self.GetPPIPrinter()
-         renderer = PrinterRender(dc, scale, (offx, offy), resolution = resx)
+         renderer = PrinterRenderer(dc, scale, offset, resolution = resy)
-         renderer.RenderMap(self.map)
+         x, y, width, height = self.region
+         canvas_scale = self.canvas.scale
+         renderer.RenderMap(self.map,
+                            (0,0,
+                                 (width/canvas_scale)*scale,
+                                 (height/canvas_scale)*scale),
+                                 mapregion,
+                            self.selected_layer, self.selected_shapes)
          return wx.true
- class MapCanvas(wxWindow):
+ class MapCanvas(wxWindow, Publisher):
      """A widget that displays a map and offers some interaction"""
+     # Some messages that can be subscribed/unsubscribed directly through
+     # the MapCanvas come in fact from other objects. This is a dict
+     # mapping those messages to the names of the instance variables they
+     # actually come from. The delegation is implemented in the Subscribe
+     # and Unsubscribe methods
+     delegated_messages = {LAYER_SELECTED: "selection",
+                           SHAPES_SELECTED: "selection"}
+     # Methods delegated to some instance variables. The delegation is
+     # implemented in the __getattr__ method.
+     delegated_methods = {"SelectLayer": "selection",
+                          "SelectShapes": "selection",
+                          "SelectedLayer": "selection",
+                          "HasSelectedLayer": "selection",
+                          "HasSelectedShapes": "selection",
+                          "SelectedShapes": "selection"}
      def __init__(self, parent, winid):
          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
+         # the bitmap serving as backing store
+         self.bitmap = None
+         # the selection
+         self.selection = Selection()
+         self.selection.Subscribe(SHAPES_SELECTED , 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)
-         wx.EVT_IDLE(self, self.OnIdle)
+         EVT_LEAVE_WINDOW(self, self.OnLeaveWindow)
-         import main
+         wx.EVT_SIZE(self, self.OnSize)
-         self.interactor = main.app.interactor
-         self.interactor.Subscribe(SELECTED_SHAPE, self.shape_selected)
+     def __del__(self):
+         wxWindow.__del__(self)
+         Publisher.__del__(self)
+     def Subscribe(self, channel, *args):
+         """Extend the inherited method to handle delegated messages.
+         If channel is one of the delegated messages call the appropriate
+         object's Subscribe method. Otherwise just call the inherited
+         method.
+         """
+         if channel in self.delegated_messages:
+             object = getattr(self, self.delegated_messages[channel])
+             object.Subscribe(channel, *args)
+         else:
+             Publisher.Subscribe(self, channel, *args)
+     def Unsubscribe(self, channel, *args):
+         """Extend the inherited method to handle delegated messages.
+         If channel is one of the delegated messages call the appropriate
+         object's Unsubscribe method. Otherwise just call the inherited
+         method.
+         """
+         if channel in self.delegated_messages:
+             object = getattr(self, self.delegated_messages[channel])
+             object.Unsubscribe(channel, *args)
+         else:
+             Publisher.Unsubscribe(self, channel, *args)
+     def __getattr__(self, attr):
+         if attr in self.delegated_methods:
+             return getattr(getattr(self, self.delegated_methods[attr]), attr)
+         raise AttributeError(attr)
      def OnPaint(self, event):
          dc = wxPaintDC(self)
-         if self.map is None or not self.map.HasLayers():
+         clear = self.map is None or not self.map.HasLayers()
-             return
-         self.redraw_on_idle = 1
+         #wxBeginBusyCursor()
+         if not clear:
+             try:
+                 self.do_redraw()
+             except:
+                 print "Error during drawing:", sys.exc_info()[0]
+                 clear = True
+         if clear:
+             # 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()
+         #wxEndBusyCursor()
      def do_redraw(self):
+         # This should only be called if we have a non-empty map.
+         # Get the window size.
          width, height = self.GetSizeTuple()
-         bitmap = wx.wxEmptyBitmap(width, height)
+         # If self.bitmap's still there, reuse it. Otherwise redraw it
+         if self.bitmap is not None:
+             bitmap = self.bitmap
+         else:
+             bitmap = wx.wxEmptyBitmap(width, height)
+             dc = wx.wxMemoryDC()
+             dc.SelectObject(bitmap)
+             dc.BeginDrawing()
+             # clear the background
+             #dc.SetBrush(wx.wxWHITE_BRUSH)
+             #dc.SetPen(wx.wxTRANSPARENT_PEN)
+             #dc.DrawRectangle(0, 0, width, height)
+             dc.SetBackground(wx.wxWHITE_BRUSH)
+             dc.Clear()
+             selected_layer = self.selection.SelectedLayer()
+             selected_shapes = self.selection.SelectedShapes()
+             # 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_shapes)
+             dc.EndDrawing()
+             dc.SelectObject(wx.wxNullBitmap)
+             self.bitmap = bitmap
+         # blit the bitmap to the screen
          dc = wx.wxMemoryDC()
          dc.SelectObject(bitmap)
-         dc.BeginDrawing()
-         dc.SetBrush(wx.wxWHITE_BRUSH)
-         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
-         renderer = ScreenRenderer(dc, self.scale, self.offset)
-         renderer.RenderMap(self.map, selected_layer, selected_shape)
          clientdc = wxClientDC(self)
          clientdc.BeginDrawing()
          clientdc.Blit(0, 0, width, height, dc, 0, 0)
          clientdc.EndDrawing()
+     def Export(self):
+         if hasattr(self, "export_path"):
+             export_path = self.export_path
+         else:
+             export_path="."
+         dlg = wxFileDialog(self, _("Export Map"), export_path, "",
+                            "Enhanced Metafile (*.wmf)|*.wmf",
+                            wxSAVE|wxOVERWRITE_PROMPT)
+         if dlg.ShowModal() == wxID_OK:
+             self.export_path = os.path.dirname(dlg.GetPath())
+             dc = wxMetaFileDC(dlg.GetPath())
+             scale, offset, mapregion = OutputTransform(self.scale,
+                                                        self.offset,
+                                                        self.GetSizeTuple(),
+                                                        dc.GetSizeTuple())
+             selected_layer = self.selection.SelectedLayer()
+             selected_shapes = self.selection.SelectedShapes()
+             renderer = ExportRenderer(dc, scale, offset)
+             # Pass the entire bitmap as update region to the renderer.
+             # We're redrawing the whole bitmap, after all.
+             width, height = self.GetSizeTuple()
+             renderer.RenderMap(self.map,
+                                 (0,0,
+                                     (width/self.scale)*scale,
+                                     (height/self.scale)*scale),
+                                 mapregion,
+                                 selected_layer, selected_shapes)
+             dc.EndDrawing()
+             dc.Close()
+         dlg.Destroy()
      def Print(self):
          printer = wx.wxPrinter()
-         printout = MapPrintout(self.map)
+         width, height = self.GetSizeTuple()
+         selected_layer = self.selection.SelectedLayer()
+         selected_shapes = self.selection.SelectedShapes()
+         printout = MapPrintout(self, self.map, (0, 0, width, height),
+                                selected_layer, selected_shapes)
          printer.Print(self, printout, wx.true)
          printout.Destroy()
      def SetMap(self, map):
-         redraw_channels = (LAYERS_CHANGED, LAYER_LEGEND_CHANGED,
+         redraw_channels = (MAP_LAYERS_CHANGED, LAYER_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
+         self.selection.ClearSelection()
          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.full_redraw()
      def Map(self):
+         """Return the map displayed by this canvas"""
          return self.map
      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()
+         self.issue(SCALE_CHANGED, scale)
      def proj_to_win(self, x, y):
          """\
-Line 336 
 class MapCanvas(wxWindow):
+Line 548 
 class MapCanvas(wxWindow):
          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:
+             # zero width or zero height. Do Nothing
+             return
          scalex = width / (urx - llx)
          scaley = height / (ury - lly)
          scale = min(scalex, scaley)
-Line 346 
 class MapCanvas(wxWindow):
+Line 566 
 class MapCanvas(wxWindow):
          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:
              self.FitRectToWindow(bbox)
-     def ZoomFactor(self, factor):
+     def FitLayerToWindow(self, layer):
+         """Fit the given layer to the window.
+         Set the scale so that the layer fits exactly into the window and
+         center it in the window.
+         """
+         bbox = layer.LatLongBoundingBox()
+         if bbox is not None:
+             proj = self.map.GetProjection()
+             if proj is not None:
+                 bbox = proj.ForwardBBox(bbox)
+             if bbox is not None:
+                 self.FitRectToWindow(bbox)
+     def FitSelectedToWindow(self):
+         layer = self.selection.SelectedLayer()
+         shapes = self.selection.SelectedShapes()
+         bbox = layer.ShapesBoundingBox(shapes)
+         if bbox is not None:
+             proj = self.map.GetProjection()
+             if proj is not None:
+                 bbox = proj.ForwardBBox(bbox)
+             if bbox is not None:
+                 self.FitRectToWindow(bbox)
+     def ZoomFactor(self, factor, center = None):
+         """Multiply the zoom by factor and center on center.
+         The optional parameter center is a point in window coordinates
+         that should be centered. If it is omitted, it defaults to the
+         center of the window
+         """
          width, height = self.GetSizeTuple()
          scale = self.scale * factor
          offx, offy = self.offset
-         offset = (factor * (offx - width / 2) + width / 2,
+         if center is not None:
-                   factor * (offy - height / 2) + height / 2)
+             cx, cy = center
+         else:
+             cx = width / 2
+             cy = height / 2
+         offset = (factor * (offx - cx) + width / 2,
+                   factor * (offy - cy) + height / 2)
          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 381 
 class MapCanvas(wxWindow):
+Line 644 
 class MapCanvas(wxWindow):
          self.set_view_transform(scale, (offx, offy))
      def Translate(self, dx, dy):
+         """Move the map by dx, dy pixels"""
          offx, offy = self.offset
          self.set_view_transform(self.scale, (offx + dx, offy + dy))
+     def SelectTool(self, tool):
+         """Make tool the active tool.
+         The parameter should be an instance of Tool or None to indicate
+         that no tool is active.
+         """
+         self.tool = tool
      def ZoomInTool(self):
-         self.tool = ZoomInTool(self)
+         """Start the zoom in tool"""
+         self.SelectTool(ZoomInTool(self))
      def ZoomOutTool(self):
-         self.tool = ZoomOutTool(self)
+         """Start the zoom out tool"""
+         self.SelectTool(ZoomOutTool(self))
      def PanTool(self):
-         self.tool = PanTool(self)
+         """Start the pan tool"""
+         self.SelectTool(PanTool(self))
+         #img = resource.GetImageResource("pan", wxBITMAP_TYPE_XPM)
+         #bmp = resource.GetBitmapResource("pan", wxBITMAP_TYPE_XPM)
+         #print bmp
+         #img = wxImageFromBitmap(bmp)
+         #print img
+         #cur = wxCursor(img)
+         #print cur
+         #self.SetCursor(cur)
      def IdentifyTool(self):
-         self.tool = IdentifyTool(self)
+         """Start the identify tool"""
+         self.SelectTool(IdentifyTool(self))
      def LabelTool(self):
-         self.tool = LabelTool(self)
+         """Start the label tool"""
+         self.SelectTool(LabelTool(self))
      def CurrentTool(self):
+         """Return the name of the current tool or None if no tool is active"""
          return self.tool and self.tool.Name() or None
+     def CurrentPosition(self):
+         """Return current position of the mouse in projected coordinates.
+         The result is a 2-tuple of floats with the coordinates. If the
+         mouse is not in the window, the result is None.
+         """
+         if self.current_position is not None:
+             x, y = self.current_position
+             return self.win_to_proj(x, y)
+         else:
+             return None
+     def set_current_position(self, event):
+         """Set the current position from event
+         Should be called by all events that contain mouse positions
+         especially EVT_MOTION. The event paramete may be None to
+         indicate the the pointer left the window.
+         """
+         if event is not None:
+             self.current_position = (event.m_x, event.m_y)
+         else:
+             self.current_position = None
+         self.issue(VIEW_POSITION)
      def OnLeftDown(self, event):
+         self.set_current_position(event)
          if self.tool is not None:
              self.drag_dc = wxClientDC(self)
              self.drag_dc.SetLogicalFunction(wxINVERT)
-Line 411 
 class MapCanvas(wxWindow):
+Line 723 
 class MapCanvas(wxWindow):
              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.tool.Hide(self.drag_dc)
+             self.ReleaseMouse()
-             self.tool.MouseUp(event)
+             try:
-             self.drag_dc = None
+                 self.tool.Hide(self.drag_dc)
-         self.dragging = 0
+                 self.tool.MouseUp(event)
+             finally:
+                 self.drag_dc = None
+                 self.dragging = 0
      def OnMotion(self, event):
+         self.set_current_position(event)
          if self.dragging:
              self.tool.Hide(self.drag_dc)
              self.tool.MouseMove(event)
              self.tool.Show(self.drag_dc)
-     def OnIdle(self, event):
+     def OnLeaveWindow(self, event):
-         if self.redraw_on_idle:
+         self.set_current_position(None)
-             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()
+         pass
      def shape_selected(self, layer, shape):
-         self.redraw()
+         """Receiver for the SHAPES_SELECTED messages. Redraw the map."""
+         # The selection object takes care that it only issues
+         # SHAPES_SELECTED messages when the set of selected shapes has
+         # actually changed, so we can do a full redraw unconditionally.
+         # FIXME: We should perhaps try to limit the redraw to the are
+         # actually covered by the shapes before and after the selection
+         # change.
+         self.full_redraw()
+     def unprojected_rect_around_point(self, x, y, dist):
+         """return a rect dist 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
-     def find_shape_at(self, px, py, select_labels = 0):
+         xs = []
-         """Return a tuple shape at point px, py in window coords."""
+         ys = []
+         for dx, dy in ((-1, -1), (1, -1), (1, 1), (-1, 1)):
+             px, py = self.win_to_proj(x + dist * dx, y + dist * 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,
+         shape).
+         If the optional parameter select_labels is true (default false)
+         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 searched_layer is given (or not None
+         which it defaults to), only search in that layer.
+         """
          map_proj = self.map.projection
          if map_proj is not None:
              forward = map_proj.Forward
-Line 447 
 class MapCanvas(wxWindow):
+Line 811 
 class MapCanvas(wxWindow):
          if select_labels:
              labels = self.map.LabelLayer().Labels()
              if labels:
                  dc = wxClientDC(self)
                  font = wxFont(10, wx.wxSWISS, wx.wxNORMAL, wx.wxNORMAL)
                  dc.SetFont(font)
-                 for i in range(len(labels)):
+                 for i in range(len(labels) - 1, -1, -1):
                      label = labels[i]
                      x = label.x
                      y = label.y
-Line 478 
 class MapCanvas(wxWindow):
+Line 842 
 class MapCanvas(wxWindow):
                          y = y - height/2
                      if x <= px < x + width and y <= py <= y + height:
                          return None, i
-         layers = self.map.Layers()
+         if searched_layer:
+             layers = [searched_layer]
+         else:
+             layers = self.map.Layers()
          for layer_index in range(len(layers) - 1, -1, -1):
              layer = layers[layer_index]
-Line 487 
 class MapCanvas(wxWindow):
+Line 855 
 class MapCanvas(wxWindow):
              if not layer.Visible():
                  continue
-             filled = layer.fill is not None
+             filled = layer.GetClassification().GetDefaultFill() \
-             stroked = layer.stroke is not None
+                      is not Color.Transparent
+             stroked = layer.GetClassification().GetDefaultLineColor() \
+                       is not Color.Transparent
              layer_proj = layer.projection
              if layer_proj is not None:
                  inverse = layer_proj.Inverse
              else:
                  inverse = None
              shapetype = layer.ShapeType()
              select_shape = -1
+             # Determine the ids of the shapes that overlap a tiny area
+             # around the point. For layers containing points we have to
+             # choose a larger size of the box we're testing agains so
+             # that we take the size of the markers into account
+             # FIXME: Once the markers are more flexible this part has to
+             # become more flexible too, of course
+             if shapetype == SHAPETYPE_POINT:
+                 box = self.unprojected_rect_around_point(px, py, 5)
+             else:
+                 box = self.unprojected_rect_around_point(px, py, 1)
+             shape_ids = layer.ShapesInRegion(box)
+             shape_ids.reverse()
              if shapetype == SHAPETYPE_POLYGON:
-                 for i in range(layer.NumShapes()):
+                 for i in shape_ids:
                      result = point_in_polygon_shape(layer.shapefile.cobject(),
                                                      i,
                                                      filled, stroked,
-Line 511 
 class MapCanvas(wxWindow):
+Line 895 
 class MapCanvas(wxWindow):
                          select_shape = i
                          break
              elif shapetype == SHAPETYPE_ARC:
-                 for i in range(layer.NumShapes()):
+                 for i in shape_ids:
                      result = point_in_polygon_shape(layer.shapefile.cobject(),
                                                      i, 0, 1,
                                                      map_proj, layer_proj,
-Line 521 
 class MapCanvas(wxWindow):
+Line 905 
 class MapCanvas(wxWindow):
                          select_shape = i
                          break
              elif shapetype == SHAPETYPE_POINT:
-                 for i in range(layer.NumShapes()):
+                 for i in shape_ids:
                      shape = layer.Shape(i)
                      x, y = shape.Points()[0]
                      if inverse:
-Line 538 
 class MapCanvas(wxWindow):
+Line 922 
 class MapCanvas(wxWindow):
                  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)
+         """\
-         self.interactor.SelectLayerAndShape(layer, shape)
+         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.selection.SelectedLayer()
+             shapes = []
+         else:
+             shapes = [shape]
+         self.selection.SelectShapes(layer, shapes)
+         return result
      def LabelShapeAt(self, x, y):
+         """Add or remove a label at window position x, y.
+         If there's a label at the given position, remove it. Otherwise
+         determine the shape at the position, run the label dialog and
+         unless the user cancels the dialog, add a laber.
+         """
          ox = x; oy = y
          label_layer = self.map.LabelLayer()
          layer, shape_index = self.find_shape_at(x, y, select_labels = 1)
-Line 591 
 class MapCanvas(wxWindow):
+Line 999 
 class MapCanvas(wxWindow):
                      valign = ALIGN_CENTER
                  label_layer.AddLabel(x, y, text,
                                       halign = halign, valign = valign)
+ def OutputTransform(canvas_scale, canvas_offset, canvas_size, device_extend):
+     """Calculate dimensions to transform canvas content to output device."""
+     width, height = device_extend
+     # Only 80 % of the with are available for the map
+     width = width * 0.8
+     # Define the distance of the map from DC border
+     distance = 20
+     if height < width:
+         # landscape
+         map_height = height - 2*distance
+         map_width = map_height
+     else:
+         # portrait, recalibrate width (usually the legend width is too
+         # small
+         width = width * 0.9
+         map_height = width - 2*distance
+         map_width = map_height
+     mapregion = (distance, distance,
+                  distance+map_width, distance+map_height)
+     canvas_width, canvas_height = canvas_size
+     scalex = map_width / (canvas_width/canvas_scale)
+     scaley = map_height / (canvas_height/canvas_scale)
+     scale = min(scalex, scaley)
+     canvas_offx, canvas_offy = canvas_offset
+     offx = scale*canvas_offx/canvas_scale
+     offy = scale*canvas_offy/canvas_scale
+     return scale, (offx, offy), mapregion

 Legend:



Removed from v.6
 


changed lines


 
Added in v.926
 Legend:



Removed from v.6
 


changed lines


 
Added in v.926
-Removed from v.6
+Added in v.926

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26