cheng/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
152d7d3516
wxWidgets/wxPython/wx/lib/masked/timectrl.py
Robin Dunn f54a36bba8 MaskedEdit updates from Will Sadkin: 
- Added '*' mask char that means "all ansii chars" (ords 32-255)
    - Added proper unicode support to masked controls and wx.tools.dbg
    - Fixed two reported missing import bugs introduced by package
      creation
    - Converted masked package doc strings to reST format for better
      epydoc support
    - lots of doc string improvements and function hiding to better
      reflect package's public contents.


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@29787 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
2004-10-11 22:13:18 +00:00

1376 lines
54 KiB
Python
Raw Blame History

#----------------------------------------------------------------------------
# Name: timectrl.py
# Author: Will Sadkin
# Created: 09/19/2002
# Copyright: (c) 2002 by Will Sadkin, 2002
# RCS-ID: $Id$
# License: wxWindows license
#----------------------------------------------------------------------------
# NOTE:
# This was written way it is because of the lack of masked edit controls
# in wxWindows/wxPython. I would also have preferred to derive this
# control from a wxSpinCtrl rather than wxTextCtrl, but the wxTextCtrl
# component of that control is inaccessible through the interface exposed in
# wxPython.
#
# TimeCtrl does not use validators, because it does careful manipulation
# of the cursor in the text window on each keystroke, and validation is
# cursor-position specific, so the control intercepts the key codes before the
# validator would fire.
#
# TimeCtrl now also supports .SetValue() with either strings or wxDateTime
# values, as well as range limits, with the option of either enforcing them
# or simply coloring the text of the control if the limits are exceeded.
#
# Note: this class now makes heavy use of wxDateTime for parsing and
# regularization, but it always does so with ephemeral instances of
# wxDateTime, as the C++/Python validity of these instances seems to not
# persist. Because "today" can be a day for which an hour can "not exist"
# or be counted twice (1 day each per year, for DST adjustments), the date
# portion of all wxDateTimes used/returned have their date portion set to
# Jan 1, 1970 (the "epoch.")
#----------------------------------------------------------------------------
# 12/13/2003 - Jeff Grimmett (grimmtooth@softhome.net)
#
# o Updated for V2.5 compatability
# o wx.SpinCtl has some issues that cause the control to
# lock up. Noted in other places using it too, it's not this module
# that's at fault.
#
# 12/20/2003 - Jeff Grimmett (grimmtooth@softhome.net)
#
# o wxMaskedTextCtrl -> masked.TextCtrl
# o wxTimeCtrl -> masked.TimeCtrl
#
"""
*TimeCtrl* provides a multi-cell control that allows manipulation of a time
value. It supports 12 or 24 hour format, and you can use wxDateTime or mxDateTime
to get/set values from the control.
Left/right/tab keys to switch cells within a TimeCtrl, and the up/down arrows act
like a spin control. TimeCtrl also allows for an actual spin button to be attached
to the control, so that it acts like the up/down arrow keys.
The ! or c key sets the value of the control to the current time.
Here's the API for TimeCtrl::
from wx.lib.masked import TimeCtrl
TimeCtrl(
parent, id = -1,
value = '00:00:00',
pos = wx.DefaultPosition,
size = wx.DefaultSize,
style = wxTE_PROCESS_TAB,
validator = wx.DefaultValidator,
name = "time",
format = 'HHMMSS',
fmt24hr = False,
displaySeconds = True,
spinButton = None,
min = None,
max = None,
limited = None,
oob_color = "Yellow"
)
value
If no initial value is set, the default will be midnight; if an illegal string
is specified, a ValueError will result. (You can always later set the initial time
with SetValue() after instantiation of the control.)
size
The size of the control will be automatically adjusted for 12/24 hour format
if wx.DefaultSize is specified. NOTE: due to a problem with wx.DateTime, if the
locale does not use 'AM/PM' for its values, the default format will automatically
change to 24 hour format, and an AttributeError will be thrown if a non-24 format
is specified.
style
By default, TimeCtrl will process TAB events, by allowing tab to the
different cells within the control.
validator
By default, TimeCtrl just uses the default (empty) validator, as all
of its validation for entry control is handled internally. However, a validator
can be supplied to provide data transfer capability to the control.
format
This parameter can be used instead of the fmt24hr and displaySeconds
parameters, respectively; it provides a shorthand way to specify the time
format you want. Accepted values are 'HHMMSS', 'HHMM', '24HHMMSS', and
'24HHMM'. If the format is specified, the other two arguments will be ignored.
fmt24hr
If True, control will display time in 24 hour time format; if False, it will
use 12 hour AM/PM format. SetValue() will adjust values accordingly for the
control, based on the format specified. (This value is ignored if the *format*
parameter is specified.)
displaySeconds
If True, control will include a seconds field; if False, it will
just show hours and minutes. (This value is ignored if the *format*
parameter is specified.)
spinButton
If specified, this button's events will be bound to the behavior of the
TimeCtrl, working like up/down cursor key events. (See BindSpinButton.)
min
Defines the lower bound for "valid" selections in the control.
By default, TimeCtrl doesn't have bounds. You must set both upper and lower
bounds to make the control pay attention to them, (as only one bound makes no sense
with times.) "Valid" times will fall between the min and max "pie wedge" of the
clock.
max
Defines the upper bound for "valid" selections in the control.
"Valid" times will fall between the min and max "pie wedge" of the
clock. (This can be a "big piece", ie. min = 11pm, max= 10pm
means *all but the hour from 10:00pm to 11pm are valid times.*)
limited
If True, the control will not permit entry of values that fall outside the
set bounds.
oob_color
Sets the background color used to indicate out-of-bounds values for the control
when the control is not limited. This is set to "Yellow" by default.
--------------------
EVT_TIMEUPDATE(win, id, func)
func is fired whenever the value of the control changes.
SetValue(time_string | wxDateTime | wxTimeSpan | mx.DateTime | mx.DateTimeDelta)
Sets the value of the control to a particular time, given a valid
value; raises ValueError on invalid value.
*NOTE:* This will only allow mx.DateTime or mx.DateTimeDelta if mx.DateTime
was successfully imported by the class module.
GetValue(as_wxDateTime = False, as_mxDateTime = False, as_wxTimeSpan=False, as mxDateTimeDelta=False)
Retrieves the value of the time from the control. By default this is
returned as a string, unless one of the other arguments is set; args are
searched in the order listed; only one value will be returned.
GetWxDateTime(value=None)
When called without arguments, retrieves the value of the control, and applies
it to the wxDateTimeFromHMS() constructor, and returns the resulting value.
The date portion will always be set to Jan 1, 1970. This form is the same
as GetValue(as_wxDateTime=True). GetWxDateTime can also be called with any of the
other valid time formats settable with SetValue, to regularize it to a single
wxDateTime form. The function will raise ValueError on an unconvertable argument.
GetMxDateTime()
Retrieves the value of the control and applies it to the DateTime.Time()
constructor,and returns the resulting value. (The date portion will always be
set to Jan 1, 1970.) (Same as GetValue(as_wxDateTime=True); provided for backward
compatibility with previous release.)
BindSpinButton(SpinBtton)
Binds an externally created spin button to the control, so that up/down spin
events change the active cell or selection in the control (in addition to the
up/down cursor keys.) (This is primarily to allow you to create a "standard"
interface to time controls, as seen in Windows.)
SetMin(min=None)
Sets the expected minimum value, or lower bound, of the control.
(The lower bound will only be enforced if the control is
configured to limit its values to the set bounds.)
If a value of *None* is provided, then the control will have
explicit lower bound. If the value specified is greater than
the current lower bound, then the function returns False and the
lower bound will not change from its current setting. On success,
the function returns True. Even if set, if there is no corresponding
upper bound, the control will behave as if it is unbounded.
If successful and the current value is outside the
new bounds, if the control is limited the value will be
automatically adjusted to the nearest bound; if not limited,
the background of the control will be colored with the current
out-of-bounds color.
GetMin(as_string=False)
Gets the current lower bound value for the control, returning
None, if not set, or a wxDateTime, unless the as_string parameter
is set to True, at which point it will return the string
representation of the lower bound.
SetMax(max=None)
Sets the expected maximum value, or upper bound, of the control.
(The upper bound will only be enforced if the control is
configured to limit its values to the set bounds.)
If a value of *None* is provided, then the control will
have no explicit upper bound. If the value specified is less
than the current lower bound, then the function returns False and
the maximum will not change from its current setting. On success,
the function returns True. Even if set, if there is no corresponding
lower bound, the control will behave as if it is unbounded.
If successful and the current value is outside the
new bounds, if the control is limited the value will be
automatically adjusted to the nearest bound; if not limited,
the background of the control will be colored with the current
out-of-bounds color.
GetMax(as_string = False)
Gets the current upper bound value for the control, returning
None, if not set, or a wxDateTime, unless the as_string parameter
is set to True, at which point it will return the string
representation of the lower bound.
SetBounds(min=None,max=None)
This function is a convenience function for setting the min and max
values at the same time. The function only applies the maximum bound
if setting the minimum bound is successful, and returns True
only if both operations succeed. *Note: leaving out an argument
will remove the corresponding bound, and result in the behavior of
an unbounded control.*
GetBounds(as_string = False)
This function returns a two-tuple (min,max), indicating the
current bounds of the control. Each value can be None if
that bound is not set. The values will otherwise be wxDateTimes
unless the as_string argument is set to True, at which point they
will be returned as string representations of the bounds.
IsInBounds(value=None)
Returns *True* if no value is specified and the current value
of the control falls within the current bounds. This function can also
be called with a value to see if that value would fall within the current
bounds of the given control. It will raise ValueError if the value
specified is not a wxDateTime, mxDateTime (if available) or parsable string.
IsValid(value)
Returns *True* if specified value is a legal time value and
falls within the current bounds of the given control.
SetLimited(bool)
If called with a value of True, this function will cause the control
to limit the value to fall within the bounds currently specified.
(Provided both bounds have been set.)
If the control's value currently exceeds the bounds, it will then
be set to the nearest bound.
If called with a value of False, this function will disable value
limiting, but coloring of out-of-bounds values will still take
place if bounds have been set for the control.
IsLimited()
Returns *True* if the control is currently limiting the
value to fall within the current bounds.
"""
import copy
import string
import types
import wx
from wx.tools.dbg import Logger
from wx.lib.masked import Field, BaseMaskedTextCtrl
dbg = Logger()
##dbg(enable=0)
try:
from mx import DateTime
accept_mx = True
except ImportError:
accept_mx = False
# This class of event fires whenever the value of the time changes in the control:
wxEVT_TIMEVAL_UPDATED = wx.NewEventType()
EVT_TIMEUPDATE = wx.PyEventBinder(wxEVT_TIMEVAL_UPDATED, 1)
class TimeUpdatedEvent(wx.PyCommandEvent):
"""
Used to fire an EVT_TIMEUPDATE event whenever the value in a TimeCtrl changes.
"""
def __init__(self, id, value ='12:00:00 AM'):
wx.PyCommandEvent.__init__(self, wxEVT_TIMEVAL_UPDATED, id)
self.value = value
def GetValue(self):
"""Retrieve the value of the time control at the time this event was generated"""
return self.value
class TimeCtrlAccessorsMixin:
"""
Defines TimeCtrl's list of attributes having their own Get/Set functions,
ignoring those in the base class that make no sense for a time control.
"""
exposed_basectrl_params = (
'defaultValue',
'description',
'useFixedWidthFont',
'emptyBackgroundColour',
'validBackgroundColour',
'invalidBackgroundColour',
'validFunc',
'validRequired',
)
for param in exposed_basectrl_params:
propname = param[0].upper() + param[1:]
exec('def Set%s(self, value): self.SetCtrlParameters(%s=value)' % (propname, param))
exec('def Get%s(self): return self.GetCtrlParameter("%s")''' % (propname, param))
if param.find('Colour') != -1:
# add non-british spellings, for backward-compatibility
propname.replace('Colour', 'Color')
exec('def Set%s(self, value): self.SetCtrlParameters(%s=value)' % (propname, param))
exec('def Get%s(self): return self.GetCtrlParameter("%s")''' % (propname, param))
class TimeCtrl(BaseMaskedTextCtrl):
"""
Masked control providing several time formats and manipulation of time values.
"""
valid_ctrl_params = {
'format' : 'HHMMSS', # default format code
'displaySeconds' : True, # by default, shows seconds
'min': None, # by default, no bounds set
'max': None,
'limited': False, # by default, no limiting even if bounds set
'useFixedWidthFont': True, # by default, use a fixed-width font
'oob_color': "Yellow" # by default, the default masked.TextCtrl "invalid" color
}
def __init__ (
self, parent, id=-1, value = '00:00:00',
pos = wx.DefaultPosition, size = wx.DefaultSize,
fmt24hr=False,
spinButton = None,
style = wx.TE_PROCESS_TAB,
validator = wx.DefaultValidator,
name = "time",
**kwargs ):
# set defaults for control:
## dbg('setting defaults:')
self.__fmt24hr = False
wxdt = wx.DateTimeFromDMY(1, 0, 1970)
if wxdt.Format('%p') != 'AM':
TimeCtrl.valid_ctrl_params['format'] = '24HHMMSS'
self.__fmt24hr = True
fmt24hr = True # force/change default positional argument
# (will countermand explicit set to False too.)
for key, param_value in TimeCtrl.valid_ctrl_params.items():
# This is done this way to make setattr behave consistently with
# "private attribute" name mangling
setattr(self, "_TimeCtrl__" + key, copy.copy(param_value))
# create locals from current defaults, so we can override if
# specified in kwargs, and handle uniformly:
min = self.__min
max = self.__max
limited = self.__limited
self.__posCurrent = 0
# handle deprecated keword argument name:
if kwargs.has_key('display_seconds'):
kwargs['displaySeconds'] = kwargs['display_seconds']
del kwargs['display_seconds']
if not kwargs.has_key('displaySeconds'):
kwargs['displaySeconds'] = True
# (handle positional arg (from original release) differently from rest of kwargs:)
if not kwargs.has_key('format'):
if fmt24hr:
if kwargs.has_key('displaySeconds') and kwargs['displaySeconds']:
kwargs['format'] = '24HHMMSS'
del kwargs['displaySeconds']
else:
kwargs['format'] = '24HHMM'
else:
if kwargs.has_key('displaySeconds') and kwargs['displaySeconds']:
kwargs['format'] = 'HHMMSS'
del kwargs['displaySeconds']
else:
kwargs['format'] = 'HHMM'
if not kwargs.has_key('useFixedWidthFont'):
# allow control over font selection:
kwargs['useFixedWidthFont'] = self.__useFixedWidthFont
maskededit_kwargs = self.SetParameters(**kwargs)
# allow for explicit size specification:
if size != wx.DefaultSize:
# override (and remove) "autofit" autoformat code in standard time formats:
maskededit_kwargs['formatcodes'] = 'T!'
# This allows range validation if set
maskededit_kwargs['validFunc'] = self.IsInBounds
# This allows range limits to affect insertion into control or not
# dynamically without affecting individual field constraint validation
maskededit_kwargs['retainFieldValidation'] = True
# Now we can initialize the base control:
BaseMaskedTextCtrl.__init__(
self, parent, id=id,
pos=pos, size=size,
style = style,
validator = validator,
name = name,
setupEventHandling = False,
**maskededit_kwargs)
# This makes ':' act like tab (after we fix each ':' key event to remove "shift")
self._SetKeyHandler(':', self._OnChangeField)
# This makes the up/down keys act like spin button controls:
self._SetKeycodeHandler(wx.WXK_UP, self.__OnSpinUp)
self._SetKeycodeHandler(wx.WXK_DOWN, self.__OnSpinDown)
# This allows ! and c/C to set the control to the current time:
self._SetKeyHandler('!', self.__OnSetToNow)
self._SetKeyHandler('c', self.__OnSetToNow)
self._SetKeyHandler('C', self.__OnSetToNow)
# Set up event handling ourselves, so we can insert special
# processing on the ":' key to remove the "shift" attribute
# *before* the default handlers have been installed, so
# that : takes you forward, not back, and so we can issue
# EVT_TIMEUPDATE events on changes:
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_UP, self.__LimitSelection) ## limit selections to single field
self.Bind(wx.EVT_LEFT_DCLICK, self._OnDoubleClick ) ## select field under cursor on dclick
self.Bind(wx.EVT_KEY_DOWN, self._OnKeyDown ) ## capture control events not normally seen, eg ctrl-tab.
self.Bind(wx.EVT_CHAR, self.__OnChar ) ## remove "shift" attribute from colon key event,
## then call BaseMaskedTextCtrl._OnChar with
## the possibly modified event.
self.Bind(wx.EVT_TEXT, self.__OnTextChange, self ) ## color control appropriately and EVT_TIMEUPDATE events
# Validate initial value and set if appropriate
try:
self.SetBounds(min, max)
self.SetLimited(limited)
self.SetValue(value)
except:
self.SetValue('00:00:00')
if spinButton:
self.BindSpinButton(spinButton) # bind spin button up/down events to this control
def SetParameters(self, **kwargs):
"""
Function providing access to the parameters governing TimeCtrl display and bounds.
"""
## dbg('TimeCtrl::SetParameters(%s)' % repr(kwargs), indent=1)
maskededit_kwargs = {}
reset_format = False
if kwargs.has_key('display_seconds'):
kwargs['displaySeconds'] = kwargs['display_seconds']
del kwargs['display_seconds']
if kwargs.has_key('format') and kwargs.has_key('displaySeconds'):
del kwargs['displaySeconds'] # always apply format if specified
# assign keyword args as appropriate:
for key, param_value in kwargs.items():
if key not in TimeCtrl.valid_ctrl_params.keys():
raise AttributeError('invalid keyword argument "%s"' % key)
if key == 'format':
wxdt = wx.DateTimeFromDMY(1, 0, 1970)
if wxdt.Format('%p') != 'AM':
require24hr = True
else:
require24hr = False
# handle both local or generic 'maskededit' autoformat codes:
if param_value == 'HHMMSS' or param_value == 'TIMEHHMMSS':
self.__displaySeconds = True
self.__fmt24hr = False
elif param_value == 'HHMM' or param_value == 'TIMEHHMM':
self.__displaySeconds = False
self.__fmt24hr = False
elif param_value == '24HHMMSS' or param_value == '24HRTIMEHHMMSS':
self.__displaySeconds = True
self.__fmt24hr = True
elif param_value == '24HHMM' or param_value == '24HRTIMEHHMM':
self.__displaySeconds = False
self.__fmt24hr = True
else:
raise AttributeError('"%s" is not a valid format' % param_value)
if require24hr and not self.__fmt24hr:
raise AttributeError('"%s" is an unsupported time format for the current locale' % param_value)
reset_format = True
elif key in ("displaySeconds", "display_seconds") and not kwargs.has_key('format'):
self.__displaySeconds = param_value
reset_format = True
elif key == "min": min = param_value
elif key == "max": max = param_value
elif key == "limited": limited = param_value
elif key == "useFixedWidthFont":
maskededit_kwargs[key] = param_value
elif key == "oob_color":
maskededit_kwargs['invalidBackgroundColor'] = param_value
if reset_format:
if self.__fmt24hr:
if self.__displaySeconds: maskededit_kwargs['autoformat'] = '24HRTIMEHHMMSS'
else: maskededit_kwargs['autoformat'] = '24HRTIMEHHMM'
# Set hour field to zero-pad, right-insert, require explicit field change,
# select entire field on entry, and require a resultant valid entry
# to allow character entry:
hourfield = Field(formatcodes='0r<SV', validRegex='0\d|1\d|2[0123]', validRequired=True)
else:
if self.__displaySeconds: maskededit_kwargs['autoformat'] = 'TIMEHHMMSS'
else: maskededit_kwargs['autoformat'] = 'TIMEHHMM'
# Set hour field to allow spaces (at start), right-insert,
# require explicit field change, select entire field on entry,
# and require a resultant valid entry to allow character entry:
hourfield = Field(formatcodes='_0<rSV', validRegex='0[1-9]| [1-9]|1[012]', validRequired=True)
ampmfield = Field(formatcodes='S', emptyInvalid = True, validRequired = True)
# Field 1 is always a zero-padded right-insert minute field,
# similarly configured as above:
minutefield = Field(formatcodes='0r<SV', validRegex='[0-5]\d', validRequired=True)
fields = [ hourfield, minutefield ]
if self.__displaySeconds:
fields.append(copy.copy(minutefield)) # second field has same constraints as field 1
if not self.__fmt24hr:
fields.append(ampmfield)
# set fields argument:
maskededit_kwargs['fields'] = fields
# This allows range validation if set
maskededit_kwargs['validFunc'] = self.IsInBounds
# This allows range limits to affect insertion into control or not
# dynamically without affecting individual field constraint validation
maskededit_kwargs['retainFieldValidation'] = True
if hasattr(self, 'controlInitialized') and self.controlInitialized:
self.SetCtrlParameters(**maskededit_kwargs) # set appropriate parameters
# Validate initial value and set if appropriate
try:
self.SetBounds(min, max)
self.SetLimited(limited)
self.SetValue(value)
except:
self.SetValue('00:00:00')
## dbg(indent=0)
return {} # no arguments to return
else:
## dbg(indent=0)
return maskededit_kwargs
def BindSpinButton(self, sb):
"""
This function binds an externally created spin button to the control, so that
up/down events from the button automatically change the control.
"""
## dbg('TimeCtrl::BindSpinButton')
self.__spinButton = sb
if self.__spinButton:
# bind event handlers to spin ctrl
self.__spinButton.Bind(wx.EVT_SPIN_UP, self.__OnSpinUp, self.__spinButton)
self.__spinButton.Bind(wx.EVT_SPIN_DOWN, self.__OnSpinDown, self.__spinButton)
def __repr__(self):
return "<TimeCtrl: %s>" % self.GetValue()
def SetValue(self, value):
"""
Validating SetValue function for time values:
This function will do dynamic type checking on the value argument,
and convert wxDateTime, mxDateTime, or 12/24 format time string
into the appropriate format string for the control.
"""
## dbg('TimeCtrl::SetValue(%s)' % repr(value), indent=1)
try:
strtime = self._toGUI(self.__validateValue(value))
except:
## dbg('validation failed', indent=0)
raise
## dbg('strtime:', strtime)
self._SetValue(strtime)
## dbg(indent=0)
def GetValue(self,
as_wxDateTime = False,
as_mxDateTime = False,
as_wxTimeSpan = False,
as_mxDateTimeDelta = False):
"""
This function returns the value of the display as a string by default, but
supports return as a wx.DateTime, mx.DateTime, wx.TimeSpan, or mx.DateTimeDelta,
if requested. (Evaluated in the order above-- first one wins!)
"""
if as_wxDateTime or as_mxDateTime or as_wxTimeSpan or as_mxDateTimeDelta:
value = self.GetWxDateTime()
if as_wxDateTime:
pass
elif as_mxDateTime:
value = DateTime.DateTime(1970, 1, 1, value.GetHour(), value.GetMinute(), value.GetSecond())
elif as_wxTimeSpan:
value = wx.TimeSpan(value.GetHour(), value.GetMinute(), value.GetSecond())
elif as_mxDateTimeDelta:
value = DateTime.DateTimeDelta(0, value.GetHour(), value.GetMinute(), value.GetSecond())
else:
value = BaseMaskedTextCtrl.GetValue(self)
return value
def SetWxDateTime(self, wxdt):
"""
Because SetValue can take a wx.DateTime, this is now just an alias.
"""
self.SetValue(wxdt)
def GetWxDateTime(self, value=None):
"""
This function is the conversion engine for TimeCtrl; it takes
one of the following types:
time string
wxDateTime
wxTimeSpan
mxDateTime
mxDateTimeDelta
and converts it to a wx.DateTime that always has Jan 1, 1970 as its date
portion, so that range comparisons around values can work using
wx.DateTime's built-in comparison function. If a value is not
provided to convert, the string value of the control will be used.
If the value is not one of the accepted types, a ValueError will be
raised.
"""
global accept_mx
## dbg(suspend=1)
## dbg('TimeCtrl::GetWxDateTime(%s)' % repr(value), indent=1)
if value is None:
## dbg('getting control value')
value = self.GetValue()
## dbg('value = "%s"' % value)
if type(value) == types.UnicodeType:
value = str(value) # convert to regular string
valid = True # assume true
if type(value) == types.StringType:
# Construct constant wxDateTime, then try to parse the string:
wxdt = wx.DateTimeFromDMY(1, 0, 1970)
## dbg('attempting conversion')
value = value.strip() # (parser doesn't like leading spaces)
checkTime = wxdt.ParseTime(value)
valid = checkTime == len(value) # entire string parsed?
## dbg('checkTime == len(value)?', valid)
if not valid:
# deal with bug/deficiency in wx.DateTime:
if wxdt.Format('%p') not in ('AM', 'PM') and checkTime in (5,8):
# couldn't parse the AM/PM field
raise ValueError('cannot convert string "%s" to valid time for the current locale; please use 24hr time instead' % value)
else:
## dbg(indent=0, suspend=0)
raise ValueError('cannot convert string "%s" to valid time' % value)
else:
if isinstance(value, wx.DateTime):
hour, minute, second = value.GetHour(), value.GetMinute(), value.GetSecond()
elif isinstance(value, wx.TimeSpan):
totalseconds = value.GetSeconds()
hour = totalseconds / 3600
minute = totalseconds / 60 - (hour * 60)
second = totalseconds - ((hour * 3600) + (minute * 60))
elif accept_mx and isinstance(value, DateTime.DateTimeType):
hour, minute, second = value.hour, value.minute, value.second
elif accept_mx and isinstance(value, DateTime.DateTimeDeltaType):
hour, minute, second = value.hour, value.minute, value.second
else:
# Not a valid function argument
if accept_mx:
error = 'GetWxDateTime requires wxDateTime, mxDateTime or parsable time string, passed %s'% repr(value)
else:
error = 'GetWxDateTime requires wxDateTime or parsable time string, passed %s'% repr(value)
## dbg(indent=0, suspend=0)
raise ValueError(error)
wxdt = wx.DateTimeFromDMY(1, 0, 1970)
wxdt.SetHour(hour)
wxdt.SetMinute(minute)
wxdt.SetSecond(second)
## dbg('wxdt:', wxdt, indent=0, suspend=0)
return wxdt
def SetMxDateTime(self, mxdt):
"""
Because SetValue can take an mx.DateTime, (if DateTime is importable),
this is now just an alias.
"""
self.SetValue(value)
def GetMxDateTime(self, value=None):
"""
Returns the value of the control as an mx.DateTime, with the date
portion set to January 1, 1970.
"""
if value is None:
t = self.GetValue(as_mxDateTime=True)
else:
# Convert string 1st to wxDateTime, then use components, since
# mx' DateTime.Parser.TimeFromString() doesn't handle AM/PM:
wxdt = self.GetWxDateTime(value)
hour, minute, second = wxdt.GetHour(), wxdt.GetMinute(), wxdt.GetSecond()
t = DateTime.DateTime(1970,1,1) + DateTimeDelta(0, hour, minute, second)
return t
def SetMin(self, min=None):
"""
Sets the minimum value of the control. If a value of None
is provided, then the control will have no explicit minimum value.
If the value specified is greater than the current maximum value,
then the function returns 0 and the minimum will not change from
its current setting. On success, the function returns 1.
If successful and the current value is lower than the new lower
bound, if the control is limited, the value will be automatically
adjusted to the new minimum value; if not limited, the value in the
control will be colored as invalid.
"""
## dbg('TimeCtrl::SetMin(%s)'% repr(min), indent=1)
if min is not None:
try:
min = self.GetWxDateTime(min)
self.__min = self._toGUI(min)
except:
## dbg('exception occurred', indent=0)
return False
else:
self.__min = min
if self.IsLimited() and not self.IsInBounds():
self.SetLimited(self.__limited) # force limited value:
else:
self._CheckValid()
ret = True
## dbg('ret:', ret, indent=0)
return ret
def GetMin(self, as_string = False):
"""
Gets the minimum value of the control.
If None, it will return None. Otherwise it will return
the current minimum bound on the control, as a wxDateTime
by default, or as a string if as_string argument is True.
"""
## dbg(suspend=1)
## dbg('TimeCtrl::GetMin, as_string?', as_string, indent=1)
if self.__min is None:
## dbg('(min == None)')
ret = self.__min
elif as_string:
ret = self.__min
## dbg('ret:', ret)
else:
try:
ret = self.GetWxDateTime(self.__min)
except:
## dbg(suspend=0)
## dbg('exception occurred', indent=0)
raise
## dbg('ret:', repr(ret))
## dbg(indent=0, suspend=0)
return ret
def SetMax(self, max=None):
"""
Sets the maximum value of the control. If a value of None
is provided, then the control will have no explicit maximum value.
If the value specified is less than the current minimum value, then
the function returns False and the maximum will not change from its
current setting. On success, the function returns True.
If successful and the current value is greater than the new upper
bound, if the control is limited the value will be automatically
adjusted to this maximum value; if not limited, the value in the
control will be colored as invalid.
"""
## dbg('TimeCtrl::SetMax(%s)' % repr(max), indent=1)
if max is not None:
try:
max = self.GetWxDateTime(max)
self.__max = self._toGUI(max)
except:
## dbg('exception occurred', indent=0)
return False
else:
self.__max = max
## dbg('max:', repr(self.__max))
if self.IsLimited() and not self.IsInBounds():
self.SetLimited(self.__limited) # force limited value:
else:
self._CheckValid()
ret = True
## dbg('ret:', ret, indent=0)
return ret
def GetMax(self, as_string = False):
"""
Gets the minimum value of the control.
If None, it will return None. Otherwise it will return
the current minimum bound on the control, as a wxDateTime
by default, or as a string if as_string argument is True.
"""
## dbg(suspend=1)
## dbg('TimeCtrl::GetMin, as_string?', as_string, indent=1)
if self.__max is None:
## dbg('(max == None)')
ret = self.__max
elif as_string:
ret = self.__max
## dbg('ret:', ret)
else:
try:
ret = self.GetWxDateTime(self.__max)
except:
## dbg(suspend=0)
## dbg('exception occurred', indent=0)
raise
## dbg('ret:', repr(ret))
## dbg(indent=0, suspend=0)
return ret
def SetBounds(self, min=None, max=None):
"""
This function is a convenience function for setting the min and max
values at the same time. The function only applies the maximum bound
if setting the minimum bound is successful, and returns True
only if both operations succeed.
**NOTE:** leaving out an argument will remove the corresponding bound.
"""
ret = self.SetMin(min)
return ret and self.SetMax(max)
def GetBounds(self, as_string = False):
"""
This function returns a two-tuple (min,max), indicating the
current bounds of the control. Each value can be None if
that bound is not set.
"""
return (self.GetMin(as_string), self.GetMax(as_string))
def SetLimited(self, limited):
"""
If called with a value of True, this function will cause the control
to limit the value to fall within the bounds currently specified.
If the control's value currently exceeds the bounds, it will then
be limited accordingly.
If called with a value of 0, this function will disable value
limiting, but coloring of out-of-bounds values will still take
place if bounds have been set for the control.
"""
## dbg('TimeCtrl::SetLimited(%d)' % limited, indent=1)
self.__limited = limited
if not limited:
self.SetMaskParameters(validRequired = False)
self._CheckValid()
## dbg(indent=0)
return
## dbg('requiring valid value')
self.SetMaskParameters(validRequired = True)
min = self.GetMin()
max = self.GetMax()
if min is None or max is None:
## dbg('both bounds not set; no further action taken')
return # can't limit without 2 bounds
elif not self.IsInBounds():
# set value to the nearest bound:
try:
value = self.GetWxDateTime()
except:
## dbg('exception occurred', indent=0)
raise
if min <= max: # valid range doesn't span midnight
## dbg('min <= max')
# which makes the "nearest bound" computation trickier...
# determine how long the "invalid" pie wedge is, and cut
# this interval in half for comparison purposes:
# Note: relies on min and max and value date portions
# always being the same.
interval = (min + wx.TimeSpan(24, 0, 0, 0)) - max
half_interval = wx.TimeSpan(
0, # hours
0, # minutes
interval.GetSeconds() / 2, # seconds
0) # msec
if value < min: # min is on next day, so use value on
# "next day" for "nearest" interval calculation:
cmp_value = value + wx.TimeSpan(24, 0, 0, 0)
else: # "before midnight; ok
cmp_value = value
if (cmp_value - max) > half_interval:
## dbg('forcing value to min (%s)' % min.FormatTime())
self.SetValue(min)
else:
## dbg('forcing value to max (%s)' % max.FormatTime())
self.SetValue(max)
else:
## dbg('max < min')
# therefore max < value < min guaranteed to be true,
# so "nearest bound" calculation is much easier:
if (value - max) >= (min - value):
# current value closer to min; pick that edge of pie wedge
## dbg('forcing value to min (%s)' % min.FormatTime())
self.SetValue(min)
else:
## dbg('forcing value to max (%s)' % max.FormatTime())
self.SetValue(max)
## dbg(indent=0)
def IsLimited(self):
"""
Returns True if the control is currently limiting the
value to fall within any current bounds. *Note:* can
be set even if there are no current bounds.
"""
return self.__limited
def IsInBounds(self, value=None):
"""
Returns True if no value is specified and the current value
of the control falls within the current bounds. As the clock
is a "circle", both minimum and maximum bounds must be set for
a value to ever be considered "out of bounds". This function can
also be called with a value to see if that value would fall within
the current bounds of the given control.
"""
if value is not None:
try:
value = self.GetWxDateTime(value) # try to regularize passed value
except ValueError:
## dbg('ValueError getting wxDateTime for %s' % repr(value), indent=0)
raise
## dbg('TimeCtrl::IsInBounds(%s)' % repr(value), indent=1)
if self.__min is None or self.__max is None:
## dbg(indent=0)
return True
elif value is None:
try:
value = self.GetWxDateTime()
except:
## dbg('exception occurred', indent=0)
raise
## dbg('value:', value.FormatTime())
# Get wxDateTime representations of bounds:
min = self.GetMin()
max = self.GetMax()
midnight = wx.DateTimeFromDMY(1, 0, 1970)
if min <= max: # they don't span midnight
ret = min <= value <= max
else:
# have to break into 2 tests; to be in bounds
# either "min" <= value (<= midnight of *next day*)
# or midnight <= value <= "max"
ret = min <= value or (midnight <= value <= max)
## dbg('in bounds?', ret, indent=0)
return ret
def IsValid( self, value ):
"""
Can be used to determine if a given value would be a legal and
in-bounds value for the control.
"""
try:
self.__validateValue(value)
return True
except ValueError:
return False
def SetFormat(self, format):
self.SetParameters(format=format)
def GetFormat(self):
if self.__displaySeconds:
if self.__fmt24hr: return '24HHMMSS'
else: return 'HHMMSS'
else:
if self.__fmt24hr: return '24HHMM'
else: return 'HHMM'
#-------------------------------------------------------------------------------------------------------------
# these are private functions and overrides:
def __OnTextChange(self, event=None):
## dbg('TimeCtrl::OnTextChange', indent=1)
# Allow Maskedtext base control to color as appropriate,
# and Skip the EVT_TEXT event (if appropriate.)
##! WS: For some inexplicable reason, every wxTextCtrl.SetValue()
## call is generating two (2) EVT_TEXT events. (!)
## The the only mechanism I can find to mask this problem is to
## keep track of last value seen, and declare a valid EVT_TEXT
## event iff the value has actually changed. The masked edit
## OnTextChange routine does this, and returns True on a valid event,
## False otherwise.
if not BaseMaskedTextCtrl._OnTextChange(self, event):
return
## dbg('firing TimeUpdatedEvent...')
evt = TimeUpdatedEvent(self.GetId(), self.GetValue())
evt.SetEventObject(self)
self.GetEventHandler().ProcessEvent(evt)
## dbg(indent=0)
def SetInsertionPoint(self, pos):
"""
This override records the specified position and associated cell before
calling base class' function. This is necessary to handle the optional
spin button, because the insertion point is lost when the focus shifts
to the spin button.
"""
## dbg('TimeCtrl::SetInsertionPoint', pos, indent=1)
BaseMaskedTextCtrl.SetInsertionPoint(self, pos) # (causes EVT_TEXT event to fire)
self.__posCurrent = self.GetInsertionPoint()
## dbg(indent=0)
def SetSelection(self, sel_start, sel_to):
## dbg('TimeCtrl::SetSelection', sel_start, sel_to, indent=1)
# Adjust selection range to legal extent if not already
if sel_start < 0:
sel_start = 0
if self.__posCurrent != sel_start: # force selection and insertion point to match
self.SetInsertionPoint(sel_start)
cell_start, cell_end = self._FindField(sel_start)._extent
if not cell_start <= sel_to <= cell_end:
sel_to = cell_end
self.__bSelection = sel_start != sel_to
BaseMaskedTextCtrl.SetSelection(self, sel_start, sel_to)
## dbg(indent=0)
def __OnSpin(self, key):
"""
This is the function that gets called in response to up/down arrow or
bound spin button events.
"""
self.__IncrementValue(key, self.__posCurrent) # changes the value
# Ensure adjusted control regains focus and has adjusted portion
# selected:
self.SetFocus()
start, end = self._FindField(self.__posCurrent)._extent
self.SetInsertionPoint(start)
self.SetSelection(start, end)
## dbg('current position:', self.__posCurrent)
def __OnSpinUp(self, event):
"""
Event handler for any bound spin button on EVT_SPIN_UP;
causes control to behave as if up arrow was pressed.
"""
## dbg('TimeCtrl::OnSpinUp', indent=1)
self.__OnSpin(wx.WXK_UP)
keep_processing = False
## dbg(indent=0)
return keep_processing
def __OnSpinDown(self, event):
"""
Event handler for any bound spin button on EVT_SPIN_DOWN;
causes control to behave as if down arrow was pressed.
"""
## dbg('TimeCtrl::OnSpinDown', indent=1)
self.__OnSpin(wx.WXK_DOWN)
keep_processing = False
## dbg(indent=0)
return keep_processing
def __OnChar(self, event):
"""
Handler to explicitly look for ':' keyevents, and if found,
clear the m_shiftDown field, so it will behave as forward tab.
It then calls the base control's _OnChar routine with the modified
event instance.
"""
## dbg('TimeCtrl::OnChar', indent=1)
keycode = event.GetKeyCode()
## dbg('keycode:', keycode)
if keycode == ord(':'):
## dbg('colon seen! removing shift attribute')
event.m_shiftDown = False
BaseMaskedTextCtrl._OnChar(self, event ) ## handle each keypress
## dbg(indent=0)
def __OnSetToNow(self, event):
"""
This is the key handler for '!' and 'c'; this allows the user to
quickly set the value of the control to the current time.
"""
self.SetValue(wx.DateTime_Now().FormatTime())
keep_processing = False
return keep_processing
def __LimitSelection(self, event):
"""
Event handler for motion events; this handler
changes limits the selection to the new cell boundaries.
"""
## dbg('TimeCtrl::LimitSelection', indent=1)
pos = self.GetInsertionPoint()
self.__posCurrent = pos
sel_start, sel_to = self.GetSelection()
selection = sel_start != sel_to
if selection:
# only allow selection to end of current cell:
start, end = self._FindField(sel_start)._extent
if sel_to < pos: sel_to = start
elif sel_to > pos: sel_to = end
## dbg('new pos =', self.__posCurrent, 'select to ', sel_to)
self.SetInsertionPoint(self.__posCurrent)
self.SetSelection(self.__posCurrent, sel_to)
if event: event.Skip()
## dbg(indent=0)
def __IncrementValue(self, key, pos):
## dbg('TimeCtrl::IncrementValue', key, pos, indent=1)
text = self.GetValue()
field = self._FindField(pos)
## dbg('field: ', field._index)
start, end = field._extent
slice = text[start:end]
if key == wx.WXK_UP: increment = 1
else: increment = -1
if slice in ('A', 'P'):
if slice == 'A': newslice = 'P'
elif slice == 'P': newslice = 'A'
newvalue = text[:start] + newslice + text[end:]
elif field._index == 0:
# adjusting this field is trickier, as its value can affect the
# am/pm setting. So, we use wxDateTime to generate a new value for us:
# (Use a fixed date not subject to DST variations:)
converter = wx.DateTimeFromDMY(1, 0, 1970)
## dbg('text: "%s"' % text)
converter.ParseTime(text.strip())
currenthour = converter.GetHour()
## dbg('current hour:', currenthour)
newhour = (currenthour + increment) % 24
## dbg('newhour:', newhour)
converter.SetHour(newhour)
## dbg('converter.GetHour():', converter.GetHour())
newvalue = converter # take advantage of auto-conversion for am/pm in .SetValue()
else: # minute or second field; handled the same way:
newslice = "%02d" % ((int(slice) + increment) % 60)
newvalue = text[:start] + newslice + text[end:]
try:
self.SetValue(newvalue)
except ValueError: # must not be in bounds:
if not wx.Validator_IsSilent():
wx.Bell()
## dbg(indent=0)
def _toGUI( self, wxdt ):
"""
This function takes a wxdt as an unambiguous representation of a time, and
converts it to a string appropriate for the format of the control.
"""
if self.__fmt24hr:
if self.__displaySeconds: strval = wxdt.Format('%H:%M:%S')
else: strval = wxdt.Format('%H:%M')
else:
if self.__displaySeconds: strval = wxdt.Format('%I:%M:%S %p')
else: strval = wxdt.Format('%I:%M %p')
return strval
def __validateValue( self, value ):
"""
This function converts the value to a wxDateTime if not already one,
does bounds checking and raises ValueError if argument is
not a valid value for the control as currently specified.
It is used by both the SetValue() and the IsValid() methods.
"""
## dbg('TimeCtrl::__validateValue(%s)' % repr(value), indent=1)
if not value:
## dbg(indent=0)
raise ValueError('%s not a valid time value' % repr(value))
valid = True # assume true
try:
value = self.GetWxDateTime(value) # regularize form; can generate ValueError if problem doing so
except:
## dbg('exception occurred', indent=0)
raise
if self.IsLimited() and not self.IsInBounds(value):
## dbg(indent=0)
raise ValueError (
'value %s is not within the bounds of the control' % str(value) )
## dbg(indent=0)
return value
#----------------------------------------------------------------------------
# Test jig for TimeCtrl:
if __name__ == '__main__':
import traceback
class TestPanel(wx.Panel):
def __init__(self, parent, id,
pos = wx.DefaultPosition, size = wx.DefaultSize,
fmt24hr = 0, test_mx = 0,
style = wx.TAB_TRAVERSAL ):
wx.Panel.__init__(self, parent, id, pos, size, style)
self.test_mx = test_mx
self.tc = TimeCtrl(self, 10, fmt24hr = fmt24hr)
sb = wx.SpinButton( self, 20, wx.DefaultPosition, (-1,20), 0 )
self.tc.BindSpinButton(sb)
sizer = wx.BoxSizer( wx.HORIZONTAL )
sizer.Add( self.tc, 0, wx.ALIGN_CENTRE|wx.LEFT|wx.TOP|wx.BOTTOM, 5 )
sizer.Add( sb, 0, wx.ALIGN_CENTRE|wx.RIGHT|wx.TOP|wx.BOTTOM, 5 )
self.SetAutoLayout( True )
self.SetSizer( sizer )
sizer.Fit( self )
sizer.SetSizeHints( self )
self.Bind(EVT_TIMEUPDATE, self.OnTimeChange, self.tc)
def OnTimeChange(self, event):
## dbg('OnTimeChange: value = ', event.GetValue())
wxdt = self.tc.GetWxDateTime()
## dbg('wxdt =', wxdt.GetHour(), wxdt.GetMinute(), wxdt.GetSecond())
if self.test_mx:
mxdt = self.tc.GetMxDateTime()
## dbg('mxdt =', mxdt.hour, mxdt.minute, mxdt.second)
class MyApp(wx.App):
def OnInit(self):
import sys
fmt24hr = '24' in sys.argv
test_mx = 'mx' in sys.argv
try:
frame = wx.Frame(None, -1, "TimeCtrl Test", (20,20), (100,100) )
panel = TestPanel(frame, -1, (-1,-1), fmt24hr=fmt24hr, test_mx = test_mx)
frame.Show(True)
except:
traceback.print_exc()
return False
return True
try:
app = MyApp(0)
app.MainLoop()
except:
traceback.print_exc()
__i=0
## CHANGELOG:
## ====================
## Version 1.3
## 1. Converted docstrings to reST format, added doc for ePyDoc.
## 2. Renamed helper functions, vars etc. not intended to be visible in public
## interface to code.
##
## Version 1.2
## 1. Changed parameter name display_seconds to displaySeconds, to follow
## other masked edit conventions.
## 2. Added format parameter, to remove need to use both fmt24hr and displaySeconds.
## 3. Changed inheritance to use BaseMaskedTextCtrl, to remove exposure of
## nonsensical parameter methods from the control, so it will work
## properly with Boa.
Reference in New Issue View Git Blame Copy Permalink