You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1022 lines
34 KiB
Plaintext
1022 lines
34 KiB
Plaintext
#
|
|
# Datefield
|
|
# ----------------------------------------------------------------------
|
|
# Implements a date entry field with adjustable built-in intelligence
|
|
# levels.
|
|
# ----------------------------------------------------------------------
|
|
# AUTHOR: Mark L. Ulferts E-mail: mulferts@austin.dsccc.com
|
|
#
|
|
# @(#) $Id: datefield.itk,v 1.5 2002/02/25 04:45:02 mgbacke Exp $
|
|
# ----------------------------------------------------------------------
|
|
# Copyright (c) 1997 DSC Technologies Corporation
|
|
# ======================================================================
|
|
#
|
|
# Permission to use, copy, modify, distribute and license this software
|
|
# and its documentation for any purpose, and without fee or written
|
|
# agreement with DSC, is hereby granted, provided that the above copyright
|
|
# notice appears in all copies and that both the copyright notice and
|
|
# warranty disclaimer below appear in supporting documentation, and that
|
|
# the names of DSC Technologies Corporation or DSC Communications
|
|
# Corporation not be used in advertising or publicity pertaining to the
|
|
# software without specific, written prior permission.
|
|
#
|
|
# DSC DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
|
# ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, AND NON-
|
|
# INFRINGEMENT. THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, AND THE
|
|
# AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE MAINTENANCE,
|
|
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. IN NO EVENT SHALL
|
|
# DSC BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
|
# ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
|
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTUOUS ACTION,
|
|
# ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
|
# SOFTWARE.
|
|
# ======================================================================
|
|
|
|
#
|
|
# Usual options.
|
|
#
|
|
itk::usual Datefield {
|
|
keep -background -borderwidth -cursor -foreground -highlightcolor \
|
|
-highlightthickness -labelfont -textbackground -textfont
|
|
}
|
|
|
|
# ------------------------------------------------------------------
|
|
# DATEFIELD
|
|
# ------------------------------------------------------------------
|
|
itcl::class iwidgets::Datefield {
|
|
inherit iwidgets::Labeledwidget
|
|
|
|
constructor {args} {}
|
|
|
|
itk_option define -childsitepos childSitePos Position e
|
|
itk_option define -command command Command {}
|
|
itk_option define -iq iq Iq high
|
|
itk_option define -gmt gmt GMT no
|
|
itk_option define -int int DateFormat no
|
|
|
|
public method get {{format "-string"}}
|
|
public method isvalid {}
|
|
public method show {{date now}}
|
|
|
|
protected method _backward {}
|
|
protected method _focusIn {}
|
|
protected method _forward {}
|
|
protected method _keyPress {char sym state}
|
|
protected method _lastDay {month year}
|
|
protected method _moveField {direction}
|
|
protected method _setField {field}
|
|
protected method _whichField {}
|
|
|
|
protected variable _cfield "month"
|
|
protected variable _fields {month day year}
|
|
}
|
|
|
|
|
|
#
|
|
# Provide a lowercased access method for the datefield class.
|
|
#
|
|
proc ::iwidgets::datefield {pathName args} {
|
|
uplevel ::iwidgets::Datefield $pathName $args
|
|
}
|
|
|
|
#
|
|
# Use option database to override default resources of base classes.
|
|
#
|
|
option add *Datefield.justify center widgetDefault
|
|
|
|
# ------------------------------------------------------------------
|
|
# CONSTRUCTOR
|
|
# ------------------------------------------------------------------
|
|
itcl::body iwidgets::Datefield::constructor {args} {
|
|
component hull configure -borderwidth 0
|
|
|
|
#
|
|
# Create an entry field for entering the date.
|
|
#
|
|
itk_component add date {
|
|
entry $itk_interior.date -width 10
|
|
} {
|
|
keep -borderwidth -cursor -exportselection \
|
|
-foreground -highlightcolor -highlightthickness \
|
|
-insertbackground -justify -relief -state
|
|
|
|
rename -font -textfont textFont Font
|
|
rename -highlightbackground -background background Background
|
|
rename -background -textbackground textBackground Background
|
|
}
|
|
|
|
#
|
|
# Create the child site widget.
|
|
#
|
|
itk_component add -protected dfchildsite {
|
|
frame $itk_interior.dfchildsite
|
|
}
|
|
set itk_interior $itk_component(dfchildsite)
|
|
|
|
#
|
|
# Add datefield event bindings for focus in and keypress events.
|
|
#
|
|
bind $itk_component(date) <FocusIn> [itcl::code $this _focusIn]
|
|
bind $itk_component(date) <KeyPress> [itcl::code $this _keyPress %A %K %s]
|
|
|
|
#
|
|
# Disable some mouse button event bindings:
|
|
# Button Motion
|
|
# Double-Clicks
|
|
# Triple-Clicks
|
|
# Button2
|
|
#
|
|
bind $itk_component(date) <Button1-Motion> break
|
|
bind $itk_component(date) <Button2-Motion> break
|
|
bind $itk_component(date) <Double-Button> break
|
|
bind $itk_component(date) <Triple-Button> break
|
|
bind $itk_component(date) <2> break
|
|
|
|
#
|
|
# Initialize the widget based on the command line options.
|
|
#
|
|
eval itk_initialize $args
|
|
|
|
#
|
|
# Initialize the date to the current date.
|
|
#
|
|
$itk_component(date) delete 0 end
|
|
|
|
show now
|
|
}
|
|
|
|
# ------------------------------------------------------------------
|
|
# OPTIONS
|
|
# ------------------------------------------------------------------
|
|
|
|
# ------------------------------------------------------------------
|
|
# OPTION: -childsitepos
|
|
#
|
|
# Specifies the position of the child site in the widget. Valid
|
|
# locations are n, s, e, and w.
|
|
# ------------------------------------------------------------------
|
|
itcl::configbody iwidgets::Datefield::childsitepos {
|
|
set parent [winfo parent $itk_component(date)]
|
|
|
|
switch $itk_option(-childsitepos) {
|
|
n {
|
|
grid $itk_component(dfchildsite) -row 0 -column 0 -sticky ew
|
|
grid $itk_component(date) -row 1 -column 0 -sticky nsew
|
|
|
|
grid rowconfigure $parent 0 -weight 0
|
|
grid rowconfigure $parent 1 -weight 1
|
|
grid columnconfigure $parent 0 -weight 1
|
|
grid columnconfigure $parent 1 -weight 0
|
|
}
|
|
|
|
e {
|
|
grid $itk_component(dfchildsite) -row 0 -column 1 -sticky ns
|
|
grid $itk_component(date) -row 0 -column 0 -sticky nsew
|
|
|
|
grid rowconfigure $parent 0 -weight 1
|
|
grid rowconfigure $parent 1 -weight 0
|
|
grid columnconfigure $parent 0 -weight 1
|
|
grid columnconfigure $parent 1 -weight 0
|
|
}
|
|
|
|
s {
|
|
grid $itk_component(dfchildsite) -row 1 -column 0 -sticky ew
|
|
grid $itk_component(date) -row 0 -column 0 -sticky nsew
|
|
|
|
grid rowconfigure $parent 0 -weight 1
|
|
grid rowconfigure $parent 1 -weight 0
|
|
grid columnconfigure $parent 0 -weight 1
|
|
grid columnconfigure $parent 1 -weight 0
|
|
}
|
|
|
|
w {
|
|
grid $itk_component(dfchildsite) -row 0 -column 0 -sticky ns
|
|
grid $itk_component(date) -row 0 -column 1 -sticky nsew
|
|
|
|
grid rowconfigure $parent 0 -weight 1
|
|
grid rowconfigure $parent 1 -weight 0
|
|
grid columnconfigure $parent 0 -weight 0
|
|
grid columnconfigure $parent 1 -weight 1
|
|
}
|
|
|
|
default {
|
|
error "bad childsite option\
|
|
\"$itk_option(-childsitepos)\":\
|
|
should be n, e, s, or w"
|
|
}
|
|
}
|
|
}
|
|
|
|
# ------------------------------------------------------------------
|
|
# OPTION: -command
|
|
#
|
|
# Command invoked upon detection of return key press event.
|
|
# ------------------------------------------------------------------
|
|
itcl::configbody iwidgets::Datefield::command {}
|
|
|
|
# ------------------------------------------------------------------
|
|
# OPTION: -iq
|
|
#
|
|
# Specifies the level of intelligence to be shown in the actions
|
|
# taken by the date field during the processing of keypress events.
|
|
# Valid settings include high, average, and low. With a high iq,
|
|
# the date prevents the user from typing in an invalid date. For
|
|
# example, if the current date is 05/31/1997 and the user changes
|
|
# the month to 04, then the day will be instantly modified for them
|
|
# to be 30. In addition, leap years are fully taken into account.
|
|
# With average iq, the month is limited to the values of 01-12, but
|
|
# it is possible to type in an invalid day. A setting of low iq
|
|
# instructs the widget to do no validity checking at all during
|
|
# date entry. With both average and low iq levels, it is assumed
|
|
# that the validity will be determined at a later time using the
|
|
# date's isvalid command.
|
|
# ------------------------------------------------------------------
|
|
itcl::configbody iwidgets::Datefield::iq {
|
|
switch $itk_option(-iq) {
|
|
high - average - low {
|
|
}
|
|
default {
|
|
error "bad iq option \"$itk_option(-iq)\":\
|
|
should be high, average or low"
|
|
}
|
|
}
|
|
}
|
|
|
|
# ------------------------------------------------------------------
|
|
# OPTION: -int
|
|
#
|
|
# Added by Mark Alston 2001/10/21
|
|
#
|
|
# Allows for the use of dates in "international" format: YYYY-MM-DD.
|
|
# It must be a boolean value.
|
|
# ------------------------------------------------------------------
|
|
itcl::configbody iwidgets::Datefield::int {
|
|
switch $itk_option(-int) {
|
|
1 - yes - true - on {
|
|
set _cfield "year"
|
|
set _fields {year month day}
|
|
}
|
|
0 - no - false - off { }
|
|
default {
|
|
error "bad int option \"$itk_option(-int)\": should be boolean"
|
|
}
|
|
}
|
|
show [get]
|
|
}
|
|
|
|
# ------------------------------------------------------------------
|
|
# OPTION: -gmt
|
|
#
|
|
# This option is used for GMT time. Must be a boolean value.
|
|
# ------------------------------------------------------------------
|
|
itcl::configbody iwidgets::Datefield::gmt {
|
|
switch $itk_option(-gmt) {
|
|
0 - no - false - off { }
|
|
1 - yes - true - on { }
|
|
default {
|
|
error "bad gmt option \"$itk_option(-gmt)\": should be boolean"
|
|
}
|
|
}
|
|
}
|
|
|
|
# ------------------------------------------------------------------
|
|
# METHODS
|
|
# ------------------------------------------------------------------
|
|
|
|
# ------------------------------------------------------------------
|
|
# PUBLIC METHOD: get ?format?
|
|
#
|
|
# Return the current contents of the datefield in one of two formats
|
|
# string or as an integer clock value using the -string and -clicks
|
|
# options respectively. The default is by string. Reference the
|
|
# clock command for more information on obtaining dates and their
|
|
# formats.
|
|
# ------------------------------------------------------------------
|
|
itcl::body iwidgets::Datefield::get {{format "-string"}} {
|
|
set datestr [$itk_component(date) get]
|
|
|
|
switch -- $format {
|
|
"-string" {
|
|
return $datestr
|
|
}
|
|
"-clicks" {
|
|
return [clock scan $datestr]
|
|
}
|
|
default {
|
|
error "bad format option \"$format\":\
|
|
should be -string or -clicks"
|
|
}
|
|
}
|
|
}
|
|
|
|
# ------------------------------------------------------------------
|
|
# PUBLIC METHOD: show date
|
|
#
|
|
# Changes the currently displayed date to be that of the date
|
|
# argument. The date may be specified either as a string or an
|
|
# integer clock value. Reference the clock command for more
|
|
# information on obtaining dates and their formats.
|
|
# ------------------------------------------------------------------
|
|
itcl::body iwidgets::Datefield::show {{date "now"}} {
|
|
$itk_component(date) delete 0 end
|
|
if {$itk_option(-int)} {
|
|
set format {%Y-%m-%d}
|
|
} else {
|
|
set format {%m/%d/%Y}
|
|
}
|
|
|
|
if {$date == "now"} {
|
|
set seconds [::clock seconds]
|
|
$itk_component(date) insert end \
|
|
[clock format $seconds -format "$format" -gmt $itk_option(-gmt)]
|
|
|
|
} elseif { $itk_option(-iq) != "low" } {
|
|
if {[catch {::clock format $date}] == 0} {
|
|
set seconds $date
|
|
} elseif {[catch {set seconds [::clock scan $date -gmt \
|
|
$itk_option(-gmt)]}] != 0} {
|
|
error "bad date: \"$date\", must be a valid date\
|
|
string, clock clicks value or the keyword now"
|
|
}
|
|
$itk_component(date) insert end \
|
|
[clock format $seconds -format "$format" -gmt $itk_option(-gmt)]
|
|
} else {
|
|
# Note that it doesn't matter what -int is set to.
|
|
$itk_component(date) insert end $date
|
|
}
|
|
|
|
if {$itk_option(-int)} {
|
|
_setField year
|
|
} else {
|
|
_setField month
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
# ------------------------------------------------------------------
|
|
# PUBLIC METHOD: isvalid
|
|
#
|
|
# Returns a boolean indication of the validity of the currently
|
|
# displayed date value. For example, 3/3/1960 is valid whereas
|
|
# 02/29/1997 is invalid.
|
|
# ------------------------------------------------------------------
|
|
itcl::body iwidgets::Datefield::isvalid {} {
|
|
if {[catch {clock scan [$itk_component(date) get]}] != 0} {
|
|
return 0
|
|
} else {
|
|
return 1
|
|
}
|
|
}
|
|
|
|
# ------------------------------------------------------------------
|
|
# PROTECTED METHOD: _focusIn
|
|
#
|
|
# This method is bound to the <FocusIn> event. It resets the
|
|
# insert cursor and field settings to be back to their last known
|
|
# positions.
|
|
# ------------------------------------------------------------------
|
|
itcl::body iwidgets::Datefield::_focusIn {} {
|
|
_setField $_cfield
|
|
}
|
|
|
|
# ------------------------------------------------------------------
|
|
# PROTECTED METHOD: _keyPress
|
|
#
|
|
# This method is the workhorse of the class. It is bound to the
|
|
# <KeyPress> event and controls the processing of all key strokes.
|
|
# ------------------------------------------------------------------
|
|
itcl::body iwidgets::Datefield::_keyPress {char sym state} {
|
|
#
|
|
# Determine which field we are in currently. This is needed
|
|
# since the user may have moved to this position via a mouse
|
|
# selection and so it would not be in the position we last
|
|
# knew it to be.
|
|
#
|
|
_whichField
|
|
|
|
#
|
|
# If we are using an international date the split char is "-"
|
|
# otherwise it is "/".
|
|
#
|
|
if {$itk_option(-int)} {
|
|
set split_char "-"
|
|
} else {
|
|
set split_char "/"
|
|
}
|
|
|
|
|
|
#
|
|
# Set up a few basic variables we'll be needing throughout the
|
|
# rest of the method such as the position of the insert cursor
|
|
# and the currently displayed day, month, and year.
|
|
#
|
|
set icursor [$itk_component(date) index insert]
|
|
set splist [split [$itk_component(date) get] "$split_char"]
|
|
|
|
|
|
# A bunch of added variables to allow for the use of int dates
|
|
if {$itk_option(-int)} {
|
|
set order {year month day}
|
|
set year [lindex $splist 0]
|
|
set month [lindex $splist 1]
|
|
set day [lindex $splist 2]
|
|
set year_start_pos 0
|
|
set year_second_pos 1
|
|
set year_third_pos 2
|
|
set year_fourth_pos 3
|
|
set year_end_pos 4
|
|
set month_start_pos 5
|
|
set month_second_pos 6
|
|
set month_end_pos 7
|
|
set day_start_pos 8
|
|
set day_second_pos 9
|
|
set day_end_pos 10
|
|
} else {
|
|
set order {month day year}
|
|
set month [lindex $splist 0]
|
|
set day [lindex $splist 1]
|
|
set year [lindex $splist 2]
|
|
set month_start_pos 0
|
|
set month_second_pos 1
|
|
set month_end_pos 2
|
|
set day_start_pos 3
|
|
set day_second_pos 4
|
|
set day_end_pos 5
|
|
set year_start_pos 6
|
|
set year_second_pos 7
|
|
set year_third_pos 8
|
|
set year_fourth_pos 9
|
|
set year_end_pos 10
|
|
}
|
|
|
|
|
|
#
|
|
# Process numeric keystrokes. This involes a fair amount of
|
|
# processing with step one being to check and make sure we
|
|
# aren't attempting to insert more that 10 characters. If
|
|
# so ring the bell and break.
|
|
#
|
|
if {[regexp {[0-9]} $char]} {
|
|
if {[$itk_component(date) index insert] == 10} {
|
|
bell
|
|
return -code break
|
|
}
|
|
|
|
#
|
|
# If we are currently in the month field then we process the
|
|
# number entered based on the cursor position. If we are at
|
|
# at the first position and our iq is low, then accept any
|
|
# input.
|
|
#
|
|
if {$_cfield == "month"} {
|
|
|
|
if {[$itk_component(date) index insert] == $month_start_pos} {
|
|
if {$itk_option(-iq) == "low"} {
|
|
$itk_component(date) delete $month_start_pos
|
|
$itk_component(date) insert $month_start_pos $char
|
|
} else {
|
|
#
|
|
# Otherwise, we're slightly smarter. If the number
|
|
# is less than two insert it at position zero. If
|
|
# this makes the month greater than twelve, set the
|
|
# number at position one to zero which makes in
|
|
# effect puts the month back in range.
|
|
#
|
|
regsub {([0-9])([0-9])} $month "$char\\2" month2b
|
|
|
|
if {$char < 2} {
|
|
$itk_component(date) delete $month_start_pos
|
|
$itk_component(date) insert $month_start_pos $char
|
|
|
|
if {$month2b > 12} {
|
|
$itk_component(date) delete $month_second_pos
|
|
$itk_component(date) insert $month_second_pos 0
|
|
$itk_component(date) icursor $month_second_pos
|
|
} elseif {$month2b == "00"} {
|
|
$itk_component(date) delete $month_second_pos
|
|
$itk_component(date) insert $month_second_pos 1
|
|
$itk_component(date) icursor $month_second_pos
|
|
}
|
|
|
|
#
|
|
# Finally, if the number is greater than one we'll
|
|
# assume that they really mean to be entering a zero
|
|
# followed by their number, do so for them, and
|
|
# proceed to skip to the next field which is the
|
|
# day field.
|
|
#
|
|
} else {
|
|
$itk_component(date) delete $month_start_pos $month_end_pos
|
|
$itk_component(date) insert $month_start_pos 0$char
|
|
_setField day
|
|
}
|
|
}
|
|
|
|
#
|
|
# Else, we're at the second month position. Again, if we aren't
|
|
# too smart, let them enter anything. Otherwise, if the
|
|
# number makes the month exceed twelve, set the month to
|
|
# zero followed by their number to get it back into range.
|
|
#
|
|
} else {
|
|
regsub {([0-9])([0-9])} $month "\\1$char" month2b
|
|
|
|
if {$itk_option(-iq) == "low"} {
|
|
$itk_component(date) delete $month_second_pos
|
|
$itk_component(date) insert $month_second_pos $char
|
|
} else {
|
|
if {$month2b > 12} {
|
|
$itk_component(date) delete $month_start_pos $month_end_pos
|
|
$itk_component(date) insert $month_start_pos 0$char
|
|
} elseif {$month2b == "00"} {
|
|
bell
|
|
return -code break
|
|
} else {
|
|
$itk_component(date) delete $month_second_pos
|
|
$itk_component(date) insert $month_second_pos $char
|
|
}
|
|
}
|
|
_setField day
|
|
}
|
|
|
|
#
|
|
# Now, the month processing is complete and if we're of a
|
|
# high level of intelligence, then we'll make sure that the
|
|
# current value for the day is valid for this month. If
|
|
# it is beyond the last day for this month, change it to
|
|
# be the last day of the new month.
|
|
#
|
|
if {$itk_option(-iq) == "high"} {
|
|
set splist [split [$itk_component(date) get] "$split_char"]
|
|
set month [lindex $splist [lsearch $order month]]
|
|
if {$day > [set endday [_lastDay $month $year]]} {
|
|
set icursor [$itk_component(date) index insert]
|
|
$itk_component(date) delete $day_start_pos $day_end_pos
|
|
$itk_component(date) insert $day_start_pos $endday
|
|
$itk_component(date) icursor $icursor
|
|
}
|
|
}
|
|
|
|
#
|
|
# Finally, return with a code of break to stop any normal
|
|
# processing in that we've done all that is necessary.
|
|
#
|
|
return -code break
|
|
}
|
|
|
|
#
|
|
# This next block of code is for processing of the day field
|
|
# which is quite similar is strategy to that of the month.
|
|
#
|
|
if {$_cfield == "day"} {
|
|
if {$itk_option(-iq) == "high"} {
|
|
set endofMonth [_lastDay $month $year]
|
|
} else {
|
|
set endofMonth 31
|
|
}
|
|
|
|
#
|
|
# If we are at the first cursor position for the day
|
|
# we are processing
|
|
# the first character of the day field. If we have an iq
|
|
# of low accept any input.
|
|
#
|
|
if {[$itk_component(date) index insert] == $day_start_pos} {
|
|
if {$itk_option(-iq) == "low"} {
|
|
$itk_component(date) delete $day_start_pos
|
|
$itk_component(date) insert $day_start_pos $char
|
|
|
|
} else {
|
|
|
|
#
|
|
# If the day to be is double zero, then make the
|
|
# day be the first.
|
|
#
|
|
regsub {([0-9])([0-9])} $day "$char\\2" day2b
|
|
|
|
if {$day2b == "00"} {
|
|
$itk_component(date) delete $day_start_pos $day_end_pos
|
|
$itk_component(date) insert $day_start_pos 01
|
|
$itk_component(date) icursor $day_second_pos
|
|
#
|
|
# Otherwise, if the character is less than four
|
|
# and the month is not Feburary, insert the number
|
|
# and if this makes the day be beyond the valid
|
|
# range for this month, than set to be back in
|
|
# range.
|
|
#
|
|
} elseif {($char < 4) && ($month != "02")} {
|
|
$itk_component(date) delete $day_start_pos
|
|
$itk_component(date) insert $day_start_pos $char
|
|
|
|
if {$day2b > $endofMonth} {
|
|
$itk_component(date) delete $day_second_pos
|
|
$itk_component(date) insert $day_second_pos 0
|
|
$itk_component(date) icursor $day_second_pos
|
|
}
|
|
|
|
#
|
|
# For Feburary with a number to be entered of
|
|
# less than three, make sure the number doesn't
|
|
# make the day be greater than the correct range
|
|
# and if so adjust the input.
|
|
#
|
|
} elseif {$char < 3} {
|
|
$itk_component(date) delete $day_start_pos
|
|
$itk_component(date) insert $day_start_pos $char
|
|
if {$day2b > $endofMonth} {
|
|
$itk_component(date) delete $day_start_pos $day_end_pos
|
|
$itk_component(date) insert $day_start_pos $endofMonth
|
|
$itk_component(date) icursor $day_second_pos
|
|
}
|
|
|
|
#
|
|
# Finally, if the number is greater than three,
|
|
# set the day to be zero followed by the number
|
|
# entered and proceed to the year field or end.
|
|
#
|
|
} else {
|
|
$itk_component(date) delete $day_start_pos $day_end_pos
|
|
$itk_component(date) insert $day_start_pos 0$char
|
|
$itk_component(date) icursor $day_end_pos
|
|
if {!$itk_option(-int)} {
|
|
_setField year
|
|
}
|
|
}
|
|
}
|
|
#
|
|
# Else, we're dealing with the second number in the day
|
|
# field. If we're not too bright accept anything, otherwise
|
|
# if the day is beyond the range for this month or equal to
|
|
# zero then ring the bell.
|
|
#
|
|
} else {
|
|
regsub {([0-9])([0-9])} $day "\\1$char" day2b
|
|
|
|
if {($itk_option(-iq) != "low") && \
|
|
(($day2b > $endofMonth) || ($day2b == "00"))} {
|
|
bell
|
|
} else {
|
|
$itk_component(date) delete $day_second_pos
|
|
$itk_component(date) insert $day_second_pos $char
|
|
$itk_component(date) icursor $day_end_pos
|
|
if {!$itk_option(-int)} {
|
|
_setField year
|
|
}
|
|
}
|
|
}
|
|
|
|
#
|
|
# Return with a code of break to prevent normal processing.
|
|
#
|
|
return -code break
|
|
}
|
|
|
|
#
|
|
# This month and day we're tough, the code for the year is
|
|
# comparitively simple. Accept any input and if we are really
|
|
# sharp, then make sure the day is correct for the month
|
|
# given the year. In short, handle leap years.
|
|
#
|
|
if {$_cfield == "year"} {
|
|
if {$itk_option(-iq) == "low"} {
|
|
$itk_component(date) delete $icursor
|
|
$itk_component(date) insert $icursor $char
|
|
} else {
|
|
set prevdate [get]
|
|
if {[$itk_component(date) index insert] == $year_start_pos} {
|
|
set yrdgt [lindex [split [lindex \
|
|
[split $prevdate "$split_char"] [lsearch $order year]] ""] 0]
|
|
if {$char != $yrdgt} {
|
|
if {$char == 1} {
|
|
$itk_component(date) delete $icursor $year_end_pos
|
|
$itk_component(date) insert $icursor 1999
|
|
} elseif {$char == 2} {
|
|
$itk_component(date) delete $icursor $year_end_pos
|
|
$itk_component(date) insert $icursor 2000
|
|
} else {
|
|
bell
|
|
return -code break
|
|
}
|
|
}
|
|
|
|
$itk_component(date) icursor $year_second_pos
|
|
return -code break
|
|
}
|
|
|
|
$itk_component(date) delete $icursor
|
|
$itk_component(date) insert $icursor $char
|
|
|
|
|
|
if {[catch {clock scan [get]}] != 0} {
|
|
$itk_component(date) delete $year_start_pos $year_end_pos
|
|
$itk_component(date) insert $year_start_pos \
|
|
[lindex [split $prevdate "$split_char"] [lsearch $order year]]
|
|
$itk_component(date) icursor $icursor
|
|
|
|
bell
|
|
return -code break
|
|
}
|
|
|
|
if {$itk_option(-iq) == "high"} {
|
|
set splist [split [$itk_component(date) get] "$split_char"]
|
|
set year [lindex $splist [lsearch $order year]]
|
|
|
|
if {$day > [set endday [_lastDay $month $year]]} {
|
|
set icursor [$itk_component(date) index insert]
|
|
$itk_component(date) delete $day_start_pos $day_end_pos
|
|
$itk_component(date) insert $day_start_pos $endday
|
|
$itk_component(date) icursor $icursor
|
|
}
|
|
}
|
|
}
|
|
if {$itk_option(-int)} {
|
|
if {$icursor == $year_fourth_pos } {
|
|
_setField month
|
|
}
|
|
}
|
|
return -code break
|
|
}
|
|
|
|
#
|
|
# Process the plus and the up arrow keys. They both yeild the same
|
|
# effect, they increment the day by one.
|
|
#
|
|
} elseif {($sym == "plus") || ($sym == "Up")} {
|
|
if {[catch {show [clock scan "1 day" -base [get -clicks]]}] != 0} {
|
|
bell
|
|
}
|
|
return -code break
|
|
|
|
#
|
|
# Process the minus and the down arrow keys which decrement the day.
|
|
#
|
|
} elseif {($sym == "minus") || ($sym == "Down")} {
|
|
if {[catch {show [clock scan "-1 day" -base [get -clicks]]}] != 0} {
|
|
bell
|
|
}
|
|
return -code break
|
|
|
|
#
|
|
# A tab key moves the day/month/year (or year/month/day) field
|
|
# forward by one unless
|
|
# the current field is the last field. In that case we'll let tab
|
|
# do what is supposed to and pass the focus onto the next widget.
|
|
#
|
|
} elseif {($sym == "Tab") && ($state == 0)} {
|
|
if {$_cfield != "[lindex $order 2]"} {
|
|
_moveField forward
|
|
return -code break
|
|
} else {
|
|
_setField "[lindex $order 0]"
|
|
return -code continue
|
|
}
|
|
|
|
#
|
|
# A ctrl-tab key moves the day/month/year field backwards by one
|
|
# unless the current field is the the first field. In that case we'll
|
|
# let tab take the focus to a previous widget.
|
|
#
|
|
} elseif {($sym == "Tab") && ($state == 4)} {
|
|
if {$_cfield != "[lindex $order 0]"} {
|
|
_moveField backward
|
|
return -code break
|
|
} else {
|
|
set _cfield "[lindex $order 0]"
|
|
return -code continue
|
|
}
|
|
|
|
#
|
|
# A right arrow key moves the insert cursor to the right one.
|
|
#
|
|
} elseif {$sym == "Right"} {
|
|
_forward
|
|
return -code break
|
|
|
|
#
|
|
# A left arrow, backspace, or delete key moves the insert cursor
|
|
# to the left one. This is what you expect for the left arrow
|
|
# and since the whole widget always operates in overstrike mode,
|
|
# it makes the most sense for backspace and delete to do the same.
|
|
#
|
|
} elseif {$sym == "Left" || $sym == "BackSpace" || $sym == "Delete"} {
|
|
_backward
|
|
return -code break
|
|
|
|
} elseif {($sym == "Control_L") || ($sym == "Shift_L") || \
|
|
($sym == "Control_R") || ($sym == "Shift_R")} {
|
|
return -code break
|
|
|
|
#
|
|
# A Return key invokes the optionally specified command option.
|
|
#
|
|
} elseif {$sym == "Return"} {
|
|
uplevel #0 $itk_option(-command)
|
|
return -code break
|
|
} else {
|
|
bell
|
|
return -code break
|
|
}
|
|
}
|
|
|
|
# ------------------------------------------------------------------
|
|
# PROTECTED METHOD: _setField field
|
|
#
|
|
# Internal method which adjusts the field to be that of the
|
|
# argument, setting the insert cursor appropriately.
|
|
# ------------------------------------------------------------------
|
|
itcl::body iwidgets::Datefield::_setField {field} {
|
|
set _cfield $field
|
|
|
|
if {$itk_option(-int)} {
|
|
set year_pos 2
|
|
set month_pos 5
|
|
set day_pos 8
|
|
} else {
|
|
set month_pos 0
|
|
set day_pos 3
|
|
set year_pos 8
|
|
}
|
|
|
|
|
|
switch $field {
|
|
"month" {
|
|
$itk_component(date) icursor $month_pos
|
|
}
|
|
"day" {
|
|
$itk_component(date) icursor $day_pos
|
|
}
|
|
"year" {
|
|
$itk_component(date) icursor $year_pos
|
|
}
|
|
default {
|
|
error "bad field: \"$field\", must be month, day or year"
|
|
}
|
|
}
|
|
}
|
|
|
|
# ------------------------------------------------------------------
|
|
# PROTECTED METHOD: _moveField
|
|
#
|
|
# Internal method for moving the field forward or backward by one.
|
|
# ------------------------------------------------------------------
|
|
itcl::body iwidgets::Datefield::_moveField {direction} {
|
|
|
|
set index [lsearch $_fields $_cfield]
|
|
|
|
if {$direction == "forward"} {
|
|
set newIndex [expr {$index + 1}]
|
|
} else {
|
|
set newIndex [expr {$index - 1}]
|
|
}
|
|
|
|
if {$newIndex == [llength $_fields]} {
|
|
set newIndex 0
|
|
}
|
|
if {$newIndex < 0} {
|
|
set newIndex [expr {[llength $_fields] - 1}]
|
|
}
|
|
|
|
_setField [lindex $_fields $newIndex]
|
|
|
|
return
|
|
}
|
|
|
|
# ------------------------------------------------------------------
|
|
# PROTECTED METHOD: _whichField
|
|
#
|
|
# Internal method which returns the current field that the cursor
|
|
# is currently within.
|
|
# ------------------------------------------------------------------
|
|
itcl::body iwidgets::Datefield::_whichField {} {
|
|
set icursor [$itk_component(date) index insert]
|
|
|
|
if {$itk_option(-int)} {
|
|
switch $icursor {
|
|
0 - 1 - 2 - 3 {
|
|
set _cfield "year"
|
|
}
|
|
5 - 6 {
|
|
set _cfield "month"
|
|
}
|
|
8 - 9 {
|
|
set _cfield "day"
|
|
}
|
|
}
|
|
} else {
|
|
switch $icursor {
|
|
0 - 1 {
|
|
set _cfield "month"
|
|
}
|
|
3 - 4 {
|
|
set _cfield "day"
|
|
}
|
|
6 - 7 - 8 - 9 {
|
|
set _cfield "year"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# ------------------------------------------------------------------
|
|
# PROTECTED METHOD: _forward
|
|
#
|
|
# Internal method which moves the cursor forward by one character
|
|
# jumping over the slashes and wrapping.
|
|
# ------------------------------------------------------------------
|
|
itcl::body iwidgets::Datefield::_forward {} {
|
|
set icursor [$itk_component(date) index insert]
|
|
|
|
if {$itk_option(-int)} {
|
|
switch $icursor {
|
|
3 {
|
|
_setField month
|
|
}
|
|
6 {
|
|
_setField day
|
|
}
|
|
9 - 10 {
|
|
_setField year
|
|
}
|
|
default {
|
|
$itk_component(date) icursor [expr {$icursor + 1}]
|
|
}
|
|
}
|
|
} else {
|
|
switch $icursor {
|
|
1 {
|
|
_setField day
|
|
}
|
|
4 {
|
|
_setField year
|
|
}
|
|
9 - 10 {
|
|
_setField month
|
|
}
|
|
default {
|
|
$itk_component(date) icursor [expr {$icursor + 1}]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# ------------------------------------------------------------------
|
|
# PROTECTED METHOD: _backward
|
|
#
|
|
# Internal method which moves the cursor backward by one character
|
|
# jumping over the slashes and wrapping.
|
|
# ------------------------------------------------------------------
|
|
itcl::body iwidgets::Datefield::_backward {} {
|
|
set icursor [$itk_component(date) index insert]
|
|
if {$itk_option(-int)} {
|
|
switch $icursor {
|
|
8 {
|
|
_setField month
|
|
}
|
|
5 {
|
|
_setField year
|
|
}
|
|
0 {
|
|
_setField day
|
|
}
|
|
default {
|
|
$itk_component(date) icursor [expr {$icursor -1}]
|
|
}
|
|
}
|
|
} else {
|
|
switch $icursor {
|
|
6 {
|
|
_setField day
|
|
}
|
|
3 {
|
|
_setField month
|
|
}
|
|
0 {
|
|
_setField year
|
|
}
|
|
default {
|
|
$itk_component(date) icursor [expr {$icursor -1}]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# ------------------------------------------------------------------
|
|
# PROTECTED METHOD: _lastDay month year
|
|
#
|
|
# Internal method which determines the last day of the month for
|
|
# the given month and year. We start at 28 and go forward till
|
|
# we fail. Crude but effective.
|
|
# ------------------------------------------------------------------
|
|
itcl::body iwidgets::Datefield::_lastDay {month year} {
|
|
set lastone 28
|
|
|
|
for {set lastone 28} {$lastone < 32} {incr lastone} {
|
|
set nextone [expr $lastone + 1]
|
|
if {[catch {clock scan $month/$nextone/$year}] != 0} {
|
|
return $lastone
|
|
}
|
|
}
|
|
}
|