#!/usr/local/bin/wish
#
# 2003-10-18  Umberto Salsi <salsi@icosaedro.it>
# www.icosaedro.it

set PROG_NAME [exec basename $argv0]
set VERSION "1.2"
set PREFS "$env(HOME)/.$PROG_NAME.prefs"

# imposta default:
set continue 0
set convert_links 1
set cookies 0
set destination_dir "$env(HOME)"
set download 0
set force_html 1
set use_level 0
set level 5
set no_parent 1
set page_requisites 1
set recursive 0
set relative 1
set save_on_exit 1
set terminal "xterm -hold -e"
set time_stamping 0
set tries 3
set use_proxy_login 0
set proxy_user "$env(USER)"
set proxy_pass ""
set save_proxy_pass 0
set use_http_proxy 0
set http_proxy "http://my.proxy.it:8080"
set use_ftp_proxy 0
set ftp_proxy "ftp://my.proxy.it:8021"
set use_quota 0
set quota 10
set use_login 0
set user "$env(USER)"
set pass ""
set save_pass 0
set ignore_length 0
set use_agent 0
set agent "Mozilla/4.0 (compatible; MSIE 5.0; Linux) wget \[en\]"
set use_globbing 0
set use_accept 0
set accept ""
set use_reject 0
set reject ""
set follow_ftp 0
set span_hosts 0
set use_passive 0
set use_limit_rate 0
set limit_rate 1
set wait 0
set url "http://"


set padx 10
set pady 10

set butw 10

set font_norm "Helvetica 12"
set font_em "Helvetica 12 bold"
set font_but "Helvetica 12 bold"

############################################
##
## Dialog box std
##
############################################

proc Errore { msg } {
	tk_dialog .zzz "Error" $msg error 0 "OK"
}


proc Avviso { msg } {
	tk_dialog .zzz "Notice" $msg info 0 "OK"
}


#############################################
##
## Std Exec
##
#############################################

proc Exec { cmd varName } {
	upvar $varName var
	if { [catch {eval $cmd} var] } {
		Errore "Failed to execute the command:\n\n    $cmd\n\nbecause:\n\n$var"
		return 0
	} else {
		return 1
	}
}


####################################
##
## StdXxx
##
####################################

proc StdButt { path name cmd } {
	global font_but
	button $path -text $name -width 10 -command $cmd -font $font_but
	#pack $path
}


proc StdEntry { w label varname width args } {
	global font_norm
	frame $w
	#pack $w
	label $w.l -text $label -font $font_norm
	pack $w.l -side left
	entry $w.v -textvariable $varname -background white -width $width
	pack $w.v -side left
	if { [string length $args] > 0 } {
		label $w.l2 -text $args -font $font_norm
		pack $w.l2 -side left
	}
}


proc Premi { bottone } {
	$bottone configure -relief sunken ;# premi il bottone
	update ;# aggiorna finestra
	after 500 ;# aspetta mezzo secondo
	$bottone configure -relief raised ;# rilascia il bottone
	$bottone invoke ;# esegue comando associato al bottone
}




####################################
##
## Cards Index
##
####################################

proc NewCardIndex { f } {
#
# Crea il frame $f dove crea la struttura per un nuovo card index:
#
#     frame $f
#     frame $f.but (per i bottoni)
#     frame $f.cards (per le schede)
#
	frame $f
	frame $f.but
	pack $f.but -anchor nw
	frame $f.cards -relief sunken -border 2
	pack $f.cards -anchor nw -fill both -expand true
	return $f
}


set hmax 0
set vmax 0

proc ShowCard { c s } {
#
# Attiva la scheda di nome $s nel frame contenitore $c:
# - disattiva tutti i bottoni del frame $c.but
# - attiva il bottone $c.but.$s
# - disattiva tutti i frames dentro al frame $c.card
# - attiva il frame $c.cards.$s
#
# Struttura di widget:
# - frame $c: contenitore di tutte le schede e dei bottoni
# - frame $c.but: frame dei bottoni
# - frame $c.cards: frame delle schede, ogni scheda un frame
#

	global hmax vmax

	# disattiva tutti i bottoni del frame $c.but
	foreach b [winfo children $c.but] {
		$b configure -relief raised
	}
	# attiva il bottone $c.but.$s:
	$c.but.$s configure -relief sunken
	# disattiva tutti i frames dentro al frame $c.card:
	foreach f [winfo children $c.cards] {
		pack forget $f
	}
	# attiva il frame $c.cards.$s:
	pack $c.cards.$s -anchor nw -padx 5 -pady 5


	return

	set f $c.cards.$s
	set h [winfo width $f]
	set v [winfo height $f]
	if { $h > $hmax } {
		set hmax $h
		$f configure -width $hmax
		puts Opps
	}
	if { $v > $vmax } {
		set vmax $v
		$f configure -height $vmax
		puts Opps
	}
	puts "$h, $v, $hmax, $vmax"
}


