/[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 293 by bh, Fri Aug 30 10:18:50 2002 UTC
# 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 282  class MapCanvas(wxWindow, Publisher): Line 294  class MapCanvas(wxWindow, Publisher):
294          self.interactor = interactor          self.interactor = interactor
295          self.interactor.Subscribe(SELECTED_SHAPE, self.shape_selected)          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          # 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)
# Line 305  class MapCanvas(wxWindow, Publisher): Line 322  class MapCanvas(wxWindow, Publisher):
322          else:          else:
323              # 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
324              # the screen.              # the screen.
325                
326              # XXX it's probably possible to get rid of this. The              # XXX it's probably possible to get rid of this. The
327              # background color of the window is already white and the              # background color of the window is already white and the
328              # only thing we may have to do is to call self.Refresh()              # only thing we may have to do is to call self.Refresh()
329              # with a true argument in the right places.              # with a true argument in the right places.
330              dc.BeginDrawing()              dc.BeginDrawing()
331              dc.Clear()                          dc.Clear()
332              dc.EndDrawing()              dc.EndDrawing()
333    
334              # clear the region              # clear the region
# Line 374  class MapCanvas(wxWindow, Publisher): Line 391  class MapCanvas(wxWindow, Publisher):
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)
# Line 428  class MapCanvas(wxWindow, Publisher): Line 445  class MapCanvas(wxWindow, Publisher):
445          return ((x - offx) / self.scale, (offy - y) / self.scale)          return ((x - offx) / self.scale, (offy - y) / self.scale)
446    
447      def FitRectToWindow(self, rect):      def FitRectToWindow(self, rect):
448            """Fit the rectangular region given by rect into the window.
449            
450            Set scale so that rect (in projected coordinates) just fits into
451            the window and center it.
452            """
453          width, height = self.GetSizeTuple()          width, height = self.GetSizeTuple()
454          llx, lly, urx, ury = rect          llx, lly, urx, ury = rect
455          if llx == urx or lly == ury:          if llx == urx or lly == ury:
# Line 441  class MapCanvas(wxWindow, Publisher): Line 463  class MapCanvas(wxWindow, Publisher):
463          self.set_view_transform(scale, (offx, offy))          self.set_view_transform(scale, (offx, offy))
464    
465      def FitMapToWindow(self):      def FitMapToWindow(self):
466          """\          """Fit the map to the window
467          Set the scale and offset so that the map is centered in the          
468          window          Set the scale so that the map fits exactly into the window and
469            center it in the window.
470          """          """
471          bbox = self.map.ProjectedBoundingBox()          bbox = self.map.ProjectedBoundingBox()
472          if bbox is not None:          if bbox is not None:
# Line 469  class MapCanvas(wxWindow, Publisher): Line 492  class MapCanvas(wxWindow, Publisher):
492          self.set_view_transform(scale, offset)          self.set_view_transform(scale, offset)
493    
494      def ZoomOutToRect(self, rect):      def ZoomOutToRect(self, rect):
495          # rect is given in window coordinates          """Zoom out to fit the currently visible region into rect.
496    
497            The rect parameter is given in window coordinates
498            """
499          # determine the bbox of the displayed region in projected          # determine the bbox of the displayed region in projected
500          # coordinates          # coordinates
501          width, height = self.GetSizeTuple()          width, height = self.GetSizeTuple()
# Line 543  class MapCanvas(wxWindow, Publisher): Line 568  class MapCanvas(wxWindow, Publisher):
568              self.tool.MouseDown(event)              self.tool.MouseDown(event)
569              self.tool.Show(self.drag_dc)              self.tool.Show(self.drag_dc)
570              self.dragging = 1              self.dragging = 1
571            
572      def OnLeftUp(self, event):      def OnLeftUp(self, event):
         self.ReleaseMouse()  
573          self.set_current_position(event)          self.set_current_position(event)
574          if self.dragging:          if self.dragging:
575                self.ReleaseMouse()
576              self.tool.Hide(self.drag_dc)              self.tool.Hide(self.drag_dc)
577              self.tool.MouseUp(event)              self.tool.MouseUp(event)
578              self.drag_dc = None              self.drag_dc = None
# Line 578  class MapCanvas(wxWindow, Publisher): Line 603  class MapCanvas(wxWindow, Publisher):
603          self.full_redraw()          self.full_redraw()
604    
605      def shape_selected(self, layer, shape):      def shape_selected(self, layer, shape):
606          self.full_redraw()          """Redraw the map.
607    
608      def find_shape_at(self, px, py, select_labels = 0, selected_layer = 1):          Receiver for the SELECTED_SHAPE messages. Try to redraw only
609            when necessary.
610            """
611            # A redraw is necessary when the display has to change, which
612            # means that either the status changes from having no selection
613            # to having a selection shape or vice versa, or when the fact
614            # whether there is a selection at all doesn't change, when the
615            # shape which is selected has changed (which means that layer or
616            # shapeid changes).
617            if ((shape is not None or self.last_selected_shape is not None)
618                and (shape != self.last_selected_shape
619                     or layer != self.last_selected_layer)):
620                self.full_redraw()
621    
622            # remember the selection so we can compare when it changes again.
623            self.last_selected_layer = layer
624            self.last_selected_shape = shape
625    
626        def unprojected_rect_around_point(self, x, y):
627            """return a rect a few pixels around (x, y) in unprojected corrdinates
628    
629            The return value is a tuple (minx, miny, maxx, maxy) suitable a
630            parameter to a layer's ShapesInRegion method.
631            """
632            map_proj = self.map.projection
633            if map_proj is not None:
634                inverse = map_proj.Inverse
635            else:
636                inverse = None
637    
638            xs = []
639            ys = []
640            for dx, dy in ((-1, -1), (1, -1), (1, 1), (-1, 1)):
641                px, py = self.win_to_proj(x + dx, y + dy)
642                if inverse:
643                    px, py = inverse(px, py)
644                xs.append(px)
645                ys.append(py)
646            return (min(xs), min(ys), max(xs), max(ys))
647    
648        def find_shape_at(self, px, py, select_labels = 0, searched_layer = None):
649          """Determine the shape at point px, py in window coords          """Determine the shape at point px, py in window coords
650    
651          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 655  class MapCanvas(wxWindow, Publisher):
655          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
656          as the shape and None as the layer.          as the shape and None as the layer.
657    
658          If the optional parameter selected_layer is true (default), only          If the optional parameter searched_layer is given (or not None
659          search in the currently selected layer.          which it defaults to), only search in that layer.
660          """          """
661          map_proj = self.map.projection          map_proj = self.map.projection
662          if map_proj is not None:          if map_proj is not None:
# Line 602  class MapCanvas(wxWindow, Publisher): Line 667  class MapCanvas(wxWindow, Publisher):
667          scale = self.scale          scale = self.scale
668          offx, offy = self.offset          offx, offy = self.offset
669    
670            box = self.unprojected_rect_around_point(px, py)
671    
672          if select_labels:          if select_labels:
673              labels = self.map.LabelLayer().Labels()              labels = self.map.LabelLayer().Labels()
674                
675              if labels:              if labels:
676                  dc = wxClientDC(self)                  dc = wxClientDC(self)
677                  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 703  class MapCanvas(wxWindow, Publisher):
703                      if x <= px < x + width and y <= py <= y + height:                      if x <= px < x + width and y <= py <= y + height:
704                          return None, i                          return None, i
705    
706          if selected_layer:          if searched_layer:
707              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 = []  
708          else:          else:
709              layers = self.map.Layers()              layers = self.map.Layers()
710    
# Line 656  class MapCanvas(wxWindow, Publisher): Line 717  class MapCanvas(wxWindow, Publisher):
717    
718              filled = layer.fill is not None              filled = layer.fill is not None
719              stroked = layer.stroke is not None              stroked = layer.stroke is not None
720                    
721              layer_proj = layer.projection              layer_proj = layer.projection
722              if layer_proj is not None:              if layer_proj is not None:
723                  inverse = layer_proj.Inverse                  inverse = layer_proj.Inverse
724              else:              else:
725                  inverse = None                  inverse = None
726                    
727              shapetype = layer.ShapeType()              shapetype = layer.ShapeType()
728    
729              select_shape = -1              select_shape = -1
730    
731                shape_ids = layer.ShapesInRegion(box)
732                shape_ids.reverse()
733    
734              if shapetype == SHAPETYPE_POLYGON:              if shapetype == SHAPETYPE_POLYGON:
735                  for i in range(layer.NumShapes() - 1, -1, -1):                  for i in shape_ids:
736                      result = point_in_polygon_shape(layer.shapefile.cobject(),                      result = point_in_polygon_shape(layer.shapefile.cobject(),
737                                                      i,                                                      i,
738                                                      filled, stroked,                                                      filled, stroked,
# Line 678  class MapCanvas(wxWindow, Publisher): Line 743  class MapCanvas(wxWindow, Publisher):
743                          select_shape = i                          select_shape = i
744                          break                          break
745              elif shapetype == SHAPETYPE_ARC:              elif shapetype == SHAPETYPE_ARC:
746                  for i in range(layer.NumShapes() - 1, -1, -1):                  for i in shape_ids:
747                      result = point_in_polygon_shape(layer.shapefile.cobject(),                      result = point_in_polygon_shape(layer.shapefile.cobject(),
748                                                      i, 0, 1,                                                      i, 0, 1,
749                                                      map_proj, layer_proj,                                                      map_proj, layer_proj,
# Line 688  class MapCanvas(wxWindow, Publisher): Line 753  class MapCanvas(wxWindow, Publisher):
753                          select_shape = i                          select_shape = i
754                          break                          break
755              elif shapetype == SHAPETYPE_POINT:              elif shapetype == SHAPETYPE_POINT:
756                  for i in range(layer.NumShapes() - 1, -1, -1):                  for i in shape_ids:
757                      shape = layer.Shape(i)                      shape = layer.Shape(i)
758                      x, y = shape.Points()[0]                      x, y = shape.Points()[0]
759                      if inverse:                      if inverse:
# Line 705  class MapCanvas(wxWindow, Publisher): Line 770  class MapCanvas(wxWindow, Publisher):
770                  return layer, select_shape                  return layer, select_shape
771          return None, None          return None, None
772    
773      def SelectShapeAt(self, x, y):      def SelectShapeAt(self, x, y, layer = None):
774          layer, shape = self.find_shape_at(x, y, selected_layer = 0)          """\
775            Select and return the shape and its layer at window position (x, y)
776    
777            If layer is given, only search in that layer. If no layer is
778            given, search through all layers.
779    
780            Return a tuple (layer, shapeid). If no shape is found, return
781            (None, None).
782            """
783            layer, shape = result = self.find_shape_at(x, y, searched_layer=layer)
784          # 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
785          # to deselect the currently selected layer, so we simply select          # to deselect the currently selected layer, so we simply select
786          # the already selected layer again.          # the already selected layer again.
787          if layer is None:          if layer is None:
788              layer = self.interactor.SelectedLayer()              layer = self.interactor.SelectedLayer()
789          self.interactor.SelectLayerAndShape(layer, shape)          self.interactor.SelectLayerAndShape(layer, shape)
790            return result
791    
792      def LabelShapeAt(self, x, y):      def LabelShapeAt(self, x, y):
793          ox = x; oy = y          ox = x; oy = y
Legend:
Removed from v.149  
changed lines
  Added in v.293
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26