SR Technology WTK Repo
Check-in [e2ff912839]
Not logged in
Bounty program for improvements to Tcl and certain Tcl packages.
Tcl 2019 Conference, Houston/TX, US, Nov 4-8
Send your abstracts to [email protected]
or submit via the online form by Sep 9.

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Added stubs for most commands.
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1: e2ff9128392507a05647bcd30a5a62d09b256546
User & Date: gerald 2013-01-18 19:25:40
Context
2013-01-18
20:27
enhanced WebSockets send proc to handle frames larger than 126 bytes check-in: dc0569b9cb user: stever tags: trunk
19:25
Added stubs for most commands. check-in: e2ff912839 user: gerald tags: trunk
16:01
decouple connection code so that WebSockets work without first requiring initial AJAX connection check-in: 02630ca04a user: stever tags: trunk
Changes
Hide Diffs Unified Diffs Ignore Whitespace Patch

Added commands/bell.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::bell {args} {
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET bell]  {bell not yet implemented}
}


Added commands/bindtags.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::bindtags {args} {
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET bindtags]  {bindtags not yet implemented}
}


Added commands/clipboard.tcl.




























>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
namespace eval ::wtk::clipboard:: {
    namespace ensemble create -subcommands {
        get
    clear
    add
    }
}

foreach file [glob [file join [file dirname [info script]] clipboard *.tcl]] {
    source $file
}


Added commands/clipboard/add.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::clipboard::add {window args} {
    return  -code error  -level 2  -errorcode [list CLIPBOARDNOTIMPYET add]  {clipboard subcommand "add" not yet implemented}
}


Added commands/clipboard/clear.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::clipboard::clear {window args} {
    return  -code error  -level 2  -errorcode [list CLIPBOARDNOTIMPYET clear]  {clipboard subcommand "clear" not yet implemented}
}


Added commands/clipboard/get.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::clipboard::get {window args} {
    return  -code error  -level 2  -errorcode [list CLIPBOARDNOTIMPYET get]  {clipboard subcommand "get" not yet implemented}
}


Added commands/console.tcl.


































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namespace eval ::wtk::console:: {
    namespace ensemble create -subcommands {
        
 eval
 hide
 show
 title

    }
}

foreach file [glob [file join [file dirname [info script]] console *.tcl]] {
    source $file
}


Added commands/console/eval.tcl.










>
>
>
>
>
1
2
3
4
5

proc ::wtk::console::eval {args} {
    return  -code error  -level 2  -errorcode [list CONSOLENOTIMPYET eval]  {console subcommand "eval" not yet implemented}
}

Added commands/console/hide.tcl.










>
>
>
>
>
1
2
3
4
5

proc ::wtk::console::hide {} {
    return  -code error  -level 2  -errorcode [list CONSOLENOTIMPYET hide]  {console subcommand "hide" not yet implemented}
}

Added commands/console/show.tcl.












>
>
>
>
>
>
1
2
3
4
5
6

proc ::wtk::console::show {} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list CONSOLENOTIMPYET show]  {console subcommand "show" not yet implemented}
}

Added commands/console/title.tcl.










>
>
>
>
>
1
2
3
4
5

proc ::wtk::console::title {args} {
    return  -code error  -level 2  -errorcode [list CONSOLENOTIMPYET title]  {console subcommand "title" not yet implemented}
}

Added commands/destroy.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::destroy {args} {
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET destroy]  {destroy not yet implemented}
}


Added commands/event.tcl.






























>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
namespace eval ::wtk::event:: {
    namespace ensemble create -subcommands {
        get
    delete
    generate
    info
    }
}

foreach file [glob [file join [file dirname [info script]] event *.tcl]] {
    source $file
}


Added commands/event/delete.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::event::delete {window args} {
    return  -code error  -level 2  -errorcode [list EVENTNOTIMPYET delete]  {event subcommand "delete" not yet implemented}
}


Added commands/event/generate.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::event::generate {window args} {
    return  -code error  -level 2  -errorcode [list EVENTNOTIMPYET generate]  {event subcommand "generate" not yet implemented}
}


Added commands/event/get.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::event::get {window args} {
    return  -code error  -level 2  -errorcode [list EVENTNOTIMPYET get]  {event subcommand "get" not yet implemented}
}


Added commands/event/info.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::event::info {window args} {
    return  -code error  -level 2  -errorcode [list EVENTNOTIMPYET info]  {event subcommand "info" not yet implemented}
}


Added commands/focus.tcl.










>
>
>
>
>
1
2
3
4
5

proc ::wtk::focus {args} {
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET focus]  {focus not yet implemented}
}

Added commands/font.tcl.






































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
namespace eval ::wtk::font:: {
    namespace ensemble create -subcommands {
        actual
    configure
    create
    delete
    families
    measure
    metrics
    names
    }
}

