~brian-sidebotham/wxwidgets-cmake/wxpython-2.9.4 : contents of wxPython/wx/lib/floatcanvas/GUIMode.py at revision 1

~brian-sidebotham/wxwidgets-cmake/wxpython-2.9.4 : (revision 1)

#!/usr/bin/env python
"""

Module that holds the GUI modes used by FloatCanvas

Note that this can only be imported after a wx.App() has been created.

This approach was inpired by Christian Blouin, who also wrote the initial
version of the code.

"""

import wx
## fixme: events should live in their own module, so all of FloatCanvas
##        wouldn't have to be imported here.
import FloatCanvas, Resources
from Utilities import BBox
import numpy as N

class Cursors(object):
    """
    Class to hold the standard Cursors
    
    """
    def __init__(self):
        if "wxMac" in wx.PlatformInfo: # use 16X16 cursors for wxMac
            self.HandCursor = wx.CursorFromImage(Resources.getHand16Image())
            self.GrabHandCursor = wx.CursorFromImage(Resources.getGrabHand16Image())
        
            img = Resources.getMagPlus16Image()
            img.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_X, 6)
            img.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_Y, 6)
            self.MagPlusCursor = wx.CursorFromImage(img)
        
            img = Resources.getMagMinus16Image()
            img.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_X, 6)
            img.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_Y, 6)
            self.MagMinusCursor = wx.CursorFromImage(img)
        else: # use 24X24 cursors for GTK and Windows
            self.HandCursor = wx.CursorFromImage(Resources.getHandImage())
            self.GrabHandCursor = wx.CursorFromImage(Resources.getGrabHandImage())
        
            img = Resources.getMagPlusImage()
            img.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_X, 9)
            img.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_Y, 9)
            self.MagPlusCursor = wx.CursorFromImage(img)
        
            img = Resources.getMagMinusImage()
            img.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_X, 9)
            img.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_Y, 9)
            self.MagMinusCursor = wx.CursorFromImage(img)


class GUIBase(object):
    """
    Basic Mouse mode and baseclass for other GUImode.

    This one does nothing with any event

    """
    def __init__(self, Canvas=None):
        self.Canvas = Canvas # set the FloatCanvas for the mode
                             # it gets set when the Mode is set on the Canvas.
        self.Cursors = Cursors()

    Cursor = wx.NullCursor
    def UnSet(self):
        """
        this method gets called by FloatCanvas when a new mode is being set
        on the Canvas
        """
        pass
    # Handlers
    def OnLeftDown(self, event):
        pass
    def OnLeftUp(self, event):
        pass
    def OnLeftDouble(self, event):
        pass
    def OnRightDown(self, event):
        pass
    def OnRightUp(self, event):
        pass
    def OnRightDouble(self, event):
        pass
    def OnMiddleDown(self, event):
        pass
    def OnMiddleUp(self, event):
        pass
    def OnMiddleDouble(self, event):
        pass
    def OnWheel(self, event):
        pass
    def OnMove(self, event):
        pass
    def OnKeyDown(self, event):
        pass
    def OnKeyUp(self, event):
        pass
    def UpdateScreen(self):
        """
        Update gets called if the screen has been repainted in the middle of a zoom in
        so the Rubber Band Box can get updated. Other GUIModes may require something similar
        """
        pass

