Pratt 1.5.6

data/pkgs/tile-0.8.2/library/menubutton.tcl

@@ -0,0 +1,171 @@
+#
+# menubutton.tcl,v 1.8 2006/08/20 19:40:39 jenglish Exp
+#
+# Bindings for Menubuttons.
+#
+# Menubuttons have three interaction modes:
+#
+# Pulldown: Press menubutton, drag over menu, release to activate menu entry
+# Popdown: Click menubutton to post menu
+# Keyboard: <Key-space> or accelerator key to post menu
+#
+# (In addition, when menu system is active, "dropdown" -- menu posts
+# on mouse-over.  Tile menubuttons don't implement this).
+#
+# For keyboard and popdown mode, we hand off to tk_popup and let 
+# the built-in Tk bindings handle the rest of the interaction.
+#
+# ON X11:
+#
+# Standard Tk menubuttons use a global grab on the menubutton.
+# This won't work for Tile menubuttons in pulldown mode,
+# since we need to process the final <ButtonRelease> event,
+# and this might be delivered to the menu.  So instead we
+# rely on the passive grab that occurs on <ButtonPress> events,
+# and transition to popdown mode when the mouse is released
+# or dragged outside the menubutton.
+# 
+# ON WINDOWS:
+#
+# I'm not sure what the hell is going on here.  [$menu post] apparently 
+# sets up some kind of internal grab for native menus.
+# On this platform, just use [tk_popup] for all menu actions.
+# 
+# ON MACOS:
+#
+# Same probably applies here.
+#
+
+namespace eval ttk {
+    namespace eval menubutton {
+	variable State
+	array set State {
+	    pulldown	0
+	    oldcursor	{}
+	}
+    }
+}
+
+bind TMenubutton <Enter>	{ %W instate !disabled {%W state active } }
+bind TMenubutton <Leave>	{ %W state !active }
+bind TMenubutton <Key-space> 	{ ttk::menubutton::Popdown %W }
+bind TMenubutton <<Invoke>> 	{ ttk::menubutton::Popdown %W }
+
+if {[tk windowingsystem] eq "x11"} {
+    bind TMenubutton <ButtonPress-1>  	{ ttk::menubutton::Pulldown %W }
+    bind TMenubutton <ButtonRelease-1>	{ ttk::menubutton::TransferGrab %W }
+    bind TMenubutton <B1-Leave> 	{ ttk::menubutton::TransferGrab %W }
+} else {
+    bind TMenubutton <ButtonPress-1>  \
+	{ %W state pressed ; ttk::menubutton::Popdown %W }
+    bind TMenubutton <ButtonRelease-1>  \
+	{ %W state !pressed }
+}
+
+# PostPosition --
+#	Returns the x and y coordinates where the menu 
+#	should be posted, based on the menubutton and menu size
+#	and -direction option.
+#
+# TODO: adjust menu width to be at least as wide as the button
+#	for -direction above, below.
+#
+proc ttk::menubutton::PostPosition {mb menu} {
+    set x [winfo rootx $mb]
+    set y [winfo rooty $mb]
+    set dir [$mb cget -direction]
+
+    set bw [winfo width $mb]
+    set bh [winfo height $mb]
+    set mw [winfo reqwidth $menu]
+    set mh [winfo reqheight $menu]
+    set sw [expr {[winfo screenwidth  $menu] - $bw - $mw}]
+    set sh [expr {[winfo screenheight $menu] - $bh - $mh}]
+
+    switch -- $dir {
+	above { if {$y >= $mh} { incr y -$mh } { incr y  $bh } }
+	below { if {$y <= $sh} { incr y  $bh } { incr y -$mh } }
+	left  { if {$x >= $mw} { incr x -$mw } { incr x  $bw } }
+	right { if {$x <= $sw} { incr x  $bw } { incr x -$mw } }
+	flush { 
+	    # post menu atop menubutton.
+	    # If there's a menu entry whose label matches the
+	    # menubutton -text, assume this is an optionmenu
+	    # and place that entry over the menubutton.
+	    set index [FindMenuEntry $menu [$mb cget -text]]
+	    if {$index ne ""} {
+		incr y -[$menu yposition $index]
+	    }
+	}
+    }
+
+    return [list $x $y]
+}
+
+# Popdown --
+#	Post the menu and set a grab on the menu.
+#
+proc ttk::menubutton::Popdown {mb} {
+    if {[$mb instate disabled] || [set menu [$mb cget -menu]] eq ""} {
+	return
+    }
+    foreach {x y} [PostPosition $mb $menu] { break }
+    tk_popup $menu $x $y
+}
+
+# Pulldown (X11 only) --
+#	Called when Button1 is pressed on a menubutton.
+#	Posts the menu; a subsequent ButtonRelease 
+#	or Leave event will set a grab on the menu.
+#
+proc ttk::menubutton::Pulldown {mb} {
+    variable State
+    if {[$mb instate disabled] || [set menu [$mb cget -menu]] eq ""} {
+	return
+    }
+    foreach {x y} [PostPosition $mb $menu] { break }
+    set State(pulldown) 1
+    set State(oldcursor) [$mb cget -cursor]
+
+    $mb state pressed
+    $mb configure -cursor [$menu cget -cursor]
+    $menu post $x $y
+    tk_menuSetFocus $menu
+}
+
+# TransferGrab (X11 only) --
+#	Switch from pulldown mode (menubutton has an implicit grab)
+#	to popdown mode (menu has an explicit grab).
+#
+proc ttk::menubutton::TransferGrab {mb} {
+    variable State
+    if {$State(pulldown)} {
+	$mb configure -cursor $State(oldcursor)
+	$mb state {!pressed !active}
+	set State(pulldown) 0
+
+	set menu [$mb cget -menu]
+    	tk_popup $menu [winfo rootx $menu] [winfo rooty $menu]
+    }
+}
+
+# FindMenuEntry --
+#	Hack to support tk_optionMenus.
+#	Returns the index of the menu entry with a matching -label,
+#	-1 if not found.
+#
+proc ttk::menubutton::FindMenuEntry {menu s} {
+    set last [$menu index last]
+    if {$last eq "none"} {
+	return ""
+    }
+    for {set i 0} {$i <= $last} {incr i} {
+	if {![catch {$menu entrycget $i -label} label]
+	    && ($label eq $s)} {
+	    return $i
+	}
+    }
+    return ""
+}
+
+#*EOF*