foreach file [glob [file join [file dirname [info script]] font *.tcl]] {
    source $file
}


Added commands/font/actual.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::font::actual {window args} {
    return  -code error  -level 2  -errorcode [list FONTNOTIMPYET actual]  {font subcommand "actual" not yet implemented}
}


Added commands/font/configure.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::font::configure {window args} {
    return  -code error  -level 2  -errorcode [list FONTNOTIMPYET configure]  {font subcommand "configure" not yet implemented}
}


Added commands/font/create.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::font::create {window args} {
    return  -code error  -level 2  -errorcode [list FONTNOTIMPYET create]  {font subcommand "create" not yet implemented}
}


Added commands/font/delete.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::font::delete {window args} {
    return  -code error  -level 2  -errorcode [list FONTNOTIMPYET delete]  {font subcommand "delete" not yet implemented}
}


Added commands/font/families.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::font::families {window args} {
    return  -code error  -level 2  -errorcode [list FONTNOTIMPYET families]  {font subcommand "families" not yet implemented}
}


Added commands/font/measure.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::font::measure {window args} {
    return  -code error  -level 2  -errorcode [list FONTNOTIMPYET measure]  {font subcommand "measure" not yet implemented}
}


Added commands/font/metrics.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::font::metrics {window args} {
    return  -code error  -level 2  -errorcode [list FONTNOTIMPYET metrics]  {font subcommand "metrics" not yet implemented}
}


Added commands/font/names.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::font::names {window args} {
    return  -code error  -level 2  -errorcode [list FONTNOTIMPYET names]  {font subcommand "names" not yet implemented}
}


Added commands/grab.tcl.






























>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
namespace eval ::wtk::grab:: {
    namespace ensemble create -subcommands {
        current
    release
    set
    status
    }
}

foreach file [glob [file join [file dirname [info script]] grab *.tcl]] {
    source $file
}


Added commands/grab/current.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::grab::current {window args} {
    return  -code error  -level 2  -errorcode [list GRABNOTIMPYET current]  {grab subcommand "current" not yet implemented}
}


Added commands/grab/release.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::grab::release {window args} {
    return  -code error  -level 2  -errorcode [list GRABNOTIMPYET release]  {grab subcommand "release" not yet implemented}
}


Added commands/grab/set.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::grab::set {window args} {
    return  -code error  -level 2  -errorcode [list GRABNOTIMPYET set]  {grab subcommand "set" not yet implemented}
}


Added commands/grab/status.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::grab::status {window args} {
    return  -code error  -level 2  -errorcode [list GRABNOTIMPYET status]  {grab subcommand "status" not yet implemented}
}


Added commands/image.tcl.






































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
namespace eval ::wtk::image:: {
    namespace ensemble create -subcommands {
        actual
    configure
    create
    delete
    families
    measure
    metrics
    names
    }
}

foreach file [glob [file join [file dirname [info script]] image *.tcl]] {
    source $file
}


Added commands/image/actual.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::image::actual {window args} {
    return  -code error  -level 2  -errorcode [list IMAGENOTIMPYET actual]  {image subcommand "actual" not yet implemented}
}


Added commands/image/configure.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::image::configure {window args} {
    return  -code error  -level 2  -errorcode [list IMAGENOTIMPYET configure]  {image subcommand "configure" not yet implemented}
}


Added commands/image/create.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::image::create {window args} {
    return  -code error  -level 2  -errorcode [list IMAGENOTIMPYET create]  {image subcommand "create" not yet implemented}
}


Added commands/image/delete.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::image::delete {window args} {
    return  -code error  -level 2  -errorcode [list IMAGENOTIMPYET delete]  {image subcommand "delete" not yet implemented}
}


Added commands/image/families.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::image::families {window args} {
    return  -code error  -level 2  -errorcode [list IMAGENOTIMPYET families]  {image subcommand "families" not yet implemented}
}


Added commands/image/measure.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::image::measure {window args} {
    return  -code error  -level 2  -errorcode [list IMAGENOTIMPYET measure]  {image subcommand "measure" not yet implemented}
}


Added commands/image/metrics.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::image::metrics {window args} {
    return  -code error  -level 2  -errorcode [list IMAGENOTIMPYET metrics]  {image subcommand "metrics" not yet implemented}
}


Added commands/image/names.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::image::names {window args} {
    return  -code error  -level 2  -errorcode [list IMAGENOTIMPYET names]  {image subcommand "names" not yet implemented}
}


Added commands/option.tcl.




























>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
namespace eval ::wtk::option:: {
    namespace ensemble create -subcommands {
        get add
    clear
    readfile
    }
}

foreach file [glob [file join [file dirname [info script]] option *.tcl]] {
    source $file
}


