/[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 149 by bh, Tue May 7 16:41:07 2002 UTC revision 404 by bh, Fri Feb 14 17:40:26 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  #  #
# Line 129  class ZoomInTool(RectTool): Line 129  class ZoomInTool(RectTool):
129              Tool.MouseUp(self, event)              Tool.MouseUp(self, event)
130              sx, sy = self.start              sx, sy = self.start
131              cx, cy = self.current              cx, cy = self.current
132              if sx == cx and sy == cy:              if sx == cx or sy == cy:
133                  # Just a mouse click. Simply zoom in by a factor of two                  # 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))                  self.view.ZoomFactor(2, center = (cx, cy))
139              else:              else:
140                  # A drag. Zoom in to the rectangle                  # A drag. Zoom in to the rectangle
# Line 140  class ZoomInTool(RectTool): Line 144  class ZoomInTool(RectTool):
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 149  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              if sx == cx and sy == cy:              if sx == cx or sy == cy:
157                  # Just a mouse click. Simply zoom out by a factor of two                  # Just a mouse click or a degenerate rectangle. Simply
158                  self.view.ZoomFactor(0.5, center = (cy, cy))                  # 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:              else:
164                  # A drag. Zoom out to the rectangle                  # A drag. Zoom out to the rectangle
165                  self.view.ZoomOutToRect((min(sx, cx), min(sy, cy),                  self.view.ZoomOutToRect((min(sx, cx), min(sy, cy),
# Line 167  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 180  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 238  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    
255  class MapCanvas(wxWindow, Publisher):  class MapCanvas(wxWindow, Publisher):
256    
# Line 267  class MapCanvas(wxWindow, Publisher): Line 279  class MapCanvas(wxWindow, Publisher):
279          # if the mouse is outside the window.          # if the mouse is outside the window.
280          self.current_position = None          self.current_position = None
281    
         # 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()  
   
282          # the bitmap serving as backing store          # the bitmap serving as backing store
283          self.bitmap = None          self.bitmap = None
284    
# Line 282  class MapCanvas(wxWindow, Publisher): Line 286  class MapCanvas(wxWindow, Publisher):
286          self.interactor = interactor          self.interactor = interactor
287          self.interactor.Subscribe(SELECTED_SHAPE, self.shape_selected)          self.interactor.Subscribe(SELECTED_SHAPE, self.shape_selected)
288    
289            # keep track of which layers/shapes are selected to make sure we
290            # only redraw when necessary
291            self.last_selected_layer = None
292            self.last_selected_shape = None
293    
294          # subscribe the WX events we're interested in          # subscribe the WX events we're interested in
295          EVT_PAINT(self, self.OnPaint)          EVT_PAINT(self, self.OnPaint)
296          EVT_LEFT_DOWN(self, self.OnLeftDown)          EVT_LEFT_DOWN(self, self.OnLeftDown)
# Line 289  class MapCanvas(wxWindow, Publisher): Line 298  class MapCanvas(wxWindow, Publisher):
298          EVT_MOTION(self, self.OnMotion)          EVT_MOTION(self, self.OnMotion)
299          EVT_LEAVE_WINDOW(self, self.OnLeaveWindow)          EVT_LEAVE_WINDOW(self, self.OnLeaveWindow)
300          wx.EVT_SIZE(self, self.OnSize)          wx.EVT_SIZE(self, self.OnSize)
         wx.EVT_IDLE(self, self.OnIdle)  
301    
302      def __del__(self):      def __del__(self):
303          wxWindow.__del__(self)          wxWindow.__del__(self)
# Line 298  class MapCanvas(wxWindow, Publisher): Line 306  class MapCanvas(wxWindow, Publisher):
306      def OnPaint(self, event):      def OnPaint(self, event):
307          dc = wxPaintDC(self)          dc = wxPaintDC(self)
308          if self.map is not None and self.map.HasLayers():          if self.map is not None and self.map.HasLayers():
309              # We have a non-empty map. Redraw it in idle time              self.do_redraw()
             self.redraw_on_idle = 1  
             # update the region that has to be redrawn  
             self.update_region.UnionRegion(self.GetUpdateRegion())  
310          else:          else:
311              # If we've got no map or if the map is empty, simply clear              # If we've got no map or if the map is empty, simply clear
312              # the screen.              # the screen.
313                
314              # XXX it's probably possible to get rid of this. The              # XXX it's probably possible to get rid of this. The
315              # background color of the window is already white and the              # background color of the window is already white and the
316              # only thing we may have to do is to call self.Refresh()              # only thing we may have to do is to call self.Refresh()
317              # with a true argument in the right places.              # with a true argument in the right places.
318              dc.BeginDrawing()              dc.BeginDrawing()
319              dc.Clear()                          dc.Clear()
320              dc.EndDrawing()              dc.EndDrawing()
321    
             # clear the region  
             self.update_region = wx.wxRegion()  
   
322      def do_redraw(self):      def do_redraw(self):
323          # This should only be called if we have a non-empty map.          # This should only be called if we have a non-empty map.
324    
         # 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()  
   
325          # Get the window size.          # Get the window size.
326          width, height = self.GetSizeTuple()          width, height = self.GetSizeTuple()
327    
# Line 352  class MapCanvas(wxWindow, Publisher): Line 349  class MapCanvas(wxWindow, Publisher):
349              # draw the map into the bitmap              # draw the map into the bitmap
350              renderer = ScreenRenderer(dc, self.scale, self.offset)              renderer = ScreenRenderer(dc, self.scale, self.offset)
351    
352              # Pass the entire bitmap as update_region to the renderer.              # Pass the entire bitmap as update region to the renderer.
353              # We're redrawing the whole bitmap, after all.              # We're redrawing the whole bitmap, after all.
354              renderer.RenderMap(self.map, (0, 0, width, height),              renderer.RenderMap(self.map, (0, 0, width, height),
355                                 selected_layer, selected_shape)                                 selected_layer, selected_shape)
# Line 374  class MapCanvas(wxWindow, Publisher): Line 371  class MapCanvas(wxWindow, Publisher):
371          printout = MapPrintout(self.map)          printout = MapPrintout(self.map)
372          printer.Print(self, printout, wx.true)          printer.Print(self, printout, wx.true)
373          printout.Destroy()          printout.Destroy()
374            
375      def SetMap(self, map):      def SetMap(self, map):
376          redraw_channels = (LAYERS_CHANGED, LAYER_LEGEND_CHANGED,          redraw_channels = (LAYERS_CHANGED, LAYER_LEGEND_CHANGED,
377                             LAYER_VISIBILITY_CHANGED)                             LAYER_VISIBILITY_CHANGED)
# Line 395  class MapCanvas(wxWindow, Publisher): Line 392  class MapCanvas(wxWindow, Publisher):
392          self.full_redraw()          self.full_redraw()
393    
394      def Map(self):      def Map(self):
395            """Return the map displayed by this canvas"""
396          return self.map          return self.map
397    
398      def redraw(self, *args):      def redraw(self, *args):
# Line 428  class MapCanvas(wxWindow, Publisher): Line 426  class MapCanvas(wxWindow, Publisher):
426          return ((x - offx) / self.scale, (offy - y) / self.scale)          return ((x - offx) / self.scale, (offy - y) / self.scale)
427    
428      def FitRectToWindow(self, rect):      def FitRectToWindow(self, rect):
429            """Fit the rectangular region given by rect into the window.
430            
431            Set scale so that rect (in projected coordinates) just fits into
432            the window and center it.
433            """
434          width, height = self.GetSizeTuple()          width, height = self.GetSizeTuple()
435          llx, lly, urx, ury = rect          llx, lly, urx, ury = rect
436          if llx == urx or lly == ury:          if llx == urx or lly == ury:
# Line 441  class MapCanvas(wxWindow, Publisher): Line 444  class MapCanvas(wxWindow, Publisher):
444          self.set_view_transform(scale, (offx, offy))          self.set_view_transform(scale, (offx, offy))
445    
446      def FitMapToWindow(self):      def FitMapToWindow(self):
447          """\          """Fit the map to the window
448          Set the scale and offset so that the map is centered in the          
449          window          Set the scale so that the map fits exactly into the window and
450            center it in the window.
451          """          """
452          bbox = self.map.ProjectedBoundingBox()          bbox = self.map.ProjectedBoundingBox()
453          if bbox is not None:          if bbox is not None:
# Line 469  class MapCanvas(wxWindow, Publisher): Line 473  class MapCanvas(wxWindow, Publisher):
473          self.set_view_transform(scale, offset)          self.set_view_transform(scale, offset)
474    
475      def ZoomOutToRect(self, rect):      def ZoomOutToRect(self, rect):
476          # rect is given in window coordinates          """Zoom out to fit the currently visible region into rect.
477    
478            The rect parameter is given in window coordinates
479            """
480          # determine the bbox of the displayed region in projected          # determine the bbox of the displayed region in projected
481          # coordinates          # coordinates
482          width, height = self.GetSizeTuple()          width, height = self.GetSizeTuple()
# Line 487  class MapCanvas(wxWindow, Publisher): Line 493  class MapCanvas(wxWindow, Publisher):
493          self.set_view_transform(scale, (offx, offy))          self.set_view_transform(scale, (offx, offy))
494    
495      def Translate(self, dx, dy):      def Translate(self, dx, dy):
496            """Move the map by dx, dy pixels"""
497          offx, offy = self.offset          offx, offy = self.offset
498          self.set_view_transform(self.scale, (offx + dx, offy + dy))          self.set_view_transform(self.scale, (offx + dx, offy + dy))
499    
500        def SelectTool(self, tool):
501            """Make tool the active tool.
502    
503            The parameter should be an instance of Tool or None to indicate
504            that no tool is active.
505            """
506            self.tool = tool
507    
508      def ZoomInTool(self):      def ZoomInTool(self):
509          self.tool = ZoomInTool(self)          """Start the zoom in tool"""
510            self.SelectTool(ZoomInTool(self))
511    
512      def ZoomOutTool(self):      def ZoomOutTool(self):
513          self.tool = ZoomOutTool(self)          """Start the zoom out tool"""
514            self.SelectTool(ZoomOutTool(self))
515    
516      def PanTool(self):      def PanTool(self):
517          self.tool = PanTool(self)          """Start the pan tool"""
518            self.SelectTool(PanTool(self))
519    
520      def IdentifyTool(self):      def IdentifyTool(self):
521          self.tool = IdentifyTool(self)          """Start the identify tool"""
522            self.SelectTool(IdentifyTool(self))
523    
524      def LabelTool(self):      def LabelTool(self):
525          self.tool = LabelTool(self)          """Start the label tool"""
526            self.SelectTool(LabelTool(self))
527    
528      def CurrentTool(self):      def CurrentTool(self):
529            """Return the name of the current tool or None if no tool is active"""
530          return self.tool and self.tool.Name() or None          return self.tool and self.tool.Name() or None
531    
532      def CurrentPosition(self):      def CurrentPosition(self):
# Line 543  class MapCanvas(wxWindow, Publisher): Line 564  class MapCanvas(wxWindow, Publisher):
564              self.tool.MouseDown(event)              self.tool.MouseDown(event)
565              self.tool.Show(self.drag_dc)              self.tool.Show(self.drag_dc)
566              self.dragging = 1              self.dragging = 1
567            
568      def OnLeftUp(self, event):      def OnLeftUp(self, event):
         self.ReleaseMouse()  
569          self.set_current_position(event)          self.set_current_position(event)
570          if self.dragging:          if self.dragging:
571              self.tool.Hide(self.drag_dc)              self.ReleaseMouse()
572              self.tool.MouseUp(event)              try:
573              self.drag_dc = None                  self.tool.Hide(self.drag_dc)
574          self.dragging = 0                  self.tool.MouseUp(event)
575                finally:
576                    self.drag_dc = None
577                    self.dragging = 0
578    
579      def OnMotion(self, event):      def OnMotion(self, event):
580          self.set_current_position(event)          self.set_current_position(event)
# Line 563  class MapCanvas(wxWindow, Publisher): Line 586  class MapCanvas(wxWindow, Publisher):
586      def OnLeaveWindow(self, event):      def OnLeaveWindow(self, event):
587          self.set_current_position(None)          self.set_current_position(None)
588    
     def OnIdle(self, event):  
         if self.redraw_on_idle:  
             self.do_redraw()  
         self.redraw_on_idle = 0  
   
589      def OnSize(self, event):      def OnSize(self, event):
590          # the window's size has changed. We have to get a new bitmap. If          # the window's size has changed. We have to get a new bitmap. If
591          # we want to be clever we could try to get by without throwing          # we want to be clever we could try to get by without throwing
# Line 578  class MapCanvas(wxWindow, Publisher): Line 596  class MapCanvas(wxWindow, Publisher):
596          self.full_redraw()          self.full_redraw()
597    
598      def shape_selected(self, layer, shape):      def shape_selected(self, layer, shape):
599          self.full_redraw()          """Redraw the map.
600    
601            Receiver for the SELECTED_SHAPE messages. Try to redraw only
602            when necessary.
603            """
604            # A redraw is necessary when the display has to change, which
605            # means that either the status changes from having no selection
606            # to having a selection shape or vice versa, or when the fact
607            # whether there is a selection at all doesn't change, when the
608            # shape which is selected has changed (which means that layer or
609            # shapeid changes).
610            if ((shape is not None or self.last_selected_shape is not None)
611                and (shape != self.last_selected_shape
612                     or layer != self.last_selected_layer)):
613                self.full_redraw()
614    
615            # remember the selection so we can compare when it changes again.
616            self.last_selected_layer = layer
617            self.last_selected_shape = shape
618    
619        def unprojected_rect_around_point(self, x, y, dist):
620            """return a rect dist pixels around (x, y) in unprojected corrdinates
621    
622            The return value is a tuple (minx, miny, maxx, maxy) suitable a
623            parameter to a layer's ShapesInRegion method.
624            """
625            map_proj = self.map.projection
626            if map_proj is not None:
627                inverse = map_proj.Inverse
628            else:
629                inverse = None
630    
631            xs = []
632            ys = []
633            for dx, dy in ((-1, -1), (1, -1), (1, 1), (-1, 1)):
634                px, py = self.win_to_proj(x + dist * dx, y + dist * dy)
635                if inverse:
636                    px, py = inverse(px, py)
637                xs.append(px)
638                ys.append(py)
639            return (min(xs), min(ys), max(xs), max(ys))
640    
641      def find_shape_at(self, px, py, select_labels = 0, selected_layer = 1):      def find_shape_at(self, px, py, select_labels = 0, searched_layer = None):
642          """Determine the shape at point px, py in window coords          """Determine the shape at point px, py in window coords
643    
644          Return the shape and the corresponding layer as a tuple (layer,          Return the shape and the corresponding layer as a tuple (layer,
# Line 590  class MapCanvas(wxWindow, Publisher): Line 648  class MapCanvas(wxWindow, Publisher):
648          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
649          as the shape and None as the layer.          as the shape and None as the layer.
650    
651          If the optional parameter selected_layer is true (default), only          If the optional parameter searched_layer is given (or not None
652          search in the currently selected layer.          which it defaults to), only search in that layer.
653          """          """
654          map_proj = self.map.projection          map_proj = self.map.projection
655          if map_proj is not None:          if map_proj is not None:
# Line 604  class MapCanvas(wxWindow, Publisher): Line 662  class MapCanvas(wxWindow, Publisher):
662    
663          if select_labels:          if select_labels:
664              labels = self.map.LabelLayer().Labels()              labels = self.map.LabelLayer().Labels()
665                
666              if labels:              if labels:
667                  dc = wxClientDC(self)                  dc = wxClientDC(self)
668                  font = wxFont(10, wx.wxSWISS, wx.wxNORMAL, wx.wxNORMAL)                  font = wxFont(10, wx.wxSWISS, wx.wxNORMAL, wx.wxNORMAL)
# Line 636  class MapCanvas(wxWindow, Publisher): Line 694  class MapCanvas(wxWindow, Publisher):
694                      if x <= px < x + width and y <= py <= y + height:                      if x <= px < x + width and y <= py <= y + height:
695                          return None, i                          return None, i
696    
697          if selected_layer:          if searched_layer:
698              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 = []  
699          else:          else:
700              layers = self.map.Layers()              layers = self.map.Layers()
701    
# Line 656  class MapCanvas(wxWindow, Publisher): Line 708  class MapCanvas(wxWindow, Publisher):
708    
709              filled = layer.fill is not None              filled = layer.fill is not None
710              stroked = layer.stroke is not None              stroked = layer.stroke is not None
711                    
712              layer_proj = layer.projection              layer_proj = layer.projection
713              if layer_proj is not None:              if layer_proj is not None:
714                  inverse = layer_proj.Inverse                  inverse = layer_proj.Inverse
715              else:              else:
716                  inverse = None                  inverse = None
717                    
718              shapetype = layer.ShapeType()              shapetype = layer.ShapeType()
719    
720              select_shape = -1              select_shape = -1
721    
722                # Determine the ids of the shapes that overlap a tiny area
723                # around the point. For layers containing points we have to
724                # choose a larger size of the box we're testing agains so
725                # that we take the size of the markers into account
726                # FIXME: Once the markers are more flexible this part has to
727                # become more flexible too, of course
728                if shapetype == SHAPETYPE_POINT:
729                    box = self.unprojected_rect_around_point(px, py, 5)
730                else:
731                    box = self.unprojected_rect_around_point(px, py, 1)
732                shape_ids = layer.ShapesInRegion(box)
733                shape_ids.reverse()
734    
735              if shapetype == SHAPETYPE_POLYGON:              if shapetype == SHAPETYPE_POLYGON:
736                  for i in range(layer.NumShapes() - 1, -1, -1):                  for i in shape_ids:
737                      result = point_in_polygon_shape(layer.shapefile.cobject(),                      result = point_in_polygon_shape(layer.shapefile.cobject(),
738                                                      i,                                                      i,
739                                                      filled, stroked,                                                      filled, stroked,
# Line 678  class MapCanvas(wxWindow, Publisher): Line 744  class MapCanvas(wxWindow, Publisher):
744                          select_shape = i                          select_shape = i
745                          break                          break
746              elif shapetype == SHAPETYPE_ARC:              elif shapetype == SHAPETYPE_ARC:
747                  for i in range(layer.NumShapes() - 1, -1, -1):                  for i in shape_ids:
748                      result = point_in_polygon_shape(layer.shapefile.cobject(),                      result = point_in_polygon_shape(layer.shapefile.cobject(),
749                                                      i, 0, 1,                                                      i, 0, 1,
750                                                      map_proj, layer_proj,                                                      map_proj, layer_proj,
# Line 688  class MapCanvas(wxWindow, Publisher): Line 754  class MapCanvas(wxWindow, Publisher):
754                          select_shape = i                          select_shape = i
755                          break                          break
756              elif shapetype == SHAPETYPE_POINT:              elif shapetype == SHAPETYPE_POINT:
757                  for i in range(layer.NumShapes() - 1, -1, -1):                  for i in shape_ids:
758                      shape = layer.Shape(i)                      shape = layer.Shape(i)
759                      x, y = shape.Points()[0]                      x, y = shape.Points()[0]
760                      if inverse:                      if inverse:
# Line 705  class MapCanvas(wxWindow, Publisher): Line 771  class MapCanvas(wxWindow, Publisher):
771                  return layer, select_shape                  return layer, select_shape
772          return None, None          return None, None
773    
774      def SelectShapeAt(self, x, y):      def SelectShapeAt(self, x, y, layer = None):
775          layer, shape = self.find_shape_at(x, y, selected_layer = 0)          """\
776            Select and return the shape and its layer at window position (x, y)
777    
778            If layer is given, only search in that layer. If no layer is
779            given, search through all layers.
780    
781            Return a tuple (layer, shapeid). If no shape is found, return
782            (None, None).
783            """
784            layer, shape = result = self.find_shape_at(x, y, searched_layer=layer)
785          # 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
786          # to deselect the currently selected layer, so we simply select          # to deselect the currently selected layer, so we simply select
787          # the already selected layer again.          # the already selected layer again.
788          if layer is None:          if layer is None:
789              layer = self.interactor.SelectedLayer()              layer = self.interactor.SelectedLayer()
790          self.interactor.SelectLayerAndShape(layer, shape)          self.interactor.SelectLayerAndShape(layer, shape)
791            return result
792    
793      def LabelShapeAt(self, x, y):      def LabelShapeAt(self, x, y):
794            """Add or remove a label at window position x, y.
795    
796            If there's a label at the given position, remove it. Otherwise
797            determine the shape at the position, run the label dialog and
798            unless the user cancels the dialog, add a laber.
799            """
800          ox = x; oy = y          ox = x; oy = y
801          label_layer = self.map.LabelLayer()          label_layer = self.map.LabelLayer()
802          layer, shape_index = self.find_shape_at(x, y, select_labels = 1)          layer, shape_index = self.find_shape_at(x, y, select_labels = 1)
Legend:
Removed from v.149  
changed lines
  Added in v.404
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26