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

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

namespace eval ::wtk::clipboard:: {
    namespace ensemble create -subcommands {
        get
    clear
    add
    }
}

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

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

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

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

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
}

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

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

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

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

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

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
}

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

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

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

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

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

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
}

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

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

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

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

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

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

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

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

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
}

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

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

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

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

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
}

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

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

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

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

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

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

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

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

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
}

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

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

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

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

namespace eval ::wtk::selection:: {
    namespace ensemble create -subcommands {
        clear
    get
    append
    }
}

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

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

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

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

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

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

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

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
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

namespace eval ::wtk::tkwait:: {
    namespace ensemble create -subcommands {
        variable visibility window
    }
}

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

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

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

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

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
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

##
## 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
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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;
}

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

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

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

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
}

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

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

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

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

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

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
}

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

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

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

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

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

#
# 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

#
# 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