package require idle
}] } then {
    # Not supported / available...
    namespace eval ::idle {}
    proc ::idle::supported {} {return 0}
}






































# 8.4 doesn't provide this - we use it for i18n on menus.
if {[llength [info commands ::tk::AmpMenuArgs]] == 0} {
    proc ::tk::AmpMenuArgs {widget add type args} {
        set options {}
        foreach {opt val} $args {
            if {$opt eq "-label"} {
                lassign [UnderlineAmpersand $val] newlabel under

    ::http::register http 80 ::socket_inet4
}

namespace eval ::tkchat {
    variable chatWindowTitle "The Tcler's Chat"

    variable HEADUrl {http://tcllib.cvs.sourceforge.net/*checkout*/tcllib/tclapps/apps/tkchat/tkchat.tcl?revision=HEAD}
    variable rcsid   {$Id: tkchat.tcl,v 1.484 2011/05/16 17:14:28 patthoyts Exp $}

    variable MSGS
    set MSGS(entered) [list \
	    "%user% has entered the chat!" \
	    "Out of a cloud of smoke, %user% appears!" \
	    "%user% saunters in." \
	    "%user% wanders in." \

}

# Beep and/or deiconify and raise the main window as an idle callback.
# This is done as an idle callback because there might be many requests
# to alert in a row and we want to batch them all together into one
# action.
#
proc ::tkchat::alertWhenIdle {w nick msg} {
    variable alert_pending

    if { ![info exists alert_pending] } {
	set alert_pending 1
	if { $::Options(AutoBookmark) && $w eq ".txt" && [focus] == {} } {
	    .txt mark set AddBookmark "end - 1 line linestart"
	    BookmarkToggle auto
	}
        set top [winfo toplevel $w]
        set focused [expr {[llength [focus -displayof $top]] != 0}]
        after idle [list [namespace origin Hook] run \
                        alert $w $focused $nick $msg]
    }
}

proc ::tkchat::alertCallback {w focused nick msg} {
    global Options
    variable alert_pending

    set top [winfo toplevel $w]
    unset -nocomplain alert_pending
    if {$Options(Alert,RAISE) && !$focused} {
	# Only call this if the window doesn't already have focus




	wm deiconify $top
	raise $top
    }
    if {$Options(Alert,SOUND)} bell
}

# Check to see if an alert is desired for the given message.  Issue

    if { $nick ne $Options(Nickname) } {
	set subjectFound [checkSubject $w $msgtype $nick $msg]
	if { !$alert && $Options(Alert,SUBJECT) && $subjectFound } {
	    set alert 1
	}
    }
    if { $alert } {
	alertWhenIdle $w $nick $msg
    }
    set LastPost($nick) $now
    return $subjectFound
}

proc ::tkchat::checkSubject { w msgtype nick msg } {
    global Options

# Hooks:
#  message hooks are called before displaying a new message
#  preinit hooks are called after app initialization before gui creation
#  init hooks are called after gui creation before login
#  login hooks are called after login to the jabber server
#  join hooks are called after successfully joining a conference
#  alert hooks are called when the user should be notified offline
#  version hooks are called once we get the current version from the web
#  save hook are called when saving options to file.
#  options hooks are called to add pages to the Preferences dialog
proc ::tkchat::Hook {do type args} {
    switch -exact -- $type {
	message { set Hook [namespace current]::MessageHooks }
        preinit { set Hook [namespace current]::PreInitHooks }
        init    { set Hook [namespace current]::InitHooks }
        login   { set Hook [namespace current]::LoginHooks }
        join    { set Hook [namespace current]::JoinHooks }
        alert   { set Hook [namespace current]::AlertHooks }
        version { set Hook [namespace current]::VersionHooks }
        save    { set Hook [namespace current]::SaveHooks }
        options { set Hook [namespace current]::OptionsHooks }
	default {
	    return -code error "unknown hook type \"$type\":\
                must be message, preinit, init, login, join, alert,\
                version, options or save"
	}
    }
    switch -exact -- $do {
	add {
            if {[llength $args] > 2} {
                return -code error "wrong # args: should be \"add hook cmd ?priority?\""
            }

            }
        }
    }

    ## Help Menu
    ##
    set m .mbar.help
    if {[tk windowingsystem] == "aqua"} {
        proc ::tk::mac::ShowHelp {} {
            ::tkchat::Help
        }
    } else {
        tk::AmpMenuArgs $m add command -label [mc "&Quick Help..."] \
            -command [list [namespace origin Help]]
    }
    tk::AmpMenuArgs $m add command -label [mc "Help (&wiki)..."] \
        -command [list [namespace origin gotoURL] http://wiki.tcl.tk/tkchat]
    $m add separator
    tk::AmpMenuArgs $m add cascade -label [mc "Translate selection"] \
        -command [list [namespace origin babelfishMenu]]
    $m add separator
    tk::AmpMenuArgs $m add command -label [mc "&Check version"] \

        ${NS}::frame .txtframe -style FakeText
    } else {
        ${NS}::frame .txtframe
    }

    CreateTxtAndSbar

    # button-3 is the scrollwheel on Aqua -- button-2 is better for this
    if { [tk windowingsystem] eq "aqua"} {
        bind .txt <Button-2> [namespace code [list OnTextPopup %W %x %y]]
    } else {
        bind .txt <Button-3> [namespace code [list OnTextPopup %W %x %y]]
    }
    bind .txt <Button-1> [namespace code [list OnTextFocus %W]]

    # user display
    ScrolledWidget text .pane.names 0 1\
	    -background "#[getColor MainBG]" \
	    -foreground "#[getColor MainFG]" \
	    -relief sunken \

    bind .eMsg <Key-Up>		::tkchat::entryUp
    bind .eMsg <Key-Down>	::tkchat::entryDown
    bind .eMsg <Key-Tab>	{ ::tkchat::nickComplete ; break }
    bind .eMsg <Key-Prior>	{ .txt yview scroll -1 pages }
    bind .eMsg <Key-Next>	{ .txt yview scroll  1 pages }
    bind .eMsg <Shift-Key-Up>   { .txt yview scroll -1 units }
    bind .eMsg <Shift-Key-Down> { .txt yview scroll  1 units }
    # button-3 is the scrollwheel on Aqua -- button-2 is better for this
    if { [tk windowingsystem] eq "aqua"} {
        bind .eMsg <Button-2>   [namespace code [list OnEntryPopup %W %X %Y]]
    } else {
        bind .eMsg <Button-3>   [namespace code [list OnEntryPopup %W %X %Y]]
    }

    text .tMsg -height 6 -font FNT
    bind .tMsg <Key-Tab>	{ ::tkchat::nickComplete ; break }

    ${NS}::button .post -text [mc Post] -command [namespace code userPost]

    if {$useTile} {

    $w configure -cursor {}
}

proc ::tkchat::SetChatWindowBindings { parent jid } {

    set post [list ::tkchat::userPostOneToOne $parent $jid]

    # button-3 is the scrollwheel on Aqua -- button-2 is better for this
    if { [tk windowingsystem] eq "aqua"} {
        bind $parent.txt <Button-2> { ::tkchat::OnTextPopup %W %x %y }
    } else {
        bind $parent.txt <Button-3> { ::tkchat::OnTextPopup %W %x %y }
    }
    bind $parent.eMsg <Return>	  $post
    bind $parent.eMsg <KP_Enter>  $post
    $parent.post configure -command $post
    wm title $parent $::tkjabber::ChatWindows(title.$jid)
    wm protocol $parent WM_DELETE_WINDOW \
	    [list ::tkchat::DeleteChatWindow $parent $jid]
    bind $parent <FocusIn> \

    $w.text tag configure h1 -font {Sans -12 bold}
    if {[llength [info command ::tkchat::img::Tkchat]] != 0} {
	#$w.text image create end -image ::tkchat::img::Tkchat -name Icon -padx 20
    }
    $w.text insert end \
	"TkChat v$rcsVersion\n" title "$ver\n\n" {h1 center} \
	"$rcsid\n\n" center \
	[mc "Copyright (c) %s by following authors:" "2001-2011"] {} "\n\n" {}

    lappend txt "Bruce B Hartweg"       "<[email protected]>"
    lappend txt "Don Porter"		"<[email protected]>"
    lappend txt "Pat Thoyts"		"<[email protected]>"
    lappend txt "Jeff Hobbs"		"<[email protected]>"
    lappend txt "Ryan Casey"		"<[email protected]>"
    lappend txt "Reinhard Max"		"<[email protected]>"
    lappend txt "D. Richard Hipp"	"<[email protected]>"
    lappend txt "Kevin Kenny"		"<[email protected]>"
    lappend txt "Pascal Scheffers"	"<[email protected]>"
    lappend txt "Joe English"		"<[email protected]>"
    lappend txt "Joe Mistachkin"	"<[email protected]>"
    lappend txt "Donal K. Fellows"      "<[email protected]>"
    lappend txt "Daniel South"		"<[email protected]>"
    lappend txt "Steve Landers"		"<[email protected]>"
    lappend txt "Elchonon Edelson"	"<[email protected]>"
    lappend txt "Kevin Walzer"          "<[email protected]>"

    insertHelpText $w.text $txt

    grid $w -sticky news
    grid rowconfigure $dlg 0 -weight 1
    grid columnconfigure $dlg 0 -weight 1

proc ::tkchat::quit {} {
    global Options
    set a "yes"
    if {$Options(AskBeforeQuit)} {
        set q [mc "Are you sure you want to quit?"]
        set a [tk_messageBox -type yesno -default yes \
                   -title [mc "Tkchat confirm quit"] \
                   -message $q -icon info]
    }
    if { $a eq "yes" } {
        ::tkchat::saveRC
        exit
    }
}

	set OnlineUsers($network,hideMenu) 0
    }

    # Process command line args
    set nologin 0
    set tkonly $Options(UseTkOnly)
    while {[string match -* [set option [lindex $args 0]]]} {
        if {[tk windowingsystem] eq "aqua" && [string match -psn* $option]} {
            Pop args
            continue
        }
	switch -exact -- $option {
	    -nologin   { set nologin 1 }
	    -tkonly    { set tkonly 1 }
	    -style     { set Options(Style) [Pop args 1] }
	    -theme     { set Options(Theme) [Pop args 1] }
	    -loglevel  { set Options(LogLevel) [Pop args 1] }
	    -useragent { set Options(UserAgent) [Pop args 1] }

    SetTheme $Options(Theme)
    CreateGUI
    foreach idx [array names Options Visibility,*] {
	set tag [string range $idx 11 end]
	.txt tag configure $tag -elide $Options($idx)
    }

    Hook add alert [namespace origin alertCallback] 40
    Hook add message [namespace origin IncrMessageCounter] 40
    BookmarkInit

    Hook run init

    if {$Options(UseProxy)} {
	if {$Options(ProxyHost) != "" && $Options(ProxyPort) != ""} {
            # nothing

		.mb.mnu add command \
			-label $nick \
			-command [list ::tkchat::MsgTo $nick]
	    } else {
		.pane.names insert $mark "$nick\n" \
			[list NICK NICK-$nick URL-[incr ::URLID]]
	    }
            if {[tk windowingsystem] eq "aqua"} {
                .pane.names tag bind URL-$::URLID <Button-2> \
		    [list ::tkchat::OnNamePopup $nick $network %X %Y]
            } else {
                .pane.names tag bind URL-$::URLID <Button-3> \
		    [list ::tkchat::OnNamePopup $nick $network %X %Y]
            }
	    .pane.names tag bind URL-$::URLID <Control-Button-1> \
		    [list ::tkchat::OnNamePopup $nick $network %X %Y]
	}
	.pane.names insert end "\n"
    }
    .pane.names insert 1.0 "$total Users Online\n\n" TITLE
    .pane.names yview moveto [lindex $scrollview 0]

	set ChatWindows(title.$jid) "$from <$jid>"
	::tkchat::SetChatWindowBindings $ChatWindows(toplevel.$jid) $jid
    }

    if { [info exists ChatWindows(toplevel.$jid)] } {
	if { ![string match "$ChatWindows(toplevel.$jid)*" [focus]] } {
	    wm title $ChatWindows(toplevel.$jid) "* $ChatWindows(title.$jid)"
	    ::tkchat::alertWhenIdle $ChatWindows(txt.$jid) $from \
                "Chat message from $from <$jid>"
	}
    }

    if { [info exists ChatWindows(txt.$jid)] } {
	return $ChatWindows(txt.$jid)
    }

	    break
        }
    }
    set m [menu $dlg.popup -tearoff 0]
    $m add command -label [mc "Clear"] -command [list $f.txt delete 0.0 end]
    $m add command -label [mc "Eval in whiteboard"] \
        -command [list [namespace origin PasteEval] $dlg]
    if {[tk windowingsystem] eq "aqua"} {
        bind $f.txt <Button-2> [list tk_popup $m %X %Y]
    } else {
        bind $f.txt <Button-3> [list tk_popup $m %X %Y]
    }

    bind $dlg <Key-Escape> [list $cancel invoke]
    pack $f2.lbl -side left
    pack $subject -side right -fill x -expand 1
    pack $cancel $send -side right
    grid $f2    -     -sticky ew -pady 2
    grid $f.txt $f.vs -sticky news
    grid $f3    -     -sticky se

# MacOS X support
#
# Use the Growl notification system on Mac's to alert the user of new
# messages via popup message and dock icon change.

#if {[tk windowingsystem] ne "aqua"} { return }

package require msgcat

namespace eval ::tkchat::aqua {
    variable version 1.0.0
    namespace import ::msgcat::mc
}

proc ::tkchat::aqua::InitHook {} {
    variable growl [expr {![catch {package require tclgrowl}]}]
    variable tkdock [expr {![catch {package require tkdock}]}]

    if {$tkdock && [info exists starkit::topdir]} {
        variable Resources
        set MacOS [file dirname $starkit::topdir]
        set Resources [file dirname $MacOS]/Resources
        # tkdock sites under lib beside tkchat.kit in the app bundle
        lappend auto_path $MacOS/lib
        bind all <FocusIn> +::tkdock::origIcon
    }
    InitAlertMenu
}

proc ::tkchat::aqua::AlertHook {w raise nick msg} {
    global Options
    variable growl
    variable tkdock
    variable Resources
    if {$raise && $growl && $Options(Alert,GROWL)} {
        growl::message TkChat "Message from $nick" $msg
    }
    if {$tkdock} {
        ::tkdock::switchIcon $Resources/tkchat_warn.icns
    }
}

# Hook the messages. If a message arrives and we are not focused, the
# message counter is incremented and we ammend the dock icon here.
# PT: is this correct, resetting the origIcon on missed messages?
proc ::tkchat::aqua::MessageHook {nick msg msgtype args} {
    variable tkdock
    if {$tkdock && [focus] eq {} && $msgtype ne "TRAFFIC"} {
        ::tkdock::origIcon
    }
}

# Update the Alert menu with MacOS specific entries
proc ::tkchat::aqua::InitAlertMenu {} {
    global Options
    variable growl
    variable menuDone
    if {[info exists menuDone]} { return }
    if {!$growl} { return }
    if {![winfo exists .mbar.alert]} { return }

    # Insert our items just before the final separator (or append)
    set end [.mbar.alert index end]
    for {set ndx $end} {$ndx >= 0} {incr ndx -1} {
        if {[.mbar.alert type $ndx] eq "separator"} { break }
    }
    if {$ndx < 0} {set ndx end}
    
    # If growl is unavailable then disable the menu item.
    set state "disabled"
    if {$growl && [growl::available]} {
        set state "normal"
    }

    foreach {tag text state} [list \
                            GROWL "&Use Growl for alerts" $state \
                            BOUNCE "Bou&nce icon on alert" normal] {
        foreach {label charindex} [tk::UnderlineAmpersand $text] break
	.mbar.alert insert $ndx checkbutton \
            -label [mc $label] -underline $charindex \
            -variable Options(Alert,$tag) \
            -onvalue 1 -offvalue 0 -state $state
        incr ndx
    }
    set menuDone 1
}

# -------------------------------------------------------------------------
::tkchat::Hook add init ::tkchat::aqua::InitHook
::tkchat::Hook add alert ::tkchat::aqua::AlertHook
::tkchat::Hook add message ::tkchat::aqua::MessageHook
package provide tkchat::aqua $::tkchat::aqua::version
# -------------------------------------------------------------------------