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