[wxWidgets.git] / wxPython / wx / lib / masked / textctrl.py

#----------------------------------------------------------------------------
# Name:         masked.textctrl.py
# Authors:      Jeff Childers, Will Sadkin
# Email:        jchilders_98@yahoo.com, wsadkin@nameconnector.com
# Created:      02/11/2003
# Copyright:    (c) 2003 by Jeff Childers, Will Sadkin, 2003
# Portions:     (c) 2002 by Will Sadkin, 2002-2003
# RCS-ID:       $Id$
# License:      wxWidgets license
#----------------------------------------------------------------------------
#
# This file contains the most typically used generic masked control,
# masked.TextCtrl.  It also defines the BaseMaskedTextCtrl, which can
# be used to derive other "semantics-specific" classes, like masked.NumCtrl,
# masked.TimeCtrl, and masked.IpAddrCtrl.
#
#----------------------------------------------------------------------------
import  wx
from wx.lib.masked import *

# jmg 12/9/03 - when we cut ties with Py 2.2 and earlier, this would
# be a good place to implement the 2.3 logger class
from wx.tools.dbg import Logger
dbg = Logger()
##dbg(enable=1)

# ## TRICKY BIT: to avoid a ton of boiler-plate, and to
# ## automate the getter/setter generation for each valid
# ## control parameter so we never forget to add the
# ## functions when adding parameters, this loop
# ## programmatically adds them to the class:
# ## (This makes it easier for Designers like Boa to
# ## deal with masked controls.)
#
# ## To further complicate matters, this is done with an
# ## extra level of inheritance, so that "general" classes like
# ## MaskedTextCtrl can have all possible attributes,
# ## while derived classes, like TimeCtrl and MaskedNumCtrl
# ## can prevent exposure of those optional attributes of their base
# ## class that do not make sense for their derivation.  Therefore,
# ## we define
# ##    BaseMaskedTextCtrl(TextCtrl, MaskedEditMixin)
# ## and
# ##    MaskedTextCtrl(BaseMaskedTextCtrl, MaskedEditAccessorsMixin).
# ##
# ## This allows us to then derive:
# ##    MaskedNumCtrl( BaseMaskedTextCtrl )
# ##
# ## and not have to expose all the same accessor functions for the
# ## derived control when they don't all make sense for it.
# ##

class BaseMaskedTextCtrl( wx.TextCtrl, MaskedEditMixin ):
    """
    This is the primary derivation from MaskedEditMixin.  It provides
    a general masked text control that can be configured with different
    masks.  It's actually a "base masked textCtrl", so that the
    MaskedTextCtrl class can be derived from it, and add those
    accessor functions to it that are appropriate to the general class,
    whilst other classes can derive from BaseMaskedTextCtrl, and
    only define those accessor functions that are appropriate for
    those derivations.
    """

    def __init__( self, parent, id=-1, value = '',
                  pos = wx.DefaultPosition,
                  size = wx.DefaultSize,
                  style = wx.TE_PROCESS_TAB,
                  validator=wx.DefaultValidator,     ## placeholder provided for data-transfer logic
                  name = 'maskedTextCtrl',
                  setupEventHandling = True,        ## setup event handling by default
                  **kwargs):

        wx.TextCtrl.__init__(self, parent, id, value='',
                            pos=pos, size = size,
                            style=style, validator=validator,
                            name=name)

        self._PostInit(setupEventHandling = setupEventHandling,
                      name=name, value=value,**kwargs )


    def _PostInit(self,setupEventHandling=True,
                 name='maskedTextCtrl' , value='', **kwargs):

        self.controlInitialized = True
        MaskedEditMixin.__init__( self, name, **kwargs )

        self._SetInitialValue(value)

        if setupEventHandling:
            ## Setup event handlers
            self.Bind(wx.EVT_SET_FOCUS, self._OnFocus )         ## defeat automatic full selection
            self.Bind(wx.EVT_KILL_FOCUS, self._OnKillFocus )    ## run internal validator
            self.Bind(wx.EVT_LEFT_DCLICK, self._OnDoubleClick)  ## select field under cursor on dclick
            self.Bind(wx.EVT_RIGHT_UP, self._OnContextMenu )    ## bring up an appropriate context menu
            self.Bind(wx.EVT_KEY_DOWN, self._OnKeyDown )        ## capture control events not normally seen, eg ctrl-tab.
            self.Bind(wx.EVT_CHAR, self._OnChar )               ## handle each keypress
            self.Bind(wx.EVT_TEXT, self._OnTextChange )         ## color control appropriately & keep
                                                                ## track of previous value for undo


    def __repr__(self):
        return "<BaseMaskedTextCtrl: %s>" % self.GetValue()


    def _GetSelection(self):
        """
        Allow mixin to get the text selection of this control.
        REQUIRED by any class derived from MaskedEditMixin.
        """
        return self.GetSelection()

    def _SetSelection(self, sel_start, sel_to):
        """
        Allow mixin to set the text selection of this control.
        REQUIRED by any class derived from MaskedEditMixin.
        """