Added commands/option/add.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::option::add {window args} {
    return  -code error  -level 2  -errorcode [list OPTIONNOTIMPYET add]  {option subcommand "add" not yet implemented}
}


Added commands/option/clear.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::option::clear {window args} {
    return  -code error  -level 2  -errorcode [list OPTIONNOTIMPYET clear]  {option subcommand "clear" not yet implemented}
}


Added commands/option/get.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::option::get {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list OPTIONNOTIMPYET get]  {option subcommand "get" not yet implemented}
}


Added commands/option/readfile.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::option::readfile {window args} {
    return  -code error  -level 2  -errorcode [list OPTIONNOTIMPYET readfile]  {option subcommand "readfile" not yet implemented}
}


Added commands/selection.tcl.




























>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
namespace eval ::wtk::selection:: {
    namespace ensemble create -subcommands {
        clear
    get
    append
    }
}

foreach file [glob [file join [file dirname [info script]] selection *.tcl]] {
    source $file
}


Added commands/selection/append.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::selection::append {window args} {
    return  -code error  -level 2  -errorcode [list SELECTIONNOTIMPYET append]  {selection subcommand "append" not yet implemented}
}


Added commands/selection/clear.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::selection::clear {window args} {
    return  -code error  -level 2  -errorcode [list SELECTIONNOTIMPYET clear]  {selection subcommand "clear" not yet implemented}
}


Added commands/selection/get.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::selection::get {window args} {
    return  -code error  -level 2  -errorcode [list SELECTIONNOTIMPYET get]  {selection subcommand "get" not yet implemented}
}


Added commands/selection/handle.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::selection::handle {window args} {
    return  -code error  -level 2  -errorcode [list SELECTIONNOTIMPYET handle]  {selection subcommand "handle" not yet implemented}
}


Added commands/selection/own.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::selection::own {window args} {
    return  -code error  -level 2  -errorcode [list SELECTIONNOTIMPYET own]  {selection subcommand "own" not yet implemented}
}


Added commands/send.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::send {args} {
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET send]  {send not yet implemented}
}


Added commands/tk.tcl.
































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
namespace eval ::wtk::tk:: {
    namespace ensemble create -subcommands {
        caret appname
    scaling
    inactive
    useinputmethods
    windowingsystem
    }
}

foreach file [glob [file join [file dirname [info script]] tk *.tcl]] {
    source $file
}


Added commands/tk/appname.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tk::appname {window args} {
    return  -code error  -level 2  -errorcode [list TKNOTIMPYET appname]  {tk subcommand "appname" not yet implemented}
}


Added commands/tk/caret.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::tk::caret {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list TKNOTIMPYET caret]  {tk subcommand "caret" not yet implemented}
}


Added commands/tk/inactive.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tk::inactive {window args} {
    return  -code error  -level 2  -errorcode [list TKNOTIMPYET inactive]  {tk subcommand "inactive" not yet implemented}
}


Added commands/tk/scaling.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tk::scaling {window args} {
    return  -code error  -level 2  -errorcode [list TKNOTIMPYET scaling]  {tk subcommand "scaling" not yet implemented}
}


Added commands/tk/useinputmethods.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tk::useinputmethods {window args} {
    return  -code error  -level 2  -errorcode [list TKNOTIMPYET useinputmethods]  {tk subcommand "useinputmethods" not yet implemented}
}


Added commands/tk/windowingsystem.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tk::windowingsystem {window args} {
    return  -code error  -level 2  -errorcode [list TKNOTIMPYET windowingsystem]  {tk subcommand "windowingsystem" not yet implemented}
}


Added commands/tk_bisque.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tk_bisque {args} {
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET tk_bisque]  {tk_bisque not yet implemented}
}


Added commands/tk_chooseColor.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tk_chooseColor {args} {
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET tk_chooseColor]  {tk_chooseColor not yet implemented}
}


Added commands/tk_chooseDirectory.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tk_chooseDirectory {args} {
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET tk_chooseDirectory]  {tk_chooseDirectory not yet implemented}
}


Added commands/tk_dialog.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tk_dialog {args} {
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET tk_dialog]  {tk_dialog not yet implemented}
}


Added commands/tk_focusFollowsMouse.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tk_focusFollowsMouse {args} {
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET tk_focusFollowsMouse]  {tk_focusFollowsMouse not yet implemented}
}


Added commands/tk_focusNext.tcl.












>
>
>
>
>
>
1
2
3
4
5
6

proc ::wtk::tk_focusNext {window} {
    _VerifyWindowExists $window
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET tk_focusNext]  {tk_focusNext not yet implemented}
}

Added commands/tk_focusPrev.tcl.












>
>
>
>
>
>
1
2
3
4
5
6

proc ::wtk::tk_focusPrev {window} {
    _VerifyWindowExists $window
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET tk_focusPrev]  {tk_focusPrev not yet implemented}
}