class GUIMouse(GUIBase):
    """

    Mouse mode checks for a hit test, and if nothing is hit,
    raises a FloatCanvas mouse event for each event.

    """

    Cursor = wx.NullCursor

    # Handlers
    def OnLeftDown(self, event):
        EventType = FloatCanvas.EVT_FC_LEFT_DOWN
        if not self.Canvas.HitTest(event, EventType):
            self.Canvas._RaiseMouseEvent(event, EventType)

    def OnLeftUp(self, event):
        EventType = FloatCanvas.EVT_FC_LEFT_UP
        if not self.Canvas.HitTest(event, EventType):
            self.Canvas._RaiseMouseEvent(event, EventType)

    def OnLeftDouble(self, event):
        EventType = FloatCanvas.EVT_FC_LEFT_DCLICK
        if not self.Canvas.HitTest(event, EventType):
                self.Canvas._RaiseMouseEvent(event, EventType)

    def OnMiddleDown(self, event):
        EventType = FloatCanvas.EVT_FC_MIDDLE_DOWN
        if not self.Canvas.HitTest(event, EventType):
            self.Canvas._RaiseMouseEvent(event, EventType)

    def OnMiddleUp(self, event):
        EventType = FloatCanvas.EVT_FC_MIDDLE_UP
        if not self.Canvas.HitTest(event, EventType):
            self.Canvas._RaiseMouseEvent(event, EventType)

    def OnMiddleDouble(self, event):
        EventType = FloatCanvas.EVT_FC_MIDDLE_DCLICK
        if not self.Canvas.HitTest(event, EventType):
            self.Canvas._RaiseMouseEvent(event, EventType)

    def OnRightDown(self, event):
        EventType = FloatCanvas.EVT_FC_RIGHT_DOWN
        if not self.Canvas.HitTest(event, EventType):
            self.Canvas._RaiseMouseEvent(event, EventType)

    def OnRightUp(self, event):
        EventType = FloatCanvas.EVT_FC_RIGHT_UP
        if not self.Canvas.HitTest(event, EventType):
            self.Canvas._RaiseMouseEvent(event, EventType)

    def OnRightDouble(self, event):
        EventType = FloatCanvas.EVT_FC_RIGHT_DCLICK
        if not self.Canvas.HitTest(event, EventType):
            self.Canvas._RaiseMouseEvent(event, EventType)

    def OnWheel(self, event):
        EventType = FloatCanvas.EVT_FC_MOUSEWHEEL
        self.Canvas._RaiseMouseEvent(event, EventType)

    def OnMove(self, event):
        ## The Move event always gets raised, even if there is a hit-test
        self.Canvas.MouseOverTest(event)
        self.Canvas._RaiseMouseEvent(event,FloatCanvas.EVT_FC_MOTION)


class GUIMove(GUIBase):
    """
    Mode that moves the image (pans).
    It doesn't change any coordinates, it only changes what the viewport is
    """
    def __init__(self, canvas=None):
        GUIBase.__init__(self, canvas)
        self.Cursor = self.Cursors.HandCursor
        self.GrabCursor = self.Cursors.GrabHandCursor
        self.StartMove = None
        self.MidMove = None
        self.PrevMoveXY = None
        
        ## timer to give a delay when moving so that buffers aren't re-built too many times.
        self.MoveTimer = wx.PyTimer(self.OnMoveTimer)

    def OnLeftDown(self, event):
        self.Canvas.SetCursor(self.GrabCursor)
        self.Canvas.CaptureMouse()
        self.StartMove = N.array( event.GetPosition() )
        self.MidMove = self.StartMove
        self.PrevMoveXY = (0,0)

    def OnLeftUp(self, event):
        self.Canvas.SetCursor(self.Cursor)
        if self.StartMove is not None:
            self.EndMove = N.array(event.GetPosition())
            DiffMove = self.MidMove-self.EndMove
            self.Canvas.MoveImage(DiffMove, 'Pixel', ReDraw=True)

    def OnMove(self, event):
        # Always raise the Move event.
        self.Canvas._RaiseMouseEvent(event, FloatCanvas.EVT_FC_MOTION)
        if event.Dragging() and event.LeftIsDown() and not self.StartMove is None:
            self.EndMove = N.array(event.GetPosition())
            self.MoveImage(event)
            DiffMove = self.MidMove-self.EndMove
            self.Canvas.MoveImage(DiffMove, 'Pixel', ReDraw=False)# reset the canvas without re-drawing
            self.MidMove = self.EndMove
            self.MoveTimer.Start(30, oneShot=True)

    def OnMoveTimer(self, event=None):
        self.Canvas.Draw()

    def UpdateScreen(self):
        ## The screen has been re-drawn, so StartMove needs to be reset.
        self.StartMove = self.MidMove

    def MoveImage(self, event ):
        #xy1 = N.array( event.GetPosition() )
        xy1 = self.EndMove
        wh = self.Canvas.PanelSize
        xy_tl = xy1 - self.StartMove
        dc = wx.ClientDC(self.Canvas)
        dc.BeginDrawing()
        x1,y1 = self.PrevMoveXY
        x2,y2 = xy_tl
        w,h = self.Canvas.PanelSize
        ##fixme: This sure could be cleaner!
        ##   This is all to fill in the background with the background color
        ##   without flashing as the image moves.
        if x2 > x1 and y2 > y1:
            xa = xb = x1
            ya = yb = y1
            wa = w
            ha = y2 - y1
            wb = x2-  x1
            hb = h
        elif x2 > x1 and y2 <= y1:
            xa = x1
            ya = y1
            wa = x2 - x1
            ha = h
            xb = x1
            yb = y2 + h
            wb = w
            hb = y1 - y2
        elif x2 <= x1 and y2 > y1:
            xa = x1
            ya = y1
            wa = w
            ha = y2 - y1
            xb = x2 + w
            yb = y1
            wb = x1 - x2
            hb = h - y2 + y1
        elif x2 <= x1 and y2 <= y1:
            xa = x2 + w
            ya = y1
            wa = x1 - x2
            ha = h
            xb = x1
            yb = y2 + h
            wb = w
            hb = y1 - y2

        dc.SetPen(wx.TRANSPARENT_PEN)
        dc.SetBrush(self.Canvas.BackgroundBrush)
        dc.DrawRectangle(xa, ya, wa, ha)
        dc.DrawRectangle(xb, yb, wb, hb)
        self.PrevMoveXY = xy_tl
        if self.Canvas._ForeDrawList:
            dc.DrawBitmapPoint(self.Canvas._ForegroundBuffer,xy_tl)
        else:
            dc.DrawBitmapPoint(self.Canvas._Buffer,xy_tl)
        dc.EndDrawing()
        #self.Canvas.Update()

    def OnWheel(self, event):
        """
           By default, zoom in/out by a 0.1 factor per Wheel event.
        """
        if event.GetWheelRotation() < 0:
            self.Canvas.Zoom(0.9)
        else:
            self.Canvas.Zoom(1.1)