####        dbg("MaskedTextCtrl::_SetSelection(%(sel_start)d, %(sel_to)d)" % locals())
        return self.SetSelection( sel_start, sel_to )

    def SetSelection(self, sel_start, sel_to):
        """
        This is just for debugging...
        """
##        dbg("MaskedTextCtrl::SetSelection(%(sel_start)d, %(sel_to)d)" % locals())
        wx.TextCtrl.SetSelection(self, sel_start, sel_to)


    def _GetInsertionPoint(self):
        return self.GetInsertionPoint()

    def _SetInsertionPoint(self, pos):
####        dbg("MaskedTextCtrl::_SetInsertionPoint(%(pos)d)" % locals())
        self.SetInsertionPoint(pos)

    def SetInsertionPoint(self, pos):
        """
        This is just for debugging...
        """
##        dbg("MaskedTextCtrl::SetInsertionPoint(%(pos)d)" % locals())
        wx.TextCtrl.SetInsertionPoint(self, pos)


    def _GetValue(self):
        """
        Allow mixin to get the raw value of the control with this function.
        REQUIRED by any class derived from MaskedEditMixin.
        """
        return self.GetValue()

    def _SetValue(self, value):
        """
        Allow mixin to set the raw value of the control with this function.
        REQUIRED by any class derived from MaskedEditMixin.
        """
##        dbg('MaskedTextCtrl::_SetValue("%(value)s")' % locals(), indent=1)
        # Record current selection and insertion point, for undo
        self._prevSelection = self._GetSelection()
        self._prevInsertionPoint = self._GetInsertionPoint()
        wx.TextCtrl.SetValue(self, value)
##        dbg(indent=0)

    def SetValue(self, value):
        """
        This function redefines the externally accessible .SetValue to be
        a smart "paste" of the text in question, so as not to corrupt the
        masked control.  NOTE: this must be done in the class derived
        from the base wx control.
        """
##        dbg('MaskedTextCtrl::SetValue = "%s"' % value, indent=1)

        if not self._mask:
            wx.TextCtrl.SetValue(self, value)    # revert to base control behavior
            return

        # empty previous contents, replacing entire value:
        self._SetInsertionPoint(0)
        self._SetSelection(0, self._masklength)
        if self._signOk and self._useParens:
            signpos = value.find('-')
            if signpos != -1:
                value = value[:signpos] + '(' + value[signpos+1:].strip() + ')'
            elif value.find(')') == -1 and len(value) < self._masklength:
                value += ' '    # add place holder for reserved space for right paren

        if( len(value) < self._masklength                # value shorter than control
            and (self._isFloat or self._isInt)            # and it's a numeric control
            and self._ctrl_constraints._alignRight ):   # and it's a right-aligned control

##            dbg('len(value)', len(value), ' < self._masklength', self._masklength)
            # try to intelligently "pad out" the value to the right size:
            value = self._template[0:self._masklength - len(value)] + value
            if self._isFloat and value.find('.') == -1:
                value = value[1:]
