/[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 145 by bh, Tue May 7 14:58:05 2002 UTC revision 356 by bh, Mon Dec 9 10:32:15 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    
         # 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.  
         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 350  class MapCanvas(wxWindow, Publisher): Line 348  class MapCanvas(wxWindow, Publisher):
348    
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              renderer.RenderMap(self.map, update_box,  
352                # Pass the entire bitmap as update region to the renderer.
353                # We're redrawing the whole bitmap, after all.
354                renderer.RenderMap(self.map, (0, 0, width, height),
355                                 selected_layer, selected_shape)                                 selected_layer, selected_shape)
356    
357              dc.EndDrawing()              dc.EndDrawing()
# Line 370  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 391  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 424  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 437  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 465  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 483  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 539  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.ReleaseMouse()
572              self.tool.Hide(self.drag_dc)              self.tool.Hide(self.drag_dc)
573              self.tool.MouseUp(event)              self.tool.MouseUp(event)
574              self.drag_dc = None              self.drag_dc = None
# Line 559  class MapCanvas(wxWindow, Publisher): Line 584  class MapCanvas(wxWindow, Publisher):
584      def OnLeaveWindow(self, event):      def OnLeaveWindow(self, event):
585          self.set_current_position(None)          self.set_current_position(None)
586    
     def OnIdle(self, event):  
         if self.redraw_on_idle:  
             self.do_redraw()  
         self.redraw_on_idle = 0  
   
587      def OnSize(self, event):      def OnSize(self, event):
588          # 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
589          # 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 574  class MapCanvas(wxWindow, Publisher): Line 594  class MapCanvas(wxWindow, Publisher):
594          self.full_redraw()          self.full_redraw()
595    
596      def shape_selected(self, layer, shape):      def shape_selected(self, layer, shape):
597          self.full_redraw()          """Redraw the map.
598    
599            Receiver for the SELECTED_SHAPE messages. Try to redraw only
600            when necessary.
601            """
602            # A redraw is necessary when the display has to change, which
603            # means that either the status changes from having no selection
604            # to having a selection shape or vice versa, or when the fact
605            # whether there is a selection at all doesn't change, when the
606            # shape which is selected has changed (which means that layer or
607            # shapeid changes).
608            if ((shape is not None or self.last_selected_shape is not None)
609                and (shape != self.last_selected_shape
610                     or layer != self.last_selected_layer)):
611                self.full_redraw()
612    
613            # remember the selection so we can compare when it changes again.
614            self.last_selected_layer = layer
615            self.last_selected_shape = shape
616    
617        def unprojected_rect_around_point(self, x, y, dist):
618            """return a rect dist pixels around (x, y) in unprojected corrdinates
619    
620      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
621            parameter to a layer's ShapesInRegion method.
622            """
623            map_proj = self.map.projection
624            if map_proj is not None:
625                inverse = map_proj.Inverse
626            else:
627                inverse = None
628    
629            xs = []
630            ys = []
631            for dx, dy in ((-1, -1), (1, -1), (1, 1), (-1, 1)):
632                px, py = self.win_to_proj(x + dist * dx, y + dist * dy)
633                if inverse:
634                    px, py = inverse(px, py)
635                xs.append(px)
636                ys.append(py)
637            return (min(xs), min(ys), max(xs), max(ys))
638    
639        def find_shape_at(self, px, py, select_labels = 0, searched_layer = None):
640          """Determine the shape at point px, py in window coords          """Determine the shape at point px, py in window coords
641    
642          Return the shape and the corresponding layer as a tuple (layer,          Return the shape and the corresponding layer as a tuple (layer,
# Line 586  class MapCanvas(wxWindow, Publisher): Line 646  class MapCanvas(wxWindow, Publisher):
646          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
647          as the shape and None as the layer.          as the shape and None as the layer.
648    
649          If the optional parameter selected_layer is true (default), only          If the optional parameter searched_layer is given (or not None
650          search in the currently selected layer.          which it defaults to), only search in that layer.
651          """          """
652          map_proj = self.map.projection          map_proj = self.map.projection
653          if map_proj is not None:          if map_proj is not None:
# Line 600  class MapCanvas(wxWindow, Publisher): Line 660  class MapCanvas(wxWindow, Publisher):
660    
661          if select_labels:          if select_labels:
662              labels = self.map.LabelLayer().Labels()              labels = self.map.LabelLayer().Labels()
663                
664              if labels:              if labels:
665                  dc = wxClientDC(self)                  dc = wxClientDC(self)
666                  font = wxFont(10, wx.wxSWISS, wx.wxNORMAL, wx.wxNORMAL)                  font = wxFont(10, wx.wxSWISS, wx.wxNORMAL, wx.wxNORMAL)
# Line 632  class MapCanvas(wxWindow, Publisher): Line 692  class MapCanvas(wxWindow, Publisher):
692                      if x <= px < x + width and y <= py <= y + height:                      if x <= px < x + width and y <= py <= y + height:
693                          return None, i                          return None, i
694    
695          if selected_layer:          if searched_layer:
696              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 = []  
697          else:          else:
698              layers = self.map.Layers()              layers = self.map.Layers()
699    
# Line 652  class MapCanvas(wxWindow, Publisher): Line 706  class MapCanvas(wxWindow, Publisher):
706    
707              filled = layer.fill is not None              filled = layer.fill is not None
708              stroked = layer.stroke is not None              stroked = layer.stroke is not None
709                    
710              layer_proj = layer.projection              layer_proj = layer.projection
711              if layer_proj is not None:              if layer_proj is not None:
712                  inverse = layer_proj.Inverse                  inverse = layer_proj.Inverse
713              else:              else:
714                  inverse = None                  inverse = None
715                    
716              shapetype = layer.ShapeType()              shapetype = layer.ShapeType()
717    
718              select_shape = -1              select_shape = -1
719    
720                # Determine the ids of the shapes that overlap a tiny area
721                # around the point. For layers containing points we have to
722                # choose a larger size of the box we're testing agains so
723                # that we take the size of the markers into account
724                # FIXME: Once the markers are more flexible this part has to
725                # become more flexible too, of course
726                if shapetype == SHAPETYPE_POINT:
727                    box = self.unprojected_rect_around_point(px, py, 5)
728                else:
729                    box = self.unprojected_rect_around_point(px, py, 1)
730                shape_ids = layer.ShapesInRegion(box)
731                shape_ids.reverse()
732    
733              if shapetype == SHAPETYPE_POLYGON:              if shapetype == SHAPETYPE_POLYGON:
734                  for i in range(layer.NumShapes() - 1, -1, -1):                  for i in shape_ids:
735                      result = point_in_polygon_shape(layer.shapefile.cobject(),                      result = point_in_polygon_shape(layer.shapefile.cobject(),
736                                                      i,                                                      i,
737                                                      filled, stroked,                                                      filled, stroked,
# Line 674  class MapCanvas(wxWindow, Publisher): Line 742  class MapCanvas(wxWindow, Publisher):
742                          select_shape = i                          select_shape = i
743                          break                          break
744              elif shapetype == SHAPETYPE_ARC:              elif shapetype == SHAPETYPE_ARC:
745                  for i in range(layer.NumShapes() - 1, -1, -1):                  for i in shape_ids:
746                      result = point_in_polygon_shape(layer.shapefile.cobject(),                      result = point_in_polygon_shape(layer.shapefile.cobject(),
747                                                      i, 0, 1,                                                      i, 0, 1,
748                                                      map_proj, layer_proj,                                                      map_proj, layer_proj,
# Line 684  class MapCanvas(wxWindow, Publisher): Line 752  class MapCanvas(wxWindow, Publisher):
752                          select_shape = i                          select_shape = i
753                          break                          break
754              elif shapetype == SHAPETYPE_POINT:              elif shapetype == SHAPETYPE_POINT:
755                  for i in range(layer.NumShapes() - 1, -1, -1):                  for i in shape_ids:
756                      shape = layer.Shape(i)                      shape = layer.Shape(i)
757                      x, y = shape.Points()[0]                      x, y = shape.Points()[0]
758                      if inverse:                      if inverse:
# Line 701  class MapCanvas(wxWindow, Publisher): Line 769  class MapCanvas(wxWindow, Publisher):
769                  return layer, select_shape                  return layer, select_shape
770          return None, None          return None, None
771    
772      def SelectShapeAt(self, x, y):      def SelectShapeAt(self, x, y, layer = None):
773          layer, shape = self.find_shape_at(x, y, selected_layer = 0)          """\
774            Select and return the shape and its layer at window position (x, y)
775    
776            If layer is given, only search in that layer. If no layer is
777            given, search through all layers.
778    
779            Return a tuple (layer, shapeid). If no shape is found, return
780            (None, None).
781            """
782            layer, shape = result = self.find_shape_at(x, y, searched_layer=layer)
783          # 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
784          # to deselect the currently selected layer, so we simply select          # to deselect the currently selected layer, so we simply select
785          # the already selected layer again.          # the already selected layer again.
786          if layer is None:          if layer is None:
787              layer = self.interactor.SelectedLayer()              layer = self.interactor.SelectedLayer()
788          self.interactor.SelectLayerAndShape(layer, shape)          self.interactor.SelectLayerAndShape(layer, shape)
789            return result
790    
791      def LabelShapeAt(self, x, y):      def LabelShapeAt(self, x, y):
792            """Add or remove a label at window position x, y.
793    
794            If there's a label at the given position, remove it. Otherwise
795            determine the shape at the position, run the label dialog and
796            unless the user cancels the dialog, add a laber.
797            """
798          ox = x; oy = y          ox = x; oy = y
799          label_layer = self.map.LabelLayer()          label_layer = self.map.LabelLayer()
800          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.145  
changed lines
  Added in v.356
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26