wxPython/wx/lib/masked/numctrl.py

   1 #----------------------------------------------------------------------------
   2 # Name:         wxPython.lib.masked.numctrl.py
   3 # Author:       Will Sadkin
   4 # Created:      09/06/2003
   5 # Copyright:   (c) 2003-2007 by Will Sadkin
   6 # RCS-ID:      $Id$
   7 # License:     wxWidgets license
   8 #----------------------------------------------------------------------------
   9 # NOTE:
  10 #   This was written to provide a numeric edit control for wxPython that
  11 #   does things like right-insert (like a calculator), and does grouping, etc.
  12 #   (ie. the features of masked.TextCtrl), but allows Get/Set of numeric
  13 #   values, rather than text.
  14 #
  15 #   Masked.NumCtrl permits integer, and floating point values to be set
  16 #   retrieved or set via .GetValue() and .SetValue() (type chosen based on
  17 #   fraction width, and provides an masked.EVT_NUM() event function for trapping
  18 #   changes to the control.
  19 #
  20 #   It supports negative numbers as well as the naturals, and has the option
  21 #   of not permitting leading zeros or an empty control; if an empty value is
  22 #   not allowed, attempting to delete the contents of the control will result
  23 #   in a (selected) value of zero, thus preserving a legitimate numeric value.
  24 #   Similarly, replacing the contents of the control with '-' will result in
  25 #   a selected (absolute) value of -1.
  26 #
  27 #   masked.NumCtrl also supports range limits, with the option of either
  28 #   enforcing them or simply coloring the text of the control if the limits
  29 #   are exceeded.
  30 #
  31 #   masked.NumCtrl is intended to support fixed-point numeric entry, and
  32 #   is derived from BaseMaskedTextCtrl.  As such, it supports a limited range
  33 #   of values to comply with a fixed-width entry mask.
  34 #----------------------------------------------------------------------------
  35 # 12/09/2003 - Jeff Grimmett (grimmtooth@softhome.net)
  36 #
  37 # o Updated for wx namespace
  38 #
  39 # 12/20/2003 - Jeff Grimmett (grimmtooth@softhome.net)
  40 #
  41 # o wxMaskedEditMixin -> MaskedEditMixin
  42 # o wxMaskedTextCtrl -> masked.TextCtrl
  43 # o wxMaskedNumNumberUpdatedEvent -> masked.NumberUpdatedEvent
  44 # o wxMaskedNumCtrl -> masked.NumCtrl
  45 #
  46
  47 """
  48 masked.NumCtrl:
  49   - allows you to get and set integer or floating point numbers as value,</LI>
  50   - provides bounds support and optional value limiting,</LI>
  51   - has the right-insert input style that MaskedTextCtrl supports,</LI>
  52   - provides optional automatic grouping, sign control and format, grouping and decimal
  53     character selection, etc. etc.</LI>
  54
  55
  56   Being derived from masked.TextCtrl, the control only allows
  57   fixed-point  notation.  That is, it has a fixed (though reconfigurable)
  58   maximum width for the integer portion and optional fixed width
  59   fractional portion.
  60
  61   Here's the API::
  62
  63         from wx.lib.masked import NumCtrl
  64
  65         NumCtrl(
  66              parent, id = -1,
  67              value = 0,
  68              pos = wx.DefaultPosition,
  69              size = wx.DefaultSize,
  70              style = 0,
  71              validator = wx.DefaultValidator,
  72              name = "masked.number",
  73              integerWidth = 10,
  74              fractionWidth = 0,
  75              allowNone = False,
  76              allowNegative = True,
  77              useParensForNegatives = False,
  78              groupDigits = False,
  79              groupChar = ',',
  80              decimalChar = '.',
  81              min = None,
  82              max = None,
  83              limited = False,
  84              limitOnFieldChange = False,
  85              selectOnEntry = True,
  86              foregroundColour = "Black",
  87              signedForegroundColour = "Red",
  88              emptyBackgroundColour = "White",
  89              validBackgroundColour = "White",
  90              invalidBackgroundColour = "Yellow",
  91              autoSize = True
  92              )
  93
  94
  95   value
  96         If no initial value is set, the default will be zero, or
  97         the minimum value, if specified.  If an illegal string is specified,
  98         a ValueError will result. (You can always later set the initial
  99         value with SetValue() after instantiation of the control.)
 100
 101   integerWidth
 102         Indicates how many places to the right of any decimal point
 103         should be allowed in the control.  This will, perforce, limit
 104         the size of the values that can be entered. This number need
 105         not include space for grouping characters or the sign, if either
 106         of these options are enabled, as the resulting underlying
 107         mask is automatically by the control.  The default of 10
 108         will allow any 32 bit integer value.  The minimum value
 109         for integerWidth is 1.
 110
 111   fractionWidth
 112         Indicates how many decimal places to show for numeric value.
 113         If default (0), then the control will display and return only
 114         integer or long values.
 115
 116   allowNone
 117         Boolean indicating whether or not the control is allowed to be
 118         empty, representing a value of None for the control.
 119
 120   allowNegative
 121         Boolean indicating whether or not control is allowed to hold
 122         negative numbers.
 123
 124   useParensForNegatives
 125         If true, this will cause negative numbers to be displayed with ()s
 126         rather than -, (although '-' will still trigger a negative number.)
 127
 128   groupDigits
 129         Indicates whether or not grouping characters should be allowed and/or
 130         inserted when leaving the control or the decimal character is entered.
 131
 132   groupChar
 133         What grouping character will be used if allowed. (By default ',')
 134
 135   decimalChar
 136         If fractionWidth is > 0, what character will be used to represent
 137         the decimal point.  (By default '.')
 138
 139   min
 140         The minimum value that the control should allow.  This can be also be
 141         adjusted with SetMin().  If the control is not limited, any value
 142         below this bound will result in a background colored with the current
 143         invalidBackgroundColour.  If the min specified will not fit into the
 144         control, the min setting will be ignored.
 145
 146   max
 147         The maximum value that the control should allow.  This can be
 148         adjusted with SetMax().  If the control is not limited, any value
 149         above this bound will result in a background colored with the current
 150         invalidBackgroundColour.  If the max specified will not fit into the
 151         control, the max setting will be ignored.
 152
 153   limited
 154         Boolean indicating whether the control prevents values from
 155         exceeding the currently set minimum and maximum values (bounds).
 156         If False and bounds are set, out-of-bounds values will
 157         result in a background colored with the current invalidBackgroundColour.
 158
 159   limitOnFieldChange
 160         An alternative to limited, this boolean indicates whether or not a
 161         field change should be allowed if the value in the control
 162         is out of bounds.  If True, and control focus is lost, this will also
 163         cause the control to take on the nearest bound value.
 164
 165   selectOnEntry
 166         Boolean indicating whether or not the value in each field of the
 167         control should be automatically selected (for replacement) when
 168         that field is entered, either by cursor movement or tabbing.
 169         This can be desirable when using these controls for rapid data entry.
 170
 171   foregroundColour
 172         Color value used for positive values of the control.
 173
 174   signedForegroundColour
 175         Color value used for negative values of the control.
 176
 177   emptyBackgroundColour
 178         What background color to use when the control is considered
 179         "empty." (allow_none must be set to trigger this behavior.)
 180
 181   validBackgroundColour
 182         What background color to use when the control value is
 183         considered valid.
 184
 185   invalidBackgroundColour
 186         Color value used for illegal values or values out-of-bounds of the
 187         control when the bounds are set but the control is not limited.
 188
 189   autoSize
 190         Boolean indicating whether or not the control should set its own
 191         width based on the integer and fraction widths.  True by default.
 192         <I>Note:</I> Setting this to False will produce seemingly odd
 193         behavior unless the control is large enough to hold the maximum
 194         specified value given the widths and the sign positions; if not,
 195         the control will appear to "jump around" as the contents scroll.
 196         (ie. autoSize is highly recommended.)
 197
 198 --------------------------
 199
 200 masked.EVT_NUM(win, id, func)
 201     Respond to a EVT_COMMAND_MASKED_NUMBER_UPDATED event, generated when
 202     the value changes. Notice that this event will always be sent when the
 203     control's contents changes - whether this is due to user input or
 204     comes from the program itself (for example, if SetValue() is called.)
 205
 206
 207 SetValue(int|long|float|string)
 208     Sets the value of the control to the value specified, if
 209     possible.  The resulting actual value of the control may be
 210     altered to conform to the format of the control, changed
 211     to conform with the bounds set on the control if limited,
 212     or colored if not limited but the value is out-of-bounds.
 213     A ValueError exception will be raised if an invalid value
 214     is specified.
 215
 216 GetValue()
 217     Retrieves the numeric value from the control.  The value
 218     retrieved will be either be returned as a long if the
 219     fractionWidth is 0, or a float otherwise.
 220
 221
 222 SetParameters(\*\*kwargs)
 223     Allows simultaneous setting of various attributes
 224     of the control after construction.  Keyword arguments
 225     allowed are the same parameters as supported in the constructor.
 226
 227
 228 SetIntegerWidth(value)
 229     Resets the width of the integer portion of the control.  The
 230     value must be >= 1, or an AttributeError exception will result.
 231     This value should account for any grouping characters that might
 232     be inserted (if grouping is enabled), but does not need to account
 233     for the sign, as that is handled separately by the control.
 234 GetIntegerWidth()
 235     Returns the current width of the integer portion of the control,
 236     not including any reserved sign position.
 237
 238
 239 SetFractionWidth(value)
 240     Resets the width of the fractional portion of the control.  The
 241     value must be >= 0, or an AttributeError exception will result.  If
 242     0, the current value of the control will be truncated to an integer
 243     value.
 244 GetFractionWidth()
 245     Returns the current width of the fractional portion of the control.
 246
 247
 248 SetMin(min=None)
 249     Resets the minimum value of the control.  If a value of <I>None</I>
 250     is provided, then the control will have no explicit minimum value.
 251     If the value specified is greater than the current maximum value,
 252     then the function returns False and the minimum will not change from
 253     its current setting.  On success, the function returns True.
 254
 255     If successful and the current value is lower than the new lower
 256     bound, if the control is limited, the value will be automatically
 257     adjusted to the new minimum value; if not limited, the value in the
 258     control will be colored as invalid.
 259
 260     If min > the max value allowed by the width of the control,
 261     the function will return False, and the min will not be set.
 262
 263 GetMin()
 264     Gets the current lower bound value for the control.
 265     It will return None if no lower bound is currently specified.
 266
 267
 268 SetMax(max=None)
 269     Resets the maximum value of the control. If a value of <I>None</I>
 270     is provided, then the control will have no explicit maximum value.
 271     If the value specified is less than the current minimum value, then
 272     the function returns False and the maximum will not change from its
 273     current setting. On success, the function returns True.
 274
 275     If successful and the current value is greater than the new upper
 276     bound, if the control is limited the value will be automatically
 277     adjusted to this maximum value; if not limited, the value in the
 278     control will be colored as invalid.
 279
 280     If max > the max value allowed by the width of the control,
 281     the function will return False, and the max will not be set.
 282
 283 GetMax()
 284     Gets the current upper bound value for the control.
 285     It will return None if no upper bound is currently specified.
 286
 287
 288 SetBounds(min=None,max=None)
 289     This function is a convenience function for setting the min and max
 290     values at the same time.  The function only applies the maximum bound
 291     if setting the minimum bound is successful, and returns True
 292     only if both operations succeed.  <B><I>Note:</I> leaving out an argument
 293     will remove the corresponding bound.
 294 GetBounds()
 295     This function returns a two-tuple (min,max), indicating the
 296     current bounds of the control.  Each value can be None if
 297     that bound is not set.
 298
 299
 300 IsInBounds(value=None)
 301     Returns <I>True</I> if no value is specified and the current value
 302     of the control falls within the current bounds.  This function can also
 303     be called with a value to see if that value would fall within the current
 304     bounds of the given control.
 305
 306
 307 SetLimited(bool)
 308     If called with a value of True, this function will cause the control
 309     to limit the value to fall within the bounds currently specified.
 310     If the control's value currently exceeds the bounds, it will then
 311     be limited accordingly.
 312     If called with a value of False, this function will disable value
 313     limiting, but coloring of out-of-bounds values will still take
 314     place if bounds have been set for the control.
 315
 316 GetLimited()
 317
 318 IsLimited()
 319     Returns <I>True</I> if the control is currently limiting the
 320     value to fall within the current bounds.
 321
 322 SetLimitOnFieldChange()
 323     If called with a value of True, will cause the control to allow
 324     out-of-bounds values, but will prevent field change if attempted
 325     via navigation, and if the control loses focus, it will change
 326     the value to the nearest bound.
 327
 328 GetLimitOnFieldChange()
 329
 330 IsLimitedOnFieldChange()
 331     Returns <I>True</I> if the control is currently limiting the
 332     value on field change.
 333
 334
 335 SetAllowNone(bool)
 336     If called with a value of True, this function will cause the control
 337     to allow the value to be empty, representing a value of None.
 338     If called with a value of False, this function will prevent the value
 339     from being None.  If the value of the control is currently None,
 340     ie. the control is empty, then the value will be changed to that
 341     of the lower bound of the control, or 0 if no lower bound is set.
 342
 343 GetAllowNone()
 344
 345 IsNoneAllowed()
 346     Returns <I>True</I> if the control currently allows its
 347     value to be None.
 348
 349
 350 SetAllowNegative(bool)
 351     If called with a value of True, this function will cause the
 352     control to allow the value to be negative (and reserve space for
 353     displaying the sign. If called with a value of False, and the
 354     value of the control is currently negative, the value of the
 355     control will be converted to the absolute value, and then
 356     limited appropriately based on the existing bounds of the control
 357     (if any).
 358
 359 GetAllowNegative()
 360
 361 IsNegativeAllowed()
 362     Returns <I>True</I> if the control currently permits values
 363     to be negative.
 364
 365
 366 SetGroupDigits(bool)
 367     If called with a value of True, this will make the control
 368     automatically add and manage grouping characters to the presented
 369     value in integer portion of the control.
 370
 371 GetGroupDigits()
 372
 373 IsGroupingAllowed()
 374     Returns <I>True</I> if the control is currently set to group digits.
 375
 376
 377 SetGroupChar()
 378     Sets the grouping character for the integer portion of the
 379     control.  (The default grouping character this is ','.
 380 GetGroupChar()
 381     Returns the current grouping character for the control.
 382
 383
 384 SetSelectOnEntry()
 385     If called with a value of <I>True</I>, this will make the control
 386     automatically select the contents of each field as it is entered
 387     within the control.  (The default is True.)
 388     GetSelectOnEntry()
 389     Returns <I>True</I> if the control currently auto selects
 390     the field values on entry.
 391
 392
 393 SetAutoSize(bool)
 394     Resets the autoSize attribute of the control.
 395 GetAutoSize()
 396     Returns the current state of the autoSize attribute for the control.
 397
 398 """
 399
 400 import  copy
 401 import  string
 402 import  types
 403
 404 import  wx
 405
 406 from sys import maxint
 407 MAXINT = maxint     # (constants should be in upper case)
 408 MININT = -maxint-1
 409
 410 from wx.tools.dbg import Logger
 411 from wx.lib.masked import MaskedEditMixin, Field, BaseMaskedTextCtrl
 412 ##dbg = Logger()
 413 ##dbg(enable=1)
 414
 415 #----------------------------------------------------------------------------
 416
 417 wxEVT_COMMAND_MASKED_NUMBER_UPDATED = wx.NewEventType()
 418 EVT_NUM = wx.PyEventBinder(wxEVT_COMMAND_MASKED_NUMBER_UPDATED, 1)
 419
 420 #----------------------------------------------------------------------------
 421
 422 class NumberUpdatedEvent(wx.PyCommandEvent):
 423     """
 424     Used to fire an EVT_NUM event whenever the value in a NumCtrl changes.
 425     """
 426
 427     def __init__(self, id, value = 0, object=None):
 428         wx.PyCommandEvent.__init__(self, wxEVT_COMMAND_MASKED_NUMBER_UPDATED, id)
 429
 430         self.__value = value
 431         self.SetEventObject(object)
 432
 433     def GetValue(self):
 434         """Retrieve the value of the control at the time
 435         this event was generated."""
 436         return self.__value
 437
 438
 439 #----------------------------------------------------------------------------
 440 class NumCtrlAccessorsMixin:
 441     """
 442     Defines masked.NumCtrl's list of attributes having their own
 443     Get/Set functions, ignoring those that make no sense for
 444     a numeric control.
 445     """
 446     exposed_basectrl_params = (
 447          'decimalChar',
 448          'shiftDecimalChar',
 449          'groupChar',
 450          'useParensForNegatives',
 451          'defaultValue',
 452          'description',
 453
 454          'useFixedWidthFont',
 455          'autoSize',
 456          'signedForegroundColour',
 457          'emptyBackgroundColour',
 458          'validBackgroundColour',
 459          'invalidBackgroundColour',
 460
 461          'emptyInvalid',
 462          'validFunc',
 463          'validRequired',
 464          'stopFieldChangeIfInvalid',
 465         )
 466     for param in exposed_basectrl_params:
 467         propname = param[0].upper() + param[1:]
 468         exec('def Set%s(self, value): self.SetCtrlParameters(%s=value)' % (propname, param))
 469         exec('def Get%s(self): return self.GetCtrlParameter("%s")''' % (propname, param))
 470
 471         if param.find('Colour') != -1:
 472             # add non-british spellings, for backward-compatibility
 473             propname.replace('Colour', 'Color')
 474
 475             exec('def Set%s(self, value): self.SetCtrlParameters(%s=value)' % (propname, param))
 476             exec('def Get%s(self): return self.GetCtrlParameter("%s")''' % (propname, param))
 477
 478
 479
 480 #----------------------------------------------------------------------------
 481
 482 class NumCtrl(BaseMaskedTextCtrl, NumCtrlAccessorsMixin):
 483     """
 484     Masked edit control supporting "native" numeric values, ie. .SetValue(3), for
 485     example, and supporting a variety of formatting options, including automatic
 486     rounding specifiable precision, grouping and decimal place characters, etc.
 487     """
 488
 489
 490     valid_ctrl_params = {
 491         'integerWidth': 10,                 # by default allow all 32-bit integers
 492         'fractionWidth': 0,                 # by default, use integers
 493         'decimalChar': '.',                 # by default, use '.' for decimal point
 494         'allowNegative': True,              # by default, allow negative numbers
 495         'useParensForNegatives': False,     # by default, use '-' to indicate negatives
 496         'groupDigits': True,                # by default, don't insert grouping
 497         'groupChar': ',',                   # by default, use ',' for grouping
 498         'min': None,                        # by default, no bounds set
 499         'max': None,
 500         'limited': False,                   # by default, no limiting even if bounds set
 501         'limitOnFieldChange': False,        # by default, don't limit if changing fields, even if bounds set
 502         'allowNone': False,                 # by default, don't allow empty value
 503         'selectOnEntry': True,              # by default, select the value of each field on entry
 504         'foregroundColour': "Black",
 505         'signedForegroundColour': "Red",
 506         'emptyBackgroundColour': "White",
 507         'validBackgroundColour': "White",
 508         'invalidBackgroundColour': "Yellow",
 509         'useFixedWidthFont': True,          # by default, use a fixed-width font
 510         'autoSize': True,                   # by default, set the width of the control based on the mask
 511         }
 512
 513
 514     def __init__ (
 515                 self, parent, id=-1, value = 0,
 516                 pos = wx.DefaultPosition, size = wx.DefaultSize,
 517                 style = wx.TE_PROCESS_TAB, validator = wx.DefaultValidator,
 518                 name = "masked.num",
 519                 **kwargs ):
 520
 521 ##        dbg('masked.NumCtrl::__init__', indent=1)
 522
 523         # Set defaults for control:
 524 ##        dbg('setting defaults:')
 525         for key, param_value in NumCtrl.valid_ctrl_params.items():
 526             # This is done this way to make setattr behave consistently with
 527             # "private attribute" name mangling
 528             setattr(self, '_' + key, copy.copy(param_value))
 529
 530         # Assign defaults for all attributes:
 531         init_args = copy.deepcopy(NumCtrl.valid_ctrl_params)
 532 ##        dbg('kwargs:', kwargs)
 533         for key, param_value in kwargs.items():
 534             key = key.replace('Color', 'Colour')
 535             if key not in NumCtrl.valid_ctrl_params.keys():
 536                 raise AttributeError('invalid keyword argument "%s"' % key)
 537             else:
 538                 init_args[key] = param_value
 539 ##        dbg('init_args:', indent=1)
 540         for key, param_value in init_args.items():
 541 ##            dbg('%s:' % key, param_value)
 542             pass
 543 ##        dbg(indent=0)
 544
 545         # Process initial fields for the control, as part of construction:
 546         if type(init_args['integerWidth']) != types.IntType:
 547             raise AttributeError('invalid integerWidth (%s) specified; expected integer' % repr(init_args['integerWidth']))
 548         elif init_args['integerWidth'] < 1:
 549             raise AttributeError('invalid integerWidth (%s) specified; must be > 0' % repr(init_args['integerWidth']))
 550
 551         fields = {}
 552
 553         if init_args.has_key('fractionWidth'):
 554             if type(init_args['fractionWidth']) != types.IntType:
 555                 raise AttributeError('invalid fractionWidth (%s) specified; expected integer' % repr(self._fractionWidth))
 556             elif init_args['fractionWidth'] < 0:
 557                 raise AttributeError('invalid fractionWidth (%s) specified; must be >= 0' % repr(init_args['fractionWidth']))
 558             self._fractionWidth = init_args['fractionWidth']
 559
 560         if self._fractionWidth:
 561             fracmask = '.' + '#{%d}' % self._fractionWidth
 562 ##            dbg('fracmask:', fracmask)
 563             fields[1] = Field(defaultValue='0'*self._fractionWidth)
 564         else:
 565             fracmask = ''
 566
 567         self._integerWidth = init_args['integerWidth']
 568         if init_args['groupDigits']:
 569             self._groupSpace = (self._integerWidth - 1) / 3
 570         else:
 571             self._groupSpace = 0
 572         intmask = '#{%d}' % (self._integerWidth + self._groupSpace)
 573         if self._fractionWidth:
 574             emptyInvalid = False
 575         else:
 576             emptyInvalid = True
 577         fields[0] = Field(formatcodes='r<>', emptyInvalid=emptyInvalid)
 578 ##        dbg('intmask:', intmask)
 579
 580         # don't bother to reprocess these arguments:
 581         del init_args['integerWidth']
 582         del init_args['fractionWidth']
 583
 584         self._autoSize = init_args['autoSize']
 585         if self._autoSize:
 586             formatcodes = 'FR<'
 587         else:
 588             formatcodes = 'R<'
 589
 590
 591         mask = intmask+fracmask
 592
 593         # initial value of state vars
 594         self._oldvalue = 0
 595         self._integerEnd = 0
 596         self._typedSign = False
 597
 598         # Construct the base control:
 599         BaseMaskedTextCtrl.__init__(
 600                 self, parent, id, '',
 601                 pos, size, style, validator, name,
 602                 mask = mask,
 603                 formatcodes = formatcodes,
 604                 fields = fields,
 605                 validFunc=self.IsInBounds,
 606                 setupEventHandling = False)
 607
 608         self.Bind(wx.EVT_SET_FOCUS, self._OnFocus )        ## defeat automatic full selection
 609         self.Bind(wx.EVT_KILL_FOCUS, self._OnKillFocus )   ## run internal validator
 610         self.Bind(wx.EVT_LEFT_DCLICK, self._OnDoubleClick)  ## select field under cursor on dclick
 611         self.Bind(wx.EVT_RIGHT_UP, self._OnContextMenu )    ## bring up an appropriate context menu
 612         self.Bind(wx.EVT_KEY_DOWN, self._OnKeyDown )       ## capture control events not normally seen, eg ctrl-tab.
 613         self.Bind(wx.EVT_CHAR, self._OnChar )              ## handle each keypress
 614         self.Bind(wx.EVT_TEXT, self.OnTextChange )      ## color control appropriately & keep
 615                                                            ## track of previous value for undo
 616
 617         # Establish any additional parameters, with appropriate error checking
 618         self.SetParameters(**init_args)
 619
 620         # Set the value requested (if possible)
 621 ##        wxCallAfter(self.SetValue, value)
 622         self.SetValue(value)
 623
 624         # Ensure proper coloring:
 625         self.Refresh()
 626 ##        dbg('finished NumCtrl::__init__', indent=0)
 627
 628
 629     def SetParameters(self, **kwargs):
 630         """
 631         This function is used to initialize and reconfigure the control.
 632         See TimeCtrl module overview for available parameters.
 633         """
 634 ##        dbg('NumCtrl::SetParameters', indent=1)
 635         maskededit_kwargs = {}
 636         reset_fraction_width = False
 637
 638
 639         if( (kwargs.has_key('integerWidth') and kwargs['integerWidth'] != self._integerWidth)
 640             or (kwargs.has_key('fractionWidth') and kwargs['fractionWidth'] != self._fractionWidth)
 641             or (kwargs.has_key('groupDigits') and kwargs['groupDigits'] != self._groupDigits)
 642             or (kwargs.has_key('autoSize') and kwargs['autoSize'] != self._autoSize) ):
 643
 644             fields = {}
 645
 646             if kwargs.has_key('fractionWidth'):
 647                 if type(kwargs['fractionWidth']) != types.IntType:
 648                     raise AttributeError('invalid fractionWidth (%s) specified; expected integer' % repr(kwargs['fractionWidth']))
 649                 elif kwargs['fractionWidth'] < 0:
 650                     raise AttributeError('invalid fractionWidth (%s) specified; must be >= 0' % repr(kwargs['fractionWidth']))
 651                 else:
 652                     if self._fractionWidth != kwargs['fractionWidth']:
 653                         self._fractionWidth = kwargs['fractionWidth']
 654
 655             if self._fractionWidth:
 656                 fracmask = '.' + '#{%d}' % self._fractionWidth
 657                 fields[1] = Field(defaultValue='0'*self._fractionWidth)
 658                 emptyInvalid = False
 659             else:
 660                 emptyInvalid = True
 661                 fracmask = ''
 662 ##            dbg('fracmask:', fracmask)
 663
 664             if kwargs.has_key('integerWidth'):
 665                 if type(kwargs['integerWidth']) != types.IntType:
 666 ##                    dbg(indent=0)
 667                     raise AttributeError('invalid integerWidth (%s) specified; expected integer' % repr(kwargs['integerWidth']))
 668                 elif kwargs['integerWidth'] < 0:
 669 ##                    dbg(indent=0)
 670                     raise AttributeError('invalid integerWidth (%s) specified; must be > 0' % repr(kwargs['integerWidth']))
 671                 else:
 672                     self._integerWidth = kwargs['integerWidth']
 673
 674             if kwargs.has_key('groupDigits'):
 675                 self._groupDigits = kwargs['groupDigits']
 676
 677             if self._groupDigits:
 678                 self._groupSpace = (self._integerWidth - 1) / 3
 679             else:
 680                 self._groupSpace = 0
 681
 682             intmask = '#{%d}' % (self._integerWidth + self._groupSpace)
 683 ##            dbg('intmask:', intmask)
 684             fields[0] = Field(formatcodes='r<>', emptyInvalid=emptyInvalid)
 685             maskededit_kwargs['fields'] = fields
 686
 687             # don't bother to reprocess these arguments:
 688             if kwargs.has_key('integerWidth'):
 689                 del kwargs['integerWidth']
 690             if kwargs.has_key('fractionWidth'):
 691                 del kwargs['fractionWidth']
 692
 693             maskededit_kwargs['mask'] = intmask+fracmask
 694
 695         if kwargs.has_key('groupChar') or kwargs.has_key('decimalChar'):
 696             old_groupchar = self._groupChar     # save so we can reformat properly
 697             old_decimalchar = self._decimalChar
 698 ##            dbg("old_groupchar: '%s'" % old_groupchar)
 699 ##            dbg("old_decimalchar: '%s'" % old_decimalchar)
 700             groupchar = old_groupchar
 701             decimalchar = old_decimalchar
 702             old_numvalue = self._GetNumValue(self._GetValue())
 703
 704             if kwargs.has_key('groupChar'):
 705                 maskededit_kwargs['groupChar'] = kwargs['groupChar']
 706                 groupchar = kwargs['groupChar']
 707             if kwargs.has_key('decimalChar'):
 708                 maskededit_kwargs['decimalChar'] = kwargs['decimalChar']
 709                 decimalchar = kwargs['decimalChar']
 710
 711             # Add sanity check to make sure these are distinct, and if not,
 712             # raise attribute error
 713             if groupchar == decimalchar:
 714                 raise AttributeError('groupChar and decimalChar must be distinct')
 715
 716
 717         # for all other parameters, assign keyword args as appropriate:
 718         for key, param_value in kwargs.items():
 719             key = key.replace('Color', 'Colour')
 720             if key not in NumCtrl.valid_ctrl_params.keys():
 721                 raise AttributeError('invalid keyword argument "%s"' % key)
 722             elif key not in MaskedEditMixin.valid_ctrl_params.keys():
 723                 setattr(self, '_' + key, param_value)
 724             elif key in ('mask', 'autoformat'): # disallow explicit setting of mask
 725                 raise AttributeError('invalid keyword argument "%s"' % key)
 726             else:
 727                 maskededit_kwargs[key] = param_value
 728 ##        dbg('kwargs:', kwargs)
 729
 730         # reprocess existing format codes to ensure proper resulting format:
 731         formatcodes = self.GetCtrlParameter('formatcodes')
 732         if kwargs.has_key('allowNegative'):
 733             if kwargs['allowNegative'] and '-' not in formatcodes:
 734                 formatcodes += '-'
 735                 maskededit_kwargs['formatcodes'] = formatcodes
 736             elif not kwargs['allowNegative'] and '-' in formatcodes:
 737                 formatcodes = formatcodes.replace('-','')
 738                 maskededit_kwargs['formatcodes'] = formatcodes
 739
 740         if kwargs.has_key('groupDigits'):
 741             if kwargs['groupDigits'] and ',' not in formatcodes:
 742                 formatcodes += ','
 743                 maskededit_kwargs['formatcodes'] = formatcodes
 744             elif not kwargs['groupDigits'] and ',' in formatcodes:
 745                 formatcodes = formatcodes.replace(',','')
 746                 maskededit_kwargs['formatcodes'] = formatcodes
 747
 748         if kwargs.has_key('selectOnEntry'):
 749             self._selectOnEntry = kwargs['selectOnEntry']
 750 ##            dbg("kwargs['selectOnEntry']?", kwargs['selectOnEntry'], "'S' in formatcodes?", 'S' in formatcodes)
 751             if kwargs['selectOnEntry'] and 'S' not in formatcodes:
 752                 formatcodes += 'S'
 753                 maskededit_kwargs['formatcodes'] = formatcodes
 754             elif not kwargs['selectOnEntry'] and 'S' in formatcodes:
 755                 formatcodes = formatcodes.replace('S','')
 756                 maskededit_kwargs['formatcodes'] = formatcodes
 757
 758         if kwargs.has_key('autoSize'):
 759             self._autoSize = kwargs['autoSize']
 760             if kwargs['autoSize'] and 'F' not in formatcodes:
 761                 formatcodes += 'F'
 762                 maskededit_kwargs['formatcodes'] = formatcodes
 763             elif not kwargs['autoSize'] and 'F' in formatcodes:
 764                 formatcodes = formatcodes.replace('F', '')
 765                 maskededit_kwargs['formatcodes'] = formatcodes
 766
 767
 768         if 'r' in formatcodes and self._fractionWidth:
 769             # top-level mask should only be right insert if no fractional
 770             # part will be shown; ie. if reconfiguring control, remove
 771             # previous "global" setting.
 772             formatcodes = formatcodes.replace('r', '')
 773             maskededit_kwargs['formatcodes'] = formatcodes
 774
 775
 776         if kwargs.has_key('limited'):
 777             if kwargs['limited'] and not self._limited:
 778                 maskededit_kwargs['validRequired'] = True
 779             elif not kwargs['limited'] and self._limited:
 780                 maskededit_kwargs['validRequired'] = False
 781             self._limited = kwargs['limited']
 782
 783         if kwargs.has_key('limitOnFieldChange'):
 784             if kwargs['limitOnFieldChange'] and not self._limitOnFieldChange:
 785                 maskededit_kwargs['stopFieldChangeIfInvalid'] = True
 786             elif kwargs['limitOnFieldChange'] and self._limitOnFieldChange:
 787                 maskededit_kwargs['stopFieldChangeIfInvalid'] = False
 788
 789 ##        dbg('maskededit_kwargs:', maskededit_kwargs)
 790         if maskededit_kwargs.keys():
 791             self.SetCtrlParameters(**maskededit_kwargs)
 792
 793         # Go ensure all the format codes necessary are present:
 794         orig_intformat = intformat = self.GetFieldParameter(0, 'formatcodes')
 795         if 'r' not in intformat:
 796             intformat += 'r'
 797         if '>' not in intformat:
 798             intformat += '>'
 799         if intformat != orig_intformat:
 800             if self._fractionWidth:
 801                 self.SetFieldParameters(0, formatcodes=intformat)
 802             else:
 803                 self.SetCtrlParameters(formatcodes=intformat)
 804
 805         # Record end of integer and place cursor there unless selecting, or select entire field:
 806         integerStart, integerEnd = self._fields[0]._extent
 807         if not self._fields[0]._selectOnFieldEntry:
 808             self.SetInsertionPoint(0)
 809             self.SetInsertionPoint(integerEnd)
 810             self.SetSelection(integerEnd, integerEnd)
 811         else:
 812             self.SetInsertionPoint(0)   # include any sign
 813             self.SetSelection(0, integerEnd)
 814
 815
 816         # Set min and max as appropriate:
 817         if kwargs.has_key('min'):
 818             min = kwargs['min']
 819             if( self._max is None
 820                 or min is None
 821                 or (self._max is not None and self._max >= min) ):
 822 ##                dbg('examining min')
 823                 if min is not None:
 824                     try:
 825                         textmin = self._toGUI(min, apply_limits = False)
 826                     except ValueError:
 827 ##                        dbg('min will not fit into control; ignoring', indent=0)
 828                         raise
 829 ##                dbg('accepted min')
 830                 self._min = min
 831             else:
 832 ##                dbg('ignoring min')
 833                 pass
 834
 835
 836         if kwargs.has_key('max'):
 837             max = kwargs['max']
 838             if( self._min is None
 839                 or max is None
 840                 or (self._min is not None and self._min <= max) ):
 841 ##                dbg('examining max')
 842                 if max is not None:
 843                     try:
 844                         textmax = self._toGUI(max, apply_limits = False)
 845                     except ValueError:
 846 ##                        dbg('max will not fit into control; ignoring', indent=0)
 847                         raise
 848 ##                dbg('accepted max')
 849                 self._max = max
 850             else:
 851 ##                dbg('ignoring max')
 852                 pass
 853
 854         if kwargs.has_key('allowNegative'):
 855             self._allowNegative = kwargs['allowNegative']
 856
 857         # Ensure current value of control obeys any new restrictions imposed:
 858         text = self._GetValue()
 859 ##        dbg('text value: "%s"' % text)
 860         if kwargs.has_key('groupChar') and self._groupChar != old_groupchar and text.find(old_groupchar) != -1:
 861             text = old_numvalue
 862 ##            dbg('old_groupchar: "%s" newgroupchar: "%s"' % (old_groupchar, self._groupChar))
 863         if kwargs.has_key('decimalChar') and self._decimalChar != old_decimalchar and text.find(old_decimalchar) != -1:
 864             text = old_numvalue
 865
 866         if text != self._GetValue():
 867             if self._decimalChar != '.':
 868                 # ensure latest decimal char is in "numeric value" so it won't be removed
 869                 # when going to the GUI:
 870                 text = text.replace('.', self._decimalChar)
 871             newtext = self._toGUI(text)
 872 ##            dbg('calling wx.TextCtrl.SetValue(self, %s)' % newtext)
 873             wx.TextCtrl.SetValue(self, newtext)
 874
 875         value = self.GetValue()
 876
 877 ##        dbg('self._allowNegative?', self._allowNegative)
 878         if not self._allowNegative and self._isNeg:
 879             value = abs(value)
 880 ##            dbg('abs(value):', value)
 881             self._isNeg = False
 882
 883         elif not self._allowNone and BaseMaskedTextCtrl.GetValue(self) == '':
 884             if self._min > 0:
 885                 value = self._min
 886             else:
 887                 value = 0
 888
 889         sel_start, sel_to = self.GetSelection()
 890         if self.IsLimited() and self._min is not None and value < self._min:
 891 ##            dbg('Set to min value:', self._min)
 892             self._SetValue(self._toGUI(self._min))
 893
 894         elif self.IsLimited() and self._max is not None and value > self._max:
 895 ##            dbg('Setting to max value:', self._max)
 896             self._SetValue(self._toGUI(self._max))
 897         else:
 898             # reformat current value as appropriate to possibly new conditions
 899 ##            dbg('Reformatting value:', value)
 900             sel_start, sel_to = self.GetSelection()
 901             self._SetValue(self._toGUI(value))
 902         self.Refresh() # recolor as appropriate
 903 ##        dbg('finished NumCtrl::SetParameters', indent=0)
 904
 905
 906
 907     def _GetNumValue(self, value):
 908         """
 909         This function attempts to "clean up" a text value, providing a regularized
 910         convertable string, via atol() or atof(), for any well-formed numeric text value.
 911         """
 912         return value.replace(self._groupChar, '').replace(self._decimalChar, '.').replace('(', '-').replace(')','').strip()
 913
 914
 915     def GetFraction(self, candidate=None):
 916         """
 917         Returns the fractional portion of the value as a float.  If there is no
 918         fractional portion, the value returned will be 0.0.
 919         """
 920         if not self._fractionWidth:
 921             return 0.0
 922         else:
 923             fracstart, fracend = self._fields[1]._extent
 924             if candidate is None:
 925                 value = self._toGUI(BaseMaskedTextCtrl.GetValue(self))
 926             else:
 927                 value = self._toGUI(candidate)
 928             fracstring = value[fracstart:fracend].strip()
 929             if not value:
 930                 return 0.0
 931             else:
 932                 return string.atof(fracstring)
 933
 934     def _OnChangeSign(self, event):
 935 ##        dbg('NumCtrl::_OnChangeSign', indent=1)
 936         self._typedSign = True
 937         MaskedEditMixin._OnChangeSign(self, event)
 938 ##        dbg(indent=0)
 939
 940
 941     def _disallowValue(self):
 942 ##        dbg('NumCtrl::_disallowValue')
 943         # limited and -1 is out of bounds
 944         if self._typedSign:
 945             self._isNeg = False
 946         if not wx.Validator_IsSilent():
 947             wx.Bell()
 948         sel_start, sel_to = self._GetSelection()
 949 ##        dbg('queuing reselection of (%d, %d)' % (sel_start, sel_to))
 950         wx.CallAfter(self.SetInsertionPoint, sel_start)      # preserve current selection/position
 951         wx.CallAfter(self.SetSelection, sel_start, sel_to)
 952
 953
 954     def _OnChangeField(self, event):
 955         """
 956         This routine enhances the base masked control _OnFieldChange().  It's job
 957         is to ensure limits are imposed if limitOnFieldChange is enabled.
 958         """
 959 ##        dbg('NumCtrl::_OnFieldChange', indent=1)
 960         if self._limitOnFieldChange and not (self._min <= self.GetValue() <= self._max):
 961             self._disallowValue()
 962 ##            dbg('oob - field change disallowed',indent=0)
 963             return False
 964         else:
 965 ##            dbg(indent=0)
 966             return MaskedEditMixin._OnChangeField(self, event)     # call the baseclass function
 967
 968
 969     def _LostFocus(self):
 970         """
 971         On loss of focus, if limitOnFieldChange is set, ensure value conforms to limits.
 972         """
 973 ##        dbg('NumCtrl::_LostFocus', indent=1)
 974         if self._limitOnFieldChange:
 975 ##            dbg("limiting on loss of focus")
 976             value = self.GetValue()
 977             if self._min is not None and value < self._min:
 978 ##                dbg('Set to min value:', self._min)
 979                 self._SetValue(self._toGUI(self._min))
 980
 981             elif self._max is not None and value > self._max:
 982 ##                dbg('Setting to max value:', self._max)
 983                 self._SetValue(self._toGUI(self._max))
 984             # (else do nothing.)
 985         # (else do nothing.)
 986 ##        dbg(indent=0)
 987         return True
 988
 989
 990     def _SetValue(self, value):
 991         """
 992         This routine supersedes the base masked control _SetValue().  It is
 993         needed to ensure that the value of the control is always representable/convertable
 994         to a numeric return value (via GetValue().)  This routine also handles
 995         automatic adjustment and grouping of the value without explicit intervention
 996         by the user.
 997         """
 998
 999 ##        dbg('NumCtrl::_SetValue("%s")' % value, indent=1)