##            dbg('padded value = "%s"' % value)

        # make SetValue behave the same as if you had typed the value in:
        try:
            value, replace_to = self._Paste(value, raise_on_invalid=True, just_return_value=True)
            if self._isFloat:
                self._isNeg = False     # (clear current assumptions)
                value = self._adjustFloat(value)
            elif self._isInt:
                self._isNeg = False     # (clear current assumptions)
                value = self._adjustInt(value)
            elif self._isDate and not self.IsValid(value) and self._4digityear:
                value = self._adjustDate(value, fixcentury=True)
        except ValueError:
            # If date, year might be 2 digits vs. 4; try adjusting it:
            if self._isDate and self._4digityear:
                dateparts = value.split(' ')
                dateparts[0] = self._adjustDate(dateparts[0], fixcentury=True)
                value = string.join(dateparts, ' ')
##                dbg('adjusted value: "%s"' % value)
                value, replace_to = self._Paste(value, raise_on_invalid=True, just_return_value=True)
            else:
##                dbg('exception thrown', indent=0)
                raise

        self._SetValue(value)   # note: to preserve similar capability, .SetValue()
                                # does not change IsModified()
####        dbg('queuing insertion after .SetValue', replace_to)
        # set selection to last char replaced by paste
        wx.CallAfter(self._SetInsertionPoint, replace_to)
        wx.CallAfter(self._SetSelection, replace_to, replace_to)
##        dbg(indent=0)

    def SetFont(self, *args, **kwargs):
        """ Set the font, then recalculate control size, if appropriate. """
        wx.TextCtrl.SetFont(self, *args, **kwargs)
        if self._autofit:
##            dbg('calculated size:', self._CalcSize())            
            self.SetClientSize(self._CalcSize())
            width = self.GetSize().width
            height = self.GetBestSize().height
##            dbg('setting client size to:', (width, height))
            self.SetSize((width, height))
            self.SetSizeHints((width, height))


    def Clear(self):
        """ Blanks the current control value by replacing it with the default value."""
##        dbg("MaskedTextCtrl::Clear - value reset to default value (template)")
        if self._mask:
            self.ClearValue()
        else:
            wx.TextCtrl.Clear(self)    # else revert to base control behavior


    def _Refresh(self):
        """
        Allow mixin to refresh the base control with this function.
        REQUIRED by any class derived from MaskedEditMixin.
        """
##        dbg('MaskedTextCtrl::_Refresh', indent=1)
        wx.TextCtrl.Refresh(self)
##        dbg(indent=0)


    def Refresh(self):
        """
        This function redefines the externally accessible .Refresh() to
        validate the contents of the masked control as it refreshes.
        NOTE: this must be done in the class derived from the base wx control.
        """
##        dbg('MaskedTextCtrl::Refresh', indent=1)
        self._CheckValid()
        self._Refresh()
##        dbg(indent=0)


    def _IsEditable(self):
        """
        Allow mixin to determine if the base control is editable with this function.
        REQUIRED by any class derived from MaskedEditMixin.
        """
        return wx.TextCtrl.IsEditable(self)


    def Cut(self):
        """
        This function redefines the externally accessible .Cut to be
        a smart "erase" of the text in question, so as not to corrupt the
        masked control.  NOTE: this must be done in the class derived
        from the base wx control.
        """
        if self._mask:
            self._Cut()             # call the mixin's Cut method
        else:
            wx.TextCtrl.Cut(self)    # else revert to base control behavior


    def Paste(self):
        """
        This function redefines the externally accessible .Paste to be
        a smart "paste" of the text in question, so as not to corrupt the
        masked control.  NOTE: this must be done in the class derived
        from the base wx control.
        """
        if self._mask:
            self._Paste()                   # call the mixin's Paste method
        else:
            wx.TextCtrl.Paste(self, value)   # else revert to base control behavior


    def Undo(self):
        """
        This function defines the undo operation for the control. (The default
        undo is 1-deep.)
        """
        if self._mask:
            self._Undo()
        else:
            wx.TextCtrl.Undo(self)   # else revert to base control behavior


    def IsModified(self):
        """
        This function overrides the raw wxTextCtrl method, because the
        masked edit mixin uses SetValue to change the value, which doesn't
        modify the state of this attribute.  So, we keep track on each
        keystroke to see if the value changes, and if so, it's been
        modified.
        """
        return wx.TextCtrl.IsModified(self) or self.modified


    def _CalcSize(self, size=None):
        """
        Calculate automatic size if allowed; use base mixin function.
        """
        return self._calcSize(size)


