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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 43 by bh, Fri Sep 7 11:55:51 2001 UTC revision 288 by bh, Thu Aug 29 13:31:43 2002 UTC
# Line 1  Line 1 
1  # Copyright (c) 2001 by Intevation GmbH  # Copyright (c) 2001, 2002 by Intevation GmbH
2  # Authors:  # Authors:
3  # Bernhard Herzog <[email protected]>  # Bernhard Herzog <[email protected]>
4  #  #
# Line 15  from math import hypot Line 15  from math import hypot
15    
16  from wxPython.wx import wxWindow,\  from wxPython.wx import wxWindow,\
17       wxPaintDC, wxColour, wxClientDC, wxINVERT, wxTRANSPARENT_BRUSH, wxFont,\       wxPaintDC, wxColour, wxClientDC, wxINVERT, wxTRANSPARENT_BRUSH, wxFont,\
18       EVT_PAINT, EVT_LEFT_DOWN, EVT_LEFT_UP, EVT_MOTION       EVT_PAINT, EVT_LEFT_DOWN, EVT_LEFT_UP, EVT_MOTION, EVT_LEAVE_WINDOW
19    
20    
21  from wxPython import wx  from wxPython import wx
# Line 29  from Thuban.Model.layer import SHAPETYPE Line 29  from Thuban.Model.layer import SHAPETYPE
29       SHAPETYPE_POINT       SHAPETYPE_POINT
30  from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \  from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \
31       ALIGN_LEFT, ALIGN_RIGHT       ALIGN_LEFT, ALIGN_RIGHT
32    from Thuban.Lib.connector import Publisher
33    
34  from renderer import ScreenRenderer, PrinterRender  from renderer import ScreenRenderer, PrinterRender
35    
36  import labeldialog  import labeldialog
37    
38  from messages import SELECTED_SHAPE  from messages import SELECTED_SHAPE, VIEW_POSITION
39    
40    
41  #  #
# Line 127  class ZoomInTool(RectTool): Line 127  class ZoomInTool(RectTool):
127      def MouseUp(self, event):      def MouseUp(self, event):
128          if self.dragging:          if self.dragging:
129              Tool.MouseUp(self, event)              Tool.MouseUp(self, event)
130              self.view.FitRectToWindow(self.proj_rect())              sx, sy = self.start
131                cx, cy = self.current
132                if sx == cx or sy == cy:
133                    # Just a mouse click or a degenerate rectangle. Simply
134                    # zoom in by a factor of two
135                    # FIXME: For a click this is the desired behavior but should we
136                    # really do this for degenrate rectagles as well or
137                    # should we ignore them?
138                    self.view.ZoomFactor(2, center = (cx, cy))
139                else:
140                    # A drag. Zoom in to the rectangle
141                    self.view.FitRectToWindow(self.proj_rect())
142    
143    
144  class ZoomOutTool(RectTool):  class ZoomOutTool(RectTool):
145    
146      """The Zoom-Out Tool"""      """The Zoom-Out Tool"""
147        
148      def Name(self):      def Name(self):
149          return "ZoomOutTool"          return "ZoomOutTool"
150    
# Line 142  class ZoomOutTool(RectTool): Line 153  class ZoomOutTool(RectTool):
153              Tool.MouseUp(self, event)              Tool.MouseUp(self, event)
154              sx, sy = self.start              sx, sy = self.start
155              cx, cy = self.current              cx, cy = self.current
156              self.view.ZoomOutToRect((min(sx, cx), min(sy, cy),              if sx == cx or sy == cy:
157                                       max(sx, cx), max(sy, cy)))                  # Just a mouse click or a degenerate rectangle. Simply
158                    # zoom out by a factor of two.
159                    # FIXME: For a click this is the desired behavior but should we
160                    # really do this for degenrate rectagles as well or
161                    # should we ignore them?
162                    self.view.ZoomFactor(0.5, center = (cx, cy))
163                else:
164                    # A drag. Zoom out to the rectangle
165                    self.view.ZoomOutToRect((min(sx, cx), min(sy, cy),
166                                             max(sx, cx), max(sy, cy)))
167    
168    
169  class PanTool(Tool):  class PanTool(Tool):
# Line 155  class PanTool(Tool): Line 175  class PanTool(Tool):
175    
176      def MouseMove(self, event):      def MouseMove(self, event):
177          if self.dragging:          if self.dragging:
             x0, y0 = self.current  
