]> git.saurik.com Git - wxWidgets.git/blob - wxPython/wx/lib/masked/maskededit.py
Just to be sure...
[wxWidgets.git] / wxPython / wx / lib / masked / maskededit.py
1 #----------------------------------------------------------------------------
2 # Name: maskededit.py
3 # Authors: Jeff Childers, Will Sadkin
4 # Email: jchilders_98@yahoo.com, wsadkin@nameconnector.com
5 # Created: 02/11/2003
6 # Copyright: (c) 2003 by Jeff Childers, Will Sadkin, 2003
7 # Portions: (c) 2002 by Will Sadkin, 2002-2003
8 # RCS-ID: $Id$
9 # License: wxWindows license
10 #----------------------------------------------------------------------------
11 # NOTE:
12 # MaskedEdit controls are based on a suggestion made on [wxPython-Users] by
13 # Jason Hihn, and borrows liberally from Will Sadkin's original masked edit
14 # control for time entry, TimeCtrl (which is now rewritten using this
15 # control!).
16 #
17 # MaskedEdit controls do not normally use validators, because they do
18 # careful manipulation of the cursor in the text window on each keystroke,
19 # and validation is cursor-position specific, so the control intercepts the
20 # key codes before the validator would fire. However, validators can be
21 # provided to do data transfer to the controls.
22 #
23 #----------------------------------------------------------------------------
24 #
25 # This file now contains the bulk of the logic behind all masked controls,
26 # the MaskedEditMixin class, the Field class, and the autoformat codes.
27 #
28 #----------------------------------------------------------------------------
29 #
30 # 03/30/2004 - Will Sadkin (wsadkin@nameconnector.com)
31 #
32 # o Split out TextCtrl, ComboBox and IpAddrCtrl into their own files,
33 # o Reorganized code into masked package
34 #
35 # 12/09/2003 - Jeff Grimmett (grimmtooth@softhome.net)
36 #
37 # o Updated for wx namespace. No guarantees. This is one huge file.
38 #
39 # 12/13/2003 - Jeff Grimmett (grimmtooth@softhome.net)
40 #
41 # o Missed wx.DateTime stuff earlier.
42 #
43 # 12/20/2003 - Jeff Grimmett (grimmtooth@softhome.net)
44 #
45 # o MaskedEditMixin -> MaskedEditMixin
46 # o wxMaskedTextCtrl -> maskedTextCtrl
47 # o wxMaskedComboBoxSelectEvent -> MaskedComboBoxSelectEvent
48 # o wxMaskedComboBox -> MaskedComboBox
49 # o wxIpAddrCtrl -> IpAddrCtrl
50 # o wxTimeCtrl -> TimeCtrl
51 #
52
53 """\
54 <b>Masked Edit Overview:
55 =====================</b>
56 <b>masked.TextCtrl</b>
57 is a sublassed text control that can carefully control the user's input
58 based on a mask string you provide.
59
60 General usage example:
61 control = masked.TextCtrl( win, -1, '', mask = '(###) ###-####')
62
63 The example above will create a text control that allows only numbers to be
64 entered and then only in the positions indicated in the mask by the # sign.
65
66 <b>masked.ComboBox</b>
67 is a similar subclass of wxComboBox that allows the same sort of masking,
68 but also can do auto-complete of values, and can require the value typed
69 to be in the list of choices to be colored appropriately.
70
71 <b>masked.Ctrl</b>
72 is actually a factory function for several types of masked edit controls:
73
74 <b>masked.TextCtrl</b> - standard masked edit text box
75 <b>masked.ComboBox</b> - adds combobox capabilities
76 <b>masked.IpAddrCtrl</b> - adds special semantics for IP address entry
77 <b>masked.TimeCtrl</b> - special subclass handling lots of types as values
78 <b>masked.NumCtrl</b> - special subclass handling numeric values
79
80 It works by looking for a <b><i>controlType</i></b> parameter in the keyword
81 arguments of the control, to determine what kind of instance to return.
82 If not specified as a keyword argument, the default control type returned
83 will be masked.TextCtrl.
84
85 Each of the above classes has its own set of arguments, but masked.Ctrl
86 provides a single "unified" interface for masked controls. Those for
87 masked.TextCtrl, masked.ComboBox and masked.IpAddrCtrl are all documented
88 below; the others have their own demo pages and interface descriptions.
89 (See end of following discussion for how to configure the wx.MaskedCtrl()
90 to select the above control types.)
91
92
93 <b>INITILIZATION PARAMETERS
94 ========================
95 mask=</b>
96 Allowed mask characters and function:
97 Character Function
98 # Allow numeric only (0-9)
99 N Allow letters and numbers (0-9)
100 A Allow uppercase letters only
101 a Allow lowercase letters only
102 C Allow any letter, upper or lower
103 X Allow string.letters, string.punctuation, string.digits
104 &amp; Allow string.punctuation only
105
106
107 These controls define these sets of characters using string.letters,
108 string.uppercase, etc. These sets are affected by the system locale
109 setting, so in order to have the masked controls accept characters
110 that are specific to your users' language, your application should
111 set the locale.
112 For example, to allow international characters to be used in the
113 above masks, you can place the following in your code as part of
114 your application's initialization code:
115
116 import locale
117 locale.setlocale(locale.LC_ALL, '')
118
119
120 Using these mask characters, a variety of template masks can be built. See
121 the demo for some other common examples include date+time, social security
122 number, etc. If any of these characters are needed as template rather
123 than mask characters, they can be escaped with \, ie. \N means "literal N".
124 (use \\ for literal backslash, as in: r'CCC\\NNN'.)
125
126
127 <b>Note:</b>
128 Masks containing only # characters and one optional decimal point
129 character are handled specially, as "numeric" controls. Such
130 controls have special handling for typing the '-' key, handling
131 the "decimal point" character as truncating the integer portion,
132 optionally allowing grouping characters and so forth.
133 There are several parameters and format codes that only make sense
134 when combined with such masks, eg. groupChar, decimalChar, and so
135 forth (see below). These allow you to construct reasonable
136 numeric entry controls.
137
138 <b>Note:</b>
139 Changing the mask for a control deletes any previous field classes
140 (and any associated validation or formatting constraints) for them.
141
142 <b>useFixedWidthFont=</b>
143 By default, masked edit controls use a fixed width font, so that
144 the mask characters are fixed within the control, regardless of
145 subsequent modifications to the value. Set to False if having
146 the control font be the same as other controls is required.
147
148
149 <b>formatcodes=</b>
150 These other properties can be passed to the class when instantiating it:
151 Formatcodes are specified as a string of single character formatting
152 codes that modify behavior of the control:
153 _ Allow spaces
154 ! Force upper
155 ^ Force lower
156 R Right-align field(s)
157 r Right-insert in field(s) (implies R)
158 &lt; Stay in field until explicit navigation out of it
159
160 &gt; Allow insert/delete within partially filled fields (as
161 opposed to the default "overwrite" mode for fixed-width
162 masked edit controls.) This allows single-field controls
163 or each field within a multi-field control to optionally
164 behave more like standard text controls.
165 (See EMAIL or phone number autoformat examples.)
166
167 <i>Note: This also governs whether backspace/delete operations
168 shift contents of field to right of cursor, or just blank the
169 erased section.
170
171 Also, when combined with 'r', this indicates that the field
172 or control allows right insert anywhere within the current
173 non-empty value in the field. (Otherwise right-insert behavior
174 is only performed to when the entire right-insertable field is
175 selected or the cursor is at the right edge of the field.</i>
176
177
178 , Allow grouping character in integer fields of numeric controls
179 and auto-group/regroup digits (if the result fits) when leaving
180 such a field. (If specified, .SetValue() will attempt to
181 auto-group as well.)
182 ',' is also the default grouping character. To change the
183 grouping character and/or decimal character, use the groupChar
184 and decimalChar parameters, respectively.
185 Note: typing the "decimal point" character in such fields will
186 clip the value to that left of the cursor for integer
187 fields of controls with "integer" or "floating point" masks.
188 If the ',' format code is specified, this will also cause the
189 resulting digits to be regrouped properly, using the current
190 grouping character.
191 - Prepend and reserve leading space for sign to mask and allow
192 signed values (negative #s shown in red by default.) Can be
193 used with argument useParensForNegatives (see below.)
194 0 integer fields get leading zeros
195 D Date[/time] field
196 T Time field
197 F Auto-Fit: the control calulates its size from
198 the length of the template mask
199 V validate entered chars against validRegex before allowing them
200 to be entered vs. being allowed by basic mask and then having
201 the resulting value just colored as invalid.
202 (See USSTATE autoformat demo for how this can be used.)
203 S select entire field when navigating to new field
204
205 <b>fillChar=
206 defaultValue=</b>
207 These controls have two options for the initial state of the control.
208 If a blank control with just the non-editable characters showing
209 is desired, simply leave the constructor variable fillChar as its
210 default (' '). If you want some other character there, simply
211 change the fillChar to that value. Note: changing the control's fillChar
212 will implicitly reset all of the fields' fillChars to this value.
213
214 If you need different default characters in each mask position,
215 you can specify a defaultValue parameter in the constructor, or
216 set them for each field individually.
217 This value must satisfy the non-editable characters of the mask,
218 but need not conform to the replaceable characters.
219
220 <b>groupChar=
221 decimalChar=</b>
222 These parameters govern what character is used to group numbers
223 and is used to indicate the decimal point for numeric format controls.
224 The default groupChar is ',', the default decimalChar is '.'
225 By changing these, you can customize the presentation of numbers
226 for your location.
227 eg: formatcodes = ',', groupChar="'" allows 12'345.34
228 formatcodes = ',', groupChar='.', decimalChar=',' allows 12.345,34
229
230 <b>shiftDecimalChar=</b>
231 The default "shiftDecimalChar" (used for "backwards-tabbing" until
232 shift-tab is fixed in wxPython) is '>' (for QUERTY keyboards.) for
233 other keyboards, you may want to customize this, eg '?' for shift ',' on
234 AZERTY keyboards, ':' or ';' for other European keyboards, etc.
235
236 <b>useParensForNegatives=False</b>
237 This option can be used with signed numeric format controls to
238 indicate signs via () rather than '-'.
239
240 <b>autoSelect=False</b>
241 This option can be used to have a field or the control try to
242 auto-complete on each keystroke if choices have been specified.
243
244 <b>autoCompleteKeycodes=[]</b>
245 By default, DownArrow, PageUp and PageDown will auto-complete a
246 partially entered field. Shift-DownArrow, Shift-UpArrow, PageUp
247 and PageDown will also auto-complete, but if the field already
248 contains a matched value, these keys will cycle through the list
249 of choices forward or backward as appropriate. Shift-Up and
250 Shift-Down also take you to the next/previous field after any
251 auto-complete action.
252
253 Additional auto-complete keys can be specified via this parameter.
254 Any keys so specified will act like PageDown.
255
256
257
258 <b>Validating User Input:
259 ======================</b>
260 There are a variety of initialization parameters that are used to validate
261 user input. These parameters can apply to the control as a whole, and/or
262 to individual fields:
263
264 excludeChars= A string of characters to exclude even if otherwise allowed
265 includeChars= A string of characters to allow even if otherwise disallowed
266 validRegex= Use a regular expression to validate the contents of the text box
267 validRange= Pass a rangeas list (low,high) to limit numeric fields/values
268 choices= A list of strings that are allowed choices for the control.
269 choiceRequired= value must be member of choices list
270 compareNoCase= Perform case-insensitive matching when validating against list
271 <i>Note: for masked.ComboBox, this defaults to True.</i>
272 emptyInvalid= Boolean indicating whether an empty value should be considered invalid
273
274 validFunc= A function to call of the form: bool = func(candidate_value)
275 which will return True if the candidate_value satisfies some
276 external criteria for the control in addition to the the
277 other validation, or False if not. (This validation is
278 applied last in the chain of validations.)
279
280 validRequired= Boolean indicating whether or not keys that are allowed by the
281 mask, but result in an invalid value are allowed to be entered
282 into the control. Setting this to True implies that a valid
283 default value is set for the control.
284
285 retainFieldValidation=
286 False by default; if True, this allows individual fields to
287 retain their own validation constraints independently of any
288 subsequent changes to the control's overall parameters.
289
290 validator= Validators are not normally needed for masked controls, because
291 of the nature of the validation and control of input. However,
292 you can supply one to provide data transfer routines for the
293 controls.
294
295
296 <b>Coloring Behavior:
297 ==================</b>
298 The following parameters have been provided to allow you to change the default
299 coloring behavior of the control. These can be set at construction, or via
300 the .SetCtrlParameters() function. Pass a color as string e.g. 'Yellow':
301
302 emptyBackgroundColour= Control Background color when identified as empty. Default=White
303 invalidBackgroundColour= Control Background color when identified as Not valid. Default=Yellow
304 validBackgroundColour= Control Background color when identified as Valid. Default=white
305
306
307 The following parameters control the default foreground color coloring behavior of the
308 control. Pass a color as string e.g. 'Yellow':
309 foregroundColour= Control foreground color when value is not negative. Default=Black
310 signedForegroundColour= Control foreground color when value is negative. Default=Red
311
312
313 <b>Fields:
314 =======</b>
315 Each part of the mask that allows user input is considered a field. The fields
316 are represented by their own class instances. You can specify field-specific
317 constraints by constructing or accessing the field instances for the control
318 and then specifying those constraints via parameters.
319
320 <b>fields=</b>
321 This parameter allows you to specify Field instances containing
322 constraints for the individual fields of a control, eg: local
323 choice lists, validation rules, functions, regexps, etc.
324 It can be either an ordered list or a dictionary. If a list,
325 the fields will be applied as fields 0, 1, 2, etc.
326 If a dictionary, it should be keyed by field index.
327 the values should be a instances of maskededit.Field.
328
329 Any field not represented by the list or dictionary will be
330 implicitly created by the control.
331
332 eg:
333 fields = [ Field(formatcodes='_r'), Field('choices=['a', 'b', 'c']) ]
334 or
335 fields = {
336 1: ( Field(formatcodes='_R', choices=['a', 'b', 'c']),
337 3: ( Field(choices=['01', '02', '03'], choiceRequired=True)
338 }
339
340 The following parameters are available for individual fields, with the
341 same semantics as for the whole control but applied to the field in question:
342
343 fillChar # if set for a field, it will override the control's fillChar for that field
344 groupChar # if set for a field, it will override the control's default
345 defaultValue # sets field-specific default value; overrides any default from control
346 compareNoCase # overrides control's settings
347 emptyInvalid # determines whether field is required to be filled at all times
348 validRequired # if set, requires field to contain valid value
349
350 If any of the above parameters are subsequently specified for the control as a
351 whole, that new value will be propagated to each field, unless the
352 retainFieldValidation control-level parameter is set.
353
354 formatcodes # Augments control's settings
355 excludeChars # ' ' '
356 includeChars # ' ' '
357 validRegex # ' ' '
358 validRange # ' ' '
359 choices # ' ' '
360 choiceRequired # ' ' '
361 validFunc # ' ' '
362
363
364
365 <b>Control Class Functions:
366 ========================
367 .GetPlainValue(value=None)</b>
368 Returns the value specified (or the control's text value
369 not specified) without the formatting text.
370 In the example above, might return phone no='3522640075',
371 whereas control.GetValue() would return '(352) 264-0075'
372 <b>.ClearValue()</b>
373 Returns the control's value to its default, and places the
374 cursor at the beginning of the control.
375 <b>.SetValue()</b>
376 Does "smart replacement" of passed value into the control, as does
377 the .Paste() method. As with other text entry controls, the
378 .SetValue() text replacement begins at left-edge of the control,
379 with missing mask characters inserted as appropriate.
380 .SetValue will also adjust integer, float or date mask entry values,
381 adding commas, auto-completing years, etc. as appropriate.
382 For "right-aligned" numeric controls, it will also now automatically
383 right-adjust any value whose length is less than the width of the
384 control before attempting to set the value.
385 If a value does not follow the format of the control's mask, or will
386 not fit into the control, a ValueError exception will be raised.
387 Eg:
388 mask = '(###) ###-####'
389 .SetValue('1234567890') => '(123) 456-7890'
390 .SetValue('(123)4567890') => '(123) 456-7890'
391 .SetValue('(123)456-7890') => '(123) 456-7890'
392 .SetValue('123/4567-890') => illegal paste; ValueError
393
394 mask = '#{6}.#{2}', formatcodes = '_,-',
395 .SetValue('111') => ' 111 . '
396 .SetValue(' %9.2f' % -111.12345 ) => ' -111.12'
397 .SetValue(' %9.2f' % 1234.00 ) => ' 1,234.00'
398 .SetValue(' %9.2f' % -1234567.12345 ) => insufficient room; ValueError
399
400 mask = '#{6}.#{2}', formatcodes = '_,-R' # will right-adjust value for right-aligned control
401 .SetValue('111') => padded value misalignment ValueError: " 111" will not fit
402 .SetValue('%.2f' % 111 ) => ' 111.00'
403 .SetValue('%.2f' % -111.12345 ) => ' -111.12'
404
405
406 <b>.IsValid(value=None)</b>
407 Returns True if the value specified (or the value of the control
408 if not specified) passes validation tests
409 <b>.IsEmpty(value=None)</b>
410 Returns True if the value specified (or the value of the control
411 if not specified) is equal to an "empty value," ie. all
412 editable characters == the fillChar for their respective fields.
413 <b>.IsDefault(value=None)</b>
414 Returns True if the value specified (or the value of the control
415 if not specified) is equal to the initial value of the control.
416
417 <b>.Refresh()</b>
418 Recolors the control as appropriate to its current settings.
419
420 <b>.SetCtrlParameters(**kwargs)</b>
421 This function allows you to set up and/or change the control parameters
422 after construction; it takes a list of key/value pairs as arguments,
423 where the keys can be any of the mask-specific parameters in the constructor.
424 Eg:
425 ctl = masked.TextCtrl( self, -1 )
426 ctl.SetCtrlParameters( mask='###-####',
427 defaultValue='555-1212',
428 formatcodes='F')
429
430 <b>.GetCtrlParameter(parametername)</b>
431 This function allows you to retrieve the current value of a parameter
432 from the control.
433
434 <b><i>Note:</i></b> Each of the control parameters can also be set using its
435 own Set and Get function. These functions follow a regular form:
436 All of the parameter names start with lower case; for their
437 corresponding Set/Get function, the parameter name is capitalized.
438 Eg: ctl.SetMask('###-####')
439 ctl.SetDefaultValue('555-1212')
440 ctl.GetChoiceRequired()
441 ctl.GetFormatcodes()
442
443 <b><i>Note:</i></b> After any change in parameters, the choices for the
444 control are reevaluated to ensure that they are still legal. If you
445 have large choice lists, it is therefore more efficient to set parameters
446 before setting the choices available.
447
448 <b>.SetFieldParameters(field_index, **kwargs)</b>
449 This function allows you to specify change individual field
450 parameters after construction. (Indices are 0-based.)
451
452 <b>.GetFieldParameter(field_index, parametername)</b>
453 Allows the retrieval of field parameters after construction
454
455
456 The control detects certain common constructions. In order to use the signed feature
457 (negative numbers and coloring), the mask has to be all numbers with optionally one
458 decimal point. Without a decimal (e.g. '######', the control will treat it as an integer
459 value. With a decimal (e.g. '###.##'), the control will act as a floating point control
460 (i.e. press decimal to 'tab' to the decimal position). Pressing decimal in the
461 integer control truncates the value. However, for a true numeric control,
462 masked.NumCtrl provides all this, and true numeric input/output support as well.
463
464
465 Check your controls by calling each control's .IsValid() function and the
466 .IsEmpty() function to determine which controls have been a) filled in and
467 b) filled in properly.
468
469
470 Regular expression validations can be used flexibly and creatively.
471 Take a look at the demo; the zip-code validation succeeds as long as the
472 first five numerals are entered. the last four are optional, but if
473 any are entered, there must be 4 to be valid.
474
475 <B>masked.Ctrl Configuration
476 ==========================</B>
477 masked.Ctrl works by looking for a special <b><i>controlType</i></b>
478 parameter in the variable arguments of the control, to determine
479 what kind of instance to return.
480 controlType can be one of:
481
482 controlTypes.TEXT
483 controlTypes.COMBO
484 controlTypes.IPADDR
485 controlTypes.TIME
486 controlTypes.NUMBER
487
488 These constants are also available individually, ie, you can
489 use either of the following:
490
491 from wxPython.wx.lib.masked import MaskedCtrl, controlTypes
492 from wxPython.wx.lib.masked import MaskedCtrl, COMBO, TEXT, NUMBER, IPADDR
493
494 If not specified as a keyword argument, the default controlType is
495 controlTypes.TEXT.
496 """
497
498 """
499 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
500 DEVELOPER COMMENTS:
501
502 Naming Conventions
503 ------------------
504 All methods of the Mixin that are not meant to be exposed to the external
505 interface are prefaced with '_'. Those functions that are primarily
506 intended to be internal subroutines subsequently start with a lower-case
507 letter; those that are primarily intended to be used and/or overridden
508 by derived subclasses start with a capital letter.
509
510 The following methods must be used and/or defined when deriving a control
511 from MaskedEditMixin. NOTE: if deriving from a *masked edit* control
512 (eg. class IpAddrCtrl(masked.TextCtrl) ), then this is NOT necessary,
513 as it's already been done for you in the base class.
514
515 ._SetInitialValue()
516 This function must be called after the associated base
517 control has been initialized in the subclass __init__
518 function. It sets the initial value of the control,
519 either to the value specified if non-empty, the
520 default value if specified, or the "template" for
521 the empty control as necessary. It will also set/reset
522 the font if necessary and apply formatting to the
523 control at this time.
524
525 ._GetSelection()
526 REQUIRED
527 Each class derived from MaskedEditMixin must define
528 the function for getting the start and end of the
529 current text selection. The reason for this is
530 that not all controls have the same function name for
531 doing this; eg. wx.TextCtrl uses .GetSelection(),
532 whereas we had to write a .GetMark() function for
533 wxComboBox, because .GetSelection() for the control
534 gets the currently selected list item from the combo
535 box, and the control doesn't (yet) natively provide
536 a means of determining the text selection.
537 ._SetSelection()
538 REQUIRED
539 Similarly to _GetSelection, each class derived from
540 MaskedEditMixin must define the function for setting
541 the start and end of the current text selection.
542 (eg. .SetSelection() for masked.TextCtrl, and .SetMark() for
543 masked.ComboBox.
544
545 ._GetInsertionPoint()
546 ._SetInsertionPoint()
547 REQUIRED
548 For consistency, and because the mixin shouldn't rely
549 on fixed names for any manipulations it does of any of
550 the base controls, we require each class derived from
551 MaskedEditMixin to define these functions as well.
552
553 ._GetValue()
554 ._SetValue() REQUIRED
555 Each class derived from MaskedEditMixin must define
556 the functions used to get and set the raw value of the
557 control.
558 This is necessary so that recursion doesn't take place
559 when setting the value, and so that the mixin can
560 call the appropriate function after doing all its
561 validation and manipulation without knowing what kind
562 of base control it was mixed in with. To handle undo
563 functionality, the ._SetValue() must record the current
564 selection prior to setting the value.
565
566 .Cut()
567 .Paste()
568 .Undo()
569 .SetValue() REQUIRED
570 Each class derived from MaskedEditMixin must redefine
571 these functions to call the _Cut(), _Paste(), _Undo()
572 and _SetValue() methods, respectively for the control,
573 so as to prevent programmatic corruption of the control's
574 value. This must be done in each derivation, as the
575 mixin cannot itself override a member of a sibling class.
576
577 ._Refresh() REQUIRED
578 Each class derived from MaskedEditMixin must define
579 the function used to refresh the base control.
580
581 .Refresh() REQUIRED
582 Each class derived from MaskedEditMixin must redefine
583 this function so that it checks the validity of the
584 control (via self._CheckValid) and then refreshes
585 control using the base class method.
586
587 ._IsEditable() REQUIRED
588 Each class derived from MaskedEditMixin must define
589 the function used to determine if the base control is
590 editable or not. (For masked.ComboBox, this has to
591 be done with code, rather than specifying the proper
592 function in the base control, as there isn't one...)
593 ._CalcSize() REQUIRED
594 Each class derived from MaskedEditMixin must define
595 the function used to determine how wide the control
596 should be given the mask. (The mixin function
597 ._calcSize() provides a baseline estimate.)
598
599
600 Event Handling
601 --------------
602 Event handlers are "chained", and MaskedEditMixin usually
603 swallows most of the events it sees, thereby preventing any other
604 handlers from firing in the chain. It is therefore required that
605 each class derivation using the mixin to have an option to hook up
606 the event handlers itself or forego this operation and let a
607 subclass of the masked control do so. For this reason, each
608 subclass should probably include the following code:
609
610 if setupEventHandling:
611 ## Setup event handlers
612 EVT_SET_FOCUS( self, self._OnFocus ) ## defeat automatic full selection
613 EVT_KILL_FOCUS( self, self._OnKillFocus ) ## run internal validator
614 EVT_LEFT_DCLICK(self, self._OnDoubleClick) ## select field under cursor on dclick
615 EVT_RIGHT_UP(self, self._OnContextMenu ) ## bring up an appropriate context menu
616 EVT_KEY_DOWN( self, self._OnKeyDown ) ## capture control events not normally seen, eg ctrl-tab.
617 EVT_CHAR( self, self._OnChar ) ## handle each keypress
618 EVT_TEXT( self, self.GetId(), self._OnTextChange ) ## color control appropriately & keep
619 ## track of previous value for undo
620
621 where setupEventHandling is an argument to its constructor.
622
623 These 5 handlers must be "wired up" for the masked edit
624 controls to provide default behavior. (The setupEventHandling
625 is an argument to masked.TextCtrl and masked.ComboBox, so
626 that controls derived from *them* may replace one of these
627 handlers if they so choose.)
628
629 If your derived control wants to preprocess events before
630 taking action, it should then set up the event handling itself,
631 so it can be first in the event handler chain.
632
633
634 The following routines are available to facilitate changing
635 the default behavior of masked edit controls:
636
637 ._SetKeycodeHandler(keycode, func)
638 ._SetKeyHandler(char, func)
639 Use to replace default handling for any given keycode.
640 func should take the key event as argument and return
641 False if no further action is required to handle the
642 key. Eg:
643 self._SetKeycodeHandler(WXK_UP, self.IncrementValue)
644 self._SetKeyHandler('-', self._OnChangeSign)
645
646 "Navigation" keys are assumed to change the cursor position, and
647 therefore don't cause automatic motion of the cursor as insertable
648 characters do.
649
650 ._AddNavKeycode(keycode, handler=None)
651 ._AddNavKey(char, handler=None)
652 Allows controls to specify other keys (and optional handlers)
653 to be treated as navigational characters. (eg. '.' in IpAddrCtrl)
654
655 ._GetNavKeycodes() Returns the current list of navigational keycodes.
656
657 ._SetNavKeycodes(key_func_tuples)
658 Allows replacement of the current list of keycode
659 processed as navigation keys, and bind associated
660 optional keyhandlers. argument is a list of key/handler
661 tuples. Passing a value of None for the handler in a
662 given tuple indicates that default processing for the key
663 is desired.
664
665 ._FindField(pos) Returns the Field object associated with this position
666 in the control.
667
668 ._FindFieldExtent(pos, getslice=False, value=None)
669 Returns edit_start, edit_end of the field corresponding
670 to the specified position within the control, and
671 optionally also returns the current contents of that field.
672 If value is specified, it will retrieve the slice the corresponding
673 slice from that value, rather than the current value of the
674 control.
675
676 ._AdjustField(pos)
677 This is, the function that gets called for a given position
678 whenever the cursor is adjusted to leave a given field.
679 By default, it adjusts the year in date fields if mask is a date,
680 It can be overridden by a derived class to
681 adjust the value of the control at that time.
682 (eg. IpAddrCtrl reformats the address in this way.)
683
684 ._Change() Called by internal EVT_TEXT handler. Return False to force
685 skip of the normal class change event.
686 ._Keypress(key) Called by internal EVT_CHAR handler. Return False to force
687 skip of the normal class keypress event.
688 ._LostFocus() Called by internal EVT_KILL_FOCUS handler
689
690 ._OnKeyDown(event)
691 This is the default EVT_KEY_DOWN routine; it just checks for
692 "navigation keys", and if event.ControlDown(), it fires the
693 mixin's _OnChar() routine, as such events are not always seen
694 by the "cooked" EVT_CHAR routine.
695
696 ._OnChar(event) This is the main EVT_CHAR handler for the
697 MaskedEditMixin.
698
699 The following routines are used to handle standard actions
700 for control keys:
701 _OnArrow(event) used for arrow navigation events
702 _OnCtrl_A(event) 'select all'
703 _OnCtrl_C(event) 'copy' (uses base control function, as copy is non-destructive)
704 _OnCtrl_S(event) 'save' (does nothing)
705 _OnCtrl_V(event) 'paste' - calls _Paste() method, to do smart paste
706 _OnCtrl_X(event) 'cut' - calls _Cut() method, to "erase" selection
707 _OnCtrl_Z(event) 'undo' - resets value to previous value (if any)
708
709 _OnChangeField(event) primarily used for tab events, but can be
710 used for other keys (eg. '.' in IpAddrCtrl)
711
712 _OnErase(event) used for backspace and delete
713 _OnHome(event)
714 _OnEnd(event)
715
716 The following routine provides a hook back to any class derivations, so that
717 they can react to parameter changes before any value is set/reset as a result of
718 those changes. (eg. masked.ComboBox needs to detect when the choices list is
719 modified, either implicitly or explicitly, so it can reset the base control
720 to have the appropriate choice list *before* the initial value is reset to match.)
721
722 _OnCtrlParametersChanged()
723
724 Accessor Functions
725 ------------------
726 For convenience, each class derived from MaskedEditMixin should
727 define an accessors mixin, so that it exposes only those parameters
728 that make sense for the derivation. This is done with an intermediate
729 level of inheritance, ie:
730
731 class BaseMaskedTextCtrl( TextCtrl, MaskedEditMixin ):
732
733 class TextCtrl( BaseMaskedTextCtrl, MaskedEditAccessorsMixin ):
734 class ComboBox( BaseMaskedComboBox, MaskedEditAccessorsMixin ):
735 class NumCtrl( BaseMaskedTextCtrl, MaskedNumCtrlAccessorsMixin ):
736 class IpAddrCtrl( BaseMaskedTextCtrl, IpAddrCtrlAccessorsMixin ):
737 class TimeCtrl( BaseMaskedTextCtrl, TimeCtrlAccessorsMixin ):
738
739 etc.
740
741 Each accessors mixin defines Get/Set functions for the base class parameters
742 that are appropriate for that derivation.
743 This allows the base classes to be "more generic," exposing the widest
744 set of options, while not requiring derived classes to be so general.
745 """
746
747 import copy
748 import difflib
749 import re
750 import string
751 import types
752
753 import wx
754
755 # jmg 12/9/03 - when we cut ties with Py 2.2 and earlier, this would
756 # be a good place to implement the 2.3 logger class
757 from wx.tools.dbg import Logger
758
759 dbg = Logger()
760 ##dbg(enable=1)
761
762 ## ---------- ---------- ---------- ---------- ---------- ---------- ----------
763
764 ## Constants for identifying control keys and classes of keys:
765
766 WXK_CTRL_A = (ord('A')+1) - ord('A') ## These keys are not already defined in wx
767 WXK_CTRL_C = (ord('C')+1) - ord('A')
768 WXK_CTRL_S = (ord('S')+1) - ord('A')
769 WXK_CTRL_V = (ord('V')+1) - ord('A')
770 WXK_CTRL_X = (ord('X')+1) - ord('A')
771 WXK_CTRL_Z = (ord('Z')+1) - ord('A')
772
773 nav = (
774 wx.WXK_BACK, wx.WXK_LEFT, wx.WXK_RIGHT, wx.WXK_UP, wx.WXK_DOWN, wx.WXK_TAB,
775 wx.WXK_HOME, wx.WXK_END, wx.WXK_RETURN, wx.WXK_PRIOR, wx.WXK_NEXT
776 )
777
778 control = (
779 wx.WXK_BACK, wx.WXK_DELETE, WXK_CTRL_A, WXK_CTRL_C, WXK_CTRL_S, WXK_CTRL_V,
780 WXK_CTRL_X, WXK_CTRL_Z
781 )
782
783
784 ## ---------- ---------- ---------- ---------- ---------- ---------- ----------
785
786 ## Constants for masking. This is where mask characters
787 ## are defined.
788 ## maskchars used to identify valid mask characters from all others
789 ## #- allow numeric 0-9 only
790 ## A- allow uppercase only. Combine with forceupper to force lowercase to upper
791 ## a- allow lowercase only. Combine with forcelower to force upper to lowercase
792 ## X- allow any character (string.letters, string.punctuation, string.digits)
793 ## Note: locale settings affect what "uppercase", lowercase, etc comprise.
794 ##
795 maskchars = ("#","A","a","X","C","N", '&')
796
797 months = '(01|02|03|04|05|06|07|08|09|10|11|12)'
798 charmonths = '(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec|JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC|jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)'
799 charmonths_dict = {'jan': 1, 'feb': 2, 'mar': 3, 'apr': 4, 'may': 5, 'jun': 6,
800 'jul': 7, 'aug': 8, 'sep': 9, 'oct': 10, 'nov': 11, 'dec': 12}
801
802 days = '(01|02|03|04|05|06|07|08|09|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31)'
803 hours = '(0\d| \d|1[012])'
804 milhours = '(00|01|02|03|04|05|06|07|08|09|10|11|12|13|14|15|16|17|18|19|20|21|22|23)'
805 minutes = """(00|01|02|03|04|05|06|07|08|09|10|11|12|13|14|15|\
806 16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32|33|34|35|\
807 36|37|38|39|40|41|42|43|44|45|46|47|48|49|50|51|52|53|54|55|\
808 56|57|58|59)"""
809 seconds = minutes
810 am_pm_exclude = 'BCDEFGHIJKLMNOQRSTUVWXYZ\x8a\x8c\x8e\x9f\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd8\xd9\xda\xdb\xdc\xdd\xde'
811
812 states = "AL,AK,AZ,AR,CA,CO,CT,DE,DC,FL,GA,GU,HI,ID,IL,IN,IA,KS,KY,LA,MA,ME,MD,MI,MN,MS,MO,MT,NE,NV,NH,NJ,NM,NY,NC,ND,OH,OK,OR,PA,PR,RI,SC,SD,TN,TX,UT,VA,VT,VI,WA,WV,WI,WY".split(',')
813
814 state_names = ['Alabama','Alaska','Arizona','Arkansas',
815 'California','Colorado','Connecticut',
816 'Delaware','District of Columbia',
817 'Florida','Georgia','Hawaii',
818 'Idaho','Illinois','Indiana','Iowa',
819 'Kansas','Kentucky','Louisiana',
820 'Maine','Maryland','Massachusetts','Michigan',
821 'Minnesota','Mississippi','Missouri','Montana',
822 'Nebraska','Nevada','New Hampshire','New Jersey',
823 'New Mexico','New York','North Carolina','North Dakokta',
824 'Ohio','Oklahoma','Oregon',
825 'Pennsylvania','Puerto Rico','Rhode Island',
826 'South Carolina','South Dakota',
827 'Tennessee','Texas','Utah',
828 'Vermont','Virginia',
829 'Washington','West Virginia',
830 'Wisconsin','Wyoming']
831
832 ## ---------- ---------- ---------- ---------- ---------- ---------- ----------
833
834 ## The following dictionary defines the current set of autoformats:
835
836 masktags = {
837 "USPHONEFULLEXT": {
838 'mask': "(###) ###-#### x:###",
839 'formatcodes': 'F^->',
840 'validRegex': "^\(\d{3}\) \d{3}-\d{4}",
841 'description': "Phone Number w/opt. ext"
842 },
843 "USPHONETIGHTEXT": {
844 'mask': "###-###-#### x:###",
845 'formatcodes': 'F^->',
846 'validRegex': "^\d{3}-\d{3}-\d{4}",
847 'description': "Phone Number\n (w/hyphens and opt. ext)"
848 },
849 "USPHONEFULL": {
850 'mask': "(###) ###-####",
851 'formatcodes': 'F^->',
852 'validRegex': "^\(\d{3}\) \d{3}-\d{4}",
853 'description': "Phone Number only"
854 },
855 "USPHONETIGHT": {
856 'mask': "###-###-####",
857 'formatcodes': 'F^->',
858 'validRegex': "^\d{3}-\d{3}-\d{4}",
859 'description': "Phone Number\n(w/hyphens)"
860 },
861 "USSTATE": {
862 'mask': "AA",
863 'formatcodes': 'F!V',
864 'validRegex': "([ACDFGHIKLMNOPRSTUVW] |%s)" % string.join(states,'|'),
865 'choices': states,
866 'choiceRequired': True,
867 'description': "US State Code"
868 },
869 "USSTATENAME": {
870 'mask': "ACCCCCCCCCCCCCCCCCCC",
871 'formatcodes': 'F_',
872 'validRegex': "([ACDFGHIKLMNOPRSTUVW] |%s)" % string.join(state_names,'|'),
873 'choices': state_names,
874 'choiceRequired': True,
875 'description': "US State Name"
876 },
877
878 "USDATETIMEMMDDYYYY/HHMMSS": {
879 'mask': "##/##/#### ##:##:## AM",
880 'excludeChars': am_pm_exclude,
881 'formatcodes': 'DF!',
882 'validRegex': '^' + months + '/' + days + '/' + '\d{4} ' + hours + ':' + minutes + ':' + seconds + ' (A|P)M',
883 'description': "US Date + Time"
884 },
885 "USDATETIMEMMDDYYYY-HHMMSS": {
886 'mask': "##-##-#### ##:##:## AM",
887 'excludeChars': am_pm_exclude,
888 'formatcodes': 'DF!',
889 'validRegex': '^' + months + '-' + days + '-' + '\d{4} ' + hours + ':' + minutes + ':' + seconds + ' (A|P)M',
890 'description': "US Date + Time\n(w/hypens)"
891 },
892 "USDATE24HRTIMEMMDDYYYY/HHMMSS": {
893 'mask': "##/##/#### ##:##:##",
894 'formatcodes': 'DF',
895 'validRegex': '^' + months + '/' + days + '/' + '\d{4} ' + milhours + ':' + minutes + ':' + seconds,
896 'description': "US Date + 24Hr (Military) Time"
897 },
898 "USDATE24HRTIMEMMDDYYYY-HHMMSS": {
899 'mask': "##-##-#### ##:##:##",
900 'formatcodes': 'DF',
901 'validRegex': '^' + months + '-' + days + '-' + '\d{4} ' + milhours + ':' + minutes + ':' + seconds,
902 'description': "US Date + 24Hr Time\n(w/hypens)"
903 },
904 "USDATETIMEMMDDYYYY/HHMM": {
905 'mask': "##/##/#### ##:## AM",
906 'excludeChars': am_pm_exclude,
907 'formatcodes': 'DF!',
908 'validRegex': '^' + months + '/' + days + '/' + '\d{4} ' + hours + ':' + minutes + ' (A|P)M',
909 'description': "US Date + Time\n(without seconds)"
910 },
911 "USDATE24HRTIMEMMDDYYYY/HHMM": {
912 'mask': "##/##/#### ##:##",
913 'formatcodes': 'DF',
914 'validRegex': '^' + months + '/' + days + '/' + '\d{4} ' + milhours + ':' + minutes,
915 'description': "US Date + 24Hr Time\n(without seconds)"
916 },
917 "USDATETIMEMMDDYYYY-HHMM": {
918 'mask': "##-##-#### ##:## AM",
919 'excludeChars': am_pm_exclude,
920 'formatcodes': 'DF!',
921 'validRegex': '^' + months + '-' + days + '-' + '\d{4} ' + hours + ':' + minutes + ' (A|P)M',
922 'description': "US Date + Time\n(w/hypens and w/o secs)"
923 },
924 "USDATE24HRTIMEMMDDYYYY-HHMM": {
925 'mask': "##-##-#### ##:##",
926 'formatcodes': 'DF',
927 'validRegex': '^' + months + '-' + days + '-' + '\d{4} ' + milhours + ':' + minutes,
928 'description': "US Date + 24Hr Time\n(w/hyphens and w/o seconds)"
929 },
930 "USDATEMMDDYYYY/": {
931 'mask': "##/##/####",
932 'formatcodes': 'DF',
933 'validRegex': '^' + months + '/' + days + '/' + '\d{4}',
934 'description': "US Date\n(MMDDYYYY)"
935 },
936 "USDATEMMDDYY/": {
937 'mask': "##/##/##",
938 'formatcodes': 'DF',
939 'validRegex': '^' + months + '/' + days + '/\d\d',
940 'description': "US Date\n(MMDDYY)"
941 },
942 "USDATEMMDDYYYY-": {
943 'mask': "##-##-####",
944 'formatcodes': 'DF',
945 'validRegex': '^' + months + '-' + days + '-' +'\d{4}',
946 'description': "MM-DD-YYYY"
947 },
948
949 "EUDATEYYYYMMDD/": {
950 'mask': "####/##/##",
951 'formatcodes': 'DF',
952 'validRegex': '^' + '\d{4}'+ '/' + months + '/' + days,
953 'description': "YYYY/MM/DD"
954 },
955 "EUDATEYYYYMMDD.": {
956 'mask': "####.##.##",
957 'formatcodes': 'DF',
958 'validRegex': '^' + '\d{4}'+ '.' + months + '.' + days,
959 'description': "YYYY.MM.DD"
960 },
961 "EUDATEDDMMYYYY/": {
962 'mask': "##/##/####",
963 'formatcodes': 'DF',
964 'validRegex': '^' + days + '/' + months + '/' + '\d{4}',
965 'description': "DD/MM/YYYY"
966 },
967 "EUDATEDDMMYYYY.": {
968 'mask': "##.##.####",
969 'formatcodes': 'DF',
970 'validRegex': '^' + days + '.' + months + '.' + '\d{4}',
971 'description': "DD.MM.YYYY"
972 },
973 "EUDATEDDMMMYYYY.": {
974 'mask': "##.CCC.####",
975 'formatcodes': 'DF',
976 'validRegex': '^' + days + '.' + charmonths + '.' + '\d{4}',
977 'description': "DD.Month.YYYY"
978 },
979 "EUDATEDDMMMYYYY/": {
980 'mask': "##/CCC/####",
981 'formatcodes': 'DF',
982 'validRegex': '^' + days + '/' + charmonths + '/' + '\d{4}',
983 'description': "DD/Month/YYYY"
984 },
985
986 "EUDATETIMEYYYYMMDD/HHMMSS": {
987 'mask': "####/##/## ##:##:## AM",
988 'excludeChars': am_pm_exclude,
989 'formatcodes': 'DF!',
990 'validRegex': '^' + '\d{4}'+ '/' + months + '/' + days + ' ' + hours + ':' + minutes + ':' + seconds + ' (A|P)M',
991 'description': "YYYY/MM/DD HH:MM:SS"
992 },
993 "EUDATETIMEYYYYMMDD.HHMMSS": {
994 'mask': "####.##.## ##:##:## AM",
995 'excludeChars': am_pm_exclude,
996 'formatcodes': 'DF!',
997 'validRegex': '^' + '\d{4}'+ '.' + months + '.' + days + ' ' + hours + ':' + minutes + ':' + seconds + ' (A|P)M',
998 'description': "YYYY.MM.DD HH:MM:SS"
999 },
1000 "EUDATETIMEDDMMYYYY/HHMMSS": {
1001 'mask': "##/##/#### ##:##:## AM",
1002 'excludeChars': am_pm_exclude,
1003 'formatcodes': 'DF!',
1004 'validRegex': '^' + days + '/' + months + '/' + '\d{4} ' + hours + ':' + minutes + ':' + seconds + ' (A|P)M',
1005 'description': "DD/MM/YYYY HH:MM:SS"
1006 },
1007 "EUDATETIMEDDMMYYYY.HHMMSS": {
1008 'mask': "##.##.#### ##:##:## AM",
1009 'excludeChars': am_pm_exclude,
1010 'formatcodes': 'DF!',
1011 'validRegex': '^' + days + '.' + months + '.' + '\d{4} ' + hours + ':' + minutes + ':' + seconds + ' (A|P)M',
1012 'description': "DD.MM.YYYY HH:MM:SS"
1013 },
1014
1015 "EUDATETIMEYYYYMMDD/HHMM": {
1016 'mask': "####/##/## ##:## AM",
1017 'excludeChars': am_pm_exclude,
1018 'formatcodes': 'DF!',
1019 'validRegex': '^' + '\d{4}'+ '/' + months + '/' + days + ' ' + hours + ':' + minutes + ' (A|P)M',
1020 'description': "YYYY/MM/DD HH:MM"
1021 },
1022 "EUDATETIMEYYYYMMDD.HHMM": {
1023 'mask': "####.##.## ##:## AM",
1024 'excludeChars': am_pm_exclude,
1025 'formatcodes': 'DF!',
1026 'validRegex': '^' + '\d{4}'+ '.' + months + '.' + days + ' ' + hours + ':' + minutes + ' (A|P)M',
1027 'description': "YYYY.MM.DD HH:MM"
1028 },
1029 "EUDATETIMEDDMMYYYY/HHMM": {
1030 'mask': "##/##/#### ##:## AM",
1031 'excludeChars': am_pm_exclude,
1032 'formatcodes': 'DF!',
1033 'validRegex': '^' + days + '/' + months + '/' + '\d{4} ' + hours + ':' + minutes + ' (A|P)M',
1034 'description': "DD/MM/YYYY HH:MM"
1035 },
1036 "EUDATETIMEDDMMYYYY.HHMM": {
1037 'mask': "##.##.#### ##:## AM",
1038 'excludeChars': am_pm_exclude,
1039 'formatcodes': 'DF!',
1040 'validRegex': '^' + days + '.' + months + '.' + '\d{4} ' + hours + ':' + minutes + ' (A|P)M',
1041 'description': "DD.MM.YYYY HH:MM"
1042 },
1043
1044 "EUDATE24HRTIMEYYYYMMDD/HHMMSS": {
1045 'mask': "####/##/## ##:##:##",
1046 'formatcodes': 'DF',
1047 'validRegex': '^' + '\d{4}'+ '/' + months + '/' + days + ' ' + milhours + ':' + minutes + ':' + seconds,
1048 'description': "YYYY/MM/DD 24Hr Time"
1049 },
1050 "EUDATE24HRTIMEYYYYMMDD.HHMMSS": {
1051 'mask': "####.##.## ##:##:##",
1052 'formatcodes': 'DF',
1053 'validRegex': '^' + '\d{4}'+ '.' + months + '.' + days + ' ' + milhours + ':' + minutes + ':' + seconds,
1054 'description': "YYYY.MM.DD 24Hr Time"
1055 },
1056 "EUDATE24HRTIMEDDMMYYYY/HHMMSS": {
1057 'mask': "##/##/#### ##:##:##",
1058 'formatcodes': 'DF',
1059 'validRegex': '^' + days + '/' + months + '/' + '\d{4} ' + milhours + ':' + minutes + ':' + seconds,
1060 'description': "DD/MM/YYYY 24Hr Time"
1061 },
1062 "EUDATE24HRTIMEDDMMYYYY.HHMMSS": {
1063 'mask': "##.##.#### ##:##:##",
1064 'formatcodes': 'DF',
1065 'validRegex': '^' + days + '.' + months + '.' + '\d{4} ' + milhours + ':' + minutes + ':' + seconds,
1066 'description': "DD.MM.YYYY 24Hr Time"
1067 },
1068 "EUDATE24HRTIMEYYYYMMDD/HHMM": {
1069 'mask': "####/##/## ##:##",
1070 'formatcodes': 'DF','validRegex': '^' + '\d{4}'+ '/' + months + '/' + days + ' ' + milhours + ':' + minutes,
1071 'description': "YYYY/MM/DD 24Hr Time\n(w/o seconds)"
1072 },
1073 "EUDATE24HRTIMEYYYYMMDD.HHMM": {
1074 'mask': "####.##.## ##:##",
1075 'formatcodes': 'DF',
1076 'validRegex': '^' + '\d{4}'+ '.' + months + '.' + days + ' ' + milhours + ':' + minutes,
1077 'description': "YYYY.MM.DD 24Hr Time\n(w/o seconds)"
1078 },
1079 "EUDATE24HRTIMEDDMMYYYY/HHMM": {
1080 'mask': "##/##/#### ##:##",
1081 'formatcodes': 'DF',
1082 'validRegex': '^' + days + '/' + months + '/' + '\d{4} ' + milhours + ':' + minutes,
1083 'description': "DD/MM/YYYY 24Hr Time\n(w/o seconds)"
1084 },
1085 "EUDATE24HRTIMEDDMMYYYY.HHMM": {
1086 'mask': "##.##.#### ##:##",
1087 'formatcodes': 'DF',
1088 'validRegex': '^' + days + '.' + months + '.' + '\d{4} ' + milhours + ':' + minutes,
1089 'description': "DD.MM.YYYY 24Hr Time\n(w/o seconds)"
1090 },
1091
1092 "TIMEHHMMSS": {
1093 'mask': "##:##:## AM",
1094 'excludeChars': am_pm_exclude,
1095 'formatcodes': 'TF!',
1096 'validRegex': '^' + hours + ':' + minutes + ':' + seconds + ' (A|P)M',
1097 'description': "HH:MM:SS (A|P)M\n(see TimeCtrl)"
1098 },
1099 "TIMEHHMM": {
1100 'mask': "##:## AM",
1101 'excludeChars': am_pm_exclude,
1102 'formatcodes': 'TF!',
1103 'validRegex': '^' + hours + ':' + minutes + ' (A|P)M',
1104 'description': "HH:MM (A|P)M\n(see TimeCtrl)"
1105 },
1106 "24HRTIMEHHMMSS": {
1107 'mask': "##:##:##",
1108 'formatcodes': 'TF',
1109 'validRegex': '^' + milhours + ':' + minutes + ':' + seconds,
1110 'description': "24Hr HH:MM:SS\n(see TimeCtrl)"
1111 },
1112 "24HRTIMEHHMM": {
1113 'mask': "##:##",
1114 'formatcodes': 'TF',
1115 'validRegex': '^' + milhours + ':' + minutes,
1116 'description': "24Hr HH:MM\n(see TimeCtrl)"
1117 },
1118 "USSOCIALSEC": {
1119 'mask': "###-##-####",
1120 'formatcodes': 'F',
1121 'validRegex': "\d{3}-\d{2}-\d{4}",
1122 'description': "Social Sec#"
1123 },
1124 "CREDITCARD": {
1125 'mask': "####-####-####-####",
1126 'formatcodes': 'F',
1127 'validRegex': "\d{4}-\d{4}-\d{4}-\d{4}",
1128 'description': "Credit Card"
1129 },
1130 "EXPDATEMMYY": {
1131 'mask': "##/##",
1132 'formatcodes': "F",
1133 'validRegex': "^" + months + "/\d\d",
1134 'description': "Expiration MM/YY"
1135 },
1136 "USZIP": {
1137 'mask': "#####",
1138 'formatcodes': 'F',
1139 'validRegex': "^\d{5}",
1140 'description': "US 5-digit zip code"
1141 },
1142 "USZIPPLUS4": {
1143 'mask': "#####-####",
1144 'formatcodes': 'F',
1145 'validRegex': "\d{5}-(\s{4}|\d{4})",
1146 'description': "US zip+4 code"
1147 },
1148 "PERCENT": {
1149 'mask': "0.##",
1150 'formatcodes': 'F',
1151 'validRegex': "^0.\d\d",
1152 'description': "Percentage"
1153 },
1154 "AGE": {
1155 'mask': "###",
1156 'formatcodes': "F",
1157 'validRegex': "^[1-9]{1} |[1-9][0-9] |1[0|1|2][0-9]",
1158 'description': "Age"
1159 },
1160 "EMAIL": {
1161 'mask': "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
1162 'excludeChars': " \\/*&%$#!+='\"",
1163 'formatcodes': "F>",
1164 'validRegex': "^\w+([\-\.]\w+)*@((([a-zA-Z0-9]+(\-[a-zA-Z0-9]+)*\.)+)[a-zA-Z]{2,4}|\[(\d|\d\d|(1\d\d|2[0-4]\d|25[0-5]))(\.(\d|\d\d|(1\d\d|2[0-4]\d|25[0-5]))){3}\]) *$",
1165 'description': "Email address"
1166 },
1167 "IPADDR": {
1168 'mask': "###.###.###.###",
1169 'formatcodes': 'F_Sr',
1170 'validRegex': "( \d| \d\d|(1\d\d|2[0-4]\d|25[0-5]))(\.( \d| \d\d|(1\d\d|2[0-4]\d|25[0-5]))){3}",
1171 'description': "IP Address\n(see IpAddrCtrl)"
1172 }
1173 }
1174
1175 # build demo-friendly dictionary of descriptions of autoformats
1176 autoformats = []
1177 for key, value in masktags.items():
1178 autoformats.append((key, value['description']))
1179 autoformats.sort()
1180
1181 ## ---------- ---------- ---------- ---------- ---------- ---------- ----------
1182
1183 class Field:
1184 valid_params = {
1185 'index': None, ## which field of mask; set by parent control.
1186 'mask': "", ## mask chars for this field
1187 'extent': (), ## (edit start, edit_end) of field; set by parent control.
1188 'formatcodes': "", ## codes indicating formatting options for the control
1189 'fillChar': ' ', ## used as initial value for each mask position if initial value is not given
1190 'groupChar': ',', ## used with numeric fields; indicates what char groups 3-tuple digits
1191 'decimalChar': '.', ## used with numeric fields; indicates what char separates integer from fraction
1192 'shiftDecimalChar': '>', ## used with numeric fields, indicates what is above the decimal point char on keyboard
1193 'useParensForNegatives': False, ## used with numeric fields, indicates that () should be used vs. - to show negative numbers.
1194 'defaultValue': "", ## use if you want different positional defaults vs. all the same fillChar
1195 'excludeChars': "", ## optional string of chars to exclude even if main mask type does
1196 'includeChars': "", ## optional string of chars to allow even if main mask type doesn't
1197 'validRegex': "", ## optional regular expression to use to validate the control
1198 'validRange': (), ## Optional hi-low range for numerics
1199 'choices': [], ## Optional list for character expressions
1200 'choiceRequired': False, ## If choices supplied this specifies if valid value must be in the list
1201 'compareNoCase': False, ## Optional flag to indicate whether or not to use case-insensitive list search
1202 'autoSelect': False, ## Set to True to try auto-completion on each keystroke:
1203 'validFunc': None, ## Optional function for defining additional, possibly dynamic validation constraints on contrl
1204 'validRequired': False, ## Set to True to disallow input that results in an invalid value
1205 'emptyInvalid': False, ## Set to True to make EMPTY = INVALID
1206 'description': "", ## primarily for autoformats, but could be useful elsewhere
1207 }
1208
1209 # This list contains all parameters that when set at the control level should
1210 # propagate down to each field:
1211 propagating_params = ('fillChar', 'groupChar', 'decimalChar','useParensForNegatives',
1212 'compareNoCase', 'emptyInvalid', 'validRequired')
1213
1214 def __init__(self, **kwargs):
1215 """
1216 This is the "constructor" for setting up parameters for fields.
1217 a field_index of -1 is used to indicate "the entire control."
1218 """
1219 #### dbg('Field::Field', indent=1)
1220 # Validate legitimate set of parameters:
1221 for key in kwargs.keys():
1222 if key not in Field.valid_params.keys():
1223 #### dbg(indent=0)
1224 raise TypeError('invalid parameter "%s"' % (key))
1225
1226 # Set defaults for each parameter for this instance, and fully
1227 # populate initial parameter list for configuration:
1228 for key, value in Field.valid_params.items():
1229 setattr(self, '_' + key, copy.copy(value))
1230 if not kwargs.has_key(key):
1231 kwargs[key] = copy.copy(value)
1232
1233 self._autoCompleteIndex = -1
1234 self._SetParameters(**kwargs)
1235 self._ValidateParameters(**kwargs)
1236
1237 #### dbg(indent=0)
1238
1239
1240 def _SetParameters(self, **kwargs):
1241 """
1242 This function can be used to set individual or multiple parameters for
1243 a masked edit field parameter after construction.
1244 """
1245 ## dbg(suspend=1)
1246 ## dbg('maskededit.Field::_SetParameters', indent=1)
1247 # Validate keyword arguments:
1248 for key in kwargs.keys():
1249 if key not in Field.valid_params.keys():
1250 ## dbg(indent=0, suspend=0)
1251 raise AttributeError('invalid keyword argument "%s"' % key)
1252
1253 if self._index is not None: dbg('field index:', self._index)
1254 ## dbg('parameters:', indent=1)
1255 for key, value in kwargs.items():
1256 ## dbg('%s:' % key, value)
1257 pass
1258 ## dbg(indent=0)
1259
1260
1261 old_fillChar = self._fillChar # store so we can change choice lists accordingly if it changes
1262
1263 # First, Assign all parameters specified:
1264 for key in Field.valid_params.keys():
1265 if kwargs.has_key(key):
1266 setattr(self, '_' + key, kwargs[key] )
1267
1268 if kwargs.has_key('formatcodes'): # (set/changed)
1269 self._forceupper = '!' in self._formatcodes
1270 self._forcelower = '^' in self._formatcodes
1271 self._groupdigits = ',' in self._formatcodes
1272 self._okSpaces = '_' in self._formatcodes
1273 self._padZero = '0' in self._formatcodes
1274 self._autofit = 'F' in self._formatcodes
1275 self._insertRight = 'r' in self._formatcodes
1276 self._allowInsert = '>' in self._formatcodes
1277 self._alignRight = 'R' in self._formatcodes or 'r' in self._formatcodes
1278 self._moveOnFieldFull = not '<' in self._formatcodes
1279 self._selectOnFieldEntry = 'S' in self._formatcodes
1280
1281 if kwargs.has_key('groupChar'):
1282 self._groupChar = kwargs['groupChar']
1283 if kwargs.has_key('decimalChar'):
1284 self._decimalChar = kwargs['decimalChar']
1285 if kwargs.has_key('shiftDecimalChar'):
1286 self._shiftDecimalChar = kwargs['shiftDecimalChar']
1287
1288 if kwargs.has_key('formatcodes') or kwargs.has_key('validRegex'):
1289 self._regexMask = 'V' in self._formatcodes and self._validRegex
1290
1291 if kwargs.has_key('fillChar'):
1292 self._old_fillChar = old_fillChar
1293 #### dbg("self._old_fillChar: '%s'" % self._old_fillChar)
1294
1295 if kwargs.has_key('mask') or kwargs.has_key('validRegex'): # (set/changed)
1296 self._isInt = isInteger(self._mask)
1297 ## dbg('isInt?', self._isInt, 'self._mask:"%s"' % self._mask)
1298
1299 ## dbg(indent=0, suspend=0)
1300
1301
1302 def _ValidateParameters(self, **kwargs):
1303 """
1304 This function can be used to validate individual or multiple parameters for
1305 a masked edit field parameter after construction.
1306 """
1307 ## dbg(suspend=1)
1308 ## dbg('maskededit.Field::_ValidateParameters', indent=1)
1309 if self._index is not None: dbg('field index:', self._index)
1310 #### dbg('parameters:', indent=1)
1311 ## for key, value in kwargs.items():
1312 #### dbg('%s:' % key, value)
1313 #### dbg(indent=0)
1314 #### dbg("self._old_fillChar: '%s'" % self._old_fillChar)
1315
1316 # Verify proper numeric format params:
1317 if self._groupdigits and self._groupChar == self._decimalChar:
1318 ## dbg(indent=0, suspend=0)
1319 raise AttributeError("groupChar '%s' cannot be the same as decimalChar '%s'" % (self._groupChar, self._decimalChar))
1320
1321
1322 # Now go do validation, semantic and inter-dependency parameter processing:
1323 if kwargs.has_key('choices') or kwargs.has_key('compareNoCase') or kwargs.has_key('choiceRequired'): # (set/changed)
1324
1325 self._compareChoices = [choice.strip() for choice in self._choices]
1326
1327 if self._compareNoCase and self._choices:
1328 self._compareChoices = [item.lower() for item in self._compareChoices]
1329
1330 if kwargs.has_key('choices'):
1331 self._autoCompleteIndex = -1
1332
1333
1334 if kwargs.has_key('validRegex'): # (set/changed)
1335 if self._validRegex:
1336 try:
1337 if self._compareNoCase:
1338 self._filter = re.compile(self._validRegex, re.IGNORECASE)
1339 else:
1340 self._filter = re.compile(self._validRegex)
1341 except:
1342 ## dbg(indent=0, suspend=0)
1343 raise TypeError('%s: validRegex "%s" not a legal regular expression' % (str(self._index), self._validRegex))
1344 else:
1345 self._filter = None
1346
1347 if kwargs.has_key('validRange'): # (set/changed)
1348 self._hasRange = False
1349 self._rangeHigh = 0
1350 self._rangeLow = 0
1351 if self._validRange:
1352 if type(self._validRange) != types.TupleType or len( self._validRange )!= 2 or self._validRange[0] > self._validRange[1]:
1353 ## dbg(indent=0, suspend=0)
1354 raise TypeError('%s: validRange %s parameter must be tuple of form (a,b) where a <= b'
1355 % (str(self._index), repr(self._validRange)) )
1356
1357 self._hasRange = True
1358 self._rangeLow = self._validRange[0]
1359 self._rangeHigh = self._validRange[1]
1360
1361 if kwargs.has_key('choices') or (len(self._choices) and len(self._choices[0]) != len(self._mask)): # (set/changed)
1362 self._hasList = False
1363 if self._choices and type(self._choices) not in (types.TupleType, types.ListType):
1364 ## dbg(indent=0, suspend=0)
1365 raise TypeError('%s: choices must be a sequence of strings' % str(self._index))
1366 elif len( self._choices) > 0:
1367 for choice in self._choices:
1368 if type(choice) not in (types.StringType, types.UnicodeType):
1369 ## dbg(indent=0, suspend=0)
1370 raise TypeError('%s: choices must be a sequence of strings' % str(self._index))
1371
1372 length = len(self._mask)
1373 ## dbg('len(%s)' % self._mask, length, 'len(self._choices):', len(self._choices), 'length:', length, 'self._alignRight?', self._alignRight)
1374 if len(self._choices) and length:
1375 if len(self._choices[0]) > length:
1376 # changed mask without respecifying choices; readjust the width as appropriate:
1377 self._choices = [choice.strip() for choice in self._choices]
1378 if self._alignRight:
1379 self._choices = [choice.rjust( length ) for choice in self._choices]
1380 else:
1381 self._choices = [choice.ljust( length ) for choice in self._choices]
1382 ## dbg('aligned choices:', self._choices)
1383
1384 if hasattr(self, '_template'):
1385 # Verify each choice specified is valid:
1386 for choice in self._choices:
1387 if self.IsEmpty(choice) and not self._validRequired:
1388 # allow empty values even if invalid, (just colored differently)
1389 continue
1390 if not self.IsValid(choice):
1391 ## dbg(indent=0, suspend=0)
1392 raise ValueError('%s: "%s" is not a valid value for the control as specified.' % (str(self._index), choice))
1393 self._hasList = True
1394
1395 #### dbg("kwargs.has_key('fillChar')?", kwargs.has_key('fillChar'), "len(self._choices) > 0?", len(self._choices) > 0)
1396 #### dbg("self._old_fillChar:'%s'" % self._old_fillChar, "self._fillChar: '%s'" % self._fillChar)
1397 if kwargs.has_key('fillChar') and len(self._choices) > 0:
1398 if kwargs['fillChar'] != ' ':
1399 self._choices = [choice.replace(' ', self._fillChar) for choice in self._choices]
1400 else:
1401 self._choices = [choice.replace(self._old_fillChar, self._fillChar) for choice in self._choices]
1402 ## dbg('updated choices:', self._choices)
1403
1404
1405 if kwargs.has_key('autoSelect') and kwargs['autoSelect']:
1406 if not self._hasList:
1407 ## dbg('no list to auto complete; ignoring "autoSelect=True"')
1408 self._autoSelect = False
1409
1410 # reset field validity assumption:
1411 self._valid = True
1412 ## dbg(indent=0, suspend=0)
1413
1414
1415 def _GetParameter(self, paramname):
1416 """
1417 Routine for retrieving the value of any given parameter
1418 """
1419 if Field.valid_params.has_key(paramname):
1420 return getattr(self, '_' + paramname)
1421 else:
1422 TypeError('Field._GetParameter: invalid parameter "%s"' % key)
1423
1424
1425 def IsEmpty(self, slice):
1426 """
1427 Indicates whether the specified slice is considered empty for the
1428 field.
1429 """
1430 ## dbg('Field::IsEmpty("%s")' % slice, indent=1)
1431 if not hasattr(self, '_template'):
1432 ## dbg(indent=0)
1433 raise AttributeError('_template')
1434
1435 ## dbg('self._template: "%s"' % self._template)
1436 ## dbg('self._defaultValue: "%s"' % str(self._defaultValue))
1437 if slice == self._template and not self._defaultValue:
1438 ## dbg(indent=0)
1439 return True
1440
1441 elif slice == self._template:
1442 empty = True
1443 for pos in range(len(self._template)):
1444 #### dbg('slice[%(pos)d] != self._fillChar?' %locals(), slice[pos] != self._fillChar[pos])
1445 if slice[pos] not in (' ', self._fillChar):
1446 empty = False
1447 break
1448 ## dbg("IsEmpty? %(empty)d (do all mask chars == fillChar?)" % locals(), indent=0)
1449 return empty
1450 else:
1451 ## dbg("IsEmpty? 0 (slice doesn't match template)", indent=0)
1452 return False
1453
1454
1455 def IsValid(self, slice):
1456 """
1457 Indicates whether the specified slice is considered a valid value for the
1458 field.
1459 """
1460 ## dbg(suspend=1)
1461 ## dbg('Field[%s]::IsValid("%s")' % (str(self._index), slice), indent=1)
1462 valid = True # assume true to start
1463
1464 if self.IsEmpty(slice):
1465 ## dbg(indent=0, suspend=0)
1466 if self._emptyInvalid:
1467 return False
1468 else:
1469 return True
1470
1471 elif self._hasList and self._choiceRequired:
1472 ## dbg("(member of list required)")
1473 # do case-insensitive match on list; strip surrounding whitespace from slice (already done for choices):
1474 if self._fillChar != ' ':
1475 slice = slice.replace(self._fillChar, ' ')
1476 ## dbg('updated slice:"%s"' % slice)
1477 compareStr = slice.strip()
1478
1479 if self._compareNoCase:
1480 compareStr = compareStr.lower()
1481 valid = compareStr in self._compareChoices
1482
1483 elif self._hasRange and not self.IsEmpty(slice):
1484 ## dbg('validating against range')
1485 try:
1486 # allow float as well as int ranges (int comparisons for free.)
1487 valid = self._rangeLow <= float(slice) <= self._rangeHigh
1488 except:
1489 valid = False
1490
1491 elif self._validRegex and self._filter:
1492 ## dbg('validating against regex')
1493 valid = (re.match( self._filter, slice) is not None)
1494
1495 if valid and self._validFunc:
1496 ## dbg('validating against supplied function')
1497 valid = self._validFunc(slice)
1498 ## dbg('valid?', valid, indent=0, suspend=0)
1499 return valid
1500
1501
1502 def _AdjustField(self, slice):
1503 """ 'Fixes' an integer field. Right or left-justifies, as required."""
1504 ## dbg('Field::_AdjustField("%s")' % slice, indent=1)
1505 length = len(self._mask)
1506 #### dbg('length(self._mask):', length)
1507 #### dbg('self._useParensForNegatives?', self._useParensForNegatives)
1508 if self._isInt:
1509 if self._useParensForNegatives:
1510 signpos = slice.find('(')
1511 right_signpos = slice.find(')')
1512 intStr = slice.replace('(', '').replace(')', '') # drop sign, if any
1513 else:
1514 signpos = slice.find('-')
1515 intStr = slice.replace( '-', '' ) # drop sign, if any
1516 right_signpos = -1
1517
1518 intStr = intStr.replace(' ', '') # drop extra spaces
1519 intStr = string.replace(intStr,self._fillChar,"") # drop extra fillchars
1520 intStr = string.replace(intStr,"-","") # drop sign, if any
1521 intStr = string.replace(intStr, self._groupChar, "") # lose commas/dots
1522 #### dbg('intStr:"%s"' % intStr)
1523 start, end = self._extent
1524 field_len = end - start
1525 if not self._padZero and len(intStr) != field_len and intStr.strip():
1526 intStr = str(long(intStr))
1527 #### dbg('raw int str: "%s"' % intStr)
1528 #### dbg('self._groupdigits:', self._groupdigits, 'self._formatcodes:', self._formatcodes)
1529 if self._groupdigits:
1530 new = ''
1531 cnt = 1
1532 for i in range(len(intStr)-1, -1, -1):
1533 new = intStr[i] + new
1534 if (cnt) % 3 == 0:
1535 new = self._groupChar + new
1536 cnt += 1
1537 if new and new[0] == self._groupChar:
1538 new = new[1:]
1539 if len(new) <= length:
1540 # expanded string will still fit and leave room for sign:
1541 intStr = new
1542 # else... leave it without the commas...
1543
1544 ## dbg('padzero?', self._padZero)
1545 ## dbg('len(intStr):', len(intStr), 'field length:', length)
1546 if self._padZero and len(intStr) < length:
1547 intStr = '0' * (length - len(intStr)) + intStr
1548 if signpos != -1: # we had a sign before; restore it
1549 if self._useParensForNegatives:
1550 intStr = '(' + intStr[1:]
1551 if right_signpos != -1:
1552 intStr += ')'
1553 else:
1554 intStr = '-' + intStr[1:]
1555 elif signpos != -1 and slice[0:signpos].strip() == '': # - was before digits
1556 if self._useParensForNegatives:
1557 intStr = '(' + intStr
1558 if right_signpos != -1:
1559 intStr += ')'
1560 else:
1561 intStr = '-' + intStr
1562 elif right_signpos != -1:
1563 # must have had ')' but '(' was before field; re-add ')'
1564 intStr += ')'
1565 slice = intStr
1566
1567 slice = slice.strip() # drop extra spaces
1568
1569 if self._alignRight: ## Only if right-alignment is enabled
1570 slice = slice.rjust( length )
1571 else:
1572 slice = slice.ljust( length )
1573 if self._fillChar != ' ':
1574 slice = slice.replace(' ', self._fillChar)
1575 ## dbg('adjusted slice: "%s"' % slice, indent=0)
1576 return slice
1577
1578
1579 ## ---------- ---------- ---------- ---------- ---------- ---------- ----------
1580
1581 class MaskedEditMixin:
1582 """
1583 This class allows us to abstract the masked edit functionality that could
1584 be associated with any text entry control. (eg. wx.TextCtrl, wx.ComboBox, etc.)
1585 """
1586 valid_ctrl_params = {
1587 'mask': 'XXXXXXXXXXXXX', ## mask string for formatting this control
1588 'autoformat': "", ## optional auto-format code to set format from masktags dictionary
1589 'fields': {}, ## optional list/dictionary of maskededit.Field class instances, indexed by position in mask
1590 'datestyle': 'MDY', ## optional date style for date-type values. Can trigger autocomplete year
1591 'autoCompleteKeycodes': [], ## Optional list of additional keycodes which will invoke field-auto-complete
1592 'useFixedWidthFont': True, ## Use fixed-width font instead of default for base control
1593 'retainFieldValidation': False, ## Set this to true if setting control-level parameters independently,
1594 ## from field validation constraints
1595 'emptyBackgroundColour': "White",
1596 'validBackgroundColour': "White",
1597 'invalidBackgroundColour': "Yellow",
1598 'foregroundColour': "Black",
1599 'signedForegroundColour': "Red",
1600 'demo': False}
1601
1602
1603 def __init__(self, name = 'MaskedEdit', **kwargs):
1604 """
1605 This is the "constructor" for setting up the mixin variable parameters for the composite class.
1606 """
1607
1608 self.name = name
1609
1610 # set up flag for doing optional things to base control if possible
1611 if not hasattr(self, 'controlInitialized'):
1612 self.controlInitialized = False
1613
1614 # Set internal state var for keeping track of whether or not a character
1615 # action results in a modification of the control, since .SetValue()
1616 # doesn't modify the base control's internal state:
1617 self.modified = False
1618 self._previous_mask = None
1619
1620 # Validate legitimate set of parameters:
1621 for key in kwargs.keys():
1622 if key.replace('Color', 'Colour') not in MaskedEditMixin.valid_ctrl_params.keys() + Field.valid_params.keys():
1623 raise TypeError('%s: invalid parameter "%s"' % (name, key))
1624
1625 ## Set up dictionary that can be used by subclasses to override or add to default
1626 ## behavior for individual characters. Derived subclasses needing to change
1627 ## default behavior for keys can either redefine the default functions for the
1628 ## common keys or add functions for specific keys to this list. Each function
1629 ## added should take the key event as argument, and return False if the key
1630 ## requires no further processing.
1631 ##
1632 ## Initially populated with navigation and function control keys:
1633 self._keyhandlers = {
1634 # default navigation keys and handlers:
1635 wx.WXK_BACK: self._OnErase,
1636 wx.WXK_LEFT: self._OnArrow,
1637 wx.WXK_RIGHT: self._OnArrow,
1638 wx.WXK_UP: self._OnAutoCompleteField,
1639 wx.WXK_DOWN: self._OnAutoCompleteField,
1640 wx.WXK_TAB: self._OnChangeField,
1641 wx.WXK_HOME: self._OnHome,
1642 wx.WXK_END: self._OnEnd,
1643 wx.WXK_RETURN: self._OnReturn,
1644 wx.WXK_PRIOR: self._OnAutoCompleteField,
1645 wx.WXK_NEXT: self._OnAutoCompleteField,
1646
1647 # default function control keys and handlers:
1648 wx.WXK_DELETE: self._OnErase,
1649 WXK_CTRL_A: self._OnCtrl_A,
1650 WXK_CTRL_C: self._OnCtrl_C,
1651 WXK_CTRL_S: self._OnCtrl_S,
1652 WXK_CTRL_V: self._OnCtrl_V,
1653 WXK_CTRL_X: self._OnCtrl_X,
1654 WXK_CTRL_Z: self._OnCtrl_Z,
1655 }
1656
1657 ## bind standard navigational and control keycodes to this instance,
1658 ## so that they can be augmented and/or changed in derived classes:
1659 self._nav = list(nav)
1660 self._control = list(control)
1661
1662 ## Dynamically evaluate and store string constants for mask chars
1663 ## so that locale settings can be made after this module is imported
1664 ## and the controls created after that is done can allow the
1665 ## appropriate characters:
1666 self.maskchardict = {
1667 '#': string.digits,
1668 'A': string.uppercase,
1669 'a': string.lowercase,
1670 'X': string.letters + string.punctuation + string.digits,
1671 'C': string.letters,
1672 'N': string.letters + string.digits,
1673 '&': string.punctuation
1674 }
1675
1676 ## self._ignoreChange is used by MaskedComboBox, because
1677 ## of the hack necessary to determine the selection; it causes
1678 ## EVT_TEXT messages from the combobox to be ignored if set.
1679 self._ignoreChange = False
1680
1681 # These are used to keep track of previous value, for undo functionality:
1682 self._curValue = None
1683 self._prevValue = None
1684
1685 self._valid = True
1686
1687 # Set defaults for each parameter for this instance, and fully
1688 # populate initial parameter list for configuration:
1689 for key, value in MaskedEditMixin.valid_ctrl_params.items():
1690 setattr(self, '_' + key, copy.copy(value))
1691 if not kwargs.has_key(key):
1692 #### dbg('%s: "%s"' % (key, repr(value)))
1693 kwargs[key] = copy.copy(value)
1694
1695 # Create a "field" that holds global parameters for control constraints
1696 self._ctrl_constraints = self._fields[-1] = Field(index=-1)
1697 self.SetCtrlParameters(**kwargs)
1698
1699
1700
1701 def SetCtrlParameters(self, **kwargs):
1702 """
1703 This public function can be used to set individual or multiple masked edit
1704 parameters after construction.
1705 """
1706 ## dbg(suspend=1)
1707 ## dbg('MaskedEditMixin::SetCtrlParameters', indent=1)
1708 #### dbg('kwargs:', indent=1)
1709 ## for key, value in kwargs.items():
1710 #### dbg(key, '=', value)
1711 #### dbg(indent=0)
1712
1713 # Validate keyword arguments:
1714 constraint_kwargs = {}
1715 ctrl_kwargs = {}
1716 for key, value in kwargs.items():
1717 key = key.replace('Color', 'Colour') # for b-c, and standard wxPython spelling
1718 if key not in MaskedEditMixin.valid_ctrl_params.keys() + Field.valid_params.keys():
1719 ## dbg(indent=0, suspend=0)
1720 raise TypeError('Invalid keyword argument "%s" for control "%s"' % (key, self.name))
1721 elif key in Field.valid_params.keys():
1722 constraint_kwargs[key] = value
1723 else:
1724 ctrl_kwargs[key] = value
1725
1726 mask = None
1727 reset_args = {}
1728
1729 if ctrl_kwargs.has_key('autoformat'):
1730 autoformat = ctrl_kwargs['autoformat']
1731 else:
1732 autoformat = None
1733
1734 # handle "parochial name" backward compatibility:
1735 if autoformat and autoformat.find('MILTIME') != -1 and autoformat not in masktags.keys():
1736 autoformat = autoformat.replace('MILTIME', '24HRTIME')
1737
1738 if autoformat != self._autoformat and autoformat in masktags.keys():
1739 ## dbg('autoformat:', autoformat)
1740 self._autoformat = autoformat
1741 mask = masktags[self._autoformat]['mask']
1742 # gather rest of any autoformat parameters:
1743 for param, value in masktags[self._autoformat].items():
1744 if param == 'mask': continue # (must be present; already accounted for)
1745 constraint_kwargs[param] = value
1746
1747 elif autoformat and not autoformat in masktags.keys():
1748 raise AttributeError('invalid value for autoformat parameter: %s' % repr(autoformat))
1749 else:
1750 ## dbg('autoformat not selected')
1751 if kwargs.has_key('mask'):
1752 mask = kwargs['mask']
1753 ## dbg('mask:', mask)
1754
1755 ## Assign style flags
1756 if mask is None:
1757 ## dbg('preserving previous mask')
1758 mask = self._previous_mask # preserve previous mask
1759 else:
1760 ## dbg('mask (re)set')
1761 reset_args['reset_mask'] = mask
1762 constraint_kwargs['mask'] = mask
1763
1764 # wipe out previous fields; preserve new control-level constraints
1765 self._fields = {-1: self._ctrl_constraints}
1766
1767
1768 if ctrl_kwargs.has_key('fields'):
1769 # do field parameter type validation, and conversion to internal dictionary
1770 # as appropriate:
1771 fields = ctrl_kwargs['fields']
1772 if type(fields) in (types.ListType, types.TupleType):
1773 for i in range(len(fields)):
1774 field = fields[i]
1775 if not isinstance(field, Field):
1776 ## dbg(indent=0, suspend=0)
1777 raise AttributeError('invalid type for field parameter: %s' % repr(field))
1778 self._fields[i] = field
1779
1780 elif type(fields) == types.DictionaryType:
1781 for index, field in fields.items():
1782 if not isinstance(field, Field):
1783 ## dbg(indent=0, suspend=0)
1784 raise AttributeError('invalid type for field parameter: %s' % repr(field))
1785 self._fields[index] = field
1786 else:
1787 ## dbg(indent=0, suspend=0)
1788 raise AttributeError('fields parameter must be a list or dictionary; not %s' % repr(fields))
1789
1790 # Assign constraint parameters for entire control:
1791 #### dbg('control constraints:', indent=1)
1792 ## for key, value in constraint_kwargs.items():
1793 #### dbg('%s:' % key, value)
1794 #### dbg(indent=0)
1795
1796 # determine if changing parameters that should affect the entire control:
1797 for key in MaskedEditMixin.valid_ctrl_params.keys():
1798 if key in ( 'mask', 'fields' ): continue # (processed separately)
1799 if ctrl_kwargs.has_key(key):
1800 setattr(self, '_' + key, ctrl_kwargs[key])
1801
1802 # Validate color parameters, converting strings to named colors and validating
1803 # result if appropriate:
1804 for key in ('emptyBackgroundColour', 'invalidBackgroundColour', 'validBackgroundColour',
1805 'foregroundColour', 'signedForegroundColour'):
1806 if ctrl_kwargs.has_key(key):
1807 if type(ctrl_kwargs[key]) in (types.StringType, types.UnicodeType):
1808 c = wx.NamedColour(ctrl_kwargs[key])
1809 if c.Get() == (-1, -1, -1):
1810 raise TypeError('%s not a legal color specification for %s' % (repr(ctrl_kwargs[key]), key))
1811 else:
1812 # replace attribute with wxColour object:
1813 setattr(self, '_' + key, c)
1814 # attach a python dynamic attribute to wxColour for debug printouts
1815 c._name = ctrl_kwargs[key]
1816
1817 elif type(ctrl_kwargs[key]) != type(wx.BLACK):
1818 raise TypeError('%s not a legal color specification for %s' % (repr(ctrl_kwargs[key]), key))
1819
1820
1821 ## dbg('self._retainFieldValidation:', self._retainFieldValidation)
1822 if not self._retainFieldValidation:
1823 # Build dictionary of any changing parameters which should be propagated to the
1824 # component fields:
1825 for arg in Field.propagating_params:
1826 #### dbg('kwargs.has_key(%s)?' % arg, kwargs.has_key(arg))
1827 #### dbg('getattr(self._ctrl_constraints, _%s)?' % arg, getattr(self._ctrl_constraints, '_'+arg))
1828 reset_args[arg] = kwargs.has_key(arg) and kwargs[arg] != getattr(self._ctrl_constraints, '_'+arg)
1829 #### dbg('reset_args[%s]?' % arg, reset_args[arg])
1830
1831 # Set the control-level constraints:
1832 self._ctrl_constraints._SetParameters(**constraint_kwargs)
1833
1834 # This routine does the bulk of the interdependent parameter processing, determining
1835 # the field extents of the mask if changed, resetting parameters as appropriate,
1836 # determining the overall template value for the control, etc.
1837 self._configure(mask, **reset_args)
1838
1839 # now that we've propagated the field constraints and mask portions to the
1840 # various fields, validate the constraints
1841 self._ctrl_constraints._ValidateParameters(**constraint_kwargs)
1842
1843 # Validate that all choices for given fields are at least of the
1844 # necessary length, and that they all would be valid pastes if pasted
1845 # into their respective fields:
1846 #### dbg('validating choices')
1847 self._validateChoices()
1848
1849
1850 self._autofit = self._ctrl_constraints._autofit
1851 self._isNeg = False
1852
1853 self._isDate = 'D' in self._ctrl_constraints._formatcodes and isDateType(mask)
1854 self._isTime = 'T' in self._ctrl_constraints._formatcodes and isTimeType(mask)
1855 if self._isDate:
1856 # Set _dateExtent, used in date validation to locate date in string;
1857 # always set as though year will be 4 digits, even if mask only has
1858 # 2 digits, so we can always properly process the intended year for
1859 # date validation (leap years, etc.)
1860 if self._mask.find('CCC') != -1: self._dateExtent = 11
1861 else: self._dateExtent = 10
1862
1863 self._4digityear = len(self._mask) > 8 and self._mask[9] == '#'
1864
1865 if self._isDate and self._autoformat:
1866 # Auto-decide datestyle:
1867 if self._autoformat.find('MDDY') != -1: self._datestyle = 'MDY'
1868 elif self._autoformat.find('YMMD') != -1: self._datestyle = 'YMD'
1869 elif self._autoformat.find('YMMMD') != -1: self._datestyle = 'YMD'
1870 elif self._autoformat.find('DMMY') != -1: self._datestyle = 'DMY'
1871 elif self._autoformat.find('DMMMY') != -1: self._datestyle = 'DMY'
1872
1873 # Give derived controls a chance to react to parameter changes before
1874 # potentially changing current value of the control.
1875 self._OnCtrlParametersChanged()
1876
1877 if self.controlInitialized:
1878 # Then the base control is available for configuration;
1879 # take action on base control based on new settings, as appropriate.
1880 if kwargs.has_key('useFixedWidthFont'):
1881 # Set control font - fixed width by default
1882 self._setFont()
1883
1884 if reset_args.has_key('reset_mask'):
1885 ## dbg('reset mask')
1886 curvalue = self._GetValue()
1887 if curvalue.strip():
1888 try:
1889 ## dbg('attempting to _SetInitialValue(%s)' % self._GetValue())
1890 self._SetInitialValue(self._GetValue())
1891 except Exception, e:
1892 ## dbg('exception caught:', e)
1893 ## dbg("current value doesn't work; attempting to reset to template")
1894 self._SetInitialValue()
1895 else:
1896 ## dbg('attempting to _SetInitialValue() with template')
1897 self._SetInitialValue()
1898
1899 elif kwargs.has_key('useParensForNegatives'):
1900 newvalue = self._getSignedValue()[0]
1901
1902 if newvalue is not None:
1903 # Adjust for new mask:
1904 if len(newvalue) < len(self._mask):
1905 newvalue += ' '
1906 elif len(newvalue) > len(self._mask):
1907 if newvalue[-1] in (' ', ')'):
1908 newvalue = newvalue[:-1]
1909
1910 ## dbg('reconfiguring value for parens:"%s"' % newvalue)
1911 self._SetValue(newvalue)
1912
1913 if self._prevValue != newvalue:
1914 self._prevValue = newvalue # disallow undo of sign type
1915
1916 if self._autofit:
1917 ## dbg('calculated size:', self._CalcSize())
1918 self.SetClientSize(self._CalcSize())
1919 width = self.GetSize().width
1920 height = self.GetBestSize().height
1921 ## dbg('setting client size to:', (width, height))
1922 self.SetSize((width, height))
1923 self.SetSizeHints((width, height))
1924
1925 # Set value/type-specific formatting
1926 self._applyFormatting()
1927 ## dbg(indent=0, suspend=0)
1928
1929 def SetMaskParameters(self, **kwargs):
1930 """ old name for this function """
1931 return self.SetCtrlParameters(**kwargs)
1932
1933
1934 def GetCtrlParameter(self, paramname):
1935 """
1936 Routine for retrieving the value of any given parameter
1937 """
1938 if MaskedEditMixin.valid_ctrl_params.has_key(paramname.replace('Color','Colour')):
1939 return getattr(self, '_' + paramname.replace('Color', 'Colour'))
1940 elif Field.valid_params.has_key(paramname):
1941 return self._ctrl_constraints._GetParameter(paramname)
1942 else:
1943 TypeError('"%s".GetCtrlParameter: invalid parameter "%s"' % (self.name, paramname))
1944
1945 def GetMaskParameter(self, paramname):
1946 """ old name for this function """
1947 return self.GetCtrlParameter(paramname)
1948
1949
1950 ## This idea worked, but Boa was unable to use this solution...
1951 ## def _attachMethod(self, func):
1952 ## import new
1953 ## setattr(self, func.__name__, new.instancemethod(func, self, self.__class__))
1954 ##
1955 ##
1956 ## def _DefinePropertyFunctions(exposed_params):
1957 ## for param in exposed_params:
1958 ## propname = param[0].upper() + param[1:]
1959 ##
1960 ## exec('def Set%s(self, value): self.SetCtrlParameters(%s=value)' % (propname, param))
1961 ## exec('def Get%s(self): return self.GetCtrlParameter("%s")''' % (propname, param))
1962 ## self._attachMethod(locals()['Set%s' % propname])
1963 ## self._attachMethod(locals()['Get%s' % propname])
1964 ##
1965 ## if param.find('Colour') != -1:
1966 ## # add non-british spellings, for backward-compatibility
1967 ## propname.replace('Colour', 'Color')
1968 ##
1969 ## exec('def Set%s(self, value): self.SetCtrlParameters(%s=value)' % (propname, param))
1970 ## exec('def Get%s(self): return self.GetCtrlParameter("%s")''' % (propname, param))
1971 ## self._attachMethod(locals()['Set%s' % propname])
1972 ## self._attachMethod(locals()['Get%s' % propname])
1973 ##
1974
1975
1976 def SetFieldParameters(self, field_index, **kwargs):
1977 """
1978 Routine provided to modify the parameters of a given field.
1979 Because changes to fields can affect the overall control,
1980 direct access to the fields is prevented, and the control
1981 is always "reconfigured" after setting a field parameter.
1982 """
1983 if field_index not in self._field_indices:
1984 raise IndexError('%s is not a valid field for control "%s".' % (str(field_index), self.name))
1985 # set parameters as requested:
1986 self._fields[field_index]._SetParameters(**kwargs)
1987
1988 # Possibly reprogram control template due to resulting changes, and ensure
1989 # control-level params are still propagated to fields:
1990 self._configure(self._previous_mask)
1991 self._fields[field_index]._ValidateParameters(**kwargs)
1992
1993 if self.controlInitialized:
1994 if kwargs.has_key('fillChar') or kwargs.has_key('defaultValue'):
1995 self._SetInitialValue()
1996
1997 if self._autofit:
1998 # this is tricky, because, as Robin explains:
1999 # "Basically there are two sizes to deal with, that are potentially
2000 # different. The client size is the inside size and may, depending
2001 # on platform, exclude the borders and such. The normal size is
2002 # the outside size that does include the borders. What you are
2003 # calculating (in _CalcSize) is the client size, but the sizers
2004 # deal with the full size and so that is the minimum size that
2005 # we need to set with SetSizeHints. The root of the problem is
2006 # that in _calcSize the current client size height is returned,
2007 # instead of a height based on the current font. So I suggest using
2008 # _calcSize to just get the width, and then use GetBestSize to
2009 # get the height."
2010 self.SetClientSize(self._CalcSize())
2011 width = self.GetSize().width
2012 height = self.GetBestSize().height
2013 self.SetSize((width, height))
2014 self.SetSizeHints((width, height))
2015
2016
2017 # Set value/type-specific formatting
2018 self._applyFormatting()
2019
2020
2021 def GetFieldParameter(self, field_index, paramname):
2022 """
2023 Routine provided for getting a parameter of an individual field.
2024 """
2025 if field_index not in self._field_indices:
2026 raise IndexError('%s is not a valid field for control "%s".' % (str(field_index), self.name))
2027 elif Field.valid_params.has_key(paramname):
2028 return self._fields[field_index]._GetParameter(paramname)
2029 else:
2030 TypeError('"%s".GetFieldParameter: invalid parameter "%s"' % (self.name, paramname))
2031
2032
2033 def _SetKeycodeHandler(self, keycode, func):
2034 """
2035 This function adds and/or replaces key event handling functions
2036 used by the control. <func> should take the event as argument
2037 and return False if no further action on the key is necessary.
2038 """
2039 self._keyhandlers[keycode] = func
2040
2041
2042 def _SetKeyHandler(self, char, func):
2043 """
2044 This function adds and/or replaces key event handling functions
2045 for ascii characters. <func> should take the event as argument
2046 and return False if no further action on the key is necessary.
2047 """
2048 self._SetKeycodeHandler(ord(char), func)
2049
2050
2051 def _AddNavKeycode(self, keycode, handler=None):
2052 """
2053 This function allows a derived subclass to augment the list of
2054 keycodes that are considered "navigational" keys.
2055 """
2056 self._nav.append(keycode)
2057 if handler:
2058 self._keyhandlers[keycode] = handler
2059
2060
2061 def _AddNavKey(self, char, handler=None):
2062 """
2063 This function is a convenience function so you don't have to
2064 remember to call ord() for ascii chars to be used for navigation.
2065 """
2066 self._AddNavKeycode(ord(char), handler)
2067
2068
2069 def _GetNavKeycodes(self):
2070 """
2071 This function retrieves the current list of navigational keycodes for
2072 the control.
2073 """
2074 return self._nav
2075
2076
2077 def _SetNavKeycodes(self, keycode_func_tuples):
2078 """
2079 This function allows you to replace the current list of keycode processed
2080 as navigation keys, and bind associated optional keyhandlers.
2081 """
2082 self._nav = []
2083 for keycode, func in keycode_func_tuples:
2084 self._nav.append(keycode)
2085 if func:
2086 self._keyhandlers[keycode] = func
2087
2088
2089 def _processMask(self, mask):
2090 """
2091 This subroutine expands {n} syntax in mask strings, and looks for escaped
2092 special characters and returns the expanded mask, and an dictionary
2093 of booleans indicating whether or not a given position in the mask is
2094 a mask character or not.
2095 """
2096 ## dbg('_processMask: mask', mask, indent=1)
2097 # regular expression for parsing c{n} syntax:
2098 rex = re.compile('([' +string.join(maskchars,"") + '])\{(\d+)\}')
2099 s = mask
2100 match = rex.search(s)
2101 while match: # found an(other) occurrence
2102 maskchr = s[match.start(1):match.end(1)] # char to be repeated
2103 repcount = int(s[match.start(2):match.end(2)]) # the number of times
2104 replacement = string.join( maskchr * repcount, "") # the resulting substr
2105 s = s[:match.start(1)] + replacement + s[match.end(2)+1:] #account for trailing '}'
2106 match = rex.search(s) # look for another such entry in mask
2107
2108 self._decimalChar = self._ctrl_constraints._decimalChar
2109 self._shiftDecimalChar = self._ctrl_constraints._shiftDecimalChar
2110
2111 self._isFloat = isFloatingPoint(s) and not self._ctrl_constraints._validRegex
2112 self._isInt = isInteger(s) and not self._ctrl_constraints._validRegex
2113 self._signOk = '-' in self._ctrl_constraints._formatcodes and (self._isFloat or self._isInt)
2114 self._useParens = self._ctrl_constraints._useParensForNegatives
2115 self._isNeg = False
2116 #### dbg('self._signOk?', self._signOk, 'self._useParens?', self._useParens)
2117 #### dbg('isFloatingPoint(%s)?' % (s), isFloatingPoint(s),
2118 ## 'ctrl regex:', self._ctrl_constraints._validRegex)
2119
2120 if self._signOk and s[0] != ' ':
2121 s = ' ' + s
2122 if self._ctrl_constraints._defaultValue and self._ctrl_constraints._defaultValue[0] != ' ':
2123 self._ctrl_constraints._defaultValue = ' ' + self._ctrl_constraints._defaultValue
2124 self._signpos = 0
2125
2126 if self._useParens:
2127 s += ' '
2128 self._ctrl_constraints._defaultValue += ' '
2129
2130 # Now, go build up a dictionary of booleans, indexed by position,
2131 # indicating whether or not a given position is masked or not
2132 ismasked = {}
2133 i = 0
2134 while i < len(s):
2135 if s[i] == '\\': # if escaped character:
2136 ismasked[i] = False # mark position as not a mask char
2137 if i+1 < len(s): # if another char follows...
2138 s = s[:i] + s[i+1:] # elide the '\'
2139 if i+2 < len(s) and s[i+1] == '\\':
2140 # if next char also a '\', char is a literal '\'
2141 s = s[:i] + s[i+1:] # elide the 2nd '\' as well
2142 else: # else if special char, mark position accordingly
2143 ismasked[i] = s[i] in maskchars
2144 #### dbg('ismasked[%d]:' % i, ismasked[i], s)
2145 i += 1 # increment to next char
2146 #### dbg('ismasked:', ismasked)
2147 ## dbg('new mask: "%s"' % s, indent=0)
2148
2149 return s, ismasked
2150
2151
2152 def _calcFieldExtents(self):
2153 """
2154 Subroutine responsible for establishing/configuring field instances with
2155 indices and editable extents appropriate to the specified mask, and building
2156 the lookup table mapping each position to the corresponding field.
2157 """
2158 self._lookupField = {}
2159 if self._mask:
2160
2161 ## Create dictionary of positions,characters in mask
2162 self.maskdict = {}
2163 for charnum in range( len( self._mask)):
2164 self.maskdict[charnum] = self._mask[charnum:charnum+1]
2165
2166 # For the current mask, create an ordered list of field extents
2167 # and a dictionary of positions that map to field indices:
2168
2169 if self._signOk: start = 1
2170 else: start = 0
2171
2172 if self._isFloat:
2173 # Skip field "discovery", and just construct a 2-field control with appropriate
2174 # constraints for a floating-point entry.
2175
2176 # .setdefault always constructs 2nd argument even if not needed, so we do this
2177 # the old-fashioned way...
2178 if not self._fields.has_key(0):
2179 self._fields[0] = Field()
2180 if not self._fields.has_key(1):
2181 self._fields[1] = Field()
2182
2183 self._decimalpos = string.find( self._mask, '.')
2184 ## dbg('decimal pos =', self._decimalpos)
2185
2186 formatcodes = self._fields[0]._GetParameter('formatcodes')
2187 if 'R' not in formatcodes: formatcodes += 'R'
2188 self._fields[0]._SetParameters(index=0, extent=(start, self._decimalpos),
2189 mask=self._mask[start:self._decimalpos], formatcodes=formatcodes)
2190 end = len(self._mask)
2191 if self._signOk and self._useParens:
2192 end -= 1
2193 self._fields[1]._SetParameters(index=1, extent=(self._decimalpos+1, end),
2194 mask=self._mask[self._decimalpos+1:end])
2195
2196 for i in range(self._decimalpos+1):
2197 self._lookupField[i] = 0
2198
2199 for i in range(self._decimalpos+1, len(self._mask)+1):
2200 self._lookupField[i] = 1
2201
2202 elif self._isInt:
2203 # Skip field "discovery", and just construct a 1-field control with appropriate
2204 # constraints for a integer entry.
2205 if not self._fields.has_key(0):
2206 self._fields[0] = Field(index=0)
2207 end = len(self._mask)
2208 if self._signOk and self._useParens:
2209 end -= 1
2210 self._fields[0]._SetParameters(index=0, extent=(start, end),
2211 mask=self._mask[start:end])
2212 for i in range(len(self._mask)+1):
2213 self._lookupField[i] = 0
2214 else:
2215 # generic control; parse mask to figure out where the fields are:
2216 field_index = 0
2217 pos = 0
2218 i = self._findNextEntry(pos,adjustInsert=False) # go to 1st entry point:
2219 if i < len(self._mask): # no editable chars!
2220 for j in range(pos, i+1):
2221 self._lookupField[j] = field_index
2222 pos = i # figure out field for 1st editable space:
2223
2224 while i <= len(self._mask):
2225 #### dbg('searching: outer field loop: i = ', i)
2226 if self._isMaskChar(i):
2227 #### dbg('1st char is mask char; recording edit_start=', i)
2228 edit_start = i
2229 # Skip to end of editable part of current field:
2230 while i < len(self._mask) and self._isMaskChar(i):
2231 self._lookupField[i] = field_index
2232 i += 1
2233 #### dbg('edit_end =', i)
2234 edit_end = i
2235 self._lookupField[i] = field_index
2236 #### dbg('self._fields.has_key(%d)?' % field_index, self._fields.has_key(field_index))
2237 if not self._fields.has_key(field_index):
2238 kwargs = Field.valid_params.copy()
2239 kwargs['index'] = field_index
2240 kwargs['extent'] = (edit_start, edit_end)
2241 kwargs['mask'] = self._mask[edit_start:edit_end]
2242 self._fields[field_index] = Field(**kwargs)
2243 else:
2244 self._fields[field_index]._SetParameters(
2245 index=field_index,
2246 extent=(edit_start, edit_end),
2247 mask=self._mask[edit_start:edit_end])
2248 pos = i
2249 i = self._findNextEntry(pos, adjustInsert=False) # go to next field:
2250 if i > pos:
2251 for j in range(pos, i+1):
2252 self._lookupField[j] = field_index
2253 if i >= len(self._mask):
2254 break # if past end, we're done
2255 else:
2256 field_index += 1
2257 #### dbg('next field:', field_index)
2258
2259 indices = self._fields.keys()
2260 indices.sort()
2261 self._field_indices = indices[1:]
2262 #### dbg('lookupField map:', indent=1)
2263 ## for i in range(len(self._mask)):
2264 #### dbg('pos %d:' % i, self._lookupField[i])
2265 #### dbg(indent=0)
2266
2267 # Verify that all field indices specified are valid for mask:
2268 for index in self._fields.keys():
2269 if index not in [-1] + self._lookupField.values():
2270 raise IndexError('field %d is not a valid field for mask "%s"' % (index, self._mask))
2271
2272
2273 def _calcTemplate(self, reset_fillchar, reset_default):
2274 """
2275 Subroutine for processing current fillchars and default values for
2276 whole control and individual fields, constructing the resulting
2277 overall template, and adjusting the current value as necessary.
2278 """
2279 default_set = False
2280 if self._ctrl_constraints._defaultValue:
2281 default_set = True
2282 else:
2283 for field in self._fields.values():
2284 if field._defaultValue and not reset_default:
2285 default_set = True
2286 ## dbg('default set?', default_set)
2287
2288 # Determine overall new template for control, and keep track of previous
2289 # values, so that current control value can be modified as appropriate:
2290 if self.controlInitialized: curvalue = list(self._GetValue())
2291 else: curvalue = None
2292
2293 if hasattr(self, '_fillChar'): old_fillchars = self._fillChar
2294 else: old_fillchars = None
2295
2296 if hasattr(self, '_template'): old_template = self._template
2297 else: old_template = None
2298
2299 self._template = ""
2300
2301 self._fillChar = {}
2302 reset_value = False
2303
2304 for field in self._fields.values():
2305 field._template = ""
2306
2307 for pos in range(len(self._mask)):
2308 #### dbg('pos:', pos)
2309 field = self._FindField(pos)
2310 #### dbg('field:', field._index)
2311 start, end = field._extent
2312
2313 if pos == 0 and self._signOk:
2314 self._template = ' ' # always make 1st 1st position blank, regardless of fillchar
2315 elif self._isFloat and pos == self._decimalpos:
2316 self._template += self._decimalChar
2317 elif self._isMaskChar(pos):
2318 if field._fillChar != self._ctrl_constraints._fillChar and not reset_fillchar:
2319 fillChar = field._fillChar
2320 else:
2321 fillChar = self._ctrl_constraints._fillChar
2322 self._fillChar[pos] = fillChar
2323
2324 # Replace any current old fillchar with new one in current value;
2325 # if action required, set reset_value flag so we can take that action
2326 # after we're all done
2327 if self.controlInitialized and old_fillchars and old_fillchars.has_key(pos) and curvalue:
2328 if curvalue[pos] == old_fillchars[pos] and old_fillchars[pos] != fillChar:
2329 reset_value = True
2330 curvalue[pos] = fillChar
2331
2332 if not field._defaultValue and not self._ctrl_constraints._defaultValue:
2333 #### dbg('no default value')
2334 self._template += fillChar
2335 field._template += fillChar
2336
2337 elif field._defaultValue and not reset_default:
2338 #### dbg('len(field._defaultValue):', len(field._defaultValue))
2339 #### dbg('pos-start:', pos-start)
2340 if len(field._defaultValue) > pos-start:
2341 #### dbg('field._defaultValue[pos-start]: "%s"' % field._defaultValue[pos-start])
2342 self._template += field._defaultValue[pos-start]
2343 field._template += field._defaultValue[pos-start]
2344 else:
2345 #### dbg('field default not long enough; using fillChar')
2346 self._template += fillChar
2347 field._template += fillChar
2348 else:
2349 if len(self._ctrl_constraints._defaultValue) > pos:
2350 #### dbg('using control default')
2351 self._template += self._ctrl_constraints._defaultValue[pos]
2352 field._template += self._ctrl_constraints._defaultValue[pos]
2353 else:
2354 #### dbg('ctrl default not long enough; using fillChar')
2355 self._template += fillChar
2356 field._template += fillChar
2357 #### dbg('field[%d]._template now "%s"' % (field._index, field._template))
2358 #### dbg('self._template now "%s"' % self._template)
2359 else:
2360 self._template += self._mask[pos]
2361
2362 self._fields[-1]._template = self._template # (for consistency)
2363
2364 if curvalue: # had an old value, put new one back together
2365 newvalue = string.join(curvalue, "")
2366 else:
2367 newvalue = None
2368
2369 if default_set:
2370 self._defaultValue = self._template
2371 ## dbg('self._defaultValue:', self._defaultValue)
2372 if not self.IsEmpty(self._defaultValue) and not self.IsValid(self._defaultValue):
2373 #### dbg(indent=0)
2374 raise ValueError('Default value of "%s" is not a valid value for control "%s"' % (self._defaultValue, self.name))
2375
2376 # if no fillchar change, but old value == old template, replace it:
2377 if newvalue == old_template:
2378 newvalue = self._template
2379 reset_value = True
2380 else:
2381 self._defaultValue = None
2382
2383 if reset_value:
2384 ## dbg('resetting value to: "%s"' % newvalue)
2385 pos = self._GetInsertionPoint()
2386 sel_start, sel_to = self._GetSelection()
2387 self._SetValue(newvalue)
2388 self._SetInsertionPoint(pos)
2389 self._SetSelection(sel_start, sel_to)
2390
2391
2392 def _propagateConstraints(self, **reset_args):
2393 """
2394 Subroutine for propagating changes to control-level constraints and
2395 formatting to the individual fields as appropriate.
2396 """
2397 parent_codes = self._ctrl_constraints._formatcodes
2398 parent_includes = self._ctrl_constraints._includeChars
2399 parent_excludes = self._ctrl_constraints._excludeChars
2400 for i in self._field_indices:
2401 field = self._fields[i]
2402 inherit_args = {}
2403 if len(self._field_indices) == 1:
2404 inherit_args['formatcodes'] = parent_codes
2405 inherit_args['includeChars'] = parent_includes
2406 inherit_args['excludeChars'] = parent_excludes
2407 else:
2408 field_codes = current_codes = field._GetParameter('formatcodes')
2409 for c in parent_codes:
2410 if c not in field_codes: field_codes += c
2411 if field_codes != current_codes:
2412 inherit_args['formatcodes'] = field_codes
2413
2414 include_chars = current_includes = field._GetParameter('includeChars')
2415 for c in parent_includes:
2416 if not c in include_chars: include_chars += c
2417 if include_chars != current_includes:
2418 inherit_args['includeChars'] = include_chars
2419
2420 exclude_chars = current_excludes = field._GetParameter('excludeChars')
2421 for c in parent_excludes:
2422 if not c in exclude_chars: exclude_chars += c
2423 if exclude_chars != current_excludes:
2424 inherit_args['excludeChars'] = exclude_chars
2425
2426 if reset_args.has_key('defaultValue') and reset_args['defaultValue']:
2427 inherit_args['defaultValue'] = "" # (reset for field)
2428
2429 for param in Field.propagating_params:
2430 #### dbg('reset_args.has_key(%s)?' % param, reset_args.has_key(param))
2431 #### dbg('reset_args.has_key(%(param)s) and reset_args[%(param)s]?' % locals(), reset_args.has_key(param) and reset_args[param])
2432 if reset_args.has_key(param):
2433 inherit_args[param] = self.GetCtrlParameter(param)
2434 #### dbg('inherit_args[%s]' % param, inherit_args[param])
2435
2436 if inherit_args:
2437 field._SetParameters(**inherit_args)
2438 field._ValidateParameters(**inherit_args)
2439
2440
2441 def _validateChoices(self):
2442 """
2443 Subroutine that validates that all choices for given fields are at
2444 least of the necessary length, and that they all would be valid pastes
2445 if pasted into their respective fields.
2446 """
2447 for field in self._fields.values():
2448 if field._choices:
2449 index = field._index
2450 if len(self._field_indices) == 1 and index == 0 and field._choices == self._ctrl_constraints._choices:
2451 ## dbg('skipping (duplicate) choice validation of field 0')
2452 continue
2453 #### dbg('checking for choices for field', field._index)
2454 start, end = field._extent
2455 field_length = end - start
2456 #### dbg('start, end, length:', start, end, field_length)
2457 for choice in field._choices:
2458 #### dbg('testing "%s"' % choice)
2459 valid_paste, ignore, replace_to = self._validatePaste(choice, start, end)
2460 if not valid_paste:
2461 #### dbg(indent=0)
2462 raise ValueError('"%s" could not be entered into field %d of control "%s"' % (choice, index, self.name))
2463 elif replace_to > end:
2464 #### dbg(indent=0)
2465 raise ValueError('"%s" will not fit into field %d of control "%s"' (choice, index, self.name))
2466 #### dbg(choice, 'valid in field', index)
2467
2468
2469 def _configure(self, mask, **reset_args):
2470 """
2471 This function sets flags for automatic styling options. It is
2472 called whenever a control or field-level parameter is set/changed.
2473
2474 This routine does the bulk of the interdependent parameter processing, determining
2475 the field extents of the mask if changed, resetting parameters as appropriate,
2476 determining the overall template value for the control, etc.
2477
2478 reset_args is supplied if called from control's .SetCtrlParameters()
2479 routine, and indicates which if any parameters which can be
2480 overridden by individual fields have been reset by request for the
2481 whole control.
2482
2483 """
2484 ## dbg(suspend=1)
2485 ## dbg('MaskedEditMixin::_configure("%s")' % mask, indent=1)
2486
2487 # Preprocess specified mask to expand {n} syntax, handle escaped
2488 # mask characters, etc and build the resulting positionally keyed
2489 # dictionary for which positions are mask vs. template characters:
2490 self._mask, self.ismasked = self._processMask(mask)
2491 self._masklength = len(self._mask)
2492 #### dbg('processed mask:', self._mask)
2493
2494 # Preserve original mask specified, for subsequent reprocessing
2495 # if parameters change.
2496 ## dbg('mask: "%s"' % self._mask, 'previous mask: "%s"' % self._previous_mask)
2497 self._previous_mask = mask # save unexpanded mask for next time
2498 # Set expanded mask and extent of field -1 to width of entire control:
2499 self._ctrl_constraints._SetParameters(mask = self._mask, extent=(0,self._masklength))
2500
2501 # Go parse mask to determine where each field is, construct field
2502 # instances as necessary, configure them with those extents, and
2503 # build lookup table mapping each position for control to its corresponding
2504 # field.
2505 #### dbg('calculating field extents')
2506
2507 self._calcFieldExtents()
2508
2509
2510 # Go process defaultValues and fillchars to construct the overall
2511 # template, and adjust the current value as necessary:
2512 reset_fillchar = reset_args.has_key('fillChar') and reset_args['fillChar']
2513 reset_default = reset_args.has_key('defaultValue') and reset_args['defaultValue']
2514
2515 #### dbg('calculating template')
2516 self._calcTemplate(reset_fillchar, reset_default)
2517
2518 # Propagate control-level formatting and character constraints to each
2519 # field if they don't already have them; if only one field, propagate
2520 # control-level validation constraints to field as well:
2521 #### dbg('propagating constraints')
2522 self._propagateConstraints(**reset_args)
2523
2524
2525 if self._isFloat and self._fields[0]._groupChar == self._decimalChar:
2526 raise AttributeError('groupChar (%s) and decimalChar (%s) must be distinct.' %
2527 (self._fields[0]._groupChar, self._decimalChar) )
2528
2529 #### dbg('fields:', indent=1)
2530 ## for i in [-1] + self._field_indices:
2531 #### dbg('field %d:' % i, self._fields[i].__dict__)
2532 #### dbg(indent=0)
2533
2534 # Set up special parameters for numeric control, if appropriate:
2535 if self._signOk:
2536 self._signpos = 0 # assume it starts here, but it will move around on floats
2537 signkeys = ['-', '+', ' ']
2538 if self._useParens:
2539 signkeys += ['(', ')']
2540 for key in signkeys:
2541 keycode = ord(key)
2542 if not self._keyhandlers.has_key(keycode):
2543 self._SetKeyHandler(key, self._OnChangeSign)
2544
2545
2546
2547 if self._isFloat or self._isInt:
2548 if self.controlInitialized:
2549 value = self._GetValue()
2550 #### dbg('value: "%s"' % value, 'len(value):', len(value),
2551 ## 'len(self._ctrl_constraints._mask):',len(self._ctrl_constraints._mask))
2552 if len(value) < len(self._ctrl_constraints._mask):
2553 newvalue = value
2554 if self._useParens and len(newvalue) < len(self._ctrl_constraints._mask) and newvalue.find('(') == -1:
2555 newvalue += ' '
2556 if self._signOk and len(newvalue) < len(self._ctrl_constraints._mask) and newvalue.find(')') == -1:
2557 newvalue = ' ' + newvalue
2558 if len(newvalue) < len(self._ctrl_constraints._mask):
2559 if self._ctrl_constraints._alignRight:
2560 newvalue = newvalue.rjust(len(self._ctrl_constraints._mask))
2561 else:
2562 newvalue = newvalue.ljust(len(self._ctrl_constraints._mask))
2563 ## dbg('old value: "%s"' % value)
2564 ## dbg('new value: "%s"' % newvalue)
2565 try:
2566 self._SetValue(newvalue)
2567 except Exception, e:
2568 ## dbg('exception raised:', e, 'resetting to initial value')
2569 self._SetInitialValue()
2570
2571 elif len(value) > len(self._ctrl_constraints._mask):
2572 newvalue = value
2573 if not self._useParens and newvalue[-1] == ' ':
2574 newvalue = newvalue[:-1]
2575 if not self._signOk and len(newvalue) > len(self._ctrl_constraints._mask):
2576 newvalue = newvalue[1:]
2577 if not self._signOk:
2578 newvalue, signpos, right_signpos = self._getSignedValue(newvalue)
2579
2580 ## dbg('old value: "%s"' % value)
2581 ## dbg('new value: "%s"' % newvalue)
2582 try:
2583 self._SetValue(newvalue)
2584 except Exception, e:
2585 ## dbg('exception raised:', e, 'resetting to initial value')
2586 self._SetInitialValue()
2587 elif not self._signOk and ('(' in value or '-' in value):
2588 newvalue, signpos, right_signpos = self._getSignedValue(value)
2589 ## dbg('old value: "%s"' % value)
2590 ## dbg('new value: "%s"' % newvalue)
2591 try:
2592 self._SetValue(newvalue)
2593 except e:
2594 ## dbg('exception raised:', e, 'resetting to initial value')
2595 self._SetInitialValue()
2596
2597 # Replace up/down arrow default handling:
2598 # make down act like tab, up act like shift-tab:
2599
2600 #### dbg('Registering numeric navigation and control handlers (if not already set)')
2601 if not self._keyhandlers.has_key(wx.WXK_DOWN):
2602 self._SetKeycodeHandler(wx.WXK_DOWN, self._OnChangeField)
2603 if not self._keyhandlers.has_key(wx.WXK_UP):
2604 self._SetKeycodeHandler(wx.WXK_UP, self._OnUpNumeric) # (adds "shift" to up arrow, and calls _OnChangeField)
2605
2606 # On ., truncate contents right of cursor to decimal point (if any)
2607 # leaves cusor after decimal point if floating point, otherwise at 0.
2608 if not self._keyhandlers.has_key(ord(self._decimalChar)):
2609 self._SetKeyHandler(self._decimalChar, self._OnDecimalPoint)
2610 if not self._keyhandlers.has_key(ord(self._shiftDecimalChar)):
2611 self._SetKeyHandler(self._shiftDecimalChar, self._OnChangeField) # (Shift-'.' == '>' on US keyboards)
2612
2613 # Allow selective insert of groupchar in numbers:
2614 if not self._keyhandlers.has_key(ord(self._fields[0]._groupChar)):
2615 self._SetKeyHandler(self._fields[0]._groupChar, self._OnGroupChar)
2616
2617 ## dbg(indent=0, suspend=0)
2618
2619
2620 def _SetInitialValue(self, value=""):
2621 """
2622 fills the control with the generated or supplied default value.
2623 It will also set/reset the font if necessary and apply
2624 formatting to the control at this time.
2625 """
2626 ## dbg('MaskedEditMixin::_SetInitialValue("%s")' % value, indent=1)
2627 if not value:
2628 self._prevValue = self._curValue = self._template
2629 # don't apply external validation rules in this case, as template may
2630 # not coincide with "legal" value...
2631 try:
2632 self._SetValue(self._curValue) # note the use of "raw" ._SetValue()...
2633 except Exception, e:
2634 ## dbg('exception thrown:', e, indent=0)
2635 raise
2636 else:
2637 # Otherwise apply validation as appropriate to passed value:
2638 #### dbg('value = "%s", length:' % value, len(value))
2639 self._prevValue = self._curValue = value
2640 try:
2641 self.SetValue(value) # use public (validating) .SetValue()
2642 except Exception, e:
2643 ## dbg('exception thrown:', e, indent=0)
2644 raise
2645
2646
2647 # Set value/type-specific formatting
2648 self._applyFormatting()
2649 ## dbg(indent=0)
2650
2651
2652 def _calcSize(self, size=None):
2653 """ Calculate automatic size if allowed; must be called after the base control is instantiated"""
2654 #### dbg('MaskedEditMixin::_calcSize', indent=1)
2655 cont = (size is None or size == wx.DefaultSize)
2656
2657 if cont and self._autofit:
2658 sizing_text = 'M' * self._masklength
2659 if wx.Platform != "__WXMSW__": # give it a little extra space
2660 sizing_text += 'M'
2661 if wx.Platform == "__WXMAC__": # give it even a little more...
2662 sizing_text += 'M'
2663 #### dbg('len(sizing_text):', len(sizing_text), 'sizing_text: "%s"' % sizing_text)
2664 w, h = self.GetTextExtent(sizing_text)
2665 size = (w+4, self.GetSize().height)
2666 #### dbg('size:', size, indent=0)
2667 return size
2668
2669
2670 def _setFont(self):
2671 """ Set the control's font typeface -- pass the font name as str."""
2672 #### dbg('MaskedEditMixin::_setFont', indent=1)
2673 if not self._useFixedWidthFont:
2674 self._font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
2675 else:
2676 font = self.GetFont() # get size, weight, etc from current font
2677
2678 # Set to teletype font (guaranteed to be mappable to all wxWindows
2679 # platforms:
2680 self._font = wx.Font( font.GetPointSize(), wx.TELETYPE, font.GetStyle(),
2681 font.GetWeight(), font.GetUnderlined())
2682 #### dbg('font string: "%s"' % font.GetNativeFontInfo().ToString())
2683
2684 self.SetFont(self._font)
2685 #### dbg(indent=0)
2686
2687
2688 def _OnTextChange(self, event):
2689 """
2690 Handler for EVT_TEXT event.
2691 self._Change() is provided for subclasses, and may return False to
2692 skip this method logic. This function returns True if the event
2693 detected was a legitimate event, or False if it was a "bogus"
2694 EVT_TEXT event. (NOTE: There is currently an issue with calling
2695 .SetValue from within the EVT_CHAR handler that causes duplicate
2696 EVT_TEXT events for the same change.)
2697 """
2698 newvalue = self._GetValue()
2699 ## dbg('MaskedEditMixin::_OnTextChange: value: "%s"' % newvalue, indent=1)
2700 bValid = False
2701 if self._ignoreChange: # ie. if an "intermediate text change event"
2702 ## dbg(indent=0)
2703 return bValid
2704
2705 ##! WS: For some inexplicable reason, every wx.TextCtrl.SetValue
2706 ## call is generating two (2) EVT_TEXT events. On certain platforms,
2707 ## (eg. linux/GTK) the 1st is an empty string value.
2708 ## This is the only mechanism I can find to mask this problem:
2709 if newvalue == self._curValue or len(newvalue) == 0:
2710 ## dbg('ignoring bogus text change event', indent=0)
2711 pass
2712 else:
2713 ## dbg('curvalue: "%s", newvalue: "%s", len(newvalue): %d' % (self._curValue, newvalue, len(newvalue)))
2714 if self._Change():
2715 if self._signOk and self._isNeg and newvalue.find('-') == -1 and newvalue.find('(') == -1:
2716 ## dbg('clearing self._isNeg')
2717 self._isNeg = False
2718 text, self._signpos, self._right_signpos = self._getSignedValue()
2719 self._CheckValid() # Recolor control as appropriate
2720 ## dbg('calling event.Skip()')
2721 event.Skip()
2722 bValid = True
2723 self._prevValue = self._curValue # save for undo
2724 self._curValue = newvalue # Save last seen value for next iteration
2725 ## dbg(indent=0)
2726 return bValid
2727
2728
2729 def _OnKeyDown(self, event):
2730 """
2731 This function allows the control to capture Ctrl-events like Ctrl-tab,
2732 that are not normally seen by the "cooked" EVT_CHAR routine.
2733 """
2734 # Get keypress value, adjusted by control options (e.g. convert to upper etc)
2735 key = event.GetKeyCode()
2736 if key in self._nav and event.ControlDown():
2737 # then this is the only place we will likely see these events;
2738 # process them now:
2739 ## dbg('MaskedEditMixin::OnKeyDown: calling _OnChar')
2740 self._OnChar(event)
2741 return
2742 # else allow regular EVT_CHAR key processing
2743 event.Skip()
2744
2745
2746 def _OnChar(self, event):
2747 """
2748 This is the engine of MaskedEdit controls. It examines each keystroke,
2749 decides if it's allowed, where it should go or what action to take.
2750 """
2751 ## dbg('MaskedEditMixin::_OnChar', indent=1)
2752
2753 # Get keypress value, adjusted by control options (e.g. convert to upper etc)
2754 key = event.GetKeyCode()
2755 orig_pos = self._GetInsertionPoint()
2756 orig_value = self._GetValue()
2757 ## dbg('keycode = ', key)
2758 ## dbg('current pos = ', orig_pos)
2759 ## dbg('current selection = ', self._GetSelection())
2760
2761 if not self._Keypress(key):
2762 ## dbg(indent=0)
2763 return
2764
2765 # If no format string for this control, or the control is marked as "read-only",
2766 # skip the rest of the special processing, and just "do the standard thing:"
2767 if not self._mask or not self._IsEditable():
2768 event.Skip()
2769 ## dbg(indent=0)
2770 return
2771
2772 # Process navigation and control keys first, with
2773 # position/selection unadulterated:
2774 if key in self._nav + self._control:
2775 if self._keyhandlers.has_key(key):
2776 keep_processing = self._keyhandlers[key](event)
2777 if self._GetValue() != orig_value:
2778 self.modified = True
2779 if not keep_processing:
2780 ## dbg(indent=0)
2781 return
2782 self._applyFormatting()
2783 ## dbg(indent=0)
2784 return
2785
2786 # Else... adjust the position as necessary for next input key,
2787 # and determine resulting selection:
2788 pos = self._adjustPos( orig_pos, key ) ## get insertion position, adjusted as needed
2789 sel_start, sel_to = self._GetSelection() ## check for a range of selected text
2790 ## dbg("pos, sel_start, sel_to:", pos, sel_start, sel_to)
2791
2792 keep_processing = True
2793 # Capture user past end of format field
2794 if pos > len(self.maskdict):
2795 ## dbg("field length exceeded:",pos)
2796 keep_processing = False
2797
2798 if keep_processing:
2799 if self._isMaskChar(pos): ## Get string of allowed characters for validation
2800 okchars = self._getAllowedChars(pos)
2801 else:
2802 ## dbg('Not a valid position: pos = ', pos,"chars=",maskchars)
2803 okchars = ""
2804
2805 key = self._adjustKey(pos, key) # apply formatting constraints to key:
2806
2807 if self._keyhandlers.has_key(key):
2808 # there's an override for default behavior; use override function instead
2809 ## dbg('using supplied key handler:', self._keyhandlers[key])
2810 keep_processing = self._keyhandlers[key](event)
2811 if self._GetValue() != orig_value:
2812 self.modified = True
2813 if not keep_processing:
2814 ## dbg(indent=0)
2815 return
2816 # else skip default processing, but do final formatting
2817 if key < wx.WXK_SPACE or key > 255:
2818 ## dbg('key < WXK_SPACE or key > 255')
2819 event.Skip() # non alphanumeric
2820 keep_processing = False
2821 else:
2822 field = self._FindField(pos)
2823 ## dbg("key ='%s'" % chr(key))
2824 if chr(key) == ' ':
2825 ## dbg('okSpaces?', field._okSpaces)
2826 pass
2827
2828
2829 if chr(key) in field._excludeChars + self._ctrl_constraints._excludeChars:
2830 keep_processing = False
2831
2832 if keep_processing and self._isCharAllowed( chr(key), pos, checkRegex = True ):
2833 ## dbg("key allowed by mask")
2834 # insert key into candidate new value, but don't change control yet:
2835 oldstr = self._GetValue()
2836 newstr, newpos, new_select_to, match_field, match_index = self._insertKey(
2837 chr(key), pos, sel_start, sel_to, self._GetValue(), allowAutoSelect = True)
2838 ## dbg("str with '%s' inserted:" % chr(key), '"%s"' % newstr)
2839 if self._ctrl_constraints._validRequired and not self.IsValid(newstr):
2840 ## dbg('not valid; checking to see if adjusted string is:')
2841 keep_processing = False
2842 if self._isFloat and newstr != self._template:
2843 newstr = self._adjustFloat(newstr)
2844 ## dbg('adjusted str:', newstr)
2845 if self.IsValid(newstr):
2846 ## dbg("it is!")
2847 keep_processing = True
2848 wx.CallAfter(self._SetInsertionPoint, self._decimalpos)
2849 if not keep_processing:
2850 ## dbg("key disallowed by validation")
2851 if not wx.Validator_IsSilent() and orig_pos == pos:
2852 wx.Bell()
2853
2854 if keep_processing:
2855 unadjusted = newstr
2856
2857 # special case: adjust date value as necessary:
2858 if self._isDate and newstr != self._template:
2859 newstr = self._adjustDate(newstr)
2860 ## dbg('adjusted newstr:', newstr)
2861
2862 if newstr != orig_value:
2863 self.modified = True
2864
2865 wx.CallAfter(self._SetValue, newstr)
2866
2867 # Adjust insertion point on date if just entered 2 digit year, and there are now 4 digits:
2868 if not self.IsDefault() and self._isDate and self._4digityear:
2869 year2dig = self._dateExtent - 2
2870 if pos == year2dig and unadjusted[year2dig] != newstr[year2dig]:
2871 newpos = pos+2
2872
2873 wx.CallAfter(self._SetInsertionPoint, newpos)
2874
2875 if match_field is not None:
2876 ## dbg('matched field')
2877 self._OnAutoSelect(match_field, match_index)
2878
2879 if new_select_to != newpos:
2880 ## dbg('queuing selection: (%d, %d)' % (newpos, new_select_to))
2881 wx.CallAfter(self._SetSelection, newpos, new_select_to)
2882 else:
2883 newfield = self._FindField(newpos)
2884 if newfield != field and newfield._selectOnFieldEntry:
2885 ## dbg('queuing selection: (%d, %d)' % (newfield._extent[0], newfield._extent[1]))
2886 wx.CallAfter(self._SetSelection, newfield._extent[0], newfield._extent[1])
2887 else:
2888 wx.CallAfter(self._SetSelection, newpos, new_select_to)
2889 keep_processing = False
2890
2891 elif keep_processing:
2892 ## dbg('char not allowed')
2893 keep_processing = False
2894 if (not wx.Validator_IsSilent()) and orig_pos == pos:
2895 wx.Bell()
2896
2897 self._applyFormatting()
2898
2899 # Move to next insertion point
2900 if keep_processing and key not in self._nav:
2901 pos = self._GetInsertionPoint()
2902 next_entry = self._findNextEntry( pos )
2903 if pos != next_entry:
2904 ## dbg("moving from %(pos)d to next valid entry: %(next_entry)d" % locals())
2905 wx.CallAfter(self._SetInsertionPoint, next_entry )
2906
2907 if self._isTemplateChar(pos):
2908 self._AdjustField(pos)
2909 ## dbg(indent=0)
2910
2911
2912 def _FindFieldExtent(self, pos=None, getslice=False, value=None):
2913 """ returns editable extent of field corresponding to
2914 position pos, and, optionally, the contents of that field
2915 in the control or the value specified.
2916 Template chars are bound to the preceding field.
2917 For masks beginning with template chars, these chars are ignored
2918 when calculating the current field.
2919
2920 Eg: with template (###) ###-####,
2921 >>> self._FindFieldExtent(pos=0)
2922 1, 4
2923 >>> self._FindFieldExtent(pos=1)
2924 1, 4
2925 >>> self._FindFieldExtent(pos=5)
2926 1, 4
2927 >>> self._FindFieldExtent(pos=6)
2928 6, 9
2929 >>> self._FindFieldExtent(pos=10)
2930 10, 14
2931 etc.
2932 """
2933 ## dbg('MaskedEditMixin::_FindFieldExtent(pos=%s, getslice=%s)' % (str(pos), str(getslice)) ,indent=1)
2934
2935 field = self._FindField(pos)
2936 if not field:
2937 if getslice:
2938 return None, None, ""
2939 else:
2940 return None, None
2941 edit_start, edit_end = field._extent
2942 if getslice:
2943 if value is None: value = self._GetValue()
2944 slice = value[edit_start:edit_end]
2945 ## dbg('edit_start:', edit_start, 'edit_end:', edit_end, 'slice: "%s"' % slice)
2946 ## dbg(indent=0)
2947 return edit_start, edit_end, slice
2948 else:
2949 ## dbg('edit_start:', edit_start, 'edit_end:', edit_end)
2950 ## dbg(indent=0)
2951 return edit_start, edit_end
2952
2953
2954 def _FindField(self, pos=None):
2955 """
2956 Returns the field instance in which pos resides.
2957 Template chars are bound to the preceding field.
2958 For masks beginning with template chars, these chars are ignored
2959 when calculating the current field.
2960
2961 """
2962 #### dbg('MaskedEditMixin::_FindField(pos=%s)' % str(pos) ,indent=1)
2963 if pos is None: pos = self._GetInsertionPoint()
2964 elif pos < 0 or pos > self._masklength:
2965 raise IndexError('position %s out of range of control' % str(pos))
2966
2967 if len(self._fields) == 0:
2968 ## dbg(indent=0)
2969 return None
2970
2971 # else...
2972 #### dbg(indent=0)
2973 return self._fields[self._lookupField[pos]]
2974
2975
2976 def ClearValue(self):
2977 """ Blanks the current control value by replacing it with the default value."""
2978 ## dbg("MaskedEditMixin::ClearValue - value reset to default value (template)")
2979 self._SetValue( self._template )
2980 self._SetInsertionPoint(0)
2981 self.Refresh()
2982
2983
2984 def _baseCtrlEventHandler(self, event):
2985 """
2986 This function is used whenever a key should be handled by the base control.
2987 """
2988 event.Skip()
2989 return False
2990
2991
2992 def _OnUpNumeric(self, event):
2993 """
2994 Makes up-arrow act like shift-tab should; ie. take you to start of
2995 previous field.
2996 """
2997 ## dbg('MaskedEditMixin::_OnUpNumeric', indent=1)
2998 event.m_shiftDown = 1
2999 ## dbg('event.ShiftDown()?', event.ShiftDown())
3000 self._OnChangeField(event)
3001 ## dbg(indent=0)
3002
3003
3004 def _OnArrow(self, event):
3005 """
3006 Used in response to left/right navigation keys; makes these actions skip
3007 over mask template chars.
3008 """
3009 ## dbg("MaskedEditMixin::_OnArrow", indent=1)
3010 pos = self._GetInsertionPoint()
3011 keycode = event.GetKeyCode()
3012 sel_start, sel_to = self._GetSelection()
3013 entry_end = self._goEnd(getPosOnly=True)
3014 if keycode in (wx.WXK_RIGHT, wx.WXK_DOWN):
3015 if( ( not self._isTemplateChar(pos) and pos+1 > entry_end)
3016 or ( self._isTemplateChar(pos) and pos >= entry_end) ):
3017 ## dbg("can't advance", indent=0)
3018 return False
3019 elif self._isTemplateChar(pos):
3020 self._AdjustField(pos)
3021 elif keycode in (wx.WXK_LEFT,wx.WXK_UP) and sel_start == sel_to and pos > 0 and self._isTemplateChar(pos-1):
3022 ## dbg('adjusting field')
3023 self._AdjustField(pos)
3024
3025 # treat as shifted up/down arrows as tab/reverse tab:
3026 if event.ShiftDown() and keycode in (wx.WXK_UP, wx.WXK_DOWN):
3027 # remove "shifting" and treat as (forward) tab:
3028 event.m_shiftDown = False
3029 keep_processing = self._OnChangeField(event)
3030
3031 elif self._FindField(pos)._selectOnFieldEntry:
3032 if( keycode in (wx.WXK_UP, wx.WXK_LEFT)
3033 and sel_start != 0
3034 and self._isTemplateChar(sel_start-1)
3035 and sel_start != self._masklength
3036 and not self._signOk and not self._useParens):
3037
3038 # call _OnChangeField to handle "ctrl-shifted event"
3039 # (which moves to previous field and selects it.)
3040 event.m_shiftDown = True
3041 event.m_ControlDown = True
3042 keep_processing = self._OnChangeField(event)
3043 elif( keycode in (wx.WXK_DOWN, wx.WXK_RIGHT)
3044 and sel_to != self._masklength
3045 and self._isTemplateChar(sel_to)):
3046
3047 # when changing field to the right, ensure don't accidentally go left instead
3048 event.m_shiftDown = False
3049 keep_processing = self._OnChangeField(event)
3050 else:
3051 # treat arrows as normal, allowing selection
3052 # as appropriate:
3053 ## dbg('using base ctrl event processing')
3054 event.Skip()
3055 else:
3056 if( (sel_to == self._fields[0]._extent[0] and keycode == wx.WXK_LEFT)
3057 or (sel_to == self._masklength and keycode == wx.WXK_RIGHT) ):
3058 if not wx.Validator_IsSilent():
3059 wx.Bell()
3060 else:
3061 # treat arrows as normal, allowing selection
3062 # as appropriate:
3063 ## dbg('using base event processing')
3064 event.Skip()
3065
3066 keep_processing = False
3067 ## dbg(indent=0)
3068 return keep_processing
3069
3070
3071 def _OnCtrl_S(self, event):
3072 """ Default Ctrl-S handler; prints value information if demo enabled. """
3073 ## dbg("MaskedEditMixin::_OnCtrl_S")
3074 if self._demo:
3075 print 'MaskedEditMixin.GetValue() = "%s"\nMaskedEditMixin.GetPlainValue() = "%s"' % (self.GetValue(), self.GetPlainValue())
3076 print "Valid? => " + str(self.IsValid())
3077 print "Current field, start, end, value =", str( self._FindFieldExtent(getslice=True))
3078 return False
3079
3080
3081 def _OnCtrl_X(self, event=None):
3082 """ Handles ctrl-x keypress in control and Cut operation on context menu.
3083 Should return False to skip other processing. """
3084 ## dbg("MaskedEditMixin::_OnCtrl_X", indent=1)
3085 self.Cut()
3086 ## dbg(indent=0)
3087 return False
3088
3089 def _OnCtrl_C(self, event=None):
3090 """ Handles ctrl-C keypress in control and Copy operation on context menu.
3091 Uses base control handling. Should return False to skip other processing."""
3092 self.Copy()
3093 return False
3094
3095 def _OnCtrl_V(self, event=None):
3096 """ Handles ctrl-V keypress in control and Paste operation on context menu.
3097 Should return False to skip other processing. """
3098 ## dbg("MaskedEditMixin::_OnCtrl_V", indent=1)
3099 self.Paste()
3100 ## dbg(indent=0)
3101 return False
3102
3103 def _OnCtrl_Z(self, event=None):
3104 """ Handles ctrl-Z keypress in control and Undo operation on context menu.
3105 Should return False to skip other processing. """
3106 ## dbg("MaskedEditMixin::_OnCtrl_Z", indent=1)
3107 self.Undo()
3108 ## dbg(indent=0)
3109 return False
3110
3111 def _OnCtrl_A(self,event=None):
3112 """ Handles ctrl-a keypress in control. Should return False to skip other processing. """
3113 end = self._goEnd(getPosOnly=True)
3114 if not event or (isinstance(event, wx.KeyEvent) and event.ShiftDown()):
3115 wx.CallAfter(self._SetInsertionPoint, 0)
3116 wx.CallAfter(self._SetSelection, 0, self._masklength)
3117 else:
3118 wx.CallAfter(self._SetInsertionPoint, 0)
3119 wx.CallAfter(self._SetSelection, 0, end)
3120 return False
3121
3122
3123 def _OnErase(self, event=None, just_return_value=False):
3124 """ Handles backspace and delete keypress in control. Should return False to skip other processing."""
3125 ## dbg("MaskedEditMixin::_OnErase", indent=1)
3126 sel_start, sel_to = self._GetSelection() ## check for a range of selected text
3127
3128 if event is None: # called as action routine from Cut() operation.
3129 key = wx.WXK_DELETE
3130 else:
3131 key = event.GetKeyCode()
3132
3133 field = self._FindField(sel_to)
3134 start, end = field._extent
3135 value = self._GetValue()
3136 oldstart = sel_start
3137
3138 # If trying to erase beyond "legal" bounds, disallow operation:
3139 if( (sel_to == 0 and key == wx.WXK_BACK)
3140 or (self._signOk and sel_to == 1 and value[0] == ' ' and key == wx.WXK_BACK)
3141 or (sel_to == self._masklength and sel_start == sel_to and key == wx.WXK_DELETE and not field._insertRight)
3142 or (self._signOk and self._useParens
3143 and sel_start == sel_to
3144 and sel_to == self._masklength - 1
3145 and value[sel_to] == ' ' and key == wx.WXK_DELETE and not field._insertRight) ):
3146 if not wx.Validator_IsSilent():
3147 wx.Bell()
3148 ## dbg(indent=0)
3149 return False
3150
3151
3152 if( field._insertRight # an insert-right field
3153 and value[start:end] != self._template[start:end] # and field not empty
3154 and sel_start >= start # and selection starts in field
3155 and ((sel_to == sel_start # and no selection
3156 and sel_to == end # and cursor at right edge
3157 and key in (wx.WXK_BACK, wx.WXK_DELETE)) # and either delete or backspace key
3158 or # or
3159 (key == wx.WXK_BACK # backspacing
3160 and (sel_to == end # and selection ends at right edge
3161 or sel_to < end and field._allowInsert)) ) ): # or allow right insert at any point in field
3162
3163 ## dbg('delete left')
3164 # if backspace but left of cursor is empty, adjust cursor right before deleting
3165 while( key == wx.WXK_BACK
3166 and sel_start == sel_to
3167 and sel_start < end
3168 and value[start:sel_start] == self._template[start:sel_start]):
3169 sel_start += 1
3170 sel_to = sel_start
3171
3172 ## dbg('sel_start, start:', sel_start, start)
3173
3174 if sel_start == sel_to:
3175 keep = sel_start -1
3176 else:
3177 keep = sel_start
3178 newfield = value[start:keep] + value[sel_to:end]
3179
3180 # handle sign char moving from outside field into the field:
3181 move_sign_into_field = False
3182 if not field._padZero and self._signOk and self._isNeg and value[0] in ('-', '('):
3183 signchar = value[0]
3184 newfield = signchar + newfield
3185 move_sign_into_field = True
3186 ## dbg('cut newfield: "%s"' % newfield)
3187
3188 # handle what should fill in from the left:
3189 left = ""
3190 for i in range(start, end - len(newfield)):
3191 if field._padZero:
3192 left += '0'
3193 elif( self._signOk and self._isNeg and i == 1
3194 and ((self._useParens and newfield.find('(') == -1)
3195 or (not self._useParens and newfield.find('-') == -1)) ):
3196 left += ' '
3197 else:
3198 left += self._template[i] # this can produce strange results in combination with default values...
3199 newfield = left + newfield
3200 ## dbg('filled newfield: "%s"' % newfield)
3201
3202 newstr = value[:start] + newfield + value[end:]
3203
3204 # (handle sign located in "mask position" in front of field prior to delete)
3205 if move_sign_into_field:
3206 newstr = ' ' + newstr[1:]
3207 pos = sel_to
3208 else:
3209 # handle erasure of (left) sign, moving selection accordingly...
3210 if self._signOk and sel_start == 0:
3211 newstr = value = ' ' + value[1:]
3212 sel_start += 1
3213
3214 if field._allowInsert and sel_start >= start:
3215 # selection (if any) falls within current insert-capable field:
3216 select_len = sel_to - sel_start
3217 # determine where cursor should end up:
3218 if key == wx.WXK_BACK:
3219 if select_len == 0:
3220 newpos = sel_start -1
3221 else:
3222 newpos = sel_start
3223 erase_to = sel_to
3224 else:
3225 newpos = sel_start
3226 if sel_to == sel_start:
3227 erase_to = sel_to + 1
3228 else:
3229 erase_to = sel_to
3230
3231 if self._isTemplateChar(newpos) and select_len == 0:
3232 if self._signOk:
3233 if value[newpos] in ('(', '-'):
3234 newpos += 1 # don't move cusor
3235 newstr = ' ' + value[newpos:]
3236 elif value[newpos] == ')':
3237 # erase right sign, but don't move cursor; (matching left sign handled later)
3238 newstr = value[:newpos] + ' '
3239 else:
3240 # no deletion; just move cursor
3241 newstr = value
3242 else:
3243 # no deletion; just move cursor
3244 newstr = value
3245 else:
3246 if erase_to > end: erase_to = end
3247 erase_len = erase_to - newpos
3248
3249 left = value[start:newpos]
3250 ## dbg("retained ='%s'" % value[erase_to:end], 'sel_to:', sel_to, "fill: '%s'" % self._template[end - erase_len:end])
3251 right = value[erase_to:end] + self._template[end-erase_len:end]
3252 pos_adjust = 0
3253 if field._alignRight:
3254 rstripped = right.rstrip()
3255 if rstripped != right:
3256 pos_adjust = len(right) - len(rstripped)
3257 right = rstripped
3258
3259 if not field._insertRight and value[-1] == ')' and end == self._masklength - 1:
3260 # need to shift ) into the field:
3261 right = right[:-1] + ')'
3262 value = value[:-1] + ' '
3263
3264 newfield = left+right
3265 if pos_adjust:
3266 newfield = newfield.rjust(end-start)
3267 newpos += pos_adjust
3268 ## dbg("left='%s', right ='%s', newfield='%s'" %(left, right, newfield))
3269 newstr = value[:start] + newfield + value[end:]
3270
3271 pos = newpos
3272
3273 else:
3274 if sel_start == sel_to:
3275 ## dbg("current sel_start, sel_to:", sel_start, sel_to)
3276 if key == wx.WXK_BACK:
3277 sel_start, sel_to = sel_to-1, sel_to-1
3278 ## dbg("new sel_start, sel_to:", sel_start, sel_to)
3279
3280 if field._padZero and not value[start:sel_to].replace('0', '').replace(' ','').replace(field._fillChar, ''):
3281 # preceding chars (if any) are zeros, blanks or fillchar; new char should be 0:
3282 newchar = '0'
3283 else:
3284 newchar = self._template[sel_to] ## get an original template character to "clear" the current char
3285 ## dbg('value = "%s"' % value, 'value[%d] = "%s"' %(sel_start, value[sel_start]))
3286
3287 if self._isTemplateChar(sel_to):
3288 if sel_to == 0 and self._signOk and value[sel_to] == '-': # erasing "template" sign char
3289 newstr = ' ' + value[1:]
3290 sel_to += 1
3291 elif self._signOk and self._useParens and (value[sel_to] == ')' or value[sel_to] == '('):
3292 # allow "change sign" by removing both parens:
3293 newstr = value[:self._signpos] + ' ' + value[self._signpos+1:-1] + ' '
3294 else:
3295 newstr = value
3296 newpos = sel_to
3297 else:
3298 if field._insertRight and sel_start == sel_to:
3299 # force non-insert-right behavior, by selecting char to be replaced:
3300 sel_to += 1
3301 newstr, ignore = self._insertKey(newchar, sel_start, sel_start, sel_to, value)
3302
3303 else:
3304 # selection made
3305 newstr = self._eraseSelection(value, sel_start, sel_to)
3306
3307 pos = sel_start # put cursor back at beginning of selection
3308
3309 if self._signOk and self._useParens:
3310 # account for resultant unbalanced parentheses:
3311 left_signpos = newstr.find('(')
3312 right_signpos = newstr.find(')')
3313
3314 if left_signpos == -1 and right_signpos != -1:
3315 # erased left-sign marker; get rid of right sign marker:
3316 newstr = newstr[:right_signpos] + ' ' + newstr[right_signpos+1:]
3317
3318 elif left_signpos != -1 and right_signpos == -1:
3319 # erased right-sign marker; get rid of left-sign marker:
3320 newstr = newstr[:left_signpos] + ' ' + newstr[left_signpos+1:]
3321
3322 ## dbg("oldstr:'%s'" % value, 'oldpos:', oldstart)
3323 ## dbg("newstr:'%s'" % newstr, 'pos:', pos)
3324
3325 # if erasure results in an invalid field, disallow it:
3326 ## dbg('field._validRequired?', field._validRequired)
3327 ## dbg('field.IsValid("%s")?' % newstr[start:end], field.IsValid(newstr[start:end]))
3328 if field._validRequired and not field.IsValid(newstr[start:end]):
3329 if not wx.Validator_IsSilent():
3330 wx.Bell()
3331 ## dbg(indent=0)
3332 return False
3333
3334 # if erasure results in an invalid value, disallow it:
3335 if self._ctrl_constraints._validRequired and not self.IsValid(newstr):
3336 if not wx.Validator_IsSilent():
3337 wx.Bell()
3338 ## dbg(indent=0)
3339 return False
3340
3341 if just_return_value:
3342 ## dbg(indent=0)
3343 return newstr
3344
3345 # else...
3346 ## dbg('setting value (later) to', newstr)
3347 wx.CallAfter(self._SetValue, newstr)
3348 ## dbg('setting insertion point (later) to', pos)
3349 wx.CallAfter(self._SetInsertionPoint, pos)
3350 ## dbg(indent=0)
3351 if newstr != value:
3352 self.modified = True
3353 return False
3354
3355
3356 def _OnEnd(self,event):
3357 """ Handles End keypress in control. Should return False to skip other processing. """
3358 ## dbg("MaskedEditMixin::_OnEnd", indent=1)
3359 pos = self._adjustPos(self._GetInsertionPoint(), event.GetKeyCode())
3360 if not event.ControlDown():
3361 end = self._masklength # go to end of control
3362 if self._signOk and self._useParens:
3363 end = end - 1 # account for reserved char at end
3364 else:
3365 end_of_input = self._goEnd(getPosOnly=True)
3366 sel_start, sel_to = self._GetSelection()
3367 if sel_to < pos: sel_to = pos
3368 field = self._FindField(sel_to)
3369 field_end = self._FindField(end_of_input)
3370
3371 # pick different end point if either:
3372 # - cursor not in same field
3373 # - or at or past last input already
3374 # - or current selection = end of current field:
3375 #### dbg('field != field_end?', field != field_end)
3376 #### dbg('sel_to >= end_of_input?', sel_to >= end_of_input)
3377 if field != field_end or sel_to >= end_of_input:
3378 edit_start, edit_end = field._extent
3379 #### dbg('edit_end:', edit_end)
3380 #### dbg('sel_to:', sel_to)
3381 #### dbg('sel_to == edit_end?', sel_to == edit_end)
3382 #### dbg('field._index < self._field_indices[-1]?', field._index < self._field_indices[-1])
3383
3384 if sel_to == edit_end and field._index < self._field_indices[-1]:
3385 edit_start, edit_end = self._FindFieldExtent(self._findNextEntry(edit_end)) # go to end of next field:
3386 end = edit_end
3387 ## dbg('end moved to', end)
3388
3389 elif sel_to == edit_end and field._index == self._field_indices[-1]:
3390 # already at edit end of last field; select to end of control:
3391 end = self._masklength
3392 ## dbg('end moved to', end)
3393 else:
3394 end = edit_end # select to end of current field
3395 ## dbg('end moved to ', end)
3396 else:
3397 # select to current end of input
3398 end = end_of_input
3399
3400
3401 #### dbg('pos:', pos, 'end:', end)
3402
3403 if event.ShiftDown():
3404 if not event.ControlDown():
3405 ## dbg("shift-end; select to end of control")
3406 pass
3407 else:
3408 ## dbg("shift-ctrl-end; select to end of non-whitespace")
3409 pass
3410 wx.CallAfter(self._SetInsertionPoint, pos)
3411 wx.CallAfter(self._SetSelection, pos, end)
3412 else:
3413 if not event.ControlDown():
3414 ## dbg('go to end of control:')
3415 pass
3416 wx.CallAfter(self._SetInsertionPoint, end)
3417 wx.CallAfter(self._SetSelection, end, end)
3418
3419 ## dbg(indent=0)
3420 return False
3421
3422
3423 def _OnReturn(self, event):
3424 """
3425 Swallows the return, issues a Navigate event instead, since
3426 masked controls are "single line" by defn.
3427 """
3428 ## dbg('MaskedEditMixin::OnReturn')
3429 self.Navigate(True)
3430 return False
3431
3432
3433 def _OnHome(self,event):
3434 """ Handles Home keypress in control. Should return False to skip other processing."""
3435 ## dbg("MaskedEditMixin::_OnHome", indent=1)
3436 pos = self._adjustPos(self._GetInsertionPoint(), event.GetKeyCode())
3437 sel_start, sel_to = self._GetSelection()
3438
3439 # There are 5 cases here:
3440
3441 # 1) shift: select from start of control to end of current
3442 # selection.
3443 if event.ShiftDown() and not event.ControlDown():
3444 ## dbg("shift-home; select to start of control")
3445 start = 0
3446 end = sel_start
3447
3448 # 2) no shift, no control: move cursor to beginning of control.
3449 elif not event.ControlDown():
3450 ## dbg("home; move to start of control")
3451 start = 0
3452 end = 0
3453
3454 # 3) No shift, control: move cursor back to beginning of field; if
3455 # there already, go to beginning of previous field.
3456 # 4) shift, control, start of selection not at beginning of control:
3457 # move sel_start back to start of field; if already there, go to
3458 # start of previous field.
3459 elif( event.ControlDown()
3460 and (not event.ShiftDown()
3461 or (event.ShiftDown() and sel_start > 0) ) ):
3462 if len(self._field_indices) > 1:
3463 field = self._FindField(sel_start)
3464 start, ignore = field._extent
3465 if sel_start == start and field._index != self._field_indices[0]: # go to start of previous field:
3466 start, ignore = self._FindFieldExtent(sel_start-1)
3467 elif sel_start == start:
3468 start = 0 # go to literal beginning if edit start
3469 # not at that point
3470 end_of_field = True
3471
3472 else:
3473 start = 0
3474
3475 if not event.ShiftDown():
3476 ## dbg("ctrl-home; move to beginning of field")
3477 end = start
3478 else:
3479 ## dbg("shift-ctrl-home; select to beginning of field")
3480 end = sel_to
3481
3482 else:
3483 # 5) shift, control, start of selection at beginning of control:
3484 # unselect by moving sel_to backward to beginning of current field;
3485 # if already there, move to start of previous field.
3486 start = sel_start
3487 if len(self._field_indices) > 1:
3488 # find end of previous field:
3489 field = self._FindField(sel_to)
3490 if sel_to > start and field._index != self._field_indices[0]:
3491 ignore, end = self._FindFieldExtent(field._extent[0]-1)
3492 else:
3493 end = start
3494 end_of_field = True
3495 else:
3496 end = start
3497 end_of_field = False
3498 ## dbg("shift-ctrl-home; unselect to beginning of field")
3499
3500 ## dbg('queuing new sel_start, sel_to:', (start, end))
3501 wx.CallAfter(self._SetInsertionPoint, start)
3502 wx.CallAfter(self._SetSelection, start, end)
3503 ## dbg(indent=0)
3504 return False
3505
3506
3507 def _OnChangeField(self, event):
3508 """
3509 Primarily handles TAB events, but can be used for any key that
3510 designer wants to change fields within a masked edit control.
3511 """
3512 ## dbg('MaskedEditMixin::_OnChangeField', indent = 1)
3513 # determine end of current field:
3514 pos = self._GetInsertionPoint()
3515 ## dbg('current pos:', pos)
3516 sel_start, sel_to = self._GetSelection()
3517
3518 if self._masklength < 0: # no fields; process tab normally
3519 self._AdjustField(pos)
3520 if event.GetKeyCode() == wx.WXK_TAB:
3521 ## dbg('tab to next ctrl')
3522 # As of 2.5.2, you don't call event.Skip() to do
3523 # this, but instead force explicit navigation, if
3524 # wx.TE_PROCESS_TAB is used (like in the masked edits)
3525 self.Navigate(True)
3526 #else: do nothing
3527 ## dbg(indent=0)
3528 return False
3529
3530
3531 if event.ShiftDown():
3532
3533 # "Go backward"
3534
3535 # NOTE: doesn't yet work with SHIFT-tab under wx; the control
3536 # never sees this event! (But I've coded for it should it ever work,
3537 # and it *does* work for '.' in IpAddrCtrl.)
3538 field = self._FindField(pos)
3539 index = field._index
3540 field_start = field._extent[0]
3541 if pos < field_start:
3542 ## dbg('cursor before 1st field; cannot change to a previous field')
3543 if not wx.Validator_IsSilent():
3544 wx.Bell()
3545 return False
3546
3547 if event.ControlDown():
3548 ## dbg('queuing select to beginning of field:', field_start, pos)
3549 wx.CallAfter(self._SetInsertionPoint, field_start)
3550 wx.CallAfter(self._SetSelection, field_start, pos)
3551 ## dbg(indent=0)
3552 return False
3553
3554 elif index == 0:
3555 # We're already in the 1st field; process shift-tab normally:
3556 self._AdjustField(pos)
3557 if event.GetKeyCode() == wx.WXK_TAB:
3558 ## dbg('tab to previous ctrl')
3559 # As of 2.5.2, you don't call event.Skip() to do
3560 # this, but instead force explicit navigation, if
3561 # wx.TE_PROCESS_TAB is used (like in the masked edits)
3562 self.Navigate(False)
3563 else:
3564 ## dbg('position at beginning')
3565 wx.CallAfter(self._SetInsertionPoint, field_start)
3566 ## dbg(indent=0)
3567 return False
3568 else:
3569 # find beginning of previous field:
3570 begin_prev = self._FindField(field_start-1)._extent[0]
3571 self._AdjustField(pos)
3572 ## dbg('repositioning to', begin_prev)
3573 wx.CallAfter(self._SetInsertionPoint, begin_prev)
3574 if self._FindField(begin_prev)._selectOnFieldEntry:
3575 edit_start, edit_end = self._FindFieldExtent(begin_prev)
3576 ## dbg('queuing selection to (%d, %d)' % (edit_start, edit_end))
3577 wx.CallAfter(self._SetInsertionPoint, edit_start)
3578 wx.CallAfter(self._SetSelection, edit_start, edit_end)
3579 ## dbg(indent=0)
3580 return False
3581
3582 else:
3583 # "Go forward"
3584 field = self._FindField(sel_to)
3585 field_start, field_end = field._extent
3586 if event.ControlDown():
3587 ## dbg('queuing select to end of field:', pos, field_end)
3588 wx.CallAfter(self._SetInsertionPoint, pos)
3589 wx.CallAfter(self._SetSelection, pos, field_end)
3590 ## dbg(indent=0)
3591 return False
3592 else:
3593 if pos < field_start:
3594 ## dbg('cursor before 1st field; go to start of field')
3595 wx.CallAfter(self._SetInsertionPoint, field_start)
3596 if field._selectOnFieldEntry:
3597 wx.CallAfter(self._SetSelection, field_start, field_end)
3598 else:
3599 wx.CallAfter(self._SetSelection, field_start, field_start)
3600 return False
3601 # else...
3602 ## dbg('end of current field:', field_end)
3603 ## dbg('go to next field')
3604 if field_end == self._fields[self._field_indices[-1]]._extent[1]:
3605 self._AdjustField(pos)
3606 if event.GetKeyCode() == wx.WXK_TAB:
3607 ## dbg('tab to next ctrl')
3608 # As of 2.5.2, you don't call event.Skip() to do
3609 # this, but instead force explicit navigation, if
3610 # wx.TE_PROCESS_TAB is used (like in the masked edits)
3611 self.Navigate(True)
3612 else:
3613 ## dbg('position at end')
3614 wx.CallAfter(self._SetInsertionPoint, field_end)
3615 ## dbg(indent=0)
3616 return False
3617 else:
3618 # we have to find the start of the next field
3619 next_pos = self._findNextEntry(field_end)
3620 if next_pos == field_end:
3621 ## dbg('already in last field')
3622 self._AdjustField(pos)
3623 if event.GetKeyCode() == wx.WXK_TAB:
3624 ## dbg('tab to next ctrl')
3625 # As of 2.5.2, you don't call event.Skip() to do
3626 # this, but instead force explicit navigation, if
3627 # wx.TE_PROCESS_TAB is used (like in the masked edits)
3628 self.Navigate(True)
3629 #else: do nothing
3630 ## dbg(indent=0)
3631 return False
3632 else:
3633 self._AdjustField( pos )
3634
3635 # move cursor to appropriate point in the next field and select as necessary:
3636 field = self._FindField(next_pos)
3637 edit_start, edit_end = field._extent
3638 if field._selectOnFieldEntry:
3639 ## dbg('move to ', next_pos)
3640 wx.CallAfter(self._SetInsertionPoint, next_pos)
3641 edit_start, edit_end = self._FindFieldExtent(next_pos)
3642 ## dbg('queuing select', edit_start, edit_end)
3643 wx.CallAfter(self._SetSelection, edit_start, edit_end)
3644 else:
3645 if field._insertRight:
3646 next_pos = field._extent[1]
3647 ## dbg('move to ', next_pos)
3648 wx.CallAfter(self._SetInsertionPoint, next_pos)
3649 ## dbg(indent=0)
3650 return False
3651
3652
3653 def _OnDecimalPoint(self, event):
3654 ## dbg('MaskedEditMixin::_OnDecimalPoint', indent=1)
3655
3656 pos = self._adjustPos(self._GetInsertionPoint(), event.GetKeyCode())
3657
3658 if self._isFloat: ## handle float value, move to decimal place
3659 ## dbg('key == Decimal tab; decimal pos:', self._decimalpos)
3660 value = self._GetValue()
3661 if pos < self._decimalpos:
3662 clipped_text = value[0:pos] + self._decimalChar + value[self._decimalpos+1:]
3663 ## dbg('value: "%s"' % self._GetValue(), "clipped_text:'%s'" % clipped_text)
3664 newstr = self._adjustFloat(clipped_text)
3665 else:
3666 newstr = self._adjustFloat(value)
3667 wx.CallAfter(self._SetValue, newstr)
3668 fraction = self._fields[1]
3669 start, end = fraction._extent
3670 wx.CallAfter(self._SetInsertionPoint, start)
3671 if fraction._selectOnFieldEntry:
3672 ## dbg('queuing selection after decimal point to:', (start, end))
3673 wx.CallAfter(self._SetSelection, start, end)
3674 else:
3675 wx.CallAfter(self._SetSelection, start, start)
3676 keep_processing = False
3677
3678 if self._isInt: ## handle integer value, truncate from current position
3679 ## dbg('key == Integer decimal event')
3680 value = self._GetValue()
3681 clipped_text = value[0:pos]
3682 ## dbg('value: "%s"' % self._GetValue(), "clipped_text:'%s'" % clipped_text)
3683 newstr = self._adjustInt(clipped_text)
3684 ## dbg('newstr: "%s"' % newstr)
3685 wx.CallAfter(self._SetValue, newstr)
3686 newpos = len(newstr.rstrip())
3687 if newstr.find(')') != -1:
3688 newpos -= 1 # (don't move past right paren)
3689 wx.CallAfter(self._SetInsertionPoint, newpos)
3690 wx.CallAfter(self._SetSelection, newpos, newpos)
3691 keep_processing = False
3692 ## dbg(indent=0)
3693
3694
3695 def _OnChangeSign(self, event):
3696 ## dbg('MaskedEditMixin::_OnChangeSign', indent=1)
3697 key = event.GetKeyCode()
3698 pos = self._adjustPos(self._GetInsertionPoint(), key)
3699 value = self._eraseSelection()
3700 integer = self._fields[0]
3701 start, end = integer._extent
3702
3703 #### dbg('adjusted pos:', pos)
3704 if chr(key) in ('-','+','(', ')') or (chr(key) == " " and pos == self._signpos):
3705 cursign = self._isNeg
3706 ## dbg('cursign:', cursign)
3707 if chr(key) in ('-','(', ')'):
3708 self._isNeg = (not self._isNeg) ## flip value
3709 else:
3710 self._isNeg = False
3711 ## dbg('isNeg?', self._isNeg)
3712
3713 text, self._signpos, self._right_signpos = self._getSignedValue(candidate=value)
3714 ## dbg('text:"%s"' % text, 'signpos:', self._signpos, 'right_signpos:', self._right_signpos)
3715 if text is None:
3716 text = value
3717
3718 if self._isNeg and self._signpos is not None and self._signpos != -1:
3719 if self._useParens and self._right_signpos is not None:
3720 text = text[:self._signpos] + '(' + text[self._signpos+1:self._right_signpos] + ')' + text[self._right_signpos+1:]
3721 else:
3722 text = text[:self._signpos] + '-' + text[self._signpos+1:]
3723 else:
3724 #### dbg('self._isNeg?', self._isNeg, 'self.IsValid(%s)' % text, self.IsValid(text))
3725 if self._useParens:
3726 text = text[:self._signpos] + ' ' + text[self._signpos+1:self._right_signpos] + ' ' + text[self._right_signpos+1:]
3727 else:
3728 text = text[:self._signpos] + ' ' + text[self._signpos+1:]
3729 ## dbg('clearing self._isNeg')
3730 self._isNeg = False
3731
3732 wx.CallAfter(self._SetValue, text)
3733 wx.CallAfter(self._applyFormatting)
3734 ## dbg('pos:', pos, 'signpos:', self._signpos)
3735 if pos == self._signpos or integer.IsEmpty(text[start:end]):
3736 wx.CallAfter(self._SetInsertionPoint, self._signpos+1)
3737 else:
3738 wx.CallAfter(self._SetInsertionPoint, pos)
3739
3740 keep_processing = False
3741 else:
3742 keep_processing = True
3743 ## dbg(indent=0)
3744 return keep_processing
3745
3746
3747 def _OnGroupChar(self, event):
3748 """
3749 This handler is only registered if the mask is a numeric mask.
3750 It allows the insertion of ',' or '.' if appropriate.
3751 """
3752 ## dbg('MaskedEditMixin::_OnGroupChar', indent=1)
3753 keep_processing = True
3754 pos = self._adjustPos(self._GetInsertionPoint(), event.GetKeyCode())
3755 sel_start, sel_to = self._GetSelection()
3756 groupchar = self._fields[0]._groupChar
3757 if not self._isCharAllowed(groupchar, pos, checkRegex=True):
3758 keep_processing = False
3759 if not wx.Validator_IsSilent():
3760 wx.Bell()
3761
3762 if keep_processing:
3763 newstr, newpos = self._insertKey(groupchar, pos, sel_start, sel_to, self._GetValue() )
3764 ## dbg("str with '%s' inserted:" % groupchar, '"%s"' % newstr)
3765 if self._ctrl_constraints._validRequired and not self.IsValid(newstr):
3766 keep_processing = False
3767 if not wx.Validator_IsSilent():
3768 wx.Bell()
3769
3770 if keep_processing:
3771 wx.CallAfter(self._SetValue, newstr)
3772 wx.CallAfter(self._SetInsertionPoint, newpos)
3773 keep_processing = False
3774 ## dbg(indent=0)
3775 return keep_processing
3776
3777
3778 def _findNextEntry(self,pos, adjustInsert=True):
3779 """ Find the insertion point for the next valid entry character position."""
3780 if self._isTemplateChar(pos): # if changing fields, pay attn to flag
3781 adjustInsert = adjustInsert
3782 else: # else within a field; flag not relevant
3783 adjustInsert = False
3784
3785 while self._isTemplateChar(pos) and pos < self._masklength:
3786 pos += 1
3787
3788 # if changing fields, and we've been told to adjust insert point,
3789 # look at new field; if empty and right-insert field,
3790 # adjust to right edge:
3791 if adjustInsert and pos < self._masklength:
3792 field = self._FindField(pos)
3793 start, end = field._extent
3794 slice = self._GetValue()[start:end]
3795 if field._insertRight and field.IsEmpty(slice):
3796 pos = end
3797 return pos
3798
3799
3800 def _findNextTemplateChar(self, pos):
3801 """ Find the position of the next non-editable character in the mask."""
3802 while not self._isTemplateChar(pos) and pos < self._masklength:
3803 pos += 1
3804 return pos
3805
3806
3807 def _OnAutoCompleteField(self, event):
3808 ## dbg('MaskedEditMixin::_OnAutoCompleteField', indent =1)
3809 pos = self._GetInsertionPoint()
3810 field = self._FindField(pos)
3811 edit_start, edit_end, slice = self._FindFieldExtent(pos, getslice=True)
3812
3813 match_index = None
3814 keycode = event.GetKeyCode()
3815
3816 if field._fillChar != ' ':
3817 text = slice.replace(field._fillChar, '')
3818 else:
3819 text = slice
3820 text = text.strip()
3821 keep_processing = True # (assume True to start)
3822 ## dbg('field._hasList?', field._hasList)
3823 if field._hasList:
3824 ## dbg('choices:', field._choices)
3825 ## dbg('compareChoices:', field._compareChoices)
3826 choices, choice_required = field._compareChoices, field._choiceRequired
3827 if keycode in (wx.WXK_PRIOR, wx.WXK_UP):
3828 direction = -1
3829 else:
3830 direction = 1
3831 match_index, partial_match = self._autoComplete(direction, choices, text, compareNoCase=field._compareNoCase, current_index = field._autoCompleteIndex)
3832 if( match_index is None
3833 and (keycode in self._autoCompleteKeycodes + [wx.WXK_PRIOR, wx.WXK_NEXT]
3834 or (keycode in [wx.WXK_UP, wx.WXK_DOWN] and event.ShiftDown() ) ) ):
3835 # Select the 1st thing from the list:
3836 match_index = 0
3837
3838 if( match_index is not None
3839 and ( keycode in self._autoCompleteKeycodes + [wx.WXK_PRIOR, wx.WXK_NEXT]
3840 or (keycode in [wx.WXK_UP, wx.WXK_DOWN] and event.ShiftDown())
3841 or (keycode == wx.WXK_DOWN and partial_match) ) ):
3842
3843 # We're allowed to auto-complete:
3844 ## dbg('match found')
3845 value = self._GetValue()
3846 newvalue = value[:edit_start] + field._choices[match_index] + value[edit_end:]
3847 ## dbg('setting value to "%s"' % newvalue)
3848 self._SetValue(newvalue)
3849 self._SetInsertionPoint(min(edit_end, len(newvalue.rstrip())))
3850 self._OnAutoSelect(field, match_index)
3851 self._CheckValid() # recolor as appopriate
3852
3853
3854 if keycode in (wx.WXK_UP, wx.WXK_DOWN, wx.WXK_LEFT, wx.WXK_RIGHT):
3855 # treat as left right arrow if unshifted, tab/shift tab if shifted.
3856 if event.ShiftDown():
3857 if keycode in (wx.WXK_DOWN, wx.WXK_RIGHT):
3858 # remove "shifting" and treat as (forward) tab:
3859 event.m_shiftDown = False
3860 keep_processing = self._OnChangeField(event)
3861 else:
3862 keep_processing = self._OnArrow(event)
3863 # else some other key; keep processing the key
3864
3865 ## dbg('keep processing?', keep_processing, indent=0)
3866 return keep_processing
3867
3868
3869 def _OnAutoSelect(self, field, match_index = None):
3870 """
3871 Function called if autoselect feature is enabled and entire control
3872 is selected:
3873 """
3874 ## dbg('MaskedEditMixin::OnAutoSelect', field._index)
3875 if match_index is not None:
3876 field._autoCompleteIndex = match_index
3877
3878
3879 def _autoComplete(self, direction, choices, value, compareNoCase, current_index):
3880 """
3881 This function gets called in response to Auto-complete events.
3882 It attempts to find a match to the specified value against the
3883 list of choices; if exact match, the index of then next
3884 appropriate value in the list, based on the given direction.
3885 If not an exact match, it will return the index of the 1st value from
3886 the choice list for which the partial value can be extended to match.
3887 If no match found, it will return None.
3888 The function returns a 2-tuple, with the 2nd element being a boolean
3889 that indicates if partial match was necessary.
3890 """
3891 ## dbg('autoComplete(direction=', direction, 'choices=',choices, 'value=',value,'compareNoCase?', compareNoCase, 'current_index:', current_index, indent=1)
3892 if value is None:
3893 ## dbg('nothing to match against', indent=0)
3894 return (None, False)
3895
3896 partial_match = False
3897
3898 if compareNoCase:
3899 value = value.lower()
3900
3901 last_index = len(choices) - 1
3902 if value in choices:
3903 ## dbg('"%s" in', choices)
3904 if current_index is not None and choices[current_index] == value:
3905 index = current_index
3906 else:
3907 index = choices.index(value)
3908
3909 ## dbg('matched "%s" (%d)' % (choices[index], index))
3910 if direction == -1:
3911 ## dbg('going to previous')
3912 if index == 0: index = len(choices) - 1
3913 else: index -= 1
3914 else:
3915 if index == len(choices) - 1: index = 0
3916 else: index += 1
3917 ## dbg('change value to "%s" (%d)' % (choices[index], index))
3918 match = index
3919 else:
3920 partial_match = True
3921 value = value.strip()
3922 ## dbg('no match; try to auto-complete:')
3923 match = None
3924 ## dbg('searching for "%s"' % value)
3925 if current_index is None:
3926 indices = range(len(choices))
3927 if direction == -1:
3928 indices.reverse()
3929 else:
3930 if direction == 1:
3931 indices = range(current_index +1, len(choices)) + range(current_index+1)
3932 ## dbg('range(current_index+1 (%d), len(choices) (%d)) + range(%d):' % (current_index+1, len(choices), current_index+1), indices)
3933 else:
3934 indices = range(current_index-1, -1, -1) + range(len(choices)-1, current_index-1, -1)
3935 ## dbg('range(current_index-1 (%d), -1) + range(len(choices)-1 (%d)), current_index-1 (%d):' % (current_index-1, len(choices)-1, current_index-1), indices)
3936 #### dbg('indices:', indices)
3937 for index in indices:
3938 choice = choices[index]
3939 if choice.find(value, 0) == 0:
3940 ## dbg('match found:', choice)
3941 match = index
3942 break
3943 else: dbg('choice: "%s" - no match' % choice)
3944 if match is not None:
3945 ## dbg('matched', match)
3946 pass
3947 else:
3948 ## dbg('no match found')
3949 pass
3950 ## dbg(indent=0)
3951 return (match, partial_match)
3952
3953
3954 def _AdjustField(self, pos):
3955 """
3956 This function gets called by default whenever the cursor leaves a field.
3957 The pos argument given is the char position before leaving that field.
3958 By default, floating point, integer and date values are adjusted to be
3959 legal in this function. Derived classes may override this function
3960 to modify the value of the control in a different way when changing fields.
3961
3962 NOTE: these change the value immediately, and restore the cursor to
3963 the passed location, so that any subsequent code can then move it
3964 based on the operation being performed.
3965 """
3966 newvalue = value = self._GetValue()
3967 field = self._FindField(pos)
3968 start, end, slice = self._FindFieldExtent(getslice=True)
3969 newfield = field._AdjustField(slice)
3970 newvalue = value[:start] + newfield + value[end:]
3971
3972 if self._isFloat and newvalue != self._template:
3973 newvalue = self._adjustFloat(newvalue)
3974
3975 if self._ctrl_constraints._isInt and value != self._template:
3976 newvalue = self._adjustInt(value)
3977
3978 if self._isDate and value != self._template:
3979 newvalue = self._adjustDate(value, fixcentury=True)
3980 if self._4digityear:
3981 year2dig = self._dateExtent - 2
3982 if pos == year2dig and value[year2dig] != newvalue[year2dig]:
3983 pos = pos+2
3984
3985 if newvalue != value:
3986 ## dbg('old value: "%s"\nnew value: "%s"' % (value, newvalue))
3987 self._SetValue(newvalue)
3988 self._SetInsertionPoint(pos)
3989
3990
3991 def _adjustKey(self, pos, key):
3992 """ Apply control formatting to the key (e.g. convert to upper etc). """
3993 field = self._FindField(pos)
3994 if field._forceupper and key in range(97,123):
3995 key = ord( chr(key).upper())
3996
3997 if field._forcelower and key in range(97,123):
3998 key = ord( chr(key).lower())
3999
4000 return key
4001
4002
4003 def _adjustPos(self, pos, key):
4004 """
4005 Checks the current insertion point position and adjusts it if
4006 necessary to skip over non-editable characters.
4007 """
4008 ## dbg('_adjustPos', pos, key, indent=1)
4009 sel_start, sel_to = self._GetSelection()
4010 # If a numeric or decimal mask, and negatives allowed, reserve the
4011 # first space for sign, and last one if using parens.
4012 if( self._signOk
4013 and ((pos == self._signpos and key in (ord('-'), ord('+'), ord(' ')) )
4014 or self._useParens and pos == self._masklength -1)):
4015 ## dbg('adjusted pos:', pos, indent=0)
4016 return pos
4017
4018 if key not in self._nav:
4019 field = self._FindField(pos)
4020
4021 ## dbg('field._insertRight?', field._insertRight)
4022 if field._insertRight: # if allow right-insert
4023 start, end = field._extent
4024 slice = self._GetValue()[start:end].strip()
4025 field_len = end - start
4026 if pos == end: # if cursor at right edge of field
4027 # if not filled or supposed to stay in field, keep current position
4028 #### dbg('pos==end')
4029 #### dbg('len (slice):', len(slice))
4030 #### dbg('field_len?', field_len)
4031 #### dbg('pos==end; len (slice) < field_len?', len(slice) < field_len)
4032 #### dbg('not field._moveOnFieldFull?', not field._moveOnFieldFull)
4033 if len(slice) == field_len and field._moveOnFieldFull:
4034 # move cursor to next field:
4035 pos = self._findNextEntry(pos)
4036 self._SetInsertionPoint(pos)
4037 if pos < sel_to:
4038 self._SetSelection(pos, sel_to) # restore selection
4039 else:
4040 self._SetSelection(pos, pos) # remove selection
4041 else: # leave cursor alone
4042 pass
4043 else:
4044 # if at start of control, move to right edge
4045 if (sel_to == sel_start
4046 and (self._isTemplateChar(pos) or (pos == start and len(slice)+ 1 < field_len))
4047 and pos != end):
4048 pos = end # move to right edge
4049 ## elif sel_start <= start and sel_to == end:
4050 ## # select to right edge of field - 1 (to replace char)
4051 ## pos = end - 1
4052 ## self._SetInsertionPoint(pos)
4053 ## # restore selection
4054 ## self._SetSelection(sel_start, pos)
4055
4056 elif self._signOk and sel_start == 0: # if selected to beginning and signed,
4057 # adjust to past reserved sign position:
4058 pos = self._fields[0]._extent[0]
4059 self._SetInsertionPoint(pos)
4060 # restore selection
4061 self._SetSelection(pos, sel_to)
4062 else:
4063 pass # leave position/selection alone
4064
4065 # else make sure the user is not trying to type over a template character
4066 # If they are, move them to the next valid entry position
4067 elif self._isTemplateChar(pos):
4068 if( not field._moveOnFieldFull
4069 and (not self._signOk
4070 or (self._signOk
4071 and field._index == 0
4072 and pos > 0) ) ): # don't move to next field without explicit cursor movement
4073 pass
4074 else:
4075 # find next valid position
4076 pos = self._findNextEntry(pos)
4077 self._SetInsertionPoint(pos)
4078 if pos < sel_to: # restore selection
4079 self._SetSelection(pos, sel_to)
4080 else:
4081 self._SetSelection(pos, pos)
4082 ## dbg('adjusted pos:', pos, indent=0)
4083 return pos
4084
4085
4086 def _adjustFloat(self, candidate=None):
4087 """
4088 'Fixes' an floating point control. Collapses spaces, right-justifies, etc.
4089 """
4090 ## dbg('MaskedEditMixin::_adjustFloat, candidate = "%s"' % candidate, indent=1)
4091 lenInt,lenFraction = [len(s) for s in self._mask.split('.')] ## Get integer, fraction lengths
4092
4093 if candidate is None: value = self._GetValue()
4094 else: value = candidate
4095 ## dbg('value = "%(value)s"' % locals(), 'len(value):', len(value))
4096 intStr, fracStr = value.split(self._decimalChar)
4097
4098 intStr = self._fields[0]._AdjustField(intStr)
4099 ## dbg('adjusted intStr: "%s"' % intStr)
4100 lenInt = len(intStr)
4101 fracStr = fracStr + ('0'*(lenFraction-len(fracStr))) # add trailing spaces to decimal
4102
4103 ## dbg('intStr "%(intStr)s"' % locals())
4104 ## dbg('lenInt:', lenInt)
4105
4106 intStr = string.rjust( intStr[-lenInt:], lenInt)
4107 ## dbg('right-justifed intStr = "%(intStr)s"' % locals())
4108 newvalue = intStr + self._decimalChar + fracStr
4109
4110 if self._signOk:
4111 if len(newvalue) < self._masklength:
4112 newvalue = ' ' + newvalue
4113 signedvalue = self._getSignedValue(newvalue)[0]
4114 if signedvalue is not None: newvalue = signedvalue
4115
4116 # Finally, align string with decimal position, left-padding with
4117 # fillChar:
4118 newdecpos = newvalue.find(self._decimalChar)
4119 if newdecpos < self._decimalpos:
4120 padlen = self._decimalpos - newdecpos
4121 newvalue = string.join([' ' * padlen] + [newvalue] ,'')
4122
4123 if self._signOk and self._useParens:
4124 if newvalue.find('(') != -1:
4125 newvalue = newvalue[:-1] + ')'
4126 else:
4127 newvalue = newvalue[:-1] + ' '
4128
4129 ## dbg('newvalue = "%s"' % newvalue)
4130 if candidate is None:
4131 wx.CallAfter(self._SetValue, newvalue)
4132 ## dbg(indent=0)
4133 return newvalue
4134
4135
4136 def _adjustInt(self, candidate=None):
4137 """ 'Fixes' an integer control. Collapses spaces, right or left-justifies."""
4138 ## dbg("MaskedEditMixin::_adjustInt", candidate)
4139 lenInt = self._masklength
4140 if candidate is None: value = self._GetValue()
4141 else: value = candidate
4142
4143 intStr = self._fields[0]._AdjustField(value)
4144 intStr = intStr.strip() # drop extra spaces
4145 ## dbg('adjusted field: "%s"' % intStr)
4146
4147 if self._isNeg and intStr.find('-') == -1 and intStr.find('(') == -1:
4148 if self._useParens:
4149 intStr = '(' + intStr + ')'
4150 else:
4151 intStr = '-' + intStr
4152 elif self._isNeg and intStr.find('-') != -1 and self._useParens:
4153 intStr = intStr.replace('-', '(')
4154
4155 if( self._signOk and ((self._useParens and intStr.find('(') == -1)
4156 or (not self._useParens and intStr.find('-') == -1))):
4157 intStr = ' ' + intStr
4158 if self._useParens:
4159 intStr += ' ' # space for right paren position
4160
4161 elif self._signOk and self._useParens and intStr.find('(') != -1 and intStr.find(')') == -1:
4162 # ensure closing right paren:
4163 intStr += ')'
4164
4165 if self._fields[0]._alignRight: ## Only if right-alignment is enabled
4166 intStr = intStr.rjust( lenInt )
4167 else:
4168 intStr = intStr.ljust( lenInt )
4169
4170 if candidate is None:
4171 wx.CallAfter(self._SetValue, intStr )
4172 return intStr
4173
4174
4175 def _adjustDate(self, candidate=None, fixcentury=False, force4digit_year=False):
4176 """
4177 'Fixes' a date control, expanding the year if it can.
4178 Applies various self-formatting options.
4179 """
4180 ## dbg("MaskedEditMixin::_adjustDate", indent=1)
4181 if candidate is None: text = self._GetValue()
4182 else: text = candidate
4183 ## dbg('text=', text)
4184 if self._datestyle == "YMD":
4185 year_field = 0
4186 else:
4187 year_field = 2
4188
4189 ## dbg('getYear: "%s"' % getYear(text, self._datestyle))
4190 year = string.replace( getYear( text, self._datestyle),self._fields[year_field]._fillChar,"") # drop extra fillChars
4191 month = getMonth( text, self._datestyle)
4192 day = getDay( text, self._datestyle)
4193 ## dbg('self._datestyle:', self._datestyle, 'year:', year, 'Month', month, 'day:', day)
4194
4195 yearVal = None
4196 yearstart = self._dateExtent - 4
4197 if( len(year) < 4
4198 and (fixcentury
4199 or force4digit_year
4200 or (self._GetInsertionPoint() > yearstart+1 and text[yearstart+2] == ' ')
4201 or (self._GetInsertionPoint() > yearstart+2 and text[yearstart+3] == ' ') ) ):
4202 ## user entered less than four digits and changing fields or past point where we could
4203 ## enter another digit:
4204 try:
4205 yearVal = int(year)
4206 except:
4207 ## dbg('bad year=', year)
4208 year = text[yearstart:self._dateExtent]
4209
4210 if len(year) < 4 and yearVal:
4211 if len(year) == 2:
4212 # Fix year adjustment to be less "20th century" :-) and to adjust heuristic as the
4213 # years pass...
4214 now = wx.DateTime_Now()
4215 century = (now.GetYear() /100) * 100 # "this century"
4216 twodig_year = now.GetYear() - century # "this year" (2 digits)
4217 # if separation between today's 2-digit year and typed value > 50,
4218 # assume last century,
4219 # else assume this century.
4220 #
4221 # Eg: if 2003 and yearVal == 30, => 2030
4222 # if 2055 and yearVal == 80, => 2080
4223 # if 2010 and yearVal == 96, => 1996
4224 #
4225 if abs(yearVal - twodig_year) > 50:
4226 yearVal = (century - 100) + yearVal
4227 else:
4228 yearVal = century + yearVal
4229 year = str( yearVal )
4230 else: # pad with 0's to make a 4-digit year
4231 year = "%04d" % yearVal
4232 if self._4digityear or force4digit_year:
4233 text = makeDate(year, month, day, self._datestyle, text) + text[self._dateExtent:]
4234 ## dbg('newdate: "%s"' % text, indent=0)
4235 return text
4236
4237
4238 def _goEnd(self, getPosOnly=False):
4239 """ Moves the insertion point to the end of user-entry """
4240 ## dbg("MaskedEditMixin::_goEnd; getPosOnly:", getPosOnly, indent=1)
4241 text = self._GetValue()
4242 #### dbg('text: "%s"' % text)
4243 i = 0
4244 if len(text.rstrip()):
4245 for i in range( min( self._masklength-1, len(text.rstrip())), -1, -1):
4246 #### dbg('i:', i, 'self._isMaskChar(%d)' % i, self._isMaskChar(i))
4247 if self._isMaskChar(i):
4248 char = text[i]
4249 #### dbg("text[%d]: '%s'" % (i, char))
4250 if char != ' ':
4251 i += 1
4252 break
4253
4254 if i == 0:
4255 pos = self._goHome(getPosOnly=True)
4256 else:
4257 pos = min(i,self._masklength)
4258
4259 field = self._FindField(pos)
4260 start, end = field._extent
4261 if field._insertRight and pos < end:
4262 pos = end
4263 ## dbg('next pos:', pos)
4264 ## dbg(indent=0)
4265 if getPosOnly:
4266 return pos
4267 else:
4268 self._SetInsertionPoint(pos)
4269
4270
4271 def _goHome(self, getPosOnly=False):
4272 """ Moves the insertion point to the beginning of user-entry """
4273 ## dbg("MaskedEditMixin::_goHome; getPosOnly:", getPosOnly, indent=1)
4274 text = self._GetValue()
4275 for i in range(self._masklength):
4276 if self._isMaskChar(i):
4277 break
4278 pos = max(i, 0)
4279 ## dbg(indent=0)
4280 if getPosOnly:
4281 return pos
4282 else:
4283 self._SetInsertionPoint(max(i,0))
4284
4285
4286
4287 def _getAllowedChars(self, pos):
4288 """ Returns a string of all allowed user input characters for the provided
4289 mask character plus control options
4290 """
4291 maskChar = self.maskdict[pos]
4292 okchars = self.maskchardict[maskChar] ## entry, get mask approved characters
4293 field = self._FindField(pos)
4294 if okchars and field._okSpaces: ## Allow spaces?
4295 okchars += " "
4296 if okchars and field._includeChars: ## any additional included characters?
4297 okchars += field._includeChars
4298 #### dbg('okchars[%d]:' % pos, okchars)
4299 return okchars
4300
4301
4302 def _isMaskChar(self, pos):
4303 """ Returns True if the char at position pos is a special mask character (e.g. NCXaA#)
4304 """
4305 if pos < self._masklength:
4306 return self.ismasked[pos]
4307 else:
4308 return False
4309
4310
4311 def _isTemplateChar(self,Pos):
4312 """ Returns True if the char at position pos is a template character (e.g. -not- NCXaA#)
4313 """
4314 if Pos < self._masklength:
4315 return not self._isMaskChar(Pos)
4316 else:
4317 return False
4318
4319
4320 def _isCharAllowed(self, char, pos, checkRegex=False, allowAutoSelect=True, ignoreInsertRight=False):
4321 """ Returns True if character is allowed at the specific position, otherwise False."""
4322 ## dbg('_isCharAllowed', char, pos, checkRegex, indent=1)
4323 field = self._FindField(pos)
4324 right_insert = False
4325
4326 if self.controlInitialized:
4327 sel_start, sel_to = self._GetSelection()
4328 else:
4329 sel_start, sel_to = pos, pos
4330
4331 if (field._insertRight or self._ctrl_constraints._insertRight) and not ignoreInsertRight:
4332 start, end = field._extent
4333 field_len = end - start
4334 if self.controlInitialized:
4335 value = self._GetValue()
4336 fstr = value[start:end].strip()
4337 if field._padZero:
4338 while fstr and fstr[0] == '0':
4339 fstr = fstr[1:]
4340 input_len = len(fstr)
4341 if self._signOk and '-' in fstr or '(' in fstr:
4342 input_len -= 1 # sign can move out of field, so don't consider it in length
4343 else:
4344 value = self._template
4345 input_len = 0 # can't get the current "value", so use 0
4346
4347
4348 # if entire field is selected or position is at end and field is not full,
4349 # or if allowed to right-insert at any point in field and field is not full and cursor is not at a fillChar:
4350 if( (sel_start, sel_to) == field._extent
4351 or (pos == end and input_len < field_len)):
4352 pos = end - 1
4353 ## dbg('pos = end - 1 = ', pos, 'right_insert? 1')
4354 right_insert = True
4355 elif( field._allowInsert and sel_start == sel_to
4356 and (sel_to == end or (sel_to < self._masklength and value[sel_start] != field._fillChar))
4357 and input_len < field_len ):
4358 pos = sel_to - 1 # where character will go
4359 ## dbg('pos = sel_to - 1 = ', pos, 'right_insert? 1')
4360 right_insert = True
4361 # else leave pos alone...
4362 else:
4363 ## dbg('pos stays ', pos, 'right_insert? 0')
4364 pass
4365
4366 if self._isTemplateChar( pos ): ## if a template character, return empty
4367 ## dbg('%d is a template character; returning False' % pos, indent=0)
4368 return False
4369
4370 if self._isMaskChar( pos ):
4371 okChars = self._getAllowedChars(pos)
4372
4373 if self._fields[0]._groupdigits and (self._isInt or (self._isFloat and pos < self._decimalpos)):
4374 okChars += self._fields[0]._groupChar
4375
4376 if self._signOk:
4377 if self._isInt or (self._isFloat and pos < self._decimalpos):
4378 okChars += '-'
4379 if self._useParens:
4380 okChars += '('
4381 elif self._useParens and (self._isInt or (self._isFloat and pos > self._decimalpos)):
4382 okChars += ')'
4383
4384 #### dbg('%s in %s?' % (char, okChars), char in okChars)
4385 approved = char in okChars
4386
4387 if approved and checkRegex:
4388 ## dbg("checking appropriate regex's")
4389 value = self._eraseSelection(self._GetValue())
4390 if right_insert:
4391 at = pos+1
4392 else:
4393 at = pos
4394 if allowAutoSelect:
4395 newvalue, ignore, ignore, ignore, ignore = self._insertKey(char, at, sel_start, sel_to, value, allowAutoSelect=True)
4396 else:
4397 newvalue, ignore = self._insertKey(char, at, sel_start, sel_to, value)
4398 ## dbg('newvalue: "%s"' % newvalue)
4399
4400 fields = [self._FindField(pos)] + [self._ctrl_constraints]
4401 for field in fields: # includes fields[-1] == "ctrl_constraints"
4402 if field._regexMask and field._filter:
4403 ## dbg('checking vs. regex')
4404 start, end = field._extent
4405 slice = newvalue[start:end]
4406 approved = (re.match( field._filter, slice) is not None)
4407 ## dbg('approved?', approved)
4408 if not approved: break
4409 ## dbg(indent=0)
4410 return approved
4411 else:
4412 ## dbg('%d is a !???! character; returning False', indent=0)
4413 return False
4414
4415
4416 def _applyFormatting(self):
4417 """ Apply formatting depending on the control's state.
4418 Need to find a way to call this whenever the value changes, in case the control's
4419 value has been changed or set programatically.
4420 """
4421 ## dbg(suspend=1)
4422 ## dbg('MaskedEditMixin::_applyFormatting', indent=1)
4423
4424 # Handle negative numbers
4425 if self._signOk:
4426 text, signpos, right_signpos = self._getSignedValue()
4427 ## dbg('text: "%s", signpos:' % text, signpos)
4428 if not text or text[signpos] not in ('-','('):
4429 self._isNeg = False
4430 ## dbg('no valid sign found; new sign:', self._isNeg)
4431 if text and signpos != self._signpos:
4432 self._signpos = signpos
4433 elif text and self._valid and not self._isNeg and text[signpos] in ('-', '('):
4434 ## dbg('setting _isNeg to True')
4435 self._isNeg = True
4436 ## dbg('self._isNeg:', self._isNeg)
4437
4438 if self._signOk and self._isNeg:
4439 fc = self._signedForegroundColour
4440 else:
4441 fc = self._foregroundColour
4442
4443 if hasattr(fc, '_name'):
4444 c =fc._name
4445 else:
4446 c = fc
4447 ## dbg('setting foreground to', c)
4448 self.SetForegroundColour(fc)
4449
4450 if self._valid:
4451 ## dbg('valid')
4452 if self.IsEmpty():
4453 bc = self._emptyBackgroundColour
4454 else:
4455 bc = self._validBackgroundColour
4456 else:
4457 ## dbg('invalid')
4458 bc = self._invalidBackgroundColour
4459 if hasattr(bc, '_name'):
4460 c =bc._name
4461 else:
4462 c = bc
4463 ## dbg('setting background to', c)
4464 self.SetBackgroundColour(bc)
4465 self._Refresh()
4466 ## dbg(indent=0, suspend=0)
4467
4468
4469 def _getAbsValue(self, candidate=None):
4470 """ Return an unsigned value (i.e. strip the '-' prefix if any), and sign position(s).
4471 """
4472 ## dbg('MaskedEditMixin::_getAbsValue; candidate="%s"' % candidate, indent=1)
4473 if candidate is None: text = self._GetValue()
4474 else: text = candidate
4475 right_signpos = text.find(')')
4476
4477 if self._isInt:
4478 if self._ctrl_constraints._alignRight and self._fields[0]._fillChar == ' ':
4479 signpos = text.find('-')
4480 if signpos == -1:
4481 ## dbg('no - found; searching for (')
4482 signpos = text.find('(')
4483 elif signpos != -1:
4484 ## dbg('- found at', signpos)
4485 pass
4486
4487 if signpos == -1:
4488 ## dbg('signpos still -1')
4489 ## dbg('len(%s) (%d) < len(%s) (%d)?' % (text, len(text), self._mask, self._masklength), len(text) < self._masklength)
4490 if len(text) < self._masklength:
4491 text = ' ' + text
4492 if len(text) < self._masklength:
4493 text += ' '
4494 if len(text) > self._masklength and text[-1] in (')', ' '):
4495 text = text[:-1]
4496 else:
4497 ## dbg('len(%s) (%d), len(%s) (%d)' % (text, len(text), self._mask, self._masklength))
4498 ## dbg('len(%s) - (len(%s) + 1):' % (text, text.lstrip()) , len(text) - (len(text.lstrip()) + 1))
4499 signpos = len(text) - (len(text.lstrip()) + 1)
4500
4501 if self._useParens and not text.strip():
4502 signpos -= 1 # empty value; use penultimate space
4503 ## dbg('signpos:', signpos)
4504 if signpos >= 0:
4505 text = text[:signpos] + ' ' + text[signpos+1:]
4506
4507 else:
4508 if self._signOk:
4509 signpos = 0
4510 text = self._template[0] + text[1:]
4511 else:
4512 signpos = -1
4513
4514 if right_signpos != -1:
4515 if self._signOk:
4516 text = text[:right_signpos] + ' ' + text[right_signpos+1:]
4517 elif len(text) > self._masklength:
4518 text = text[:right_signpos] + text[right_signpos+1:]
4519 right_signpos = -1
4520
4521
4522 elif self._useParens and self._signOk:
4523 # figure out where it ought to go:
4524 right_signpos = self._masklength - 1 # initial guess
4525 if not self._ctrl_constraints._alignRight:
4526 ## dbg('not right-aligned')
4527 if len(text.strip()) == 0:
4528 right_signpos = signpos + 1
4529 elif len(text.strip()) < self._masklength:
4530 right_signpos = len(text.rstrip())
4531 ## dbg('right_signpos:', right_signpos)
4532
4533 groupchar = self._fields[0]._groupChar
4534 try:
4535 value = long(text.replace(groupchar,'').replace('(','-').replace(')','').replace(' ', ''))
4536 except:
4537 ## dbg('invalid number', indent=0)
4538 return None, signpos, right_signpos
4539
4540 else: # float value
4541 try:
4542 groupchar = self._fields[0]._groupChar
4543 value = float(text.replace(groupchar,'').replace(self._decimalChar, '.').replace('(', '-').replace(')','').replace(' ', ''))
4544 ## dbg('value:', value)
4545 except:
4546 value = None
4547
4548 if value < 0 and value is not None:
4549 signpos = text.find('-')
4550 if signpos == -1:
4551 signpos = text.find('(')
4552
4553 text = text[:signpos] + self._template[signpos] + text[signpos+1:]
4554 else:
4555 # look forwards up to the decimal point for the 1st non-digit
4556 ## dbg('decimal pos:', self._decimalpos)
4557 ## dbg('text: "%s"' % text)
4558 if self._signOk:
4559 signpos = self._decimalpos - (len(text[:self._decimalpos].lstrip()) + 1)
4560 # prevent checking for empty string - Tomo - Wed 14 Jan 2004 03:19:09 PM CET
4561 if len(text) >= signpos+1 and text[signpos+1] in ('-','('):
4562 signpos += 1
4563 else:
4564 signpos = -1
4565 ## dbg('signpos:', signpos)
4566
4567 if self._useParens:
4568 if self._signOk:
4569 right_signpos = self._masklength - 1
4570 text = text[:right_signpos] + ' '
4571 if text[signpos] == '(':
4572 text = text[:signpos] + ' ' + text[signpos+1:]
4573 else:
4574 right_signpos = text.find(')')
4575 if right_signpos != -1:
4576 text = text[:-1]
4577 right_signpos = -1
4578
4579 if value is None:
4580 ## dbg('invalid number')
4581 text = None
4582
4583 ## dbg('abstext = "%s"' % text, 'signpos:', signpos, 'right_signpos:', right_signpos)
4584 ## dbg(indent=0)
4585 return text, signpos, right_signpos
4586
4587
4588 def _getSignedValue(self, candidate=None):
4589 """ Return a signed value by adding a "-" prefix if the value
4590 is set to negative, or a space if positive.
4591 """
4592 ## dbg('MaskedEditMixin::_getSignedValue; candidate="%s"' % candidate, indent=1)
4593 if candidate is None: text = self._GetValue()
4594 else: text = candidate
4595
4596
4597 abstext, signpos, right_signpos = self._getAbsValue(text)
4598 if self._signOk:
4599 if abstext is None:
4600 ## dbg(indent=0)
4601 return abstext, signpos, right_signpos
4602
4603 if self._isNeg or text[signpos] in ('-', '('):
4604 if self._useParens:
4605 sign = '('
4606 else:
4607 sign = '-'
4608 else:
4609 sign = ' '
4610 if abstext[signpos] not in string.digits:
4611 text = abstext[:signpos] + sign + abstext[signpos+1:]
4612 else:
4613 # this can happen if value passed is too big; sign assumed to be
4614 # in position 0, but if already filled with a digit, prepend sign...
4615 text = sign + abstext
4616 if self._useParens and text.find('(') != -1:
4617 text = text[:right_signpos] + ')' + text[right_signpos+1:]
4618 else:
4619 text = abstext
4620 ## dbg('signedtext = "%s"' % text, 'signpos:', signpos, 'right_signpos', right_signpos)
4621 ## dbg(indent=0)
4622 return text, signpos, right_signpos
4623
4624
4625 def GetPlainValue(self, candidate=None):
4626 """ Returns control's value stripped of the template text.
4627 plainvalue = MaskedEditMixin.GetPlainValue()
4628 """
4629 ## dbg('MaskedEditMixin::GetPlainValue; candidate="%s"' % candidate, indent=1)
4630
4631 if candidate is None: text = self._GetValue()
4632 else: text = candidate
4633
4634 if self.IsEmpty():
4635 ## dbg('returned ""', indent=0)
4636 return ""
4637 else:
4638 plain = ""
4639 for idx in range( min(len(self._template), len(text)) ):
4640 if self._mask[idx] in maskchars:
4641 plain += text[idx]
4642
4643 if self._isFloat or self._isInt:
4644 ## dbg('plain so far: "%s"' % plain)
4645 plain = plain.replace('(', '-').replace(')', ' ')
4646 ## dbg('plain after sign regularization: "%s"' % plain)
4647
4648 if self._signOk and self._isNeg and plain.count('-') == 0:
4649 # must be in reserved position; add to "plain value"
4650 plain = '-' + plain.strip()
4651
4652 if self._fields[0]._alignRight:
4653 lpad = plain.count(',')
4654 plain = ' ' * lpad + plain.replace(',','')
4655 else:
4656 plain = plain.replace(',','')
4657 ## dbg('plain after pad and group:"%s"' % plain)
4658
4659 ## dbg('returned "%s"' % plain.rstrip(), indent=0)
4660 return plain.rstrip()
4661
4662
4663 def IsEmpty(self, value=None):
4664 """
4665 Returns True if control is equal to an empty value.
4666 (Empty means all editable positions in the template == fillChar.)
4667 """
4668 if value is None: value = self._GetValue()
4669 if value == self._template and not self._defaultValue:
4670 #### dbg("IsEmpty? 1 (value == self._template and not self._defaultValue)")
4671 return True # (all mask chars == fillChar by defn)
4672 elif value == self._template:
4673 empty = True
4674 for pos in range(len(self._template)):
4675 #### dbg('isMaskChar(%(pos)d)?' % locals(), self._isMaskChar(pos))
4676 #### dbg('value[%(pos)d] != self._fillChar?' %locals(), value[pos] != self._fillChar[pos])
4677 if self._isMaskChar(pos) and value[pos] not in (' ', self._fillChar[pos]):
4678 empty = False
4679 #### dbg("IsEmpty? %(empty)d (do all mask chars == fillChar?)" % locals())
4680 return empty
4681 else:
4682 #### dbg("IsEmpty? 0 (value doesn't match template)")
4683 return False
4684
4685
4686 def IsDefault(self, value=None):
4687 """
4688 Returns True if the value specified (or the value of the control if not specified)
4689 is equal to the default value.
4690 """
4691 if value is None: value = self._GetValue()
4692 return value == self._template
4693
4694
4695 def IsValid(self, value=None):
4696 """ Indicates whether the value specified (or the current value of the control
4697 if not specified) is considered valid."""
4698 #### dbg('MaskedEditMixin::IsValid("%s")' % value, indent=1)
4699 if value is None: value = self._GetValue()
4700 ret = self._CheckValid(value)
4701 #### dbg(indent=0)
4702 return ret
4703
4704
4705 def _eraseSelection(self, value=None, sel_start=None, sel_to=None):
4706 """ Used to blank the selection when inserting a new character. """
4707 ## dbg("MaskedEditMixin::_eraseSelection", indent=1)
4708 if value is None: value = self._GetValue()
4709 if sel_start is None or sel_to is None:
4710 sel_start, sel_to = self._GetSelection() ## check for a range of selected text
4711 ## dbg('value: "%s"' % value)
4712 ## dbg("current sel_start, sel_to:", sel_start, sel_to)
4713
4714 newvalue = list(value)
4715 for i in range(sel_start, sel_to):
4716 if self._signOk and newvalue[i] in ('-', '(', ')'):
4717 ## dbg('found sign (%s) at' % newvalue[i], i)
4718
4719 # balance parentheses:
4720 if newvalue[i] == '(':
4721 right_signpos = value.find(')')
4722 if right_signpos != -1:
4723 newvalue[right_signpos] = ' '
4724
4725 elif newvalue[i] == ')':
4726 left_signpos = value.find('(')
4727 if left_signpos != -1:
4728 newvalue[left_signpos] = ' '
4729
4730 newvalue[i] = ' '
4731
4732 elif self._isMaskChar(i):
4733 field = self._FindField(i)
4734 if field._padZero:
4735 newvalue[i] = '0'
4736 else:
4737 newvalue[i] = self._template[i]
4738
4739 value = string.join(newvalue,"")
4740 ## dbg('new value: "%s"' % value)
4741 ## dbg(indent=0)
4742 return value
4743
4744
4745 def _insertKey(self, char, pos, sel_start, sel_to, value, allowAutoSelect=False):
4746 """ Handles replacement of the character at the current insertion point."""
4747 ## dbg('MaskedEditMixin::_insertKey', "\'" + char + "\'", pos, sel_start, sel_to, '"%s"' % value, indent=1)
4748
4749 text = self._eraseSelection(value)
4750 field = self._FindField(pos)
4751 start, end = field._extent
4752 newtext = ""
4753 newpos = pos
4754
4755 # if >= 2 chars selected in a right-insert field, do appropriate erase on field,
4756 # then set selection to end, and do usual right insert.
4757 if sel_start != sel_to and sel_to >= sel_start+2:
4758 field = self._FindField(sel_start)
4759 if( field._insertRight # if right-insert
4760 and field._allowInsert # and allow insert at any point in field
4761 and field == self._FindField(sel_to) ): # and selection all in same field
4762 text = self._OnErase(just_return_value=True) # remove selection before insert
4763 ## dbg('text after (left)erase: "%s"' % text)
4764 pos = sel_start = sel_to
4765
4766 if pos != sel_start and sel_start == sel_to:
4767 # adjustpos must have moved the position; make selection match:
4768 sel_start = sel_to = pos
4769
4770 ## dbg('field._insertRight?', field._insertRight)
4771 ## dbg('field._allowInsert?', field._allowInsert)
4772 ## dbg('sel_start, end', sel_start, end)
4773 if sel_start < end:
4774 ## dbg('text[sel_start] != field._fillChar?', text[sel_start] != field._fillChar)
4775 pass
4776
4777 if( field._insertRight # field allows right insert
4778 and ((sel_start, sel_to) == field._extent # and whole field selected
4779 or (sel_start == sel_to # or nothing selected
4780 and (sel_start == end # and cursor at right edge
4781 or (field._allowInsert # or field allows right-insert
4782 and sel_start < end # next to other char in field:
4783 and text[sel_start] != field._fillChar) ) ) ) ):
4784 ## dbg('insertRight')
4785 fstr = text[start:end]
4786 erasable_chars = [field._fillChar, ' ']
4787
4788 if field._padZero:
4789 erasable_chars.append('0')
4790
4791 erased = ''
4792 #### dbg("fstr[0]:'%s'" % fstr[0])
4793 #### dbg('field_index:', field._index)
4794 #### dbg("fstr[0] in erasable_chars?", fstr[0] in erasable_chars)
4795 #### dbg("self._signOk and field._index == 0 and fstr[0] in ('-','(')?",
4796 ## self._signOk and field._index == 0 and fstr[0] in ('-','('))
4797 if fstr[0] in erasable_chars or (self._signOk and field._index == 0 and fstr[0] in ('-','(')):
4798 erased = fstr[0]
4799 #### dbg('value: "%s"' % text)
4800 #### dbg('fstr: "%s"' % fstr)
4801 #### dbg("erased: '%s'" % erased)
4802 field_sel_start = sel_start - start
4803 field_sel_to = sel_to - start
4804 ## dbg('left fstr: "%s"' % fstr[1:field_sel_start])
4805 ## dbg('right fstr: "%s"' % fstr[field_sel_to:end])
4806 fstr = fstr[1:field_sel_start] + char + fstr[field_sel_to:end]
4807 if field._alignRight and sel_start != sel_to:
4808 field_len = end - start
4809 ## pos += (field_len - len(fstr)) # move cursor right by deleted amount
4810 pos = sel_to
4811 ## dbg('setting pos to:', pos)
4812 if field._padZero:
4813 fstr = '0' * (field_len - len(fstr)) + fstr
4814 else:
4815 fstr = fstr.rjust(field_len) # adjust the field accordingly
4816 ## dbg('field str: "%s"' % fstr)
4817
4818 newtext = text[:start] + fstr + text[end:]
4819 if erased in ('-', '(') and self._signOk:
4820 newtext = erased + newtext[1:]
4821 ## dbg('newtext: "%s"' % newtext)
4822
4823 if self._signOk and field._index == 0:
4824 start -= 1 # account for sign position
4825
4826 #### dbg('field._moveOnFieldFull?', field._moveOnFieldFull)
4827 #### dbg('len(fstr.lstrip()) == end-start?', len(fstr.lstrip()) == end-start)
4828 if( field._moveOnFieldFull and pos == end
4829 and len(fstr.lstrip()) == end-start): # if field now full
4830 newpos = self._findNextEntry(end) # go to next field
4831 else:
4832 newpos = pos # else keep cursor at current position
4833
4834 if not newtext:
4835 ## dbg('not newtext')
4836 if newpos != pos:
4837 ## dbg('newpos:', newpos)
4838 pass
4839 if self._signOk and self._useParens:
4840 old_right_signpos = text.find(')')
4841
4842 if field._allowInsert and not field._insertRight and sel_to <= end and sel_start >= start:
4843 # inserting within a left-insert-capable field
4844 field_len = end - start
4845 before = text[start:sel_start]
4846 after = text[sel_to:end].strip()
4847 #### dbg("current field:'%s'" % text[start:end])
4848 #### dbg("before:'%s'" % before, "after:'%s'" % after)
4849 new_len = len(before) + len(after) + 1 # (for inserted char)
4850 #### dbg('new_len:', new_len)
4851
4852 if new_len < field_len:
4853 retained = after + self._template[end-(field_len-new_len):end]
4854 elif new_len > end-start:
4855 retained = after[1:]
4856 else:
4857 retained = after
4858
4859 left = text[0:start] + before
4860 #### dbg("left:'%s'" % left, "retained:'%s'" % retained)
4861 right = retained + text[end:]
4862 else:
4863 left = text[0:pos]
4864 right = text[pos+1:]
4865
4866 newtext = left + char + right
4867
4868 if self._signOk and self._useParens:
4869 # Balance parentheses:
4870 left_signpos = newtext.find('(')
4871
4872 if left_signpos == -1: # erased '('; remove ')'
4873 right_signpos = newtext.find(')')
4874 if right_signpos != -1:
4875 newtext = newtext[:right_signpos] + ' ' + newtext[right_signpos+1:]
4876
4877 elif old_right_signpos != -1:
4878 right_signpos = newtext.find(')')
4879
4880 if right_signpos == -1: # just replaced right-paren
4881 if newtext[pos] == ' ': # we just erased '); erase '('
4882 newtext = newtext[:left_signpos] + ' ' + newtext[left_signpos+1:]
4883 else: # replaced with digit; move ') over
4884 if self._ctrl_constraints._alignRight or self._isFloat:
4885 newtext = newtext[:-1] + ')'
4886 else:
4887 rstripped_text = newtext.rstrip()
4888 right_signpos = len(rstripped_text)
4889 ## dbg('old_right_signpos:', old_right_signpos, 'right signpos now:', right_signpos)
4890 newtext = newtext[:right_signpos] + ')' + newtext[right_signpos+1:]
4891
4892 if( field._insertRight # if insert-right field (but we didn't start at right edge)
4893 and field._moveOnFieldFull # and should move cursor when full
4894 and len(newtext[start:end].strip()) == end-start): # and field now full
4895 newpos = self._findNextEntry(end) # go to next field
4896 ## dbg('newpos = nextentry =', newpos)
4897 else:
4898 ## dbg('pos:', pos, 'newpos:', pos+1)
4899 newpos = pos+1
4900
4901
4902 if allowAutoSelect:
4903 new_select_to = newpos # (default return values)
4904 match_field = None
4905 match_index = None
4906
4907 if field._autoSelect:
4908 match_index, partial_match = self._autoComplete(1, # (always forward)
4909 field._compareChoices,
4910 newtext[start:end],
4911 compareNoCase=field._compareNoCase,
4912 current_index = field._autoCompleteIndex-1)
4913 if match_index is not None and partial_match:
4914 matched_str = newtext[start:end]
4915 newtext = newtext[:start] + field._choices[match_index] + newtext[end:]
4916 new_select_to = end
4917 match_field = field
4918 if field._insertRight:
4919 # adjust position to just after partial match in field
4920 newpos = end - (len(field._choices[match_index].strip()) - len(matched_str.strip()))
4921
4922 elif self._ctrl_constraints._autoSelect:
4923 match_index, partial_match = self._autoComplete(
4924 1, # (always forward)
4925 self._ctrl_constraints._compareChoices,
4926 newtext,
4927 self._ctrl_constraints._compareNoCase,
4928 current_index = self._ctrl_constraints._autoCompleteIndex - 1)
4929 if match_index is not None and partial_match:
4930 matched_str = newtext
4931 newtext = self._ctrl_constraints._choices[match_index]
4932 edit_end = self._ctrl_constraints._extent[1]
4933 new_select_to = min(edit_end, len(newvalue.rstrip()))
4934 match_field = self._ctrl_constraints
4935 if self._ctrl_constraints._insertRight:
4936 # adjust position to just after partial match in control:
4937 newpos = self._masklength - (len(self._ctrl_constraints._choices[match_index].strip()) - len(matched_str.strip()))
4938
4939 ## dbg('newtext: "%s"' % newtext, 'newpos:', newpos, 'new_select_to:', new_select_to)
4940 ## dbg(indent=0)
4941 return newtext, newpos, new_select_to, match_field, match_index
4942 else:
4943 ## dbg('newtext: "%s"' % newtext, 'newpos:', newpos)
4944 ## dbg(indent=0)
4945 return newtext, newpos
4946
4947
4948 def _OnFocus(self,event):
4949 """
4950 This event handler is currently necessary to work around new default
4951 behavior as of wxPython2.3.3;
4952 The TAB key auto selects the entire contents of the wx.TextCtrl *after*
4953 the EVT_SET_FOCUS event occurs; therefore we can't query/adjust the selection
4954 *here*, because it hasn't happened yet. So to prevent this behavior, and
4955 preserve the correct selection when the focus event is not due to tab,
4956 we need to pull the following trick:
4957 """
4958 ## dbg('MaskedEditMixin::_OnFocus')
4959 if self.IsBeingDeleted() or self.GetParent().IsBeingDeleted():
4960 return
4961 wx.CallAfter(self._fixSelection)
4962 event.Skip()
4963 self.Refresh()
4964
4965
4966 def _CheckValid(self, candidate=None):
4967 """
4968 This is the default validation checking routine; It verifies that the
4969 current value of the control is a "valid value," and has the side
4970 effect of coloring the control appropriately.
4971 """
4972 ## dbg(suspend=1)
4973 ## dbg('MaskedEditMixin::_CheckValid: candidate="%s"' % candidate, indent=1)
4974 oldValid = self._valid
4975 if candidate is None: value = self._GetValue()
4976 else: value = candidate
4977 ## dbg('value: "%s"' % value)
4978 oldvalue = value
4979 valid = True # assume True
4980
4981 if not self.IsDefault(value) and self._isDate: ## Date type validation
4982 valid = self._validateDate(value)
4983 ## dbg("valid date?", valid)
4984
4985 elif not self.IsDefault(value) and self._isTime:
4986 valid = self._validateTime(value)
4987 ## dbg("valid time?", valid)
4988
4989 elif not self.IsDefault(value) and (self._isInt or self._isFloat): ## Numeric type
4990 valid = self._validateNumeric(value)
4991 ## dbg("valid Number?", valid)
4992
4993 if valid: # and not self.IsDefault(value): ## generic validation accounts for IsDefault()
4994 ## valid so far; ensure also allowed by any list or regex provided:
4995 valid = self._validateGeneric(value)
4996 ## dbg("valid value?", valid)
4997
4998 ## dbg('valid?', valid)
4999
5000 if not candidate:
5001 self._valid = valid
5002 self._applyFormatting()
5003 if self._valid != oldValid:
5004 ## dbg('validity changed: oldValid =',oldValid,'newvalid =', self._valid)
5005 ## dbg('oldvalue: "%s"' % oldvalue, 'newvalue: "%s"' % self._GetValue())
5006 pass
5007 ## dbg(indent=0, suspend=0)
5008 return valid
5009
5010
5011 def _validateGeneric(self, candidate=None):
5012 """ Validate the current value using the provided list or Regex filter (if any).
5013 """
5014 if candidate is None:
5015 text = self._GetValue()
5016 else:
5017 text = candidate
5018
5019 valid = True # assume True
5020 for i in [-1] + self._field_indices: # process global constraints first:
5021 field = self._fields[i]
5022 start, end = field._extent
5023 slice = text[start:end]
5024 valid = field.IsValid(slice)
5025 if not valid:
5026 break
5027
5028 return valid
5029
5030
5031 def _validateNumeric(self, candidate=None):
5032 """ Validate that the value is within the specified range (if specified.)"""
5033 if candidate is None: value = self._GetValue()
5034 else: value = candidate
5035 try:
5036 groupchar = self._fields[0]._groupChar
5037 if self._isFloat:
5038 number = float(value.replace(groupchar, '').replace(self._decimalChar, '.').replace('(', '-').replace(')', ''))
5039 else:
5040 number = long( value.replace(groupchar, '').replace('(', '-').replace(')', ''))
5041 if value.strip():
5042 if self._fields[0]._alignRight:
5043 require_digit_at = self._fields[0]._extent[1]-1
5044 else:
5045 require_digit_at = self._fields[0]._extent[0]
5046 ## dbg('require_digit_at:', require_digit_at)
5047 ## dbg("value[rda]: '%s'" % value[require_digit_at])
5048 if value[require_digit_at] not in list(string.digits):
5049 valid = False
5050 return valid
5051 # else...
5052 ## dbg('number:', number)
5053 if self._ctrl_constraints._hasRange:
5054 valid = self._ctrl_constraints._rangeLow <= number <= self._ctrl_constraints._rangeHigh
5055 else:
5056 valid = True
5057 groupcharpos = value.rfind(groupchar)
5058 if groupcharpos != -1: # group char present
5059 ## dbg('groupchar found at', groupcharpos)
5060 if self._isFloat and groupcharpos > self._decimalpos:
5061 # 1st one found on right-hand side is past decimal point
5062 ## dbg('groupchar in fraction; illegal')
5063 return False
5064 elif self._isFloat:
5065 integer = value[:self._decimalpos].strip()
5066 else:
5067 integer = value.strip()
5068 ## dbg("integer:'%s'" % integer)
5069 if integer[0] in ('-', '('):
5070 integer = integer[1:]
5071 if integer[-1] == ')':
5072 integer = integer[:-1]
5073
5074 parts = integer.split(groupchar)
5075 ## dbg('parts:', parts)
5076 for i in range(len(parts)):
5077 if i == 0 and abs(int(parts[0])) > 999:
5078 ## dbg('group 0 too long; illegal')
5079 valid = False
5080 break
5081 elif i > 0 and (len(parts[i]) != 3 or ' ' in parts[i]):
5082 ## dbg('group %i (%s) not right size; illegal' % (i, parts[i]))
5083 valid = False
5084 break
5085 except ValueError:
5086 ## dbg('value not a valid number')
5087 valid = False
5088 return valid
5089
5090
5091 def _validateDate(self, candidate=None):
5092 """ Validate the current date value using the provided Regex filter.
5093 Generally used for character types.BufferType
5094 """
5095 ## dbg('MaskedEditMixin::_validateDate', indent=1)
5096 if candidate is None: value = self._GetValue()
5097 else: value = candidate
5098 ## dbg('value = "%s"' % value)
5099 text = self._adjustDate(value, force4digit_year=True) ## Fix the date up before validating it
5100 ## dbg('text =', text)
5101 valid = True # assume True until proven otherwise
5102
5103 try:
5104 # replace fillChar in each field with space:
5105 datestr = text[0:self._dateExtent]
5106 for i in range(3):
5107 field = self._fields[i]
5108 start, end = field._extent
5109 fstr = datestr[start:end]
5110 fstr.replace(field._fillChar, ' ')
5111 datestr = datestr[:start] + fstr + datestr[end:]
5112
5113 year, month, day = getDateParts( datestr, self._datestyle)
5114 year = int(year)
5115 ## dbg('self._dateExtent:', self._dateExtent)
5116 if self._dateExtent == 11:
5117 month = charmonths_dict[month.lower()]
5118 else:
5119 month = int(month)
5120 day = int(day)
5121 ## dbg('year, month, day:', year, month, day)
5122
5123 except ValueError:
5124 ## dbg('cannot convert string to integer parts')
5125 valid = False
5126 except KeyError:
5127 ## dbg('cannot convert string to integer month')
5128 valid = False
5129
5130 if valid:
5131 # use wxDateTime to unambiguously try to parse the date:
5132 # ### Note: because wxDateTime is *brain-dead* and expects months 0-11,
5133 # rather than 1-12, so handle accordingly:
5134 if month > 12:
5135 valid = False
5136 else:
5137 month -= 1
5138 try:
5139 ## dbg("trying to create date from values day=%d, month=%d, year=%d" % (day,month,year))
5140 dateHandler = wx.DateTimeFromDMY(day,month,year)
5141 ## dbg("succeeded")
5142 dateOk = True
5143 except:
5144 ## dbg('cannot convert string to valid date')
5145 dateOk = False
5146 if not dateOk:
5147 valid = False
5148
5149 if valid:
5150 # wxDateTime doesn't take kindly to leading/trailing spaces when parsing,
5151 # so we eliminate them here:
5152 timeStr = text[self._dateExtent+1:].strip() ## time portion of the string
5153 if timeStr:
5154 ## dbg('timeStr: "%s"' % timeStr)
5155 try:
5156 checkTime = dateHandler.ParseTime(timeStr)
5157 valid = checkTime == len(timeStr)
5158 except:
5159 valid = False
5160 if not valid:
5161 ## dbg('cannot convert string to valid time')
5162 pass
5163 if valid: dbg('valid date')
5164 ## dbg(indent=0)
5165 return valid
5166
5167
5168 def _validateTime(self, candidate=None):
5169 """ Validate the current time value using the provided Regex filter.
5170 Generally used for character types.BufferType
5171 """
5172 ## dbg('MaskedEditMixin::_validateTime', indent=1)
5173 # wxDateTime doesn't take kindly to leading/trailing spaces when parsing,
5174 # so we eliminate them here:
5175 if candidate is None: value = self._GetValue().strip()
5176 else: value = candidate.strip()
5177 ## dbg('value = "%s"' % value)
5178 valid = True # assume True until proven otherwise
5179
5180 dateHandler = wx.DateTime_Today()
5181 try:
5182 checkTime = dateHandler.ParseTime(value)
5183 ## dbg('checkTime:', checkTime, 'len(value)', len(value))
5184 valid = checkTime == len(value)
5185 except:
5186 valid = False
5187
5188 if not valid:
5189 ## dbg('cannot convert string to valid time')
5190 pass
5191 if valid: dbg('valid time')
5192 ## dbg(indent=0)
5193 return valid
5194
5195
5196 def _OnKillFocus(self,event):
5197 """ Handler for EVT_KILL_FOCUS event.
5198 """
5199 ## dbg('MaskedEditMixin::_OnKillFocus', 'isDate=',self._isDate, indent=1)
5200 if self._mask and self._IsEditable():
5201 self._AdjustField(self._GetInsertionPoint())
5202 self._CheckValid() ## Call valid handler
5203
5204 self._LostFocus() ## Provided for subclass use
5205 event.Skip()
5206 ## dbg(indent=0)
5207
5208
5209 def _fixSelection(self):
5210 """
5211 This gets called after the TAB traversal selection is made, if the
5212 focus event was due to this, but before the EVT_LEFT_* events if
5213 the focus shift was due to a mouse event.
5214
5215 The trouble is that, a priori, there's no explicit notification of
5216 why the focus event we received. However, the whole reason we need to
5217 do this is because the default behavior on TAB traveral in a wx.TextCtrl is
5218 now to select the entire contents of the window, something we don't want.
5219 So we can *now* test the selection range, and if it's "the whole text"
5220 we can assume the cause, change the insertion point to the start of
5221 the control, and deselect.
5222 """
5223 ## dbg('MaskedEditMixin::_fixSelection', indent=1)
5224 # can get here if called with wx.CallAfter after underlying
5225 # control has been destroyed on close, but after focus
5226 # events
5227 if not self or not self._mask or not self._IsEditable():
5228 ## dbg(indent=0)
5229 return
5230
5231 sel_start, sel_to = self._GetSelection()
5232 ## dbg('sel_start, sel_to:', sel_start, sel_to, 'self.IsEmpty()?', self.IsEmpty())
5233
5234 if( sel_start == 0 and sel_to >= len( self._mask ) #(can be greater in numeric controls because of reserved space)
5235 and (not self._ctrl_constraints._autoSelect or self.IsEmpty() or self.IsDefault() ) ):
5236 # This isn't normally allowed, and so assume we got here by the new
5237 # "tab traversal" behavior, so we need to reset the selection
5238 # and insertion point:
5239 ## dbg('entire text selected; resetting selection to start of control')
5240 self._goHome()
5241 field = self._FindField(self._GetInsertionPoint())
5242 edit_start, edit_end = field._extent
5243 if field._selectOnFieldEntry:
5244 self._SetInsertionPoint(edit_start)
5245 self._SetSelection(edit_start, edit_end)
5246
5247 elif field._insertRight:
5248 self._SetInsertionPoint(edit_end)
5249 self._SetSelection(edit_end, edit_end)
5250
5251 elif (self._isFloat or self._isInt):
5252
5253 text, signpos, right_signpos = self._getAbsValue()
5254 if text is None or text == self._template:
5255 integer = self._fields[0]
5256 edit_start, edit_end = integer._extent
5257
5258 if integer._selectOnFieldEntry:
5259 ## dbg('select on field entry:')
5260 self._SetInsertionPoint(edit_start)
5261 self._SetSelection(edit_start, edit_end)
5262
5263 elif integer._insertRight:
5264 ## dbg('moving insertion point to end')
5265 self._SetInsertionPoint(edit_end)
5266 self._SetSelection(edit_end, edit_end)
5267 else:
5268 ## dbg('numeric ctrl is empty; start at beginning after sign')
5269 self._SetInsertionPoint(signpos+1) ## Move past minus sign space if signed
5270 self._SetSelection(signpos+1, signpos+1)
5271
5272 elif sel_start > self._goEnd(getPosOnly=True):
5273 ## dbg('cursor beyond the end of the user input; go to end of it')
5274 self._goEnd()
5275 else:
5276 ## dbg('sel_start, sel_to:', sel_start, sel_to, 'self._masklength:', self._masklength)
5277 pass
5278 ## dbg(indent=0)
5279
5280
5281 def _Keypress(self,key):
5282 """ Method provided to override OnChar routine. Return False to force
5283 a skip of the 'normal' OnChar process. Called before class OnChar.
5284 """
5285 return True
5286
5287
5288 def _LostFocus(self):
5289 """ Method provided for subclasses. _LostFocus() is called after
5290 the class processes its EVT_KILL_FOCUS event code.
5291 """
5292 pass
5293
5294
5295 def _OnDoubleClick(self, event):
5296 """ selects field under cursor on dclick."""
5297 pos = self._GetInsertionPoint()
5298 field = self._FindField(pos)
5299 start, end = field._extent
5300 self._SetInsertionPoint(start)
5301 self._SetSelection(start, end)
5302
5303
5304 def _Change(self):
5305 """ Method provided for subclasses. Called by internal EVT_TEXT
5306 handler. Return False to override the class handler, True otherwise.
5307 """
5308 return True
5309
5310
5311 def _Cut(self):
5312 """
5313 Used to override the default Cut() method in base controls, instead
5314 copying the selection to the clipboard and then blanking the selection,
5315 leaving only the mask in the selected area behind.
5316 Note: _Cut (read "undercut" ;-) must be called from a Cut() override in the
5317 derived control because the mixin functions can't override a method of
5318 a sibling class.
5319 """
5320 ## dbg("MaskedEditMixin::_Cut", indent=1)
5321 value = self._GetValue()
5322 ## dbg('current value: "%s"' % value)
5323 sel_start, sel_to = self._GetSelection() ## check for a range of selected text
5324 ## dbg('selected text: "%s"' % value[sel_start:sel_to].strip())
5325 do = wx.TextDataObject()
5326 do.SetText(value[sel_start:sel_to].strip())
5327 wx.TheClipboard.Open()
5328 wx.TheClipboard.SetData(do)
5329 wx.TheClipboard.Close()
5330
5331 if sel_to - sel_start != 0:
5332 self._OnErase()
5333 ## dbg(indent=0)
5334
5335
5336 # WS Note: overriding Copy is no longer necessary given that you
5337 # can no longer select beyond the last non-empty char in the control.
5338 #
5339 ## def _Copy( self ):
5340 ## """
5341 ## Override the wx.TextCtrl's .Copy function, with our own
5342 ## that does validation. Need to strip trailing spaces.
5343 ## """
5344 ## sel_start, sel_to = self._GetSelection()
5345 ## select_len = sel_to - sel_start
5346 ## textval = wx.TextCtrl._GetValue(self)
5347 ##
5348 ## do = wx.TextDataObject()
5349 ## do.SetText(textval[sel_start:sel_to].strip())
5350 ## wx.TheClipboard.Open()
5351 ## wx.TheClipboard.SetData(do)
5352 ## wx.TheClipboard.Close()
5353
5354
5355 def _getClipboardContents( self ):
5356 """ Subroutine for getting the current contents of the clipboard.
5357 """
5358 do = wx.TextDataObject()
5359 wx.TheClipboard.Open()
5360 success = wx.TheClipboard.GetData(do)
5361 wx.TheClipboard.Close()
5362
5363 if not success:
5364 return None
5365 else:
5366 # Remove leading and trailing spaces before evaluating contents
5367 return do.GetText().strip()
5368
5369
5370 def _validatePaste(self, paste_text, sel_start, sel_to, raise_on_invalid=False):
5371 """
5372 Used by paste routine and field choice validation to see
5373 if a given slice of paste text is legal for the area in question:
5374 returns validity, replacement text, and extent of paste in
5375 template.
5376 """
5377 ## dbg(suspend=1)
5378 ## dbg('MaskedEditMixin::_validatePaste("%(paste_text)s", %(sel_start)d, %(sel_to)d), raise_on_invalid? %(raise_on_invalid)d' % locals(), indent=1)
5379 select_length = sel_to - sel_start
5380 maxlength = select_length
5381 ## dbg('sel_to - sel_start:', maxlength)
5382 if maxlength == 0:
5383 maxlength = self._masklength - sel_start
5384 item = 'control'
5385 else:
5386 item = 'selection'
5387 ## dbg('maxlength:', maxlength)
5388 length_considered = len(paste_text)
5389 if length_considered > maxlength:
5390 ## dbg('paste text will not fit into the %s:' % item, indent=0)
5391 if raise_on_invalid:
5392 ## dbg(indent=0, suspend=0)
5393 if item == 'control':
5394 raise ValueError('"%s" will not fit into the control "%s"' % (paste_text, self.name))
5395 else:
5396 raise ValueError('"%s" will not fit into the selection' % paste_text)
5397 else:
5398 ## dbg(indent=0, suspend=0)
5399 return False, None, None
5400
5401 text = self._template
5402 ## dbg('length_considered:', length_considered)
5403
5404 valid_paste = True
5405 replacement_text = ""
5406 replace_to = sel_start
5407 i = 0
5408 while valid_paste and i < length_considered and replace_to < self._masklength:
5409 if paste_text[i:] == self._template[replace_to:length_considered]:
5410 # remainder of paste matches template; skip char-by-char analysis
5411 ## dbg('remainder paste_text[%d:] (%s) matches template[%d:%d]' % (i, paste_text[i:], replace_to, length_considered))
5412 replacement_text += paste_text[i:]
5413 replace_to = i = length_considered
5414 continue
5415 # else:
5416 char = paste_text[i]
5417 field = self._FindField(replace_to)
5418 if not field._compareNoCase:
5419 if field._forceupper: char = char.upper()
5420 elif field._forcelower: char = char.lower()
5421
5422 ## dbg('char:', "'"+char+"'", 'i =', i, 'replace_to =', replace_to)
5423 ## dbg('self._isTemplateChar(%d)?' % replace_to, self._isTemplateChar(replace_to))
5424 if not self._isTemplateChar(replace_to) and self._isCharAllowed( char, replace_to, allowAutoSelect=False, ignoreInsertRight=True):
5425 replacement_text += char
5426 ## dbg("not template(%(replace_to)d) and charAllowed('%(char)s',%(replace_to)d)" % locals())
5427 ## dbg("replacement_text:", '"'+replacement_text+'"')
5428 i += 1
5429 replace_to += 1
5430 elif( char == self._template[replace_to]
5431 or (self._signOk and
5432 ( (i == 0 and (char == '-' or (self._useParens and char == '(')))
5433 or (i == self._masklength - 1 and self._useParens and char == ')') ) ) ):
5434 replacement_text += char
5435 ## dbg("'%(char)s' == template(%(replace_to)d)" % locals())
5436 ## dbg("replacement_text:", '"'+replacement_text+'"')
5437 i += 1
5438 replace_to += 1
5439 else:
5440 next_entry = self._findNextEntry(replace_to, adjustInsert=False)
5441 if next_entry == replace_to:
5442 valid_paste = False
5443 else:
5444 replacement_text += self._template[replace_to:next_entry]
5445 ## dbg("skipping template; next_entry =", next_entry)
5446 ## dbg("replacement_text:", '"'+replacement_text+'"')
5447 replace_to = next_entry # so next_entry will be considered on next loop
5448
5449 if not valid_paste and raise_on_invalid:
5450 ## dbg('raising exception', indent=0, suspend=0)
5451 raise ValueError('"%s" cannot be inserted into the control "%s"' % (paste_text, self.name))
5452
5453 elif i < len(paste_text):
5454 valid_paste = False
5455 if raise_on_invalid:
5456 ## dbg('raising exception', indent=0, suspend=0)
5457 raise ValueError('"%s" will not fit into the control "%s"' % (paste_text, self.name))
5458
5459 ## dbg('valid_paste?', valid_paste)
5460 if valid_paste:
5461 ## dbg('replacement_text: "%s"' % replacement_text, 'replace to:', replace_to)
5462 pass
5463 ## dbg(indent=0, suspend=0)
5464 return valid_paste, replacement_text, replace_to
5465
5466
5467 def _Paste( self, value=None, raise_on_invalid=False, just_return_value=False ):
5468 """
5469 Used to override the base control's .Paste() function,
5470 with our own that does validation.
5471 Note: _Paste must be called from a Paste() override in the
5472 derived control because the mixin functions can't override a
5473 method of a sibling class.
5474 """
5475 ## dbg('MaskedEditMixin::_Paste (value = "%s")' % value, indent=1)
5476 if value is None:
5477 paste_text = self._getClipboardContents()
5478 else:
5479 paste_text = value
5480
5481 if paste_text is not None:
5482 ## dbg('paste text: "%s"' % paste_text)
5483 # (conversion will raise ValueError if paste isn't legal)
5484 sel_start, sel_to = self._GetSelection()
5485 ## dbg('selection:', (sel_start, sel_to))
5486
5487 # special case: handle allowInsert fields properly
5488 field = self._FindField(sel_start)
5489 edit_start, edit_end = field._extent
5490 new_pos = None
5491 if field._allowInsert and sel_to <= edit_end and (sel_start + len(paste_text) < edit_end or field._insertRight):
5492 if field._insertRight:
5493 # want to paste to the left; see if it will fit:
5494 left_text = self._GetValue()[edit_start:sel_start].lstrip()
5495 ## dbg('len(left_text):', len(left_text))
5496 ## dbg('len(paste_text):', len(paste_text))
5497 ## dbg('sel_start - (len(left_text) + len(paste_text)) >= edit_start?', sel_start - (len(left_text) + len(paste_text)) >= edit_start)
5498 if sel_start - (len(left_text) - (sel_to - sel_start) + len(paste_text)) >= edit_start:
5499 # will fit! create effective paste text, and move cursor back to do so:
5500 paste_text = left_text + paste_text
5501 sel_start -= len(left_text)
5502 paste_text = paste_text.rjust(sel_to - sel_start)
5503 ## dbg('modified paste_text to be: "%s"' % paste_text)
5504 ## dbg('modified selection to:', (sel_start, sel_to))
5505 else:
5506 ## dbg("won't fit left;", 'paste text remains: "%s"' % paste_text)
5507 pass
5508 else:
5509 paste_text = paste_text + self._GetValue()[sel_to:edit_end].rstrip()
5510 ## dbg("allow insert, but not insert right;", 'paste text set to: "%s"' % paste_text)
5511
5512
5513 new_pos = sel_start + len(paste_text) # store for subsequent positioning
5514 ## dbg('paste within insertable field; adjusted paste_text: "%s"' % paste_text, 'end:', edit_end)
5515 ## dbg('expanded selection to:', (sel_start, sel_to))
5516
5517 # Another special case: paste won't fit, but it's a right-insert field where entire
5518 # non-empty value is selected, and there's room if the selection is expanded leftward:
5519 if( len(paste_text) > sel_to - sel_start
5520 and field._insertRight
5521 and sel_start > edit_start
5522 and sel_to >= edit_end
5523 and not self._GetValue()[edit_start:sel_start].strip() ):
5524 # text won't fit within selection, but left of selection is empty;
5525 # check to see if we can expand selection to accomodate the value:
5526 empty_space = sel_start - edit_start
5527 amount_needed = len(paste_text) - (sel_to - sel_start)
5528 if amount_needed <= empty_space:
5529 sel_start -= amount_needed
5530 ## dbg('expanded selection to:', (sel_start, sel_to))
5531
5532
5533 # another special case: deal with signed values properly:
5534 if self._signOk:
5535 signedvalue, signpos, right_signpos = self._getSignedValue()
5536 paste_signpos = paste_text.find('-')
5537 if paste_signpos == -1:
5538 paste_signpos = paste_text.find('(')
5539
5540 # if paste text will result in signed value:
5541 #### dbg('paste_signpos != -1?', paste_signpos != -1)
5542 #### dbg('sel_start:', sel_start, 'signpos:', signpos)
5543 #### dbg('field._insertRight?', field._insertRight)
5544 #### dbg('sel_start - len(paste_text) >= signpos?', sel_start - len(paste_text) <= signpos)
5545 if paste_signpos != -1 and (sel_start <= signpos
5546 or (field._insertRight and sel_start - len(paste_text) <= signpos)):
5547 signed = True
5548 else:
5549 signed = False
5550 # remove "sign" from paste text, so we can auto-adjust for sign type after paste:
5551 paste_text = paste_text.replace('-', ' ').replace('(',' ').replace(')','')
5552 ## dbg('unsigned paste text: "%s"' % paste_text)
5553 else:
5554 signed = False
5555
5556 # another special case: deal with insert-right fields when selection is empty and
5557 # cursor is at end of field:
5558 #### dbg('field._insertRight?', field._insertRight)
5559 #### dbg('sel_start == edit_end?', sel_start == edit_end)
5560 #### dbg('sel_start', sel_start, 'sel_to', sel_to)
5561 if field._insertRight and sel_start == edit_end and sel_start == sel_to:
5562 sel_start -= len(paste_text)
5563 if sel_start < 0:
5564 sel_start = 0
5565 ## dbg('adjusted selection:', (sel_start, sel_to))
5566
5567 try:
5568 valid_paste, replacement_text, replace_to = self._validatePaste(paste_text, sel_start, sel_to, raise_on_invalid)
5569 except:
5570 ## dbg('exception thrown', indent=0)
5571 raise
5572
5573 if not valid_paste:
5574 ## dbg('paste text not legal for the selection or portion of the control following the cursor;')
5575 if not wx.Validator_IsSilent():
5576 wx.Bell()
5577 ## dbg(indent=0)
5578 return None, -1
5579 # else...
5580 text = self._eraseSelection()
5581
5582 new_text = text[:sel_start] + replacement_text + text[replace_to:]
5583 if new_text:
5584 new_text = string.ljust(new_text,self._masklength)
5585 if signed:
5586 new_text, signpos, right_signpos = self._getSignedValue(candidate=new_text)
5587 if new_text:
5588 if self._useParens:
5589 new_text = new_text[:signpos] + '(' + new_text[signpos+1:right_signpos] + ')' + new_text[right_signpos+1:]
5590 else:
5591 new_text = new_text[:signpos] + '-' + new_text[signpos+1:]
5592 if not self._isNeg:
5593 self._isNeg = 1
5594
5595 ## dbg("new_text:", '"'+new_text+'"')
5596
5597 if not just_return_value:
5598 if new_text != self._GetValue():
5599 self.modified = True
5600 if new_text == '':
5601 self.ClearValue()
5602 else:
5603 wx.CallAfter(self._SetValue, new_text)
5604 if new_pos is None:
5605 new_pos = sel_start + len(replacement_text)
5606 wx.CallAfter(self._SetInsertionPoint, new_pos)
5607 else:
5608 ## dbg(indent=0)
5609 return new_text, replace_to
5610 elif just_return_value:
5611 ## dbg(indent=0)
5612 return self._GetValue(), sel_to
5613 ## dbg(indent=0)
5614
5615 def _Undo(self, value=None, prev=None, just_return_results=False):
5616 """ Provides an Undo() method in base controls. """
5617 ## dbg("MaskedEditMixin::_Undo", indent=1)
5618 if value is None:
5619 value = self._GetValue()
5620 if prev is None:
5621 prev = self._prevValue
5622 ## dbg('current value: "%s"' % value)
5623 ## dbg('previous value: "%s"' % prev)
5624 if prev is None:
5625 ## dbg('no previous value', indent=0)
5626 return
5627
5628 elif value != prev:
5629 # Determine what to select: (relies on fixed-length strings)
5630 # (This is a lot harder than it would first appear, because
5631 # of mask chars that stay fixed, and so break up the "diff"...)
5632
5633 # Determine where they start to differ:
5634 i = 0
5635 length = len(value) # (both are same length in masked control)
5636
5637 while( value[:i] == prev[:i] ):
5638 i += 1
5639 sel_start = i - 1
5640
5641
5642 # handle signed values carefully, so undo from signed to unsigned or vice-versa
5643 # works properly:
5644 if self._signOk:
5645 text, signpos, right_signpos = self._getSignedValue(candidate=prev)
5646 if self._useParens:
5647 if prev[signpos] == '(' and prev[right_signpos] == ')':
5648 self._isNeg = True
5649 else:
5650 self._isNeg = False
5651 # eliminate source of "far-end" undo difference if using balanced parens:
5652 value = value.replace(')', ' ')
5653 prev = prev.replace(')', ' ')
5654 elif prev[signpos] == '-':
5655 self._isNeg = True
5656 else:
5657 self._isNeg = False
5658
5659 # Determine where they stop differing in "undo" result:
5660 sm = difflib.SequenceMatcher(None, a=value, b=prev)
5661 i, j, k = sm.find_longest_match(sel_start, length, sel_start, length)
5662 ## dbg('i,j,k = ', (i,j,k), 'value[i:i+k] = "%s"' % value[i:i+k], 'prev[j:j+k] = "%s"' % prev[j:j+k] )
5663
5664 if k == 0: # no match found; select to end
5665 sel_to = length
5666 else:
5667 code_5tuples = sm.get_opcodes()
5668 for op, i1, i2, j1, j2 in code_5tuples:
5669 ## dbg("%7s value[%d:%d] (%s) prev[%d:%d] (%s)" % (op, i1, i2, value[i1:i2], j1, j2, prev[j1:j2]))
5670 pass
5671
5672 diff_found = False
5673 # look backward through operations needed to produce "previous" value;
5674 # first change wins:
5675 for next_op in range(len(code_5tuples)-1, -1, -1):
5676 op, i1, i2, j1, j2 = code_5tuples[next_op]
5677 ## dbg('value[i1:i2]: "%s"' % value[i1:i2], 'template[i1:i2] "%s"' % self._template[i1:i2])
5678 field = self._FindField(i2)
5679 if op == 'insert' and prev[j1:j2] != self._template[j1:j2]:
5680 ## dbg('insert found: selection =>', (j1, j2))
5681 sel_start = j1
5682 sel_to = j2
5683 diff_found = True
5684 break
5685 elif op == 'delete' and value[i1:i2] != self._template[i1:i2]:
5686 edit_start, edit_end = field._extent
5687 if field._insertRight and (field._allowInsert or i2 == edit_end):
5688 sel_start = i2
5689 sel_to = i2
5690 else:
5691 sel_start = i1
5692 sel_to = j1
5693 ## dbg('delete found: selection =>', (sel_start, sel_to))
5694 diff_found = True
5695 break
5696 elif op == 'replace':
5697 if not prev[i1:i2].strip() and field._insertRight:
5698 sel_start = sel_to = j2
5699 else:
5700 sel_start = j1
5701 sel_to = j2
5702 ## dbg('replace found: selection =>', (sel_start, sel_to))
5703 diff_found = True
5704 break
5705
5706
5707 if diff_found:
5708 # now go forwards, looking for earlier changes:
5709 ## dbg('searching forward...')
5710 for next_op in range(len(code_5tuples)):
5711 op, i1, i2, j1, j2 = code_5tuples[next_op]
5712 field = self._FindField(i1)
5713 if op == 'equal':
5714 continue
5715 elif op == 'replace':
5716 if field._insertRight:
5717 # if replace with spaces in an insert-right control, ignore "forward" replace
5718 if not prev[i1:i2].strip():
5719 continue
5720 elif j1 < i1:
5721 ## dbg('setting sel_start to', j1)
5722 sel_start = j1
5723 else:
5724 ## dbg('setting sel_start to', i1)
5725 sel_start = i1
5726 else:
5727 ## dbg('setting sel_start to', i1)
5728 sel_start = i1
5729 ## dbg('saw replace; breaking')
5730 break
5731 elif op == 'insert' and not value[i1:i2]:
5732 ## dbg('forward %s found' % op)
5733 if prev[j1:j2].strip():
5734 ## dbg('item to insert non-empty; setting sel_start to', j1)
5735 sel_start = j1
5736 break
5737 elif not field._insertRight:
5738 ## dbg('setting sel_start to inserted space:', j1)
5739 sel_start = j1
5740 break
5741 elif op == 'delete':
5742 ## dbg('delete; field._insertRight?', field._insertRight, 'value[%d:%d].lstrip: "%s"' % (i1,i2,value[i1:i2].lstrip()))
5743 if field._insertRight:
5744 if value[i1:i2].lstrip():
5745 ## dbg('setting sel_start to ', j1)
5746 sel_start = j1
5747 ## dbg('breaking loop')
5748 break
5749 else:
5750 continue
5751 else:
5752 ## dbg('saw delete; breaking')
5753 break
5754 else:
5755 ## dbg('unknown code!')
5756 # we've got what we need
5757 break
5758
5759
5760 if not diff_found:
5761 ## dbg('no insert,delete or replace found (!)')
5762 # do "left-insert"-centric processing of difference based on l.c.s.:
5763 if i == j and j != sel_start: # match starts after start of selection
5764 sel_to = sel_start + (j-sel_start) # select to start of match
5765 else:
5766 sel_to = j # (change ends at j)
5767
5768
5769 # There are several situations where the calculated difference is
5770 # not what we want to select. If changing sign, or just adding
5771 # group characters, we really don't want to highlight the characters
5772 # changed, but instead leave the cursor where it is.
5773 # Also, there a situations in which the difference can be ambiguous;
5774 # Consider:
5775 #
5776 # current value: 11234
5777 # previous value: 1111234
5778 #
5779 # Where did the cursor actually lie and which 1s were selected on the delete
5780 # operation?
5781 #
5782 # Also, difflib can "get it wrong;" Consider:
5783 #
5784 # current value: " 128.66"
5785 # previous value: " 121.86"
5786 #
5787 # difflib produces the following opcodes, which are sub-optimal:
5788 # equal value[0:9] ( 12) prev[0:9] ( 12)
5789 # insert value[9:9] () prev[9:11] (1.)
5790 # equal value[9:10] (8) prev[11:12] (8)
5791 # delete value[10:11] (.) prev[12:12] ()
5792 # equal value[11:12] (6) prev[12:13] (6)
5793 # delete value[12:13] (6) prev[13:13] ()
5794 #
5795 # This should have been:
5796 # equal value[0:9] ( 12) prev[0:9] ( 12)
5797 # replace value[9:11] (8.6) prev[9:11] (1.8)
5798 # equal value[12:13] (6) prev[12:13] (6)
5799 #
5800 # But it didn't figure this out!
5801 #
5802 # To get all this right, we use the previous selection recorded to help us...
5803
5804 if (sel_start, sel_to) != self._prevSelection:
5805 ## dbg('calculated selection', (sel_start, sel_to), "doesn't match previous", self._prevSelection)
5806
5807 prev_sel_start, prev_sel_to = self._prevSelection
5808 field = self._FindField(sel_start)
5809 if( self._signOk
5810 and sel_start < self._masklength
5811 and (prev[sel_start] in ('-', '(', ')')
5812 or value[sel_start] in ('-', '(', ')')) ):
5813 # change of sign; leave cursor alone...
5814 ## dbg("prev[sel_start] in ('-', '(', ')')?", prev[sel_start] in ('-', '(', ')'))
5815 ## dbg("value[sel_start] in ('-', '(', ')')?", value[sel_start] in ('-', '(', ')'))
5816 ## dbg('setting selection to previous one')
5817 sel_start, sel_to = self._prevSelection
5818
5819 elif field._groupdigits and (value[sel_start:sel_to] == field._groupChar
5820 or prev[sel_start:sel_to] == field._groupChar):
5821 # do not highlight grouping changes
5822 ## dbg('value[sel_start:sel_to] == field._groupChar?', value[sel_start:sel_to] == field._groupChar)
5823 ## dbg('prev[sel_start:sel_to] == field._groupChar?', prev[sel_start:sel_to] == field._groupChar)
5824 ## dbg('setting selection to previous one')
5825 sel_start, sel_to = self._prevSelection
5826
5827 else:
5828 calc_select_len = sel_to - sel_start
5829 prev_select_len = prev_sel_to - prev_sel_start
5830
5831 ## dbg('sel_start == prev_sel_start', sel_start == prev_sel_start)
5832 ## dbg('sel_to > prev_sel_to', sel_to > prev_sel_to)
5833
5834 if prev_select_len >= calc_select_len:
5835 # old selection was bigger; trust it:
5836 ## dbg('prev_select_len >= calc_select_len?', prev_select_len >= calc_select_len)
5837 if not field._insertRight:
5838 ## dbg('setting selection to previous one')
5839 sel_start, sel_to = self._prevSelection
5840 else:
5841 sel_to = self._prevSelection[1]
5842 ## dbg('setting selection to', (sel_start, sel_to))
5843
5844 elif( sel_to > prev_sel_to # calculated select past last selection
5845 and prev_sel_to < len(self._template) # and prev_sel_to not at end of control
5846 and sel_to == len(self._template) ): # and calculated selection goes to end of control
5847
5848 i, j, k = sm.find_longest_match(prev_sel_to, length, prev_sel_to, length)
5849 ## dbg('i,j,k = ', (i,j,k), 'value[i:i+k] = "%s"' % value[i:i+k], 'prev[j:j+k] = "%s"' % prev[j:j+k] )
5850 if k > 0:
5851 # difflib must not have optimized opcodes properly;
5852 sel_to = j
5853
5854 else:
5855 # look for possible ambiguous diff:
5856
5857 # if last change resulted in no selection, test from resulting cursor position:
5858 if prev_sel_start == prev_sel_to:
5859 calc_select_len = sel_to - sel_start
5860 field = self._FindField(prev_sel_start)
5861
5862 # determine which way to search from last cursor position for ambiguous change:
5863 if field._insertRight:
5864 test_sel_start = prev_sel_start
5865 test_sel_to = prev_sel_start + calc_select_len
5866 else:
5867 test_sel_start = prev_sel_start - calc_select_len
5868 test_sel_to = prev_sel_start
5869 else:
5870 test_sel_start, test_sel_to = prev_sel_start, prev_sel_to
5871
5872 ## dbg('test selection:', (test_sel_start, test_sel_to))
5873 ## dbg('calc change: "%s"' % prev[sel_start:sel_to])
5874 ## dbg('test change: "%s"' % prev[test_sel_start:test_sel_to])
5875
5876 # if calculated selection spans characters, and same characters
5877 # "before" the previous insertion point are present there as well,
5878 # select the ones related to the last known selection instead.
5879 if( sel_start != sel_to
5880 and test_sel_to < len(self._template)
5881 and prev[test_sel_start:test_sel_to] == prev[sel_start:sel_to] ):
5882
5883 sel_start, sel_to = test_sel_start, test_sel_to
5884
5885 # finally, make sure that the old and new values are
5886 # different where we say they're different:
5887 while( sel_to - 1 > 0
5888 and sel_to > sel_start
5889 and value[sel_to-1:] == prev[sel_to-1:]):
5890 sel_to -= 1
5891 while( sel_start + 1 < self._masklength
5892 and sel_start < sel_to
5893 and value[:sel_start+1] == prev[:sel_start+1]):
5894 sel_start += 1
5895
5896 ## dbg('sel_start, sel_to:', sel_start, sel_to)
5897 ## dbg('previous value: "%s"' % prev)
5898 ## dbg(indent=0)
5899 if just_return_results:
5900 return prev, (sel_start, sel_to)
5901 # else...
5902 self._SetValue(prev)
5903 self._SetInsertionPoint(sel_start)
5904 self._SetSelection(sel_start, sel_to)
5905
5906 else:
5907 ## dbg('no difference between previous value')
5908 ## dbg(indent=0)
5909 if just_return_results:
5910 return prev, self._GetSelection()
5911
5912
5913 def _OnClear(self, event):
5914 """ Provides an action for context menu delete operation """
5915 self.ClearValue()
5916
5917
5918 def _OnContextMenu(self, event):
5919 ## dbg('MaskedEditMixin::OnContextMenu()', indent=1)
5920 menu = wx.Menu()
5921 menu.Append(wx.ID_UNDO, "Undo", "")
5922 menu.AppendSeparator()
5923 menu.Append(wx.ID_CUT, "Cut", "")
5924 menu.Append(wx.ID_COPY, "Copy", "")
5925 menu.Append(wx.ID_PASTE, "Paste", "")
5926 menu.Append(wx.ID_CLEAR, "Delete", "")
5927 menu.AppendSeparator()
5928 menu.Append(wx.ID_SELECTALL, "Select All", "")
5929
5930 wx.EVT_MENU(menu, wx.ID_UNDO, self._OnCtrl_Z)
5931 wx.EVT_MENU(menu, wx.ID_CUT, self._OnCtrl_X)
5932 wx.EVT_MENU(menu, wx.ID_COPY, self._OnCtrl_C)
5933 wx.EVT_MENU(menu, wx.ID_PASTE, self._OnCtrl_V)
5934 wx.EVT_MENU(menu, wx.ID_CLEAR, self._OnClear)
5935 wx.EVT_MENU(menu, wx.ID_SELECTALL, self._OnCtrl_A)
5936
5937 # ## WSS: The base control apparently handles
5938 # enable/disable of wx.ID_CUT, wx.ID_COPY, wx.ID_PASTE
5939 # and wx.ID_CLEAR menu items even if the menu is one
5940 # we created. However, it doesn't do undo properly,
5941 # so we're keeping track of previous values ourselves.
5942 # Therefore, we have to override the default update for
5943 # that item on the menu:
5944 wx.EVT_UPDATE_UI(self, wx.ID_UNDO, self._UndoUpdateUI)
5945 self._contextMenu = menu
5946
5947 self.PopupMenu(menu, event.GetPosition())
5948 menu.Destroy()
5949 self._contextMenu = None
5950 ## dbg(indent=0)
5951
5952 def _UndoUpdateUI(self, event):
5953 if self._prevValue is None or self._prevValue == self._curValue:
5954 self._contextMenu.Enable(wx.ID_UNDO, False)
5955 else:
5956 self._contextMenu.Enable(wx.ID_UNDO, True)
5957
5958
5959 def _OnCtrlParametersChanged(self):
5960 """
5961 Overridable function to allow derived classes to take action as a
5962 result of parameter changes prior to possibly changing the value
5963 of the control.
5964 """
5965 pass
5966
5967 ## ---------- ---------- ---------- ---------- ---------- ---------- ----------
5968 # ## TRICKY BIT: to avoid a ton of boiler-plate, and to
5969 # ## automate the getter/setter generation for each valid
5970 # ## control parameter so we never forget to add the
5971 # ## functions when adding parameters, this loop
5972 # ## programmatically adds them to the class:
5973 # ## (This makes it easier for Designers like Boa to
5974 # ## deal with masked controls.)
5975 #
5976 # ## To further complicate matters, this is done with an
5977 # ## extra level of inheritance, so that "general" classes like
5978 # ## MaskedTextCtrl can have all possible attributes,
5979 # ## while derived classes, like TimeCtrl and MaskedNumCtrl
5980 # ## can prevent exposure of those optional attributes of their base
5981 # ## class that do not make sense for their derivation. Therefore,
5982 # ## we define
5983 # ## BaseMaskedTextCtrl(TextCtrl, MaskedEditMixin)
5984 # ## and
5985 # ## MaskedTextCtrl(BaseMaskedTextCtrl, MaskedEditAccessorsMixin).
5986 # ##
5987 # ## This allows us to then derive:
5988 # ## MaskedNumCtrl( BaseMaskedTextCtrl )
5989 # ##
5990 # ## and not have to expose all the same accessor functions for the
5991 # ## derived control when they don't all make sense for it.
5992 # ##
5993 class MaskedEditAccessorsMixin:
5994
5995 # Define the default set of attributes exposed by the most generic masked controls:
5996 exposed_basectrl_params = MaskedEditMixin.valid_ctrl_params.keys() + Field.valid_params.keys()
5997 exposed_basectrl_params.remove('index')
5998 exposed_basectrl_params.remove('extent')
5999 exposed_basectrl_params.remove('foregroundColour') # (base class already has this)
6000
6001 for param in exposed_basectrl_params:
6002 propname = param[0].upper() + param[1:]
6003 exec('def Set%s(self, value): self.SetCtrlParameters(%s=value)' % (propname, param))
6004 exec('def Get%s(self): return self.GetCtrlParameter("%s")''' % (propname, param))
6005
6006 if param.find('Colour') != -1:
6007 # add non-british spellings, for backward-compatibility
6008 propname.replace('Colour', 'Color')
6009
6010 exec('def Set%s(self, value): self.SetCtrlParameters(%s=value)' % (propname, param))
6011 exec('def Get%s(self): return self.GetCtrlParameter("%s")''' % (propname, param))
6012
6013
6014
6015
6016 ## ---------- ---------- ---------- ---------- ---------- ---------- ----------
6017 ## these are helper subroutines:
6018
6019 def movetofloat( origvalue, fmtstring, neg, addseparators=False, sepchar = ',',fillchar=' '):
6020 """ addseparators = add separator character every three numerals if True
6021 """
6022 fmt0 = fmtstring.split('.')
6023 fmt1 = fmt0[0]
6024 fmt2 = fmt0[1]
6025 val = origvalue.split('.')[0].strip()
6026 ret = fillchar * (len(fmt1)-len(val)) + val + "." + "0" * len(fmt2)
6027 if neg:
6028 ret = '-' + ret[1:]
6029 return (ret,len(fmt1))
6030
6031
6032 def isDateType( fmtstring ):
6033 """ Checks the mask and returns True if it fits an allowed
6034 date or datetime format.
6035 """
6036 dateMasks = ("^##/##/####",
6037 "^##-##-####",
6038 "^##.##.####",
6039 "^####/##/##",
6040 "^####-##-##",
6041 "^####.##.##",
6042 "^##/CCC/####",
6043 "^##.CCC.####",
6044 "^##/##/##$",
6045 "^##/##/## ",
6046 "^##/CCC/##$",
6047 "^##.CCC.## ",)
6048 reString = "|".join(dateMasks)
6049 filter = re.compile( reString)
6050 if re.match(filter,fmtstring): return True
6051 return False
6052
6053 def isTimeType( fmtstring ):
6054 """ Checks the mask and returns True if it fits an allowed
6055 time format.
6056 """
6057 reTimeMask = "^##:##(:##)?( (AM|PM))?"
6058 filter = re.compile( reTimeMask )
6059 if re.match(filter,fmtstring): return True
6060 return False
6061
6062
6063 def isFloatingPoint( fmtstring):
6064 filter = re.compile("[ ]?[#]+\.[#]+\n")
6065 if re.match(filter,fmtstring+"\n"): return True
6066 return False
6067
6068
6069 def isInteger( fmtstring ):
6070 filter = re.compile("[#]+\n")
6071 if re.match(filter,fmtstring+"\n"): return True
6072 return False
6073
6074
6075 def getDateParts( dateStr, dateFmt ):
6076 if len(dateStr) > 11: clip = dateStr[0:11]
6077 else: clip = dateStr
6078 if clip[-2] not in string.digits:
6079 clip = clip[:-1] # (got part of time; drop it)
6080
6081 dateSep = (('/' in clip) * '/') + (('-' in clip) * '-') + (('.' in clip) * '.')
6082 slices = clip.split(dateSep)
6083 if dateFmt == "MDY":
6084 y,m,d = (slices[2],slices[0],slices[1]) ## year, month, date parts
6085 elif dateFmt == "DMY":
6086 y,m,d = (slices[2],slices[1],slices[0]) ## year, month, date parts
6087 elif dateFmt == "YMD":
6088 y,m,d = (slices[0],slices[1],slices[2]) ## year, month, date parts
6089 else:
6090 y,m,d = None, None, None
6091 if not y:
6092 return None
6093 else:
6094 return y,m,d
6095
6096
6097 def getDateSepChar(dateStr):
6098 clip = dateStr[0:10]
6099 dateSep = (('/' in clip) * '/') + (('-' in clip) * '-') + (('.' in clip) * '.')
6100 return dateSep
6101
6102
6103 def makeDate( year, month, day, dateFmt, dateStr):
6104 sep = getDateSepChar( dateStr)
6105 if dateFmt == "MDY":
6106 return "%s%s%s%s%s" % (month,sep,day,sep,year) ## year, month, date parts
6107 elif dateFmt == "DMY":
6108 return "%s%s%s%s%s" % (day,sep,month,sep,year) ## year, month, date parts
6109 elif dateFmt == "YMD":
6110 return "%s%s%s%s%s" % (year,sep,month,sep,day) ## year, month, date parts
6111 else:
6112 return none
6113
6114
6115 def getYear(dateStr,dateFmt):
6116 parts = getDateParts( dateStr, dateFmt)
6117 return parts[0]
6118
6119 def getMonth(dateStr,dateFmt):
6120 parts = getDateParts( dateStr, dateFmt)
6121 return parts[1]
6122
6123 def getDay(dateStr,dateFmt):
6124 parts = getDateParts( dateStr, dateFmt)
6125 return parts[2]
6126
6127 ## ---------- ---------- ---------- ---------- ---------- ---------- ----------
6128 class test(wx.PySimpleApp):
6129 def OnInit(self):
6130 from wx.lib.rcsizer import RowColSizer
6131 self.frame = wx.Frame( None, -1, "MaskedEditMixin 0.0.7 Demo Page #1", size = (700,600))
6132 self.panel = wx.Panel( self.frame, -1)
6133 self.sizer = RowColSizer()
6134 self.labels = []
6135 self.editList = []
6136 rowcount = 4
6137
6138 id, id1 = wx.NewId(), wx.NewId()
6139 self.command1 = wx.Button( self.panel, id, "&Close" )
6140 self.command2 = wx.Button( self.panel, id1, "&AutoFormats" )
6141 self.sizer.Add(self.command1, row=0, col=0, flag=wx.ALL, border = 5)
6142 self.sizer.Add(self.command2, row=0, col=1, colspan=2, flag=wx.ALL, border = 5)
6143 self.panel.Bind(wx.EVT_BUTTON, self.onClick, self.command1 )
6144 ## self.panel.SetDefaultItem(self.command1 )
6145 self.panel.Bind(wx.EVT_BUTTON, self.onClickPage, self.command2)
6146
6147 self.check1 = wx.CheckBox( self.panel, -1, "Disallow Empty" )
6148 self.check2 = wx.CheckBox( self.panel, -1, "Highlight Empty" )
6149 self.sizer.Add( self.check1, row=0,col=3, flag=wx.ALL,border=5 )
6150 self.sizer.Add( self.check2, row=0,col=4, flag=wx.ALL,border=5 )
6151 self.panel.Bind(wx.EVT_CHECKBOX, self._onCheck1, self.check1 )
6152 self.panel.Bind(wx.EVT_CHECKBOX, self._onCheck2, self.check2 )
6153
6154
6155 label = """Press ctrl-s in any field to output the value and plain value. Press ctrl-x to clear and re-set any field.
6156 Note that all controls have been auto-sized by including F in the format code.
6157 Try entering nonsensical or partial values in validated fields to see what happens (use ctrl-s to test the valid status)."""
6158 label2 = "\nNote that the State and Last Name fields are list-limited (Name:Smith,Jones,Williams)."
6159
6160 self.label1 = wx.StaticText( self.panel, -1, label)
6161 self.label2 = wx.StaticText( self.panel, -1, "Description")
6162 self.label3 = wx.StaticText( self.panel, -1, "Mask Value")
6163 self.label4 = wx.StaticText( self.panel, -1, "Format")
6164 self.label5 = wx.StaticText( self.panel, -1, "Reg Expr Val. (opt)")
6165 self.label6 = wx.StaticText( self.panel, -1, "MaskedEdit Ctrl")
6166 self.label7 = wx.StaticText( self.panel, -1, label2)
6167 self.label7.SetForegroundColour("Blue")
6168 self.label1.SetForegroundColour("Blue")
6169 self.label2.SetFont(wx.Font(9,wx.SWISS,wx.NORMAL,wx.BOLD))
6170 self.label3.SetFont(wx.Font(9,wx.SWISS,wx.NORMAL,wx.BOLD))
6171 self.label4.SetFont(wx.Font(9,wx.SWISS,wx.NORMAL,wx.BOLD))
6172 self.label5.SetFont(wx.Font(9,wx.SWISS,wx.NORMAL,wx.BOLD))
6173 self.label6.SetFont(wx.Font(9,wx.SWISS,wx.NORMAL,wx.BOLD))
6174
6175 self.sizer.Add( self.label1, row=1,col=0,colspan=7, flag=wx.ALL,border=5)
6176 self.sizer.Add( self.label7, row=2,col=0,colspan=7, flag=wx.ALL,border=5)
6177 self.sizer.Add( self.label2, row=3,col=0, flag=wx.ALL,border=5)
6178 self.sizer.Add( self.label3, row=3,col=1, flag=wx.ALL,border=5)
6179 self.sizer.Add( self.label4, row=3,col=2, flag=wx.ALL,border=5)
6180 self.sizer.Add( self.label5, row=3,col=3, flag=wx.ALL,border=5)
6181 self.sizer.Add( self.label6, row=3,col=4, flag=wx.ALL,border=5)
6182
6183 # The following list is of the controls for the demo. Feel free to play around with
6184 # the options!
6185 controls = [
6186 #description mask excl format regexp range,list,initial
6187 ("Phone No", "(###) ###-#### x:###", "", 'F!^-R', "^\(\d\d\d\) \d\d\d-\d\d\d\d", (),[],''),
6188 ("Last Name Only", "C{14}", "", 'F {list}', '^[A-Z][a-zA-Z]+', (),('Smith','Jones','Williams'),''),
6189 ("Full Name", "C{14}", "", 'F_', '^[A-Z][a-zA-Z]+ [A-Z][a-zA-Z]+', (),[],''),
6190 ("Social Sec#", "###-##-####", "", 'F', "\d{3}-\d{2}-\d{4}", (),[],''),
6191 ("U.S. Zip+4", "#{5}-#{4}", "", 'F', "\d{5}-(\s{4}|\d{4})",(),[],''),
6192 ("U.S. State (2 char)\n(with default)","AA", "", 'F!', "[A-Z]{2}", (),states, 'AZ'),
6193 ("Customer No", "\CAA-###", "", 'F!', "C[A-Z]{2}-\d{3}", (),[],''),
6194 ("Date (MDY) + Time\n(with default)", "##/##/#### ##:## AM", 'BCDEFGHIJKLMNOQRSTUVWXYZ','DFR!',"", (),[], r'03/05/2003 12:00 AM'),
6195 ("Invoice Total", "#{9}.##", "", 'F-R,', "", (),[], ''),
6196 ("Integer (signed)\n(with default)", "#{6}", "", 'F-R', "", (),[], '0 '),
6197 ("Integer (unsigned)\n(with default), 1-399", "######", "", 'F', "", (1,399),[], '1 '),
6198 ("Month selector", "XXX", "", 'F', "", (),
6199 ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],""),
6200 ("fraction selector","#/##", "", 'F', "^\d\/\d\d?", (),
6201 ['2/3', '3/4', '1/2', '1/4', '1/8', '1/16', '1/32', '1/64'], "")
6202 ]
6203
6204 for control in controls:
6205 self.sizer.Add( wx.StaticText( self.panel, -1, control[0]),row=rowcount, col=0,border=5,flag=wx.ALL)
6206 self.sizer.Add( wx.StaticText( self.panel, -1, control[1]),row=rowcount, col=1,border=5, flag=wx.ALL)
6207 self.sizer.Add( wx.StaticText( self.panel, -1, control[3]),row=rowcount, col=2,border=5, flag=wx.ALL)
6208 self.sizer.Add( wx.StaticText( self.panel, -1, control[4][:20]),row=rowcount, col=3,border=5, flag=wx.ALL)
6209
6210 if control in controls[:]:#-2]:
6211 newControl = MaskedTextCtrl( self.panel, -1, "",
6212 mask = control[1],
6213 excludeChars = control[2],
6214 formatcodes = control[3],
6215 includeChars = "",
6216 validRegex = control[4],
6217 validRange = control[5],
6218 choices = control[6],
6219 defaultValue = control[7],
6220 demo = True)
6221 if control[6]: newControl.SetCtrlParameters(choiceRequired = True)
6222 else:
6223 newControl = MaskedComboBox( self.panel, -1, "",
6224 choices = control[7],
6225 choiceRequired = True,
6226 mask = control[1],
6227 formatcodes = control[3],
6228 excludeChars = control[2],
6229 includeChars = "",
6230 validRegex = control[4],
6231 validRange = control[5],
6232 demo = True)
6233 self.editList.append( newControl )
6234
6235 self.sizer.Add( newControl, row=rowcount,col=4,flag=wx.ALL,border=5)
6236 rowcount += 1
6237
6238 self.sizer.AddGrowableCol(4)
6239
6240 self.panel.SetSizer(self.sizer)
6241 self.panel.SetAutoLayout(1)
6242
6243 self.frame.Show(1)
6244 self.MainLoop()
6245
6246 return True
6247
6248 def onClick(self, event):
6249 self.frame.Close()
6250
6251 def onClickPage(self, event):
6252 self.page2 = test2(self.frame,-1,"")
6253 self.page2.Show(True)
6254
6255 def _onCheck1(self,event):
6256 """ Set required value on/off """
6257 value = event.IsChecked()
6258 if value:
6259 for control in self.editList:
6260 control.SetCtrlParameters(emptyInvalid=True)
6261 control.Refresh()
6262 else:
6263 for control in self.editList:
6264 control.SetCtrlParameters(emptyInvalid=False)
6265 control.Refresh()
6266 self.panel.Refresh()
6267
6268 def _onCheck2(self,event):
6269 """ Highlight empty values"""
6270 value = event.IsChecked()
6271 if value:
6272 for control in self.editList:
6273 control.SetCtrlParameters( emptyBackgroundColour = 'Aquamarine')
6274 control.Refresh()
6275 else:
6276 for control in self.editList:
6277 control.SetCtrlParameters( emptyBackgroundColour = 'White')
6278 control.Refresh()
6279 self.panel.Refresh()
6280
6281
6282 ## ---------- ---------- ---------- ---------- ---------- ---------- ----------
6283
6284 class test2(wx.Frame):
6285 def __init__(self, parent, id, caption):
6286 wx.Frame.__init__( self, parent, id, "MaskedEdit control 0.0.7 Demo Page #2 -- AutoFormats", size = (550,600))
6287 from wx.lib.rcsizer import RowColSizer
6288 self.panel = wx.Panel( self, -1)
6289 self.sizer = RowColSizer()
6290 self.labels = []
6291 self.texts = []
6292 rowcount = 4
6293
6294 label = """\
6295 All these controls have been created by passing a single parameter, the AutoFormat code.
6296 The class contains an internal dictionary of types and formats (autoformats).
6297 To see a great example of validations in action, try entering a bad email address, then tab out."""
6298
6299 self.label1 = wx.StaticText( self.panel, -1, label)
6300 self.label2 = wx.StaticText( self.panel, -1, "Description")
6301 self.label3 = wx.StaticText( self.panel, -1, "AutoFormat Code")
6302 self.label4 = wx.StaticText( self.panel, -1, "MaskedEdit Control")
6303 self.label1.SetForegroundColour("Blue")
6304 self.label2.SetFont(wx.Font(9,wx.SWISS,wx.NORMAL,wx.BOLD))
6305 self.label3.SetFont(wx.Font(9,wx.SWISS,wx.NORMAL,wx.BOLD))
6306 self.label4.SetFont(wx.Font(9,wx.SWISS,wx.NORMAL,wx.BOLD))
6307
6308 self.sizer.Add( self.label1, row=1,col=0,colspan=3, flag=wx.ALL,border=5)
6309 self.sizer.Add( self.label2, row=3,col=0, flag=wx.ALL,border=5)
6310 self.sizer.Add( self.label3, row=3,col=1, flag=wx.ALL,border=5)
6311 self.sizer.Add( self.label4, row=3,col=2, flag=wx.ALL,border=5)
6312
6313 id, id1 = wx.NewId(), wx.NewId()
6314 self.command1 = wx.Button( self.panel, id, "&Close")
6315 self.command2 = wx.Button( self.panel, id1, "&Print Formats")
6316 self.panel.Bind(wx.EVT_BUTTON, self.onClick, self.command1)
6317 self.panel.SetDefaultItem(self.command1)
6318 self.panel.Bind(wx.EVT_BUTTON, self.onClickPrint, self.command2)
6319
6320 # The following list is of the controls for the demo. Feel free to play around with
6321 # the options!
6322 controls = [
6323 ("Phone No","USPHONEFULLEXT"),
6324 ("US Date + Time","USDATETIMEMMDDYYYY/HHMM"),
6325 ("US Date MMDDYYYY","USDATEMMDDYYYY/"),
6326 ("Time (with seconds)","TIMEHHMMSS"),
6327 ("Military Time\n(without seconds)","24HRTIMEHHMM"),
6328 ("Social Sec#","USSOCIALSEC"),
6329 ("Credit Card","CREDITCARD"),
6330 ("Expiration MM/YY","EXPDATEMMYY"),
6331 ("Percentage","PERCENT"),
6332 ("Person's Age","AGE"),
6333 ("US Zip Code","USZIP"),
6334 ("US Zip+4","USZIPPLUS4"),
6335 ("Email Address","EMAIL"),
6336 ("IP Address", "(derived control IpAddrCtrl)")
6337 ]
6338
6339 for control in controls:
6340 self.sizer.Add( wx.StaticText( self.panel, -1, control[0]),row=rowcount, col=0,border=5,flag=wx.ALL)
6341 self.sizer.Add( wx.StaticText( self.panel, -1, control[1]),row=rowcount, col=1,border=5, flag=wx.ALL)
6342 if control in controls[:-1]:
6343 self.sizer.Add( MaskedTextCtrl( self.panel, -1, "",
6344 autoformat = control[1],
6345 demo = True),
6346 row=rowcount,col=2,flag=wx.ALL,border=5)
6347 else:
6348 self.sizer.Add( IpAddrCtrl( self.panel, -1, "", demo=True ),
6349 row=rowcount,col=2,flag=wx.ALL,border=5)
6350 rowcount += 1
6351
6352 self.sizer.Add(self.command1, row=0, col=0, flag=wx.ALL, border = 5)
6353 self.sizer.Add(self.command2, row=0, col=1, flag=wx.ALL, border = 5)
6354 self.sizer.AddGrowableCol(3)
6355
6356 self.panel.SetSizer(self.sizer)
6357 self.panel.SetAutoLayout(1)
6358
6359 def onClick(self, event):
6360 self.Close()
6361
6362 def onClickPrint(self, event):
6363 for format in masktags.keys():
6364 sep = "+------------------------+"
6365 print "%s\n%s \n Mask: %s \n RE Validation string: %s\n" % (sep,format, masktags[format]['mask'], masktags[format]['validRegex'])
6366
6367 ## ---------- ---------- ---------- ---------- ---------- ---------- ----------
6368
6369 if __name__ == "__main__":
6370 app = test(False)
6371
6372 i=1
6373 ##
6374 ## Current Issues:
6375 ## ===================================
6376 ##
6377 ## 1. WS: For some reason I don't understand, the control is generating two (2)
6378 ## EVT_TEXT events for every one (1) .SetValue() of the underlying control.
6379 ## I've been unsuccessful in determining why or in my efforts to make just one
6380 ## occur. So, I've added a hack to save the last seen value from the
6381 ## control in the EVT_TEXT handler, and if *different*, call event.Skip()
6382 ## to propagate it down the event chain, and let the application see it.
6383 ##
6384 ## 2. WS: MaskedComboBox is deficient in several areas, all having to do with the
6385 ## behavior of the underlying control that I can't fix. The problems are:
6386 ## a) The background coloring doesn't work in the text field of the control;
6387 ## instead, there's a only border around it that assumes the correct color.
6388 ## b) The control will not pass WXK_TAB to the event handler, no matter what
6389 ## I do, and there's no style wxCB_PROCESS_TAB like wxTE_PROCESS_TAB to
6390 ## indicate that we want these events. As a result, MaskedComboBox
6391 ## doesn't do the nice field-tabbing that MaskedTextCtrl does.
6392 ## c) Auto-complete had to be reimplemented for the control because programmatic
6393 ## setting of the value of the text field does not set up the auto complete
6394 ## the way that the control processing keystrokes does. (But I think I've
6395 ## implemented a fairly decent approximation.) Because of this the control
6396 ## also won't auto-complete on dropdown, and there's no event I can catch
6397 ## to work around this problem.
6398 ## d) There is no method provided for getting the selection; the hack I've
6399 ## implemented has its flaws, not the least of which is that due to the
6400 ## strategy that I'm using, the paste buffer is always replaced by the
6401 ## contents of the control's selection when in focus, on each keystroke;
6402 ## this makes it impossible to paste anything into a MaskedComboBox
6403 ## at the moment... :-(
6404 ## e) The other deficient behavior, likely induced by the workaround for (d),
6405 ## is that you can can't shift-left to select more than one character
6406 ## at a time.
6407 ##
6408 ##
6409 ## 3. WS: Controls on wxPanels don't seem to pass Shift-WXK_TAB to their
6410 ## EVT_KEY_DOWN or EVT_CHAR event handlers. Until this is fixed in
6411 ## wxWindows, shift-tab won't take you backwards through the fields of
6412 ## a MaskedTextCtrl like it should. Until then Shifted arrow keys will
6413 ## work like shift-tab and tab ought to.
6414 ##
6415
6416 ## To-Do's:
6417 ## =============================##
6418 ## 1. Add Popup list for auto-completable fields that simulates combobox on individual
6419 ## fields. Example: City validates against list of cities, or zip vs zip code list.
6420 ## 2. Allow optional monetary symbols (eg. $, pounds, etc.) at front of a "decimal"
6421 ## control.
6422 ## 3. Fix shift-left selection for MaskedComboBox.
6423 ## 5. Transform notion of "decimal control" to be less "entire control"-centric,
6424 ## so that monetary symbols can be included and still have the appropriate
6425 ## semantics. (Big job, as currently written, but would make control even
6426 ## more useful for business applications.)
6427
6428
6429 ## CHANGELOG:
6430 ## ====================
6431 ## Version 1.7
6432 ## 1. Fixed intra-right-insert-field erase, such that it doesn't leave a hole, but instead
6433 ## shifts the text to the left accordingly.
6434 ## 2. Fixed _SetValue() to place cursor after last character inserted, rather than end of
6435 ## mask.
6436 ## 3. Fixed some incorrect undo behavior for right-insert fields, and allowed derived classes
6437 ## (eg. numctrl) to pass modified values for undo processing (to handle/ignore grouping
6438 ## chars properly.)
6439 ## 4. Fixed autoselect behavior to work similarly to (2) above, so that combobox
6440 ## selection will only select the non-empty text, as per request.
6441 ## 5. Fixed tabbing to work with 2.5.2 semantics.
6442 ## 6. Fixed size calculation to handle changing fonts
6443 ##
6444 ## Version 1.6
6445 ## 1. Reorganized masked controls into separate package, renamed things accordingly
6446 ## 2. Split actual controls out of this file into their own files.
6447 ## Version 1.5
6448 ## (Reported) bugs fixed:
6449 ## 1. Crash ensues if you attempt to change the mask of a read-only
6450 ## MaskedComboBox after initial construction.
6451 ## 2. Changed strategy of defining Get/Set property functions so that
6452 ## these are now generated dynamically at runtime, rather than as
6453 ## part of the class definition. (This makes it possible to have
6454 ## more general base classes that have many more options for configuration
6455 ## without requiring that derivations support the same options.)
6456 ## 3. Fixed IsModified for _Paste() and _OnErase().
6457 ##
6458 ## Enhancements:
6459 ## 1. Fixed "attribute function inheritance," since base control is more
6460 ## generic than subsequent derivations, not all property functions of a
6461 ## generic control should be exposed in those derivations. New strategy
6462 ## uses base control classes (eg. BaseMaskedTextCtrl) that should be
6463 ## used to derive new class types, and mixed with their own mixins to
6464 ## only expose those attributes from the generic masked controls that
6465 ## make sense for the derivation. (This makes Boa happier.)
6466 ## 2. Renamed (with b-c) MILTIME autoformats to 24HRTIME, so as to be less
6467 ## "parochial."
6468 ##
6469 ## Version 1.4
6470 ## (Reported) bugs fixed:
6471 ## 1. Right-click menu allowed "cut" operation that destroyed mask
6472 ## (was implemented by base control)
6473 ## 2. MaskedComboBox didn't allow .Append() of mixed-case values; all
6474 ## got converted to lower case.
6475 ## 3. MaskedComboBox selection didn't deal with spaces in values
6476 ## properly when autocompleting, and didn't have a concept of "next"
6477 ## match for handling choice list duplicates.
6478 ## 4. Size of MaskedComboBox was always default.
6479 ## 5. Email address regexp allowed some "non-standard" things, and wasn't
6480 ## general enough.
6481 ## 6. Couldn't easily reset MaskedComboBox contents programmatically.
6482 ## 7. Couldn't set emptyInvalid during construction.
6483 ## 8. Under some versions of wxPython, readonly comboboxes can apparently
6484 ## return a GetInsertionPoint() result (655535), causing masked control
6485 ## to fail.
6486 ## 9. Specifying an empty mask caused the controls to traceback.
6487 ## 10. Can't specify float ranges for validRange.
6488 ## 11. '.' from within a the static portion of a restricted IP address
6489 ## destroyed the mask from that point rightward; tab when cursor is
6490 ## before 1st field takes cursor past that field.
6491 ##
6492 ## Enhancements:
6493 ## 12. Added Ctrl-Z/Undo handling, (and implemented context-menu properly.)
6494 ## 13. Added auto-select option on char input for masked controls with
6495 ## choice lists.
6496 ## 14. Added '>' formatcode, allowing insert within a given or each field
6497 ## as appropriate, rather than requiring "overwrite". This makes single
6498 ## field controls that just have validation rules (eg. EMAIL) much more
6499 ## friendly. The same flag controls left shift when deleting vs just
6500 ## blanking the value, and for right-insert fields, allows right-insert
6501 ## at any non-blank (non-sign) position in the field.
6502 ## 15. Added option to use to indicate negative values for numeric controls.
6503 ## 16. Improved OnFocus handling of numeric controls.
6504 ## 17. Enhanced Home/End processing to allow operation on a field level,
6505 ## using ctrl key.
6506 ## 18. Added individual Get/Set functions for control parameters, for
6507 ## simplified integration with Boa Constructor.
6508 ## 19. Standardized "Colour" parameter names to match wxPython, with
6509 ## non-british spellings still supported for backward-compatibility.
6510 ## 20. Added '&' mask specification character for punctuation only (no letters
6511 ## or digits).
6512 ## 21. Added (in a separate file) wx.MaskedCtrl() factory function to provide
6513 ## unified interface to the masked edit subclasses.
6514 ##
6515 ##
6516 ## Version 1.3
6517 ## 1. Made it possible to configure grouping, decimal and shift-decimal characters,
6518 ## to make controls more usable internationally.
6519 ## 2. Added code to smart "adjust" value strings presented to .SetValue()
6520 ## for right-aligned numeric format controls if they are shorter than
6521 ## than the control width, prepending the missing portion, prepending control
6522 ## template left substring for the missing characters, so that setting
6523 ## numeric values is easier.
6524 ## 3. Renamed SetMaskParameters SetCtrlParameters() (with old name preserved
6525 ## for b-c), as this makes more sense.
6526 ##
6527 ## Version 1.2
6528 ## 1. Fixed .SetValue() to replace the current value, rather than the current
6529 ## selection. Also changed it to generate ValueError if presented with
6530 ## either a value which doesn't follow the format or won't fit. Also made
6531 ## set value adjust numeric and date controls as if user entered the value.
6532 ## Expanded doc explaining how SetValue() works.
6533 ## 2. Fixed EUDATE* autoformats, fixed IsDateType mask list, and added ability to
6534 ## use 3-char months for dates, and EUDATETIME, and EUDATEMILTIME autoformats.
6535 ## 3. Made all date autoformats automatically pick implied "datestyle".
6536 ## 4. Added IsModified override, since base wx.TextCtrl never reports modified if
6537 ## .SetValue used to change the value, which is what the masked edit controls
6538 ## use internally.
6539 ## 5. Fixed bug in date position adjustment on 2 to 4 digit date conversion when
6540 ## using tab to "leave field" and auto-adjust.
6541 ## 6. Fixed bug in _isCharAllowed() for negative number insertion on pastes,
6542 ## and bug in ._Paste() that didn't account for signs in signed masks either.
6543 ## 7. Fixed issues with _adjustPos for right-insert fields causing improper
6544 ## selection/replacement of values
6545 ## 8. Fixed _OnHome handler to properly handle extending current selection to
6546 ## beginning of control.
6547 ## 9. Exposed all (valid) autoformats to demo, binding descriptions to
6548 ## autoformats.
6549 ## 10. Fixed a couple of bugs in email regexp.
6550 ## 11. Made maskchardict an instance var, to make mask chars to be more
6551 ## amenable to international use.
6552 ## 12. Clarified meaning of '-' formatcode in doc.
6553 ## 13. Fixed a couple of coding bugs being flagged by Python2.1.
6554 ## 14. Fixed several issues with sign positioning, erasure and validity
6555 ## checking for "numeric" masked controls.
6556 ## 15. Added validation to IpAddrCtrl.SetValue().
6557 ##
6558 ## Version 1.1
6559 ## 1. Changed calling interface to use boolean "useFixedWidthFont" (True by default)
6560 ## vs. literal font facename, and use wxTELETYPE as the font family
6561 ## if so specified.
6562 ## 2. Switched to use of dbg module vs. locally defined version.
6563 ## 3. Revamped entire control structure to use Field classes to hold constraint
6564 ## and formatting data, to make code more hierarchical, allow for more
6565 ## sophisticated masked edit construction.
6566 ## 4. Better strategy for managing options, and better validation on keywords.
6567 ## 5. Added 'V' format code, which requires that in order for a character
6568 ## to be accepted, it must result in a string that passes the validRegex.
6569 ## 6. Added 'S' format code which means "select entire field when navigating
6570 ## to new field."
6571 ## 7. Added 'r' format code to allow "right-insert" fields. (implies 'R'--right-alignment)
6572 ## 8. Added '<' format code to allow fields to require explicit cursor movement
6573 ## to leave field.
6574 ## 9. Added validFunc option to other validation mechanisms, that allows derived
6575 ## classes to add dynamic validation constraints to the control.
6576 ## 10. Fixed bug in validatePaste code causing possible IndexErrors, and also
6577 ## fixed failure to obey case conversion codes when pasting.
6578 ## 11. Implemented '0' (zero-pad) formatting code, as it wasn't being done anywhere...
6579 ## 12. Removed condition from OnDecimalPoint, so that it always truncates right on '.'
6580 ## 13. Enhanced IpAddrCtrl to use right-insert fields, selection on field traversal,
6581 ## individual field validation to prevent field values > 255, and require explicit
6582 ## tab/. to change fields.
6583 ## 14. Added handler for left double-click to select field under cursor.
6584 ## 15. Fixed handling for "Read-only" styles.
6585 ## 16. Separated signedForegroundColor from 'R' style, and added foregroundColor
6586 ## attribute, for more consistent and controllable coloring.
6587 ## 17. Added retainFieldValidation parameter, allowing top-level constraints
6588 ## such as "validRequired" to be set independently of field-level equivalent.
6589 ## (needed in TimeCtrl for bounds constraints.)
6590 ## 18. Refactored code a bit, cleaned up and commented code more heavily, fixed
6591 ## some of the logic for setting/resetting parameters, eg. fillChar, defaultValue,
6592 ## etc.
6593 ## 19. Fixed maskchar setting for upper/lowercase, to work in all locales.
6594 ##
6595 ##
6596 ## Version 1.0
6597 ## 1. Decimal point behavior restored for decimal and integer type controls:
6598 ## decimal point now trucates the portion > 0.
6599 ## 2. Return key now works like the tab character and moves to the next field,
6600 ## provided no default button is set for the form panel on which the control
6601 ## resides.
6602 ## 3. Support added in _FindField() for subclasses controls (like timecontrol)
6603 ## to determine where the current insertion point is within the mask (i.e.
6604 ## which sub-'field'). See method documentation for more info and examples.
6605 ## 4. Added Field class and support for all constraints to be field-specific
6606 ## in addition to being globally settable for the control.
6607 ## Choices for each field are validated for length and pastability into
6608 ## the field in question, raising ValueError if not appropriate for the control.
6609 ## Also added selective additional validation based on individual field constraints.
6610 ## By default, SHIFT-WXK_DOWN, SHIFT-WXK_UP, WXK_PRIOR and WXK_NEXT all
6611 ## auto-complete fields with choice lists, supplying the 1st entry in
6612 ## the choice list if the field is empty, and cycling through the list in
6613 ## the appropriate direction if already a match. WXK_DOWN will also auto-
6614 ## complete if the field is partially completed and a match can be made.
6615 ## SHIFT-WXK_UP/DOWN will also take you to the next field after any
6616 ## auto-completion performed.
6617 ## 5. Added autoCompleteKeycodes=[] parameters for allowing further
6618 ## customization of the control. Any keycode supplied as a member
6619 ## of the _autoCompleteKeycodes list will be treated like WXK_NEXT. If
6620 ## requireFieldChoice is set, then a valid value from each non-empty
6621 ## choice list will be required for the value of the control to validate.
6622 ## 6. Fixed "auto-sizing" to be relative to the font actually used, rather
6623 ## than making assumptions about character width.
6624 ## 7. Fixed GetMaskParameter(), which was non-functional in previous version.
6625 ## 8. Fixed exceptions raised to provide info on which control had the error.
6626 ## 9. Fixed bug in choice management of MaskedComboBox.
6627 ## 10. Fixed bug in IpAddrCtrl causing traceback if field value was of
6628 ## the form '# #'. Modified control code for IpAddrCtrl so that '.'
6629 ## in the middle of a field clips the rest of that field, similar to
6630 ## decimal and integer controls.
6631 ##
6632 ##
6633 ## Version 0.0.7
6634 ## 1. "-" is a toggle for sign; "+" now changes - signed numerics to positive.
6635 ## 2. ',' in formatcodes now causes numeric values to be comma-delimited (e.g.333,333).
6636 ## 3. New support for selecting text within the control.(thanks Will Sadkin!)
6637 ## Shift-End and Shift-Home now select text as you would expect
6638 ## Control-Shift-End selects to the end of the mask string, even if value not entered.
6639 ## Control-A selects all *entered* text, Shift-Control-A selects everything in the control.
6640 ## 4. event.Skip() added to onKillFocus to correct remnants when running in Linux (contributed-
6641 ## for some reason I couldn't find the original email but thanks!!!)
6642 ## 5. All major key-handling code moved to their own methods for easier subclassing: OnHome,
6643 ## OnErase, OnEnd, OnCtrl_X, OnCtrl_A, etc.
6644 ## 6. Email and autoformat validations corrected using regex provided by Will Sadkin (thanks!).
6645 ## (The rest of the changes in this version were done by Will Sadkin with permission from Jeff...)
6646 ## 7. New mechanism for replacing default behavior for any given key, using
6647 ## ._SetKeycodeHandler(keycode, func) and ._SetKeyHandler(char, func) now available
6648 ## for easier subclassing of the control.
6649 ## 8. Reworked the delete logic, cut, paste and select/replace logic, as well as some bugs
6650 ## with insertion point/selection modification. Changed Ctrl-X to use standard "cut"
6651 ## semantics, erasing the selection, rather than erasing the entire control.
6652 ## 9. Added option for an "default value" (ie. the template) for use when a single fillChar
6653 ## is not desired in every position. Added IsDefault() function to mean "does the value
6654 ## equal the template?" and modified .IsEmpty() to mean "do all of the editable
6655 ## positions in the template == the fillChar?"
6656 ## 10. Extracted mask logic into mixin, so we can have both MaskedTextCtrl and MaskedComboBox,
6657 ## now included.
6658 ## 11. MaskedComboBox now adds the capability to validate from list of valid values.
6659 ## Example: City validates against list of cities, or zip vs zip code list.
6660 ## 12. Fixed oversight in EVT_TEXT handler that prevented the events from being
6661 ## passed to the next handler in the event chain, causing updates to the
6662 ## control to be invisible to the parent code.
6663 ## 13. Added IPADDR autoformat code, and subclass IpAddrCtrl for controlling tabbing within
6664 ## the control, that auto-reformats as you move between cells.
6665 ## 14. Mask characters [A,a,X,#] can now appear in the format string as literals, by using '\'.
6666 ## 15. It is now possible to specify repeating masks, e.g. #{3}-#{3}-#{14}
6667 ## 16. Fixed major bugs in date validation, due to the fact that
6668 ## wxDateTime.ParseDate is too liberal, and will accept any form that
6669 ## makes any kind of sense, regardless of the datestyle you specified
6670 ## for the control. Unfortunately, the strategy used to fix it only
6671 ## works for versions of wxPython post 2.3.3.1, as a C++ assert box
6672 ## seems to show up on an invalid date otherwise, instead of a catchable
6673 ## exception.
6674 ## 17. Enhanced date adjustment to automatically adjust heuristic based on
6675 ## current year, making last century/this century determination on
6676 ## 2-digit year based on distance between today's year and value;
6677 ## if > 50 year separation, assume last century (and don't assume last
6678 ## century is 20th.)
6679 ## 18. Added autoformats and support for including HHMMSS as well as HHMM for
6680 ## date times, and added similar time, and militaray time autoformats.
6681 ## 19. Enhanced tabbing logic so that tab takes you to the next field if the
6682 ## control is a multi-field control.
6683 ## 20. Added stub method called whenever the control "changes fields", that
6684 ## can be overridden by subclasses (eg. IpAddrCtrl.)
6685 ## 21. Changed a lot of code to be more functionally-oriented so side-effects
6686 ## aren't as problematic when maintaining code and/or adding features.
6687 ## Eg: IsValid() now does not have side-effects; it merely reflects the
6688 ## validity of the value of the control; to determine validity AND recolor
6689 ## the control, _CheckValid() should be used with a value argument of None.
6690 ## Similarly, made most reformatting function take an optional candidate value
6691 ## rather than just using the current value of the control, and only
6692 ## have them change the value of the control if a candidate is not specified.
6693 ## In this way, you can do validation *before* changing the control.
6694 ## 22. Changed validRequired to mean "disallow chars that result in invalid
6695 ## value." (Old meaning now represented by emptyInvalid.) (This was
6696 ## possible once I'd made the changes in (19) above.)
6697 ## 23. Added .SetMaskParameters and .GetMaskParameter methods, so they
6698 ## can be set/modified/retrieved after construction. Removed individual
6699 ## parameter setting functions, in favor of this mechanism, so that
6700 ## all adjustment of the control based on changing parameter values can
6701 ## be handled in one place with unified mechanism.
6702 ## 24. Did a *lot* of testing and fixing re: numeric values. Added ability
6703 ## to type "grouping char" (ie. ',') and validate as appropriate.
6704 ## 25. Fixed ZIPPLUS4 to allow either 5 or 4, but if > 5 must be 9.
6705 ## 26. Fixed assumption about "decimal or integer" masks so that they're only
6706 ## made iff there's no validRegex associated with the field. (This
6707 ## is so things like zipcodes which look like integers can have more
6708 ## restrictive validation (ie. must be 5 digits.)
6709 ## 27. Added a ton more doc strings to explain use and derivation requirements
6710 ## and did regularization of the naming conventions.
6711 ## 28. Fixed a range bug in _adjustKey preventing z from being handled properly.
6712 ## 29. Changed behavior of '.' (and shift-.) in numeric controls to move to
6713 ## reformat the value and move the next field as appropriate. (shift-'.',
6714 ## ie. '>' moves to the previous field.
6715
6716 ## Version 0.0.6
6717 ## 1. Fixed regex bug that caused autoformat AGE to invalidate any age ending
6718 ## in '0'.
6719 ## 2. New format character 'D' to trigger date type. If the user enters 2 digits in the
6720 ## year position, the control will expand the value to four digits, using numerals below
6721 ## 50 as 21st century (20+nn) and less than 50 as 20th century (19+nn).
6722 ## Also, new optional parameter datestyle = set to one of {MDY|DMY|YDM}
6723 ## 3. revalid parameter renamed validRegex to conform to standard for all validation
6724 ## parameters (see 2 new ones below).
6725 ## 4. New optional init parameter = validRange. Used only for int/dec (numeric) types.
6726 ## Allows the developer to specify a valid low/high range of values.
6727 ## 5. New optional init parameter = validList. Used for character types. Allows developer
6728 ## to send a list of values to the control to be used for specific validation.
6729 ## See the Last Name Only example - it is list restricted to Smith/Jones/Williams.
6730 ## 6. Date type fields now use wxDateTime's parser to validate the date and time.
6731 ## This works MUCH better than my kludgy regex!! Thanks to Robin Dunn for pointing
6732 ## me toward this solution!
6733 ## 7. Date fields now automatically expand 2-digit years when it can. For example,
6734 ## if the user types "03/10/67", then "67" will auto-expand to "1967". If a two-year
6735 ## date is entered it will be expanded in any case when the user tabs out of the
6736 ## field.
6737 ## 8. New class functions: SetValidBackgroundColor, SetInvalidBackgroundColor, SetEmptyBackgroundColor,
6738 ## SetSignedForeColor allow accessto override default class coloring behavior.
6739 ## 9. Documentation updated and improved.
6740 ## 10. Demo - page 2 is now a wxFrame class instead of a wxPyApp class. Works better.
6741 ## Two new options (checkboxes) - test highlight empty and disallow empty.
6742 ## 11. Home and End now work more intuitively, moving to the first and last user-entry
6743 ## value, respectively.
6744 ## 12. New class function: SetRequired(bool). Sets the control's entry required flag
6745 ## (i.e. disallow empty values if True).
6746 ##
6747 ## Version 0.0.5
6748 ## 1. get_plainValue method renamed to GetPlainValue following the wxWindows
6749 ## StudlyCaps(tm) standard (thanks Paul Moore). ;)
6750 ## 2. New format code 'F' causes the control to auto-fit (auto-size) itself
6751 ## based on the length of the mask template.
6752 ## 3. Class now supports "autoformat" codes. These can be passed to the class
6753 ## on instantiation using the parameter autoformat="code". If the code is in
6754 ## the dictionary, it will self set the mask, formatting, and validation string.
6755 ## I have included a number of samples, but I am hoping that someone out there
6756 ## can help me to define a whole bunch more.
6757 ## 4. I have added a second page to the demo (as well as a second demo class, test2)
6758 ## to showcase how autoformats work. The way they self-format and self-size is,
6759 ## I must say, pretty cool.
6760 ## 5. Comments added and some internal cosmetic revisions re: matching the code
6761 ## standards for class submission.
6762 ## 6. Regex validation is now done in real time - field turns yellow immediately
6763 ## and stays yellow until the entered value is valid
6764 ## 7. Cursor now skips over template characters in a more intuitive way (before the
6765 ## next keypress).
6766 ## 8. Change, Keypress and LostFocus methods added for convenience of subclasses.
6767 ## Developer may use these methods which will be called after EVT_TEXT, EVT_CHAR,
6768 ## and EVT_KILL_FOCUS, respectively.
6769 ## 9. Decimal and numeric handlers have been rewritten and now work more intuitively.
6770 ##
6771 ## Version 0.0.4
6772 ## 1. New .IsEmpty() method returns True if the control's value is equal to the
6773 ## blank template string
6774 ## 2. Control now supports a new init parameter: revalid. Pass a regular expression
6775 ## that the value will have to match when the control loses focus. If invalid,
6776 ## the control's BackgroundColor will turn yellow, and an internal flag is set (see next).
6777 ## 3. Demo now shows revalid functionality. Try entering a partial value, such as a
6778 ## partial social security number.
6779 ## 4. New .IsValid() value returns True if the control is empty, or if the value matches
6780 ## the revalid expression. If not, .IsValid() returns False.
6781 ## 5. Decimal values now collapse to decimal with '.00' on losefocus if the user never
6782 ## presses the decimal point.
6783 ## 6. Cursor now goes to the beginning of the field if the user clicks in an
6784 ## "empty" field intead of leaving the insertion point in the middle of the
6785 ## field.
6786 ## 7. New "N" mask type includes upper and lower chars plus digits. a-zA-Z0-9.
6787 ## 8. New formatcodes init parameter replaces other init params and adds functions.
6788 ## String passed to control on init controls:
6789 ## _ Allow spaces
6790 ## ! Force upper
6791 ## ^ Force lower
6792 ## R Show negative #s in red
6793 ## , Group digits
6794 ## - Signed numerals
6795 ## 0 Numeric fields get leading zeros
6796 ## 9. Ctrl-X in any field clears the current value.
6797 ## 10. Code refactored and made more modular (esp in OnChar method). Should be more
6798 ## easy to read and understand.
6799 ## 11. Demo enhanced.
6800 ## 12. Now has _doc_.
6801 ##
6802 ## Version 0.0.3
6803 ## 1. GetPlainValue() now returns the value without the template characters;
6804 ## so, for example, a social security number (123-33-1212) would return as
6805 ## 123331212; also removes white spaces from numeric/decimal values, so
6806 ## "- 955.32" is returned "-955.32". Press ctrl-S to see the plain value.
6807 ## 2. Press '.' in an integer style masked control and truncate any trailing digits.
6808 ## 3. Code moderately refactored. Internal names improved for clarity. Additional
6809 ## internal documentation.
6810 ## 4. Home and End keys now supported to move cursor to beginning or end of field.
6811 ## 5. Un-signed integers and decimals now supported.
6812 ## 6. Cosmetic improvements to the demo.
6813 ## 7. Class renamed to MaskedTextCtrl.
6814 ## 8. Can now specify include characters that will override the basic
6815 ## controls: for example, includeChars = "@." for email addresses
6816 ## 9. Added mask character 'C' -> allow any upper or lowercase character
6817 ## 10. .SetSignColor(str:color) sets the foreground color for negative values
6818 ## in signed controls (defaults to red)
6819 ## 11. Overview documentation written.
6820 ##
6821 ## Version 0.0.2
6822 ## 1. Tab now works properly when pressed in last position
6823 ## 2. Decimal types now work (e.g. #####.##)
6824 ## 3. Signed decimal or numeric values supported (i.e. negative numbers)
6825 ## 4. Negative decimal or numeric values now can show in red.
6826 ## 5. Can now specify an "exclude list" with the excludeChars parameter.
6827 ## See date/time formatted example - you can only enter A or P in the
6828 ## character mask space (i.e. AM/PM).
6829 ## 6. Backspace now works properly, including clearing data from a selected
6830 ## region but leaving template characters intact. Also delete key.
6831 ## 7. Left/right arrows now work properly.
6832 ## 8. Removed EventManager call from test so demo should work with wxPython 2.3.3
6833 ##