class TextCtrl( BaseMaskedTextCtrl, MaskedEditAccessorsMixin ):
    """
    This extra level of inheritance allows us to add the generic set of
    masked edit parameters only to this class while allowing other
    classes to derive from the "base" masked text control, and provide
    a smaller set of valid accessor functions.
    """
    pass


class PreMaskedTextCtrl( BaseMaskedTextCtrl, MaskedEditAccessorsMixin ):
    """
    This allows us to use XRC subclassing.
    """
    # This should really be wx.EVT_WINDOW_CREATE but it is not
    # currently delivered for native controls on all platforms, so
    # we'll use EVT_SIZE instead.  It should happen shortly after the
    # control is created as the control is set to its "best" size.
    _firstEventType = wx.EVT_SIZE

    def __init__(self):
        pre = wx.PreTextCtrl()
        self.PostCreate(pre)
        self.Bind(self._firstEventType, self.OnCreate)


    def OnCreate(self, evt):
        self.Unbind(self._firstEventType)
        self._PostInit()

i=0
## CHANGELOG:
## ====================
##  Version 1.1
##  1. Added .SetFont() method that properly resizes control
##  2. Modified control to support construction via XRC mechanism.
Commit	Line	Data
c878ceea RD	1	#----------------------------------------------------------------------------
	2	# Name: masked.textctrl.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: wxWidgets license
	10	#----------------------------------------------------------------------------
	11	#
	12	# This file contains the most typically used generic masked control,
	13	# masked.TextCtrl. It also defines the BaseMaskedTextCtrl, which can
	14	# be used to derive other "semantics-specific" classes, like masked.NumCtrl,
	15	# masked.TimeCtrl, and masked.IpAddrCtrl.
	16	#
	17	#----------------------------------------------------------------------------
	18	import wx
	19	from wx.lib.masked import *
	20
	21	# jmg 12/9/03 - when we cut ties with Py 2.2 and earlier, this would
	22	# be a good place to implement the 2.3 logger class
	23	from wx.tools.dbg import Logger
	24	dbg = Logger()
339983ff	25	##dbg(enable=1)
c878ceea RD	26
	27	# ## TRICKY BIT: to avoid a ton of boiler-plate, and to
	28	# ## automate the getter/setter generation for each valid
	29	# ## control parameter so we never forget to add the
	30	# ## functions when adding parameters, this loop
	31	# ## programmatically adds them to the class:
	32	# ## (This makes it easier for Designers like Boa to
	33	# ## deal with masked controls.)
	34	#
	35	# ## To further complicate matters, this is done with an
	36	# ## extra level of inheritance, so that "general" classes like
	37	# ## MaskedTextCtrl can have all possible attributes,
	38	# ## while derived classes, like TimeCtrl and MaskedNumCtrl
	39	# ## can prevent exposure of those optional attributes of their base
	40	# ## class that do not make sense for their derivation. Therefore,
	41	# ## we define
	42	# ## BaseMaskedTextCtrl(TextCtrl, MaskedEditMixin)
	43	# ## and
	44	# ## MaskedTextCtrl(BaseMaskedTextCtrl, MaskedEditAccessorsMixin).
	45	# ##
	46	# ## This allows us to then derive:
	47	# ## MaskedNumCtrl( BaseMaskedTextCtrl )
	48	# ##
	49	# ## and not have to expose all the same accessor functions for the
	50	# ## derived control when they don't all make sense for it.
	51	# ##
	52
	53	class BaseMaskedTextCtrl( wx.TextCtrl, MaskedEditMixin ):
	54	"""
	55	This is the primary derivation from MaskedEditMixin. It provides
	56	a general masked text control that can be configured with different
	57	masks. It's actually a "base masked textCtrl", so that the
	58	MaskedTextCtrl class can be derived from it, and add those
	59	accessor functions to it that are appropriate to the general class,
	60	whilst other classes can derive from BaseMaskedTextCtrl, and
	61	only define those accessor functions that are appropriate for
	62	those derivations.
	63	"""
	64
	65	def __init__( self, parent, id=-1, value = '',
	66	pos = wx.DefaultPosition,
	67	size = wx.DefaultSize,
	68	style = wx.TE_PROCESS_TAB,
	69	validator=wx.DefaultValidator, ## placeholder provided for data-transfer logic
	70	name = 'maskedTextCtrl',
	71	setupEventHandling = True, ## setup event handling by default
	72	**kwargs):
	73
	74	wx.TextCtrl.__init__(self, parent, id, value='',
	75	pos=pos, size = size,
	76	style=style, validator=validator,
	77	name=name)
	78