class GUIZoomIn(GUIBase):
 
    def __init__(self, canvas=None):
        GUIBase.__init__(self, canvas)
        self.StartRBBox = None
        self.PrevRBBox = None
        self.Cursor = self.Cursors.MagPlusCursor

    def OnLeftDown(self, event):
        self.StartRBBox = N.array( event.GetPosition() )
        self.PrevRBBox = None
        self.Canvas.CaptureMouse()

    def OnLeftUp(self, event):
        if event.LeftUp() and not self.StartRBBox is None:
            self.PrevRBBox = None
            EndRBBox = event.GetPosition()
            StartRBBox = self.StartRBBox
            # if mouse has moved less that ten pixels, don't use the box.
            if ( abs(StartRBBox[0] - EndRBBox[0]) > 10
                    and abs(StartRBBox[1] - EndRBBox[1]) > 10 ):
                EndRBBox = self.Canvas.PixelToWorld(EndRBBox)
                StartRBBox = self.Canvas.PixelToWorld(StartRBBox)
                self.Canvas.ZoomToBB( BBox.fromPoints(N.r_[EndRBBox,StartRBBox]) )
            else:
                Center = self.Canvas.PixelToWorld(StartRBBox)
                self.Canvas.Zoom(1.5,Center)
            self.StartRBBox = None

    def OnMove(self, event):
        # Always raise the Move event.
        self.Canvas._RaiseMouseEvent(event,FloatCanvas.EVT_FC_MOTION)
        if event.Dragging() and event.LeftIsDown() and not (self.StartRBBox is None):
            xy0 = self.StartRBBox
            xy1 = N.array( event.GetPosition() )
            wh  = abs(xy1 - xy0)
            wh[0] = max(wh[0], int(wh[1]*self.Canvas.AspectRatio))
            wh[1] = int(wh[0] / self.Canvas.AspectRatio)
            xy_c = (xy0 + xy1) / 2
            dc = wx.ClientDC(self.Canvas)
            dc.BeginDrawing()
            dc.SetPen(wx.Pen('WHITE', 2, wx.SHORT_DASH))
            dc.SetBrush(wx.TRANSPARENT_BRUSH)
            dc.SetLogicalFunction(wx.XOR)
            if self.PrevRBBox:
                dc.DrawRectanglePointSize(*self.PrevRBBox)
            self.PrevRBBox = ( xy_c - wh/2, wh )
            dc.DrawRectanglePointSize( *self.PrevRBBox )
            dc.EndDrawing()
            
    def UpdateScreen(self):
        """
        Update gets called if the screen has been repainted in the middle of a zoom in
        so the Rubber Band Box can get updated
        """
        #if False:
        if self.PrevRBBox is not None:
            dc = wx.ClientDC(self.Canvas)
            dc.SetPen(wx.Pen('WHITE', 2, wx.SHORT_DASH))
            dc.SetBrush(wx.TRANSPARENT_BRUSH)
            dc.SetLogicalFunction(wx.XOR)
            dc.DrawRectanglePointSize(*self.PrevRBBox)

    def OnRightDown(self, event):
        self.Canvas.Zoom(1/1.5, event.GetPosition(), centerCoords="pixel")

    def OnWheel(self, event):
        if event.GetWheelRotation() < 0:
            self.Canvas.Zoom(0.9)
        else:
            self.Canvas.Zoom(1.1)