Added commands/tk_getOpenFile.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tk_getOpenFile {args} {
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET tk_getOpenFile]  {tk_getOpenFile not yet implemented}
}


Added commands/tk_getSaveFile.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tk_getSaveFile {args} {
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET tk_getSaveFile]  {tk_getSaveFile not yet implemented}
}


Added commands/tk_messageBox.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tk_messageBox {args} {
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET tk_messageBox]  {tk_messageBox not yet implemented}
}


Added commands/tk_popup.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tk_popup {args} {
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET tk_popup]  {tk_popup not yet implemented}
}


Added commands/tk_setPalette.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tk_setPalette {args} {
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET tk_setPalette]  {tk_setPalette not yet implemented}
}


Added commands/tkerror.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tkerror {args} {
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET tkerror]  {tkerror not yet implemented}
}


Added commands/tkwait.tcl.
























>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
namespace eval ::wtk::tkwait:: {
    namespace ensemble create -subcommands {
        variable visibility window
    }
}

foreach file [glob [file join [file dirname [info script]] tkwait *.tcl]] {
    source $file
}


Added commands/tkwait/variable.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tkwait::variable {window args} {
    return  -code error  -level 2  -errorcode [list TKWAITNOTIMPYET variable]  {tkwait subcommand "variable" not yet implemented}
}


Added commands/tkwait/visibility.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tkwait::visibility {window args} {
    return  -code error  -level 2  -errorcode [list TKWAITNOTIMPYET visibility]  {tkwait subcommand "visibility" not yet implemented}
}


Added commands/tkwait/window.tcl.














>
>
>
>
>
>
>
1
2
3
4
5
6
7

proc ::wtk::tkwait::window {window args} {
    return  -code error  -level 2  -errorcode [list TKWAITNOTIMPYET window]  {tkwait subcommand "window" not yet implemented}
}


Added commands/winfo.tcl.




























































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
namespace eval ::wtk::winfo:: {
    namespace ensemble create -subcommands {
        
        atom
        atomname
        cells
        children
        class
        colormapfull
        containing
        depth
        exists
        fpixels
        geometry
        height
        id
        interps
        ismapped
        manager
        name
        parent
        pathname
        pixels
        pointerx
        pointerxy
        pointery
        reqheight
        reqwidth
        rgb
        rootx
        rooty
        screen
        screencells
        screendepth
        screenheight
        screenmmheight
        screenmmwidth
        screenvisual
        screenwidth
        server
        toplevel
        viewable
        visual
        visualid
        visualsavailable
        vrootheight
        vrootwidth
        vrootx
        vrooty
        width
        x
        y

    }
}

foreach file [glob [file join [file dirname [info script]] winfo *.tcl]] {
    source $file
}


Added commands/winfo/atom.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::atom {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET atom]  {winfo subcommand "atom" not yet implemented}
}


Added commands/winfo/atomname.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::atomname {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET atomname]  {winfo subcommand "atomname" not yet implemented}
}


Added commands/winfo/cells.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::cells {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET cells]  {winfo subcommand "cells" not yet implemented}
}


Added commands/winfo/children.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::children {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET children]  {winfo subcommand "children" not yet implemented}
}


Added commands/winfo/class.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::class {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET class]  {winfo subcommand "class" not yet implemented}
}


Added commands/winfo/colormapfull.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::colormapfull {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET colormapfull]  {winfo subcommand "colormapfull" not yet implemented}
}


Added commands/winfo/containing.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::containing {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET containing]  {winfo subcommand "containing" not yet implemented}
}


Added commands/winfo/depth.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::depth {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET depth]  {winfo subcommand "depth" not yet implemented}
}


Added commands/winfo/exists.tcl.










>
>
>
>
>
1
2
3
4
5

proc ::wtk::winfo::exists {window args} {
    return  [info exists ::wtk::widgets($window}]
}

Added commands/winfo/fpixels.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::fpixels {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET fpixels]  {winfo subcommand "fpixels" not yet implemented}
}


Added commands/winfo/geometry.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::geometry {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET geometry]  {winfo subcommand "geometry" not yet implemented}
}


Added commands/winfo/height.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::height {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET height]  {winfo subcommand "height" not yet implemented}
}


Added commands/winfo/id.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::id {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET id]  {winfo subcommand "id" not yet implemented}
}


Added commands/winfo/interps.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::interps {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET interps]  {winfo subcommand "interps" not yet implemented}
}


Added commands/winfo/ismapped.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::ismapped {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET ismapped]  {winfo subcommand "ismapped" not yet implemented}
}


Added commands/winfo/manager.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::manager {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET manager]  {winfo subcommand "manager" not yet implemented}
}