339983ff RD	79	self._PostInit(setupEventHandling = setupEventHandling,
	80	name=name, value=value,**kwargs )
	81
	82
	83	def _PostInit(self,setupEventHandling=True,
	84	name='maskedTextCtrl' , value='', **kwargs):
	85
c878ceea RD	86	self.controlInitialized = True
	87	MaskedEditMixin.__init__( self, name, **kwargs )
	88
	89	self._SetInitialValue(value)
	90
	91	if setupEventHandling:
	92	## Setup event handlers
	93	self.Bind(wx.EVT_SET_FOCUS, self._OnFocus ) ## defeat automatic full selection
	94	self.Bind(wx.EVT_KILL_FOCUS, self._OnKillFocus ) ## run internal validator
	95	self.Bind(wx.EVT_LEFT_DCLICK, self._OnDoubleClick) ## select field under cursor on dclick
	96	self.Bind(wx.EVT_RIGHT_UP, self._OnContextMenu ) ## bring up an appropriate context menu
	97	self.Bind(wx.EVT_KEY_DOWN, self._OnKeyDown ) ## capture control events not normally seen, eg ctrl-tab.
	98	self.Bind(wx.EVT_CHAR, self._OnChar ) ## handle each keypress
	99	self.Bind(wx.EVT_TEXT, self._OnTextChange ) ## color control appropriately & keep
	100	## track of previous value for undo
	101
	102
	103	def __repr__(self):
	104	return "<BaseMaskedTextCtrl: %s>" % self.GetValue()
	105
	106
	107	def _GetSelection(self):
	108	"""
	109	Allow mixin to get the text selection of this control.
	110	REQUIRED by any class derived from MaskedEditMixin.
	111	"""
	112	return self.GetSelection()
	113
	114	def _SetSelection(self, sel_start, sel_to):
	115	"""
	116	Allow mixin to set the text selection of this control.
	117	REQUIRED by any class derived from MaskedEditMixin.
	118	"""
	119	#### dbg("MaskedTextCtrl::_SetSelection(%(sel_start)d, %(sel_to)d)" % locals())
	120	return self.SetSelection( sel_start, sel_to )
	121
	122	def SetSelection(self, sel_start, sel_to):
	123	"""
	124	This is just for debugging...
	125	"""
	126	## dbg("MaskedTextCtrl::SetSelection(%(sel_start)d, %(sel_to)d)" % locals())
	127	wx.TextCtrl.SetSelection(self, sel_start, sel_to)
	128
	129
	130	def _GetInsertionPoint(self):
	131	return self.GetInsertionPoint()
	132
	133	def _SetInsertionPoint(self, pos):
	134	#### dbg("MaskedTextCtrl::_SetInsertionPoint(%(pos)d)" % locals())
	135	self.SetInsertionPoint(pos)
	136
	137	def SetInsertionPoint(self, pos):
	138	"""
	139	This is just for debugging...
	140	"""
	141	## dbg("MaskedTextCtrl::SetInsertionPoint(%(pos)d)" % locals())
	142	wx.TextCtrl.SetInsertionPoint(self, pos)
	143
	144
	145	def _GetValue(self):
	146	"""
	147	Allow mixin to get the raw value of the control with this function.
	148	REQUIRED by any class derived from MaskedEditMixin.
	149	"""
