/[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 125 by bh, Thu May 2 18:55:33 2002 UTC revision 288 by bh, Thu Aug 29 13:31:43 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 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    
   
282          # If true, OnIdle will call do_redraw to do the actual          # If true, OnIdle will call do_redraw to do the actual
283          # redrawing. Set by OnPaint to avoid some unnecessary redraws.          # redrawing. Set by OnPaint to avoid some unnecessary redraws.
284          # To force a redraw call full_redraw().          # 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          # the bitmap serving as backing store
291          self.bitmap = None          self.bitmap = None
292    
# Line 280  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 298  class MapCanvas(wxWindow, Publisher): Line 317  class MapCanvas(wxWindow, Publisher):
317          if self.map is not None and self.map.HasLayers():          if self.map is not None and self.map.HasLayers():
318              # We have a non-empty map. Redraw it in idle time              # 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:          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
335                self.update_region = wx.wxRegion()
336    
337      def do_redraw(self):      def do_redraw(self):
338          # This should only be called if we have a non-empty map. We draw          # This should only be called if we have a non-empty map.
339          # it into a memory DC and then blit it to the screen.  
340            # get the update region and reset it. We're not actually using
341            # it anymore, though.
342            update_box = self.update_region.GetBox()
343            self.update_region = wx.wxRegion()
344    
345            # Get the window size.
346          width, height = self.GetSizeTuple()          width, height = self.GetSizeTuple()
347    
348          # If self.bitmap's still there, reuse it. Otherwise redraw it          # If self.bitmap's still there, reuse it. Otherwise redraw it
# Line 339  class MapCanvas(wxWindow, Publisher): Line 368  class MapCanvas(wxWindow, Publisher):
368    
369              # draw the map into the bitmap              # draw the map into the bitmap
370              renderer = ScreenRenderer(dc, self.scale, self.offset)              renderer = ScreenRenderer(dc, self.scale, self.offset)
371              renderer.RenderMap(self.map, selected_layer, selected_shape)  
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()              dc.EndDrawing()
378              dc.SelectObject(wx.wxNullBitmap)              dc.SelectObject(wx.wxNullBitmap)
# Line 358  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 527  class MapCanvas(wxWindow, Publisher): Line 560  class MapCanvas(wxWindow, Publisher):
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):
         self.ReleaseMouse()  
565          self.set_current_position(event)          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
# Line 562  class MapCanvas(wxWindow, Publisher): Line 595  class MapCanvas(wxWindow, Publisher):
595          self.full_redraw()          self.full_redraw()
596    
597      def shape_selected(self, layer, shape):      def shape_selected(self, layer, shape):
598          self.full_redraw()          """Redraw the map.
599    
600            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 find_shape_at(self, px, py, select_labels = 0, selected_layer = 1):      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 574  class MapCanvas(wxWindow, Publisher): Line 647  class MapCanvas(wxWindow, Publisher):
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 586  class MapCanvas(wxWindow, Publisher): Line 659  class MapCanvas(wxWindow, Publisher):
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)
# Line 620  class MapCanvas(wxWindow, Publisher): Line 695  class MapCanvas(wxWindow, Publisher):
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 640  class MapCanvas(wxWindow, Publisher): Line 709  class MapCanvas(wxWindow, Publisher):
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() - 1, -1, -1):                  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 662  class MapCanvas(wxWindow, Publisher): Line 735  class MapCanvas(wxWindow, Publisher):
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() - 1, -1, -1):                  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 672  class MapCanvas(wxWindow, Publisher): Line 745  class MapCanvas(wxWindow, Publisher):
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() - 1, -1, -1):                  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 689  class MapCanvas(wxWindow, Publisher): Line 762  class MapCanvas(wxWindow, Publisher):
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, selected_layer = 0)          """\
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.125  
changed lines
  Added in v.288
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26