proc AddCard { ci name text } {
#
# Crea una nuova card.
# Ritorna il frame della card creata.
#
	button $ci.but.$name -text $text -command "ShowCard $ci $name"
	$ci.but.$name configure -relief sunken
	pack $ci.but.$name -side left
	frame $ci.cards.$name
	return $ci.cards.$name
}

#
#
###### Fine di Card Index





proc add_slashes_sh { s } {
#
# Converte la stringa $s in una stringa interpretabile letteralmente
# dallo shell.
#
	regsub -all "\\\\" $s "\\\\\\\\"  s
	regsub -all "\""   $s "\\\""  s
	#regsub -all "\\("  $s "\\("   s
	#regsub -all "\\)"    $s "\\\\)" s
	regsub -all "\\\$" $s "\\\\\$"    s
	regsub -all "`"    $s "\\\\`" s
	return $s
}


proc build_cmd {} {
	global \
		continue \
		convert_links \
		cookies \
		destination_dir \
		download \
		force_html \
		use_level level \
		no_parent \
		page_requisites \
		recursive \
		relative \
		save_on_exit \
		terminal \
		time_stamping \
		tries \
		wait \
		use_proxy_login proxy_user proxy_pass save_proxy_pass\
		use_http_proxy http_proxy \
		use_ftp_proxy ftp_proxy \
		use_limit_rate limit_rate \
		use_quota quota \
		use_login user pass save_pass \
		ignore_length \
		use_agent agent \
		use_globbing \
		use_passive \
		use_accept accept \
		use_reject reject \
		follow_ftp \
		span_hosts \
		url \

	set cmd "wget"
	if { $ignore_length } {
		set cmd "$cmd --ignore-length"
	}
	if { $use_agent & [string compare $agent ""] != 0 } {
		set cmd "$cmd --user-agent=\"[add_slashes_sh $agent]\""
	}
	if { $use_globbing } {
		set cmd "$cmd --glob=on"
	}
	switch $download {
		0 { }
		1 { set cmd "$cmd --no-clobber" }
		2 { set cmd "$cmd --timestamping" }
	}
	if { $use_quota & [string compare $quota ""] != 0 } {
		set cmd "$cmd --quota=${quota}m"
	}
	if { $use_login & [string compare $user ""] != 0 } {
		set cmd "$cmd --http-user=\"[add_slashes_sh $user]\" --http-passwd=\"[add_slashes_sh $pass]\""
	}
	if { $use_passive } {
		set cmd "$cmd --passive-ftp"
	}
	if { $use_limit_rate } {
		set cmd "$cmd --limit-rate=${limit_rate}k"
	}
	if { [string compare $wait ""] != 0 & $wait > 0 } {
		set cmd "$cmd --wait=$wait"
	}
	if { $use_proxy_login } {
		set cmd "$cmd --proxy-user=\"[add_slashes_sh $proxy_user]\""
		set cmd "$cmd --proxy-user=\"[add_slashes_sh $proxy_pass]\""
	}
	if { $recursive } {
		set cmd "$cmd --recursive"
		if { $use_level } {
			set cmd "$cmd --level=$level"
		} else {
			set cmd "$cmd --level=inf"
		}
		if { $cookies } {
			set cmd "$cmd --cookies=on"
		} else {
			set cmd "$cmd --cookies=off"
		}
		if { $relative } {
			set cmd "$cmd --relative"
		}
		if { $no_parent } {
			set cmd "$cmd --no-parent"
		}
		if { $convert_links } {
			set cmd "$cmd --convert-links"
		}
		if { $time_stamping } {
			set cmd "$cmd --timestamping"
		}
		if { $use_accept & [string compare $accept ""] != 0 } {
			set cmd "$cmd --accept \"[add_slashes_sh $accept]\""
		}
		if { $use_reject & [string compare $reject ""] != 0 } {
			set cmd "$cmd --reject \"[add_slashes_sh $reject]\""
		}
		if { $follow_ftp } {
			set cmd "$cmd --follow-ftp"
		}
		if { $span_hosts } {
			set cmd "$cmd --span-hosts"
		}
	}
	if { $page_requisites } {
		set cmd "$cmd --page-requisites"
	}
	if { $continue } {
		set cmd "$cmd --continue"
	}
	if { $force_html } {
		set cmd "$cmd --html-extension"
	}
	return "$cmd --tries=$tries \"[add_slashes_sh $url]\""
}