150	return self.GetValue()
151
152	def _SetValue(self, value):
153	"""
154	Allow mixin to set the raw value of the control with this function.
155	REQUIRED by any class derived from MaskedEditMixin.
156	"""
157	## dbg('MaskedTextCtrl::_SetValue("%(value)s")' % locals(), indent=1)
158	# Record current selection and insertion point, for undo
159	self._prevSelection = self._GetSelection()
160	self._prevInsertionPoint = self._GetInsertionPoint()
161	wx.TextCtrl.SetValue(self, value)
162	## dbg(indent=0)
163
164	def SetValue(self, value):
165	"""
166	This function redefines the externally accessible .SetValue to be
167	a smart "paste" of the text in question, so as not to corrupt the
168	masked control. NOTE: this must be done in the class derived
169	from the base wx control.
170	"""
171	## dbg('MaskedTextCtrl::SetValue = "%s"' % value, indent=1)
172
173	if not self._mask:
174	wx.TextCtrl.SetValue(self, value) # revert to base control behavior
175	return
176
177	# empty previous contents, replacing entire value:
178	self._SetInsertionPoint(0)
179	self._SetSelection(0, self._masklength)
180	if self._signOk and self._useParens:
181	signpos = value.find('-')
182	if signpos != -1:
183	value = value[:signpos] + '(' + value[signpos+1:].strip() + ')'
184	elif value.find(')') == -1 and len(value) < self._masklength:
185	value += ' ' # add place holder for reserved space for right paren
186
187	if( len(value) < self._masklength # value shorter than control
188	and (self._isFloat or self._isInt) # and it's a numeric control
189	and self._ctrl_constraints._alignRight ): # and it's a right-aligned control
190
191	## dbg('len(value)', len(value), ' < self._masklength', self._masklength)
192	# try to intelligently "pad out" the value to the right size:
193	value = self._template[0:self._masklength - len(value)] + value
194	if self._isFloat and value.find('.') == -1:
195	value = value[1:]
196	## dbg('padded value = "%s"' % value)
197
198	# make SetValue behave the same as if you had typed the value in:
199	try:
5f280eaa	200	value, replace_to = self._Paste(value, raise_on_invalid=True, just_return_value=True)
c878ceea RD	201	if self._isFloat:
	202	self._isNeg = False # (clear current assumptions)
	203	value = self._adjustFloat(value)
	204	elif self._isInt:
	205	self._isNeg = False # (clear current assumptions)
	206	value = self._adjustInt(value)
	207	elif self._isDate and not self.IsValid(value) and self._4digityear:
	208	value = self._adjustDate(value, fixcentury=True)
	209	except ValueError:
	210	# If date, year might be 2 digits vs. 4; try adjusting it:
	211	if self._isDate and self._4digityear:
	212	dateparts = value.split(' ')
	213	dateparts[0] = self._adjustDate(dateparts[0], fixcentury=True)
	214	value = string.join(dateparts, ' ')
	215	## dbg('adjusted value: "%s"' % value)
5f280eaa	216	value, replace_to = self._Paste(value, raise_on_invalid=True, just_return_value=True)
c878ceea RD	217	else:
	218	## dbg('exception thrown', indent=0)
	219	raise
	220
	221	self._SetValue(value) # note: to preserve similar capability, .SetValue()
	222	# does not change IsModified()
5f280eaa RD	223	#### dbg('queuing insertion after .SetValue', replace_to)
	224	# set selection to last char replaced by paste
	225	wx.CallAfter(self._SetInsertionPoint, replace_to)
	226	wx.CallAfter(self._SetSelection, replace_to, replace_to)
c878ceea RD	227	## dbg(indent=0)
c878ceea RD	228
339983ff RD	229	def SetFont(self, args, *kwargs):
	230	""" Set the font, then recalculate control size, if appropriate. """
	231	wx.TextCtrl.SetFont(self, args, *kwargs)
	232	if self._autofit:
	233	## dbg('calculated size:', self._CalcSize())
	234	self.SetClientSize(self._CalcSize())
	235	width = self.GetSize().width
	236	height = self.GetBestSize().height
	237	## dbg('setting client size to:', (width, height))
	238	self.SetSize((width, height))
	239	self.SetSizeHints((width, height))
	240
