share/tk8.4/entry.tcl - toolchains/skids - Git at Google

 # entry.tcl --
 #
 # This file defines the default bindings for Tk entry widgets and provides
 # procedures that help in implementing those bindings.
 #
 # RCS: @(#) $Id: entry.tcl,v 1.20 2002/08/31 06:12:28 das Exp $
 #
 # Copyright (c) 1992-1994 The Regents of the University of California.
 # Copyright (c) 1994-1997 Sun Microsystems, Inc.
 #
 # See the file "license.terms" for information on usage and redistribution
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 #

 #-------------------------------------------------------------------------
 # Elements of tk::Priv that are used in this file:
 #
 # afterId -		If non-null, it means that auto-scanning is underway
 #			and it gives the "after" id for the next auto-scan
 #			command to be executed.
 # mouseMoved -		Non-zero means the mouse has moved a significant
 #			amount since the button went down (so, for example,
 #			start dragging out a selection).
 # pressX -		X-coordinate at which the mouse button was pressed.
 # selectMode -		The style of selection currently underway:
 #			char, word, or line.
 # x, y -		Last known mouse coordinates for scanning
 #			and auto-scanning.
 # data -		Used for Cut and Copy
 #-------------------------------------------------------------------------

 #-------------------------------------------------------------------------
 # The code below creates the default class bindings for entries.
 #-------------------------------------------------------------------------
 bind Entry <<Cut>> {
     if {![catch {tk::EntryGetSelection %W} tk::Priv(data)]} {
 	clipboard clear -displayof %W
 	clipboard append -displayof %W $tk::Priv(data)
 	%W delete sel.first sel.last
 	unset tk::Priv(data)
     }
 }
 bind Entry <<Copy>> {
     if {![catch {tk::EntryGetSelection %W} tk::Priv(data)]} {
 	clipboard clear -displayof %W
 	clipboard append -displayof %W $tk::Priv(data)
 	unset tk::Priv(data)
     }
 }
 bind Entry <<Paste>> {
     global tcl_platform
     catch {
 	if {[string compare [tk windowingsystem] "x11"]} {
 	    catch {
 		%W delete sel.first sel.last
 	    }
 	}
 	%W insert insert [::tk::GetSelection %W CLIPBOARD]
 	tk::EntrySeeInsert %W
     }
 }
 bind Entry <<Clear>> {
     %W delete sel.first sel.last
 }
 bind Entry <<PasteSelection>> {
     if {$tk_strictMotif || ![info exists tk::Priv(mouseMoved)]
 	|| !$tk::Priv(mouseMoved)} {
 	tk::EntryPaste %W %x
     }
 }

 # Standard Motif bindings:

 bind Entry <1> {
     tk::EntryButton1 %W %x
     %W selection clear
 }
 bind Entry <B1-Motion> {
     set tk::Priv(x) %x
     tk::EntryMouseSelect %W %x
 }
 bind Entry <Double-1> {
     set tk::Priv(selectMode) word
     tk::EntryMouseSelect %W %x
     catch {%W icursor sel.last}
 }
 bind Entry <Triple-1> {
     set tk::Priv(selectMode) line
     tk::EntryMouseSelect %W %x
     catch {%W icursor sel.last}
 }
 bind Entry <Shift-1> {
     set tk::Priv(selectMode) char
     %W selection adjust @%x
 }
 bind Entry <Double-Shift-1>	{
     set tk::Priv(selectMode) word
     tk::EntryMouseSelect %W %x
 }
 bind Entry <Triple-Shift-1>	{
     set tk::Priv(selectMode) line
     tk::EntryMouseSelect %W %x
 }
 bind Entry <B1-Leave> {
     set tk::Priv(x) %x
     tk::EntryAutoScan %W
 }
 bind Entry <B1-Enter> {
     tk::CancelRepeat
 }
 bind Entry <ButtonRelease-1> {
     tk::CancelRepeat
 }
 bind Entry <Control-1> {
     %W icursor @%x
 }

 bind Entry <Left> {
     tk::EntrySetCursor %W [expr {[%W index insert] - 1}]
 }
 bind Entry <Right> {
     tk::EntrySetCursor %W [expr {[%W index insert] + 1}]
 }
 bind Entry <Shift-Left> {
     tk::EntryKeySelect %W [expr {[%W index insert] - 1}]
     tk::EntrySeeInsert %W
 }
 bind Entry <Shift-Right> {
     tk::EntryKeySelect %W [expr {[%W index insert] + 1}]
     tk::EntrySeeInsert %W
 }
 bind Entry <Control-Left> {
     tk::EntrySetCursor %W [tk::EntryPreviousWord %W insert]
 }
 bind Entry <Control-Right> {
     tk::EntrySetCursor %W [tk::EntryNextWord %W insert]
 }
 bind Entry <Shift-Control-Left> {
     tk::EntryKeySelect %W [tk::EntryPreviousWord %W insert]
     tk::EntrySeeInsert %W
 }
 bind Entry <Shift-Control-Right> {
     tk::EntryKeySelect %W [tk::EntryNextWord %W insert]
     tk::EntrySeeInsert %W
 }
 bind Entry <Home> {
     tk::EntrySetCursor %W 0
 }
 bind Entry <Shift-Home> {
     tk::EntryKeySelect %W 0
     tk::EntrySeeInsert %W
 }
 bind Entry <End> {
     tk::EntrySetCursor %W end
 }
 bind Entry <Shift-End> {
     tk::EntryKeySelect %W end
     tk::EntrySeeInsert %W
 }

 bind Entry <Delete> {
     if {[%W selection present]} {
 	%W delete sel.first sel.last
     } else {
 	%W delete insert
     }
 }
 bind Entry <BackSpace> {
     tk::EntryBackspace %W
 }

 bind Entry <Control-space> {
     %W selection from insert
 }
 bind Entry <Select> {
     %W selection from insert
 }
 bind Entry <Control-Shift-space> {
     %W selection adjust insert
 }
 bind Entry <Shift-Select> {
     %W selection adjust insert
 }
 bind Entry <Control-slash> {
     %W selection range 0 end
 }
 bind Entry <Control-backslash> {
     %W selection clear
 }
 bind Entry <KeyPress> {
     tk::EntryInsert %W %A
 }

 # Ignore all Alt, Meta, and Control keypresses unless explicitly bound.
 # Otherwise, if a widget binding for one of these is defined, the
 # <KeyPress> class binding will also fire and insert the character,
 # which is wrong.  Ditto for Escape, Return, and Tab.

 bind Entry <Alt-KeyPress> {# nothing}
 bind Entry <Meta-KeyPress> {# nothing}
 bind Entry <Control-KeyPress> {# nothing}
 bind Entry <Escape> {# nothing}
 bind Entry <Return> {# nothing}
 bind Entry <KP_Enter> {# nothing}
 bind Entry <Tab> {# nothing}
 if {[string equal [tk windowingsystem] "classic"]
 	|| [string equal [tk windowingsystem] "aqua"]} {
 	bind Entry <Command-KeyPress> {# nothing}
 }

 # On Windows, paste is done using Shift-Insert.  Shift-Insert already
 # generates the <<Paste>> event, so we don't need to do anything here.
 if {[string compare $tcl_platform(platform) "windows"]} {
     bind Entry <Insert> {
 	catch {tk::EntryInsert %W [::tk::GetSelection %W PRIMARY]}
     }
 }

 # Additional emacs-like bindings:

 bind Entry <Control-a> {
     if {!$tk_strictMotif} {
 	tk::EntrySetCursor %W 0
     }
 }
 bind Entry <Control-b> {
     if {!$tk_strictMotif} {
 	tk::EntrySetCursor %W [expr {[%W index insert] - 1}]
     }
 }
 bind Entry <Control-d> {
     if {!$tk_strictMotif} {
 	%W delete insert
     }
 }
 bind Entry <Control-e> {
     if {!$tk_strictMotif} {
 	tk::EntrySetCursor %W end
     }
 }
 bind Entry <Control-f> {
     if {!$tk_strictMotif} {
 	tk::EntrySetCursor %W [expr {[%W index insert] + 1}]
     }
 }
 bind Entry <Control-h> {
     if {!$tk_strictMotif} {
 	tk::EntryBackspace %W
     }
 }
 bind Entry <Control-k> {
     if {!$tk_strictMotif} {
 	%W delete insert end
     }
 }
 bind Entry <Control-t> {
     if {!$tk_strictMotif} {
 	tk::EntryTranspose %W
     }
 }
 bind Entry <Meta-b> {
     if {!$tk_strictMotif} {
 	tk::EntrySetCursor %W [tk::EntryPreviousWord %W insert]
     }
 }
 bind Entry <Meta-d> {
     if {!$tk_strictMotif} {
 	%W delete insert [tk::EntryNextWord %W insert]
     }
 }
 bind Entry <Meta-f> {
     if {!$tk_strictMotif} {
 	tk::EntrySetCursor %W [tk::EntryNextWord %W insert]
     }
 }
 bind Entry <Meta-BackSpace> {
     if {!$tk_strictMotif} {
 	%W delete [tk::EntryPreviousWord %W insert] insert
     }
 }
 bind Entry <Meta-Delete> {
     if {!$tk_strictMotif} {
 	%W delete [tk::EntryPreviousWord %W insert] insert
     }
 }

 # A few additional bindings of my own.

 bind Entry <2> {
     if {!$tk_strictMotif} {
 	::tk::EntryScanMark %W %x
     }
 }
 bind Entry <B2-Motion> {
     if {!$tk_strictMotif} {
 	::tk::EntryScanDrag %W %x
     }
 }

 # ::tk::EntryClosestGap --
 # Given x and y coordinates, this procedure finds the closest boundary
 # between characters to the given coordinates and returns the index
 # of the character just after the boundary.
 #
 # Arguments:
 # w -		The entry window.
 # x -		X-coordinate within the window.

 proc ::tk::EntryClosestGap {w x} {
     set pos [$w index @$x]
     set bbox [$w bbox $pos]
     if {($x - [lindex $bbox 0]) < ([lindex $bbox 2]/2)} {
 	return $pos
     }
     incr pos
 }

 # ::tk::EntryButton1 --
 # This procedure is invoked to handle button-1 presses in entry
 # widgets.  It moves the insertion cursor, sets the selection anchor,
 # and claims the input focus.
 #
 # Arguments:
 # w -		The entry window in which the button was pressed.
 # x -		The x-coordinate of the button press.

 proc ::tk::EntryButton1 {w x} {
     variable ::tk::Priv

     set Priv(selectMode) char
     set Priv(mouseMoved) 0
     set Priv(pressX) $x
     $w icursor [EntryClosestGap $w $x]
     $w selection from insert
     if {[string compare "disabled" [$w cget -state]]} {focus $w}
 }

 # ::tk::EntryMouseSelect --
 # This procedure is invoked when dragging out a selection with
 # the mouse.  Depending on the selection mode (character, word,
 # line) it selects in different-sized units.  This procedure
 # ignores mouse motions initially until the mouse has moved from
 # one character to another or until there have been multiple clicks.
 #
 # Arguments:
 # w -		The entry window in which the button was pressed.
 # x -		The x-coordinate of the mouse.

 proc ::tk::EntryMouseSelect {w x} {
     variable ::tk::Priv

     set cur [EntryClosestGap $w $x]
     set anchor [$w index anchor]
     if {($cur != $anchor) || (abs($Priv(pressX) - $x) >= 3)} {
 	set Priv(mouseMoved) 1
     }
     switch $Priv(selectMode) {
 	char {
 	    if {$Priv(mouseMoved)} {
 		if {$cur < $anchor} {
 		    $w selection range $cur $anchor
 		} elseif {$cur > $anchor} {
 		    $w selection range $anchor $cur
 		} else {
 		    $w selection clear
 		}
 	    }
 	}
 	word {
 	    if {$cur < [$w index anchor]} {
 		set before [tcl_wordBreakBefore [$w get] $cur]
 		set after [tcl_wordBreakAfter [$w get] [expr {$anchor-1}]]
 	    } else {
 		set before [tcl_wordBreakBefore [$w get] $anchor]
 		set after [tcl_wordBreakAfter [$w get] [expr {$cur - 1}]]
 	    }
 	    if {$before < 0} {
 		set before 0
 	    }
 	    if {$after < 0} {
 		set after end
 	    }
 	    $w selection range $before $after
 	}
 	line {
 	    $w selection range 0 end
 	}
     }
     if {$Priv(mouseMoved)} {
         $w icursor $cur
     }
     update idletasks
 }

 # ::tk::EntryPaste --
 # This procedure sets the insertion cursor to the current mouse position,
 # pastes the selection there, and sets the focus to the window.
 #
 # Arguments:
 # w -		The entry window.
 # x -		X position of the mouse.

 proc ::tk::EntryPaste {w x} {
     $w icursor [EntryClosestGap $w $x]
     catch {$w insert insert [::tk::GetSelection $w PRIMARY]}
     if {[string compare "disabled" [$w cget -state]]} {focus $w}
 }

 # ::tk::EntryAutoScan --
 # This procedure is invoked when the mouse leaves an entry window
 # with button 1 down.  It scrolls the window left or right,
 # depending on where the mouse is, and reschedules itself as an
 # "after" command so that the window continues to scroll until the
 # mouse moves back into the window or the mouse button is released.
 #
 # Arguments:
 # w -		The entry window.

 proc ::tk::EntryAutoScan {w} {
     variable ::tk::Priv
     set x $Priv(x)
     if {![winfo exists $w]} return
     if {$x >= [winfo width $w]} {
 	$w xview scroll 2 units
 	EntryMouseSelect $w $x
     } elseif {$x < 0} {
 	$w xview scroll -2 units
 	EntryMouseSelect $w $x
     }
     set Priv(afterId) [after 50 [list tk::EntryAutoScan $w]]
 }

 # ::tk::EntryKeySelect --
 # This procedure is invoked when stroking out selections using the
 # keyboard.  It moves the cursor to a new position, then extends
 # the selection to that position.
 #
 # Arguments:
 # w -		The entry window.
 # new -		A new position for the insertion cursor (the cursor hasn't
 #		actually been moved to this position yet).

 proc ::tk::EntryKeySelect {w new} {
     if {![$w selection present]} {
 	$w selection from insert
 	$w selection to $new
     } else {
 	$w selection adjust $new
     }
     $w icursor $new
 }

 # ::tk::EntryInsert --
 # Insert a string into an entry at the point of the insertion cursor.
 # If there is a selection in the entry, and it covers the point of the
 # insertion cursor, then delete the selection before inserting.
 #
 # Arguments:
 # w -		The entry window in which to insert the string
 # s -		The string to insert (usually just a single character)

 proc ::tk::EntryInsert {w s} {
     if {[string equal $s ""]} {
 	return
     }
     catch {
 	set insert [$w index insert]
 	if {([$w index sel.first] <= $insert)
 		&& ([$w index sel.last] >= $insert)} {
 	    $w delete sel.first sel.last
 	}
     }
     $w insert insert $s
     EntrySeeInsert $w
 }

 # ::tk::EntryBackspace --
 # Backspace over the character just before the insertion cursor.
 # If backspacing would move the cursor off the left edge of the
 # window, reposition the cursor at about the middle of the window.
 #
 # Arguments:
 # w -		The entry window in which to backspace.

 proc ::tk::EntryBackspace w {
     if {[$w selection present]} {
 	$w delete sel.first sel.last
     } else {
 	set x [expr {[$w index insert] - 1}]
 	if {$x >= 0} {$w delete $x}
 	if {[$w index @0] >= [$w index insert]} {
 	    set range [$w xview]
 	    set left [lindex $range 0]
 	    set right [lindex $range 1]
 	    $w xview moveto [expr {$left - ($right - $left)/2.0}]
 	}
     }
 }

 # ::tk::EntrySeeInsert --
 # Make sure that the insertion cursor is visible in the entry window.
 # If not, adjust the view so that it is.
 #
 # Arguments:
 # w -		The entry window.

 proc ::tk::EntrySeeInsert w {
     set c [$w index insert]
     if {($c < [$w index @0]) || ($c > [$w index @[winfo width $w]])} {
 	$w xview $c
     }
 }

 # ::tk::EntrySetCursor -
 # Move the insertion cursor to a given position in an entry.  Also
 # clears the selection, if there is one in the entry, and makes sure
 # that the insertion cursor is visible.
 #
 # Arguments:
 # w -		The entry window.
 # pos -		The desired new position for the cursor in the window.

 proc ::tk::EntrySetCursor {w pos} {
     $w icursor $pos
     $w selection clear
     EntrySeeInsert $w
 }

 # ::tk::EntryTranspose -
 # This procedure implements the "transpose" function for entry widgets.
 # It tranposes the characters on either side of the insertion cursor,
 # unless the cursor is at the end of the line.  In this case it
 # transposes the two characters to the left of the cursor.  In either
 # case, the cursor ends up to the right of the transposed characters.
 #
 # Arguments:
 # w -		The entry window.

 proc ::tk::EntryTranspose w {
     set i [$w index insert]
     if {$i < [$w index end]} {
 	incr i
     }
     set first [expr {$i-2}]
     if {$first < 0} {
 	return
     }
     set data [$w get]
     set new [string index $data [expr {$i-1}]][string index $data $first]
     $w delete $first $i
     $w insert insert $new
     EntrySeeInsert $w
 }

 # ::tk::EntryNextWord --
 # Returns the index of the next word position after a given position in the
 # entry.  The next word is platform dependent and may be either the next
 # end-of-word position or the next start-of-word position after the next
 # end-of-word position.
 #
 # Arguments:
 # w -		The entry window in which the cursor is to move.
 # start -	Position at which to start search.

 if {[string equal $tcl_platform(platform) "windows"]}  {
     proc ::tk::EntryNextWord {w start} {
 	set pos [tcl_endOfWord [$w get] [$w index $start]]
 	if {$pos >= 0} {
 	    set pos [tcl_startOfNextWord [$w get] $pos]
 	}
 	if {$pos < 0} {
 	    return end
 	}
 	return $pos
     }
 } else {
     proc ::tk::EntryNextWord {w start} {
 	set pos [tcl_endOfWord [$w get] [$w index $start]]
 	if {$pos < 0} {
 	    return end
 	}
 	return $pos
     }
 }

 # ::tk::EntryPreviousWord --
 #
 # Returns the index of the previous word position before a given
 # position in the entry.
 #
 # Arguments:
 # w -		The entry window in which the cursor is to move.
 # start -	Position at which to start search.

 proc ::tk::EntryPreviousWord {w start} {
     set pos [tcl_startOfPreviousWord [$w get] [$w index $start]]
     if {$pos < 0} {
 	return 0
     }
     return $pos
 }

 # ::tk::EntryScanMark --
 #
 # Marks the start of a possible scan drag operation
 #
 # Arguments:
 # w -	The entry window from which the text to get
 # x -	x location on screen

 proc ::tk::EntryScanMark {w x} {
     $w scan mark $x
     set ::tk::Priv(x) $x
     set ::tk::Priv(y) 0 ; # not used
     set ::tk::Priv(mouseMoved) 0
 }

 # ::tk::EntryScanDrag --
 #
 # Marks the start of a possible scan drag operation
 #
 # Arguments:
 # w -	The entry window from which the text to get
 # x -	x location on screen

 proc ::tk::EntryScanDrag {w x} {
     # Make sure these exist, as some weird situations can trigger the
     # motion binding without the initial press.  [Bug #220269]
     if {![info exists ::tk::Priv(x)]} { set ::tk::Priv(x) $x }
     # allow for a delta
     if {abs($x-$::tk::Priv(x)) > 2} {
 	set ::tk::Priv(mouseMoved) 1
     }
     $w scan dragto $x
 }

 # ::tk::EntryGetSelection --
 #
 # Returns the selected text of the entry with respect to the -show option.
 #
 # Arguments:
 # w -         The entry window from which the text to get

 proc ::tk::EntryGetSelection {w} {
     set entryString [string range [$w get] [$w index sel.first] \
 	    [expr {[$w index sel.last] - 1}]]
     if {[string compare [$w cget -show] ""]} {
 	return [string repeat [string index [$w cget -show] 0] \
 		[string length $entryString]]
     }
     return $entryString
 }
	# entry.tcl --
	#
	# This file defines the default bindings for Tk entry widgets and provides
	# procedures that help in implementing those bindings.
	#
	# RCS: @(#) $Id: entry.tcl,v 1.20 2002/08/31 06:12:28 das Exp $
	#
	# Copyright (c) 1992-1994 The Regents of the University of California.
	# Copyright (c) 1994-1997 Sun Microsystems, Inc.
	#
	# See the file "license.terms" for information on usage and redistribution
	# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
	#

	#-------------------------------------------------------------------------
	# Elements of tk::Priv that are used in this file:
	#
	# afterId - If non-null, it means that auto-scanning is underway
	# and it gives the "after" id for the next auto-scan
	# command to be executed.
	# mouseMoved - Non-zero means the mouse has moved a significant
	# amount since the button went down (so, for example,
	# start dragging out a selection).
	# pressX - X-coordinate at which the mouse button was pressed.
	# selectMode - The style of selection currently underway:
	# char, word, or line.
	# x, y - Last known mouse coordinates for scanning
	# and auto-scanning.
	# data - Used for Cut and Copy
	#-------------------------------------------------------------------------

	#-------------------------------------------------------------------------
	# The code below creates the default class bindings for entries.
	#-------------------------------------------------------------------------
	bind Entry <<Cut>> {
	if {![catch {tk::EntryGetSelection %W} tk::Priv(data)]} {
	clipboard clear -displayof %W
	clipboard append -displayof %W $tk::Priv(data)
	%W delete sel.first sel.last
	unset tk::Priv(data)
	}
	}
	bind Entry <<Copy>> {
	if {![catch {tk::EntryGetSelection %W} tk::Priv(data)]} {
	clipboard clear -displayof %W
	clipboard append -displayof %W $tk::Priv(data)
	unset tk::Priv(data)
	}
	}
	bind Entry <<Paste>> {
	global tcl_platform
	catch {
	if {[string compare [tk windowingsystem] "x11"]} {
	catch {
	%W delete sel.first sel.last
	}
	}
	%W insert insert [::tk::GetSelection %W CLIPBOARD]
	tk::EntrySeeInsert %W
	}
	}
	bind Entry <<Clear>> {
	%W delete sel.first sel.last
	}
	bind Entry <<PasteSelection>> {
	if {$tk_strictMotif \|\| ![info exists tk::Priv(mouseMoved)]
	\|\| !$tk::Priv(mouseMoved)} {
	tk::EntryPaste %W %x
	}
	}

	# Standard Motif bindings:

	bind Entry <1> {
	tk::EntryButton1 %W %x
	%W selection clear
	}
	bind Entry <B1-Motion> {
	set tk::Priv(x) %x
	tk::EntryMouseSelect %W %x
	}
	bind Entry <Double-1> {
	set tk::Priv(selectMode) word
	tk::EntryMouseSelect %W %x
	catch {%W icursor sel.last}
	}
	bind Entry <Triple-1> {
	set tk::Priv(selectMode) line
	tk::EntryMouseSelect %W %x
	catch {%W icursor sel.last}
	}
	bind Entry <Shift-1> {
	set tk::Priv(selectMode) char
	%W selection adjust @%x
	}
	bind Entry <Double-Shift-1> {
	set tk::Priv(selectMode) word
	tk::EntryMouseSelect %W %x
	}
	bind Entry <Triple-Shift-1> {
	set tk::Priv(selectMode) line
	tk::EntryMouseSelect %W %x
	}
	bind Entry <B1-Leave> {
	set tk::Priv(x) %x
	tk::EntryAutoScan %W
	}
	bind Entry <B1-Enter> {
	tk::CancelRepeat
	}
	bind Entry <ButtonRelease-1> {
	tk::CancelRepeat
	}
	bind Entry <Control-1> {
	%W icursor @%x
	}

	bind Entry <Left> {
	tk::EntrySetCursor %W [expr {[%W index insert] - 1}]
	}
	bind Entry <Right> {
	tk::EntrySetCursor %W [expr {[%W index insert] + 1}]
	}
	bind Entry <Shift-Left> {
	tk::EntryKeySelect %W [expr {[%W index insert] - 1}]
	tk::EntrySeeInsert %W
	}
	bind Entry <Shift-Right> {
	tk::EntryKeySelect %W [expr {[%W index insert] + 1}]
	tk::EntrySeeInsert %W
	}
	bind Entry <Control-Left> {
	tk::EntrySetCursor %W [tk::EntryPreviousWord %W insert]
	}
	bind Entry <Control-Right> {
	tk::EntrySetCursor %W [tk::EntryNextWord %W insert]
	}
	bind Entry <Shift-Control-Left> {
	tk::EntryKeySelect %W [tk::EntryPreviousWord %W insert]
	tk::EntrySeeInsert %W
	}
	bind Entry <Shift-Control-Right> {
	tk::EntryKeySelect %W [tk::EntryNextWord %W insert]
	tk::EntrySeeInsert %W
	}
	bind Entry <Home> {
	tk::EntrySetCursor %W 0
	}
	bind Entry <Shift-Home> {
	tk::EntryKeySelect %W 0
	tk::EntrySeeInsert %W
	}
	bind Entry <End> {
	tk::EntrySetCursor %W end
	}
	bind Entry <Shift-End> {
	tk::EntryKeySelect %W end
	tk::EntrySeeInsert %W
	}

	bind Entry <Delete> {
	if {[%W selection present]} {
	%W delete sel.first sel.last
	} else {
	%W delete insert
	}
	}
	bind Entry <BackSpace> {
	tk::EntryBackspace %W
	}

	bind Entry <Control-space> {
	%W selection from insert
	}
	bind Entry <Select> {
	%W selection from insert
	}
	bind Entry <Control-Shift-space> {
	%W selection adjust insert
	}
	bind Entry <Shift-Select> {
	%W selection adjust insert
	}
	bind Entry <Control-slash> {
	%W selection range 0 end
	}
	bind Entry <Control-backslash> {
	%W selection clear
	}
	bind Entry <KeyPress> {
	tk::EntryInsert %W %A
	}

	# Ignore all Alt, Meta, and Control keypresses unless explicitly bound.
	# Otherwise, if a widget binding for one of these is defined, the
	# <KeyPress> class binding will also fire and insert the character,
	# which is wrong. Ditto for Escape, Return, and Tab.

	bind Entry <Alt-KeyPress> {# nothing}
	bind Entry <Meta-KeyPress> {# nothing}
	bind Entry <Control-KeyPress> {# nothing}
	bind Entry <Escape> {# nothing}
	bind Entry <Return> {# nothing}
	bind Entry <KP_Enter> {# nothing}
	bind Entry <Tab> {# nothing}
	if {[string equal [tk windowingsystem] "classic"]
	\|\| [string equal [tk windowingsystem] "aqua"]} {
	bind Entry <Command-KeyPress> {# nothing}
	}

	# On Windows, paste is done using Shift-Insert. Shift-Insert already
	# generates the <<Paste>> event, so we don't need to do anything here.
	if {[string compare $tcl_platform(platform) "windows"]} {
	bind Entry <Insert> {
	catch {tk::EntryInsert %W [::tk::GetSelection %W PRIMARY]}
	}
	}

	# Additional emacs-like bindings:

	bind Entry <Control-a> {
	if {!$tk_strictMotif} {
	tk::EntrySetCursor %W 0
	}
	}
	bind Entry <Control-b> {
	if {!$tk_strictMotif} {
	tk::EntrySetCursor %W [expr {[%W index insert] - 1}]
	}
	}
	bind Entry <Control-d> {
	if {!$tk_strictMotif} {
	%W delete insert
	}
	}
	bind Entry <Control-e> {
	if {!$tk_strictMotif} {
	tk::EntrySetCursor %W end
	}
	}
	bind Entry <Control-f> {
	if {!$tk_strictMotif} {
	tk::EntrySetCursor %W [expr {[%W index insert] + 1}]
	}
	}
	bind Entry <Control-h> {
	if {!$tk_strictMotif} {
	tk::EntryBackspace %W
	}
	}
	bind Entry <Control-k> {
	if {!$tk_strictMotif} {
	%W delete insert end
	}
	}
	bind Entry <Control-t> {
	if {!$tk_strictMotif} {
	tk::EntryTranspose %W
	}
	}
	bind Entry <Meta-b> {
	if {!$tk_strictMotif} {
	tk::EntrySetCursor %W [tk::EntryPreviousWord %W insert]
	}
	}
	bind Entry <Meta-d> {
	if {!$tk_strictMotif} {
	%W delete insert [tk::EntryNextWord %W insert]
	}
	}
	bind Entry <Meta-f> {
	if {!$tk_strictMotif} {
	tk::EntrySetCursor %W [tk::EntryNextWord %W insert]
	}
	}
	bind Entry <Meta-BackSpace> {
	if {!$tk_strictMotif} {
	%W delete [tk::EntryPreviousWord %W insert] insert
	}
	}
	bind Entry <Meta-Delete> {
	if {!$tk_strictMotif} {
	%W delete [tk::EntryPreviousWord %W insert] insert
	}
	}

	# A few additional bindings of my own.

	bind Entry <2> {
	if {!$tk_strictMotif} {
	::tk::EntryScanMark %W %x
	}
	}
	bind Entry <B2-Motion> {
	if {!$tk_strictMotif} {
	::tk::EntryScanDrag %W %x
	}
	}

	# ::tk::EntryClosestGap --
	# Given x and y coordinates, this procedure finds the closest boundary
	# between characters to the given coordinates and returns the index
	# of the character just after the boundary.
	#
	# Arguments:
	# w - The entry window.
	# x - X-coordinate within the window.

	proc ::tk::EntryClosestGap {w x} {
	set pos [$w index @$x]
	set bbox [$w bbox $pos]
	if {($x - [lindex $bbox 0]) < ([lindex $bbox 2]/2)} {
	return $pos
	}
	incr pos
	}

	# ::tk::EntryButton1 --
	# This procedure is invoked to handle button-1 presses in entry
	# widgets. It moves the insertion cursor, sets the selection anchor,
	# and claims the input focus.
	#
	# Arguments:
	# w - The entry window in which the button was pressed.
	# x - The x-coordinate of the button press.

	proc ::tk::EntryButton1 {w x} {
	variable ::tk::Priv

	set Priv(selectMode) char
	set Priv(mouseMoved) 0
	set Priv(pressX) $x
	$w icursor [EntryClosestGap $w $x]
	$w selection from insert
	if {[string compare "disabled" [$w cget -state]]} {focus $w}
	}

	# ::tk::EntryMouseSelect --
	# This procedure is invoked when dragging out a selection with
	# the mouse. Depending on the selection mode (character, word,
	# line) it selects in different-sized units. This procedure
	# ignores mouse motions initially until the mouse has moved from
	# one character to another or until there have been multiple clicks.
	#
	# Arguments:
	# w - The entry window in which the button was pressed.
	# x - The x-coordinate of the mouse.

	proc ::tk::EntryMouseSelect {w x} {
	variable ::tk::Priv

	set cur [EntryClosestGap $w $x]
	set anchor [$w index anchor]
	if {($cur != $anchor) \|\| (abs($Priv(pressX) - $x) >= 3)} {
	set Priv(mouseMoved) 1
	}
	switch $Priv(selectMode) {
	char {
	if {$Priv(mouseMoved)} {
	if {$cur < $anchor} {
	$w selection range $cur $anchor
	} elseif {$cur > $anchor} {
	$w selection range $anchor $cur
	} else {
	$w selection clear
	}
	}
	}
	word {
	if {$cur < [$w index anchor]} {
	set before [tcl_wordBreakBefore [$w get] $cur]
	set after [tcl_wordBreakAfter [$w get] [expr {$anchor-1}]]
	} else {
	set before [tcl_wordBreakBefore [$w get] $anchor]
	set after [tcl_wordBreakAfter [$w get] [expr {$cur - 1}]]
	}
	if {$before < 0} {
	set before 0
	}
	if {$after < 0} {
	set after end
	}
	$w selection range $before $after
	}
	line {
	$w selection range 0 end
	}
	}
	if {$Priv(mouseMoved)} {
	$w icursor $cur
	}
	update idletasks
	}

	# ::tk::EntryPaste --
	# This procedure sets the insertion cursor to the current mouse position,
	# pastes the selection there, and sets the focus to the window.
	#
	# Arguments:
	# w - The entry window.
	# x - X position of the mouse.

	proc ::tk::EntryPaste {w x} {
	$w icursor [EntryClosestGap $w $x]
	catch {$w insert insert [::tk::GetSelection $w PRIMARY]}
	if {[string compare "disabled" [$w cget -state]]} {focus $w}
	}

	# ::tk::EntryAutoScan --
	# This procedure is invoked when the mouse leaves an entry window
	# with button 1 down. It scrolls the window left or right,
	# depending on where the mouse is, and reschedules itself as an
	# "after" command so that the window continues to scroll until the
	# mouse moves back into the window or the mouse button is released.
	#
	# Arguments:
	# w - The entry window.

	proc ::tk::EntryAutoScan {w} {
	variable ::tk::Priv
	set x $Priv(x)
	if {![winfo exists $w]} return
	if {$x >= [winfo width $w]} {
	$w xview scroll 2 units
	EntryMouseSelect $w $x
	} elseif {$x < 0} {
	$w xview scroll -2 units
	EntryMouseSelect $w $x
	}
	set Priv(afterId) [after 50 [list tk::EntryAutoScan $w]]
	}

	# ::tk::EntryKeySelect --
	# This procedure is invoked when stroking out selections using the
	# keyboard. It moves the cursor to a new position, then extends
	# the selection to that position.
	#
	# Arguments:
	# w - The entry window.
	# new - A new position for the insertion cursor (the cursor hasn't
	# actually been moved to this position yet).

	proc ::tk::EntryKeySelect {w new} {
	if {![$w selection present]} {
	$w selection from insert
	$w selection to $new
	} else {
	$w selection adjust $new
	}
	$w icursor $new
	}

	# ::tk::EntryInsert --
	# Insert a string into an entry at the point of the insertion cursor.
	# If there is a selection in the entry, and it covers the point of the
	# insertion cursor, then delete the selection before inserting.
	#
	# Arguments:
	# w - The entry window in which to insert the string
	# s - The string to insert (usually just a single character)

	proc ::tk::EntryInsert {w s} {
	if {[string equal $s ""]} {
	return
	}
	catch {
	set insert [$w index insert]
	if {([$w index sel.first] <= $insert)
	&& ([$w index sel.last] >= $insert)} {
	$w delete sel.first sel.last
	}
	}
	$w insert insert $s
	EntrySeeInsert $w
	}

	# ::tk::EntryBackspace --
	# Backspace over the character just before the insertion cursor.
	# If backspacing would move the cursor off the left edge of the
	# window, reposition the cursor at about the middle of the window.
	#
	# Arguments:
	# w - The entry window in which to backspace.

	proc ::tk::EntryBackspace w {
	if {[$w selection present]} {
	$w delete sel.first sel.last
	} else {
	set x [expr {[$w index insert] - 1}]
	if {$x >= 0} {$w delete $x}
	if {[$w index @0] >= [$w index insert]} {
	set range [$w xview]
	set left [lindex $range 0]
	set right [lindex $range 1]
	$w xview moveto [expr {$left - ($right - $left)/2.0}]
	}
	}
	}

	# ::tk::EntrySeeInsert --
	# Make sure that the insertion cursor is visible in the entry window.
	# If not, adjust the view so that it is.
	#
	# Arguments:
	# w - The entry window.

	proc ::tk::EntrySeeInsert w {
	set c [$w index insert]
	if {($c < [$w index @0]) \|\| ($c > [$w index @[winfo width $w]])} {
	$w xview $c
	}
	}

	# ::tk::EntrySetCursor -
	# Move the insertion cursor to a given position in an entry. Also
	# clears the selection, if there is one in the entry, and makes sure
	# that the insertion cursor is visible.
	#
	# Arguments:
	# w - The entry window.
	# pos - The desired new position for the cursor in the window.

	proc ::tk::EntrySetCursor {w pos} {
	$w icursor $pos
	$w selection clear
	EntrySeeInsert $w
	}

	# ::tk::EntryTranspose -
	# This procedure implements the "transpose" function for entry widgets.
	# It tranposes the characters on either side of the insertion cursor,
	# unless the cursor is at the end of the line. In this case it
	# transposes the two characters to the left of the cursor. In either
	# case, the cursor ends up to the right of the transposed characters.
	#
	# Arguments:
	# w - The entry window.

	proc ::tk::EntryTranspose w {
	set i [$w index insert]
	if {$i < [$w index end]} {
	incr i
	}
	set first [expr {$i-2}]
	if {$first < 0} {
	return
	}
	set data [$w get]
	set new [string index $data [expr {$i-1}]][string index $data $first]
	$w delete $first $i
	$w insert insert $new
	EntrySeeInsert $w
	}

	# ::tk::EntryNextWord --
	# Returns the index of the next word position after a given position in the
	# entry. The next word is platform dependent and may be either the next
	# end-of-word position or the next start-of-word position after the next
	# end-of-word position.
	#
	# Arguments:
	# w - The entry window in which the cursor is to move.
	# start - Position at which to start search.

	if {[string equal $tcl_platform(platform) "windows"]} {
	proc ::tk::EntryNextWord {w start} {
	set pos [tcl_endOfWord [$w get] [$w index $start]]
	if {$pos >= 0} {
	set pos [tcl_startOfNextWord [$w get] $pos]
	}
	if {$pos < 0} {
	return end
	}
	return $pos
	}
	} else {
	proc ::tk::EntryNextWord {w start} {
	set pos [tcl_endOfWord [$w get] [$w index $start]]
	if {$pos < 0} {
	return end
	}
	return $pos
	}
	}

	# ::tk::EntryPreviousWord --
	#
	# Returns the index of the previous word position before a given
	# position in the entry.
	#
	# Arguments:
	# w - The entry window in which the cursor is to move.
	# start - Position at which to start search.

	proc ::tk::EntryPreviousWord {w start} {
	set pos [tcl_startOfPreviousWord [$w get] [$w index $start]]
	if {$pos < 0} {
	return 0
	}
	return $pos
	}

	# ::tk::EntryScanMark --
	#
	# Marks the start of a possible scan drag operation
	#
	# Arguments:
	# w - The entry window from which the text to get
	# x - x location on screen

	proc ::tk::EntryScanMark {w x} {
	$w scan mark $x
	set ::tk::Priv(x) $x
	set ::tk::Priv(y) 0 ; # not used
	set ::tk::Priv(mouseMoved) 0
	}

	# ::tk::EntryScanDrag --
	#
	# Marks the start of a possible scan drag operation
	#
	# Arguments:
	# w - The entry window from which the text to get
	# x - x location on screen

	proc ::tk::EntryScanDrag {w x} {
	# Make sure these exist, as some weird situations can trigger the
	# motion binding without the initial press. [Bug #220269]
	if {![info exists ::tk::Priv(x)]} { set ::tk::Priv(x) $x }
	# allow for a delta
	if {abs($x-$::tk::Priv(x)) > 2} {
	set ::tk::Priv(mouseMoved) 1
	}
	$w scan dragto $x
	}

	# ::tk::EntryGetSelection --
	#
	# Returns the selected text of the entry with respect to the -show option.
	#
	# Arguments:
	# w - The entry window from which the text to get

	proc ::tk::EntryGetSelection {w} {
	set entryString [string range [$w get] [$w index sel.first] \
	[expr {[$w index sel.last] - 1}]]
	if {[string compare [$w cget -show] ""]} {
	return [string repeat [string index [$w cget -show] 0] \
	[string length $entryString]]
	}
	return $entryString
	}