proc ShowCmd {} {
	set cmd [build_cmd]
	Avviso "The resulting command is:\n\n    $cmd"
}


proc add_slashes { s } {
#
# Converte la stringa $s in una stringa interpretabile letteralmente
# da tcl.
#
	regsub -all "\\\\" $s "\\\\\\\\" s
	regsub -all "\\\[" $s "\\\[" s
	regsub -all "\\\$" $s "\\\$"  s
	regsub -all "\""   $s "\\\"" s
	return $s
}


proc Execute {} {
	global terminal destination_dir \
		use_http_proxy http_proxy \
		use_ftp_proxy ftp_proxy \

	# build $dest:
	if { $destination_dir == "" } {
		set dest ""
	} elseif { ! [file isdirectory $destination_dir] } {
		Errore "The destination directory $destination_dir don't exist."
		return
	} else {
		set dest "cd -- \"[add_slashes_sh $destination_dir]\";"
	}

	# build $proxy:
	if { $use_http_proxy } {
		set proxy " http_proxy=\"[add_slashes_sh $http_proxy]\"; ftp_proxy=\"[add_slashes_sh $ftp_proxy]\"; export http_proxy ftp_proxy;"
	} else {
		set proxy ""
	}

	# execute!
	set cmd "$proxy $dest [build_cmd]"
	eval exec [add_slashes $terminal] sh -c \"[add_slashes $cmd]\" &
}


proc save_prefs {} {
	global \
		PREFS PROG_NAME VERSION \
		continue \
		convert_links \
		cookies \
		destination_dir \
		download \
		force_html \
		use_level level \
		no_parent \
		page_requisites \
		recursive \
		relative \
		save_on_exit \
		terminal \
		time_stamping \
		tries \
		wait \
		use_proxy_login proxy_user proxy_pass save_proxy_pass \
		use_http_proxy http_proxy \
		use_ftp_proxy ftp_proxy \
		use_limit_rate limit_rate \
		use_quota quota \
		use_login user pass save_pass \
		ignore_length \
		use_agent agent \
		use_globbing \
		use_passive \
		use_accept accept \
		use_reject reject \
		follow_ftp \
		span_hosts \
		url \
	
	if { ! $save_on_exit } {
		return
	}

	if { ! [Exec "open $PREFS w" fd] } {
		return
	}
	puts $fd "# This file is generated by $PROG_NAME v. $VERSION"
	puts $fd "set terminal \"[add_slashes $terminal]\""
	puts $fd "set continue $continue"
	puts $fd "set convert_links $convert_links"
	puts $fd "set cookies $cookies"
	puts $fd "set destination_dir \"[add_slashes $destination_dir]\""
	puts $fd "set download $download"
	puts $fd "set force_html $force_html"
	puts $fd "set use_level $use_level"
	puts $fd "set level \"[add_slashes $level]\""
	puts $fd "set no_parent $no_parent"
	puts $fd "set page_requisites $page_requisites"
	puts $fd "set recursive $recursive"
	puts $fd "set relative $relative"
	puts $fd "set save_on_exit $save_on_exit"
	puts $fd "set terminal \"[add_slashes $terminal]\""
	puts $fd "set time_stamping $time_stamping"
	puts $fd "set tries \"[add_slashes $tries]\""
	puts $fd "set use_proxy_login $use_proxy_login"
	puts $fd "set proxy_user \"[add_slashes $proxy_user]\""
	if { $save_proxy_pass } {
		puts $fd "set proxy_pass \"[add_slashes $proxy_pass]\""
	}
	puts $fd "set save_proxy_pass $save_proxy_pass"
	puts $fd "set use_http_proxy $use_http_proxy"
	puts $fd "set http_proxy \"[add_slashes $http_proxy]\""
	puts $fd "set use_ftp_proxy $use_ftp_proxy"
	puts $fd "set ftp_proxy \"[add_slashes $ftp_proxy]\""
	puts $fd "set use_limit_rate $use_limit_rate"
	puts $fd "set limit_rate \"[add_slashes $limit_rate]\""
	puts $fd "set use_quota $use_quota"
	puts $fd "set quota \"[add_slashes $quota]\""
	puts $fd "set use_login $use_login"
	puts $fd "set user \"[add_slashes $user]\""
	if { $save_pass } {
		puts $fd "set pass \"[add_slashes $pass]\""
	}
	puts $fd "set save_pass $save_pass"
	puts $fd "set ignore_length $ignore_length"
	puts $fd "set use_agent $use_agent"
	puts $fd "set agent \"[add_slashes $agent]\""
	puts $fd "set use_globbing $use_globbing"
	puts $fd "set use_passive $use_passive"
	puts $fd "set use_accept $use_accept"
	puts $fd "set accept \"[add_slashes $accept]\""
	puts $fd "set use_reject $use_reject"
	puts $fd "set reject \"[add_slashes $reject]\""
	puts $fd "set follow_ftp $follow_ftp"
	puts $fd "set span_hosts $span_hosts"
	puts $fd "set url \"[add_slashes $url]\""
	Exec "close $fd" err
}