data/pkgs/tile-0.8.2/library/notebook.tcl

@@ -0,0 +1,193 @@
+#
+# notebook.tcl,v 1.24 2007/02/26 18:06:26 hobbs Exp
+#
+# Bindings for TNotebook widget
+#
+
+namespace eval ttk::notebook {
+    variable TLNotebooks ;# See enableTraversal
+}
+
+bind TNotebook <ButtonPress-1>		{ ttk::notebook::Press %W %x %y }
+bind TNotebook <Key-Right>		{ ttk::notebook::CycleTab %W  1; break }
+bind TNotebook <Key-Left>		{ ttk::notebook::CycleTab %W -1; break }
+bind TNotebook <Control-Key-Tab>	{ ttk::notebook::CycleTab %W  1; break }
+bind TNotebook <Control-Shift-Key-Tab>	{ ttk::notebook::CycleTab %W -1; break }
+catch {
+bind TNotebook <Control-ISO_Left_Tab>	{ ttk::notebook::CycleTab %W -1; break }
+}
+bind TNotebook <Destroy>		{ ttk::notebook::Cleanup %W }
+
+# ActivateTab $nb $tab --
+#	Select the specified tab and set focus.
+#
+# 	If $tab was already the current tab, set the focus to the
+#	notebook widget.  Otherwise, set the focus to the first
+#	traversable widget in the pane.  The behavior is that the
+#	notebook takes focus when the user selects the same tab
+#	a second time.  This mirrors Windows tab behavior.
+#
+proc ttk::notebook::ActivateTab {w tab} {
+    if {[$w index $tab] eq [$w index current]} {
+	focus $w
+    } else {
+    	$w select $tab
+	update ;# needed so focus logic sees correct mapped/unmapped states
+	if {[set f [ttk::focusFirst [$w select]]] ne ""} {
+	    ttk::traverseTo $f
+	}
+    }
+}
+
+# Press $nb $x $y --
+#	ButtonPress-1 binding for notebook widgets.
+#	Activate the tab under the mouse cursor, if any.
+#
+proc ttk::notebook::Press {w x y} {
+    set index [$w index @$x,$y]
+    if {$index ne ""} {
+	ActivateTab $w $index
+    }
+}
+
+# CycleTab --
+#	Select the next/previous tab in the list.
+#
+proc ttk::notebook::CycleTab {w dir} {
+    if {[$w index end] != 0} {
+	set current [$w index current]
+	set select [expr {($current + $dir) % [$w index end]}]
+	while {[$w tab $select -state] != "normal" && ($select != $current)} {
+	    set select [expr {($select + $dir) % [$w index end]}]
+	}
+	if {$select != $current} {
+	    ActivateTab $w $select
+	}
+    }
+}
+
+# MnemonicTab $nb $key --
+#	Scan all tabs in the specified notebook for one with the
+#	specified mnemonic. If found, returns path name of tab;
+#	otherwise returns ""
+#
+proc ttk::notebook::MnemonicTab {nb key} {
+    set key [string toupper $key]
+    foreach tab [$nb tabs] {
+	set label [$nb tab $tab -text]
+	set underline [$nb tab $tab -underline]
+	set mnemonic [string toupper [string index $label $underline]]
+	if {$mnemonic ne "" && $mnemonic eq $key} {
+	    return $tab
+	}
+    }
+    return ""
+}
+
+# +++ Toplevel keyboard traversal.
+#
+
+# enableTraversal --
+#	Enable keyboard traversal for a notebook widget
+#	by adding bindings to the containing toplevel window.
+#
+#	TLNotebooks($top) keeps track of the list of all traversal-enabled
+#	notebooks contained in the toplevel
+#
+proc ttk::notebook::enableTraversal {nb} {
+    variable TLNotebooks
+
+    set top [winfo toplevel $nb]
+
+    if {![info exists TLNotebooks($top)]} {
+	# Augment $top bindings:
+	#
+	bind $top <Control-Key-Tab> 	     {+ttk::notebook::TLCycleTab %W  1}
+	bind $top <Shift-Control-Key-Tab>    {+ttk::notebook::TLCycleTab %W -1}
+	catch {
+	bind $top <Control-Key-ISO_Left_Tab> {+ttk::notebook::TLCycleTab %W -1}
+	}
+	if {[tk windowingsystem] eq "aqua"} {
+	    bind $top <Option-KeyPress> \
+		+[list ttk::notebook::MnemonicActivation $top %K]
+	} else {
+	    bind $top <Alt-KeyPress> \
+		+[list ttk::notebook::MnemonicActivation $top %K]
+	}
+	bind $top <Destroy> {+ttk::notebook::TLCleanup %W}
+    }
+
+    lappend TLNotebooks($top) $nb
+}
+
+# TLCleanup -- <Destroy> binding for traversal-enabled toplevels
+#
+proc ttk::notebook::TLCleanup {w} {
+    variable TLNotebooks
+    if {$w eq [winfo toplevel $w]} {
+	unset -nocomplain -please TLNotebooks($w)
+    }
+}
+
+# Cleanup -- <Destroy> binding for notebooks
+#
+proc ttk::notebook::Cleanup {nb} {
+    variable TLNotebooks
+    set top [winfo toplevel $nb]
+    if {[info exists TLNotebooks($top)]} {
+	set index [lsearch -exact $TLNotebooks($top) $nb]
+        set TLNotebooks($top) [lreplace $TLNotebooks($top) $index $index]
+    }
+}
+
+# EnclosingNotebook $w --
+#	Return the nearest traversal-enabled notebook widget
+#	that contains $w.
+#
+# BUGS: this only works properly for tabs that are direct children
+#	of the notebook widget.  This routine should follow the
+#	geometry manager hierarchy, not window ancestry, but that
+#	information is not available in Tk.
+#
+proc ttk::notebook::EnclosingNotebook {w} {
+    variable TLNotebooks
+
+    set top [winfo toplevel $w]
+    if {![info exists TLNotebooks($top)]} { return }
+
+    while {$w ne $top  && $w ne ""} {
+	if {[lsearch -exact $TLNotebooks($top) $w] >= 0} {
+	    return $w
+	}
+	set w [winfo parent $w]
+    }
+    return ""
+}
+
+# TLCycleTab --
+#	toplevel binding procedure for Control-Tab / Shift-Control-Tab
+#	Select the next/previous tab in the nearest ancestor notebook.
+#
+proc ttk::notebook::TLCycleTab {w dir} {
+    set nb [EnclosingNotebook $w]
+    if {$nb ne ""} {
+	CycleTab $nb $dir
+	return -code break
+    }
+}
+
+# MnemonicActivation $nb $key --
+#	Alt-KeyPress binding procedure for mnemonic activation.
+#	Scan all notebooks in specified toplevel for a tab with the
+#	the specified mnemonic.  If found, activate it and return TCL_BREAK.
+#
+proc ttk::notebook::MnemonicActivation {top key} {
+    variable TLNotebooks
+    foreach nb $TLNotebooks($top) {
+	if {[set tab [MnemonicTab $nb $key]] ne ""} {
+	    ActivateTab $nb [$nb index $tab]
+	    return -code break
+	}
+    }
+}
+