Added commands/winfo/name.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::name {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET name]  {winfo subcommand "name" not yet implemented}
}


Added commands/winfo/parent.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::parent {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET parent]  {winfo subcommand "parent" not yet implemented}
}


Added commands/winfo/pathname.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::pathname {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET pathname]  {winfo subcommand "pathname" not yet implemented}
}


Added commands/winfo/pixels.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::pixels {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET pixels]  {winfo subcommand "pixels" not yet implemented}
}


Added commands/winfo/pointerx.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::pointerx {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET pointerx]  {winfo subcommand "pointerx" not yet implemented}
}


Added commands/winfo/pointerxy.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::pointerxy {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET pointerxy]  {winfo subcommand "pointerxy" not yet implemented}
}


Added commands/winfo/pointery.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::pointery {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET pointery]  {winfo subcommand "pointery" not yet implemented}
}


Added commands/winfo/reqheight.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::reqheight {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET reqheight]  {winfo subcommand "reqheight" not yet implemented}
}


Added commands/winfo/reqwidth.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::reqwidth {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET reqwidth]  {winfo subcommand "reqwidth" not yet implemented}
}


Added commands/winfo/rgb.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::rgb {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET rgb]  {winfo subcommand "rgb" not yet implemented}
}


Added commands/winfo/rootx.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::rootx {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET rootx]  {winfo subcommand "rootx" not yet implemented}
}


Added commands/winfo/rooty.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::rooty {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET rooty]  {winfo subcommand "rooty" not yet implemented}
}


Added commands/winfo/screen.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::screen {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET screen]  {winfo subcommand "screen" not yet implemented}
}


Added commands/winfo/screencells.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::screencells {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET screencells]  {winfo subcommand "screencells" not yet implemented}
}


Added commands/winfo/screendepth.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::screendepth {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET screendepth]  {winfo subcommand "screendepth" not yet implemented}
}


Added commands/winfo/screenheight.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::screenheight {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET screenheight]  {winfo subcommand "screenheight" not yet implemented}
}


Added commands/winfo/screenmmheight.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::screenmmheight {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET screenmmheight]  {winfo subcommand "screenmmheight" not yet implemented}
}


Added commands/winfo/screenmmwidth.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::screenmmwidth {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET screenmmwidth]  {winfo subcommand "screenmmwidth" not yet implemented}
}


Added commands/winfo/screenvisual.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::screenvisual {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET screenvisual]  {winfo subcommand "screenvisual" not yet implemented}
}


Added commands/winfo/screenwidth.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::screenwidth {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET screenwidth]  {winfo subcommand "screenwidth" not yet implemented}
}


Added commands/winfo/server.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::server {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET server]  {winfo subcommand "server" not yet implemented}
}


Added commands/winfo/toplevel.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::toplevel {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET toplevel]  {winfo subcommand "toplevel" not yet implemented}
}


Added commands/winfo/viewable.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::viewable {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET viewable]  {winfo subcommand "viewable" not yet implemented}
}


Added commands/winfo/visual.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::visual {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET visual]  {winfo subcommand "visual" not yet implemented}
}


Added commands/winfo/visualid.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::visualid {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET visualid]  {winfo subcommand "visualid" not yet implemented}
}


Added commands/winfo/visualsavailable.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::visualsavailable {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET visualsavailable]  {winfo subcommand "visualsavailable" not yet implemented}
}


Added commands/winfo/vrootheight.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::vrootheight {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET vrootheight]  {winfo subcommand "vrootheight" not yet implemented}
}


Added commands/winfo/vrootwidth.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::vrootwidth {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET vrootwidth]  {winfo subcommand "vrootwidth" not yet implemented}
}


Added commands/winfo/vrootx.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::vrootx {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET vrootx]  {winfo subcommand "vrootx" not yet implemented}
}


Added commands/winfo/vrooty.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::vrooty {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET vrooty]  {winfo subcommand "vrooty" not yet implemented}
}


Added commands/winfo/width.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::width {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET width]  {winfo subcommand "width" not yet implemented}
}


Added commands/winfo/x.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::x {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET x]  {winfo subcommand "x" not yet implemented}
}


Added commands/winfo/y.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::winfo::y {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list WINFONOTIMPYET y]  {winfo subcommand "y" not yet implemented}
}


Added commands/wm.tcl.
















































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
##
## This code implements the wm command and its subcommands.
##
namespace eval ::wtk::wm:: {
    namespace ensemble create -subcommands {
        aspect
        attributes
        client
        colormapwindows
        command
        deiconify
        focusmodel
        frame
        geometry
        grid
        group
        iconbitmap
        iconify
        iconmask
        iconname
        iconphoto
        iconposition
        iconwindow
        maxsize
        minsize
        overrideredirect
        positionfrom
        protocol
        resizable
        sizefrom
        stackorder
        state
        title
        transient
        withdraw
    }
}

