| # |
| # 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 |
| } |
| } |
| } |
