# This file defines the default bindings for Tk text widgets and provides
# procedures that help in implementing the bindings.
# RCS: @(#) $Id: text.tcl,v 1.24.2.6 2005/05/13 13:48:21 vincentdarley Exp $
# Copyright (c) 1992-1994 The Regents of the University of California.
# Copyright (c) 1994-1997 Sun Microsystems, Inc.
# Copyright (c) 1998 by Scriptics Corporation.
# 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.
# char - Character position on the line; kept in order
# to allow moving up or down past short lines while
# still remembering the desired position.
# mouseMoved - Non-zero means the mouse has moved a significant
# amount since the button went down (so, for example,
# start dragging out a selection).
# prevPos - Used when moving up or down lines via the keyboard.
# Keeps track of the previous insert position, so
# we can distinguish a series of ups and downs, all
# in a row, from a new up or down.
# selectMode - The style of selection currently underway:
# x, y - Last known mouse coordinates for scanning
#-------------------------------------------------------------------------
#-------------------------------------------------------------------------
# The code below creates the default class bindings for text widgets.
#-------------------------------------------------------------------------
# Standard Motif bindings:
%W tag remove sel
0.0 end
tk::TextSelectTo %W
%x
%y
set tk::Priv(selectMode
) word
tk::TextSelectTo %W
%x
%y
catch {%W mark
set insert sel.last
}
set tk::Priv(selectMode
) line
tk::TextSelectTo %W
%x
%y
catch {%W mark
set insert sel.last
}
tk::TextResetAnchor %W
@%x
,%y
set tk::Priv(selectMode
) char
tk::TextSelectTo %W
%x
%y
bind Text
<Double-Shift-1
> {
set tk::Priv(selectMode
) word
tk::TextSelectTo %W
%x
%y
1
bind Text
<Triple-Shift-1
> {
set tk::Priv(selectMode
) line
tk::TextSelectTo %W
%x
%y
bind Text
<ButtonRelease-1
> {
%W mark
set insert
@%x
,%y
tk::TextSetCursor %W insert-1c
tk::TextSetCursor %W insert
+1c
tk::TextSetCursor %W
[tk::TextUpDownLine %W
-1]
tk::TextSetCursor %W
[tk::TextUpDownLine %W
1]
tk::TextKeySelect %W
[%W index
{insert
- 1c
}]
bind Text
<Shift-Right
> {
tk::TextKeySelect %W
[%W index
{insert
+ 1c
}]
tk::TextKeySelect %W
[tk::TextUpDownLine %W
-1]
tk::TextKeySelect %W
[tk::TextUpDownLine %W
1]
bind Text
<Control-Left
> {
tk::TextSetCursor %W
[tk::TextPrevPos %W insert
tcl_startOfPreviousWord]
bind Text
<Control-Right
> {
tk::TextSetCursor %W
[tk::TextNextWord %W insert
]
tk::TextSetCursor %W
[tk::TextPrevPara %W insert
]
bind Text
<Control-Down
> {
tk::TextSetCursor %W
[tk::TextNextPara %W insert
]
bind Text
<Shift-Control-Left
> {
tk::TextKeySelect %W
[tk::TextPrevPos %W insert
tcl_startOfPreviousWord]
bind Text
<Shift-Control-Right
> {
tk::TextKeySelect %W
[tk::TextNextWord %W insert
]
bind Text
<Shift-Control-Up
> {
tk::TextKeySelect %W
[tk::TextPrevPara %W insert
]
bind Text
<Shift-Control-Down
> {
tk::TextKeySelect %W
[tk::TextNextPara %W insert
]
tk::TextSetCursor %W
[tk::TextScrollPages %W
-1]
bind Text
<Shift-Prior
> {
tk::TextKeySelect %W
[tk::TextScrollPages %W
-1]
tk::TextSetCursor %W
[tk::TextScrollPages %W
1]
tk::TextKeySelect %W
[tk::TextScrollPages %W
1]
bind Text
<Control-Prior
> {
bind Text
<Control-Next
> {
tk::TextSetCursor %W
{insert linestart
}
tk::TextKeySelect %W
{insert linestart
}
tk::TextSetCursor %W
{insert lineend
}
tk::TextKeySelect %W
{insert lineend
}
bind Text
<Control-Home
> {
bind Text
<Control-Shift-Home
> {
bind Text
<Control-End
> {
tk::TextSetCursor %W
{end
- 1 char
}
bind Text
<Control-Shift-End
> {
tk::TextKeySelect %W
{end
- 1 char
}
if { [string equal
[%W cget
-state] "normal"] } {
# Needed only to keep <Tab> binding from triggering; doesn't
# have to actually do anything.
bind Text
<Control-Tab
> {
bind Text
<Control-Shift-Tab
> {
if {[%W cget
-autoseparators]} {%W edit separator
}
if {[%W tag nextrange sel
1.0 end
] ne
""} {
%W delete sel.first sel.last
if {[%W tag nextrange sel
1.0 end
] ne
""} {
%W delete sel.first sel.last
} elseif
{[%W compare insert
!= 1.0]} {
bind Text
<Control-space
> {
%W mark
set anchor insert
%W mark
set anchor insert
bind Text
<Control-Shift-space
> {
set tk::Priv(selectMode
) char
tk::TextKeyExtend %W insert
bind Text
<Shift-Select
> {
set tk::Priv(selectMode
) char
tk::TextKeyExtend %W insert
bind Text
<Control-slash
> {
bind Text
<Control-backslash
> {
%W tag remove sel
1.0 end
catch {%W delete sel.first sel.last
}
bind Text
<<PasteSelection
>> {
if {$tk_strictMotif ||
![info exists
tk::Priv(mouseMoved
)]
||
!$tk::Priv(mouseMoved
)} {
tk::TextPasteSelection %W
%x
%y
catch {tk::TextInsert %W
[::tk::GetSelection %W PRIMARY
]}
# 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>.
bind Text
<Alt-KeyPress
> {# nothing }
bind Text
<Meta-KeyPress
> {# nothing}
bind Text
<Control-KeyPress
> {# nothing}
bind Text
<Escape
> {# nothing}
bind Text
<KP_Enter
> {# nothing}
if {[string equal
[tk windowingsystem
] "classic"]
||
[string equal
[tk windowingsystem
] "aqua"]} {
bind Text
<Command-KeyPress
> {# nothing}
# Additional emacs-like bindings:
tk::TextSetCursor %W
{insert linestart
}
tk::TextSetCursor %W insert-1c
tk::TextSetCursor %W
{insert lineend
}
tk::TextSetCursor %W insert
+1c
if {[%W compare insert
== {insert lineend
}]} {
%W delete insert
{insert lineend
}
tk::TextSetCursor %W
[tk::TextUpDownLine %W
1]
%W mark
set insert insert-1c
tk::TextSetCursor %W
[tk::TextUpDownLine %W
-1]
if {$tcl_platform(platform
) ne
"windows"} {
tk::TextSetCursor %W
[tk::TextPrevPos %W insert
tcl_startOfPreviousWord]
%W delete insert
[tk::TextNextWord %W insert
]
tk::TextSetCursor %W
[tk::TextNextWord %W insert
]
bind Text
<Meta-greater
> {
tk::TextSetCursor %W end-1c
bind Text
<Meta-BackSpace
> {
%W delete
[tk::TextPrevPos %W insert
tcl_startOfPreviousWord] insert
bind Text
<Meta-Delete
> {
%W delete
[tk::TextPrevPos %W insert
tcl_startOfPreviousWord] insert
# Macintosh only bindings:
# if text black & highlight black -> text white, other text the same
if {[string equal
[tk windowingsystem
] "classic"]
||
[string equal
[tk windowingsystem
] "aqua"]} {
%W tag configure sel
-borderwidth 0
%W configure
-selectbackground systemHighlight
-selectforeground systemHighlightText
%W tag configure sel
-borderwidth 1
%W configure
-selectbackground white
-selectforeground black
bind Text
<Option-Left
> {
tk::TextSetCursor %W
[tk::TextPrevPos %W insert
tcl_startOfPreviousWord]
bind Text
<Option-Right
> {
tk::TextSetCursor %W
[tk::TextNextWord %W insert
]
tk::TextSetCursor %W
[tk::TextPrevPara %W insert
]
bind Text
<Option-Down
> {
tk::TextSetCursor %W
[tk::TextNextPara %W insert
]
bind Text
<Shift-Option-Left
> {
tk::TextKeySelect %W
[tk::TextPrevPos %W insert
tcl_startOfPreviousWord]
bind Text
<Shift-Option-Right
> {
tk::TextKeySelect %W
[tk::TextNextWord %W insert
]
bind Text
<Shift-Option-Up
> {
tk::TextKeySelect %W
[tk::TextPrevPara %W insert
]
bind Text
<Shift-Option-Down
> {
tk::TextKeySelect %W
[tk::TextNextPara %W insert
]
# End of Mac only bindings
# A few additional bindings of my own.
if {[%W compare insert
!= 1.0]} {
tk::TextScanMark %W
%x
%y
tk::TextScanDrag %W
%x
%y
set ::tk::Priv(prevPos
) {}
# The MouseWheel will typically only fire on Windows. However,
# someone could use the "event generate" command to produce one
if {[string equal
[tk windowingsystem
] "classic"]
||
[string equal
[tk windowingsystem
] "aqua"]} {
%W yview scroll
[expr {- (%D
)}] units
bind Text
<Option-MouseWheel
> {
%W yview scroll
[expr {-10 * (%D
)}] units
bind Text
<Shift-MouseWheel
> {
%W xview scroll
[expr {- (%D
)}] units
bind Text
<Shift-Option-MouseWheel
> {
%W xview scroll
[expr {-10 * (%D
)}] units
%W yview scroll
[expr {- (%D
/ 120) * 4}] units
if {[string equal
"x11" [tk windowingsystem
]]} {
# Support for mousewheels on Linux/Unix commonly comes through mapping
# the wheel to the extended buttons. If you have a mousewheel, find
# Linux configuration info at:
# http://www.inria.fr/koala/colas/mouse-wheel-scroll/
# ::tk::TextClosestGap --
# 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.
# x - X-coordinate within the window.
# y - Y-coordinate within the window.
proc ::tk::TextClosestGap {w x y
} {
set pos
[$w index
@$x,$y]
if {[string equal
$bbox ""]} {
if {($x - [lindex $bbox 0]) < ([lindex $bbox 2]/2)} {
# This procedure is invoked to handle button-1 presses in text
# widgets. It moves the insertion cursor, sets the selection anchor,
# and claims the input focus.
# w - The text window in which the button was pressed.
# x - The x-coordinate of the button press.
# y - The x-coordinate of the button press.
proc ::tk::TextButton1 {w x y
} {
set Priv
(selectMode
) char
$w mark
set insert
[TextClosestGap
$w $x $y]
$w mark
set anchor insert
# Allow focus in any case on Windows, because that will let the
# selection be displayed even for state disabled text widgets.
if {[string equal
$::tcl_platform(platform
) "windows"] \
||
[string equal
[$w cget
-state] "normal"]} {focus $w}
if {[$w cget
-autoseparators]} {$w edit separator
}
# This procedure is invoked to extend the selection, typically when
# dragging it 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.
# w - The text window in which the button was pressed.
proc ::tk::TextSelectTo {w x y
{extend
0}} {
set cur
[TextClosestGap
$w $x $y]
if {[catch {$w index anchor
}]} {
set anchor
[$w index anchor
]
if {[$w compare
$cur != $anchor] ||
(abs
($Priv(pressX
) - $x) >= 3)} {
switch $Priv(selectMode
) {
if {[$w compare
$cur < anchor
]} {
if {[$w compare
$cur < anchor
]} {
set first
[TextPrevPos
$w "$cur + 1c" tcl_wordBreakBefore]
set last
[TextNextPos
$w "anchor" tcl_wordBreakAfter]
set last
[TextNextPos
$w "$cur - 1c" tcl_wordBreakAfter]
set first
[TextPrevPos
$w anchor
tcl_wordBreakBefore]
if {[$w compare
$cur < anchor
]} {
set first
[$w index
"$cur linestart"]
set last
[$w index
"anchor - 1c lineend + 1c"]
set first
[$w index
"anchor linestart"]
set last
[$w index
"$cur lineend + 1c"]
if {$Priv(mouseMoved
) ||
$Priv(selectMode
) ne
"char"} {
$w tag remove sel
0.0 end
$w tag add sel
$first $last
$w tag remove sel
$last end
# This procedure handles extending the selection from the keyboard,
# where the point to extend to is really the boundary between two
# characters rather than a particular character.
# index - The point to which the selection is to be extended.
proc ::tk::TextKeyExtend {w index
} {
set cur
[$w index
$index]
if {[catch {$w index anchor
}]} {
set anchor
[$w index anchor
]
if {[$w compare
$cur < anchor
]} {
$w tag remove sel
0.0 $first
$w tag add sel
$first $last
$w tag remove sel
$last end
# ::tk::TextPasteSelection --
# This procedure sets the insertion cursor to the mouse position,
# inserts the selection, and sets the focus to the window.
# x, y - Position of the mouse.
proc ::tk::TextPasteSelection {w x y
} {
$w mark
set insert
[TextClosestGap
$w $x $y]
if {![catch {::tk::GetSelection $w PRIMARY
} sel
]} {
set oldSeparator
[$w cget
-autoseparators]
$w configure
-autoseparators 0
$w configure
-autoseparators 1
if {[string equal
[$w cget
-state] "normal"]} {focus $w}
# This procedure is invoked when the mouse leaves a text window
# with button 1 down. It scrolls the window up, down, left, or right,
# depending on where the mouse is (this information was saved in
# ::tk::Priv(x) and ::tk::Priv(y)), 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.
proc ::tk::TextAutoScan {w
} {
if {![winfo exists
$w]} return
if {$Priv(y
) >= [winfo height
$w]} {
} elseif
{$Priv(y
) < 0} {
} elseif
{$Priv(x
) >= [winfo width
$w]} {
} elseif
{$Priv(x
) < 0} {
TextSelectTo
$w $Priv(x
) $Priv(y
)
set Priv
(afterId
) [after 50 [list tk::TextAutoScan $w]]
# Move the insertion cursor to a given position in a text. Also
# clears the selection, if there is one in the text, and makes sure
# that the insertion cursor is visible. Also, don't let the insertion
# cursor appear on the dummy last line of the text.
# pos - The desired new position for the cursor in the window.
proc ::tk::TextSetCursor {w pos
} {
if {[$w compare
$pos == end
]} {
$w tag remove sel
1.0 end
if {[$w cget
-autoseparators]} {$w edit separator
}
# 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.
# new - A new position for the insertion cursor (the cursor hasn't
# actually been moved to this position yet).
proc ::tk::TextKeySelect {w new
} {
if {[string equal
[$w tag nextrange sel
1.0 end
] ""]} {
if {[$w compare
$new < insert
]} {
$w tag add sel
$new insert
$w tag add sel insert
$new
$w mark
set anchor insert
if {[$w compare
$new < anchor
]} {
$w tag remove sel
1.0 $first
$w tag add sel
$first $last
$w tag remove sel
$last end
# ::tk::TextResetAnchor --
# Set the selection anchor to whichever end is farthest from the
# index argument. One special trick: if the selection has two or
# fewer characters, just leave the anchor where it is. In this
# case it doesn't matter which point gets chosen for the anchor,
# and for the things like Shift-Left and Shift-Right this produces
# better behavior when the cursor moves back and forth across the
# index - Position at which mouse button was pressed, which determines
# which end of selection should be used as anchor point.
proc ::tk::TextResetAnchor {w index
} {
if {[string equal
[$w tag ranges sel
] ""]} {
# Don't move the anchor if there is no selection now; this makes
# the widget behave "correctly" when the user clicks once, then
# shift-clicks somewhere -- ie, the area between the two clicks will be
set b
[$w index sel.first
]
set c
[$w index sel.last
]
if {[$w compare
$a < $b]} {
$w mark
set anchor sel.last
if {[$w compare
$a > $c]} {
$w mark
set anchor sel.first
scan $a "%d.%d" lineA chA
scan $b "%d.%d" lineB chB
scan $c "%d.%d" lineC chC
set total
[string length
[$w get
$b $c]]
if {[string length
[$w get
$b $a]] < ($total/2)} {
$w mark
set anchor sel.last
$w mark
set anchor sel.first
if {($lineA-$lineB) < ($lineC-$lineA)} {
$w mark
set anchor sel.last
$w mark
set anchor sel.first
# Insert a string into a text at the point of the insertion cursor.
# If there is a selection in the text, and it covers the point of the
# insertion cursor, then delete the selection before inserting.
# w - The text window in which to insert the string
# s - The string to insert (usually just a single character)
proc ::tk::TextInsert {w s
} {
if {[string equal
$s ""] ||
[string equal
[$w cget
-state] "disabled"]} {
if {[$w compare sel.first
<= insert
] \
&& [$w compare sel.last
>= insert
]} {
set oldSeparator
[$w cget
-autoseparators]
$w configure
-autoseparators 0
$w delete sel.first sel.last
if { $compound && $oldSeparator } {
$w configure
-autoseparators 1
# ::tk::TextUpDownLine --
# Returns the index of the character one line above or below the
# insertion cursor. There are two tricky things here. First,
# we want to maintain the original column across repeated operations,
# even though some lines that will get passed through don't have
# enough characters to cover the original column. Second, don't
# try to scroll past the beginning or end of the text.
# w - The text window in which the cursor is to move.
# n - The number of lines to move: -1 for up one line,
proc ::tk::TextUpDownLine {w n
} {
scan $i "%d.%d" line char
if {$Priv(prevPos
) ne
$i} {
set new
[$w index
[expr {$line + $n}].
$Priv(char
)]
if {[$w compare
$new == end
] ||
[$w compare
$new == "insert linestart"]} {
# Returns the index of the beginning of the paragraph just before a given
# position in the text (the beginning of a paragraph is the first non-blank
# character after a blank line).
# w - The text window in which the cursor is to move.
# pos - Position at which to start search.
proc ::tk::TextPrevPara {w pos
} {
set pos
[$w index
"$pos linestart"]
if {([string equal
[$w get
"$pos - 1 line"] "\n"] \
&& [$w get
$pos] ne
"\n") ||
[string equal
$pos 1.0]} {
if {[regexp -indices {^
[ ]+(.
)} [$w get
$pos "$pos lineend"] \
set pos
[$w index
"$pos + [lindex $index 0] chars"]
if {[$w compare
$pos != insert
] ||
[lindex [split $pos .
] 0] == 1} {
set pos
[$w index
"$pos - 1 line"]
# Returns the index of the beginning of the paragraph just after a given
# position in the text (the beginning of a paragraph is the first non-blank
# character after a blank line).
# w - The text window in which the cursor is to move.
# start - Position at which to start search.
proc ::tk::TextNextPara {w start
} {
set pos
[$w index
"$start linestart + 1 line"]
while {[$w get
$pos] ne
"\n"} {
if {[$w compare
$pos == end
]} {
return [$w index
"end - 1c"]
set pos
[$w index
"$pos + 1 line"]
while {[$w get
$pos] eq
"\n"} {
set pos
[$w index
"$pos + 1 line"]
if {[$w compare
$pos == end
]} {
return [$w index
"end - 1c"]
if {[regexp -indices {^
[ ]+(.
)} [$w get
$pos "$pos lineend"] \
return [$w index
"$pos + [lindex $index 0] chars"]
# ::tk::TextScrollPages --
# This is a utility procedure used in bindings for moving up and down
# pages and possibly extending the selection along the way. It scrolls
# the view in the widget by the number of pages, and it returns the
# index of the character that is at the same position in the new view
# as the insertion cursor used to be in the old view.
# w - The text window in which the cursor is to move.
# count - Number of pages forward to scroll; may be negative
proc ::tk::TextScrollPages {w count
} {
set bbox
[$w bbox insert
]
$w yview scroll
$count pages
if {[string equal
$bbox ""]} {
return [$w index
@[expr {[winfo height
$w]/2}],0]
return [$w index
@[lindex $bbox 0],[lindex $bbox 1]]
# This procedure implements the "transpose" function for text 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.
# w - Text window in which to transpose.
proc ::tk::TextTranspose w
{
if {[$w compare
$pos != "$pos lineend"]} {
set pos
[$w index
"$pos + 1 char"]
set new
[$w get
"$pos - 1 char"][$w get
"$pos - 2 char"]
if {[$w compare
"$pos - 1 char" == 1.0]} {
# ensure this is seen as an atomic op to undo
set autosep
[$w cget
-autoseparators]
$w configure
-autoseparators 0
$w delete
"$pos - 2 char" $pos
$w configure
-autoseparators $autosep
# This procedure copies the selection from a text widget into the
# w - Name of a text widget.
if {![catch {set data
[$w get sel.first sel.last
]}]} {
clipboard clear
-displayof $w
clipboard append -displayof $w $data
# This procedure copies the selection from a text widget into the
# clipboard, then deletes the selection (if it exists in the given
# w - Name of a text widget.
if {![catch {set data
[$w get sel.first sel.last
]}]} {
clipboard clear
-displayof $w
clipboard append -displayof $w $data
$w delete sel.first sel.last
# This procedure pastes the contents of the clipboard to the insertion
# point in a text widget.
# w - Name of a text widget.
if {![catch {::tk::GetSelection $w CLIPBOARD
} sel
]} {
# ensure this is seen as an atomic op to undo
set oldSeparator
[$w cget
-autoseparators]
$w configure
-autoseparators 0
if {[tk windowingsystem
] ne
"x11"} {
catch { $w delete sel.first sel.last
}
$w configure
-autoseparators 1
# Returns the index of the next word position after a given position in the
# text. 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
# w - The text window in which the cursor is to move.
# start - Position at which to start search.
if {[string equal
$tcl_platform(platform
) "windows"]} {
proc ::tk::TextNextWord {w start
} {
TextNextPos
$w [TextNextPos
$w $start tcl_endOfWord] \
proc ::tk::TextNextWord {w start
} {
TextNextPos
$w $start tcl_endOfWord
# Returns the index of the next position after the given starting
# position in the text as computed by a specified function.
# w - The text window in which the cursor is to move.
# start - Position at which to start search.
# op - Function to use to find next position.
proc ::tk::TextNextPos {w start op
} {
while {[$w compare
$cur < end
]} {
set text $text[$w get
$cur "$cur lineend + 1c"]
## Adjust for embedded windows and images
## dump gives us 3 items per window/image
set dump
[$w dump
-image -window $start "$start + $pos c"]
set pos
[expr {$pos + ([llength $dump]/3)}]
return [$w index
"$start + $pos c"]
set cur
[$w index
"$cur lineend +1c"]
# Returns the index of the previous position before the given starting
# position in the text as computed by a specified function.
# w - The text window in which the cursor is to move.
# start - Position at which to start search.
# op - Function to use to find next position.
proc ::tk::TextPrevPos {w start op
} {
while {[$w compare
$cur > 0.0]} {
set text [$w get
"$cur linestart - 1c" $cur]$text
## Adjust for embedded windows and images
## dump gives us 3 items per window/image
set dump
[$w dump
-image -window "$cur linestart" "$start - 1c"]
## This is a hokey extra hack for control-arrow movement
## that should be in a while loop to be correct (hobbs)
if {[$w compare
[lindex $dump 2] > \
"$cur linestart - 1c + $pos c"]} {
set pos
[expr {$pos + ([llength $dump]/3)}]
return [$w index
"$cur linestart - 1c + $pos c"]
set cur
[$w index
"$cur linestart - 1c"]
# Marks the start of a possible scan drag operation
# w - The text window from which the text to get
# x - x location on screen
# y - y location on screen
proc ::tk::TextScanMark {w x y
} {
set ::tk::Priv(mouseMoved
) 0
# Marks the start of a possible scan drag operation
# w - The text window from which the text to get
# x - x location on screen
# y - y location on screen
proc ::tk::TextScanDrag {w x y
} {
# 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 }
if {![info exists
::tk::Priv(y
)]} { set ::tk::Priv(y
) $y }
if {($x != $::tk::Priv(x
)) ||
($y != $::tk::Priv(y
))} {
set ::tk::Priv(mouseMoved
) 1
if {[info exists
::tk::Priv(mouseMoved
)] && $::tk::Priv(mouseMoved
)} {