/[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 174 by bh, Wed May 15 13:30:00 2002 UTC revision 295 by bh, Fri Aug 30 10:39:17 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 184  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 242  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 314  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 383  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 404  class MapCanvas(wxWindow, Publisher): Line 412  class MapCanvas(wxWindow, Publisher):
412          self.full_redraw()          self.full_redraw()
413    
414      def Map(self):      def Map(self):
415            """Return the map displayed by this canvas"""
416          return self.map          return self.map
417    
418      def redraw(self, *args):      def redraw(self, *args):
# Line 437  class MapCanvas(wxWindow, Publisher): Line 446  class MapCanvas(wxWindow, Publisher):
446          return ((x - offx) / self.scale, (offy - y) / self.scale)          return ((x - offx) / self.scale, (offy - y) / self.scale)
447    
448      def FitRectToWindow(self, rect):      def FitRectToWindow(self, rect):
449            """Fit the rectangular region given by rect into the window.
450            
451            Set scale so that rect (in projected coordinates) just fits into
452            the window and center it.
453            """
454          width, height = self.GetSizeTuple()          width, height = self.GetSizeTuple()
455          llx, lly, urx, ury = rect          llx, lly, urx, ury = rect
456          if llx == urx or lly == ury:          if llx == urx or lly == ury:
# Line 450  class MapCanvas(wxWindow, Publisher): Line 464  class MapCanvas(wxWindow, Publisher):
464          self.set_view_transform(scale, (offx, offy))          self.set_view_transform(scale, (offx, offy))
465    
466      def FitMapToWindow(self):      def FitMapToWindow(self):
467          """\          """Fit the map to the window
468          Set the scale and offset so that the map is centered in the          
469          window          Set the scale so that the map fits exactly into the window and
470            center it in the window.
471          """          """
472          bbox = self.map.ProjectedBoundingBox()          bbox = self.map.ProjectedBoundingBox()
473          if bbox is not None:          if bbox is not None:
# Line 478  class MapCanvas(wxWindow, Publisher): Line 493  class MapCanvas(wxWindow, Publisher):
493          self.set_view_transform(scale, offset)          self.set_view_transform(scale, offset)
494    
495      def ZoomOutToRect(self, rect):      def ZoomOutToRect(self, rect):
496          # rect is given in window coordinates          """Zoom out to fit the currently visible region into rect.
497    
498            The rect parameter is given in window coordinates
499            """
500          # determine the bbox of the displayed region in projected          # determine the bbox of the displayed region in projected
501          # coordinates          # coordinates
502          width, height = self.GetSizeTuple()          width, height = self.GetSizeTuple()
# Line 496  class MapCanvas(wxWindow, Publisher): Line 513  class MapCanvas(wxWindow, Publisher):
513          self.set_view_transform(scale, (offx, offy))          self.set_view_transform(scale, (offx, offy))
514    
515      def Translate(self, dx, dy):      def Translate(self, dx, dy):
516            """Move the map by dx, dy pixels"""
517          offx, offy = self.offset          offx, offy = self.offset
518          self.set_view_transform(self.scale, (offx + dx, offy + dy))          self.set_view_transform(self.scale, (offx + dx, offy + dy))
519    
520      def ZoomInTool(self):      def ZoomInTool(self):
521            """Start the zoom in tool"""
522          self.tool = ZoomInTool(self)          self.tool = ZoomInTool(self)
523    
524      def ZoomOutTool(self):      def ZoomOutTool(self):
525            """Start the zoom out tool"""
526          self.tool = ZoomOutTool(self)          self.tool = ZoomOutTool(self)
527    
528      def PanTool(self):      def PanTool(self):
529            """Start the pan tool"""
530          self.tool = PanTool(self)          self.tool = PanTool(self)
531    
532      def IdentifyTool(self):      def IdentifyTool(self):
533            """Start the identify tool"""
534          self.tool = IdentifyTool(self)          self.tool = IdentifyTool(self)
535    
536      def LabelTool(self):      def LabelTool(self):
537            """Start the label tool"""
538          self.tool = LabelTool(self)          self.tool = LabelTool(self)
539    
540      def CurrentTool(self):      def CurrentTool(self):
541            """Return the name of the current tool or None if no tool is active"""
542          return self.tool and self.tool.Name() or None          return self.tool and self.tool.Name() or None
543    
544      def CurrentPosition(self):      def CurrentPosition(self):
# Line 552  class MapCanvas(wxWindow, Publisher): Line 576  class MapCanvas(wxWindow, Publisher):
576              self.tool.MouseDown(event)              self.tool.MouseDown(event)
577              self.tool.Show(self.drag_dc)              self.tool.Show(self.drag_dc)
578              self.dragging = 1              self.dragging = 1
579            
580      def OnLeftUp(self, event):      def OnLeftUp(self, event):
         self.ReleaseMouse()  
581          self.set_current_position(event)          self.set_current_position(event)
582          if self.dragging:          if self.dragging:
583                self.ReleaseMouse()
584              self.tool.Hide(self.drag_dc)              self.tool.Hide(self.drag_dc)
585              self.tool.MouseUp(event)              self.tool.MouseUp(event)
586              self.drag_dc = None              self.drag_dc = None
# Line 598  class MapCanvas(wxWindow, Publisher): Line 622  class MapCanvas(wxWindow, Publisher):
622          # whether there is a selection at all doesn't change, when the          # whether there is a selection at all doesn't change, when the
623          # shape which is selected has changed (which means that layer or          # shape which is selected has changed (which means that layer or
624          # shapeid changes).          # shapeid changes).
         print "MapCanvas.shape_selected:", layer, shape  
625          if ((shape is not None or self.last_selected_shape is not None)          if ((shape is not None or self.last_selected_shape is not None)
626              and (shape != self.last_selected_shape              and (shape != self.last_selected_shape
627                   or layer != self.last_selected_layer)):                   or layer != self.last_selected_layer)):
             print "MapCanvas.shape_selected: redraw",  
628              self.full_redraw()              self.full_redraw()
629          else:  
630              print "MapCanvas.shape_selected: no redraw"          # remember the selection so we can compare when it changes again.
631          self.last_selected_layer = layer          self.last_selected_layer = layer
632          self.last_selected_shape = shape          self.last_selected_shape = shape
633    
# Line 631  class MapCanvas(wxWindow, Publisher): Line 653  class MapCanvas(wxWindow, Publisher):
653              ys.append(py)              ys.append(py)
654          return (min(xs), min(ys), max(xs), max(ys))          return (min(xs), min(ys), max(xs), max(ys))
655    
656      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):
657          """Determine the shape at point px, py in window coords          """Determine the shape at point px, py in window coords
658    
659          Return the shape and the corresponding layer as a tuple (layer,          Return the shape and the corresponding layer as a tuple (layer,
# Line 641  class MapCanvas(wxWindow, Publisher): Line 663  class MapCanvas(wxWindow, Publisher):
663          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
664          as the shape and None as the layer.          as the shape and None as the layer.
665    
666          If the optional parameter selected_layer is true (default), only          If the optional parameter searched_layer is given (or not None
667          search in the currently selected layer.          which it defaults to), only search in that layer.
668          """          """
669          map_proj = self.map.projection          map_proj = self.map.projection
670          if map_proj is not None:          if map_proj is not None:
# Line 657  class MapCanvas(wxWindow, Publisher): Line 679  class MapCanvas(wxWindow, Publisher):
679    
680          if select_labels:          if select_labels:
681              labels = self.map.LabelLayer().Labels()              labels = self.map.LabelLayer().Labels()
682                
683              if labels:              if labels:
684                  dc = wxClientDC(self)                  dc = wxClientDC(self)
685                  font = wxFont(10, wx.wxSWISS, wx.wxNORMAL, wx.wxNORMAL)                  font = wxFont(10, wx.wxSWISS, wx.wxNORMAL, wx.wxNORMAL)
# Line 689  class MapCanvas(wxWindow, Publisher): Line 711  class MapCanvas(wxWindow, Publisher):
711                      if x <= px < x + width and y <= py <= y + height:                      if x <= px < x + width and y <= py <= y + height:
712                          return None, i                          return None, i
713    
714          if selected_layer:          if searched_layer:
715              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 = []  
716          else:          else:
717              layers = self.map.Layers()              layers = self.map.Layers()
718    
# Line 709  class MapCanvas(wxWindow, Publisher): Line 725  class MapCanvas(wxWindow, Publisher):
725    
726              filled = layer.fill is not None              filled = layer.fill is not None
727              stroked = layer.stroke is not None              stroked = layer.stroke is not None
728                    
729              layer_proj = layer.projection              layer_proj = layer.projection
730              if layer_proj is not None:              if layer_proj is not None:
731                  inverse = layer_proj.Inverse                  inverse = layer_proj.Inverse
732              else:              else:
733                  inverse = None                  inverse = None
734                    
735              shapetype = layer.ShapeType()              shapetype = layer.ShapeType()
736    
737              select_shape = -1              select_shape = -1
# Line 762  class MapCanvas(wxWindow, Publisher): Line 778  class MapCanvas(wxWindow, Publisher):
778                  return layer, select_shape                  return layer, select_shape
779          return None, None          return None, None
780    
781      def SelectShapeAt(self, x, y):      def SelectShapeAt(self, x, y, layer = None):
782          layer, shape = self.find_shape_at(x, y, selected_layer = 0)          """\
783            Select and return the shape and its layer at window position (x, y)
784    
785            If layer is given, only search in that layer. If no layer is
786            given, search through all layers.
787    
788            Return a tuple (layer, shapeid). If no shape is found, return
789            (None, None).
790            """
791            layer, shape = result = self.find_shape_at(x, y, searched_layer=layer)
792          # 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
793          # to deselect the currently selected layer, so we simply select          # to deselect the currently selected layer, so we simply select
794          # the already selected layer again.          # the already selected layer again.
795          if layer is None:          if layer is None:
796              layer = self.interactor.SelectedLayer()              layer = self.interactor.SelectedLayer()
797          self.interactor.SelectLayerAndShape(layer, shape)          self.interactor.SelectLayerAndShape(layer, shape)
798            return result
799    
800      def LabelShapeAt(self, x, y):      def LabelShapeAt(self, x, y):
801            """Add or remove a label at window position x, y.
802    
803            If there's a label at the given position, remove it. Otherwise
804            determine the shape at the position, run the label dialog and
805            unless the user cancels the dialog, add a laber.
806            """
807          ox = x; oy = y          ox = x; oy = y
808          label_layer = self.map.LabelLayer()          label_layer = self.map.LabelLayer()
809          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.174  
changed lines
  Added in v.295
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26