text: # entry.tcl --
  #
  # This file defines the default bindings for Tk entry widgets and provides
  # procedures that help in implementing those bindings.
  #
  # RCS: @(#) $Id$
  #
  # 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 {[tk windowingsystem] ne "x11"} {
  	    catch {
  		%W delete sel.first sel.last
  	    }
  	}
  	%W insert insert [::tk::GetSelection %W CLIPBOARD]
  	tk::EntrySeeInsert %W
      }
  }
  bind Entry <<Clear>> {
      # ignore if there is no selection
      catch { %W delete sel.first sel.last }
  }
  bind Entry <<PasteSelection>> {
      if {$tk_strictMotif || ![info exists tk::Priv(mouseMoved)]
  	|| !$tk::Priv(mouseMoved)} {
  	tk::EntryPaste %W %x
      }
  }
  
  bind Entry <<TraverseIn>> {
      %W selection range 0 end 
      %W icursor end 
  }
  
  # 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::CancelRepeat
      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 {[tk windowingsystem] eq "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 {$tcl_platform(platform) ne "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 {"disabled" ne [$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 {"disabled" ne [$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 {$s eq ""} {
  	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 {$tcl_platform(platform) eq "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 {[$w cget -show] ne ""} {
  	return [string repeat [string index [$w cget -show] 0] \
  		[string length $entryString]]
      }
      return $entryString
  }
  