c878ceea RD	241
	242	def Clear(self):
	243	""" Blanks the current control value by replacing it with the default value."""
	244	## dbg("MaskedTextCtrl::Clear - value reset to default value (template)")
	245	if self._mask:
	246	self.ClearValue()
	247	else:
	248	wx.TextCtrl.Clear(self) # else revert to base control behavior
	249
	250
	251	def _Refresh(self):
	252	"""
	253	Allow mixin to refresh the base control with this function.
	254	REQUIRED by any class derived from MaskedEditMixin.
	255	"""
	256	## dbg('MaskedTextCtrl::_Refresh', indent=1)
	257	wx.TextCtrl.Refresh(self)
	258	## dbg(indent=0)
	259
	260
	261	def Refresh(self):
	262	"""
	263	This function redefines the externally accessible .Refresh() to
	264	validate the contents of the masked control as it refreshes.
	265	NOTE: this must be done in the class derived from the base wx control.
	266	"""
	267	## dbg('MaskedTextCtrl::Refresh', indent=1)
	268	self._CheckValid()
	269	self._Refresh()
	270	## dbg(indent=0)
	271
	272
	273	def _IsEditable(self):
	274	"""
	275	Allow mixin to determine if the base control is editable with this function.
	276	REQUIRED by any class derived from MaskedEditMixin.
	277	"""
	278	return wx.TextCtrl.IsEditable(self)
	279
	280
	281	def Cut(self):
	282	"""
	283	This function redefines the externally accessible .Cut to be
	284	a smart "erase" of the text in question, so as not to corrupt the
	285	masked control. NOTE: this must be done in the class derived
	286	from the base wx control.
	287	"""
	288	if self._mask:
	289	self._Cut() # call the mixin's Cut method
	290	else:
	291	wx.TextCtrl.Cut(self) # else revert to base control behavior
	292
	293
	294	def Paste(self):
	295	"""
	296	This function redefines the externally accessible .Paste to be
	297	a smart "paste" of the text in question, so as not to corrupt the
	298	masked control. NOTE: this must be done in the class derived
	299	from the base wx control.
	300	"""
	301	if self._mask:
	302	self._Paste() # call the mixin's Paste method
	303	else:
	304	wx.TextCtrl.Paste(self, value) # else revert to base control behavior
305
306
307	def Undo(self):
308	"""
309	This function defines the undo operation for the control. (The default
310	undo is 1-deep.)
311	"""
312	if self._mask:
313	self._Undo()
314	else:
315	wx.TextCtrl.Undo(self) # else revert to base control behavior
316
317
318	def IsModified(self):
319	"""
320	This function overrides the raw wxTextCtrl method, because the
321	masked edit mixin uses SetValue to change the value, which doesn't
322	modify the state of this attribute. So, we keep track on each
323	keystroke to see if the value changes, and if so, it's been
324	modified.
325	"""
326	return wx.TextCtrl.IsModified(self) or self.modified
327
328
329	def _CalcSize(self, size=None):
330	"""
331	Calculate automatic size if allowed; use base mixin function.
332	"""
333	return self._calcSize(size)
334
335
336	class TextCtrl( BaseMaskedTextCtrl, MaskedEditAccessorsMixin ):
337	"""
338	This extra level of inheritance allows us to add the generic set of
339	masked edit parameters only to this class while allowing other
340	classes to derive from the "base" masked text control, and provide
341	a smaller set of valid accessor functions.
342	"""
343	pass
344
345
339983ff RD	346	class PreMaskedTextCtrl( BaseMaskedTextCtrl, MaskedEditAccessorsMixin ):
	347	"""
	348	This allows us to use XRC subclassing.
	349	"""
	350	# This should really be wx.EVT_WINDOW_CREATE but it is not
	351	# currently delivered for native controls on all platforms, so
	352	# we'll use EVT_SIZE instead. It should happen shortly after the
	353	# control is created as the control is set to its "best" size.
	354	_firstEventType = wx.EVT_SIZE
	355
	356	def __init__(self):
	357	pre = wx.PreTextCtrl()
	358	self.PostCreate(pre)
	359	self.Bind(self._firstEventType, self.OnCreate)
	360
	361
	362	def OnCreate(self, evt):
	363	self.Unbind(self._firstEventType)
	364	self._PostInit()
	365
	366	i=0
	367	## CHANGELOG:
	368	## ====================
	369	## Version 1.1
	370	## 1. Added .SetFont() method that properly resizes control
	371	## 2. Modified control to support construction via XRC mechanism.