proc tgvonjoin {nick uhost handle chan} {
   set tmp [list]
   for {set i 0} {$i<[llength $::tgscore]} {incr i} {
      lappend tmp [split [lindex $::tgscore $i] ,]
   }
   set tmp [lrange [lsort -decreasing -integer -index 2 $tmp] 0 2]
   if {[lsearch -nocase -index 0 $tmp $nick]>-1} {
      pushmode $chan +v $nick
   }
}
bind join - "$tgchan *" tgvonjoin

set t_idx [lsearch -index 2 [timers] montimer]

proc updatetimer {tname delay} {
   if {[lsearch -index 2 [timers] $tname]!=-1} {
      killtimer $tname
   }
   if {$delay > 0} {
      list [timer $delay [list maproc with params] 1 $tname]
   }
}

[file dirname [file normalize [info script]]]

proc octet_formatting {value {SI 1}} {
	if { $SI } {
		set base 1024
		set units {Kio Mio Gio Tio Pio Eio Zio}
	} else {
		set base 1000
		set units {Ko Mo Go To Po Eo Zo}
	}   
	if { $value < $base } { return "${value}o" }
	foreach unit $units {
		set value [expr {$value / ($base / 1.0)} ]
		if { $value < $base } {
			return "[format %1.2f $value]$unit"
		}
	}
}

proc form2oct {formated} {
	set usi {kio Mio Gio Tio Pio Eio Zio}
	set units {ko Mo Go To Po Eo Zo}
	set base 1000
	regexp {([0-9\.]+)(\w+)} $formated - s u
	if {$u in $usi} {
		set units $usi
		set base 1024
	}
	for {set i [lsearch $units $u]} {$i>=0} {incr i -1} {
		set s [expr $s * $base]
	}
	return $s
}

# Recherche les éléments de list1 contenus dans list2
proc lintersect {list1 list2} {
   foreach element $list1 {
      if { ($element in $list2) } { lappend intersect $element }
   }
   return $intersect
}

# version de #MenzAgitat
proc ldiff {list1 list2} {
   foreach element $list1 {
      if { !($element in $list2) } {
         lappend diff $element
      }
   }
   return $diff
}

proc lintersect {list1 list2 {option -exact}} {
   if {$option ne "-nocase"} { set option -exact }
   return [lmap x $list1 {expr {[lsearch $option $list2 $x] >= 0 ? $x : [continue]}}]
}
 
proc ldiff {list1 list2 {option -exact}} {
   if {$option ne "-nocase"} { set option -exact }
   return [lmap x $list1 {expr {[lsearch $option $list2 $x] < 0 ? $x : [continue]}}]
}

hook bind subject hook observer binding

# angel.job
hook bind job start angel [namespace current]::start
proc start {} { putlog "Angel is loaded" }
#thief
hook bind job start thief [namespace current]::start
proc start {} { putlog "Thief is loaded" }

hook call subject hook arguments

namespace eval dates {
 
   variable treg {^((\d{1,2})y)?((\d{1,})w)?((\d{1,})d)?((\d{1,})h)?((\d{1,})m)?((\d{1,})s)?$}
 
   proc futur {sdate} {
      set more {}
      if {![regexp -nocase -- $::dates::treg $sdate -> Y y W w D d H h M m S s]} {
         putlog "Désolé mais $sdate n'est pas un format reconnu"
         return [clock seconds]
      }
      if {[info exists y] && $y ne ""} { lappend more "$y years" }
      if {[info exists w] && $w ne ""} { lappend more "$w weeks" }
      if {[info exists d] && $d ne ""} { lappend more "$d days" }
      if {[info exists h] && $h ne ""} { lappend more "$h hours" }
      if {[info exists m] && $m ne ""} { lappend more "$m minutes" }
      if {[info exists s] && $s ne ""} { lappend more "$s seconds" }
      return [clock add [clock seconds] {*}[join $more " "]]
   }
}

if { [regsub -all {\.} [lindex $::version 0] ""] < 1620 } {

if { [regsub -all {\.} [lindex $::version 1] ""] < 1620 } {

if { [package vcompare [regexp -inline {^[[:digit:]\.]+} $::version] 1.6.20] == -1 } {

if {[info exists ::numversion] && $::numversion > 1080000 } {

# Recherche les éléments de list1 contenus dans list2
proc lintersect {list1 list2} {
   foreach element $list1 {
      if { ($element in $list2) } { lappend intersect $element }
   }
   return $intersect
}

proc add_thousand_separators {value} {
return [::tcl::string::trimleft [::tcl::string::reverse [regsub -all {...} [::tcl::string::reverse $value] {&.}]] "."]
}

clock format [clock scan "Tue, 06 Jan 2015 5:30 pm"] -format "%A %d %B %Y %H:%M" -locale fr

Variables à déclarer
# Filtrer les codes de style (couleurs, gras, ...) dans tous les affichages du
# script ? (0 = non / 1 = oui)
variable monochrome 0

# Longueur maximum d'une ligne affichable (si la fin de certaines lignes est
# tronquée, cela signifie que vous devez diminuer cette valeur)
variable max_line_length 435

Procédure
###############################################################################
### Affichage d'un texte, filtrage des styles si nécessaire.
### * queue peut valoir help, quick, now, serv, dcc, log ou loglev
### * method peut valoir PRIVMSG ou NOTICE et sera ignoré si queue vaut dcc, log
###      ou loglev
### * target peut être un nick, un chan ou un idx, et sera ignoré si queue vaut
###      log ou loglev
###############################################################################
proc display_output {queue method target text} {
variable monochrome
variable max_line_length
if {
($monochrome)
|| ((![::tcl::string::first "#" $target])
&& ([::tcl::string::match *c* [lindex [split [getchanmode $target]] 0]]))
|| (($queue eq "dcc")
&& (![matchattr [idx2hand $target] h]))
} then {
regsub -all "\017" [stripcodes abcgru $text] "" text
}
switch -- $queue {
help - quick - now - serv {
foreach line [split_line $text $max_line_length] {
put$queue "$method $target :$line"
}
}
dcc {
foreach line [split_line $text $max_line_length] {
putdcc $target $line
}
}
loglev {
foreach line [split_line $text $max_line_length] {
putloglev o * $line
}
}
log {
foreach line [split_line $text $max_line_length] {
putlog $line
}
}
}
}