+import wx
+
+#----------------------------------------------------------------------------
+
+from sys import maxint
+MAXINT = maxint # (constants should be in upper case)
+MININT = -maxint-1
+
+#----------------------------------------------------------------------------
+
+# Used to trap events indicating that the current
+# integer value of the control has been changed.
+wxEVT_COMMAND_INT_UPDATED = wx.NewEventType()
+EVT_INT = wx.PyEventBinder(wxEVT_COMMAND_INT_UPDATED, 1)
+
+#----------------------------------------------------------------------------
+
+# 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')
+
+class IntUpdatedEvent(wx.PyCommandEvent):
+ def __init__(self, id, value = 0, object=None):
+ wx.PyCommandEvent.__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 IntValidator( wx.PyValidator ):
+ """
+ Validator class used with IntCtrl; handles all validation of input
+ prior to changing the value of the underlying wx.TextCtrl.
+ """
+ def __init__(self):
+ wx.PyValidator.__init__(self)
+ self.Bind(wx.EVT_CHAR, 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 = wx.TextCtrl.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 (wx.WXK_DELETE, wx.WXK_BACK, WXK_CTRL_X):
+ if select_len:
+ new_text = textval[:sel_start] + textval[sel_to:]
+ elif key == wx.WXK_DELETE and pos < len(textval):
+ new_text = textval[:pos] + textval[pos+1:]
+ elif key == wx.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 < wx.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 == wx.WXK_BACK
+ or (paste and paste_value == 0 and new_pos > 0) ):
+ new_pos = new_pos - 1
+
+ wx.CallAfter(ctrl.SetValue, new_value)
+ wx.CallAfter(ctrl.SetInsertionPoint, new_pos)
+ internally_set = 1
+
+ elif paste:
+ # Always do paste numerically, to remove
+ # leading/trailing spaces
+ wx.CallAfter(ctrl.SetValue, new_value)
+ wx.CallAfter(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:
+ wx.CallAfter(ctrl.SetValue, new_value)
+
+ elif set_to_zero:
+ # select to "empty" numeric value
+ wx.CallAfter(ctrl.SetValue, new_value)
+ wx.CallAfter(ctrl.SetInsertionPoint, 0)
+ wx.CallAfter(ctrl.SetSelection, 0, 1)
+
+ elif set_to_minus_one:
+ wx.CallAfter(ctrl.SetValue, new_value)
+ wx.CallAfter(ctrl.SetInsertionPoint, 1)
+ wx.CallAfter(ctrl.SetSelection, 1, 2)
+
+ elif not internally_set:
+ event.Skip() # allow base wxTextCtrl to finish processing
+
+ elif not wx.Validator_IsSilent():
+ wx.Bell()
+
+
+ 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 wx.Dialog 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 wx.Dialog from complaining.
+
+
+#----------------------------------------------------------------------------
+
+class IntCtrl(wx.TextCtrl):
+ """
+ This class provides a control that takes and returns integers as
+ value, and provides bounds support and optional value limiting.
+
+ IntCtrl(
+ parent, id = -1,
+ value = 0,
+ pos = wxDefaultPosition,
+ size = wxDefaultSize,
+ style = 0,
+ validator = wxDefaultValidator,
+ name = "integer",
+ min = None,
+ max = None,
+ limited = False,
+ allow_none = False,
+ allow_long = False,
+ default_color = wxBLACK,
+ oob_color = wxRED )
+
+ 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.
+
+ validator
+ Normally None, IntCtrl uses its own validator to do value
+ validation and input control. However, a validator derived
+ from IntValidator can be supplied to override the data
+ transfer methods for the IntValidator class.
+ """
+
+ def __init__ (
+ self, parent, id=-1, value = 0,
+ pos = wx.DefaultPosition, size = wx.DefaultSize,
+ style = 0, validator = wx.DefaultValidator,
+ name = "integer",
+ min=None, max=None,
+ limited = 0, allow_none = 0, allow_long = 0,
+ default_color = wx.BLACK, oob_color = wx.RED,
+ ):
+
+ # Establish attrs required for any operation on value:
+ self.__min = None
+ self.__max = None
+ self.__limited = 0
+ self.__default_color = wx.BLACK
+ self.__oob_color = wx.RED
+ self.__allow_none = 0
+ self.__allow_long = 0
+ self.__oldvalue = None
+
+ if validator == wx.DefaultValidator:
+ validator = IntValidator()
+
+ wx.TextCtrl.__init__(
+ self, parent, id, self._toGUI(0),
+ pos, size, style, validator, name )
+
+ # The following lets us set out our "integer update" events:
+ self.Bind(wx.EVT_TEXT, 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)
+ self.__oldvalue = 0
+
+
+ def OnText( self, event ):
+ """
+ Handles an event indicating that the text control's value
+ has changed, and issue EVT_INT event.
+ NOTE: using wx.TextCtrl.SetValue() to change the control's
+ contents from within a wx.EVT_CHAR handler can cause double
+ text events. So we check for actual changes to the text
+ before passing the events on.
+ """
+ value = self.GetValue()
+ if value != self.__oldvalue:
+ try:
+ self.GetEventHandler().ProcessEvent(
+ IntUpdatedEvent( self.GetId(), self.GetValue(), self ) )
+ except ValueError:
+ return
+ # let normal processing of the text continue
+ event.Skip()
+ self.__oldvalue = value # record for next event
+
+
+ def GetValue(self):
+ """
+ Returns the current integer (long) value of the control.
+ """
+ return self._fromGUI( wx.TextCtrl.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.
+ """
+ wx.TextCtrl.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 (
+ 'IntCtrl 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=wx.BLACK, oob_color=wx.RED):
+ """
+ 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 (
+ 'IntCtrl requires integer value, passed long' )
+ elif type(value) not in (types.IntType, types.LongType):
+ raise ValueError (
+ 'IntCtrl 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.
+ """
+
+ # One or more of the underlying text control implementations
+ # issue an intermediate EVT_TEXT when replacing the control's
+ # value, where the intermediate value is an empty string.
+ # So, to ensure consistency and to prevent spurious ValueErrors,
+ # we make the following test, and react accordingly:
+ #
+ if value == '':
+ if not self.IsNoneAllowed():
+ return 0
+ else:
+ 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 = wx.TextCtrl.GetValue(self)
+
+ do = wx.TextDataObject()
+ do.SetText(textval[sel_start:sel_to])
+ wx.TheClipboard.Open()
+ wx.TheClipboard.SetData(do)
+ wx.TheClipboard.Close()
+ if select_len == len(wxTextCtrl.GetValue(self)):
+ if not self.IsNoneAllowed():
+ self.SetValue(0)
+ self.SetInsertionPoint(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 = wx.TextDataObject()
+ wx.TheClipboard.Open()
+ success = wx.TheClipboard.GetData(do)
+ wx.TheClipboard.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 = wx.TextCtrl.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)
+ wx.CallAfter(self.SetInsertionPoint, new_pos)
+
+
+
+#===========================================================================
+
+if __name__ == '__main__':
+
+ import traceback
+
+ class myDialog(wx.Dialog):
+ def __init__(self, parent, id, title,
+ pos = wx.DefaultPosition, size = wx.DefaultSize,
+ style = wx.DEFAULT_DIALOG_STYLE ):
+ wx.Dialog.__init__(self, parent, id, title, pos, size, style)
+
+ self.int_ctrl = IntCtrl(self, wx.NewId(), size=(55,20))
+ self.OK = wx.Button( self, wx.ID_OK, "OK")
+ self.Cancel = wx.Button( self, wx.ID_CANCEL, "Cancel")
+
+ vs = wx.BoxSizer( wx.VERTICAL )
+ vs.Add( self.int_ctrl, 0, wx.ALIGN_CENTRE|wx.ALL, 5 )
+ hs = wx.BoxSizer( wx.HORIZONTAL )
+ hs.Add( self.OK, 0, wx.ALIGN_CENTRE|wx.ALL, 5 )
+ hs.Add( self.Cancel, 0, wx.ALIGN_CENTRE|wx.ALL, 5 )
+ vs.Add(hs, 0, wx.ALIGN_CENTRE|wx.ALL, 5 )
+
+ self.SetAutoLayout( True )
+ self.SetSizer( vs )
+ vs.Fit( self )
+ vs.SetSizeHints( self )
+ self.Bind(EVT_INT, self.OnInt, self.int_ctrl)
+
+ def OnInt(self, event):
+ print 'int now', event.GetValue()
+
+ class TestApp(wx.App):
+ def OnInit(self):
+ try:
+ self.frame = wx.Frame(None, -1, "Test", (20,20), (120,100) )
+ self.panel = wx.Panel(self.frame, -1)
+ button = wx.Button(self.panel, 10, "Push Me", (20, 20))
+ self.Bind(wx.EVT_BUTTON, self.OnClick, button)
+ except:
+ traceback.print_exc()
+ return False
+ return True
+
+ def OnClick(self, event):
+ dlg = myDialog(self.panel, -1, "test IntCtrl")
+ dlg.int_ctrl.SetValue(501)
+ dlg.int_ctrl.SetInsertionPoint(1)
+ 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()
projects / wxWidgets.git / blobdiff