178              Tool.MouseMove(self, event)              Tool.MouseMove(self, event)
179                sx, sy = self.start
180              x, y = self.current              x, y = self.current
181              width, height = self.view.GetSizeTuple()              width, height = self.view.GetSizeTuple()
182    
183                bitmapdc = wx.wxMemoryDC()
184                bitmapdc.SelectObject(self.view.bitmap)
185    
186              dc = self.view.drag_dc              dc = self.view.drag_dc
187              dc.Blit(0, 0, width, height, dc, x0 - x, y0 - y)              dc.Blit(0, 0, width, height, bitmapdc, sx - x, sy - y)
188    
189      def MouseUp(self, event):      def MouseUp(self, event):
190          if self.dragging:          if self.dragging:
# Line 168  class PanTool(Tool): Line 192  class PanTool(Tool):
192              sx, sy = self.start              sx, sy = self.start
193              cx, cy = self.current              cx, cy = self.current
194              self.view.Translate(cx - sx, cy - sy)              self.view.Translate(cx - sx, cy - sy)
195            
196  class IdentifyTool(Tool):  class IdentifyTool(Tool):
197    
198      """The "Identify" Tool"""      """The "Identify" Tool"""
199        
200      def Name(self):      def Name(self):
201          return "IdentifyTool"          return "IdentifyTool"
202    
# Line 226  class MapPrintout(wx.wxPrintout): Line 250  class MapPrintout(wx.wxPrintout):
250          renderer = PrinterRender(dc, scale, (offx, offy), resolution = resx)          renderer = PrinterRender(dc, scale, (offx, offy), resolution = resx)
251          renderer.RenderMap(self.map)          renderer.RenderMap(self.map)
252          return wx.true          return wx.true
           
253    
254  class MapCanvas(wxWindow):  
255    class MapCanvas(wxWindow, Publisher):
256    
257      """A widget that displays a map and offers some interaction"""      """A widget that displays a map and offers some interaction"""
258    
259      def __init__(self, parent, winid, interactor):      def __init__(self, parent, winid, interactor):
260          wxWindow.__init__(self, parent, winid)          wxWindow.__init__(self, parent, winid)
261          self.SetBackgroundColour(wxColour(255, 255, 255))          self.SetBackgroundColour(wxColour(255, 255, 255))
262    
263            # the map displayed in this canvas. Set with SetMap()
264          self.map = None          self.map = None
265    
266            # scale and offset describe the transformation from projected
267            # coordinates to window coordinates.
268          self.scale = 1.0          self.scale = 1.0
269          self.offset = (0, 0)          self.offset = (0, 0)
270    
271            # whether the user is currently dragging the mouse, i.e. moving
272            # the mouse while pressing a mouse button
273          self.dragging = 0          self.dragging = 0
274    
275            # the currently active tool
276          self.tool = None          self.tool = None
277    
278            # The current mouse position of the last OnMotion event or None
279            # if the mouse is outside the window.
280            self.current_position = None
281    
282            # If true, OnIdle will call do_redraw to do the actual
283            # redrawing. Set by OnPaint to avoid some unnecessary redraws.
284            # To force a redraw call full_redraw().
285          self.redraw_on_idle = 0          self.redraw_on_idle = 0
286    
287            # The region to update when idle
288            self.update_region = wx.wxRegion()
289    
290            # the bitmap serving as backing store
291            self.bitmap = None
292    
293            # the interactor
294            self.interactor = interactor
295            self.interactor.Subscribe(SELECTED_SHAPE, self.shape_selected)
296    
297            # keep track of which layers/shapes are selected to make sure we
298            # only redraw when necessary
299            self.last_selected_layer = None
300            self.last_selected_shape = None
301    
302            # subscribe the WX events we're interested in
303          EVT_PAINT(self, self.OnPaint)          EVT_PAINT(self, self.OnPaint)
304          EVT_LEFT_DOWN(self, self.OnLeftDown)          EVT_LEFT_DOWN(self, self.OnLeftDown)
305          EVT_LEFT_UP(self, self.OnLeftUp)          EVT_LEFT_UP(self, self.OnLeftUp)
306          EVT_MOTION(self, self.OnMotion)          EVT_MOTION(self, self.OnMotion)
307            EVT_LEAVE_WINDOW(self, self.OnLeaveWindow)
308            wx.EVT_SIZE(self, self.OnSize)
309          wx.EVT_IDLE(self, self.OnIdle)          wx.EVT_IDLE(self, self.OnIdle)
310          self.interactor = interactor  
311          self.interactor.Subscribe(SELECTED_SHAPE, self.shape_selected)      def __del__(self):
312            wxWindow.__del__(self)
313            Publisher.__del__(self)
314    
315      def OnPaint(self, event):      def OnPaint(self, event):
316          dc = wxPaintDC(self)          dc = wxPaintDC(self)
317          if self.map is None or not self.map.HasLayers():          if self.map is not None and self.map.HasLayers():
318              return              # We have a non-empty map. Redraw it in idle time
319          self.redraw_on_idle = 1              self.redraw_on_idle = 1
320                # update the region that has to be redrawn
321                self.update_region.UnionRegion(self.GetUpdateRegion())
322            else:
323                # If we've got no map or if the map is empty, simply clear
324                # the screen.
325    
326                # XXX it's probably possible to get rid of this. The
327                # background color of the window is already white and the
328                # only thing we may have to do is to call self.Refresh()
329                # with a true argument in the right places.
330                dc.BeginDrawing()
331                dc.Clear()
332                dc.EndDrawing()
333    
334                # clear the region
335                self.update_region = wx.wxRegion()
336    
337      def do_redraw(self):      def do_redraw(self):
338          width, height = self.GetSizeTuple()          # This should only be called if we have a non-empty map.
         bitmap = wx.wxEmptyBitmap(width, height)  