data/pkgs/tile-0.8.2/library/paned.tcl

@@ -0,0 +1,87 @@
+#
+# paned.tcl,v 1.5 2007/06/09 21:45:51 jenglish Exp
+#
+# Bindings for ttk::panedwindow widget.
+#
+
+namespace eval ttk::panedwindow {
+    variable State
+    array set State {
+	pressed 	0
+    	pressX		-
+	pressY		-
+	sash 		-
+	sashPos 	-
+    }
+}
+
+## Bindings:
+#
+bind TPanedwindow <ButtonPress-1> 	{ ttk::panedwindow::Press %W %x %y }
+bind TPanedwindow <B1-Motion> 		{ ttk::panedwindow::Drag %W %x %y }
+bind TPanedwindow <ButtonRelease-1> 	{ ttk::panedwindow::Release %W %x %y }
+
+bind TPanedwindow <Motion> 		{ ttk::panedwindow::SetCursor %W %x %y }
+bind TPanedwindow <Enter> 		{ ttk::panedwindow::SetCursor %W %x %y }
+bind TPanedwindow <Leave> 		{ ttk::panedwindow::ResetCursor %W } 
+# See <<NOTE-PW-LEAVE-NOTIFYINFERIOR>>
+bind TPanedwindow <<EnteredChild>>	{ ttk::panedwindow::ResetCursor %W }
+
+
+## Sash movement:
+#
+proc ttk::panedwindow::Press {w x y} {
+    variable State
+
+    set sash [$w identify $x $y]
+    if {$sash eq ""} {
+    	set State(pressed) 0
+	return 
+    }
+    set State(pressed) 	1
+    set State(pressX) 	$x
+    set State(pressY) 	$y
+    set State(sash) 	$sash
+    set State(sashPos)	[$w sashpos $sash]
+}
+
+proc ttk::panedwindow::Drag {w x y} {
+    variable State
+    if {!$State(pressed)} { return }
+    switch -- [$w cget -orient] {
+    	horizontal 	{ set delta [expr {$x - $State(pressX)}] }
+    	vertical 	{ set delta [expr {$y - $State(pressY)}] }
+    }
+    $w sashpos $State(sash) [expr {$State(sashPos) + $delta}]
+}
+
+proc ttk::panedwindow::Release {w x y} {
+    variable State
+    set State(pressed) 0
+    SetCursor $w $x $y
+}
+
+## Cursor management:
+#
+proc ttk::panedwindow::ResetCursor {w} {
+    variable State
+    if {!$State(pressed)} {
+	$w configure -cursor {}
+    }
+}
+
+proc ttk::panedwindow::SetCursor {w x y} {
+    variable ::ttk::Cursors
+
+    if {![llength [$w identify $x $y]]} {
+    	ResetCursor $w
+    } else {
+    	# Assume we're over a sash.
+	switch -- [$w cget -orient] {
+	    horizontal 	{ $w configure -cursor $Cursors(hresize) }
+	    vertical 	{ $w configure -cursor $Cursors(vresize) }
+	}
+    }
+}
+
+#*EOF*