proc Usage {} {
	Notice"$PROG_NAME - menu interface to tcpdump\n\nUsage:  $PROG_NAME [-h] [--help] [interface]"
}



####################################
##
## Controlled Frames
##
####################################

# Routines di utilita' per creare frames il cui contenuto e' attivo
# in dipendenza di una certa condizione logica.

proc ControlledFrame { f e args } {
#
# Crea un frame controllato. $f e' il path voluto. $e e' l'espressione
# logica che se valutata vera rende il contenuto del frame attivo.
# Ritorna $f.
#
# Struttura creata:
#
#     label $f.ctrl: il campo "-text" contiene l'espressione logica
#     frame $f.space: crea l'indentazione verso destra
#
	set compound 0
	set indent 0
	if { [info exists args] } {
		foreach opt $args {
			switch -exact -- $opt {
				-compound { set compound 1 }
				-indent   { set indent 1 }
				default { puts "ControlledFrame: unknown option '$opt': ignore" }
			}
		}
	}
	frame $f
	pack $f -anchor nw -fill x
	label $f.ctrl -text $e
	if { $compound } {
		if { $indent } {
			frame $f.space -width 3
			pack $f.space -side left
			frame $f.tbar -width 20 -height 1 -background gray
			pack $f.tbar -side left -anchor nw
		}
		frame $f.vbar -width 1 -background gray
		pack $f.vbar -side left -fill y
		frame $f.bbar -width 20 -height 1 -background gray
		pack $f.bbar -side bottom -anchor nw
	} elseif { $indent } {
		frame $f.space -width 30
		pack $f.space -side left
	}
	return $f
}