339    
340          dc = wx.wxMemoryDC()          # get the update region and reset it. We're not actually using
341          dc.SelectObject(bitmap)          # it anymore, though.
342            update_box = self.update_region.GetBox()
343            self.update_region = wx.wxRegion()
344    
345          dc.BeginDrawing()          # Get the window size.
346            width, height = self.GetSizeTuple()
347    
348          dc.SetBrush(wx.wxWHITE_BRUSH)          # If self.bitmap's still there, reuse it. Otherwise redraw it
349          dc.SetPen(wx.wxTRANSPARENT_PEN)          if self.bitmap is not None:
350          dc.DrawRectangle(0, 0, width, height)              bitmap = self.bitmap
   
         if 1: #self.interactor.selected_map is self.map:  
             selected_layer = self.interactor.selected_layer  
             selected_shape = self.interactor.selected_shape  
351          else:          else:
352              selected_layer = None              bitmap = wx.wxEmptyBitmap(width, height)
353              selected_shape = None              dc = wx.wxMemoryDC()
354                            dc.SelectObject(bitmap)
355          renderer = ScreenRenderer(dc, self.scale, self.offset)              dc.BeginDrawing()
356          renderer.RenderMap(self.map, selected_layer, selected_shape)  
357                # clear the background
358                dc.SetBrush(wx.wxWHITE_BRUSH)
359                dc.SetPen(wx.wxTRANSPARENT_PEN)
360                dc.DrawRectangle(0, 0, width, height)
361    
362                if 1: #self.interactor.selected_map is self.map:
363                    selected_layer = self.interactor.selected_layer
364                    selected_shape = self.interactor.selected_shape
365                else:
366                    selected_layer = None
367                    selected_shape = None
368    
369                # draw the map into the bitmap
370                renderer = ScreenRenderer(dc, self.scale, self.offset)
371    
372                # Pass the entire bitmap as update_region to the renderer.
373                # We're redrawing the whole bitmap, after all.
374                renderer.RenderMap(self.map, (0, 0, width, height),
375                                   selected_layer, selected_shape)
376    
377                dc.EndDrawing()
378                dc.SelectObject(wx.wxNullBitmap)
379                self.bitmap = bitmap
380    
381            # blit the bitmap to the screen
382            dc = wx.wxMemoryDC()
383            dc.SelectObject(bitmap)
384          clientdc = wxClientDC(self)          clientdc = wxClientDC(self)
385          clientdc.BeginDrawing()          clientdc.BeginDrawing()
386          clientdc.Blit(0, 0, width, height, dc, 0, 0)          clientdc.Blit(0, 0, width, height, dc, 0, 0)
387          clientdc.EndDrawing()          clientdc.EndDrawing()
388    
   
