/[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 261 by bh, Thu Aug 15 17:44:33 2002 UTC
# Line 140  class ZoomInTool(RectTool): Line 140  class ZoomInTool(RectTool):
140  class ZoomOutTool(RectTool):  class ZoomOutTool(RectTool):
141    
142      """The Zoom-Out Tool"""      """The Zoom-Out Tool"""
143        
144      def Name(self):      def Name(self):
145          return "ZoomOutTool"          return "ZoomOutTool"
146    
# Line 151  class ZoomOutTool(RectTool): Line 151  class ZoomOutTool(RectTool):
151              cx, cy = self.current              cx, cy = self.current
152              if sx == cx and sy == cy:              if sx == cx and sy == cy:
153                  # Just a mouse click. Simply zoom out by a factor of two                  # Just a mouse click. Simply zoom out by a factor of two
154                  self.view.ZoomFactor(0.5, center = (cy, cy))                  self.view.ZoomFactor(0.5, center = (cx, cy))
155              else:              else:
156                  # A drag. Zoom out to the rectangle                  # A drag. Zoom out to the rectangle
157                  self.view.ZoomOutToRect((min(sx, cx), min(sy, cy),                  self.view.ZoomOutToRect((min(sx, cx), min(sy, cy),
# Line 167  class PanTool(Tool): Line 167  class PanTool(Tool):
167    
168      def MouseMove(self, event):      def MouseMove(self, event):
169          if self.dragging:          if self.dragging:
             x0, y0 = self.current  
170              Tool.MouseMove(self, event)              Tool.MouseMove(self, event)
171                sx, sy = self.start
172              x, y = self.current              x, y = self.current
173              width, height = self.view.GetSizeTuple()              width, height = self.view.GetSizeTuple()
174    
175                bitmapdc = wx.wxMemoryDC()
176                bitmapdc.SelectObject(self.view.bitmap)
177    
178              dc = self.view.drag_dc              dc = self.view.drag_dc
179              dc.Blit(0, 0, width, height, dc, x0 - x, y0 - y)              dc.Blit(0, 0, width, height, bitmapdc, sx - x, sy - y)
180    
181      def MouseUp(self, event):      def MouseUp(self, event):
182          if self.dragging:          if self.dragging:
# Line 180  class PanTool(Tool): Line 184  class PanTool(Tool):
184              sx, sy = self.start              sx, sy = self.start
185              cx, cy = self.current              cx, cy = self.current
186              self.view.Translate(cx - sx, cy - sy)              self.view.Translate(cx - sx, cy - sy)
187            
188  class IdentifyTool(Tool):  class IdentifyTool(Tool):
189    
190      """The "Identify" Tool"""      """The "Identify" Tool"""
191        
192      def Name(self):      def Name(self):
193          return "IdentifyTool"          return "IdentifyTool"
194    
# Line 238  class MapPrintout(wx.wxPrintout): Line 242  class MapPrintout(wx.wxPrintout):
242          renderer = PrinterRender(dc, scale, (offx, offy), resolution = resx)          renderer = PrinterRender(dc, scale, (offx, offy), resolution = resx)
243          renderer.RenderMap(self.map)          renderer.RenderMap(self.map)
244          return wx.true          return wx.true
245            
246    
247  class MapCanvas(wxWindow, Publisher):  class MapCanvas(wxWindow, Publisher):
248    
# 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 305  class MapCanvas(wxWindow, Publisher): Line 314  class MapCanvas(wxWindow, Publisher):
314          else:          else:
315              # 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
316              # the screen.              # the screen.
317                
318              # XXX it's probably possible to get rid of this. The              # XXX it's probably possible to get rid of this. The
319              # background color of the window is already white and the              # background color of the window is already white and the
320              # only thing we may have to do is to call self.Refresh()              # only thing we may have to do is to call self.Refresh()
321              # with a true argument in the right places.              # with a true argument in the right places.
322              dc.BeginDrawing()              dc.BeginDrawing()
323              dc.Clear()                          dc.Clear()
324              dc.EndDrawing()              dc.EndDrawing()
325    
326              # clear the region              # clear the region
# Line 374  class MapCanvas(wxWindow, Publisher): Line 383  class MapCanvas(wxWindow, Publisher):
383          printout = MapPrintout(self.map)          printout = MapPrintout(self.map)
384          printer.Print(self, printout, wx.true)          printer.Print(self, printout, wx.true)
385          printout.Destroy()          printout.Destroy()
386            
387      def SetMap(self, map):      def SetMap(self, map):
388          redraw_channels = (LAYERS_CHANGED, LAYER_LEGEND_CHANGED,          redraw_channels = (LAYERS_CHANGED, LAYER_LEGEND_CHANGED,
389                             LAYER_VISIBILITY_CHANGED)                             LAYER_VISIBILITY_CHANGED)
# Line 543  class MapCanvas(wxWindow, Publisher): Line 552  class MapCanvas(wxWindow, Publisher):
552              self.tool.MouseDown(event)              self.tool.MouseDown(event)
553              self.tool.Show(self.drag_dc)              self.tool.Show(self.drag_dc)
554              self.dragging = 1              self.dragging = 1
555            
556      def OnLeftUp(self, event):      def OnLeftUp(self, event):
         self.ReleaseMouse()  
557          self.set_current_position(event)          self.set_current_position(event)
558          if self.dragging:          if self.dragging:
559                self.ReleaseMouse()
560              self.tool.Hide(self.drag_dc)              self.tool.Hide(self.drag_dc)
561              self.tool.MouseUp(event)              self.tool.MouseUp(event)
562              self.drag_dc = None              self.drag_dc = None
# Line 578  class MapCanvas(wxWindow, Publisher): Line 587  class MapCanvas(wxWindow, Publisher):
587          self.full_redraw()          self.full_redraw()
588    
589      def shape_selected(self, layer, shape):      def shape_selected(self, layer, shape):
590          self.full_redraw()          """Redraw the map.
591    
592            Receiver for the SELECTED_SHAPE messages. Try to redraw only
593            when necessary.
594            """
595            # A redraw is necessary when the display has to change, which
596            # means that either the status changes from having no selection
597            # to having a selection shape or vice versa, or when the fact
598            # whether there is a selection at all doesn't change, when the
599            # shape which is selected has changed (which means that layer or
600            # shapeid changes).
601            if ((shape is not None or self.last_selected_shape is not None)
602                and (shape != self.last_selected_shape
603                     or layer != self.last_selected_layer)):
604                self.full_redraw()
605    
606            # remember the selection so we can compare when it changes again.
607            self.last_selected_layer = layer
608            self.last_selected_shape = shape
609    
610        def unprojected_rect_around_point(self, x, y):
611            """return a rect a few pixels around (x, y) in unprojected corrdinates
612    
613      def find_shape_at(self, px, py, select_labels = 0, selected_layer = 1):          The return value is a tuple (minx, miny, maxx, maxy) suitable a
614            parameter to a layer's ShapesInRegion method.
615            """
616            map_proj = self.map.projection
617            if map_proj is not None:
618                inverse = map_proj.Inverse
619            else:
620                inverse = None
621    
622            xs = []
623            ys = []
624            for dx, dy in ((-1, -1), (1, -1), (1, 1), (-1, 1)):
625                px, py = self.win_to_proj(x + dx, y + dy)
626                if inverse:
627                    px, py = inverse(px, py)
628                xs.append(px)
629                ys.append(py)
630            return (min(xs), min(ys), max(xs), max(ys))
631    
632        def find_shape_at(self, px, py, select_labels = 0, searched_layer = None):
633          """Determine the shape at point px, py in window coords          """Determine the shape at point px, py in window coords
634    
635          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 639  class MapCanvas(wxWindow, Publisher):
639          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
640          as the shape and None as the layer.          as the shape and None as the layer.
641    
642          If the optional parameter selected_layer is true (default), only          If the optional parameter searched_layer is given (or not None
643          search in the currently selected layer.          which it defaults to), only search in that layer.
644          """          """
645          map_proj = self.map.projection          map_proj = self.map.projection
646          if map_proj is not None:          if map_proj is not None:
# Line 602  class MapCanvas(wxWindow, Publisher): Line 651  class MapCanvas(wxWindow, Publisher):
651          scale = self.scale          scale = self.scale
652          offx, offy = self.offset          offx, offy = self.offset
653    
654            box = self.unprojected_rect_around_point(px, py)
655    
656          if select_labels:          if select_labels:
657              labels = self.map.LabelLayer().Labels()              labels = self.map.LabelLayer().Labels()
658                
659              if labels:              if labels:
660                  dc = wxClientDC(self)                  dc = wxClientDC(self)
661                  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 687  class MapCanvas(wxWindow, Publisher):
687                      if x <= px < x + width and y <= py <= y + height:                      if x <= px < x + width and y <= py <= y + height:
688                          return None, i                          return None, i
689    
690          if selected_layer:          if searched_layer:
691              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 = []  
692          else:          else:
693              layers = self.map.Layers()              layers = self.map.Layers()
694    
# Line 656  class MapCanvas(wxWindow, Publisher): Line 701  class MapCanvas(wxWindow, Publisher):
701    
702              filled = layer.fill is not None              filled = layer.fill is not None
703              stroked = layer.stroke is not None              stroked = layer.stroke is not None
704                    
705              layer_proj = layer.projection              layer_proj = layer.projection
706              if layer_proj is not None:              if layer_proj is not None:
707                  inverse = layer_proj.Inverse                  inverse = layer_proj.Inverse
708              else:              else:
709                  inverse = None                  inverse = None
710                    
711              shapetype = layer.ShapeType()              shapetype = layer.ShapeType()
712    
713              select_shape = -1              select_shape = -1
714    
715                shape_ids = layer.ShapesInRegion(box)
716                shape_ids.reverse()
717    
718              if shapetype == SHAPETYPE_POLYGON:              if shapetype == SHAPETYPE_POLYGON:
719                  for i in range(layer.NumShapes() - 1, -1, -1):                  for i in shape_ids:
720                      result = point_in_polygon_shape(layer.shapefile.cobject(),                      result = point_in_polygon_shape(layer.shapefile.cobject(),
721                                                      i,                                                      i,
722                                                      filled, stroked,                                                      filled, stroked,
# Line 678  class MapCanvas(wxWindow, Publisher): Line 727  class MapCanvas(wxWindow, Publisher):
727                          select_shape = i                          select_shape = i
728                          break                          break
729              elif shapetype == SHAPETYPE_ARC:              elif shapetype == SHAPETYPE_ARC:
730                  for i in range(layer.NumShapes() - 1, -1, -1):                  for i in shape_ids:
731                      result = point_in_polygon_shape(layer.shapefile.cobject(),                      result = point_in_polygon_shape(layer.shapefile.cobject(),
732                                                      i, 0, 1,                                                      i, 0, 1,
733                                                      map_proj, layer_proj,                                                      map_proj, layer_proj,
# Line 688  class MapCanvas(wxWindow, Publisher): Line 737  class MapCanvas(wxWindow, Publisher):
737                          select_shape = i                          select_shape = i
738                          break                          break
739              elif shapetype == SHAPETYPE_POINT:              elif shapetype == SHAPETYPE_POINT:
740                  for i in range(layer.NumShapes() - 1, -1, -1):                  for i in shape_ids:
741                      shape = layer.Shape(i)                      shape = layer.Shape(i)
742                      x, y = shape.Points()[0]                      x, y = shape.Points()[0]
743                      if inverse:                      if inverse:
# Line 705  class MapCanvas(wxWindow, Publisher): Line 754  class MapCanvas(wxWindow, Publisher):
754                  return layer, select_shape                  return layer, select_shape
755          return None, None          return None, None
756    
757      def SelectShapeAt(self, x, y):      def SelectShapeAt(self, x, y, layer = None):
758          layer, shape = self.find_shape_at(x, y, selected_layer = 0)          """\
759            Select and return the shape and its layer at window position (x, y)
760    
761            If layer is given, only search in that layer. If no layer is
762            given, search through all layers.
763    
764            Return a tuple (layer, shapeid). If no shape is found, return
765            (None, None).
766            """
767            layer, shape = result = self.find_shape_at(x, y, searched_layer=layer)
768          # 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
769          # to deselect the currently selected layer, so we simply select          # to deselect the currently selected layer, so we simply select
770          # the already selected layer again.          # the already selected layer again.
771          if layer is None:          if layer is None:
772              layer = self.interactor.SelectedLayer()              layer = self.interactor.SelectedLayer()
773          self.interactor.SelectLayerAndShape(layer, shape)          self.interactor.SelectLayerAndShape(layer, shape)
774            return result
775    
776      def LabelShapeAt(self, x, y):      def LabelShapeAt(self, x, y):
777          ox = x; oy = y          ox = x; oy = y
Legend:
Removed from v.149  
changed lines
  Added in v.261
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26