1000
1001         if( (self._fractionWidth and value.find(self._decimalChar) == -1) or
1002             (self._fractionWidth == 0 and value.find(self._decimalChar) != -1) ) :
1003             value = self._toGUI(value)
1004
1005         numvalue = self._GetNumValue(value)
1006 ##        dbg('cleansed value: "%s"' % numvalue)
1007         replacement = None
1008
1009         if numvalue == "":
1010             if self._allowNone:
1011 ##                dbg('calling base BaseMaskedTextCtrl._SetValue(self, "%s")' % value)
1012                 BaseMaskedTextCtrl._SetValue(self, value)
1013                 self.Refresh()
1014 ##                dbg(indent=0)
1015                 return
1016             elif self._min > 0 and self.IsLimited():
1017                 replacement = self._min
1018             else:
1019                 replacement = 0
1020 ##            dbg('empty value; setting replacement:', replacement)
1021
1022         if replacement is None:
1023             # Go get the integer portion about to be set and verify its validity
1024             intstart, intend = self._fields[0]._extent
1025 ##            dbg('intstart, intend:', intstart, intend)
1026 ##            dbg('raw integer:"%s"' % value[intstart:intend])
1027             int = self._GetNumValue(value[intstart:intend])
1028             numval = self._fromGUI(value)
1029
1030 ##            dbg('integer: "%s"' % int)
1031             try:
1032                 # if a float value, this will implicitly verify against limits,
1033                 # and generate an exception if out-of-bounds and limited
1034                 # if not a float, it will just return 0.0, and we therefore
1035                 # have to test against the limits explicitly after testing
1036                 # special cases for handling -0 and empty controls...
1037                 fracval = self.GetFraction(value)
1038             except ValueError, e:
1039 ##                dbg('Exception:', e, 'must be out of bounds; disallow value')
1040                 self._disallowValue()
1041 ##                dbg(indent=0)
1042                 return
1043
1044             if fracval == 0.0: # (can be 0 for floats as well as integers)
1045                 # we have to do special testing to account for emptying controls, or -0
1046                 # and/or just leaving the sign character or changing the sign,
1047                 # so we can do appropriate things to the value of the control,
1048                 # we can't just immediately test to see if the value is valid
1049                 # If all of these special cases are not in play, THEN we can do
1050                 # a limits check and see if the value is otherwise ok...
1051
1052 ##                dbg('self._isNeg?', self._isNeg)
1053                 if int == '-' and self._oldvalue < 0 and not self._typedSign:
1054 ##                    dbg('just a negative sign; old value < 0; setting replacement of 0')
1055                     replacement = 0
1056                     self._isNeg = False
1057                 elif int[:2] == '-0':
1058                     if self._oldvalue < 0:
1059 ##                        dbg('-0; setting replacement of 0')
1060                         replacement = 0
1061                         self._isNeg = False
1062                     elif not self._limited or (self._min < -1 and self._max >= -1):
1063 ##                        dbg('-0; setting replacement of -1')
1064                         replacement = -1
1065                         self._isNeg = True
1066                     else:
1067                         # limited and -1 is out of bounds
1068                         self._disallowValue()
1069 ##                        dbg(indent=0)
1070                         return
1071
1072                 elif int == '-' and (self._oldvalue >= 0 or self._typedSign):
1073                     if not self._limited or (self._min < -1 and self._max >= -1):
1074 ##                        dbg('just a negative sign; setting replacement of -1')
1075                         replacement = -1
1076                     else:
1077                         # limited and -1 is out of bounds
1078                         self._disallowValue()
1079 ##                        dbg(indent=0)
1080                         return
1081
1082                 elif( self._typedSign
1083                       and int.find('-') != -1
1084                       and self._limited
1085                       and not self._min <= numval <= self._max):
1086                     # changed sign resulting in value that's now out-of-bounds;
1087                     # disallow
1088                     self._disallowValue()
1089 ##                    dbg(indent=0)
1090                     return
1091
1092             if replacement is None:
1093                 if int and int != '-':
1094                     try:
1095                         string.atol(int)
1096                     except ValueError:
1097                         # integer requested is not legal.  This can happen if the user
1098                         # is attempting to insert a digit in the middle of the control
1099                         # resulting in something like "   3   45". Disallow such actions:
1100 ##                        dbg('>>>>>>>>>>>>>>>> "%s" does not convert to a long!' % int)
1101                         if not wx.Validator_IsSilent():
1102                             wx.Bell()
1103                         sel_start, sel_to = self._GetSelection()
1104 ##                        dbg('queuing reselection of (%d, %d)' % (sel_start, sel_to))
1105                         wx.CallAfter(self.SetInsertionPoint, sel_start)      # preserve current selection/position
1106                         wx.CallAfter(self.SetSelection, sel_start, sel_to)
1107 ##                        dbg(indent=0)
1108                         return
1109
1110 ##                    dbg('numvalue: "%s"' % numvalue.replace(' ', ''))
1111                     # finally, (potentially re) verify that numvalue will pass any limits imposed:
1112                     try:
1113                         if self._fractionWidth:
1114                             value = self._toGUI(string.atof(numvalue))
1115                         else:
1116                             value = self._toGUI(string.atol(numvalue))
1117                     except ValueError, e:
1118 ##                        dbg('Exception:', e, 'must be out of bounds; disallow value')
1119                         self._disallowValue()
1120 ##                        dbg(indent=0)
1121                         return
1122
1123 ##                        dbg('modified value: "%s"' % value)
1124
1125
1126         self._typedSign = False     # reset state var
1127
1128         if replacement is not None:
1129             # Value presented wasn't a legal number, but control should do something
1130             # reasonable instead:
1131 ##            dbg('setting replacement value:', replacement)
1132             self._SetValue(self._toGUI(replacement))
1133             sel_start = BaseMaskedTextCtrl.GetValue(self).find(str(abs(replacement)))   # find where it put the 1, so we can select it
1134             sel_to = sel_start + len(str(abs(replacement)))
1135 ##            dbg('queuing selection of (%d, %d)' %(sel_start, sel_to))
1136             wx.CallAfter(self.SetInsertionPoint, sel_start)
1137             wx.CallAfter(self.SetSelection, sel_start, sel_to)
1138 ##            dbg(indent=0)
1139             return
1140
1141         # Otherwise, apply appropriate formatting to value:
1142
1143         # Because we're intercepting the value and adjusting it
1144         # before a sign change is detected, we need to do this here:
1145         if '-' in value or '(' in value:
1146             self._isNeg = True
1147         else:
1148             self._isNeg = False
1149
1150 ##        dbg('value:"%s"' % value, 'self._useParens:', self._useParens)
1151         if self._fractionWidth:
1152             adjvalue = self._adjustFloat(self._GetNumValue(value).replace('.',self._decimalChar))
1153         else:
1154             adjvalue = self._adjustInt(self._GetNumValue(value))
1155 ##        dbg('adjusted value: "%s"' % adjvalue)
1156
1157
1158         sel_start, sel_to = self._GetSelection()     # record current insertion point
1159 ##        dbg('calling BaseMaskedTextCtrl._SetValue(self, "%s")' % adjvalue)
1160         BaseMaskedTextCtrl._SetValue(self, adjvalue)
1161         # After all actions so far scheduled, check that resulting cursor
1162         # position is appropriate, and move if not:
1163         wx.CallAfter(self._CheckInsertionPoint)
1164
1165 ##        dbg('finished NumCtrl::_SetValue', indent=0)
1166
1167     def _CheckInsertionPoint(self):
1168         # If current insertion point is before the end of the integer and
1169         # its before the 1st digit, place it just after the sign position:
1170 ##        dbg('NumCtrl::CheckInsertionPoint', indent=1)
1171         sel_start, sel_to = self._GetSelection()
1172         text = self._GetValue()
1173         if sel_to < self._fields[0]._extent[1] and text[sel_to] in (' ', '-', '('):
1174             text, signpos, right_signpos = self._getSignedValue()
1175 ##            dbg('setting selection(%d, %d)' % (signpos+1, signpos+1))
1176             self.SetInsertionPoint(signpos+1)
1177             self.SetSelection(signpos+1, signpos+1)
1178 ##        dbg(indent=0)
1179
1180
1181     def _OnErase( self, event=None, just_return_value=False ):
1182         """
1183         This overrides the base control _OnErase, so that erasing around
1184         grouping characters auto selects the digit before or after the
1185         grouping character, so that the erasure does the right thing.
1186         """
1187 ##        dbg('NumCtrl::_OnErase', indent=1)
1188         if event is None:   # called as action routine from Cut() operation.
1189             key = wx.WXK_DELETE
1190         else:
1191             key = event.GetKeyCode()
1192         #if grouping digits, make sure deletes next to group char always
1193         # delete next digit to appropriate side:
1194         if self._groupDigits:
1195             value = BaseMaskedTextCtrl.GetValue(self)
1196             sel_start, sel_to = self._GetSelection()
1197
1198             if key == wx.WXK_BACK:
1199                 # if 1st selected char is group char, select to previous digit
1200                 if sel_start > 0 and sel_start < len(self._mask) and value[sel_start:sel_to] == self._groupChar:
1201                     self.SetInsertionPoint(sel_start-1)
1202                     self.SetSelection(sel_start-1, sel_to)
1203
1204                 # elif previous char is group char, select to previous digit
1205                 elif sel_start > 1 and sel_start == sel_to and value[sel_start-1:sel_start] == self._groupChar:
1206                     self.SetInsertionPoint(sel_start-2)
1207                     self.SetSelection(sel_start-2, sel_to)
1208
1209             elif key == wx.WXK_DELETE:
1210                 if( sel_to < len(self._mask) - 2 + (1 *self._useParens)
1211                     and sel_start == sel_to
1212                     and value[sel_to] == self._groupChar ):
1213                     self.SetInsertionPoint(sel_start)
1214                     self.SetSelection(sel_start, sel_to+2)
1215
1216                 elif( sel_to < len(self._mask) - 2 + (1 *self._useParens)
1217                            and value[sel_start:sel_to] == self._groupChar ):
1218                     self.SetInsertionPoint(sel_start)
1219                     self.SetSelection(sel_start, sel_to+1)
1220 ##        dbg(indent=0)
1221         return BaseMaskedTextCtrl._OnErase(self, event, just_return_value)
1222
1223
1224     def OnTextChange( self, event ):
1225         """
1226         Handles an event indicating that the text control's value
1227         has changed, and issue EVT_NUM event.
1228         NOTE: using wxTextCtrl.SetValue() to change the control's
1229         contents from within a EVT_CHAR handler can cause double
1230         text events.  So we check for actual changes to the text
1231         before passing the events on.
1232         """
1233 ##        dbg('NumCtrl::OnTextChange', indent=1)
1234         if not BaseMaskedTextCtrl._OnTextChange(self, event):
1235 ##            dbg(indent=0)
1236             return
1237
1238         # else... legal value
1239
1240         value = self.GetValue()
1241         if value != self._oldvalue:
1242             try:
1243                 self.GetEventHandler().ProcessEvent(
1244                     NumberUpdatedEvent( self.GetId(), self.GetValue(), self ) )
1245             except ValueError:
1246 ##                dbg(indent=0)
1247                 return
1248             # let normal processing of the text continue
1249             event.Skip()
1250         self._oldvalue = value # record for next event
1251 ##        dbg(indent=0)
1252
1253     def _GetValue(self):
1254         """
1255         Override of BaseMaskedTextCtrl to allow mixin to get the raw text value of the
1256         control with this function.
1257         """
1258         return wx.TextCtrl.GetValue(self)
1259
1260
1261     def GetValue(self):
1262         """
1263         Returns the current numeric value of the control.
1264         """
1265         return self._fromGUI( BaseMaskedTextCtrl.GetValue(self) )
1266
1267     def SetValue(self, value):
1268         """
1269         Sets the value of the control to the value specified.
1270         The resulting actual value of the control may be altered to
1271         conform with the bounds set on the control if limited,
1272         or colored if not limited but the value is out-of-bounds.
1273         A ValueError exception will be raised if an invalid value
1274         is specified.
1275         """
1276 ##        dbg('NumCtrl::SetValue(%s)' % value, indent=1)
1277         BaseMaskedTextCtrl.SetValue( self, self._toGUI(value) )
1278 ##        dbg(indent=0)
1279
1280
1281     def SetIntegerWidth(self, value):
1282         self.SetParameters(integerWidth=value)
1283     def GetIntegerWidth(self):
1284         return self._integerWidth
1285
1286     def SetFractionWidth(self, value):
1287         self.SetParameters(fractionWidth=value)
1288     def GetFractionWidth(self):
1289         return self._fractionWidth
1290
1291
1292
1293     def SetMin(self, min=None):
1294         """
1295         Sets the minimum value of the control.  If a value of None
1296         is provided, then the control will have no explicit minimum value.
1297         If the value specified is greater than the current maximum value,
1298         then the function returns False and the minimum will not change from
1299         its current setting.  On success, the function returns True.
1300
1301         If successful and the current value is lower than the new lower
1302         bound, if the control is limited, the value will be automatically
1303         adjusted to the new minimum value; if not limited, the value in the
1304         control will be colored as invalid.
1305
1306         If min > the max value allowed by the width of the control,
1307         the function will return False, and the min will not be set.
1308         """
1309 ##        dbg('NumCtrl::SetMin(%s)' % repr(min), indent=1)
1310         if( self._max is None
1311             or min is None
1312             or (self._max is not None and self._max >= min) ):
1313             try:
1314                 self.SetParameters(min=min)
1315                 bRet = True
1316             except ValueError:
1317                 bRet = False
1318         else:
1319             bRet = False
1320 ##        dbg(indent=0)
1321         return bRet
1322
1323     def GetMin(self):
1324         """
1325         Gets the lower bound value of the control.  It will return
1326         None if not specified.
1327         """
1328         return self._min
1329
1330
1331     def SetMax(self, max=None):
1332         """
1333         Sets the maximum value of the control. If a value of None
1334         is provided, then the control will have no explicit maximum value.
1335         If the value specified is less than the current minimum value, then
1336         the function returns False and the maximum will not change from its
1337         current setting. On success, the function returns True.
1338
1339         If successful and the current value is greater than the new upper
1340         bound, if the control is limited the value will be automatically
1341         adjusted to this maximum value; if not limited, the value in the
1342         control will be colored as invalid.
1343
1344         If max > the max value allowed by the width of the control,
1345         the function will return False, and the max will not be set.
1346         """
1347         if( self._min is None
1348             or max is None
1349             or (self._min is not None and self._min <= max) ):
1350             try:
1351                 self.SetParameters(max=max)
1352                 bRet = True
1353             except ValueError:
1354                 bRet = False
1355         else:
1356             bRet = False
1357
1358         return bRet
1359
1360
1361     def GetMax(self):
1362         """
1363         Gets the maximum value of the control.  It will return the current
1364         maximum integer, or None if not specified.
1365         """
1366         return self._max
1367
1368
1369     def SetBounds(self, min=None, max=None):
1370         """
1371         This function is a convenience function for setting the min and max
1372         values at the same time.  The function only applies the maximum bound
1373         if setting the minimum bound is successful, and returns True
1374         only if both operations succeed.
1375         NOTE: leaving out an argument will remove the corresponding bound.
1376         """
1377         ret = self.SetMin(min)
1378         return ret and self.SetMax(max)
1379
1380
1381     def GetBounds(self):
1382         """
1383         This function returns a two-tuple (min,max), indicating the
1384         current bounds of the control.  Each value can be None if
1385         that bound is not set.
1386         """
1387         return (self._min, self._max)
1388
1389
1390     def SetLimited(self, limited):
1391         """
1392         If called with a value of True, this function will cause the control
1393         to limit the value to fall within the bounds currently specified.
1394         If the control's value currently exceeds the bounds, it will then
1395         be limited accordingly.
1396
1397         If called with a value of False, this function will disable value
1398         limiting, but coloring of out-of-bounds values will still take
1399         place if bounds have been set for the control.
1400         """
1401         self.SetParameters(limited = limited)
1402
1403
1404     def IsLimited(self):
1405         """
1406         Returns True if the control is currently limiting the
1407         value to fall within the current bounds.
1408         """
1409         return self._limited
1410
1411     def GetLimited(self):
1412         """ (For regularization of property accessors) """
1413         return self.IsLimited()
1414
1415     def SetLimitOnFieldChange(self, limit):
1416         """
1417         If called with a value of True, this function will cause the control
1418         to prevent navigation out of the current field if its value is out-of-bounds,
1419         and limit the value to fall within the bounds currently specified if the
1420         control loses focus.
1421
1422         If called with a value of False, this function will disable value
1423         limiting, but coloring of out-of-bounds values will still take
1424         place if bounds have been set for the control.
1425         """
1426         self.SetParameters(limitOnFieldChange = limit)
1427
1428
1429     def IsLimitedOnFieldChange(self):
1430         """
1431         Returns True if the control is currently limiting the
1432         value to fall within the current bounds.
1433         """
1434         return self._limitOnFieldChange
1435
1436     def GetLimitOnFieldChange(self):
1437         """ (For regularization of property accessors) """
1438         return self.IsLimitedOnFieldChange()
1439
1440
1441     def IsInBounds(self, value=None):
1442         """
1443         Returns True if no value is specified and the current value
1444         of the control falls within the current bounds.  This function can
1445         also be called with a value to see if that value would fall within
1446         the current bounds of the given control.
1447         """
1448 ##        dbg('IsInBounds(%s)' % repr(value), indent=1)
1449         if value is None:
1450             value = self.GetValue()
1451         else:
1452             try:
1453                 value = self._GetNumValue(self._toGUI(value))
1454             except ValueError, e:
1455 ##                dbg('error getting NumValue(self._toGUI(value)):', e, indent=0)
1456                 return False
1457             if value.strip() == '':
1458                 value = None
1459             elif self._fractionWidth:
1460                 value = float(value)
1461             else:
1462                 value = long(value)
1463
1464         min = self.GetMin()
1465         max = self.GetMax()
1466         if min is None: min = value
1467         if max is None: max = value
1468
1469         # if bounds set, and value is None, return False
1470         if value == None and (min is not None or max is not None):
1471 ##            dbg('finished IsInBounds', indent=0)
1472             return 0
1473         else:
1474 ##            dbg('finished IsInBounds', indent=0)
1475             return min <= value <= max
1476
1477
1478     def SetAllowNone(self, allow_none):
1479         """
1480         Change the behavior of the validation code, allowing control
1481         to have a value of None or not, as appropriate.  If the value
1482         of the control is currently None, and allow_none is False, the
1483         value of the control will be set to the minimum value of the
1484         control, or 0 if no lower bound is set.
1485         """
1486         self._allowNone = allow_none
1487         if not allow_none and self.GetValue() is None:
1488             min = self.GetMin()
1489             if min is not None: self.SetValue(min)
1490             else:               self.SetValue(0)
1491
1492
1493     def IsNoneAllowed(self):
1494         return self._allowNone
1495     def GetAllowNone(self):
1496         """ (For regularization of property accessors) """
1497         return self.IsNoneAllowed()
1498
1499     def SetAllowNegative(self, value):
1500         self.SetParameters(allowNegative=value)
1501     def IsNegativeAllowed(self):
1502         return self._allowNegative
1503     def GetAllowNegative(self):
1504         """ (For regularization of property accessors) """
1505         return self.IsNegativeAllowed()
1506
1507     def SetGroupDigits(self, value):
1508         self.SetParameters(groupDigits=value)
1509     def IsGroupingAllowed(self):
1510         return self._groupDigits
1511     def GetGroupDigits(self):
1512         """ (For regularization of property accessors) """
1513         return self.IsGroupingAllowed()
1514
1515     def SetGroupChar(self, value):
1516         self.SetParameters(groupChar=value)
1517     def GetGroupChar(self):
1518         return self._groupChar
1519
1520     def SetDecimalChar(self, value):
1521         self.SetParameters(decimalChar=value)
1522     def GetDecimalChar(self):
1523         return self._decimalChar
1524
1525     def SetSelectOnEntry(self, value):
1526         self.SetParameters(selectOnEntry=value)
1527     def GetSelectOnEntry(self):
1528         return self._selectOnEntry
1529
1530     def SetAutoSize(self, value):
1531         self.SetParameters(autoSize=value)
1532     def GetAutoSize(self):
1533         return self._autoSize
1534
1535
1536     # (Other parameter accessors are inherited from base class)
1537
1538
1539     def _toGUI( self, value, apply_limits = True ):
1540         """
1541         Conversion function used to set the value of the control; does
1542         type and bounds checking and raises ValueError if argument is
1543         not a valid value.
1544         """
1545 ##        dbg('NumCtrl::_toGUI(%s)' % repr(value), indent=1)
1546         if value is None and self.IsNoneAllowed():
1547 ##            dbg(indent=0)
1548             return self._template
1549
1550         elif type(value) in (types.StringType, types.UnicodeType):
1551             value = self._GetNumValue(value)
1552 ##            dbg('cleansed num value: "%s"' % value)
1553             if value == "":
1554                 if self.IsNoneAllowed():
1555 ##                    dbg(indent=0)
1556                     return self._template
1557                 else:
1558 ##                    dbg('exception raised:', e, indent=0)
1559                     raise ValueError ('NumCtrl requires numeric value, passed %s'% repr(value) )
1560             # else...
1561             try:
1562                 if self._fractionWidth or value.find('.') != -1:
1563                     value = float(value)
1564                 else:
1565                     value = long(value)
1566             except Exception, e:
1567 ##                dbg('exception raised:', e, indent=0)
1568                 raise ValueError ('NumCtrl requires numeric value, passed %s'% repr(value) )
1569
1570         elif type(value) not in (types.IntType, types.LongType, types.FloatType):
1571 ##            dbg(indent=0)
1572             raise ValueError (
1573                 'NumCtrl requires numeric value, passed %s'% repr(value) )
1574
1575         if not self._allowNegative and value < 0:
1576             raise ValueError (
1577                 'control configured to disallow negative values, passed %s'% repr(value) )
1578
1579         if self.IsLimited() and apply_limits:
1580             min = self.GetMin()
1581             max = self.GetMax()
1582             if not min is None and value < min:
1583 ##                dbg(indent=0)
1584                 raise ValueError (
1585                     'value %d is below minimum value of control'% value )
1586             if not max is None and value > max:
1587 ##                dbg(indent=0)
1588                 raise ValueError (
1589                     'value %d exceeds value of control'% value )
1590
1591         adjustwidth = len(self._mask) - (1 * self._useParens * self._signOk)
1592 ##        dbg('len(%s):' % self._mask, len(self._mask))
1593 ##        dbg('adjustwidth - groupSpace:', adjustwidth - self._groupSpace)
1594 ##        dbg('adjustwidth:', adjustwidth)
1595         if self._fractionWidth == 0:
1596             s = str(long(value)).rjust(self._integerWidth)
1597         else:
1598             format = '%' + '%d.%df' % (self._integerWidth+self._fractionWidth+1, self._fractionWidth)
1599             s = format % float(value)
1600 ##        dbg('s:"%s"' % s, 'len(s):', len(s))
1601         if len(s) > (adjustwidth - self._groupSpace):
1602 ##            dbg(indent=0)
1603             raise ValueError ('value %s exceeds the integer width of the control (%d)' % (s, self._integerWidth))
1604         elif s[0] not in ('-', ' ') and self._allowNegative and len(s) == (adjustwidth - self._groupSpace):
1605 ##            dbg(indent=0)
1606             raise ValueError ('value %s exceeds the integer width of the control (%d)' % (s, self._integerWidth))
1607
1608         s = s.rjust(adjustwidth).replace('.', self._decimalChar)
1609         if self._signOk and self._useParens:
1610             if s.find('-') != -1:
1611                 s = s.replace('-', '(') + ')'
1612             else:
1613                 s += ' '
1614 ##        dbg('returned: "%s"' % s, indent=0)
1615         return s
1616
1617
1618     def _fromGUI( self, value ):
1619         """
1620         Conversion function used in getting the value of the control.
1621         """
1622 ##        dbg(suspend=0)
1623 ##        dbg('NumCtrl::_fromGUI(%s)' % value, indent=1)
1624         # One or more of the underlying text control implementations
1625         # issue an intermediate EVT_TEXT when replacing the control's
1626         # value, where the intermediate value is an empty string.
1627         # So, to ensure consistency and to prevent spurious ValueErrors,
1628         # we make the following test, and react accordingly:
1629         #
1630         if value.strip() == '':
1631             if not self.IsNoneAllowed():
1632 ##                dbg('empty value; not allowed,returning 0', indent = 0)
1633                 if self._fractionWidth:
1634                     return 0.0
1635                 else:
1636                     return 0
1637             else:
1638 ##                dbg('empty value; returning None', indent = 0)
1639                 return None
1640         else:
1641             value = self._GetNumValue(value)
1642 ##            dbg('Num value: "%s"' % value)
1643             if self._fractionWidth:
1644                 try:
1645 ##                    dbg(indent=0)
1646                     return float( value )
1647                 except ValueError:
1648 ##                    dbg("couldn't convert to float; returning None")
1649                     return None
1650                 else:
1651                     raise
1652             else:
1653                 try:
1654 ##                    dbg(indent=0)
1655                     return int( value )
1656                 except ValueError:
1657                     try:
1658 ##                       dbg(indent=0)
1659                        return long( value )
1660                     except ValueError:
1661 ##                       dbg("couldn't convert to long; returning None")
1662                        return None
1663
1664                     else:
1665                        raise
1666                 else:
1667 ##                    dbg('exception occurred; returning None')
1668                     return None
1669
1670
1671     def _Paste( self, value=None, raise_on_invalid=False, just_return_value=False ):
1672         """
1673         Preprocessor for base control paste; if value needs to be right-justified
1674         to fit in control, do so prior to paste:
1675         """
1676 ##        dbg('NumCtrl::_Paste (value = "%s")' % value, indent=1)
1677         if value is None:
1678             paste_text = self._getClipboardContents()
1679         else:
1680             paste_text = value
1681         sel_start, sel_to = self._GetSelection()
1682         orig_sel_start = sel_start
1683         orig_sel_to = sel_to
1684 ##        dbg('selection:', (sel_start, sel_to))
1685         old_value = self._GetValue()
1686
1687         #
1688         field = self._FindField(sel_start)
1689         edit_start, edit_end = field._extent
1690
1691         # handle possibility of groupChar being a space:
1692         newtext = paste_text.lstrip()
1693         lspace_count = len(paste_text) - len(newtext)
1694         paste_text = ' ' * lspace_count  + newtext.replace(self._groupChar, '').replace('(', '-').replace(')','')
1695
1696         if field._insertRight and self._groupDigits:
1697             # want to paste to the left; see if it will fit:
1698             left_text = old_value[edit_start:sel_start].lstrip()
1699 ##            dbg('len(left_text):', len(left_text))
1700 ##            dbg('len(paste_text):', len(paste_text))
1701 ##            dbg('sel_start - (len(left_text) + len(paste_text)) >= edit_start?', sel_start - (len(left_text) + len(paste_text)) >= edit_start)
1702             if sel_start - (len(left_text) + len(paste_text)) >= edit_start:
1703                 # will fit! create effective paste text, and move cursor back to do so:
1704                 paste_text = left_text + paste_text
1705                 sel_start -= len(paste_text)
1706                 sel_start += sel_to - orig_sel_start    # decrease by amount selected
1707             else:
1708 ##                dbg("won't fit left;", 'paste text remains: "%s"' % paste_text)
1709 ##                dbg('adjusted start before accounting for grouping:', sel_start)
1710 ##                dbg('adjusted paste_text before accounting for grouping: "%s"' % paste_text)
1711                 pass
1712             if self._groupDigits and sel_start != orig_sel_start:
1713                 left_len = len(old_value[:sel_to].lstrip())
1714                 # remove group chars from adjusted paste string, and left pad to wipe out
1715                 # old characters, so that selection will remove the right chars, and
1716                 # readjust will do the right thing:
1717                 paste_text = paste_text.replace(self._groupChar,'')
1718                 adjcount = left_len - len(paste_text)
1719                 paste_text = ' ' * adjcount + paste_text
1720                 sel_start = sel_to - len(paste_text)
1721 ##                dbg('adjusted start after accounting for grouping:', sel_start)
1722 ##                dbg('adjusted paste_text after accounting for grouping: "%s"' % paste_text)
1723             self.SetInsertionPoint(sel_to)
1724             self.SetSelection(sel_start, sel_to)
1725
1726         new_text, replace_to = MaskedEditMixin._Paste(self,
1727                                         paste_text,
1728                                         raise_on_invalid=raise_on_invalid,
1729                                         just_return_value=True)
1730         self._SetInsertionPoint(orig_sel_to)
1731         self._SetSelection(orig_sel_start, orig_sel_to)
1732         if not just_return_value and new_text is not None:
1733             if new_text != self._GetValue():
1734                     self.modified = True
1735             if new_text == '':
1736                 self.ClearValue()
1737             else:
1738                 wx.CallAfter(self._SetValue, new_text)
1739                 wx.CallAfter(self._SetInsertionPoint, replace_to)
1740 ##            dbg(indent=0)
1741         else:
1742 ##            dbg(indent=0)
1743             return new_text, replace_to
1744
1745     def _Undo(self, value=None, prev=None):
1746         '''numctrl's undo is more complicated than the base control's, due to
1747         grouping characters; we don't want to consider them when calculating
1748         the undone portion.'''
1749 ##        dbg('NumCtrl::_Undo', indent=1)
1750         if value is None: value = self._GetValue()
1751         if prev is None: prev = self._prevValue
1752         if not self._groupDigits:
1753             ignore, (new_sel_start, new_sel_to) = BaseMaskedTextCtrl._Undo(self, value, prev, just_return_results = True)
1754             self._SetValue(prev)
1755             self._SetInsertionPoint(new_sel_start)
1756             self._SetSelection(new_sel_start, new_sel_to)
1757             self._prevSelection = (new_sel_start, new_sel_to)
1758 ##            dbg('resetting "prev selection" to', self._prevSelection)
1759 ##            dbg(indent=0)
1760             return
1761         # else...
1762         sel_start, sel_to = self._prevSelection
1763         edit_start, edit_end = self._FindFieldExtent(0)
1764
1765         adjvalue = self._GetNumValue(value).rjust(self._masklength)
1766         adjprev  = self._GetNumValue(prev ).rjust(self._masklength)
1767
1768         # move selection to account for "ungrouped" value:
1769         left_text = value[sel_start:].lstrip()
1770         numleftgroups = len(left_text) - len(left_text.replace(self._groupChar, ''))
1771         adjsel_start = sel_start + numleftgroups
1772         right_text = value[sel_to:].lstrip()
1773         numrightgroups = len(right_text) - len(right_text.replace(self._groupChar, ''))
1774         adjsel_to = sel_to + numrightgroups
1775 ##        dbg('adjusting "previous" selection from', (sel_start, sel_to), 'to:', (adjsel_start, adjsel_to))
1776         self._prevSelection = (adjsel_start, adjsel_to)
1777
1778         # determine appropriate selection for ungrouped undo
1779         ignore, (new_sel_start, new_sel_to) = BaseMaskedTextCtrl._Undo(self, adjvalue, adjprev, just_return_results = True)
1780
1781         # adjust new selection based on grouping:
1782         left_len = edit_end - new_sel_start
1783         numleftgroups = left_len / 3
1784         new_sel_start -= numleftgroups
1785         if numleftgroups and left_len % 3 == 0:
1786             new_sel_start += 1
1787
1788         if new_sel_start < self._masklength and prev[new_sel_start] == self._groupChar:
1789             new_sel_start += 1
1790
1791         right_len = edit_end - new_sel_to
1792         numrightgroups = right_len / 3
1793         new_sel_to -= numrightgroups
1794
1795         if new_sel_to and prev[new_sel_to-1] == self._groupChar:
1796             new_sel_to -= 1
1797
1798         if new_sel_start > new_sel_to:
1799             new_sel_to = new_sel_start
1800
1801         # for numbers, we don't care about leading whitespace; adjust selection if
1802         # it includes leading space.
1803         prev_stripped = prev.lstrip()
1804         prev_start = self._masklength - len(prev_stripped)
1805         if new_sel_start < prev_start:
1806             new_sel_start = prev_start
1807
1808 ##        dbg('adjusted selection accounting for grouping:', (new_sel_start, new_sel_to))
1809         self._SetValue(prev)
1810         self._SetInsertionPoint(new_sel_start)
1811         self._SetSelection(new_sel_start, new_sel_to)
1812         self._prevSelection = (new_sel_start, new_sel_to)
1813 ##        dbg('resetting "prev selection" to', self._prevSelection)
1814 ##        dbg(indent=0)
1815
1816 #===========================================================================
1817
1818 if __name__ == '__main__':
1819
1820     import traceback
1821
1822     class myDialog(wx.Dialog):
1823         def __init__(self, parent, id, title,
1824             pos = wx.DefaultPosition, size = wx.DefaultSize,
1825             style = wx.DEFAULT_DIALOG_STYLE ):
1826             wx.Dialog.__init__(self, parent, id, title, pos, size, style)
1827
1828             self.int_ctrl = NumCtrl(self, wx.NewId(), size=(55,20))
1829             self.OK = wx.Button( self, wx.ID_OK, "OK")
1830             self.Cancel = wx.Button( self, wx.ID_CANCEL, "Cancel")
1831
1832             vs = wx.BoxSizer( wx.VERTICAL )
1833             vs.Add( self.int_ctrl, 0, wx.ALIGN_CENTRE|wx.ALL, 5 )
1834             hs = wx.BoxSizer( wx.HORIZONTAL )
1835             hs.Add( self.OK, 0, wx.ALIGN_CENTRE|wx.ALL, 5 )
1836             hs.Add( self.Cancel, 0, wx.ALIGN_CENTRE|wx.ALL, 5 )
1837             vs.Add(hs, 0, wx.ALIGN_CENTRE|wx.ALL, 5 )
1838
1839             self.SetAutoLayout( True )
1840             self.SetSizer( vs )
1841             vs.Fit( self )
1842             vs.SetSizeHints( self )
1843             self.Bind(EVT_NUM, self.OnChange, self.int_ctrl)
1844
1845         def OnChange(self, event):
1846             print 'value now', event.GetValue()
1847
1848     class TestApp(wx.App):
1849         def OnInit(self):
1850             try:
1851                 self.frame = wx.Frame(None, -1, "Test", (20,20), (120,100)  )
1852                 self.panel = wx.Panel(self.frame, -1)
1853                 button = wx.Button(self.panel, -1, "Push Me", (20, 20))
1854                 self.Bind(wx.EVT_BUTTON, self.OnClick, button)
1855             except:
1856                 traceback.print_exc()
1857                 return False
1858             return True
1859
1860         def OnClick(self, event):
1861             dlg = myDialog(self.panel, -1, "test NumCtrl")
1862             dlg.int_ctrl.SetValue(501)
1863             dlg.int_ctrl.SetInsertionPoint(1)
1864             dlg.int_ctrl.SetSelection(1,2)
1865             rc = dlg.ShowModal()
1866             print 'final value', dlg.int_ctrl.GetValue()
1867             del dlg
1868             self.frame.Destroy()
1869
1870         def Show(self):
1871             self.frame.Show(True)
1872
1873     try:
1874         app = TestApp(0)
1875         app.Show()
1876         app.MainLoop()
1877     except:
1878         traceback.print_exc()
1879
1880 __i=0
1881 ## To-Do's:
1882 ## =============================##
1883 ##   1. Add support for printf-style format specification.
1884 ##   2. Add option for repositioning on 'illegal' insertion point.
1885 ##
1886 ## Version 1.4
1887 ##   1. In response to user request, added limitOnFieldChange feature, so that
1888 ##      out-of-bounds values can be temporarily added to the control, but should
1889 ##      navigation be attempted out of an invalid field, it will not navigate,
1890 ##      and if focus is lost on a control so limited with an invalid value, it
1891 ##      will change the value to the nearest bound.
1892 ##
1893 ## Version 1.3
1894 ##   1. fixed to allow space for a group char.
1895 ##
1896 ## Version 1.2
1897 ##   1. Allowed select/replace digits.
1898 ##   2. Fixed undo to ignore grouping chars.
1899 ##
1900 ## Version 1.1
1901 ##   1. Fixed .SetIntegerWidth() and .SetFractionWidth() functions.
1902 ##   2. Added autoSize parameter, to allow manual sizing of the control.
1903 ##   3. Changed inheritance to use wxBaseMaskedTextCtrl, to remove exposure of
1904 ##      nonsensical parameter methods from the control, so it will work
1905 ##      properly with Boa.
1906 ##   4. Fixed allowNone bug found by user sameerc1@grandecom.net
1907 ##