proc ::wtk::wm::_VerifyWindowExists {window} {
    if {![info exists ::wtk::widgets($window}]} {
        return \
            -code error \
            -level 2 \
            [format {bad window path name "%1$s"} $window]
    } elseif {![string equal $window {.}]} {
        return \
            -code error \
            -level 2 \
            [format {window "%1$s" isn't a top-level window} $window]
    }
    return;
}

foreach file [glob [file join [file dirname [info script]] wm *.tcl]] {
    source $file
}

Added commands/wm/aspect.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::aspect {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET aspect]  {wm subcommand "aspect" not yet implemented}
}


Added commands/wm/attributes.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::attributes {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET attributes]  {wm subcommand "attributes" not yet implemented}
}


Added commands/wm/client.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::client {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET client]  {wm subcommand "client" not yet implemented}
}


Added commands/wm/colormapwindows.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::colormapwindows {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET colormapwindows]  {wm subcommand "colormapwindows" not yet implemented}
}


Added commands/wm/command.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::command {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET command]  {wm subcommand "command" not yet implemented}
}


Added commands/wm/deiconify.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::deiconify {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET deiconify]  {wm subcommand "deiconify" not yet implemented}
}


Added commands/wm/focusmodel.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::focusmodel {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET focusmodel]  {wm subcommand "focusmodel" not yet implemented}
}


Added commands/wm/frame.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::frame {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET frame]  {wm subcommand "frame" not yet implemented}
}


Added commands/wm/geometry.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::geometry {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET geometry]  {wm subcommand "geometry" not yet implemented}
}


Added commands/wm/grid.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::grid {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET grid]  {wm subcommand "grid" not yet implemented}
}


Added commands/wm/group.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::group {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET group]  {wm subcommand "group" not yet implemented}
}


Added commands/wm/iconbitmap.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::iconbitmap {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET iconbitmap]  {wm subcommand "iconbitmap" not yet implemented}
}


Added commands/wm/iconify.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::iconify {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET iconify]  {wm subcommand "iconify" not yet implemented}
}


Added commands/wm/iconmask.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::iconmask {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET iconmask]  {wm subcommand "iconmask" not yet implemented}
}


Added commands/wm/iconname.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::iconname {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET iconname]  {wm subcommand "iconname" not yet implemented}
}


Added commands/wm/iconphoto.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::iconphoto {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET iconphoto]  {wm subcommand "iconphoto" not yet implemented}
}


Added commands/wm/iconposition.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::iconposition {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET iconposition]  {wm subcommand "iconposition" not yet implemented}
}


Added commands/wm/iconwindow.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::iconwindow {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET iconwindow]  {wm subcommand "iconwindow" not yet implemented}
}


Added commands/wm/maxsize.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::maxsize {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET maxsize]  {wm subcommand "maxsize" not yet implemented}
}


Added commands/wm/minsize.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::minsize {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET minsize]  {wm subcommand "minsize" not yet implemented}
}


Added commands/wm/overrideredirect.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::overrideredirect {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET overrideredirect]  {wm subcommand "overrideredirect" not yet implemented}
}


Added commands/wm/positionfrom.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::positionfrom {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET positionfrom]  {wm subcommand "positionfrom" not yet implemented}
}


Added commands/wm/protocol.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::protocol {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET protocol]  {wm subcommand "protocol" not yet implemented}
}


Added commands/wm/resizable.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::resizable {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET resizable]  {wm subcommand "resizable" not yet implemented}
}


Added commands/wm/sizefrom.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::sizefrom {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET sizefrom]  {wm subcommand "sizefrom" not yet implemented}
}


Added commands/wm/stackorder.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::stackorder {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET stackorder]  {wm subcommand "stackorder" not yet implemented}
}


Added commands/wm/state.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::state {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET state]  {wm subcommand "state" not yet implemented}
}


Added commands/wm/title.tcl.


































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
proc ::wtk::wm::title {window args} {
    _VerifyWindowExists $window
    switch -exact -- [llength $args] {
        0 {

        }
        1 {
            toclient "document.title='[lindex $args 2]';"
        }
        default {
            return \
                -code error \
                {wrong # args: should be "wm title window ?newTitle?"}
        }
    }
    return;
}

Added commands/wm/transient.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::transient {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET transient]  {wm subcommand "transient" not yet implemented}
}


Added commands/wm/withdraw.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::wm::withdraw {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list wmNOTIMPYET withdraw]  {wm subcommand "withdraw" not yet implemented}
}


Added geomanagers/lower.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::lower {window} {
    _VerifyWindowExists $window
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET lower]  {lower not yet implemented}
}