class GUIZoomOut(GUIBase):

    def __init__(self, Canvas=None):
        GUIBase.__init__(self, Canvas)
        self.Cursor = self.Cursors.MagMinusCursor
        
    def OnLeftDown(self, event):
        self.Canvas.Zoom(1/1.5, event.GetPosition(), centerCoords="pixel")

    def OnRightDown(self, event):
        self.Canvas.Zoom(1.5, event.GetPosition(), centerCoords="pixel")

    def OnWheel(self, event):
        if event.GetWheelRotation() < 0:
            self.Canvas.Zoom(0.9)
        else:
            self.Canvas.Zoom(1.1)

    def OnMove(self, event):
        # Always raise the Move event.
        self.Canvas._RaiseMouseEvent(event,FloatCanvas.EVT_FC_MOTION)


1 by Brian Sidebotham Initial import into Bazaar	1	#!/usr/bin/env python
	2	"""
	3
	4	Module that holds the GUI modes used by FloatCanvas
	5
	6	Note that this can only be imported after a wx.App() has been created.
	7
	8	This approach was inpired by Christian Blouin, who also wrote the initial
	9	version of the code.
	10
	11	"""
	12
	13	import wx
	14	## fixme: events should live in their own module, so all of FloatCanvas
	15	## wouldn't have to be imported here.
	16	import FloatCanvas, Resources
	17	from Utilities import BBox
	18	import numpy as N
	19
	20	class Cursors(object):
	21	"""
	22	Class to hold the standard Cursors
	23
	24	"""
	25	def __init__(self):
	26	if "wxMac" in wx.PlatformInfo: # use 16X16 cursors for wxMac
	27	self.HandCursor = wx.CursorFromImage(Resources.getHand16Image())
	28	self.GrabHandCursor = wx.CursorFromImage(Resources.getGrabHand16Image())
	29
	30	img = Resources.getMagPlus16Image()
	31	img.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_X, 6)
	32	img.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_Y, 6)
	33	self.MagPlusCursor = wx.CursorFromImage(img)
	34
	35	img = Resources.getMagMinus16Image()
	36	img.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_X, 6)
	37	img.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_Y, 6)
	38	self.MagMinusCursor = wx.CursorFromImage(img)
	39	else: # use 24X24 cursors for GTK and Windows
	40	self.HandCursor = wx.CursorFromImage(Resources.getHandImage())
	41	self.GrabHandCursor = wx.CursorFromImage(Resources.getGrabHandImage())
	42
	43	img = Resources.getMagPlusImage()
	44	img.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_X, 9)
	45	img.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_Y, 9)
	46	self.MagPlusCursor = wx.CursorFromImage(img)
	47
	48	img = Resources.getMagMinusImage()
	49	img.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_X, 9)
	50	img.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_Y, 9)
	51	self.MagMinusCursor = wx.CursorFromImage(img)
	52
	53
	54	class GUIBase(object):
	55	"""
	56	Basic Mouse mode and baseclass for other GUImode.
	57
	58	This one does nothing with any event
	59
	60	"""
	61	def __init__(self, Canvas=None):
	62	self.Canvas = Canvas # set the FloatCanvas for the mode
	63	# it gets set when the Mode is set on the Canvas.
	64	self.Cursors = Cursors()
