Spaces:
Running
Running
| # console.tcl -- | |
| # | |
| # This code constructs the console window for an application. It | |
| # can be used by non-unix systems that do not have built-in support | |
| # for shells. | |
| # | |
| # Copyright (c) 1995-1997 Sun Microsystems, Inc. | |
| # Copyright (c) 1998-2000 Ajuba Solutions. | |
| # Copyright (c) 2007-2008 Daniel A. Steffen <das@users.sourceforge.net> | |
| # | |
| # See the file "license.terms" for information on usage and redistribution | |
| # of this file, and for a DISCLAIMER OF ALL WARRANTIES. | |
| # | |
| # TODO: history - remember partially written command | |
| namespace eval ::tk::console { | |
| variable blinkTime 500 ; # msecs to blink braced range for | |
| variable blinkRange 1 ; # enable blinking of the entire braced range | |
| variable magicKeys 1 ; # enable brace matching and proc/var recognition | |
| variable maxLines 600 ; # maximum # of lines buffered in console | |
| variable showMatches 1 ; # show multiple expand matches | |
| variable useFontchooser [llength [info command ::tk::fontchooser]] | |
| variable inPlugin [info exists embed_args] | |
| variable defaultPrompt ; # default prompt if tcl_prompt1 isn't used | |
| if {$inPlugin} { | |
| set defaultPrompt {subst {[history nextid] % }} | |
| } else { | |
| set defaultPrompt {subst {([file tail [pwd]]) [history nextid] % }} | |
| } | |
| } | |
| # simple compat function for tkcon code added for this console | |
| interp alias {} EvalAttached {} consoleinterp eval | |
| # ::tk::ConsoleInit -- | |
| # This procedure constructs and configures the console windows. | |
| # | |
| # Arguments: | |
| # None. | |
| proc ::tk::ConsoleInit {} { | |
| if {![consoleinterp eval {set tcl_interactive}]} { | |
| wm withdraw . | |
| } | |
| if {[tk windowingsystem] eq "aqua"} { | |
| set mod "Cmd" | |
| } else { | |
| set mod "Ctrl" | |
| } | |
| if {[catch {menu .menubar} err]} { | |
| bgerror "INIT: $err" | |
| } | |
| AmpMenuArgs .menubar add cascade -label [mc &File] -menu .menubar.file | |
| AmpMenuArgs .menubar add cascade -label [mc &Edit] -menu .menubar.edit | |
| menu .menubar.file -tearoff 0 | |
| AmpMenuArgs .menubar.file add command -label [mc "&Source..."] \ | |
| -command {tk::ConsoleSource} | |
| AmpMenuArgs .menubar.file add command -label [mc "&Hide Console"] \ | |
| -command {wm withdraw .} | |
| AmpMenuArgs .menubar.file add command -label [mc "&Clear Console"] \ | |
| -command {.console delete 1.0 "promptEnd linestart"} | |
| if {[tk windowingsystem] ne "aqua"} { | |
| AmpMenuArgs .menubar.file add command -label [mc E&xit] -command {exit} | |
| } | |
| menu .menubar.edit -tearoff 0 | |
| AmpMenuArgs .menubar.edit add command -label [mc Cu&t] -accel "$mod+X"\ | |
| -command {event generate .console <<Cut>>} | |
| AmpMenuArgs .menubar.edit add command -label [mc &Copy] -accel "$mod+C"\ | |
| -command {event generate .console <<Copy>>} | |
| AmpMenuArgs .menubar.edit add command -label [mc P&aste] -accel "$mod+V"\ | |
| -command {event generate .console <<Paste>>} | |
| if {[tk windowingsystem] ne "win32"} { | |
| AmpMenuArgs .menubar.edit add command -label [mc Cl&ear] \ | |
| -command {event generate .console <<Clear>>} | |
| } else { | |
| AmpMenuArgs .menubar.edit add command -label [mc &Delete] \ | |
| -command {event generate .console <<Clear>>} -accel "Del" | |
| AmpMenuArgs .menubar add cascade -label [mc &Help] -menu .menubar.help | |
| menu .menubar.help -tearoff 0 | |
| AmpMenuArgs .menubar.help add command -label [mc &About...] \ | |
| -command tk::ConsoleAbout | |
| } | |
| AmpMenuArgs .menubar.edit add separator | |
| if {$::tk::console::useFontchooser} { | |
| if {[tk windowingsystem] eq "aqua"} { | |
| .menubar.edit add command -label tk_choose_font_marker | |
| set index [.menubar.edit index tk_choose_font_marker] | |
| .menubar.edit entryconfigure $index \ | |
| -label [mc "Show Fonts"]\ | |
| -accelerator "$mod-T"\ | |
| -command [list ::tk::console::FontchooserToggle] | |
| bind Console <<TkFontchooserVisibility>> \ | |
| [list ::tk::console::FontchooserVisibility $index] | |
| ::tk::console::FontchooserVisibility $index | |
| } else { | |
| AmpMenuArgs .menubar.edit add command -label [mc "&Font..."] \ | |
| -command [list ::tk::console::FontchooserToggle] | |
| } | |
| bind Console <FocusIn> [list ::tk::console::FontchooserFocus %W 1] | |
| bind Console <FocusOut> [list ::tk::console::FontchooserFocus %W 0] | |
| } | |
| AmpMenuArgs .menubar.edit add command -label [mc "&Increase Font Size"] \ | |
| -accel "$mod++" -command {event generate .console <<Console_FontSizeIncr>>} | |
| AmpMenuArgs .menubar.edit add command -label [mc "&Decrease Font Size"] \ | |
| -accel "$mod+-" -command {event generate .console <<Console_FontSizeDecr>>} | |
| AmpMenuArgs .menubar.edit add command -label [mc "Fit To Screen Width"] \ | |
| -command {event generate .console <<Console_FitScreenWidth>>} | |
| if {[tk windowingsystem] eq "aqua"} { | |
| .menubar add cascade -label [mc Window] -menu [menu .menubar.window] | |
| .menubar add cascade -label [mc Help] -menu [menu .menubar.help] | |
| } | |
| . configure -menu .menubar | |
| # See if we can find a better font than the TkFixedFont | |
| catch {font create TkConsoleFont {*}[font configure TkFixedFont]} | |
| set families [font families] | |
| switch -exact -- [tk windowingsystem] { | |
| aqua { set preferred {Monaco 10} } | |
| win32 { set preferred {ProFontWindows 8 Consolas 8} } | |
| default { set preferred {} } | |
| } | |
| foreach {family size} $preferred { | |
| if {$family in $families} { | |
| font configure TkConsoleFont -family $family -size $size | |
| break | |
| } | |
| } | |
| # Provide the right border for the text widget (platform dependent). | |
| ::ttk::style layout ConsoleFrame { | |
| Entry.field -sticky news -border 1 -children { | |
| ConsoleFrame.padding -sticky news | |
| } | |
| } | |
| ::ttk::frame .consoleframe -style ConsoleFrame | |
| set con [text .console -yscrollcommand [list .sb set] -setgrid true \ | |
| -borderwidth 0 -highlightthickness 0 -font TkConsoleFont] | |
| if {[tk windowingsystem] eq "aqua"} { | |
| scrollbar .sb -command [list $con yview] | |
| } else { | |
| ::ttk::scrollbar .sb -command [list $con yview] | |
| } | |
| pack .sb -in .consoleframe -fill both -side right -padx 1 -pady 1 | |
| pack $con -in .consoleframe -fill both -expand 1 -side left -padx 1 -pady 1 | |
| pack .consoleframe -fill both -expand 1 -side left | |
| ConsoleBind $con | |
| $con tag configure stderr -foreground red | |
| $con tag configure stdin -foreground blue | |
| $con tag configure prompt -foreground \#8F4433 | |
| $con tag configure proc -foreground \#008800 | |
| $con tag configure var -background \#FFC0D0 | |
| $con tag raise sel | |
| $con tag configure blink -background \#FFFF00 | |
| $con tag configure find -background \#FFFF00 | |
| focus $con | |
| # Avoid listing this console in [winfo interps] | |
| if {[info command ::send] eq "::send"} {rename ::send {}} | |
| wm protocol . WM_DELETE_WINDOW { wm withdraw . } | |
| wm title . [mc "Console"] | |
| flush stdout | |
| $con mark set output [$con index "end - 1 char"] | |
| tk::TextSetCursor $con end | |
| $con mark set promptEnd insert | |
| $con mark gravity promptEnd left | |
| # A variant of ConsolePrompt to avoid a 'puts' call | |
| set w $con | |
| set temp [$w index "end - 1 char"] | |
| $w mark set output end | |
| if {![consoleinterp eval "info exists tcl_prompt1"]} { | |
| set string [EvalAttached $::tk::console::defaultPrompt] | |
| $w insert output $string stdout | |
| } | |
| $w mark set output $temp | |
| ::tk::TextSetCursor $w end | |
| $w mark set promptEnd insert | |
| $w mark gravity promptEnd left | |
| if {[tk windowingsystem] ne "aqua"} { | |
| # Subtle work-around to erase the '% ' that tclMain.c prints out | |
| after idle [subst -nocommand { | |
| if {[$con get 1.0 output] eq "% "} { $con delete 1.0 output } | |
| }] | |
| } | |
| } | |
| # ::tk::ConsoleSource -- | |
| # | |
| # Prompts the user for a file to source in the main interpreter. | |
| # | |
| # Arguments: | |
| # None. | |
| proc ::tk::ConsoleSource {} { | |
| set filename [tk_getOpenFile -defaultextension .tcl -parent . \ | |
| -title [mc "Select a file to source"] \ | |
| -filetypes [list \ | |
| [list [mc "Tcl Scripts"] .tcl] \ | |
| [list [mc "All Files"] *]]] | |
| if {$filename ne ""} { | |
| set cmd [list source $filename] | |
| if {[catch {consoleinterp eval $cmd} result]} { | |
| ConsoleOutput stderr "$result\n" | |
| } | |
| } | |
| } | |
| # ::tk::ConsoleInvoke -- | |
| # Processes the command line input. If the command is complete it | |
| # is evaled in the main interpreter. Otherwise, the continuation | |
| # prompt is added and more input may be added. | |
| # | |
| # Arguments: | |
| # None. | |
| proc ::tk::ConsoleInvoke {args} { | |
| set ranges [.console tag ranges input] | |
| set cmd "" | |
| if {[llength $ranges]} { | |
| set pos 0 | |
| while {[lindex $ranges $pos] ne ""} { | |
| set start [lindex $ranges $pos] | |
| set end [lindex $ranges [incr pos]] | |
| append cmd [.console get $start $end] | |
| incr pos | |
| } | |
| } | |
| if {$cmd eq ""} { | |
| ConsolePrompt | |
| } elseif {[info complete $cmd]} { | |
| .console mark set output end | |
| .console tag delete input | |
| set result [consoleinterp record $cmd] | |
| if {$result ne ""} { | |
| puts $result | |
| } | |
| ConsoleHistory reset | |
| ConsolePrompt | |
| } else { | |
| ConsolePrompt partial | |
| } | |
| .console yview -pickplace insert | |
| } | |
| # ::tk::ConsoleHistory -- | |
| # This procedure implements command line history for the | |
| # console. In general is evals the history command in the | |
| # main interpreter to obtain the history. The variable | |
| # ::tk::HistNum is used to store the current location in the history. | |
| # | |
| # Arguments: | |
| # cmd - Which action to take: prev, next, reset. | |
| set ::tk::HistNum 1 | |
| proc ::tk::ConsoleHistory {cmd} { | |
| variable HistNum | |
| switch $cmd { | |
| prev { | |
| incr HistNum -1 | |
| if {$HistNum == 0} { | |
| set cmd {history event [expr {[history nextid] -1}]} | |
| } else { | |
| set cmd "history event $HistNum" | |
| } | |
| if {[catch {consoleinterp eval $cmd} cmd]} { | |
| incr HistNum | |
| return | |
| } | |
| .console delete promptEnd end | |
| .console insert promptEnd $cmd {input stdin} | |
| .console see end | |
| } | |
| next { | |
| incr HistNum | |
| if {$HistNum == 0} { | |
| set cmd {history event [expr {[history nextid] -1}]} | |
| } elseif {$HistNum > 0} { | |
| set cmd "" | |
| set HistNum 1 | |
| } else { | |
| set cmd "history event $HistNum" | |
| } | |
| if {$cmd ne ""} { | |
| catch {consoleinterp eval $cmd} cmd | |
| } | |
| .console delete promptEnd end | |
| .console insert promptEnd $cmd {input stdin} | |
| .console see end | |
| } | |
| reset { | |
| set HistNum 1 | |
| } | |
| } | |
| } | |
| # ::tk::ConsolePrompt -- | |
| # This procedure draws the prompt. If tcl_prompt1 or tcl_prompt2 | |
| # exists in the main interpreter it will be called to generate the | |
| # prompt. Otherwise, a hard coded default prompt is printed. | |
| # | |
| # Arguments: | |
| # partial - Flag to specify which prompt to print. | |
| proc ::tk::ConsolePrompt {{partial normal}} { | |
| set w .console | |
| if {$partial eq "normal"} { | |
| set temp [$w index "end - 1 char"] | |
| $w mark set output end | |
| if {[consoleinterp eval "info exists tcl_prompt1"]} { | |
| consoleinterp eval "eval \[set tcl_prompt1\]" | |
| } else { | |
| puts -nonewline [EvalAttached $::tk::console::defaultPrompt] | |
| } | |
| } else { | |
| set temp [$w index output] | |
| $w mark set output end | |
| if {[consoleinterp eval "info exists tcl_prompt2"]} { | |
| consoleinterp eval "eval \[set tcl_prompt2\]" | |
| } else { | |
| puts -nonewline "> " | |
| } | |
| } | |
| flush stdout | |
| $w mark set output $temp | |
| ::tk::TextSetCursor $w end | |
| $w mark set promptEnd insert | |
| $w mark gravity promptEnd left | |
| ::tk::console::ConstrainBuffer $w $::tk::console::maxLines | |
| $w see end | |
| } | |
| # Copy selected text from the console | |
| proc ::tk::console::Copy {w} { | |
| if {![catch {set data [$w get sel.first sel.last]}]} { | |
| clipboard clear -displayof $w | |
| clipboard append -displayof $w $data | |
| } | |
| } | |
| # Copies selected text. If the selection is within the current active edit | |
| # region then it will be cut, if not it is only copied. | |
| proc ::tk::console::Cut {w} { | |
| if {![catch {set data [$w get sel.first sel.last]}]} { | |
| clipboard clear -displayof $w | |
| clipboard append -displayof $w $data | |
| if {[$w compare sel.first >= output]} { | |
| $w delete sel.first sel.last | |
| } | |
| } | |
| } | |
| # Paste text from the clipboard | |
| proc ::tk::console::Paste {w} { | |
| catch { | |
| set clip [::tk::GetSelection $w CLIPBOARD] | |
| set list [split $clip \n\r] | |
| tk::ConsoleInsert $w [lindex $list 0] | |
| foreach x [lrange $list 1 end] { | |
| $w mark set insert {end - 1c} | |
| tk::ConsoleInsert $w "\n" | |
| tk::ConsoleInvoke | |
| tk::ConsoleInsert $w $x | |
| } | |
| } | |
| } | |
| # Fit TkConsoleFont to window width | |
| proc ::tk::console::FitScreenWidth {w} { | |
| set width [winfo screenwidth $w] | |
| set cwidth [$w cget -width] | |
| set s -50 | |
| set fit 0 | |
| array set fi [font configure TkConsoleFont] | |
| while {$s < 0} { | |
| set fi(-size) $s | |
| set f [font create {*}[array get fi]] | |
| set c [font measure $f "eM"] | |
| font delete $f | |
| if {$c * $cwidth < 1.667 * $width} { | |
| font configure TkConsoleFont -size $s | |
| break | |
| } | |
| incr s 2 | |
| } | |
| } | |
| # ::tk::ConsoleBind -- | |
| # This procedure first ensures that the default bindings for the Text | |
| # class have been defined. Then certain bindings are overridden for | |
| # the class. | |
| # | |
| # Arguments: | |
| # None. | |
| proc ::tk::ConsoleBind {w} { | |
| bindtags $w [list $w Console PostConsole [winfo toplevel $w] all] | |
| ## Get all Text bindings into Console | |
| foreach ev [bind Text] { | |
| bind Console $ev [bind Text $ev] | |
| } | |
| ## We really didn't want the newline insertion... | |
| bind Console <Control-Key-o> {} | |
| ## ...or any Control-v binding (would block <<Paste>>) | |
| bind Console <Control-Key-v> {} | |
| # For the moment, transpose isn't enabled until the console | |
| # gets and overhaul of how it handles input -- hobbs | |
| bind Console <Control-Key-t> {} | |
| # 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. | |
| bind Console <Alt-KeyPress> {# nothing } | |
| bind Console <Meta-KeyPress> {# nothing} | |
| bind Console <Control-KeyPress> {# nothing} | |
| foreach {ev key} { | |
| <<Console_NextImmediate>> <Control-Key-n> | |
| <<Console_PrevImmediate>> <Control-Key-p> | |
| <<Console_PrevSearch>> <Control-Key-r> | |
| <<Console_NextSearch>> <Control-Key-s> | |
| <<Console_Expand>> <Key-Tab> | |
| <<Console_Expand>> <Key-Escape> | |
| <<Console_ExpandFile>> <Control-Shift-Key-F> | |
| <<Console_ExpandProc>> <Control-Shift-Key-P> | |
| <<Console_ExpandVar>> <Control-Shift-Key-V> | |
| <<Console_Tab>> <Control-Key-i> | |
| <<Console_Tab>> <Meta-Key-i> | |
| <<Console_Eval>> <Key-Return> | |
| <<Console_Eval>> <Key-KP_Enter> | |
| <<Console_Clear>> <Control-Key-l> | |
| <<Console_KillLine>> <Control-Key-k> | |
| <<Console_Transpose>> <Control-Key-t> | |
| <<Console_ClearLine>> <Control-Key-u> | |
| <<Console_SaveCommand>> <Control-Key-z> | |
| <<Console_FontSizeIncr>> <Control-Key-plus> | |
| <<Console_FontSizeDecr>> <Control-Key-minus> | |
| } { | |
| event add $ev $key | |
| bind Console $key {} | |
| } | |
| if {[tk windowingsystem] eq "aqua"} { | |
| foreach {ev key} { | |
| <<Console_FontSizeIncr>> <Command-Key-plus> | |
| <<Console_FontSizeDecr>> <Command-Key-minus> | |
| } { | |
| event add $ev $key | |
| bind Console $key {} | |
| } | |
| if {$::tk::console::useFontchooser} { | |
| bind Console <Command-Key-t> [list ::tk::console::FontchooserToggle] | |
| } | |
| } | |
| bind Console <<Console_Expand>> { | |
| if {[%W compare insert > promptEnd]} { | |
| ::tk::console::Expand %W | |
| } | |
| } | |
| bind Console <<Console_ExpandFile>> { | |
| if {[%W compare insert > promptEnd]} { | |
| ::tk::console::Expand %W path | |
| } | |
| } | |
| bind Console <<Console_ExpandProc>> { | |
| if {[%W compare insert > promptEnd]} { | |
| ::tk::console::Expand %W proc | |
| } | |
| } | |
| bind Console <<Console_ExpandVar>> { | |
| if {[%W compare insert > promptEnd]} { | |
| ::tk::console::Expand %W var | |
| } | |
| } | |
| bind Console <<Console_Eval>> { | |
| %W mark set insert {end - 1c} | |
| tk::ConsoleInsert %W "\n" | |
| tk::ConsoleInvoke | |
| break | |
| } | |
| bind Console <Delete> { | |
| if {{} ne [%W tag nextrange sel 1.0 end] \ | |
| && [%W compare sel.first >= promptEnd]} { | |
| %W delete sel.first sel.last | |
| } elseif {[%W compare insert >= promptEnd]} { | |
| %W delete insert | |
| %W see insert | |
| } | |
| } | |
| bind Console <BackSpace> { | |
| if {{} ne [%W tag nextrange sel 1.0 end] \ | |
| && [%W compare sel.first >= promptEnd]} { | |
| %W delete sel.first sel.last | |
| } elseif {[%W compare insert != 1.0] && \ | |
| [%W compare insert > promptEnd]} { | |
| %W delete insert-1c | |
| %W see insert | |
| } | |
| } | |
| bind Console <Control-h> [bind Console <BackSpace>] | |
| bind Console <<LineStart>> { | |
| if {[%W compare insert < promptEnd]} { | |
| tk::TextSetCursor %W {insert linestart} | |
| } else { | |
| tk::TextSetCursor %W promptEnd | |
| } | |
| } | |
| bind Console <<LineEnd>> { | |
| tk::TextSetCursor %W {insert lineend} | |
| } | |
| bind Console <Control-d> { | |
| if {[%W compare insert < promptEnd]} { | |
| break | |
| } | |
| %W delete insert | |
| } | |
| bind Console <<Console_KillLine>> { | |
| if {[%W compare insert < promptEnd]} { | |
| break | |
| } | |
| if {[%W compare insert == {insert lineend}]} { | |
| %W delete insert | |
| } else { | |
| %W delete insert {insert lineend} | |
| } | |
| } | |
| bind Console <<Console_Clear>> { | |
| ## Clear console display | |
| %W delete 1.0 "promptEnd linestart" | |
| } | |
| bind Console <<Console_ClearLine>> { | |
| ## Clear command line (Unix shell staple) | |
| %W delete promptEnd end | |
| } | |
| bind Console <Meta-d> { | |
| if {[%W compare insert >= promptEnd]} { | |
| %W delete insert {insert wordend} | |
| } | |
| } | |
| bind Console <Meta-BackSpace> { | |
| if {[%W compare {insert -1c wordstart} >= promptEnd]} { | |
| %W delete {insert -1c wordstart} insert | |
| } | |
| } | |
| bind Console <Meta-d> { | |
| if {[%W compare insert >= promptEnd]} { | |
| %W delete insert {insert wordend} | |
| } | |
| } | |
| bind Console <Meta-BackSpace> { | |
| if {[%W compare {insert -1c wordstart} >= promptEnd]} { | |
| %W delete {insert -1c wordstart} insert | |
| } | |
| } | |
| bind Console <Meta-Delete> { | |
| if {[%W compare insert >= promptEnd]} { | |
| %W delete insert {insert wordend} | |
| } | |
| } | |
| bind Console <<PrevLine>> { | |
| tk::ConsoleHistory prev | |
| } | |
| bind Console <<NextLine>> { | |
| tk::ConsoleHistory next | |
| } | |
| bind Console <Insert> { | |
| catch {tk::ConsoleInsert %W [::tk::GetSelection %W PRIMARY]} | |
| } | |
| bind Console <KeyPress> { | |
| tk::ConsoleInsert %W %A | |
| } | |
| bind Console <F9> { | |
| eval destroy [winfo child .] | |
| source -encoding utf-8 [file join $tk_library console.tcl] | |
| } | |
| if {[tk windowingsystem] eq "aqua"} { | |
| bind Console <Command-q> { | |
| exit | |
| } | |
| } | |
| bind Console <<Cut>> { ::tk::console::Cut %W } | |
| bind Console <<Copy>> { ::tk::console::Copy %W } | |
| bind Console <<Paste>> { ::tk::console::Paste %W } | |
| bind Console <<Console_FontSizeIncr>> { | |
| set size [font configure TkConsoleFont -size] | |
| if {$size < 0} {set sign -1} else {set sign 1} | |
| set size [expr {(abs($size) + 1) * $sign}] | |
| font configure TkConsoleFont -size $size | |
| if {$::tk::console::useFontchooser} { | |
| tk fontchooser configure -font TkConsoleFont | |
| } | |
| } | |
| bind Console <<Console_FontSizeDecr>> { | |
| set size [font configure TkConsoleFont -size] | |
| if {abs($size) < 2} { return } | |
| if {$size < 0} {set sign -1} else {set sign 1} | |
| set size [expr {(abs($size) - 1) * $sign}] | |
| font configure TkConsoleFont -size $size | |
| if {$::tk::console::useFontchooser} { | |
| tk fontchooser configure -font TkConsoleFont | |
| } | |
| } | |
| bind Console <<Console_FitScreenWidth>> { | |
| ::tk::console::FitScreenWidth %W | |
| } | |
| ## | |
| ## Bindings for doing special things based on certain keys | |
| ## | |
| bind PostConsole <Key-parenright> { | |
| if {"\\" ne [%W get insert-2c]} { | |
| ::tk::console::MatchPair %W \( \) promptEnd | |
| } | |
| } | |
| bind PostConsole <Key-bracketright> { | |
| if {"\\" ne [%W get insert-2c]} { | |
| ::tk::console::MatchPair %W \[ \] promptEnd | |
| } | |
| } | |
| bind PostConsole <Key-braceright> { | |
| if {"\\" ne [%W get insert-2c]} { | |
| ::tk::console::MatchPair %W \{ \} promptEnd | |
| } | |
| } | |
| bind PostConsole <Key-quotedbl> { | |
| if {"\\" ne [%W get insert-2c]} { | |
| ::tk::console::MatchQuote %W promptEnd | |
| } | |
| } | |
| bind PostConsole <KeyPress> { | |
| if {"%A" ne ""} { | |
| ::tk::console::TagProc %W | |
| } | |
| } | |
| } | |
| # ::tk::ConsoleInsert -- | |
| # 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. Insertion | |
| # is restricted to the prompt area. | |
| # | |
| # Arguments: | |
| # w - The text window in which to insert the string | |
| # s - The string to insert (usually just a single character) | |
| proc ::tk::ConsoleInsert {w s} { | |
| if {$s eq ""} { | |
| return | |
| } | |
| catch { | |
| if {[$w compare sel.first <= insert] \ | |
| && [$w compare sel.last >= insert]} { | |
| $w tag remove sel sel.first promptEnd | |
| $w delete sel.first sel.last | |
| } | |
| } | |
| if {[$w compare insert < promptEnd]} { | |
| $w mark set insert end | |
| } | |
| $w insert insert $s {input stdin} | |
| $w see insert | |
| } | |
| # ::tk::ConsoleOutput -- | |
| # | |
| # This routine is called directly by ConsolePutsCmd to cause a string | |
| # to be displayed in the console. | |
| # | |
| # Arguments: | |
| # dest - The output tag to be used: either "stderr" or "stdout". | |
| # string - The string to be displayed. | |
| proc ::tk::ConsoleOutput {dest string} { | |
| set w .console | |
| $w insert output $string $dest | |
| ::tk::console::ConstrainBuffer $w $::tk::console::maxLines | |
| $w see insert | |
| } | |
| # ::tk::ConsoleExit -- | |
| # | |
| # This routine is called by ConsoleEventProc when the main window of | |
| # the application is destroyed. Don't call exit - that probably already | |
| # happened. Just delete our window. | |
| # | |
| # Arguments: | |
| # None. | |
| proc ::tk::ConsoleExit {} { | |
| destroy . | |
| } | |
| # ::tk::ConsoleAbout -- | |
| # | |
| # This routine displays an About box to show Tcl/Tk version info. | |
| # | |
| # Arguments: | |
| # None. | |
| proc ::tk::ConsoleAbout {} { | |
| tk_messageBox -type ok -message "[mc {Tcl for Windows}] | |
| Tcl $::tcl_patchLevel | |
| Tk $::tk_patchLevel" | |
| } | |
| # ::tk::console::Fontchooser* -- | |
| # Let the user select the console font (TIP 324). | |
| proc ::tk::console::FontchooserToggle {} { | |
| if {[tk fontchooser configure -visible]} { | |
| tk fontchooser hide | |
| } else { | |
| tk fontchooser show | |
| } | |
| } | |
| proc ::tk::console::FontchooserVisibility {index} { | |
| if {[tk fontchooser configure -visible]} { | |
| .menubar.edit entryconfigure $index -label [::tk::msgcat::mc "Hide Fonts"] | |
| } else { | |
| .menubar.edit entryconfigure $index -label [::tk::msgcat::mc "Show Fonts"] | |
| } | |
| } | |
| proc ::tk::console::FontchooserFocus {w isFocusIn} { | |
| if {$isFocusIn} { | |
| tk fontchooser configure -parent $w -font TkConsoleFont \ | |
| -command [namespace code [list FontchooserApply]] | |
| } else { | |
| tk fontchooser configure -parent $w -font {} -command {} | |
| } | |
| } | |
| proc ::tk::console::FontchooserApply {font args} { | |
| catch {font configure TkConsoleFont {*}[font actual $font]} | |
| } | |
| # ::tk::console::TagProc -- | |
| # | |
| # Tags a procedure in the console if it's recognized | |
| # This procedure is not perfect. However, making it perfect wastes | |
| # too much CPU time... | |
| # | |
| # Arguments: | |
| # w - console text widget | |
| proc ::tk::console::TagProc w { | |
| if {!$::tk::console::magicKeys} { | |
| return | |
| } | |
| set exp "\[^\\\\\]\[\[ \t\n\r\;{}\"\$\]" | |
| set i [$w search -backwards -regexp $exp insert-1c promptEnd-1c] | |
| if {$i eq ""} { | |
| set i promptEnd | |
| } else { | |
| append i +2c | |
| } | |
| regsub -all "\[\[\\\\\\?\\*\]" [$w get $i "insert-1c wordend"] {\\\0} c | |
| if {[llength [EvalAttached [list info commands $c]]]} { | |
| $w tag add proc $i "insert-1c wordend" | |
| } else { | |
| $w tag remove proc $i "insert-1c wordend" | |
| } | |
| if {[llength [EvalAttached [list info vars $c]]]} { | |
| $w tag add var $i "insert-1c wordend" | |
| } else { | |
| $w tag remove var $i "insert-1c wordend" | |
| } | |
| } | |
| # ::tk::console::MatchPair -- | |
| # | |
| # Blinks a matching pair of characters | |
| # c2 is assumed to be at the text index 'insert'. | |
| # This proc is really loopy and took me an hour to figure out given | |
| # all possible combinations with escaping except for escaped \'s. | |
| # It doesn't take into account possible commenting... Oh well. If | |
| # anyone has something better, I'd like to see/use it. This is really | |
| # only efficient for small contexts. | |
| # | |
| # Arguments: | |
| # w - console text widget | |
| # c1 - first char of pair | |
| # c2 - second char of pair | |
| # | |
| # Calls: ::tk::console::Blink | |
| proc ::tk::console::MatchPair {w c1 c2 {lim 1.0}} { | |
| if {!$::tk::console::magicKeys} { | |
| return | |
| } | |
| if {{} ne [set ix [$w search -back $c1 insert $lim]]} { | |
| while { | |
| [string match {\\} [$w get $ix-1c]] && | |
| [set ix [$w search -back $c1 $ix-1c $lim]] ne {} | |
| } {} | |
| set i1 insert-1c | |
| while {$ix ne {}} { | |
| set i0 $ix | |
| set j 0 | |
| while {[set i0 [$w search $c2 $i0 $i1]] ne {}} { | |
| append i0 +1c | |
| if {[string match {\\} [$w get $i0-2c]]} { | |
| continue | |
| } | |
| incr j | |
| } | |
| if {!$j} { | |
| break | |
| } | |
| set i1 $ix | |
| while {$j && [set ix [$w search -back $c1 $ix $lim]] ne {}} { | |
| if {[string match {\\} [$w get $ix-1c]]} { | |
| continue | |
| } | |
| incr j -1 | |
| } | |
| } | |
| if {[string match {} $ix]} { | |
| set ix [$w index $lim] | |
| } | |
| } else { | |
| set ix [$w index $lim] | |
| } | |
| if {$::tk::console::blinkRange} { | |
| Blink $w $ix [$w index insert] | |
| } else { | |
| Blink $w $ix $ix+1c [$w index insert-1c] [$w index insert] | |
| } | |
| } | |
| # ::tk::console::MatchQuote -- | |
| # | |
| # Blinks between matching quotes. | |
| # Blinks just the quote if it's unmatched, otherwise blinks quoted string | |
| # The quote to match is assumed to be at the text index 'insert'. | |
| # | |
| # Arguments: | |
| # w - console text widget | |
| # | |
| # Calls: ::tk::console::Blink | |
| proc ::tk::console::MatchQuote {w {lim 1.0}} { | |
| if {!$::tk::console::magicKeys} { | |
| return | |
| } | |
| set i insert-1c | |
| set j 0 | |
| while {[set i [$w search -back \" $i $lim]] ne {}} { | |
| if {[string match {\\} [$w get $i-1c]]} { | |
| continue | |
| } | |
| if {!$j} { | |
| set i0 $i | |
| } | |
| incr j | |
| } | |
| if {$j&1} { | |
| if {$::tk::console::blinkRange} { | |
| Blink $w $i0 [$w index insert] | |
| } else { | |
| Blink $w $i0 $i0+1c [$w index insert-1c] [$w index insert] | |
| } | |
| } else { | |
| Blink $w [$w index insert-1c] [$w index insert] | |
| } | |
| } | |
| # ::tk::console::Blink -- | |
| # | |
| # Blinks between n index pairs for a specified duration. | |
| # | |
| # Arguments: | |
| # w - console text widget | |
| # i1 - start index to blink region | |
| # i2 - end index of blink region | |
| # dur - duration in usecs to blink for | |
| # | |
| # Outputs: | |
| # blinks selected characters in $w | |
| proc ::tk::console::Blink {w args} { | |
| eval [list $w tag add blink] $args | |
| after $::tk::console::blinkTime [list $w] tag remove blink $args | |
| } | |
| # ::tk::console::ConstrainBuffer -- | |
| # | |
| # This limits the amount of data in the text widget | |
| # Called by Prompt and ConsoleOutput | |
| # | |
| # Arguments: | |
| # w - console text widget | |
| # size - # of lines to constrain to | |
| # | |
| # Outputs: | |
| # may delete data in console widget | |
| proc ::tk::console::ConstrainBuffer {w size} { | |
| if {[$w index end] > $size} { | |
| $w delete 1.0 [expr {int([$w index end])-$size}].0 | |
| } | |
| } | |
| # ::tk::console::Expand -- | |
| # | |
| # Arguments: | |
| # ARGS: w - text widget in which to expand str | |
| # type - type of expansion (path / proc / variable) | |
| # | |
| # Calls: ::tk::console::Expand(Pathname|Procname|Variable) | |
| # | |
| # Outputs: The string to match is expanded to the longest possible match. | |
| # If ::tk::console::showMatches is non-zero and the longest match | |
| # equaled the string to expand, then all possible matches are | |
| # output to stdout. Triggers bell if no matches are found. | |
| # | |
| # Returns: number of matches found | |
| proc ::tk::console::Expand {w {type ""}} { | |
| set exp "\[^\\\\\]\[\[ \t\n\r\\\{\"\\\\\$\]" | |
| set tmp [$w search -backwards -regexp $exp insert-1c promptEnd-1c] | |
| if {$tmp eq ""} { | |
| set tmp promptEnd | |
| } else { | |
| append tmp +2c | |
| } | |
| if {[$w compare $tmp >= insert]} { | |
| return | |
| } | |
| set str [$w get $tmp insert] | |
| switch -glob $type { | |
| path* { | |
| set res [ExpandPathname $str] | |
| } | |
| proc* { | |
| set res [ExpandProcname $str] | |
| } | |
| var* { | |
| set res [ExpandVariable $str] | |
| } | |
| default { | |
| set res {} | |
| foreach t {Pathname Procname Variable} { | |
| if {![catch {Expand$t $str} res] && ($res ne "")} { | |
| break | |
| } | |
| } | |
| } | |
| } | |
| set len [llength $res] | |
| if {$len} { | |
| set repl [lindex $res 0] | |
| $w delete $tmp insert | |
| $w insert $tmp $repl {input stdin} | |
| if {($len > 1) && ($::tk::console::showMatches) && ($repl eq $str)} { | |
| puts stdout [lsort [lreplace $res 0 0]] | |
| } | |
| } else { | |
| bell | |
| } | |
| return [incr len -1] | |
| } | |
| # ::tk::console::ExpandPathname -- | |
| # | |
| # Expand a file pathname based on $str | |
| # This is based on UNIX file name conventions | |
| # | |
| # Arguments: | |
| # str - partial file pathname to expand | |
| # | |
| # Calls: ::tk::console::ExpandBestMatch | |
| # | |
| # Returns: list containing longest unique match followed by all the | |
| # possible further matches | |
| proc ::tk::console::ExpandPathname str { | |
| set pwd [EvalAttached pwd] | |
| if {[catch {EvalAttached [list cd [file dirname $str]]} err opt]} { | |
| return -options $opt $err | |
| } | |
| set dir [file tail $str] | |
| ## Check to see if it was known to be a directory and keep the trailing | |
| ## slash if so (file tail cuts it off) | |
| if {[string match */ $str]} { | |
| append dir / | |
| } | |
| if {[catch {lsort [EvalAttached [list glob $dir*]]} m]} { | |
| set match {} | |
| } else { | |
| if {[llength $m] > 1} { | |
| if { $::tcl_platform(platform) eq "windows" } { | |
| ## Windows is screwy because it's case insensitive | |
| set tmp [ExpandBestMatch [string tolower $m] \ | |
| [string tolower $dir]] | |
| ## Don't change case if we haven't changed the word | |
| if {[string length $dir]==[string length $tmp]} { | |
| set tmp $dir | |
| } | |
| } else { | |
| set tmp [ExpandBestMatch $m $dir] | |
| } | |
| if {[string match ?*/* $str]} { | |
| set tmp [file dirname $str]/$tmp | |
| } elseif {[string match /* $str]} { | |
| set tmp /$tmp | |
| } | |
| regsub -all { } $tmp {\\ } tmp | |
| set match [linsert $m 0 $tmp] | |
| } else { | |
| ## This may look goofy, but it handles spaces in path names | |
| eval append match $m | |
| if {[file isdir $match]} { | |
| append match / | |
| } | |
| if {[string match ?*/* $str]} { | |
| set match [file dirname $str]/$match | |
| } elseif {[string match /* $str]} { | |
| set match /$match | |
| } | |
| regsub -all { } $match {\\ } match | |
| ## Why is this one needed and the ones below aren't!! | |
| set match [list $match] | |
| } | |
| } | |
| EvalAttached [list cd $pwd] | |
| return $match | |
| } | |
| # ::tk::console::ExpandProcname -- | |
| # | |
| # Expand a tcl proc name based on $str | |
| # | |
| # Arguments: | |
| # str - partial proc name to expand | |
| # | |
| # Calls: ::tk::console::ExpandBestMatch | |
| # | |
| # Returns: list containing longest unique match followed by all the | |
| # possible further matches | |
| proc ::tk::console::ExpandProcname str { | |
| set match [EvalAttached [list info commands $str*]] | |
| if {[llength $match] == 0} { | |
| set ns [EvalAttached \ | |
| "namespace children \[namespace current\] [list $str*]"] | |
| if {[llength $ns]==1} { | |
| set match [EvalAttached [list info commands ${ns}::*]] | |
| } else { | |
| set match $ns | |
| } | |
| } | |
| if {[llength $match] > 1} { | |
| regsub -all { } [ExpandBestMatch $match $str] {\\ } str | |
| set match [linsert $match 0 $str] | |
| } else { | |
| regsub -all { } $match {\\ } match | |
| } | |
| return $match | |
| } | |
| # ::tk::console::ExpandVariable -- | |
| # | |
| # Expand a tcl variable name based on $str | |
| # | |
| # Arguments: | |
| # str - partial tcl var name to expand | |
| # | |
| # Calls: ::tk::console::ExpandBestMatch | |
| # | |
| # Returns: list containing longest unique match followed by all the | |
| # possible further matches | |
| proc ::tk::console::ExpandVariable str { | |
| if {[regexp {([^\(]*)\((.*)} $str -> ary str]} { | |
| ## Looks like they're trying to expand an array. | |
| set match [EvalAttached [list array names $ary $str*]] | |
| if {[llength $match] > 1} { | |
| set vars $ary\([ExpandBestMatch $match $str] | |
| foreach var $match { | |
| lappend vars $ary\($var\) | |
| } | |
| return $vars | |
| } elseif {[llength $match] == 1} { | |
| set match $ary\($match\) | |
| } | |
| ## Space transformation avoided for array names. | |
| } else { | |
| set match [EvalAttached [list info vars $str*]] | |
| if {[llength $match] > 1} { | |
| regsub -all { } [ExpandBestMatch $match $str] {\\ } str | |
| set match [linsert $match 0 $str] | |
| } else { | |
| regsub -all { } $match {\\ } match | |
| } | |
| } | |
| return $match | |
| } | |
| # ::tk::console::ExpandBestMatch -- | |
| # | |
| # Finds the best unique match in a list of names. | |
| # The extra $e in this argument allows us to limit the innermost loop a little | |
| # further. This improves speed as $l becomes large or $e becomes long. | |
| # | |
| # Arguments: | |
| # l - list to find best unique match in | |
| # e - currently best known unique match | |
| # | |
| # Returns: longest unique match in the list | |
| proc ::tk::console::ExpandBestMatch {l {e {}}} { | |
| set ec [lindex $l 0] | |
| if {[llength $l]>1} { | |
| set e [expr {[string length $e] - 1}] | |
| set ei [expr {[string length $ec] - 1}] | |
| foreach l $l { | |
| while {$ei>=$e && [string first $ec $l]} { | |
| set ec [string range $ec 0 [incr ei -1]] | |
| } | |
| } | |
| } | |
| return $ec | |
| } | |
| # now initialize the console | |
| ::tk::ConsoleInit | |