389      def Print(self):      def Print(self):
390          printer = wx.wxPrinter()          printer = wx.wxPrinter()
391          printout = MapPrintout(self.map)          printout = MapPrintout(self.map)
392          printer.Print(self, printout, wx.true)          printer.Print(self, printout, wx.true)
393          printout.Destroy()          printout.Destroy()
394            
395      def SetMap(self, map):      def SetMap(self, map):
396          redraw_channels = (LAYERS_CHANGED, LAYER_LEGEND_CHANGED,          redraw_channels = (LAYERS_CHANGED, LAYER_LEGEND_CHANGED,
397                             LAYER_VISIBILITY_CHANGED)                             LAYER_VISIBILITY_CHANGED)
398          if self.map is not None:          if self.map is not None:
399              for channel in redraw_channels:              for channel in redraw_channels:
400                  self.map.Unsubscribe(channel, self.redraw)                  self.map.Unsubscribe(channel, self.full_redraw)
401              self.map.Unsubscribe(MAP_PROJECTION_CHANGED,              self.map.Unsubscribe(MAP_PROJECTION_CHANGED,
402                                   self.projection_changed)                                   self.projection_changed)
403          self.map = map          self.map = map
404          if self.map is not None:          if self.map is not None:
405              for channel in redraw_channels:              for channel in redraw_channels:
406                  self.map.Subscribe(channel, self.redraw)                  self.map.Subscribe(channel, self.full_redraw)
407              self.map.Subscribe(MAP_PROJECTION_CHANGED, self.projection_changed)              self.map.Subscribe(MAP_PROJECTION_CHANGED, self.projection_changed)
408          self.FitMapToWindow()          self.FitMapToWindow()
409            # force a redraw. If map is not empty, it's already been called
410            # by FitMapToWindow but if map is empty it hasn't been called
411            # yet so we have to explicitly call it.
412            self.full_redraw()
413    
414      def Map(self):      def Map(self):
415          return self.map          return self.map
# Line 311  class MapCanvas(wxWindow): Line 417  class MapCanvas(wxWindow):
417      def redraw(self, *args):      def redraw(self, *args):
418          self.Refresh(0)          self.Refresh(0)
419    
420        def full_redraw(self, *args):
421            self.bitmap = None
422            self.redraw()
423    
424      def projection_changed(self, *args):      def projection_changed(self, *args):
425          self.FitMapToWindow()          self.FitMapToWindow()
426          self.redraw()          self.full_redraw()
427    
428      def set_view_transform(self, scale, offset):      def set_view_transform(self, scale, offset):
429          self.scale = scale          self.scale = scale
430          self.offset = offset          self.offset = offset
431          self.redraw()          self.full_redraw()
432    
433      def proj_to_win(self, x, y):      def proj_to_win(self, x, y):
434          """\          """\
# Line 337  class MapCanvas(wxWindow): Line 447  class MapCanvas(wxWindow):
447      def FitRectToWindow(self, rect):      def FitRectToWindow(self, rect):
448          width, height = self.GetSizeTuple()          width, height = self.GetSizeTuple()
449          llx, lly, urx, ury = rect          llx, lly, urx, ury = rect
450            if llx == urx or lly == ury:
451                # zero with or zero height. Do Nothing
452                return
453          scalex = width / (urx - llx)          scalex = width / (urx - llx)
454          scaley = height / (ury - lly)          scaley = height / (ury - lly)
455          scale = min(scalex, scaley)          scale = min(scalex, scaley)
# Line 353  class MapCanvas(wxWindow): Line 466  class MapCanvas(wxWindow):
466          if bbox is not None:          if bbox is not None:
467              self.FitRectToWindow(bbox)              self.FitRectToWindow(bbox)
468    
469      def ZoomFactor(self, factor):      def ZoomFactor(self, factor, center = None):
470            """Multiply the zoom by factor and center on center.
471    
472            The optional parameter center is a point in window coordinates
473            that should be centered. If it is omitted, it defaults to the
474            center of the window
475            """
476          width, height = self.GetSizeTuple()          width, height = self.GetSizeTuple()
477          scale = self.scale * factor          scale = self.scale * factor
478          offx, offy = self.offset          offx, offy = self.offset
479          offset = (factor * (offx - width / 2) + width / 2,          if center is not None:
480                    factor * (offy - height / 2) + height / 2)              cx, cy = center
481            else:
482                cx = width / 2
483                cy = height / 2
484            offset = (factor * (offx - cx) + width / 2,
485                      factor * (offy - cy) + height / 2)
486          self.set_view_transform(scale, offset)          self.set_view_transform(scale, offset)
487    
488      def ZoomOutToRect(self, rect):      def ZoomOutToRect(self, rect):
# Line 401  class MapCanvas(wxWindow): Line 525  class MapCanvas(wxWindow):
525      def CurrentTool(self):      def CurrentTool(self):
526          return self.tool and self.tool.Name() or None          return self.tool and self.tool.Name() or None
527    
528        def CurrentPosition(self):
529            """Return current position of the mouse in projected coordinates.
530    
531            The result is a 2-tuple of floats with the coordinates. If the
532            mouse is not in the window, the result is None.
533            """
534            if self.current_position is not None:
535                x, y = self.current_position
536                return self.win_to_proj(x, y)
537            else:
538                return None
539    
540        def set_current_position(self, event):
541            """Set the current position from event
542    
543            Should be called by all events that contain mouse positions
544            especially EVT_MOTION. The event paramete may be None to
545            indicate the the pointer left the window.
546            """
547            if event is not None:
548                self.current_position = (event.m_x, event.m_y)
549            else:
550                self.current_position = None
551            self.issue(VIEW_POSITION)
552    
553      def OnLeftDown(self, event):      def OnLeftDown(self, event):
554            self.set_current_position(event)
555          if self.tool is not None:          if self.tool is not None:
556              self.drag_dc = wxClientDC(self)              self.drag_dc = wxClientDC(self)
557              self.drag_dc.SetLogicalFunction(wxINVERT)              self.drag_dc.SetLogicalFunction(wxINVERT)
# Line 410  class MapCanvas(wxWindow): Line 560  class MapCanvas(wxWindow):
560              self.tool.MouseDown(event)              self.tool.MouseDown(event)
561              self.tool.Show(self.drag_dc)              self.tool.Show(self.drag_dc)
562              self.dragging = 1              self.dragging = 1
563            
564      def OnLeftUp(self, event):      def OnLeftUp(self, event):
565          self.ReleaseMouse()          self.set_current_position(event)
566          if self.dragging:          if self.dragging:
567                self.ReleaseMouse()
568              self.tool.Hide(self.drag_dc)              self.tool.Hide(self.drag_dc)
569              self.tool.MouseUp(event)              self.tool.MouseUp(event)
570              self.drag_dc = None              self.drag_dc = None
571          self.dragging = 0          self.dragging = 0
572    
573      def OnMotion(self, event):      def OnMotion(self, event):
574            self.set_current_position(event)
575          if self.dragging:          if self.dragging:
576              self.tool.Hide(self.drag_dc)              self.tool.Hide(self.drag_dc)
577              self.tool.MouseMove(event)              self.tool.MouseMove(event)
578              self.tool.Show(self.drag_dc)              self.tool.Show(self.drag_dc)
579    
580        def OnLeaveWindow(self, event):
581            self.set_current_position(None)
582    
583      def OnIdle(self, event):      def OnIdle(self, event):
584          if self.redraw_on_idle:          if self.redraw_on_idle:
585              self.do_redraw()              self.do_redraw()
586          self.redraw_on_idle = 0          self.redraw_on_idle = 0
587    
588        def OnSize(self, event):
589            # the window's size has changed. We have to get a new bitmap. If
590            # we want to be clever we could try to get by without throwing
591            # everything away. E.g. when the window gets smaller, we could
592            # either keep the bitmap or create the new one from the old one.
593            # Even when the window becomes larger some parts of the bitmap
594            # could be reused.
595            self.full_redraw()
596    
597      def shape_selected(self, layer, shape):      def shape_selected(self, layer, shape):
598          self.redraw()          """Redraw the map.
599    
600      def find_shape_at(self, px, py, select_labels = 0, selected_layer = 1):          Receiver for the SELECTED_SHAPE messages. Try to redraw only
601            when necessary.
602            """
603            # A redraw is necessary when the display has to change, which
604            # means that either the status changes from having no selection
605            # to having a selection shape or vice versa, or when the fact
606            # whether there is a selection at all doesn't change, when the
607            # shape which is selected has changed (which means that layer or
608            # shapeid changes).
609            if ((shape is not None or self.last_selected_shape is not None)
610                and (shape != self.last_selected_shape
611                     or layer != self.last_selected_layer)):
612                self.full_redraw()
613    
614            # remember the selection so we can compare when it changes again.
615            self.last_selected_layer = layer
616            self.last_selected_shape = shape
617    
618        def unprojected_rect_around_point(self, x, y):
619            """return a rect a few pixels around (x, y) in unprojected corrdinates
620    
621            The return value is a tuple (minx, miny, maxx, maxy) suitable a
622            parameter to a layer's ShapesInRegion method.
623            """
624            map_proj = self.map.projection
625            if map_proj is not None:
626                inverse = map_proj.Inverse
627            else:
628                inverse = None
629    
630            xs = []
631            ys = []
632            for dx, dy in ((-1, -1), (1, -1), (1, 1), (-1, 1)):
633                px, py = self.win_to_proj(x + dx, y + dy)
634                if inverse:
635                    px, py = inverse(px, py)
636                xs.append(px)
637                ys.append(py)
638            return (min(xs), min(ys), max(xs), max(ys))
639    
640        def find_shape_at(self, px, py, select_labels = 0, searched_layer = None):
641          """Determine the shape at point px, py in window coords          """Determine the shape at point px, py in window coords
642    
643          Return the shape and the corresponding layer as a tuple (layer,          Return the shape and the corresponding layer as a tuple (layer,
# Line 443  class MapCanvas(wxWindow): Line 647  class MapCanvas(wxWindow):
647          search through the labels. If a label is found return it's index          search through the labels. If a label is found return it's index
648          as the shape and None as the layer.          as the shape and None as the layer.
649    
650          If the optional parameter selected_layer is true (default), only          If the optional parameter searched_layer is given (or not None
651          search in the currently selected layer.          which it defaults to), only search in that layer.
652          """          """
653          map_proj = self.map.projection          map_proj = self.map.projection
654          if map_proj is not None:          if map_proj is not None:
# Line 455  class MapCanvas(wxWindow): Line 659  class MapCanvas(wxWindow):
659          scale = self.scale          scale = self.scale
660          offx, offy = self.offset          offx, offy = self.offset
661    
662            box = self.unprojected_rect_around_point(px, py)
663    
664          if select_labels:          if select_labels:
665              labels = self.map.LabelLayer().Labels()              labels = self.map.LabelLayer().Labels()
666                
667              if labels:              if labels:
668                  dc = wxClientDC(self)                  dc = wxClientDC(self)
669                  font = wxFont(10, wx.wxSWISS, wx.wxNORMAL, wx.wxNORMAL)                  font = wxFont(10, wx.wxSWISS, wx.wxNORMAL, wx.wxNORMAL)
670                  dc.SetFont(font)                  dc.SetFont(font)
671                  for i in range(len(labels)):                  for i in range(len(labels) - 1, -1, -1):
672                      label = labels[i]                      label = labels[i]
673                      x = label.x                      x = label.x
674                      y = label.y                      y = label.y
# Line 489  class MapCanvas(wxWindow): Line 695  class MapCanvas(wxWindow):
695                      if x <= px < x + width and y <= py <= y + height:                      if x <= px < x + width and y <= py <= y + height:
696                          return None, i                          return None, i
697    
698          if selected_layer:          if searched_layer:
699              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 = []  
700          else:          else:
701              layers = self.map.Layers()              layers = self.map.Layers()
702    
# Line 509  class MapCanvas(wxWindow): Line 709  class MapCanvas(wxWindow):
709    
710              filled = layer.fill is not None              filled = layer.fill is not None
711              stroked = layer.stroke is not None              stroked = layer.stroke is not None
712                    
713              layer_proj = layer.projection              layer_proj = layer.projection
714              if layer_proj is not None:              if layer_proj is not None:
715                  inverse = layer_proj.Inverse                  inverse = layer_proj.Inverse
716              else:              else:
717                  inverse = None                  inverse = None
718                    
719              shapetype = layer.ShapeType()              shapetype = layer.ShapeType()
720    
721              select_shape = -1              select_shape = -1
722    
723                shape_ids = layer.ShapesInRegion(box)
724                shape_ids.reverse()
725    
726              if shapetype == SHAPETYPE_POLYGON:              if shapetype == SHAPETYPE_POLYGON:
727                  for i in range(layer.NumShapes()):                  for i in shape_ids:
728                      result = point_in_polygon_shape(layer.shapefile.cobject(),                      result = point_in_polygon_shape(layer.shapefile.cobject(),
729                                                      i,                                                      i,
730                                                      filled, stroked,                                                      filled, stroked,
# Line 531  class MapCanvas(wxWindow): Line 735  class MapCanvas(wxWindow):
735                          select_shape = i                          select_shape = i
736                          break                          break
737              elif shapetype == SHAPETYPE_ARC:              elif shapetype == SHAPETYPE_ARC:
738                  for i in range(layer.NumShapes()):                  for i in shape_ids:
739                      result = point_in_polygon_shape(layer.shapefile.cobject(),                      result = point_in_polygon_shape(layer.shapefile.cobject(),
740                                                      i, 0, 1,                                                      i, 0, 1,
741                                                      map_proj, layer_proj,                                                      map_proj, layer_proj,
# Line 541  class MapCanvas(wxWindow): Line 745  class MapCanvas(wxWindow):
745                          select_shape = i                          select_shape = i
746                          break                          break
747              elif shapetype == SHAPETYPE_POINT:              elif shapetype == SHAPETYPE_POINT:
748                  for i in range(layer.NumShapes()):                  for i in shape_ids:
749                      shape = layer.Shape(i)                      shape = layer.Shape(i)
750                      x, y = shape.Points()[0]                      x, y = shape.Points()[0]
751                      if inverse:                      if inverse:
# Line 558  class MapCanvas(wxWindow): Line 762  class MapCanvas(wxWindow):
762                  return layer, select_shape                  return layer, select_shape
763          return None, None          return None, None
764    
765      def SelectShapeAt(self, x, y):      def SelectShapeAt(self, x, y, layer = None):
766          layer, shape = self.find_shape_at(x, y)          """\
767            Select and return the shape and its layer at window position (x, y)
768    
769            If layer is given, only search in that layer. If no layer is
770            given, search through all layers.
771    
772            Return a tuple (layer, shapeid). If no shape is found, return
773            (None, None).
774            """
775            layer, shape = result = self.find_shape_at(x, y, searched_layer=layer)
776          # If layer is None, then shape will also be None. We don't want          # If layer is None, then shape will also be None. We don't want
777          # to deselect the currently selected layer, so we simply select          # to deselect the currently selected layer, so we simply select
778          # the already selected layer again.          # the already selected layer again.
779          if layer is None:          if layer is None:
780              layer = self.interactor.SelectedLayer()              layer = self.interactor.SelectedLayer()
781          self.interactor.SelectLayerAndShape(layer, shape)          self.interactor.SelectLayerAndShape(layer, shape)
782            return result
783    
784      def LabelShapeAt(self, x, y):      def LabelShapeAt(self, x, y):
785          ox = x; oy = y          ox = x; oy = y
Legend:
Removed from v.43  
changed lines
  Added in v.288
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26