Added geomanagers/pack.tcl.
































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
namespace eval ::wtk::pack:: {
    namespace ensemble create -subcommands {
        configure
     forget
     info
     propagate
     slaves
    }
}

foreach file [glob [file join [file dirname [info script]] pack *.tcl]] {
    source $file
}


Added geomanagers/pack/configure.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::pack::configure {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list PACKNOTIMPYET configure]  {pack subcommand "configure" not yet implemented}
}


Added geomanagers/pack/forget.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::pack::forget {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list PACKNOTIMPYET forget]  {pack subcommand "forget" not yet implemented}
}


Added geomanagers/pack/info.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::pack::info {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list PACKNOTIMPYET info]  {pack subcommand "info" not yet implemented}
}


Added geomanagers/pack/propagate.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::pack::propagate {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list PACKNOTIMPYET propagate]  {pack subcommand "propagate" not yet implemented}
}


Added geomanagers/pack/slaves.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::pack::slaves {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list PACKNOTIMPYET slaves]  {pack subcommand "slaves" not yet implemented}
}


Added geomanagers/place.tcl.






























>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
namespace eval ::wtk::place:: {
    namespace ensemble create -subcommands {
        configure
     forget
     info
     slaves
    }
}

foreach file [glob [file join [file dirname [info script]] place *.tcl]] {
    source $file
}


Added geomanagers/place/configure.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::place::configure {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list PLACENOTIMPYET configure]  {place subcommand "configure" not yet implemented}
}


Added geomanagers/place/forget.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::place::forget {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list PLACENOTIMPYET forget]  {place subcommand "forget" not yet implemented}
}


Added geomanagers/place/info.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::place::info {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list PLACENOTIMPYET info]  {place subcommand "info" not yet implemented}
}


Added geomanagers/place/slaves.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::place::slaves {window args} {
    _VerifyWindowExists $window
    return  -code error  -level 2  -errorcode [list PLACENOTIMPYET slaves]  {place subcommand "slaves" not yet implemented}
}


Added geomanagers/raise.tcl.
















>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8

proc ::wtk::raise {window} {
    _VerifyWindowExists $window
    return  -code error  -level 1  -errorcode [list WTKNOTIMPYET raise]  {raise not yet implemented}
}


Changes to lib/wtk-base.tcl.

6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
..
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
..
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114








115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133







134
135
#
# Communication with the client is solely via the "fromclient" and "toclient" routines
# (the latter of which is setup in the wtk::init call).

package require snit

namespace eval ::wtk {
    variable widgets 
    variable wobj
    variable _nextid -1
    variable _sender ""

    # Initialization and communication
    proc init {sender} {
        set wtk::_sender $sender
................................................................................
            set js [$wobj _createjs]
            append js $postcreatemsgs; set postcreatemsgs ""
            wtk::toclient $js
            set created 1
            return ""
        }
        method _sendWhenCreated {msg} {if {[$self _created?]} {wtk::toclient $msg} else {append postcreatemsgs $msg}}
        
        
        method id {} {return $id}
        method jqobj {} {return "\$('#[$self id]')"}
        method jsobj {} {return "wtk.widgets\['[$self id]'\]"}
        method _focus {} {toclient "[$self jsobj].focus();"}
    
