Added wxIntCtrl from Will Sadkin
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/branches/WX_2_4_BRANCH@18870 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robin Dunn
@@ -5,6 +5,10 @@ CHANGES.txt for wxPython
|
||||
2.4.0.2
|
||||
-------
|
||||
|
||||
Mostly bug fixes.
|
||||
|
||||
Added wxIntCtrl from Will Sadkin.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -25,11 +25,8 @@ import images
|
||||
_treeList = [
|
||||
# new stuff
|
||||
('New since last release', [
|
||||
'wxRadioButton',
|
||||
'Throbber',
|
||||
'wxPopupControl',
|
||||
'wxMultiSash',
|
||||
'EventManager',
|
||||
'wxIntCtrl',
|
||||
|
||||
]),
|
||||
|
||||
# managed windows == things with a caption you can close
|
||||
@@ -102,6 +99,7 @@ _treeList = [
|
||||
('More Windows/Controls', [
|
||||
#'wxFloatBar', deprecated
|
||||
#'wxMVCTree', deprecated
|
||||
#'wxRightTextCtrl', deprecated as we have wxTE_RIGHT now.
|
||||
'ColourSelect',
|
||||
'ContextHelp',
|
||||
'FancyText',
|
||||
@@ -119,11 +117,11 @@ _treeList = [
|
||||
'wxEditor',
|
||||
'wxHtmlWindow',
|
||||
'wxIEHtmlWin',
|
||||
'wxIntCtrl',
|
||||
'wxLEDNumberCtrl',
|
||||
'wxMimeTypesManager',
|
||||
'wxMultiSash',
|
||||
'wxPopupControl',
|
||||
'wxRightTextCtrl',
|
||||
'wxStyledTextCtrl_1',
|
||||
'wxStyledTextCtrl_2',
|
||||
'wxTimeCtrl',
|
||||
@@ -148,9 +146,9 @@ _treeList = [
|
||||
'OOR',
|
||||
'PythonEvents',
|
||||
'Threads',
|
||||
'wxKeyEvents',
|
||||
'wxProcess',
|
||||
'wxTimer',
|
||||
'wxKeyEvents',
|
||||
]),
|
||||
|
||||
# Clipboard and DnD
|
||||
@@ -163,11 +161,11 @@ _treeList = [
|
||||
# Images
|
||||
('Using Images', [
|
||||
'Throbber',
|
||||
'wxArtProvider',
|
||||
'wxDragImage',
|
||||
'wxImage',
|
||||
'wxImageFromStream',
|
||||
'wxMask',
|
||||
'wxArtProvider',
|
||||
]),
|
||||
|
||||
# Other stuff
|
||||
|
||||
337
wxPython/demo/wxIntCtrl.py
Normal file
337
wxPython/demo/wxIntCtrl.py
Normal file
@@ -0,0 +1,337 @@
|
||||
from wxPython.wx import *
|
||||
from wxPython.lib.intctrl import *
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class TestPanel( wxPanel ):
|
||||
def __init__( self, parent, log ):
|
||||
|
||||
wxPanel.__init__( self, parent, -1 )
|
||||
self.log = log
|
||||
panel = wxPanel( self, -1 )
|
||||
|
||||
self.set_min = wxCheckBox( panel, -1, "Set minimum value:" )
|
||||
self.min = wxIntCtrl( panel, size=wxSize( 50, 20 ) )
|
||||
self.min.Enable( FALSE )
|
||||
|
||||
self.set_max = wxCheckBox( panel, -1, "Set maximum value:" )
|
||||
self.max = wxIntCtrl( panel, size=wxSize( 50, 20 ) )
|
||||
self.max.Enable( FALSE )
|
||||
|
||||
self.limit_target = wxCheckBox( panel, -1, "Limit control" )
|
||||
self.allow_none = wxCheckBox( panel, -1, "Allow empty control" )
|
||||
self.allow_long = wxCheckBox( panel, -1, "Allow long integers" )
|
||||
|
||||
label = wxStaticText( panel, -1, "Resulting integer control:" )
|
||||
self.target_ctl = wxIntCtrl( panel )
|
||||
|
||||
grid = wxFlexGridSizer( 0, 2, 0, 0 )
|
||||
grid.AddWindow( self.set_min, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5 )
|
||||
grid.AddWindow( self.min, 0, wxALIGN_LEFT|wxALL, 5 )
|
||||
|
||||
grid.AddWindow( self.set_max, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5 )
|
||||
grid.AddWindow( self.max, 0, wxALIGN_LEFT|wxALL, 5 )
|
||||
|
||||
grid.AddWindow( self.limit_target, 0, wxALIGN_LEFT|wxALL, 5 )
|
||||
grid.AddSpacer( 20, 0, 0, wxALIGN_LEFT|wxALL, 5 )
|
||||
grid.AddWindow( self.allow_none, 0, wxALIGN_LEFT|wxALL, 5 )
|
||||
grid.AddSpacer( 20, 0, 0, wxALIGN_LEFT|wxALL, 5 )
|
||||
grid.AddWindow( self.allow_long, 0, wxALIGN_LEFT|wxALL, 5 )
|
||||
grid.AddSpacer( 20, 0, 0, wxALIGN_LEFT|wxALL, 5 )
|
||||
|
||||
grid.AddSpacer( 20, 0, 0, wxALIGN_LEFT|wxALL, 5 )
|
||||
grid.AddSpacer( 20, 0, 0, wxALIGN_LEFT|wxALL, 5 )
|
||||
|
||||
grid.AddWindow( label, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5 )
|
||||
grid.AddWindow( self.target_ctl, 0, wxALIGN_LEFT|wxALL, 5 )
|
||||
|
||||
outer_box = wxBoxSizer( wxVERTICAL )
|
||||
outer_box.AddSizer( grid, 0, wxALIGN_CENTRE|wxALL, 20 )
|
||||
|
||||
panel.SetAutoLayout( true )
|
||||
panel.SetSizer( outer_box )
|
||||
outer_box.Fit( panel )
|
||||
panel.Move( (50,50) )
|
||||
self.panel = panel
|
||||
|
||||
EVT_CHECKBOX( self, self.set_min.GetId(), self.OnSetMin )
|
||||
EVT_CHECKBOX( self, self.set_max.GetId(), self.OnSetMax )
|
||||
EVT_CHECKBOX( self, self.limit_target.GetId(), self.SetTargetMinMax )
|
||||
EVT_CHECKBOX( self, self.allow_none.GetId(), self.OnSetAllowNone )
|
||||
EVT_CHECKBOX( self, self.allow_long.GetId(), self.OnSetAllowLong )
|
||||
EVT_INT( self, self.min.GetId(), self.SetTargetMinMax )
|
||||
EVT_INT( self, self.max.GetId(), self.SetTargetMinMax )
|
||||
EVT_INT( self, self.target_ctl.GetId(), self.OnTargetChange )
|
||||
|
||||
|
||||
def OnSetMin( self, event ):
|
||||
self.min.Enable( self.set_min.GetValue() )
|
||||
self.SetTargetMinMax()
|
||||
|
||||
def OnSetMax( self, event ):
|
||||
self.max.Enable( self.set_max.GetValue() )
|
||||
self.SetTargetMinMax()
|
||||
|
||||
|
||||
def SetTargetMinMax( self, event=None ):
|
||||
min = max = None
|
||||
self.target_ctl.SetLimited( self.limit_target.GetValue() )
|
||||
|
||||
if self.set_min.GetValue():
|
||||
min = self.min.GetValue()
|
||||
if self.set_max.GetValue():
|
||||
max = self.max.GetValue()
|
||||
|
||||
cur_min, cur_max = self.target_ctl.GetBounds()
|
||||
|
||||
if min != cur_min and not self.target_ctl.SetMin( min ):
|
||||
self.log.write( "min (%d) > current max (%d) -- bound not set\n" % ( min, self.target_ctl.GetMax() ) )
|
||||
self.min.SetForegroundColour( wxRED )
|
||||
else:
|
||||
self.min.SetForegroundColour( wxBLACK )
|
||||
self.min.Refresh()
|
||||
|
||||
if max != cur_max and not self.target_ctl.SetMax( max ):
|
||||
self.log.write( "max (%d) < current min (%d) -- bound not set\n" % ( max, self.target_ctl.GetMin() ) )
|
||||
self.max.SetForegroundColour( wxRED )
|
||||
else:
|
||||
self.max.SetForegroundColour( wxBLACK )
|
||||
self.max.Refresh()
|
||||
|
||||
if min != cur_min or max != cur_max:
|
||||
new_min, new_max = self.target_ctl.GetBounds()
|
||||
self.log.write( "current min, max: (%s, %s)\n" % ( str(new_min), str(new_max) ) )
|
||||
|
||||
|
||||
def OnSetAllowNone( self, event ):
|
||||
self.target_ctl.SetNoneAllowed( self.allow_none.GetValue() )
|
||||
|
||||
|
||||
def OnSetAllowLong( self, event ):
|
||||
self.target_ctl.SetLongAllowed( self.allow_long.GetValue() )
|
||||
|
||||
|
||||
def OnTargetChange( self, event ):
|
||||
ctl = event.GetEventObject()
|
||||
value = ctl.GetValue()
|
||||
ib_str = [ " (out of bounds)", "" ]
|
||||
self.log.write( "integer value = %s%s\n" % ( str(value), ib_str[ ctl.IsInBounds(value) ] ) )
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
def runTest( frame, nb, log ):
|
||||
win = TestPanel( nb, log )
|
||||
return win
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
overview = """<html><body>
|
||||
<P>
|
||||
<B>wxIntCtrl</B> provides a control that takes and returns integers as
|
||||
value, and provides bounds support and optional value limiting.
|
||||
<P>
|
||||
<P>
|
||||
Here's the API for wxIntCtrl:
|
||||
<DL><PRE>
|
||||
<B>wxIntCtrl</B>(
|
||||
parent, id = -1,
|
||||
<B>value</B> = 0,
|
||||
<B>min</B> = None,
|
||||
<B>max</B> = None,
|
||||
<B>limited</B> = False,
|
||||
<B>allow_none</B> = False,
|
||||
<B>allow_long</B> = False,
|
||||
<B>default_color</B> = wxBLACK,
|
||||
<B>oob_color</B> = wxRED,
|
||||
pos = wxDefaultPosition,
|
||||
size = wxDefaultSize,
|
||||
style = 0,
|
||||
name = "integer")
|
||||
</PRE>
|
||||
<UL>
|
||||
<DT><B>value</B>
|
||||
<DD>If no initial value is set, the default will be zero, or
|
||||
the minimum value, if specified. If an illegal string is specified,
|
||||
a ValueError will result. (You can always later set the initial
|
||||
value with SetValue() after instantiation of the control.)
|
||||
<BR>
|
||||
<DL><B>min</B>
|
||||
<DD>The minimum value that the control should allow. This can be
|
||||
adjusted with SetMin(). If the control is not limited, any value
|
||||
below this bound will be colored with the current out-of-bounds color.
|
||||
<BR>
|
||||
<DT><B>max</B>
|
||||
<DD>The maximum value that the control should allow. This can be
|
||||
adjusted with SetMax(). If the control is not limited, any value
|
||||
above this bound will be colored with the current out-of-bounds color.
|
||||
<BR>
|
||||
<DT><B>limited</B>
|
||||
<DD>Boolean indicating whether the control prevents values from
|
||||
exceeding the currently set minimum and maximum values (bounds).
|
||||
If <I>false</I> and bounds are set, out-of-bounds values will
|
||||
be colored with the current out-of-bounds color.
|
||||
<BR>
|
||||
<DT><B>allow_none</B>
|
||||
<DD>Boolean indicating whether or not the control is allowed to be
|
||||
empty, representing a value of <I>None</I> for the control.
|
||||
<BR>
|
||||
<DT><B>allow_long</B>
|
||||
<DD>Boolean indicating whether or not the control is allowed to hold
|
||||
and return a value of type long as well as int. If false, the
|
||||
control will be implicitly limited to have a value such that
|
||||
-sys.maxint-1 <= n <= sys.maxint.
|
||||
<BR>
|
||||
<DT><B>default_color</B>
|
||||
<DD>Color value used for in-bounds values of the control.
|
||||
<BR>
|
||||
<DT><B>oob_color</B>
|
||||
<DD>Color value used for out-of-bounds values of the control
|
||||
when the bounds are set but the control is not limited.
|
||||
</UL>
|
||||
<BR>
|
||||
<BR>
|
||||
<DT><B>EVT_INT(win, id, func)</B>
|
||||
<DD>Respond to a wxEVT_COMMAND_INT_UPDATED event, generated when the
|
||||
value changes. Notice that this event will always be sent when the
|
||||
control's contents changes - whether this is due to user input or
|
||||
comes from the program itself (for example, if SetValue() is called.)
|
||||
<BR>
|
||||
<BR>
|
||||
<DT><B>SetValue(int)</B>
|
||||
<DD>Sets the value of the control to the integer value specified.
|
||||
The resulting actual value of the control may be altered to
|
||||
conform with the bounds set on the control if limited,
|
||||
or colored if not limited but the value is out-of-bounds.
|
||||
A ValueError exception will be raised if an invalid value
|
||||
is specified.
|
||||
<BR>
|
||||
<DT><B>GetValue()</B>
|
||||
<DD>Retrieves the integer value from the control. The value
|
||||
retrieved will be sized as an int if possible or a long,
|
||||
if necessary.
|
||||
<BR>
|
||||
<BR>
|
||||
<DT><B>SetMin(min=None)</B>
|
||||
<DD>Sets the expected minimum value, or lower bound, of the control.
|
||||
(The lower bound will only be enforced if the control is
|
||||
configured to limit its values to the set bounds.)
|
||||
If a value of <I>None</I> is provided, then the control will have
|
||||
no explicit lower bound. If the value specified is greater than
|
||||
the current lower bound, then the function returns 0 and the
|
||||
lower bound will not change from its current setting. On success,
|
||||
the function returns 1.
|
||||
<DT><DD>If successful and the current value is
|
||||
lower than the new lower bound, if the control is limited, the
|
||||
value will be automatically adjusted to the new minimum value;
|
||||
if not limited, the value in the control will be colored with
|
||||
the current out-of-bounds color.
|
||||
<BR>
|
||||
<DT><B>GetMin()</B>
|
||||
<DD>Gets the current lower bound value for the control.
|
||||
It will return None if no lower bound is currently specified.
|
||||
<BR>
|
||||
<BR>
|
||||
<DT><B>SetMax(max=None)</B>
|
||||
<DD>Sets the expected maximum value, or upper bound, of the control.
|
||||
(The upper bound will only be enforced if the control is
|
||||
configured to limit its values to the set bounds.)
|
||||
If a value of <I>None</I> is provided, then the control will
|
||||
have no explicit upper bound. If the value specified is less
|
||||
than the current lower bound, then the function returns 0 and
|
||||
the maximum will not change from its current setting. On success,
|
||||
the function returns 1.
|
||||
<DT><DD>If successful and the current value
|
||||
is greater than the new upper bound, if the control is limited
|
||||
the value will be automatically adjusted to the new maximum value;
|
||||
if not limited, the value in the control will be colored with the
|
||||
current out-of-bounds color.
|
||||
<BR>
|
||||
<DT><B>GetMax()</B>
|
||||
<DD>Gets the current upper bound value for the control.
|
||||
It will return None if no upper bound is currently specified.
|
||||
<BR>
|
||||
<BR>
|
||||
<DT><B>SetBounds(min=None,max=None)</B>
|
||||
<DD>This function is a convenience function for setting the min and max
|
||||
values at the same time. The function only applies the maximum bound
|
||||
if setting the minimum bound is successful, and returns true
|
||||
only if both operations succeed. <B><I>Note:</I></B> leaving out an argument
|
||||
will remove the corresponding bound.
|
||||
<DT><B>GetBounds()</B>
|
||||
<DD>This function returns a two-tuple (min,max), indicating the
|
||||
current bounds of the control. Each value can be None if
|
||||
that bound is not set.
|
||||
<BR>
|
||||
<BR>
|
||||
<DT><B>IsInBounds(value=None)</B>
|
||||
<DD>Returns <I>true</I> if no value is specified and the current value
|
||||
of the control falls within the current bounds. This function can also
|
||||
be called with a value to see if that value would fall within the current
|
||||
bounds of the given control.
|
||||
<BR>
|
||||
<BR>
|
||||
<DT><B>SetLimited(bool)</B>
|
||||
<DD>If called with a value of true, this function will cause the control
|
||||
to limit the value to fall within the bounds currently specified.
|
||||
If the control's value currently exceeds the bounds, it will then
|
||||
be limited accordingly.
|
||||
If called with a value of 0, this function will disable value
|
||||
limiting, but coloring of out-of-bounds values will still take
|
||||
place if bounds have been set for the control.
|
||||
<DT><B>IsLimited()</B>
|
||||
<DD>Returns <I>true</I> if the control is currently limiting the
|
||||
value to fall within the current bounds.
|
||||
<BR>
|
||||
<BR>
|
||||
<DT><B>SetNoneAllowed(bool)</B>
|
||||
<DD>If called with a value of true, this function will cause the control
|
||||
to allow the value to be empty, representing a value of None.
|
||||
If called with a value of fakse, this function will prevent the value
|
||||
from being None. If the value of the control is currently None,
|
||||
ie. the control is empty, then the value will be changed to that
|
||||
of the lower bound of the control, or 0 if no lower bound is set.
|
||||
<DT><B>IsNoneAllowed()</B>
|
||||
<DD>Returns <I>true</I> if the control currently allows its
|
||||
value to be None.
|
||||
<BR>
|
||||
<BR>
|
||||
<DT><B>SetLongAllowed(bool)</B>
|
||||
<DD>If called with a value of true, this function will cause the
|
||||
control to allow the value to be a long. If called with a value
|
||||
of false, and the value of the control is currently a long value,
|
||||
the value of the control will be adjusted to fall within the
|
||||
size of an integer type, at either the sys.maxint or -sys.maxint-1,
|
||||
for positive and negative values, respectively.
|
||||
<DT><B>IsLongAllowed()</B>
|
||||
<DD>Returns <I>true</I> if the control currently allows its
|
||||
value to be of type long.
|
||||
<BR>
|
||||
<BR>
|
||||
<DT><B>SetColors(default_color=wxBLACK, oob_color=wxRED)</B>
|
||||
<DD>Tells the control what colors to use for normal and out-of-bounds
|
||||
values. If the value currently exceeds the bounds, it will be
|
||||
recolored accordingly.
|
||||
<DT><B>GetColors()</B>
|
||||
<DD>Returns a tuple of <I>(default_color, oob_color)</I> indicating
|
||||
the current color settings for the control.
|
||||
<BR>
|
||||
<BR>
|
||||
<DT><B>Cut()</B>
|
||||
<DD>Will allow cuts to the clipboard of the text portion of the value,
|
||||
leaving the value of zero if the entire contents are "cut."
|
||||
<DT><B>Paste()</B>
|
||||
<DD>Will paste the contents of the clipboard to the selected portion
|
||||
of the value; if the resulting string does not represent a legal
|
||||
value, a ValueError will result. If the result is out-of bounds,
|
||||
it will either be adjusted or colored as appropriate.
|
||||
</DL>
|
||||
</body></html>
|
||||
"""
|
||||
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
import sys,os
|
||||
import run
|
||||
run.main(['', os.path.basename(sys.argv[0])])
|
||||
859
wxPython/wxPython/lib/intctrl.py
Normal file
859
wxPython/wxPython/lib/intctrl.py
Normal file
@@ -0,0 +1,859 @@
|
||||
#----------------------------------------------------------------------------
|
||||
# Name: wxPython.lib.intctrl.py
|
||||
# Author: Will Sadkin
|
||||
# Created: 01/16/2003
|
||||
# Copyright: (c) 2003 by Will Sadkin
|
||||
# RCS-ID: $Id$
|
||||
# License: wxWindows license
|
||||
#----------------------------------------------------------------------------
|
||||
# NOTE:
|
||||
# This was written to provide a standard integer edit control for wxPython.
|
||||
#
|
||||
# wxIntCtrl permits integer (long) values to be retrieved or set via
|
||||
# .GetValue() and .SetValue(), and provides an EVT_INT() event function
|
||||
# for trapping changes to the control.
|
||||
#
|
||||
# It supports negative integers as well as the naturals, and does not
|
||||
# permit leading zeros or an empty control; attempting to delete the
|
||||
# contents of the control will result in a (selected) value of zero,
|
||||
# thus preserving a legitimate integer value, or an empty control
|
||||
# (if a value of None is allowed for the control.) Similarly, replacing the
|
||||
# contents of the control with '-' will result in a selected (absolute)
|
||||
# value of -1.
|
||||
#
|
||||
# wxIntCtrl also supports range limits, with the option of either
|
||||
# enforcing them or simply coloring the text of the control if the limits
|
||||
# are exceeded.
|
||||
|
||||
from wxPython.wx import *
|
||||
import types, string
|
||||
from sys import maxint
|
||||
MAXINT = maxint # (constants should be in upper case)
|
||||
MININT = -maxint-1
|
||||
|
||||
#----------------------------------------------------------------------------
|
||||
|
||||
wxEVT_COMMAND_INT_UPDATED = wxNewEventType()
|
||||
|
||||
# wxWindows' wxTextCtrl translates Composite "control key"
|
||||
# events into single events before returning them to its OnChar
|
||||
# routine. The doc says that this results in 1 for Ctrl-A, 2 for
|
||||
# Ctrl-B, etc. However, there are no wxPython or wxWindows
|
||||
# symbols for them, so I'm defining codes for Ctrl-X (cut) and
|
||||
# Ctrl-V (paste) here for readability:
|
||||
WXK_CTRL_X = (ord('X')+1) - ord('A')
|
||||
WXK_CTRL_V = (ord('V')+1) - ord('A')
|
||||
|
||||
|
||||
def EVT_INT(win, id, func):
|
||||
"""Used to trap events indicating that the current
|
||||
integer value of the control has been changed."""
|
||||
win.Connect(id, -1, wxEVT_COMMAND_INT_UPDATED, func)
|
||||
|
||||
|
||||
class wxIntUpdatedEvent(wxPyCommandEvent):
|
||||
def __init__(self, id, value = 0, object=None):
|
||||
wxPyCommandEvent.__init__(self, wxEVT_COMMAND_INT_UPDATED, id)
|
||||
|
||||
self.__value = value
|
||||
self.SetEventObject(object)
|
||||
|
||||
def GetValue(self):
|
||||
"""Retrieve the value of the control at the time
|
||||
this event was generated."""
|
||||
return self.__value
|
||||
|
||||
|
||||
#----------------------------------------------------------------------------
|
||||
|
||||
class wxIntValidator( wxPyValidator ):
|
||||
"""
|
||||
Validator class used with wxIntCtrl; handles all validation of input
|
||||
prior to changing the value of the underlying wxTextCtrl.
|
||||
"""
|
||||
def __init__(self):
|
||||
wxPyValidator.__init__(self)
|
||||
EVT_CHAR(self, self.OnChar)
|
||||
|
||||
def Clone (self):
|
||||
return self.__class__()
|
||||
|
||||
def Validate(self, window): # window here is the *parent* of the ctrl
|
||||
"""
|
||||
Because each operation on the control is vetted as it's made,
|
||||
the value of the control is always valid.
|
||||
"""
|
||||
return 1
|
||||
|
||||
|
||||
def OnChar(self, event):
|
||||
"""
|
||||
Validates keystrokes to make sure the resulting value will a legal
|
||||
value. Erasing the value causes it to be set to 0, with the value
|
||||
selected, so it can be replaced. Similarly, replacing the value
|
||||
with a '-' sign causes the value to become -1, with the value
|
||||
selected. Leading zeros are removed if introduced by selection,
|
||||
and are prevented from being inserted.
|
||||
"""
|
||||
key = event.KeyCode()
|
||||
ctrl = event.GetEventObject()
|
||||
|
||||
|
||||
value = ctrl.GetValue()
|
||||
textval = wxTextCtrl.GetValue(ctrl)
|
||||
allow_none = ctrl.IsNoneAllowed()
|
||||
|
||||
pos = ctrl.GetInsertionPoint()
|
||||
sel_start, sel_to = ctrl.GetSelection()
|
||||
select_len = sel_to - sel_start
|
||||
|
||||
# (Uncomment for debugging:)
|
||||
## print 'keycode:', key
|
||||
## print 'pos:', pos
|
||||
## print 'sel_start, sel_to:', sel_start, sel_to
|
||||
## print 'select_len:', select_len
|
||||
## print 'textval:', textval
|
||||
|
||||
# set defaults for processing:
|
||||
allow_event = 1
|
||||
set_to_none = 0
|
||||
set_to_zero = 0
|
||||
set_to_minus_one = 0
|
||||
paste = 0
|
||||
internally_set = 0
|
||||
|
||||
new_value = value
|
||||
new_text = textval
|
||||
new_pos = pos
|
||||
|
||||
# Validate action, and predict resulting value, so we can
|
||||
# range check the result and validate that too.
|
||||
|
||||
if key in (WXK_DELETE, WXK_BACK, WXK_CTRL_X):
|
||||
if select_len:
|
||||
new_text = textval[:sel_start] + textval[sel_to:]
|
||||
elif key == WXK_DELETE and pos < len(textval):
|
||||
new_text = textval[:pos] + textval[pos+1:]
|
||||
elif key == WXK_BACK and pos > 0:
|
||||
new_text = textval[:pos-1] + textval[pos:]
|
||||
# (else value shouldn't change)
|
||||
|
||||
if new_text in ('', '-'):
|
||||
# Deletion of last significant digit:
|
||||
if allow_none and new_text == '':
|
||||
new_value = None
|
||||
set_to_none = 1
|
||||
else:
|
||||
new_value = 0
|
||||
set_to_zero = 1
|
||||
else:
|
||||
try:
|
||||
new_value = ctrl._fromGUI(new_text)
|
||||
except ValueError:
|
||||
allow_event = 0
|
||||
|
||||
|
||||
elif key == WXK_CTRL_V: # (see comments at top of file)
|
||||
# Only allow paste if number:
|
||||
paste_text = ctrl._getClipboardContents()
|
||||
new_text = textval[:sel_start] + paste_text + textval[sel_to:]
|
||||
if new_text == '' and allow_none:
|
||||
new_value = None
|
||||
set_to_none = 1
|
||||
else:
|
||||
try:
|
||||
# Convert the resulting strings, verifying they
|
||||
# are legal integers and will fit in proper
|
||||
# size if ctrl limited to int. (if not,
|
||||
# disallow event.)
|
||||
new_value = ctrl._fromGUI(new_text)
|
||||
if paste_text:
|
||||
paste_value = ctrl._fromGUI(paste_text)
|
||||
else:
|
||||
paste_value = 0
|
||||
new_pos = sel_start + len(str(paste_value))
|
||||
|
||||
# if resulting value is 0, truncate and highlight value:
|
||||
if new_value == 0 and len(new_text) > 1:
|
||||
set_to_zero = 1
|
||||
|
||||
elif paste_value == 0:
|
||||
# Disallow pasting a leading zero with nothing selected:
|
||||
if( select_len == 0
|
||||
and value is not None
|
||||
and ( (value >= 0 and pos == 0)
|
||||
or (value < 0 and pos in [0,1]) ) ):
|
||||
allow_event = 0
|
||||
paste = 1
|
||||
|
||||
except ValueError:
|
||||
allow_event = 0
|
||||
|
||||
|
||||
elif key < WXK_SPACE or key > 255:
|
||||
pass # event ok
|
||||
|
||||
|
||||
elif chr(key) == '-':
|
||||
# Allow '-' to result in -1 if replacing entire contents:
|
||||
if( value is None
|
||||
or (value == 0 and pos == 0)
|
||||
or (select_len >= len(str(abs(value)))) ):
|
||||
new_value = -1
|
||||
set_to_minus_one = 1
|
||||
|
||||
# else allow negative sign only at start, and only if
|
||||
# number isn't already zero or negative:
|
||||
elif pos != 0 or (value is not None and value < 0):
|
||||
allow_event = 0
|
||||
else:
|
||||
new_text = '-' + textval
|
||||
new_pos = 1
|
||||
try:
|
||||
new_value = ctrl._fromGUI(new_text)
|
||||
except ValueError:
|
||||
allow_event = 0
|
||||
|
||||
|
||||
elif chr(key) in string.digits:
|
||||
# disallow inserting a leading zero with nothing selected
|
||||
if( chr(key) == '0'
|
||||
and select_len == 0
|
||||
and value is not None
|
||||
and ( (value >= 0 and pos == 0)
|
||||
or (value < 0 and pos in [0,1]) ) ):
|
||||
allow_event = 0
|
||||
# disallow inserting digits before the minus sign:
|
||||
elif value is not None and value < 0 and pos == 0:
|
||||
allow_event = 0
|
||||
else:
|
||||
new_text = textval[:sel_start] + chr(key) + textval[sel_to:]
|
||||
try:
|
||||
new_value = ctrl._fromGUI(new_text)
|
||||
except ValueError:
|
||||
allow_event = 0
|
||||
|
||||
else:
|
||||
# not a legal char
|
||||
allow_event = 0
|
||||
|
||||
|
||||
if allow_event:
|
||||
# Do range checking for new candidate value:
|
||||
if ctrl.IsLimited() and not ctrl.IsInBounds(new_value):
|
||||
allow_event = 0
|
||||
elif new_value is not None:
|
||||
# ensure resulting text doesn't result in a leading 0:
|
||||
if not set_to_zero and not set_to_minus_one:
|
||||
if( (new_value > 0 and new_text[0] == '0')
|
||||
or (new_value < 0 and new_text[1] == '0')
|
||||
or (new_value == 0 and select_len > 1 ) ):
|
||||
|
||||
# Allow replacement of leading chars with
|
||||
# zero, but remove the leading zero, effectively
|
||||
# making this like "remove leading digits"
|
||||
|
||||
# Account for leading zero when positioning cursor:
|
||||
if( key == WXK_BACK
|
||||
or (paste and paste_value == 0 and new_pos > 0) ):
|
||||
new_pos = new_pos - 1
|
||||
|
||||
wxCallAfter(ctrl.SetValue, new_value)
|
||||
wxCallAfter(ctrl.SetInsertionPoint, new_pos)
|
||||
internally_set = 1
|
||||
|
||||
elif paste:
|
||||
# Always do paste numerically, to remove
|
||||
# leading/trailing spaces
|
||||
wxCallAfter(ctrl.SetValue, new_value)
|
||||
wxCallAfter(ctrl.SetInsertionPoint, new_pos)
|
||||
internally_set = 1
|
||||
|
||||
elif (new_value == 0 and len(new_text) > 1 ):
|
||||
allow_event = 0
|
||||
|
||||
if allow_event:
|
||||
ctrl._colorValue(new_value) # (one way or t'other)
|
||||
|
||||
# (Uncomment for debugging:)
|
||||
## if allow_event:
|
||||
## print 'new value:', new_value
|
||||
## if paste: print 'paste'
|
||||
## if set_to_none: print 'set_to_none'
|
||||
## if set_to_zero: print 'set_to_zero'
|
||||
## if set_to_minus_one: print 'set_to_minus_one'
|
||||
## if internally_set: print 'internally_set'
|
||||
## else:
|
||||
## print 'new text:', new_text
|
||||
## print 'disallowed'
|
||||
## print
|
||||
|
||||
if allow_event:
|
||||
if set_to_none:
|
||||
wxCallAfter(ctrl.SetValue, new_value)
|
||||
|
||||
elif set_to_zero:
|
||||
# select to "empty" numeric value
|
||||
wxCallAfter(ctrl.SetValue, new_value)
|
||||
wxCallAfter(ctrl.SetSelection, 0, 1)
|
||||
|
||||
elif set_to_minus_one:
|
||||
wxCallAfter(ctrl.SetValue, new_value)
|
||||
wxCallAfter(ctrl.SetSelection, 1, 2)
|
||||
|
||||
elif not internally_set:
|
||||
event.Skip() # allow base wxTextCtrl to finish processing
|
||||
|
||||
elif not wxValidator_IsSilent():
|
||||
wxBell()
|
||||
|
||||
|
||||
def TransferToWindow(self):
|
||||
""" Transfer data from validator to window.
|
||||
|
||||
The default implementation returns false, indicating that an error
|
||||
occurred. We simply return true, as we don't do any data transfer.
|
||||
"""
|
||||
return true # Prevent wxDialog from complaining.
|
||||
|
||||
|
||||
def TransferFromWindow(self):
|
||||
""" Transfer data from window to validator.
|
||||
|
||||
The default implementation returns false, indicating that an error
|
||||
occurred. We simply return true, as we don't do any data transfer.
|
||||
"""
|
||||
return true # Prevent wxDialog from complaining.
|
||||
|
||||
|
||||
#----------------------------------------------------------------------------
|
||||
|
||||
class wxIntCtrl(wxTextCtrl):
|
||||
"""
|
||||
This class provides a control that takes and returns integers as
|
||||
value, and provides bounds support and optional value limiting.
|
||||
|
||||
wxIntCtrl(
|
||||
parent, id = -1,
|
||||
value = 0,
|
||||
min = None,
|
||||
max = None,
|
||||
limited = False,
|
||||
allow_none = False,
|
||||
allow_long = False,
|
||||
default_color = wxBLACK,
|
||||
oob_color = wxRED,
|
||||
pos = wxDefaultPosition,
|
||||
size = wxDefaultSize,
|
||||
style = 0,
|
||||
name = "integer")
|
||||
|
||||
value
|
||||
If no initial value is set, the default will be zero, or
|
||||
the minimum value, if specified. If an illegal string is specified,
|
||||
a ValueError will result. (You can always later set the initial
|
||||
value with SetValue() after instantiation of the control.)
|
||||
min
|
||||
The minimum value that the control should allow. This can be
|
||||
adjusted with SetMin(). If the control is not limited, any value
|
||||
below this bound will be colored with the current out-of-bounds color.
|
||||
If min < -sys.maxint-1 and the control is configured to not allow long
|
||||
values, the minimum bound will still be set to the long value, but
|
||||
the implicit bound will be -sys.maxint-1.
|
||||
max
|
||||
The maximum value that the control should allow. This can be
|
||||
adjusted with SetMax(). If the control is not limited, any value
|
||||
above this bound will be colored with the current out-of-bounds color.
|
||||
if max > sys.maxint and the control is configured to not allow long
|
||||
values, the maximum bound will still be set to the long value, but
|
||||
the implicit bound will be sys.maxint.
|
||||
|
||||
limited
|
||||
Boolean indicating whether the control prevents values from
|
||||
exceeding the currently set minimum and maximum values (bounds).
|
||||
If false and bounds are set, out-of-bounds values will
|
||||
be colored with the current out-of-bounds color.
|
||||
|
||||
allow_none
|
||||
Boolean indicating whether or not the control is allowed to be
|
||||
empty, representing a value of None for the control.
|
||||
|
||||
allow_long
|
||||
Boolean indicating whether or not the control is allowed to hold
|
||||
and return a long as well as an int.
|
||||
|
||||
default_color
|
||||
Color value used for in-bounds values of the control.
|
||||
|
||||
oob_color
|
||||
Color value used for out-of-bounds values of the control
|
||||
when the bounds are set but the control is not limited.
|
||||
"""
|
||||
def __init__ (
|
||||
self, parent, id=-1,
|
||||
value = 0, min=None, max=None,
|
||||
limited = 0, allow_none = 0, allow_long = 0,
|
||||
default_color = wxBLACK, oob_color = wxRED,
|
||||
pos = wxDefaultPosition, size = wxDefaultSize,
|
||||
style = 0, name = "integer",
|
||||
):
|
||||
|
||||
# Establish attrs required for any operation on value:
|
||||
self.__min = None
|
||||
self.__max = None
|
||||
self.__limited = 0
|
||||
self.__default_color = wxBLACK
|
||||
self.__oob_color = wxRED
|
||||
self.__allow_none = 0
|
||||
self.__allow_long = 0
|
||||
|
||||
wxTextCtrl.__init__(
|
||||
self, parent, id, self._toGUI(0),
|
||||
pos, size, style, wxIntValidator(), name )
|
||||
|
||||
# The following lets us set out our "integer update" events:
|
||||
EVT_TEXT( self, self.GetId(), self.OnText )
|
||||
|
||||
# Establish parameters, with appropriate error checking
|
||||
|
||||
self.SetBounds(min, max)
|
||||
self.SetLimited(limited)
|
||||
self.SetColors(default_color, oob_color)
|
||||
self.SetNoneAllowed(allow_none)
|
||||
self.SetLongAllowed(allow_long)
|
||||
self.SetValue(value)
|
||||
|
||||
|
||||
def OnText( self, event ):
|
||||
"""
|
||||
Handles an event indicating that the text control's value
|
||||
has changed, and issue EVT_INT event.
|
||||
"""
|
||||
try:
|
||||
self.GetEventHandler().ProcessEvent(
|
||||
wxIntUpdatedEvent( self.GetId(), self.GetValue(), self ) )
|
||||
except ValueError:
|
||||
return
|
||||
# let normal processing of the text continue
|
||||
event.Skip()
|
||||
|
||||
|
||||
def GetValue(self):
|
||||
"""
|
||||
Returns the current integer (long) value of the control.
|
||||
"""
|
||||
return self._fromGUI( wxTextCtrl.GetValue(self) )
|
||||
|
||||
def SetValue(self, value):
|
||||
"""
|
||||
Sets the value of the control to the integer value specified.
|
||||
The resulting actual value of the control may be altered to
|
||||
conform with the bounds set on the control if limited,
|
||||
or colored if not limited but the value is out-of-bounds.
|
||||
A ValueError exception will be raised if an invalid value
|
||||
is specified.
|
||||
"""
|
||||
wxTextCtrl.SetValue( self, self._toGUI(value) )
|
||||
self._colorValue()
|
||||
|
||||
|
||||
def SetMin(self, min=None):
|
||||
"""
|
||||
Sets the minimum value of the control. If a value of None
|
||||
is provided, then the control will have no explicit minimum value.
|
||||
If the value specified is greater than the current maximum value,
|
||||
then the function returns 0 and the minimum will not change from
|
||||
its current setting. On success, the function returns 1.
|
||||
|
||||
If successful and the current value is lower than the new lower
|
||||
bound, if the control is limited, the value will be automatically
|
||||
adjusted to the new minimum value; if not limited, the value in the
|
||||
control will be colored with the current out-of-bounds color.
|
||||
|
||||
If min > -sys.maxint-1 and the control is configured to not allow longs,
|
||||
the function will return 0, and the min will not be set.
|
||||
"""
|
||||
if( self.__max is None
|
||||
or min is None
|
||||
or (self.__max is not None and self.__max >= min) ):
|
||||
self.__min = min
|
||||
|
||||
if self.IsLimited() and min is not None and self.GetValue() < min:
|
||||
self.SetValue(min)
|
||||
else:
|
||||
self._colorValue()
|
||||
return 1
|
||||
else:
|
||||
return 0
|
||||
|
||||
|
||||
def GetMin(self):
|
||||
"""
|
||||
Gets the minimum value of the control. It will return the current
|
||||
minimum integer, or None if not specified.
|
||||
"""
|
||||
return self.__min
|
||||
|
||||
|
||||
def SetMax(self, max=None):
|
||||
"""
|
||||
Sets the maximum value of the control. If a value of None
|
||||
is provided, then the control will have no explicit maximum value.
|
||||
If the value specified is less than the current minimum value, then
|
||||
the function returns 0 and the maximum will not change from its
|
||||
current setting. On success, the function returns 1.
|
||||
|
||||
If successful and the current value is greater than the new upper
|
||||
bound, if the control is limited the value will be automatically
|
||||
adjusted to this maximum value; if not limited, the value in the
|
||||
control will be colored with the current out-of-bounds color.
|
||||
|
||||
If max > sys.maxint and the control is configured to not allow longs,
|
||||
the function will return 0, and the max will not be set.
|
||||
"""
|
||||
if( self.__min is None
|
||||
or max is None
|
||||
or (self.__min is not None and self.__min <= max) ):
|
||||
self.__max = max
|
||||
|
||||
if self.IsLimited() and max is not None and self.GetValue() > max:
|
||||
self.SetValue(max)
|
||||
else:
|
||||
self._colorValue()
|
||||
return 1
|
||||
else:
|
||||
return 0
|
||||
|
||||
|
||||
def GetMax(self):
|
||||
"""
|
||||
Gets the maximum value of the control. It will return the current
|
||||
maximum integer, or None if not specified.
|
||||
"""
|
||||
return self.__max
|
||||
|
||||
|
||||
def SetBounds(self, min=None, max=None):
|
||||
"""
|
||||
This function is a convenience function for setting the min and max
|
||||
values at the same time. The function only applies the maximum bound
|
||||
if setting the minimum bound is successful, and returns true
|
||||
only if both operations succeed.
|
||||
NOTE: leaving out an argument will remove the corresponding bound.
|
||||
"""
|
||||
ret = self.SetMin(min)
|
||||
return ret and self.SetMax(max)
|
||||
|
||||
|
||||
def GetBounds(self):
|
||||
"""
|
||||
This function returns a two-tuple (min,max), indicating the
|
||||
current bounds of the control. Each value can be None if
|
||||
that bound is not set.
|
||||
"""
|
||||
return (self.__min, self.__max)
|
||||
|
||||
|
||||
def SetLimited(self, limited):
|
||||
"""
|
||||
If called with a value of true, this function will cause the control
|
||||
to limit the value to fall within the bounds currently specified.
|
||||
If the control's value currently exceeds the bounds, it will then
|
||||
be limited accordingly.
|
||||
|
||||
If called with a value of 0, this function will disable value
|
||||
limiting, but coloring of out-of-bounds values will still take
|
||||
place if bounds have been set for the control.
|
||||
"""
|
||||
self.__limited = limited
|
||||
if limited:
|
||||
min = self.GetMin()
|
||||
max = self.GetMax()
|
||||
if not min is None and self.GetValue() < min:
|
||||
self.SetValue(min)
|
||||
elif not max is None and self.GetValue() > max:
|
||||
self.SetValue(max)
|
||||
else:
|
||||
self._colorValue()
|
||||
|
||||
|
||||
def IsLimited(self):
|
||||
"""
|
||||
Returns true if the control is currently limiting the
|
||||
value to fall within the current bounds.
|
||||
"""
|
||||
return self.__limited
|
||||
|
||||
|
||||
def IsInBounds(self, value=None):
|
||||
"""
|
||||
Returns true if no value is specified and the current value
|
||||
of the control falls within the current bounds. This function can
|
||||
also be called with a value to see if that value would fall within
|
||||
the current bounds of the given control.
|
||||
"""
|
||||
if value is None:
|
||||
value = self.GetValue()
|
||||
|
||||
if( not (value is None and self.IsNoneAllowed())
|
||||
and type(value) not in (types.IntType, types.LongType) ):
|
||||
raise ValueError (
|
||||
'wxIntCtrl requires integer values, passed %s'% repr(value) )
|
||||
|
||||
min = self.GetMin()
|
||||
max = self.GetMax()
|
||||
if min is None: min = value
|
||||
if max is None: max = value
|
||||
|
||||
# if bounds set, and value is None, return false
|
||||
if value == None and (min is not None or max is not None):
|
||||
return 0
|
||||
else:
|
||||
return min <= value <= max
|
||||
|
||||
|
||||
def SetNoneAllowed(self, allow_none):
|
||||
"""
|
||||
Change the behavior of the validation code, allowing control
|
||||
to have a value of None or not, as appropriate. If the value
|
||||
of the control is currently None, and allow_none is 0, the
|
||||
value of the control will be set to the minimum value of the
|
||||
control, or 0 if no lower bound is set.
|
||||
"""
|
||||
self.__allow_none = allow_none
|
||||
if not allow_none and self.GetValue() is None:
|
||||
min = self.GetMin()
|
||||
if min is not None: self.SetValue(min)
|
||||
else: self.SetValue(0)
|
||||
|
||||
|
||||
def IsNoneAllowed(self):
|
||||
return self.__allow_none
|
||||
|
||||
|
||||
def SetLongAllowed(self, allow_long):
|
||||
"""
|
||||
Change the behavior of the validation code, allowing control
|
||||
to have a long value or not, as appropriate. If the value
|
||||
of the control is currently long, and allow_long is 0, the
|
||||
value of the control will be adjusted to fall within the
|
||||
size of an integer type, at either the sys.maxint or -sys.maxint-1,
|
||||
for positive and negative values, respectively.
|
||||
"""
|
||||
current_value = self.GetValue()
|
||||
if not allow_long and type(current_value) is types.LongType:
|
||||
if current_value > 0:
|
||||
self.SetValue(MAXINT)
|
||||
else:
|
||||
self.SetValue(MININT)
|
||||
self.__allow_long = allow_long
|
||||
|
||||
|
||||
def IsLongAllowed(self):
|
||||
return self.__allow_long
|
||||
|
||||
|
||||
|
||||
def SetColors(self, default_color=wxBLACK, oob_color=wxRED):
|
||||
"""
|
||||
Tells the control what colors to use for normal and out-of-bounds
|
||||
values. If the value currently exceeds the bounds, it will be
|
||||
recolored accordingly.
|
||||
"""
|
||||
self.__default_color = default_color
|
||||
self.__oob_color = oob_color
|
||||
self._colorValue()
|
||||
|
||||
|
||||
def GetColors(self):
|
||||
"""
|
||||
Returns a tuple of (default_color, oob_color), indicating
|
||||
the current color settings for the control.
|
||||
"""
|
||||
return self.__default_color, self.__oob_color
|
||||
|
||||
|
||||
def _colorValue(self, value=None):
|
||||
"""
|
||||
Colors text with oob_color if current value exceeds bounds
|
||||
set for control.
|
||||
"""
|
||||
if not self.IsInBounds(value):
|
||||
self.SetForegroundColour(self.__oob_color)
|
||||
else:
|
||||
self.SetForegroundColour(self.__default_color)
|
||||
self.Refresh()
|
||||
|
||||
|
||||
def _toGUI( self, value ):
|
||||
"""
|
||||
Conversion function used to set the value of the control; does
|
||||
type and bounds checking and raises ValueError if argument is
|
||||
not a valid value.
|
||||
"""
|
||||
if value is None and self.IsNoneAllowed():
|
||||
return ''
|
||||
elif type(value) == types.LongType and not self.IsLongAllowed():
|
||||
raise ValueError (
|
||||
'wxIntCtrl requires integer value, passed long' )
|
||||
elif type(value) not in (types.IntType, types.LongType):
|
||||
raise ValueError (
|
||||
'wxIntCtrl requires integer value, passed %s'% repr(value) )
|
||||
|
||||
elif self.IsLimited():
|
||||
min = self.GetMin()
|
||||
max = self.GetMax()
|
||||
if not min is None and value < min:
|
||||
raise ValueError (
|
||||
'value is below minimum value of control %d'% value )
|
||||
if not max is None and value > max:
|
||||
raise ValueError (
|
||||
'value exceeds value of control %d'% value )
|
||||
|
||||
return str(value)
|
||||
|
||||
|
||||
def _fromGUI( self, value ):
|
||||
"""
|
||||
Conversion function used in getting the value of the control.
|
||||
"""
|
||||
if value == '':
|
||||
return None
|
||||
else:
|
||||
try:
|
||||
return int( value )
|
||||
except ValueError:
|
||||
if self.IsLongAllowed():
|
||||
return long( value )
|
||||
else:
|
||||
raise
|
||||
|
||||
|
||||
def Cut( self ):
|
||||
"""
|
||||
Override the wxTextCtrl's .Cut function, with our own
|
||||
that does validation. Will result in a value of 0
|
||||
if entire contents of control are removed.
|
||||
"""
|
||||
sel_start, sel_to = self.GetSelection()
|
||||
select_len = sel_to - sel_start
|
||||
textval = wxTextCtrl.GetValue(self)
|
||||
|
||||
do = wxTextDataObject()
|
||||
do.SetText(textval[sel_start:sel_to])
|
||||
wxTheClipboard.Open()
|
||||
wxTheClipboard.SetData(do)
|
||||
wxTheClipboard.Close()
|
||||
if select_len == len(wxTextCtrl.GetValue(self)):
|
||||
if not self.IsNoneAllowed():
|
||||
self.SetValue(0)
|
||||
self.SetSelection(0,1)
|
||||
else:
|
||||
self.SetValue(None)
|
||||
else:
|
||||
new_value = self._fromGUI(textval[:sel_start] + textval[sel_to:])
|
||||
self.SetValue(new_value)
|
||||
|
||||
|
||||
def _getClipboardContents( self ):
|
||||
"""
|
||||
Subroutine for getting the current contents of the clipboard.
|
||||
"""
|
||||
do = wxTextDataObject()
|
||||
wxTheClipboard.Open()
|
||||
success = wxTheClipboard.GetData(do)
|
||||
wxTheClipboard.Close()
|
||||
|
||||
if not success:
|
||||
return None
|
||||
else:
|
||||
# Remove leading and trailing spaces before evaluating contents
|
||||
return do.GetText().strip()
|
||||
|
||||
|
||||
def Paste( self ):
|
||||
"""
|
||||
Override the wxTextCtrl's .Paste function, with our own
|
||||
that does validation. Will raise ValueError if not a
|
||||
valid integerizable value.
|
||||
"""
|
||||
paste_text = self._getClipboardContents()
|
||||
if paste_text:
|
||||
# (conversion will raise ValueError if paste isn't legal)
|
||||
sel_start, sel_to = self.GetSelection()
|
||||
text = wxTextCtrl.GetValue( self )
|
||||
new_text = text[:sel_start] + paste_text + text[sel_to:]
|
||||
if new_text == '' and self.IsNoneAllowed():
|
||||
self.SetValue(None)
|
||||
else:
|
||||
value = self._fromGUI(new_text)
|
||||
self.SetValue(value)
|
||||
new_pos = sel_start + len(paste_text)
|
||||
wxCallAfter(self.SetInsertionPoint, new_pos)
|
||||
|
||||
|
||||
|
||||
#===========================================================================
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
import traceback
|
||||
|
||||
class myDialog(wxDialog):
|
||||
def __init__(self, parent, id, title,
|
||||
pos = wxPyDefaultPosition, size = wxPyDefaultSize,
|
||||
style = wxDEFAULT_DIALOG_STYLE ):
|
||||
wxDialog.__init__(self, parent, id, title, pos, size, style)
|
||||
|
||||
self.int_ctrl = wxIntCtrl(self, NewId(), size=(55,20))
|
||||
self.OK = wxButton( self, wxID_OK, "OK")
|
||||
self.Cancel = wxButton( self, wxID_CANCEL, "Cancel")
|
||||
|
||||
vs = wxBoxSizer( wxVERTICAL )
|
||||
vs.AddWindow( self.int_ctrl, 0, wxALIGN_CENTRE|wxALL, 5 )
|
||||
hs = wxBoxSizer( wxHORIZONTAL )
|
||||
hs.AddWindow( self.OK, 0, wxALIGN_CENTRE|wxALL, 5 )
|
||||
hs.AddWindow( self.Cancel, 0, wxALIGN_CENTRE|wxALL, 5 )
|
||||
vs.AddSizer(hs, 0, wxALIGN_CENTRE|wxALL, 5 )
|
||||
|
||||
self.SetAutoLayout( true )
|
||||
self.SetSizer( vs )
|
||||
vs.Fit( self )
|
||||
vs.SetSizeHints( self )
|
||||
EVT_INT(self, self.int_ctrl.GetId(), self.OnInt)
|
||||
|
||||
def OnInt(self, event):
|
||||
print 'int now', event.GetValue()
|
||||
|
||||
class TestApp(wxApp):
|
||||
def OnInit(self):
|
||||
try:
|
||||
self.frame = wxFrame(NULL, -1, "Test",
|
||||
wxPoint(20,20), wxSize(120,100) )
|
||||
self.panel = wxPanel(self.frame, -1)
|
||||
button = wxButton(self.panel, 10, "Push Me",
|
||||
wxPoint(20, 20))
|
||||
EVT_BUTTON(self, 10, self.OnClick)
|
||||
except:
|
||||
traceback.print_exc()
|
||||
return false
|
||||
return true
|
||||
|
||||
def OnClick(self, event):
|
||||
dlg = myDialog(self.panel, -1, "test wxIntCtrl")
|
||||
dlg.int_ctrl.SetValue(501)
|
||||
dlg.int_ctrl.SetSelection(1,2)
|
||||
rc = dlg.ShowModal()
|
||||
print 'final value', dlg.int_ctrl.GetValue()
|
||||
del dlg
|
||||
self.frame.Destroy()
|
||||
|
||||
def Show(self):
|
||||
self.frame.Show(true)
|
||||
|
||||
try:
|
||||
app = TestApp(0)
|
||||
app.Show()
|
||||
app.MainLoop()
|
||||
except:
|
||||
traceback.print_exc()
|
||||
Reference in New Issue
Block a user