proc SetWidgetVisibility { widget active } {
#
# Imposta le caratteristiche del $widget secondo il flag $active.
# Se $widget e' un frame, procede ricorsivamente, cercando in ogni
# frame l'eventuale presenza di una label .ctrl creata con ControlledFrame.
#
	if { $active } {
		set bg red
		set fg black
		set state normal
		set selectcolor red
		set entryfg black
		set entrybg white
	} else {
		set bg yellow
		set fg gray50
		set state disabled
		set selectcolor "#ffd0d0"
		set entryfg gray
		set entrybg "#e0e0e0"
	}
	switch [winfo class $widget] {

		Checkbutton { $widget configure -fg $fg -activeforeground $fg -state $state -selectcolor $selectcolor}

		Entry       { $widget configure -fg $entryfg -bg $entrybg -state $state }

		Label       { $widget configure -fg $fg }

		Menubutton  { $widget configure -state $state }

		Frame {
			if { $active && [winfo exists $widget.ctrl] } {
				set expr [$widget.ctrl cget -text]
				set a [uplevel #0 $expr]
			} else {
				set a $active
			}
			foreach o [winfo children $widget] {
				#puts "   child: $o"
				SetWidgetVisibility $o $a
			}
		}

		##default { puts "widget: $widget, class: [winfo class $widget]" }

	}
}


proc SetWidgetTreeActiveState_CallBack { var_name dummy op } {
# Proc accessoria di TraceVar.
	global sub_frames
	foreach f $sub_frames($var_name) {
		SetWidgetVisibility $f 1 
	}
}


proc TraceVar { var frame } {
#
# Imposta il tracing della variabile di nome $var: se il suo valore cambia,
# imposta lo stato corrispondente per il frame $frame e per tutti gli
# altri widget in esso contenuti.
# Esegue anche l'impostazione iniziale dello stato dei widget, per cui
# questa proc va chiamata solo *dopo* che tutti i sub-widget sono stati
# creati.
#
# Il frame $frame e ogni sub-frame deve contenere un widget di classe "label"
# il cui campo # "-text" contiene l'expressione logica il cui valore e'
# 0=frame disattivo, oppure 1=frame attivo.
#
# Variabili globali usate: array sub_frames(), che contiene l'associazione
# tra il nome della variabile (indice) e il frame/widget controllato.
#
	global sub_frames
	if { [info exists sub_frames($var)] } {
		# esiste gia' un altro frame controllato da $var; aggiungi questo:
		lappend sub_frames($var) $frame
	} else {
		set sub_frames($var) [list $frame]
	}
	SetWidgetTreeActiveState_CallBack $var dummy w
	upvar $var x
	trace variable x w SetWidgetTreeActiveState_CallBack
}

#
#
##### Fine Controlled Frames


##############################
##
##  MAIN
##
##############################

#set log "$env(HOME)/.$PROG_NAME.log"

# carica default:
if { [file exists $PREFS] } {
	source $PREFS
}

set arg1 [lindex $argv 0]
if { [string compare $arg1 "-h"] == 0 || [string compare $arg1 "--help"] == 0 } {
	Usage
} else {
	if { [string length $arg1] > 0 } {
		set url $arg1
	}
}


wm title . "$PROG_NAME v. $VERSION"
wm resizable . 0 0

pack [frame .top   -height $pady] -side top
#pack [frame .bot   -height $pady] -side bottom
pack [frame .left  -width  $padx] -side left
pack [frame .right -width  $padx] -side right

#
# Bottoniera:
#

frame .b
pack .b -side bottom -fill x

StdButt .b.close Close { save_prefs; exit }
StdButt .b.show_cmd "Show Cmd" ShowCmd
StdButt .b.execute Execute Execute
pack .b.close .b.execute -padx $padx -pady $pady -side right
pack .b.show_cmd -side left

.b.execute configure -default active
bind . <Return> {Premi .b.execute}
bind . <KP_Enter> {Premi .b.execute}
bind . <Escape> {Premi .b.close}


#
# Crea card index:
#

set ci [NewCardIndex .ci]
pack $ci -fill both -expand true

#
# Crea scheda "Main":
#

set main [AddCard $ci main Main]

StdEntry $main.url "URL:" url 40
pack $main.url -anchor nw

set f $main.destination_dir
frame $f
pack $f -anchor nw
StdEntry $f.destination_dir "Destination dir.:" destination_dir 30
button $f.select_dir -text "Select" -command {
	global destination_dir
	set new $destination_dir
	while { 1 } {
		set new [tk_chooseDirectory -initialdir $new -parent . -mustexist false -title "Destination directory"]
		if { [string compare $new ""] == 0 } {
			return
		} elseif { [file isdirectory $new] } {
			set destination_dir $new
			return
		} elseif { [file exists $new] } {
			Errore "The file $new is not a directory.\n\nPlease retry."
		} elseif { [Exec "file mkdir \"$new\"" err] } {
			set destination_dir $new
			return
		}
	}
}
pack $f.destination_dir $f.select_dir -side left

set c $main.dowload
frame $c
pack $c -anchor nw
label $c.l -text "Download:" -font $font_norm
radiobutton $c.all -text "all, " -value 0 -variable download -font $font_norm
radiobutton $c.preserve -text "preserve existing, " -value 1 -variable download -font $font_norm
radiobutton $c.newwer -text "newer only." -value 2 -variable download -font $font_norm
pack $c.l $c.all $c.preserve $c.newwer -side left

checkbutton $main.page_requisites -text "Download page requisites (images, style sheets, etc.)" -variable page_requisites -font $font_norm
pack $main.page_requisites -anchor nw

checkbutton $main.continue -text "Continue interrupted download" -variable continue -font $font_norm
pack $main.continue -anchor nw

checkbutton $main.force_html -text "Force .html extension for text/html docs" -variable force_html -font $font_norm
pack $main.force_html -anchor nw

checkbutton $main.recursive -text "Recursive:" -variable recursive -font $font_norm
pack $main.recursive -anchor nw

set f [ControlledFrame $main.recursivef {expr $recursive} -indent -compound]

frame $f.level
pack $f.level -anchor nw
checkbutton $f.level.c -text "Limit recursion level to:" -variable use_level -font $font_norm
pack $f.level.c -side left
set h [ControlledFrame $f.level.e {expr $use_level}]
pack $h -side left
StdEntry $h.e "" level 4
pack $h.e -side left
TraceVar use_level $h

checkbutton $f.relative -text "Follow relative links only" -variable relative -font $font_norm
pack $f.relative -anchor nw

checkbutton $f.no_parent -text "No parent" -variable no_parent -font $font_norm
pack $f.no_parent -anchor nw

TraceVar recursive $main.recursivef

checkbutton $f.convert_links -text "Convert links to local" -variable convert_links -font $font_norm
pack $f.convert_links -anchor nw

checkbutton $main.save_on_exit -text "Save settings on exit to the file $PREFS" -variable save_on_exit -font $font_norm
pack $main.save_on_exit -anchor nw

#
# Crea scheda "Advanced":
#

set adv  [AddCard $ci adv  Advanced]


StdEntry $adv.terminal "Terminal:" terminal 30
pack $adv.terminal -anchor nw

StdEntry $adv.tries "Retries:" tries 4
pack $adv.tries -anchor nw

StdEntry $adv.wait "Wait between retrievals:" wait 5 s
pack $adv.wait -anchor nw

set f $adv.use_limit_rate
frame $f
pack $f -anchor nw
checkbutton $f.f -text "Limit download rate to:" -variable use_limit_rate -font $font_norm
pack $f.f -side left
set h [ControlledFrame $f.h {expr $use_limit_rate}]
pack $h -side left
StdEntry $h.limit_rate "" limit_rate 6 "KB/s"
pack $h.limit_rate
TraceVar use_limit_rate $h

#
# Frame controllato da $recursive per le opz. avanzate legate alla recursione:
#

label $adv.recursive_opts -text "Recursive retrieval options:" -font $font_norm
pack $adv.recursive_opts -anchor nw
set h [ControlledFrame $adv.recursive {expr $recursive} -indent -compound]

#
# Accept list:
#
checkbutton $h.use_accept -text "Accept these suffixes or patterns:" -variable use_accept -font $font_norm
pack $h.use_accept -anchor nw

set f [ControlledFrame $h.use_acceptf {expr $use_accept} -indent]

StdEntry $f.accept "" accept 30
pack $f.accept

TraceVar use_accept $f

#
# Reject list:
#
checkbutton $h.use_reject -text "Reject these suffixes or patterns:" -variable use_reject -font $font_norm
pack $h.use_reject -anchor nw
set f [ControlledFrame $h.use_rejectf {expr $use_reject} -indent]
StdEntry $f.reject "" reject 30
pack $f.reject
TraceVar use_reject $f

set g $h.q
frame $g
pack $g -anchor nw
checkbutton $g.use_quota -text "Download quota:" -variable use_quota -font $font_norm
pack $g.use_quota -side left
set f [ControlledFrame $g.use_quotaf {expr $use_quota}]
pack $f -side left
StdEntry $f.quota "" quota 6 "MB"
pack $f.quota
TraceVar use_quota $f

TraceVar recursive $adv.recursive_opts
TraceVar recursive $h

#
# Crea scheda "HTTP":
#

set http  [AddCard $ci http  HTTP]


checkbutton $http.use_login -text "Login to the HTTP server using:" -variable use_login -font $font_norm
pack $http.use_login -anchor nw
set f [ControlledFrame $http.use_loginf {expr $use_login} -indent]
StdEntry $f.user "User:" user 10
StdEntry $f.pass "Password:" pass 10
checkbutton $f.save -text "save" -variable save_pass -font $font_norm
$f.pass.v configure -show "*"
pack $f.user $f.pass $f.save -side left
TraceVar use_login $f

checkbutton $http.ignore_length -text "Ignore bogus length from HTTP server" -variable ignore_length -font $font_norm
pack $http.ignore_length -anchor nw

checkbutton $http.use_agent -text "Identify to the HTTP server as:" -variable use_agent -font $font_norm
pack $http.use_agent -anchor nw
set f [ControlledFrame $http.use_agentf {expr $use_agent} -indent]
StdEntry $f.agent "" agent 40
pack $f.agent
TraceVar use_agent $f


label $http.l -text "Recursive retrieval options:" -font $font_norm
pack $http.l -anchor nw

set f [ControlledFrame $http.r {expr $recursive} -indent -compound]

checkbutton $f.span_hosts -text "Span across hosts" -variable span_hosts -font $font_norm
pack $f.span_hosts -anchor nw

checkbutton $f.follow_ftp -text "Follow FTP links" -variable follow_ftp -font $font_norm
pack $f.follow_ftp -anchor nw

checkbutton $f.cookies -text "Use cookies" -variable cookies -font $font_norm
pack $f.cookies -anchor nw

TraceVar recursive $f


#
# Crea scheda "FTP":
#

set ftp  [AddCard $ci ftp  FTP]

checkbutton $ftp.use_globbing -text "Enable use of the globbing chars: * ? \[ \]" -variable use_globbing -font $font_norm
pack $ftp.use_globbing

checkbutton $ftp.use_passive -text "Use passive mode" -variable use_passive -font $font_norm
pack $ftp.use_passive -anchor nw

#
# Scheda "Proxy":
#

set c [AddCard $ci proxy Proxy]

checkbutton $c.use_proxy_login -text "Proxy login:" -variable use_proxy_login -font $font_norm
pack $c.use_proxy_login -anchor nw
set f [ControlledFrame $c.use_proxy_loginf {expr $use_proxy_login} -indent]
StdEntry $f.proxy_user "User:" proxy_user 10
StdEntry $f.proxy_pass "Password:" proxy_pass 10
checkbutton $f.save -text "save" -variable save_proxy_pass -font $font_norm
$f.proxy_pass.v configure -show "*"
pack $f.proxy_user $f.proxy_pass $f.save -side left
TraceVar use_proxy_login $f

checkbutton $c.use_http_proxy -text "HTTP Proxy Server:" -variable use_http_proxy -font $font_norm
pack $c.use_http_proxy -anchor nw

set f [ControlledFrame $c.http_proxyf {expr $use_http_proxy} -indent]
StdEntry $f.http_proxy "" http_proxy 30
pack $f.http_proxy -anchor nw
TraceVar use_http_proxy $f

checkbutton $c.use_ftp_proxy -text "FTP Proxy Server:" -variable use_ftp_proxy -font $font_norm
pack $c.use_ftp_proxy -anchor nw

set f [ControlledFrame $c.ftp_proxyf {expr $use_ftp_proxy} -indent]
StdEntry $f.ftp_proxy "" ftp_proxy 30
pack $f.ftp_proxy -anchor nw
TraceVar use_ftp_proxy $f


#
# Crea scheda "About":
#

set about [AddCard $ci about About]
label $about.title -text "
$PROG_NAME v. $VERSION"
message $about.msg -font $font_norm -aspect 110 -text "
Copyright 2003 by Umberto Salsi

Email: salsi@icosaedro.it

WEB: www.icosaedro.it

This is public domain software.  You are free to copy, distribute and modify it as you like, provided that in your modified version this copyright message be removed or updated with YOUR name and YOUR copyright conditions.

Use at your own risk.


ACKNOLEDGMENTS

wget is copyrighted by the Free Software Foundation, Inc. under the GNU General Public License, and was originally written by Hrvoje Niksic.

Tcl/Tk was created by John Ousterhout and it was enhanced and extended by a variety of programmers over The Net.
"
pack $about.title
pack $about.msg





ShowCard $ci main

# Intercetta la chiusura della finestra:
wm protocol . WM_DELETE_WINDOW {.b.close invoke}



#
##### Fine!