Merged wxPython 2.4.x to the 2.5 branch (Finally!!!)
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@19793 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robin Dunn
@@ -11,6 +11,7 @@
|
||||
#----------------------------------------------------------------------------
|
||||
|
||||
from wxPython.wx import *
|
||||
import locale
|
||||
|
||||
#----------------------------------------------------------------------------
|
||||
|
||||
@@ -105,7 +106,12 @@ class wxColumnSorterMixin:
|
||||
item1 = self.itemDataMap[key1][col]
|
||||
item2 = self.itemDataMap[key2][col]
|
||||
|
||||
cmpVal = cmp(item1, item2)
|
||||
#--- Internationalization of string sorting with locale module
|
||||
if type(item1) == type('') or type(item2) == type(''):
|
||||
cmpVal = locale.strcoll(str(item1), str(item2))
|
||||
else:
|
||||
cmpVal = cmp(item1, item2)
|
||||
#---
|
||||
|
||||
# If the items are equal then pick something else to make the sort value unique
|
||||
if cmpVal == 0:
|
||||
@@ -132,137 +138,102 @@ class wxColumnSorterMixin:
|
||||
|
||||
class wxListCtrlAutoWidthMixin:
|
||||
""" A mix-in class that automatically resizes the last column to take up
|
||||
the remaining width of the wxListCtrl.
|
||||
the remaining width of the wxListCtrl.
|
||||
|
||||
This causes the wxListCtrl to automatically take up the full width of
|
||||
the list, without either a horizontal scroll bar (unless absolutely
|
||||
necessary) or empty space to the right of the last column.
|
||||
This causes the wxListCtrl to automatically take up the full width of
|
||||
the list, without either a horizontal scroll bar (unless absolutely
|
||||
necessary) or empty space to the right of the last column.
|
||||
|
||||
NOTE: This only works for report-style lists.
|
||||
NOTE: This only works for report-style lists.
|
||||
|
||||
WARNING: If you override the EVT_SIZE event in your wxListCtrl, make
|
||||
sure you call event.Skip() to ensure that the mixin's
|
||||
_OnResize method is called.
|
||||
WARNING: If you override the EVT_SIZE event in your wxListCtrl, make
|
||||
sure you call event.Skip() to ensure that the mixin's
|
||||
_OnResize method is called.
|
||||
|
||||
This mix-in class was written by Erik Westra <ewestra@wave.co.nz>
|
||||
This mix-in class was written by Erik Westra <ewestra@wave.co.nz>
|
||||
"""
|
||||
def __init__(self):
|
||||
""" Standard initialiser.
|
||||
"""
|
||||
self._needResize = false
|
||||
self._lastColMinWidth = None
|
||||
""" Standard initialiser.
|
||||
"""
|
||||
self._lastColMinWidth = None
|
||||
|
||||
EVT_SIZE(self, self._onResize)
|
||||
EVT_LIST_COL_END_DRAG(self, self.GetId(), self._onEndColDrag)
|
||||
EVT_IDLE(self, self._onIdle)
|
||||
EVT_SIZE(self, self._onResize)
|
||||
EVT_LIST_COL_END_DRAG(self, self.GetId(), self._onResize)
|
||||
|
||||
|
||||
def resizeLastColumn(self, minWidth):
|
||||
""" Resize the last column appropriately.
|
||||
""" Resize the last column appropriately.
|
||||
|
||||
If the list's columns are too wide to fit within the window, we use
|
||||
a horizontal scrollbar. Otherwise, we expand the right-most column
|
||||
to take up the remaining free space in the list.
|
||||
If the list's columns are too wide to fit within the window, we use
|
||||
a horizontal scrollbar. Otherwise, we expand the right-most column
|
||||
to take up the remaining free space in the list.
|
||||
|
||||
This method is called automatically when the wxListCtrl is resized;
|
||||
you can also call it yourself whenever you want the last column to
|
||||
be resized appropriately (eg, when adding, removing or resizing
|
||||
columns).
|
||||
This method is called automatically when the wxListCtrl is resized;
|
||||
you can also call it yourself whenever you want the last column to
|
||||
be resized appropriately (eg, when adding, removing or resizing
|
||||
columns).
|
||||
|
||||
'minWidth' is the preferred minimum width for the last column.
|
||||
"""
|
||||
self._lastColMinWidth = minWidth
|
||||
self._doResize()
|
||||
'minWidth' is the preferred minimum width for the last column.
|
||||
"""
|
||||
self._lastColMinWidth = minWidth
|
||||
self._doResize()
|
||||
|
||||
# =====================
|
||||
# == Private Methods ==
|
||||
# =====================
|
||||
|
||||
def _onResize(self, event):
|
||||
""" Respond to the wxListCtrl being resized.
|
||||
""" Respond to the wxListCtrl being resized.
|
||||
|
||||
We automatically resize the last column in the list.
|
||||
"""
|
||||
self._doResize()
|
||||
event.Skip()
|
||||
|
||||
def _onEndColDrag(self, event):
|
||||
""" Respond to the user resizing one of our columns.
|
||||
|
||||
We resize the last column in the list to match. Note that, because
|
||||
of a quirk in the way columns are resized under MS Windows, we
|
||||
actually have to do the column resize in idle time.
|
||||
"""
|
||||
self._needResize = true
|
||||
event.Skip()
|
||||
|
||||
|
||||
def _onIdle(self, event):
|
||||
""" Respond to an idle event.
|
||||
|
||||
We resize the last column, if we've been asked to do so.
|
||||
"""
|
||||
if self._needResize:
|
||||
self._doResize()
|
||||
self.Refresh() # Fixes redraw problem under MS Windows.
|
||||
self._needResize = false
|
||||
We automatically resize the last column in the list.
|
||||
"""
|
||||
wxCallAfter(self._doResize)
|
||||
event.Skip()
|
||||
|
||||
|
||||
def _doResize(self):
|
||||
""" Resize the last column as appropriate.
|
||||
""" Resize the last column as appropriate.
|
||||
|
||||
If the list's columns are too wide to fit within the window, we use
|
||||
a horizontal scrollbar. Otherwise, we expand the right-most column
|
||||
to take up the remaining free space in the list.
|
||||
If the list's columns are too wide to fit within the window, we use
|
||||
a horizontal scrollbar. Otherwise, we expand the right-most column
|
||||
to take up the remaining free space in the list.
|
||||
|
||||
We remember the current size of the last column, before resizing,
|
||||
as the preferred minimum width if we haven't previously been given
|
||||
or calculated a minimum width. This ensure that repeated calls to
|
||||
_doResize() don't cause the last column to size itself too large.
|
||||
"""
|
||||
numCols = self.GetColumnCount()
|
||||
if numCols == 0: return # Nothing to resize.
|
||||
We remember the current size of the last column, before resizing,
|
||||
as the preferred minimum width if we haven't previously been given
|
||||
or calculated a minimum width. This ensure that repeated calls to
|
||||
_doResize() don't cause the last column to size itself too large.
|
||||
"""
|
||||
numCols = self.GetColumnCount()
|
||||
if numCols == 0: return # Nothing to resize.
|
||||
|
||||
if self._lastColMinWidth == None:
|
||||
self._lastColMinWidth = self.GetColumnWidth(numCols - 1)
|
||||
if self._lastColMinWidth == None:
|
||||
self._lastColMinWidth = self.GetColumnWidth(numCols - 1)
|
||||
|
||||
listWidth = self.GetSize().width
|
||||
if self.GetItemCount() > self.GetCountPerPage():
|
||||
# We're showing the vertical scrollbar -> allow for scrollbar width
|
||||
scrollWidth = wxSystemSettings_GetSystemMetric(wxSYS_VSCROLL_X)
|
||||
listWidth = listWidth - scrollWidth
|
||||
# We're showing the vertical scrollbar -> allow for scrollbar width
|
||||
# NOTE: on GTK, the scrollbar is included in the client size, but on
|
||||
# Windows it is not included
|
||||
listWidth = self.GetClientSize().width
|
||||
if wxPlatform != '__WXMSW__':
|
||||
if self.GetItemCount() > self.GetCountPerPage():
|
||||
scrollWidth = wxSystemSettings_GetSystemMetric(wxSYS_VSCROLL_X)
|
||||
listWidth = listWidth - scrollWidth
|
||||
|
||||
totColWidth = 0 # Width of all columns except last one.
|
||||
for col in range(numCols-1):
|
||||
totColWidth = totColWidth + self.GetColumnWidth(col)
|
||||
totColWidth = 0 # Width of all columns except last one.
|
||||
for col in range(numCols-1):
|
||||
totColWidth = totColWidth + self.GetColumnWidth(col)
|
||||
|
||||
lastColWidth = self.GetColumnWidth(numCols - 1)
|
||||
lastColWidth = self.GetColumnWidth(numCols - 1)
|
||||
|
||||
# NOTE: This is the extra number of pixels required to make the
|
||||
# wxListCtrl size correctly, at least under Windows 2000.
|
||||
# Unfortunately, different OSs and even different versions of the
|
||||
# same OS may implement the wxListCtrl differently, so different
|
||||
# margins may be needed to get the columns resized correctly. No
|
||||
# doubt the margin could be calculated in a more intelligent
|
||||
# manner...
|
||||
if wxPlatform == '__WXMSW__':
|
||||
margin = 6
|
||||
elif wxPlatform == '__WXGTK__':
|
||||
margin = 8
|
||||
else:
|
||||
margin = 0
|
||||
if totColWidth + self._lastColMinWidth > listWidth:
|
||||
# We haven't got the width to show the last column at its minimum
|
||||
# width -> set it to its minimum width and allow the horizontal
|
||||
# scrollbar to show.
|
||||
self.SetColumnWidth(numCols-1, self._lastColMinWidth)
|
||||
return
|
||||
|
||||
if totColWidth + self._lastColMinWidth > listWidth - margin:
|
||||
# We haven't got the width to show the last column at its minimum
|
||||
# width -> set it to its minimum width and allow the horizontal
|
||||
# scrollbar to show.
|
||||
self.SetColumnWidth(numCols-1, self._lastColMinWidth)
|
||||
return
|
||||
# Resize the last column to take up the remaining available space.
|
||||
|
||||
# Resize the last column to take up the remaining available space.
|
||||
|
||||
self.SetColumnWidth(numCols-1, listWidth - totColWidth - margin)
|
||||
self.SetColumnWidth(numCols-1, listWidth - totColWidth)
|
||||
|
||||
|
||||
|
||||
|
||||
389
wxPython/wxPython/lib/mixins/rubberband.py
Normal file
389
wxPython/wxPython/lib/mixins/rubberband.py
Normal file
@@ -0,0 +1,389 @@
|
||||
"""
|
||||
A mixin class for doing "RubberBand"-ing on a window.
|
||||
|
||||
by "Robb Shecter" <rs@onsitetech.com>
|
||||
|
||||
$Id$
|
||||
|
||||
"""
|
||||
|
||||
from wxPython.wx import *
|
||||
import Image
|
||||
|
||||
#
|
||||
# Some miscellaneous mathematical and geometrical functions
|
||||
#
|
||||
|
||||
def isNegative(aNumber):
|
||||
"""
|
||||
x < 0: 1
|
||||
else: 0
|
||||
"""
|
||||
return aNumber < 0
|
||||
|
||||
|
||||
def normalizeBox(box):
|
||||
"""
|
||||
Convert any negative measurements in the current
|
||||
box to positive, and adjust the origin.
|
||||
"""
|
||||
x, y, w, h = box
|
||||
if w < 0:
|
||||
x += (w+1)
|
||||
w *= -1
|
||||
if h < 0:
|
||||
y += (h+1)
|
||||
h *= -1
|
||||
return (x, y, w, h)
|
||||
|
||||
|
||||
def boxToExtent(box):
|
||||
"""
|
||||
Convert a box specification to an extent specification.
|
||||
I put this into a seperate function after I realized that
|
||||
I had been implementing it wrong in several places.
|
||||
"""
|
||||
b = normalizeBox(box)
|
||||
return (b[0], b[1], b[0]+b[2]-1, b[1]+b[3]-1)
|
||||
|
||||
|
||||
def pointInBox(x, y, box):
|
||||
"""
|
||||
Return True if the given point is contained in the box.
|
||||
"""
|
||||
e = boxToExtent(box)
|
||||
return x >= e[0] and x <= e[2] and y >= e[1] and y <= e[3]
|
||||
|
||||
|
||||
def pointOnBox(x, y, box, thickness=1):
|
||||
"""
|
||||
Return True if the point is on the outside edge
|
||||
of the box. The thickness defines how thick the
|
||||
edge should be. This is necessary for HCI reasons:
|
||||
For example, it's normally very difficult for a user
|
||||
to manuever the mouse onto a one pixel border.
|
||||
"""
|
||||
outerBox = box
|
||||
innerBox = (box[0]+thickness, box[1]+thickness, box[2]-(thickness*2), box[3]-(thickness*2))
|
||||
return pointInBox(x, y, outerBox) and not pointInBox(x, y, innerBox)
|
||||
|
||||
|
||||
def getCursorPosition(x, y, box, thickness=1):
|
||||
"""
|
||||
Return a position number in the range 0 .. 7 to indicate
|
||||
where on the box border the point is. The layout is:
|
||||
|
||||
0 1 2
|
||||
7 3
|
||||
6 5 4
|
||||
"""
|
||||
x0, y0, x1, y1 = boxToExtent(box)
|
||||
w, h = box[2], box[3]
|
||||
delta = thickness - 1
|
||||
p = None
|
||||
|
||||
if pointInBox(x, y, (x0, y0, thickness, thickness)):
|
||||
p = 0
|
||||
elif pointInBox(x, y, (x1-delta, y0, thickness, thickness)):
|
||||
p = 2
|
||||
elif pointInBox(x, y, (x1-delta, y1-delta, thickness, thickness)):
|
||||
p = 4
|
||||
elif pointInBox(x, y, (x0, y1-delta, thickness, thickness)):
|
||||
p = 6
|
||||
elif pointInBox(x, y, (x0+thickness, y0, w-(thickness*2), thickness)):
|
||||
p = 1
|
||||
elif pointInBox(x, y, (x1-delta, y0+thickness, thickness, h-(thickness*2))):
|
||||
p = 3
|
||||
elif pointInBox(x, y, (x0+thickness, y1-delta, w-(thickness*2), thickness)):
|
||||
p = 5
|
||||
elif pointInBox(x, y, (x0, y0+thickness, thickness, h-(thickness*2))):
|
||||
p = 7
|
||||
|
||||
return p
|
||||
|
||||
|
||||
|
||||
|
||||
class RubberBand:
|
||||
"""
|
||||
A stretchable border which is drawn on top of an
|
||||
image to define an area.
|
||||
"""
|
||||
def __init__(self, drawingSurface, aspectRatio=None):
|
||||
self.__THICKNESS = 5
|
||||
self.drawingSurface = drawingSurface
|
||||
self.aspectRatio = aspectRatio
|
||||
self.hasLetUp = 0
|
||||
self.currentlyMoving = None
|
||||
self.currentBox = None
|
||||
self.__enabled = 1
|
||||
self.__currentCursor = None
|
||||
EVT_MOUSE_EVENTS(drawingSurface, self.__handleMouseEvents)
|
||||
EVT_PAINT(drawingSurface, self.__handleOnPaint)
|
||||
|
||||
def __setEnabled(self, enabled):
|
||||
self.__enabled = enabled
|
||||
|
||||
def __isEnabled(self):
|
||||
return self.__enabled
|
||||
|
||||
def __handleOnPaint(self, event):
|
||||
#print 'paint'
|
||||
event.Skip()
|
||||
|
||||
def __isMovingCursor(self):
|
||||
"""
|
||||
Return True if the current cursor is one used to
|
||||
mean moving the rubberband.
|
||||
"""
|
||||
return self.__currentCursor == wxCURSOR_HAND
|
||||
|
||||
def __isSizingCursor(self):
|
||||
"""
|
||||
Return True if the current cursor is one of the ones
|
||||
I may use to signify sizing.
|
||||
"""
|
||||
sizingCursors = [wxCURSOR_SIZENESW,
|
||||
wxCURSOR_SIZENS,
|
||||
wxCURSOR_SIZENWSE,
|
||||
wxCURSOR_SIZEWE,
|
||||
wxCURSOR_SIZING,
|
||||
wxCURSOR_CROSS]
|
||||
try:
|
||||
sizingCursors.index(self.__currentCursor)
|
||||
return 1
|
||||
except ValueError:
|
||||
return 0
|
||||
|
||||
|
||||
def __handleMouseEvents(self, event):
|
||||
"""
|
||||
React according to the new event. This is the main
|
||||
entry point into the class. This method contains the
|
||||
logic for the class's behavior.
|
||||
"""
|
||||
if not self.enabled:
|
||||
return
|
||||
|
||||
x, y = event.GetPosition()
|
||||
|
||||
# First make sure we have started a box.
|
||||
if self.currentBox == None and not event.LeftDown():
|
||||
# No box started yet. Set cursor to the initial kind.
|
||||
self.__setCursor(wxCURSOR_CROSS)
|
||||
return
|
||||
|
||||
if event.LeftDown():
|
||||
if self.currentBox == None:
|
||||
# No RB Box, so start a new one.
|
||||
self.currentBox = (x, y, 0, 0)
|
||||
self.hasLetUp = 0
|
||||
elif self.__isSizingCursor():
|
||||
# Starting a sizing operation. Change the origin.
|
||||
position = getCursorPosition(x, y, self.currentBox, thickness=self.__THICKNESS)
|
||||
self.currentBox = self.__denormalizeBox(position, self.currentBox)
|
||||
|
||||
elif event.Dragging() and event.LeftIsDown():
|
||||
# Use the cursor type to determine operation
|
||||
if self.__isMovingCursor():
|
||||
if self.currentlyMoving or pointInBox(x, y, self.currentBox):
|
||||
if not self.currentlyMoving:
|
||||
self.currentlyMoving = (x - self.currentBox[0], y - self.currentBox[1])
|
||||
self.__moveTo(x - self.currentlyMoving[0], y - self.currentlyMoving[1])
|
||||
elif self.__isSizingCursor():
|
||||
self.__resizeBox(x, y)
|
||||
|
||||
elif event.LeftUp():
|
||||
self.hasLetUp = 1
|
||||
self.currentlyMoving = None
|
||||
self.__normalizeBox()
|
||||
|
||||
elif event.Moving() and not event.Dragging():
|
||||
# Simple mouse movement event
|
||||
self.__mouseMoved(x,y)
|
||||
|
||||
def __denormalizeBox(self, position, box):
|
||||
x, y, w, h = box
|
||||
b = box
|
||||
if position == 2 or position == 3:
|
||||
b = (x, y + (h-1), w, h * -1)
|
||||
elif position == 0 or position == 1 or position == 7:
|
||||
b = (x + (w-1), y + (h-1), w * -1, h * -1)
|
||||
elif position == 6:
|
||||
b = (x + (w-1), y, w * -1, h)
|
||||
return b
|
||||
|
||||
def __resizeBox(self, x, y):
|
||||
"""
|
||||
Resize and repaint the box based on the given mouse
|
||||
coordinates.
|
||||
"""
|
||||
# Implement the correct behavior for dragging a side
|
||||
# of the box: Only change one dimension.
|
||||
if not self.aspectRatio:
|
||||
if self.__currentCursor == wxCURSOR_SIZENS:
|
||||
x = None
|
||||
elif self.__currentCursor == wxCURSOR_SIZEWE:
|
||||
y = None
|
||||
|
||||
x0,y0,w0,h0 = self.currentBox
|
||||
currentExtent = boxToExtent(self.currentBox)
|
||||
if x == None:
|
||||
if w0 < 1:
|
||||
w0 += 1
|
||||
else:
|
||||
w0 -= 1
|
||||
x = x0 + w0
|
||||
if y == None:
|
||||
if h0 < 1:
|
||||
h0 += 1
|
||||
else:
|
||||
h0 -= 1
|
||||
y = y0 + h0
|
||||
x1,y1 = x, y
|
||||
w, h = abs(x1-x0)+1, abs(y1-y0)+1
|
||||
if self.aspectRatio:
|
||||
w = max(w, int(h * self.aspectRatio))
|
||||
h = int(w / self.aspectRatio)
|
||||
w *= [1,-1][isNegative(x1-x0)]
|
||||
h *= [1,-1][isNegative(y1-y0)]
|
||||
newbox = (x0, y0, w, h)
|
||||
self.__drawAndErase(boxToDraw=normalizeBox(newbox), boxToErase=normalizeBox(self.currentBox))
|
||||
self.currentBox = (x0, y0, w, h)
|
||||
|
||||
def __normalizeBox(self):
|
||||
"""
|
||||
Convert any negative measurements in the current
|
||||
box to positive, and adjust the origin.
|
||||
"""
|
||||
self.currentBox = normalizeBox(self.currentBox)
|
||||
|
||||
def __mouseMoved(self, x, y):
|
||||
"""
|
||||
Called when the mouse moved without any buttons pressed
|
||||
or dragging being done.
|
||||
"""
|
||||
# Are we on the bounding box?
|
||||
if pointOnBox(x, y, self.currentBox, thickness=self.__THICKNESS):
|
||||
position = getCursorPosition(x, y, self.currentBox, thickness=self.__THICKNESS)
|
||||
cursor = [
|
||||
wxCURSOR_SIZENWSE,
|
||||
wxCURSOR_SIZENS,
|
||||
wxCURSOR_SIZENESW,
|
||||
wxCURSOR_SIZEWE,
|
||||
wxCURSOR_SIZENWSE,
|
||||
wxCURSOR_SIZENS,
|
||||
wxCURSOR_SIZENESW,
|
||||
wxCURSOR_SIZEWE
|
||||
] [position]
|
||||
self.__setCursor(cursor)
|
||||
elif pointInBox(x, y, self.currentBox):
|
||||
self.__setCursor(wxCURSOR_HAND)
|
||||
else:
|
||||
self.__setCursor()
|
||||
|
||||
def __setCursor(self, id=None):
|
||||
"""
|
||||
Set the mouse cursor to the given id.
|
||||
"""
|
||||
if self.__currentCursor != id: # Avoid redundant calls
|
||||
if id:
|
||||
self.drawingSurface.SetCursor(wxStockCursor(id))
|
||||
else:
|
||||
self.drawingSurface.SetCursor(wxNullCursor)
|
||||
self.__currentCursor = id
|
||||
|
||||
def __moveCenterTo(self, x, y):
|
||||
"""
|
||||
Move the rubber band so that its center is at (x,y).
|
||||
"""
|
||||
x0, y0, w, h = self.currentBox
|
||||
x2, y2 = x - (w/2), y - (h/2)
|
||||
self.__moveTo(x2, y2)
|
||||
|
||||
def __moveTo(self, x, y):
|
||||
"""
|
||||
Move the rubber band so that its origin is at (x,y).
|
||||
"""
|
||||
newbox = (x, y, self.currentBox[2], self.currentBox[3])
|
||||
self.__drawAndErase(boxToDraw=newbox, boxToErase=self.currentBox)
|
||||
self.currentBox = newbox
|
||||
|
||||
def __drawAndErase(self, boxToDraw, boxToErase=None):
|
||||
"""
|
||||
Draw one box shape and possibly erase another.
|
||||
"""
|
||||
dc = wxClientDC(self.drawingSurface)
|
||||
dc.BeginDrawing()
|
||||
dc.SetPen(wxPen(wxWHITE, 1, wxDOT))
|
||||
dc.SetBrush(wxTRANSPARENT_BRUSH)
|
||||
dc.SetLogicalFunction(wxXOR)
|
||||
if boxToErase:
|
||||
dc.DrawRectangle(*boxToErase)
|
||||
dc.DrawRectangle(*boxToDraw)
|
||||
dc.EndDrawing()
|
||||
|
||||
def __dumpMouseEvent(self, event):
|
||||
print 'Moving: ',event.Moving()
|
||||
print 'Dragging: ',event.Dragging()
|
||||
print 'LeftDown: ',event.LeftDown()
|
||||
print 'LeftisDown: ',event.LeftIsDown()
|
||||
print 'LeftUp: ',event.LeftUp()
|
||||
print 'Position: ',event.GetPosition()
|
||||
print 'x,y: ',event.GetX(),event.GetY()
|
||||
print
|
||||
|
||||
|
||||
#
|
||||
# The public API:
|
||||
#
|
||||
|
||||
def reset(self, aspectRatio=None):
|
||||
"""
|
||||
Clear the existing rubberband
|
||||
"""
|
||||
self.currentBox = None
|
||||
self.aspectRatio = aspectRatio
|
||||
self.drawingSurface.Refresh()
|
||||
|
||||
def getCurrentExtent(self):
|
||||
"""
|
||||
Return (x0, y0, x1, y1) or None if
|
||||
no drawing has yet been done.
|
||||
"""
|
||||
if not self.currentBox:
|
||||
extent = None
|
||||
else:
|
||||
extent = boxToExtent(self.currentBox)
|
||||
return extent
|
||||
|
||||
enabled = property(__isEnabled, __setEnabled, None, 'True if I am responding to mouse events')
|
||||
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
app = wxPySimpleApp()
|
||||
frame = wxFrame(None, -1, title='RubberBand Test', size=(300,300))
|
||||
|
||||
# Add a panel that the rubberband will work on.
|
||||
panel = wxPanel(frame, -1)
|
||||
panel.SetBackgroundColour(wxBLUE)
|
||||
|
||||
# Create the rubberband
|
||||
frame.rubberBand = RubberBand(drawingSurface=panel)
|
||||
frame.rubberBand.reset(aspectRatio=0.5)
|
||||
|
||||
# Add a button that creates a new rubberband
|
||||
def __newRubberBand(event):
|
||||
frame.rubberBand.reset()
|
||||
button = wxButton(frame, 100, 'Reset Rubberband')
|
||||
EVT_BUTTON(frame, 100, __newRubberBand)
|
||||
|
||||
# Layout the frame
|
||||
sizer = wxBoxSizer(wxVERTICAL)
|
||||
sizer.Add(panel, 1, wxEXPAND | wxALL, 5)
|
||||
sizer.Add(button, 0, wxALIGN_CENTER | wxALL, 5)
|
||||
frame.SetAutoLayout(1)
|
||||
frame.SetSizer(sizer)
|
||||
frame.Show(1)
|
||||
app.MainLoop()
|
||||
Reference in New Issue
Block a user