        # text variable handling; only relevant if the main types delegate these options to us
        option -text -configuremethod _textchanged
        option -textvariable -configuremethod _textvarset
        method _textchanged {opt txt {fromwidget 0}} {
            set options($opt) $txt; 
            if {$created && !$fromwidget} {wtk::toclient [$wobj _textchangejs $txt]}
            if {$options(-textvariable)!=""} {uplevel #0 set $options(-textvariable) [list $txt]}
        }   
        method _textvariablechanged {args} {
            if {$options(-text) ne [uplevel #0 set $options(-textvariable)]} {
                $self _textchanged -text [uplevel #0 set $options(-textvariable)]
            }
        }
        method _setuptextvar {} {
            if {$options(-textvariable)!=""} {
................................................................................
                uplevel #0 trace add variable $options(-textvariable) write [list [list $self _textvariablechanged]]
            }
        }
        method _textvarset {opt var} {
            set options($opt) $var
            $self _setuptextvar
        }
        
        
        # TODO - variable handling; only relevant if -variable option is delegated to us
        
        
        # bindings
        variable bindings
        method _bind {ev script} {set bindings($ev) $script}
        method _fireevent {ev subs} {if {[info exists bindings($ev)]} {uplevel #0 [string map $subs $bindings($ev)]}}
    }

    proc getwidget {id} {return $wtk::wobj($id)}

    proc wm {args} {if {[lindex $args 0]=="title" && [lindex $args 1]=="."} {toclient "document.title='[lindex $args 2]';"}; return ""; # placeholder}
    proc winfo {args} {; # placeholder}








    proc focus {w} {$w _focus; return ""}
    proc bind {w ev script} {return [$w _bind $ev $script]}

    # Macro that can be used to simplify the definition of any widget
    snit::macro _wtkwidget {args} {
        component W; delegate method * to W; set extrainits ""
        if {"-usetextvar" in $args} {delegate option -textvariable to W; delegate option -text to W; set extrainits {$W _setuptextvar}}
        constructor {args} "install W using Widget \$\{selfns\}::W \$self; \$self configurelist \$args; $extrainits"
    }

    
    # Macro used to define options which set their value and then send some Javascript command to the widget
    snit::macro _wtkoption {opt default msg} {
        option $opt -default $default -configuremethod _wtkoption$opt
        method _wtkoption$opt {opt val} "set options(\$opt) \$val; set JS \[\$self jsobj\]; set V \$val; \$self _sendWhenCreated \[subst [list $msg]\]"
    }
    
}








source widgets/wtk-widgets.tcl
source geomanagers/wtk-grid.tcl






|







 







|
|




|




|


|







 







|
|

|
|








|
|
>
>
>
>
>
>
>
>










|





|


>
>
>
>
>
>
>

<
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
..
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
..
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

#
# Communication with the client is solely via the "fromclient" and "toclient" routines
# (the latter of which is setup in the wtk::init call).

package require snit

namespace eval ::wtk {
    variable widgets
    variable wobj
    variable _nextid -1
    variable _sender ""

    # Initialization and communication
    proc init {sender} {
        set wtk::_sender $sender
................................................................................
            set js [$wobj _createjs]
            append js $postcreatemsgs; set postcreatemsgs ""
            wtk::toclient $js
            set created 1
            return ""
        }
        method _sendWhenCreated {msg} {if {[$self _created?]} {wtk::toclient $msg} else {append postcreatemsgs $msg}}


        method id {} {return $id}
        method jqobj {} {return "\$('#[$self id]')"}
        method jsobj {} {return "wtk.widgets\['[$self id]'\]"}
        method _focus {} {toclient "[$self jsobj].focus();"}

        # text variable handling; only relevant if the main types delegate these options to us
        option -text -configuremethod _textchanged
        option -textvariable -configuremethod _textvarset
        method _textchanged {opt txt {fromwidget 0}} {
            set options($opt) $txt;
            if {$created && !$fromwidget} {wtk::toclient [$wobj _textchangejs $txt]}
            if {$options(-textvariable)!=""} {uplevel #0 set $options(-textvariable) [list $txt]}
        }
        method _textvariablechanged {args} {
            if {$options(-text) ne [uplevel #0 set $options(-textvariable)]} {
                $self _textchanged -text [uplevel #0 set $options(-textvariable)]
            }
        }
        method _setuptextvar {} {
            if {$options(-textvariable)!=""} {
................................................................................
                uplevel #0 trace add variable $options(-textvariable) write [list [list $self _textvariablechanged]]
            }
        }
        method _textvarset {opt var} {
            set options($opt) $var
            $self _setuptextvar
        }


        # TODO - variable handling; only relevant if -variable option is delegated to us


        # bindings
        variable bindings
        method _bind {ev script} {set bindings($ev) $script}
        method _fireevent {ev subs} {if {[info exists bindings($ev)]} {uplevel #0 [string map $subs $bindings($ev)]}}
    }

    proc getwidget {id} {return $wtk::wobj($id)}

    proc _VerifyWindowExists {window} {
        variable widgets
        if {![info exists ::wtk::widgets($window}]} {
            return \
                -code error \
                -level 2 \
                [format {bad window path name "%1$s"} $window]
        return;
    }

    proc focus {w} {$w _focus; return ""}
    proc bind {w ev script} {return [$w _bind $ev $script]}

    # Macro that can be used to simplify the definition of any widget
    snit::macro _wtkwidget {args} {
        component W; delegate method * to W; set extrainits ""
        if {"-usetextvar" in $args} {delegate option -textvariable to W; delegate option -text to W; set extrainits {$W _setuptextvar}}
        constructor {args} "install W using Widget \$\{selfns\}::W \$self; \$self configurelist \$args; $extrainits"
    }


    # Macro used to define options which set their value and then send some Javascript command to the widget
    snit::macro _wtkoption {opt default msg} {
        option $opt -default $default -configuremethod _wtkoption$opt
        method _wtkoption$opt {opt val} "set options(\$opt) \$val; set JS \[\$self jsobj\]; set V \$val; \$self _sendWhenCreated \[subst [list $msg]\]"
    }

}


foreach file [glob commands/*.tcl] {
    source $file
}
foreach file [glob geomanagers/*.tcl] {
    source $file
}
source widgets/wtk-widgets.tcl