64dfb023eb
true/false or TRUE/FALSE to prepare for the new boolean type and constants being added to Python. Added code to wx.py to test for the existence of the new constants and to create suitable values if not present. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/branches/WX_2_4_BRANCH@19335 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
338 lines
13 KiB
Python
338 lines
13 KiB
Python
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, -1 ) )
|
|
self.min.Enable( False )
|
|
|
|
self.set_max = wxCheckBox( panel, -1, "Set maximum value:" )
|
|
self.max = wxIntCtrl( panel, size=wxSize( 50, -1 ) )
|
|
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])])
|