65
66	Cursor = wx.NullCursor
67	def UnSet(self):
68	"""
69	this method gets called by FloatCanvas when a new mode is being set
70	on the Canvas
71	"""
72	pass
73	# Handlers
74	def OnLeftDown(self, event):
75	pass
76	def OnLeftUp(self, event):
77	pass
78	def OnLeftDouble(self, event):
79	pass
80	def OnRightDown(self, event):
81	pass
82	def OnRightUp(self, event):
83	pass
84	def OnRightDouble(self, event):
85	pass
86	def OnMiddleDown(self, event):
87	pass
88	def OnMiddleUp(self, event):
89	pass
90	def OnMiddleDouble(self, event):
91	pass
92	def OnWheel(self, event):
93	pass
94	def OnMove(self, event):
95	pass
96	def OnKeyDown(self, event):
97	pass
98	def OnKeyUp(self, event):
99	pass
100	def UpdateScreen(self):
101	"""
102	Update gets called if the screen has been repainted in the middle of a zoom in
103	so the Rubber Band Box can get updated. Other GUIModes may require something similar
104	"""
105	pass
106
107	class GUIMouse(GUIBase):
108	"""
109
110	Mouse mode checks for a hit test, and if nothing is hit,
111	raises a FloatCanvas mouse event for each event.
112
113	"""
114
115	Cursor = wx.NullCursor
116
117	# Handlers
118	def OnLeftDown(self, event):
119	EventType = FloatCanvas.EVT_FC_LEFT_DOWN
120	if not self.Canvas.HitTest(event, EventType):
121	self.Canvas._RaiseMouseEvent(event, EventType)
122
123	def OnLeftUp(self, event):
124	EventType = FloatCanvas.EVT_FC_LEFT_UP
125	if not self.Canvas.HitTest(event, EventType):
126	self.Canvas._RaiseMouseEvent(event, EventType)
127
128	def OnLeftDouble(self, event):
129	EventType = FloatCanvas.EVT_FC_LEFT_DCLICK
130	if not self.Canvas.HitTest(event, EventType):
131	self.Canvas._RaiseMouseEvent(event, EventType)
132
133	def OnMiddleDown(self, event):
134	EventType = FloatCanvas.EVT_FC_MIDDLE_DOWN
135	if not self.Canvas.HitTest(event, EventType):
136	self.Canvas._RaiseMouseEvent(event, EventType)
137
138	def OnMiddleUp(self, event):
139	EventType = FloatCanvas.EVT_FC_MIDDLE_UP
140	if not self.Canvas.HitTest(event, EventType):
141	self.Canvas._RaiseMouseEvent(event, EventType)
142
143	def OnMiddleDouble(self, event):
144	EventType = FloatCanvas.EVT_FC_MIDDLE_DCLICK
145	if not self.Canvas.HitTest(event, EventType):
146	self.Canvas._RaiseMouseEvent(event, EventType)
147
148	def OnRightDown(self, event):
149	EventType = FloatCanvas.EVT_FC_RIGHT_DOWN
150	if not self.Canvas.HitTest(event, EventType):
151	self.Canvas._RaiseMouseEvent(event, EventType)
152
153	def OnRightUp(self, event):
154	EventType = FloatCanvas.EVT_FC_RIGHT_UP
155	if not self.Canvas.HitTest(event, EventType):
156	self.Canvas._RaiseMouseEvent(event, EventType)
157
158	def OnRightDouble(self, event):
159	EventType = FloatCanvas.EVT_FC_RIGHT_DCLICK
160	if not self.Canvas.HitTest(event, EventType):
161	self.Canvas._RaiseMouseEvent(event, EventType)
162
163	def OnWheel(self, event):
164	EventType = FloatCanvas.EVT_FC_MOUSEWHEEL
165	self.Canvas._RaiseMouseEvent(event, EventType)
166
167	def OnMove(self, event):
168	## The Move event always gets raised, even if there is a hit-test
169	self.Canvas.MouseOverTest(event)
170	self.Canvas._RaiseMouseEvent(event,FloatCanvas.EVT_FC_MOTION)
171
172
173	class GUIMove(GUIBase):
174	"""
175	Mode that moves the image (pans).
176	It doesn't change any coordinates, it only changes what the viewport is
177	"""
178	def __init__(self, canvas=None):
179	GUIBase.__init__(self, canvas)
180	self.Cursor = self.Cursors.HandCursor
181	self.GrabCursor = self.Cursors.GrabHandCursor
182	self.StartMove = None
183	self.MidMove = None
184	self.PrevMoveXY = None
185
186	## timer to give a delay when moving so that buffers aren't re-built too many times.
187	self.MoveTimer = wx.PyTimer(self.OnMoveTimer)
188
189	def OnLeftDown(self, event):
190	self.Canvas.SetCursor(self.GrabCursor)
191	self.Canvas.CaptureMouse()
192	self.StartMove = N.array( event.GetPosition() )
193	self.MidMove = self.StartMove
194	self.PrevMoveXY = (0,0)
195
196	def OnLeftUp(self, event):
197	self.Canvas.SetCursor(self.Cursor)
198	if self.StartMove is not None:
199	self.EndMove = N.array(event.GetPosition())
200	DiffMove = self.MidMove-self.EndMove
201	self.Canvas.MoveImage(DiffMove, 'Pixel', ReDraw=True)
202
203	def OnMove(self, event):
204	# Always raise the Move event.
205	self.Canvas._RaiseMouseEvent(event, FloatCanvas.EVT_FC_MOTION)
206	if event.Dragging() and event.LeftIsDown() and not self.StartMove is None:
207	self.EndMove = N.array(event.GetPosition())
208	self.MoveImage(event)
209	DiffMove = self.MidMove-self.EndMove
210	self.Canvas.MoveImage(DiffMove, 'Pixel', ReDraw=False)# reset the canvas without re-drawing
211	self.MidMove = self.EndMove
212	self.MoveTimer.Start(30, oneShot=True)
213
214	def OnMoveTimer(self, event=None):
215	self.Canvas.Draw()
216
217	def UpdateScreen(self):
218	## The screen has been re-drawn, so StartMove needs to be reset.
219	self.StartMove = self.MidMove
220
221	def MoveImage(self, event ):
222	#xy1 = N.array( event.GetPosition() )
223	xy1 = self.EndMove
224	wh = self.Canvas.PanelSize
225	xy_tl = xy1 - self.StartMove
226	dc = wx.ClientDC(self.Canvas)
227	dc.BeginDrawing()
228	x1,y1 = self.PrevMoveXY
229	x2,y2 = xy_tl
230	w,h = self.Canvas.PanelSize
231	##fixme: This sure could be cleaner!
232	## This is all to fill in the background with the background color
233	## without flashing as the image moves.
234	if x2 > x1 and y2 > y1:
235	xa = xb = x1
236	ya = yb = y1
237	wa = w
238	ha = y2 - y1
239	wb = x2- x1
240	hb = h
241	elif x2 > x1 and y2 <= y1:
242	xa = x1
243	ya = y1
244	wa = x2 - x1
245	ha = h
246	xb = x1
247	yb = y2 + h
248	wb = w
249	hb = y1 - y2
250	elif x2 <= x1 and y2 > y1:
251	xa = x1
252	ya = y1
253	wa = w
254	ha = y2 - y1
255	xb = x2 + w
256	yb = y1
257	wb = x1 - x2
258	hb = h - y2 + y1
259	elif x2 <= x1 and y2 <= y1:
260	xa = x2 + w
261	ya = y1
262	wa = x1 - x2
263	ha = h
264	xb = x1
265	yb = y2 + h
266	wb = w
267	hb = y1 - y2
268
269	dc.SetPen(wx.TRANSPARENT_PEN)
270	dc.SetBrush(self.Canvas.BackgroundBrush)
271	dc.DrawRectangle(xa, ya, wa, ha)
272	dc.DrawRectangle(xb, yb, wb, hb)
273	self.PrevMoveXY = xy_tl
274	if self.Canvas._ForeDrawList:
275	dc.DrawBitmapPoint(self.Canvas._ForegroundBuffer,xy_tl)
276	else:
277	dc.DrawBitmapPoint(self.Canvas._Buffer,xy_tl)
278	dc.EndDrawing()
279	#self.Canvas.Update()
280
281	def OnWheel(self, event):
282	"""
283	By default, zoom in/out by a 0.1 factor per Wheel event.
284	"""
285	if event.GetWheelRotation() < 0:
286	self.Canvas.Zoom(0.9)
287	else:
288	self.Canvas.Zoom(1.1)
289
290	class GUIZoomIn(GUIBase):
291
292	def __init__(self, canvas=None):
293	GUIBase.__init__(self, canvas)
294	self.StartRBBox = None
295	self.PrevRBBox = None
296	self.Cursor = self.Cursors.MagPlusCursor
297
298	def OnLeftDown(self, event):
299	self.StartRBBox = N.array( event.GetPosition() )
300	self.PrevRBBox = None
301	self.Canvas.CaptureMouse()
302
303	def OnLeftUp(self, event):
304	if event.LeftUp() and not self.StartRBBox is None:
305	self.PrevRBBox = None
306	EndRBBox = event.GetPosition()
307	StartRBBox = self.StartRBBox
308	# if mouse has moved less that ten pixels, don't use the box.
309	if ( abs(StartRBBox[0] - EndRBBox[0]) > 10
310	and abs(StartRBBox[1] - EndRBBox[1]) > 10 ):
311	EndRBBox = self.Canvas.PixelToWorld(EndRBBox)
312	StartRBBox = self.Canvas.PixelToWorld(StartRBBox)
313	self.Canvas.ZoomToBB( BBox.fromPoints(N.r_[EndRBBox,StartRBBox]) )
314	else:
315	Center = self.Canvas.PixelToWorld(StartRBBox)
316	self.Canvas.Zoom(1.5,Center)
317	self.StartRBBox = None
318
319	def OnMove(self, event):
320	# Always raise the Move event.
321	self.Canvas._RaiseMouseEvent(event,FloatCanvas.EVT_FC_MOTION)
322	if event.Dragging() and event.LeftIsDown() and not (self.StartRBBox is None):
323	xy0 = self.StartRBBox
324	xy1 = N.array( event.GetPosition() )
325	wh = abs(xy1 - xy0)
326	wh[0] = max(wh[0], int(wh[1]*self.Canvas.AspectRatio))
327	wh[1] = int(wh[0] / self.Canvas.AspectRatio)
328	xy_c = (xy0 + xy1) / 2
329	dc = wx.ClientDC(self.Canvas)
330	dc.BeginDrawing()
331	dc.SetPen(wx.Pen('WHITE', 2, wx.SHORT_DASH))
332	dc.SetBrush(wx.TRANSPARENT_BRUSH)
333	dc.SetLogicalFunction(wx.XOR)
334	if self.PrevRBBox:
335	dc.DrawRectanglePointSize(*self.PrevRBBox)
336	self.PrevRBBox = ( xy_c - wh/2, wh )
337	dc.DrawRectanglePointSize( *self.PrevRBBox )
338	dc.EndDrawing()
339
340	def UpdateScreen(self):
341	"""
342	Update gets called if the screen has been repainted in the middle of a zoom in
343	so the Rubber Band Box can get updated
344	"""
345	#if False:
346	if self.PrevRBBox is not None:
347	dc = wx.ClientDC(self.Canvas)
348	dc.SetPen(wx.Pen('WHITE', 2, wx.SHORT_DASH))
349	dc.SetBrush(wx.TRANSPARENT_BRUSH)
350	dc.SetLogicalFunction(wx.XOR)
351	dc.DrawRectanglePointSize(*self.PrevRBBox)
352
353	def OnRightDown(self, event):
354	self.Canvas.Zoom(1/1.5, event.GetPosition(), centerCoords="pixel")
355
356	def OnWheel(self, event):
357	if event.GetWheelRotation() < 0:
358	self.Canvas.Zoom(0.9)
359	else:
360	self.Canvas.Zoom(1.1)
361
362	class GUIZoomOut(GUIBase):
363
364	def __init__(self, Canvas=None):
365	GUIBase.__init__(self, Canvas)
366	self.Cursor = self.Cursors.MagMinusCursor
367
368	def OnLeftDown(self, event):
369	self.Canvas.Zoom(1/1.5, event.GetPosition(), centerCoords="pixel")
370
371	def OnRightDown(self, event):
372	self.Canvas.Zoom(1.5, event.GetPosition(), centerCoords="pixel")
373
374	def OnWheel(self, event):
375	if event.GetWheelRotation() < 0:
376	self.Canvas.Zoom(0.9)
377	else:
378	self.Canvas.Zoom(1.1)
379
380	def OnMove(self, event):
381	# Always raise the Move event.
382	self.Canvas._RaiseMouseEvent(event,FloatCanvas.EVT_FC_MOTION)
383