#rR gscope_misc.tcl

proc CompareLesARNs {K L} {
    set I 0
    foreach Ligne [LesLignesDuFichier [Fiches "bornesdesarns"]] {
	if { ! [regexp {rRNA-16S} $Ligne]} { continue }
	incr I
	scan $Ligne "%s %d %d %s" N D F S
	if {$S=="R"} { incr D 198 ; incr F 198 }
	set Seq [BoutADN $D $F $S]
	set SeqDe($I) $Seq
    }
    set NbE 0
    foreach A [split $SeqDe($K) ""] B [split $SeqDe($L) ""] {
	if {$A!=$B} { incr NbE }
    }
    Espionne $NbE
    return 
    set P1 [string first aaagaggggga $SeqDe(1)]
    set P2 [string first aaagaggggga $SeqDe(2)]
    Espionne $P1 $P2 [expr $P1-$P2]
    Espionne [string range $SeqDe(1) 198 298]
    Espionne [string range $SeqDe(2)  0  100]
    return
}

proc TestCG {{Seq ""}} {
    set SeqPro [SeqNucToSeqPro [RandomAdnFromProteinSequence $Seq]]
    return $SeqPro
}

proc RandomAdnFromProteinSequence {{Seq ""}} {
    if {$Seq==""} { set Seq "NiceICanTranslateDna" }
    foreach A [split $Seq ""] {
	set MesCodons [CodonsDuAA $A]
	set M [expr [llength $MesCodons]-1]
	set N [expr $M+1]
	set Ra [expr rand()]
	set R [expr round($Ra*$M)]
	set Codon [lindex $MesCodons $R]
	#Espionne $A je prends le $R (0-$M) : $Codon    parmi $N codons : $MesCodons random $Ra
	lappend LesNuc $Codon
    }
    set SeqNuc [join $LesNuc ""]
    return $SeqNuc
}

proc BeauCodeGenetique {} {
    foreach B2 [list A C G T] {
	foreach B3 [list A C G T] {
	    set LaLigne {}
	    foreach B1 [list A C G T] {
		set Codon "$B1$B2$B3"
		set AA [CodeGenetique $Codon]
		regsub "X" $AA "*"
		lappend LaLigne "$Codon $AA"
		lappend EnLong "$B2$B3$B1 [CodeGenetique $B2$B3$B1]"
	    }
	    set Ligne [join $LaLigne "   "]
	    lappend LesLignes $Ligne
	}
	lappend LesLignes ""
    }
    EspionneL $EnLong
    set Texte [join $LesLignes "\n"]
    return $Texte
}


proc CodeGenetique {{Qui ""} { Quoi ""}} {
    #rR CodeGenetique rend l'acide amine d'un codon, ou les codons d'un acide amine
    #rR               ou le code a 3 lettres d'un code a 1 lettre et inversement
    #rR               ou les listes de tout ca.
    #rR   A signifie acide amine a 1 lettre  (code par exemple M)
    #rR AAA signifie acide amine a 3 lettres (code par exemple Met)
    #rR Qui peut aussi etre ListOf
    #rR Quoi peut etre A AAA Codons
    global CodeGenetique

    #rR comportement par defaut 
    if {$Qui==""} { set Qui "ListOf"; set Quoi "Codons" }
    if {$Quoi=="" && [regexp -nocase {^[ATGC][ATGC][ATGC]$} $Qui]} { set Quoi "A" }
    if {[regexp -nocase "Codon" $Quoi]} { set Quoi "Codons" }
    if {$Quoi==""} { set Quoi "Codons" }

    #rR on regle le cas de majuscules minuscules pour un aa a 1 lettre un codon ou un aa a 3 lettres
    if {[regexp -nocase {^[A-Z][A-Z][A-Z]$}    $Qui]} { set Qui [string totitle $Qui] }
    if {[regexp -nocase {^[ATGC][ATGC][ATGC]$} $Qui]} { set Qui [string toupper $Qui] }
    if {[regexp -nocase {^[A-Z]$}              $Qui]} { set Qui [string toupper $Qui] }

    if {[info exists CodeGenetique($Qui,$Quoi)]}  { return $CodeGenetique($Qui,$Quoi) }
    if {[info exists CodeGenetique("EstCharge")]} {
	if {[regexp {^[ATGC][ATGC][ATGC]$} $Qui] && [info exists CodeGenetique($Qui,A)]} {
	    #rR pour un codon on rend les codons qui codent pour le meme A
	    set A $CodeGenetique($Qui,A)
	    if {[info exists CodeGenetique($A,$Quoi)]} { return $CodeGenetique($A,$Quoi) }
	}
	return ""
    }
    set CodeGenetique("EstCharge") 1

    #rR au premier appel on passe par ici pour charger le tout, puis plus jamais.
    set FichierCodeGenetique "[GscopeEtc]/gscope_codegenetique.txt"

    set AllCodons                 {}
    set CodeGenetique(ListOf,A)   {}
    set CodeGenetique(ListOf,AAA) {}
    foreach Ligne [LesLignesDuFichier $FichierCodeGenetique] {
	regsub -all { +} $Ligne " " Ligne
	set Ligne [string trim $Ligne]
	if {$Ligne==""} { continue }

	set LesMots [LesMotsDeLaLigne $Ligne]
	set A   [string toupper [lindex $LesMots 0]]
	set AAA [string totitle [lindex $LesMots 1]]
	if {$A=="*"} { set A "X" }

	set CodeGenetique($A,Codons)   {}
	set CodeGenetique($AAA,Codons) {}
	set LesCodons {}
	foreach Codon [lrange $LesMots 2 end] {
	    set Codon [string toupper $Codon]
	    if { ! [regexp {^[ATGC][ATGC][ATGC]$} $Codon]} { continue }
	    lappend AllCodons $Codon
	    lappend LesCodons $Codon
	    set CodeGenetique($Codon,A)   $A
	    set CodeGenetique($Codon,AAA) $AAA
	    lappend CodeGenetique($A,Codons)   $Codon
	    lappend CodeGenetique($AAA,Codons) $Codon
	}
	if {$LesCodons=={}} { continue }

	lappend CodeGenetique(ListOf,A)   $A
	lappend CodeGenetique(ListOf,AAA) $AAA
	set CodeGenetique($A,A)   $A
	set CodeGenetique($AAA,A) $A
	set CodeGenetique($A,AAA)   $AAA
	set CodeGenetique($AAA,AAA) $AAA
    }
    set CodeGenetique(ListOf,Codons) [lsort $AllCodons]

    #rR maintenant tout est charge. On rappelle recursivement la fonction
    return [CodeGenetique $Qui $Quoi]
}

proc TestonsExec {} {
    #rR voir dans [HomeRipp]/Werig/bugPgtclExec
    puts "First exec"
    puts [exec pwd]
    puts [package require Pgtcl]
    puts "Second exec"
    puts [exec pwd]    

    return "return from TestonExec"
    # load /usr/local/ActiveTcl/lib/pgtcl2.0.0/libpgtcl2.0.0.so
}

proc CG {X} {
    set X [string toupper $X]
    foreach A {A T G C} {
	foreach B {A T G C} {
	    foreach C {A T G C} {
		set Codon "$A$B$C"
		set AA [AAduCodon $Codon]
		lappend T($AA) $Codon
		lappend L "$Codon $AA" 
	    }
	}
    }
    if {[info exists T($X) ]} { return $T($X) }
    return $L
}

proc KillPython {} {
    set Qds [exec ps -ef | grep "python"]
    set LesQds [split $Qds "\n"]
    foreach Ligne $LesQds {
    Espionne $Ligne
    if { ! [regexp "python sv" $Ligne]} { continue }
	scan $Ligne "%s %d" moi Pid
	Espionne $Pid
	catch {exec kill -9 $Pid}
    }
}

proc KillQds {} {
    set Qds [exec ps -ef | grep "/cafedessciences/bin/qds"]
    set LesQds [split $Qds "\n"]
    foreach Ligne $LesQds {
    Espionne $Ligne
    if { ! [regexp "/usr/local/bin/tclsh .*/cafedessciences/bin/qds " $Ligne]} { continue }
	scan $Ligne "%s %d" moi Pid
	Espionne $Pid
	catch {exec kill -9 $Pid}
    }
}

proc CreateRandomTfa {{Fichier ""} {N ""}} {
    if {$Fichier==""} { set Fichier "/home/gioalt/arrayagilent_validation/SequenceList/014717_D_SequenceList_20080623.txt" }
    if {$N==""} { set N 5 }
    set LesTFAs {}
    foreach Ligne [ExtractRandomLinesFromFile $Fichier $N "" 3 "" "GetList"] {
	scan $Ligne "%s" Access
	set Seq [regsub "$Access " $Ligne ""]
	set Seq [regsub -all -nocase {[^ATGCN]} $Seq ""]
	set TFA [SequenceFormatTFA $Seq $Access "nucbrut"]
	lappend LesTFAs $TFA
    }
    return [join $LesTFAs "\n"]
}

proc ExtractRandomLinesFromFile {Fichier N {Seed ""} {Start ""} {Stop ""} {GetWhat ""}} {
    if {$GetWhat==""} { set GetWhat "GetText" }
    set LesLignes [LesLignesDuFichier $Fichier]
    if {$Stop!=""}  { set LesLignes [lrange $LesLignes 0 $Stop] } 
    if {$Start!=""} { set LesLignes [lrange $LesLignes $Start end] } 
    set Size [llength $LesLignes]
    if {$Seed==""} {
	set Seed [expr round(1000 * rand())]
	expr srand($Seed)
    }
    set Selection {}
    while {1} {
	set I [expr round(rand()*$Size)]
	if {[info exists DejaVu($I)]} { continue }
	set DejaVu($I) 1
	set Ligne [lindex $LesLignes $I]
	lappend Selection $Ligne
	if { ! [incr N -1] } { break }
    }
    if {$GetWhat=="GetText"} { return [join $Selection "\n"] }
    return $Selection
} 

proc TestDecortiqueBlat {Fichier} {
    set LesHits [DecortiqueBlat $Fichier]
    foreach LeHit $LesHits {
	ScanLaListe $LeHit Query LongQuery BId Access Length Score Expect Identities Strand \
			DebQuery FinQuery DebSbjct FinSbjct SeqQuery Barres SeqSbjct] 
	Espionne "$Query $LongQuery $BId $Access $Length $Score $Expect $Identities $Strand"
    }
    
}

proc DecortiqueBlastCommeBlat TexteListeOuFichier {
    return [DecortiqueBlat $TexteListeOuFichier]
}

proc DecortiqueBlat TexteListeOuFichier {
    if {[regexp "\n" $TexteListeOuFichier]} {
	set LesLignes [split $TexteListeOuFichier "\n"]
    } elseif {[llength $TexteListeOuFichier]==1} {
	    set LesLignes [LesLignesDuFichier $TexteListeOuFichier]
    } else {
	set LesLignes $TexteListeOuFichier
    }
    set LongQuery -1
    set Query "QueryNotFoundInBlat"
    set StartBarrette -1
    set LesHits {}
    set AHitNeedsToBeStored 0
    set SeqQuery ""
    set Barres   ""
    set SeqSbjct ""
    set DebQuery -1
    set DebSbjct -1
    set Strand "Plus/Plus"
    lappend LesLignes "EndOfFile"
    foreach Ligne $LesLignes {
	if {[regexp {^>} $Ligne] || [regexp { Score =} $Ligne] || [regexp "^EndOfFile$" $Ligne]} {
	    if {$AHitNeedsToBeStored} {
		lappend LesHits [list $Query $LongQuery $BId $Access $Length $Score $Expect $Identities $Strand \
			$DebQuery $FinQuery $DebSbjct $FinSbjct $SeqQuery $Barres $SeqSbjct] 
		set SeqQuery ""
		set Barres   ""
		set SeqSbjct ""
		set DebQuery -1
		set DebSbjct -1
		set AHitNeedsToBeStored 0
	    }
	}
	if {$StartBarrette>=0} {
	    set Barrette [string range $Ligne $StartBarrette end]
	    append Barres $Barrette
	    set StartBarrette -1
	    continue
	}
	if {[regexp {^Query= } $Ligne]} {
	    set Query [StringApres "Query=" dans $Ligne]
	    continue
	}
	if {[regexp {\(([0-9]+) letters\)} $Ligne Match LongQuery]} {
	    continue
	}
	if {[regexp {^>} $Ligne]} {
	    set Access ""
	    scan $Ligne "%s %s" BId Access
	    regsub ">" $BId "" BId
	    if {$Access==""} { set Access $BId }
	    continue
	}
	if {[regexp { Score =} $Ligne]} {
	    set Score  [IntegerApres "Score =" dans $Ligne]
	    set Expect [StringApres "Expect =" dans $Ligne]
	    regsub {^[eE]} $Expect "1e" Expect
	    continue
	}
	if {[regexp { Length =} $Ligne]} {
	    set Length  [IntegerApres "Length =" dans $Ligne]
	    continue
	}
	if {[regexp { Identities =} $Ligne]} {
	    set Identities  [StringSuivant "Identities = " dans $Ligne]
	    regsub { *\(.*} $Identities "" Identities
	    continue
	}
	if {[regexp { Strand =} $Ligne]} {
	    set Strand  [StringSuivant "Strand =" dans $Ligne]
	    regsub -all " " $Strand "" Strand
	    continue
	}
	if {[regexp {^Query\: +([0-9]+) +} $Ligne Match DQ]} {
	    if {$DebQuery==-1} { set DebQuery $DQ }
	    set StartBarrette [string length $Match]
	    regsub {^Query\: +([0-9]+) +} $Ligne "" SeqQ
	    if {[regexp { +([0-9]+) *$} $SeqQ MQ FQ]} { 
		regsub { +[0-9]+ *$} $SeqQ "" SeqQ
		set FinQuery $FQ
	    }
	    append SeqQuery $SeqQ
	    continue
	}
	if {[regexp {^Sbjct\:? +([0-9]+) +} $Ligne Match DS]} {
	    if {$DebSbjct==-1} { set DebSbjct $DS }
	    regsub {^Sbjct\:? +([0-9]+) +} $Ligne "" SeqS
	    if {[regexp { +([0-9]+) *$} $SeqS MS FS]} { 
		regsub { +[0-9]+ *$} $SeqS "" SeqS
		set FinSbjct $FS
	    }
	    append SeqSbjct $SeqS
	    set AHitNeedsToBeStored 1
	    continue
	}
    }
    return $LesHits
}

proc RemplaceAccessParPABPourTous {{Rep ""}} {
    while {$Rep==""} {
	set Rep [ChoixDuRepertoire "[RepertoireDuGenome]/"]
	if {$Rep!=""} { break }
	if {[OuiOuNon "Do I cancel ? "]} { return "" }
    }
    if { ! [regexp "/" $Rep]} { set Rep "[RepertoireDuGenome]/$Rep" }
    foreach Nom [ListeDesPABs] {
	set F "$Rep/$Nom"
	if {[FileAbsent $F]} { continue }
	set TFA [ContenuDuFichier $F]
	if { ! [regexp {^>} $TFA]} { continue }
	set B ""
	scan $TFA "%s %s" A B
	regsub ">" $A "" A
	if {$A==$Nom} { continue }
	if {$A==$B} {
	    regsub ">$A " $TFA ">$Nom " NewTFA
	} else {
	    regsub ">" $TFA ">$Nom " NewTFA
	}
	Espionne $F
	Sauve $NewTFA dans $F
    }
}

proc QueryDuBlast Fichier {
    set LeDebut [LesLignesIaJDuFichier $Fichier 1 10] 
    set IndexQuery [lsearch -regexp $LeDebut "Query="]
    if {$IndexQuery==-1} { return "" }
    return [StringApres "Query=" dans [lindex $LeDebut $IndexQuery]] 
}

proc BlastWithAllExpectsToZero {Fichier {Nouveau ""}} {
    if {$Nouveau==""} { set Nouveau "GetText" }

    set OnAttendPartieScore 1
    set OnEstDansScore 0
    set OnFinit 0
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {$OnAttendPartieScore} {
	    lappend LesBonnes $Ligne
	    if {[regexp "Sequences producing" $Ligne]} {
		set OnAttendPartieScore 0
		set OnEstDansScore 1
	    }
	    continue
	}
	if {$OnEstDansScore} {
	    if {[regexp ">" $Ligne]} {
		set OnEstDansScore 0
	    } else {
		if {[regexp { [\+\-\.0-9eE]+ *$} $Ligne]} {
		    regsub  { [\+\-\.0-9eE]+ *$} $Ligne " 0.0000" Ligne
		}
	    }
	    lappend LesBonnes $Ligne
	    continue
	}
	if {[regexp -nocase {Expect = .+} $Ligne]} {
	    regsub  -nocase {Expect = .+} $Ligne "Expect = 0.0000" Ligne
	}
	lappend LesBonnes $Ligne
    }
    if {$Nouveau=="GetLines"} { return $LesBonnes }
    if {$Nouveau=="GetText"}  { return [join $LesBonnes "\n"] }
    return [SauveLesLignes $LesBonnes dans $Nouveau]
}

proc VraiGNDeLaLigneGN Ligne {
    regsub "^GN *" $Ligne "" GN
    regsub {\;$} $GN "" GN
    if { ! [regexp -nocase "Name=" $GN NameEgal]} { return $GN }
    regsub -all "\;" $GN " " GN
    set Vrai [StringApres $NameEgal dans $GN]
    if {$Vrai==""} { return $GN }
    return $Vrai
}

proc VraiDEDeLaLigneDE Ligne {
    regsub "^DE *" $Ligne "" DE
    if { ! [regexp -nocase "RecName:" $DE]} { return $DE }
Espionne $DE
    set Full  ""; regexp {Full=([^\;]+)\;}  $DE Match Full
    set Short ""; regexp {Short=([^\;]+)\;} $DE Match Short
    set EC    ""; regexp {EC=([^\;]+)\;}    $DE Match EC
Espionne $EC
    set Vrai "$Full $Short EC=$EC"
    if {$Full=="" && $Short==""} { return $DE }
    return $Vrai
}

proc RenommeExtension {Avant Apres {Rep ""} {Ask ""}} {
    if {$Ask==""} { set Ask "Ask" }
    if {$Ask=="DontAsk"} { set Ask 0 } else { set Ask 1 }

    if {$Rep==""} { set Rep "." }
    set LesAvants [lsort [glob -nocomplain "$Rep/*$Avant"]]
    set n [llength $LesAvants] 
    if {$n==0} {
	FaireLire "I found no file coresponding to $Rep/*$Avant"
	return ""
    }
    if { ! [OuiOuNon "Do I rename the $n files corresponding to \n$Rep/*$Avant"]} { return "" }
    set Ask 1
    set LesAP {}
    foreach FicAv $LesAvants {
	set i [string last $Avant $FicAv]
	if {$i==-1} { continue }
	set FicAp [string replace $FicAv $i end $Apres]
	
	if {$Ask && [OuiOuNon "Do You want to verify what I'm doing ?"]} {
	    if {  ! [OuiOuNon "file rename -force \n$FicAv \n$FicAp\n\nOk ?"]} { return "" }
	    set Ask [OuiOuNon "Do I continue asking for verification ?"]
	} else {
	    set Ask 0
	}
	file rename -force $FicAv $FicAp
	lappend LesAp $FicAp
    }
    return $LesAp
}

proc MetExtreme {Seq Depart } {
    Wup "numerotation commence a 0"

    regsub -all " " $Seq "" Seq
    set DernierBon $Depart
    foreach I [NombresEntre $Depart 1 -3] {
	set Codon [string range $Seq $I [expr $I+2]]
#	if {[CodonStartPossible $Codon]} { set DernierBon $I }
	if {[string equal -nocase $Codon "ATG"]} { set DernierBon $I }
	if {[CodonStopPossible $Codon]} { break }
    }
    return $DernierBon
}

proc StopProchain {Seq {Depart ""}} {
    Wup "numerotation commence a 0"

    if {$Depart==""} { set Depart 0 }

    regsub -all " " $Seq "" Seq
    set FinSeq [string length $Seq]

    set PremierBon -1
    foreach I [NombresEntre $Depart $FinSeq 3] {
	set Codon [string range $Seq $I [expr $I+2]]
	if {[CodonStopPossible $Codon]} { set PremierBon $I ; break }
    }
    return $PremierBon
}

proc StopAvant {Seq {Depart ""}} {
    Wup "numerotation commence a 0"

    regsub -all " " $Seq "" Seq
    set FinSeq [string length $Seq]

    if {$Depart==""} { set Depart $FinSeq-1 }

    set PremierBon -1
    foreach I [NombresEntre [expr $Depart-3] 0 -3] {
	set Codon [string range $Seq $I [expr $I+2]]
	if {[CodonStopPossible $Codon]} { set PremierBon $I ; break }
    }
    return $PremierBon
}

proc NucExtension5Prime {NucTotal Nuc3Prime} {
    if {$Nuc3Prime==""} { return "" }
    set NucTotal [string toupper $NucTotal]
    
    set Depart [string last [string toupper $Nuc3Prime] [string toupper $NucTotal]]
    if {$Depart<0} { return "" }

    set Debut [MetExtreme   $NucTotal $Depart]
    set Fin   [StopProchain $NucTotal $Depart]
    incr Fin -1
    if {$Fin<0} { set Fin "end" }
    return [string range $NucTotal $Debut $Fin]
}

proc ProtDansNuc {TFA Pro} {
    set Seq [QueLaSequenceDuTexteTFA $TFA]
    set Sortie {}
    foreach Frame [list 0 1 2] {
	set BonSeq [string range $Seq $Frame end]
	set SeqPro [SeqNucToSeqPro $BonSeq]
	if {[regexp -indices -nocase $Pro $SeqPro Indices]} {
	    lappend Sortie $Indices
	}
    }
    return $Sortie
}

proc VersPoubelle Nom {
    set Poubelle "[RepertoireDuGenome]/poubelle"
    if { ! [file exists $Poubelle]} { file mkdir $Poubelle }

    set LesFiPou {}
    foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/*/$Nom"] {
	if { ! [file exists $Fichier]} { continue }
	set Rep [file tail [file dirname $Fichier]]
	if {[file type $Rep]=="link"} { continue  }
	set Pou "${Rep}_$Nom"
	set FiPou "$Poubelle/$Pou"
	if {[file exists $FiPou]} { Garde $FiPou }
	file rename -force $Fichier $FiPou
	lappend LesFiPou $FiPou
    }
    foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/*/$Nom"] {
	if { ! [file exists $Fichier]} { continue }
	set Rep [file tail [file dirname $Fichier]]
	if { ! [OuiOuNon "$Fichier\nis in a directory which is a link.\nDo I move to poubelle anyway ?"]} { continue }
	set Pou "${Rep}_$Nom"
	set FiPou "$Poubelle/$Pou"
	if {[file exists $FiPou]} { Garde $FiPou }
	file rename -force $Fichier $FiPou
	lappend LesFiPou $FiPou
    }
    return $LesFiPou
}

proc SeqToTfaPourTous {} {
    foreach S [glob *.seq] {
	regsub ".seq$" $S ".tfa" T
	Espionne [SeqToTfa $S "seqtotfa/$T"]
    }
    exit
}

proc SeqToTfa {FichierSeq {FichierTFA ""}} {

    if {$FichierTFA==""} {
	regsub ".seq$" $FichierSeq "" FichierTFA
	append FichierTFA ".tfa"
    }

    set EuNA 0
    set EuTitre 0
    set EuPP 0
    set Titre ""
    set Seq ""
    foreach Ligne [LesLignesDuFichier $FichierSeq] {
	if { ! $EuNA && ! [regexp "!!NA_SEQUENCE" $Ligne]} {
	    return ""
	}
	if { ! $EuNA} { set EuNA 1 ; continue }
	if { ! $EuTitre} {
	    if { ! [regexp -nocase {[a-z0-9]+} $Ligne]} {
		set EuTitre 1
		continue
	    }
	    append Titre $Ligne
	    continue
	}
	if { ! $EuPP } {
	    if { [regexp {\.\. *} $Ligne]} { set EuPP 1 }
	    continue
	}
	regsub -all -nocase {[^a-z]} $Ligne "" BoutSeq
	append Seq $BoutSeq
    }
    set TFA [SequenceFormatTFA $Seq ">$Titre" "nucbrut"]
    return [Sauve $TFA dans $FichierTFA]
} 

proc NormaliseTxlFieldName Field {
    regsub -all -nocase {[^a-z0-9\-_\.]} $Field "_" Good
    return $Good
}

proc TestRowsOfCells {} {
    set Texte [ContenuDuFichier "[HomeRipp]/GenoretWww/AmdConsortium/FamLevel2OK.csv"]
    EspionneL [RowsOfCells $Texte]
    exit
}

proc RowsOfCells {Texte {Separateur ""} {NewSep ""} {NewQQ ""} {NewRet ""}} {

    #rR attention j'ai rajoute le dernier caractere a Cell le 2009/01/22

    if {$Separateur==""} { set Separateur ";" }
    if {$NewSep==""}     { set NewSep     "," }
    if {$NewQQ ==""}     { set NewQQ      "\"" }
    if {$NewRet==""}     { set NewRet     " " }

    if {$NewSep=="Keep"}     { set NewSep $Separateur }

    set E 0

    set Q "\""
    set Ret "\n"

    set C ""
    set QQ 0
    set InQ 0
    set LesCell {}
    set LesRows {}
    set Cell ""
    foreach Suivant [split [string trim $Texte " \n\t\f\r\v"] ""] {
	if {$C==""} { set C $Suivant ; continue }
	if {$E} { Espionne $C }
	if {$C==$Q} {
	    if {$QQ} {
		set QQ 0
		append Cell $NewQQ
		if {$E} { Espionne "$C =$Cell= QQ 0" }
		set C $Suivant; continue 
	    } 
	    if {$InQ} {
		if {$Suivant==$Q} {
		    set QQ 1
		    if {$E} { Espionne "$C =$Cell= InQ QQ 1" }
		    set C $Suivant; continue
		}
		append Cell $Q
		set InQ 0
		if {$E} { Espionne "$C =$Cell= InQ 0" }
		set C $Suivant ; continue
	    }
	    set InQ 1
	    append Cell $Q
	    if {$E} { Espionne "$C =$Cell= InQ 1" }
	    set C $Suivant; continue
	}
	if {$C==$Separateur} {
	    if {$InQ} {
		append Cell $NewSep
		if {$E} { Espionne "$C =$Cell= S InQ" }
		set C $Suivant; continue
	    }
	    lappend LesCell $Cell
	    set Cell ""
	    if {$E} { Espionne "$C =$Cell= S OutQ" }
	    set C $Suivant; continue
	}
	if {$C==$Ret} {
	    if {$InQ} {
		append Cell $NewRet
		if {$E} { Espionne "$C =$Cell= R InQ" }
		set C $Suivant; continue
	    }
	    lappend LesCell $Cell
	    set Cell ""
	    lappend LesRows $LesCell
	    if {$E} { Espionne [join $LesCell "/"] }
	    set LesCell {}
	    if {$E} { Espionne "$C =$Cell= R OutQ" }
	    set C $Suivant; continue
	}
	append Cell $C
	if {$E} { Espionne "$C =$Cell=" }
	set C $Suivant; continue
    }
#rR rajoute le 2009/01/22
    if {$C!=$Ret && $C!=$Separateur && $C!=$Q} { append Cell $C }
#rR rajoute le 2009/01/22
    lappend LesCell $Cell
    lappend LesRows $LesCell
    return $LesRows
}

proc LoadTxlWithRowsOfCells {Fichier {aTxl ""} {MainIndex 0} {Sep ""} {CoLi ""} {WholeLine ""}} {

    set WholeLine [string equal -nocase "WholeLine" $WholeLine]

    if {$CoLi==""} { set CoLi "LiCo" }

    Wup "Normally the values are stored in  Txl(Line,Column)"
    Wup "  with CoLi==CoLi we have Txl(Column,Line)"

    if {$aTxl!=""} { upvar $aTxl Txl } else { global Txl ; set aTxl Txl }
    if {$Sep==""} { set Sep "\t" }
    set Queue [file tail $Fichier]
    regsub -nocase {\.[^\.]+$} $Queue "" Queue
    global LoadTxlForGenoret
    if {[info exists LoadTxlForGenoret] && $LoadTxlForGenoret} {set Queue [NormaliseTxlFieldName $Queue] }
    set Txl(Queue) $Queue

    if { ! [file exists $Fichier]} {
	set Txl(ListHeaderPlease,$Queue) {}
	set Txl(ListAllPlease,$Queue)    {}
	return $aTxl
    }
	
	
    set Texte [ContenuDuFichier $Fichier]
    set NewSep ""
    set NewQQ  ""
    set NewRet ""
    set LesRowsOfCells [RowsOfCells $Texte $Sep $NewSep $NewQQ $NewRet]
    set LesHLus [lindex $LesRowsOfCells 0]
    set LesRowsOfCells [lrange $LesRowsOfCells 1 end]

    set LesTetes {}
    foreach Tete $LesHLus {
	regsub -all {\'} $Tete "" Tete
	regsub -all {\?} $Tete "" Tete
	regsub -all {\(} $Tete "" Tete
	regsub -all {\)} $Tete "" Tete
	regsub -all {\"} $Tete "" Tete
	regsub -all {\,} $Tete "_" Tete
	while {[regexp "  " $Tete]} { regsub -all { {2,}} $Tete " " Tete } 
	set Tete [string trim $Tete]
	regsub -all { } $Tete "_" Tete
	#rR ca devrait enlever le degre
	regsub -all -nocase {\0260} $Tete "_" Tete

	set Original $Tete
	if {$Tete==""} { set Tete "_" }
	while {[info exists DejaVu($Tete)]} { append Tete "_2" }
	set DejaVu($Tete) $Original
	lappend LesTetes $Tete
    }
    set Txl(ListHeaderPlease,$Queue) $LesTetes
    set I 1
    foreach LesMots $LesRowsOfCells {
	incr I
	if {$MainIndex<0} {
	    set Nom $I
	} else {
	    set Nom [lindex $LesMots $MainIndex]
	    regsub -all {\"} $Nom "" Nom
	}
	set Nom [string trim $Nom]
	if {$Nom==""} { continue }
	if {[info exists DejaVu($Nom,$Queue)]} { FaireLire "I already saw $Nom , I'll skip it now" ; continue }
	set DejaVu($Nom,$Queue) 1
	lappend Txl(ListAllPlease,$Queue) $Nom
	foreach Mot $LesMots Tete $LesTetes {
	    regsub -all {\"} $Mot "" Mot
	    if {$CoLi=="CoLi"} {
		set Txl($Tete,$Nom) $Mot
	    } else {
		set Txl($Nom,$Tete) $Mot
	    }
	}
	if {$WholeLine} {
	    if {$CoLi=="CoLi"} {
		set Txl(WholeLine,$Nom) $LesMots
	    } else {
		set Txl($Nom,WholeLine) $LesMots
	    }
	}
    }
    set Txl(ListHeaderPlease,) $Txl(ListHeaderPlease,$Queue)
    set Txl(ListAllPlease,)    $Txl(ListAllPlease,$Queue)

    return $aTxl
}

proc LoadTxl {Fichier {aTxl ""} {MainIndex 0} {Sep ""} {CoLi ""} {WholeLine ""}} {

    set WholeLine [string equal -nocase "WholeLine" $WholeLine]

    if {$CoLi==""} { set CoLi "LiCo" }

    Wup "Normally the values are stored in  Txl(Line,Column)"
    Wup "  with CoLi==CoLi we have Txl(Column,Line)"

    if {$aTxl!=""} { upvar $aTxl Txl } else { global Txl ; set aTxl Txl }
    if {$Sep==""} { set Sep "\t" }
    set Queue [file tail $Fichier]
    regsub -nocase {\.[^\.]+$} $Queue "" Queue
    global LoadTxlForGenoret
    if {[info exists LoadTxlForGenoret] && $LoadTxlForGenoret} {set Queue [NormaliseTxlFieldName $Queue] }

    if { ! [file exists $Fichier]} {
	Warne "$Fichier does not exist"
	set Txl(ListHeaderPlease,$Queue) {}
	set Txl(ListAllPlease,$Queue)    {}
	return $aTxl
    }
	
	
    set LesLignes [LesLignesDuFichier $Fichier]
    set Entete [lindex $LesLignes 0]
    set LesLignes [lrange $LesLignes 1 end]
    set LesTetes {}
    foreach Tete [split $Entete $Sep] {
	regsub -all {\#} $Tete "" Tete
	regsub -all {\'} $Tete "" Tete
	regsub -all {\?} $Tete "" Tete
	regsub -all {\(} $Tete "" Tete
	regsub -all {\)} $Tete "" Tete
	regsub -all {\"} $Tete "" Tete
	while {[regexp "  " $Tete]} { regsub -all { {2,}} $Tete " " Tete } 
	set Tete [string trim $Tete]
	regsub -all { } $Tete "_" Tete
#	regsub -all -nocase {[\0260\$]} $Tete "_" Tete
	regsub -all -nocase {[\176\$]} $Tete "_" Tete
	set Original $Tete
	if {$Tete==""} { set Tete "_" }
	while {[info exists DejaVu($Tete)]} { append Tete "_2" }
	set DejaVu($Tete) $Original
	lappend LesTetes $Tete
    }	
    set Txl(ListHeaderPlease,$Queue) $LesTetes
    set Txl(ListOf,Header)           $LesTetes
    set I 1
    foreach Ligne $LesLignes {
	if { ! [regexp -nocase {\S} $Ligne]} { continue }
	incr I
	set LesMots [split $Ligne $Sep]
	if {$MainIndex<0} {
	    set Nom $I
	} else {
	    set Nom [lindex $LesMots $MainIndex]
	    regsub -all {\"} $Nom "" Nom
	}
	lappend Txl(ListAllPlease,$Queue) $Nom
	lappend Txl(ListOf,Index)         $Nom
	foreach Mot $LesMots Tete $LesTetes {
	    regsub -all {\"} $Mot "" Mot
	    if {$CoLi=="CoLi"} {
		set Txl($Tete,$Nom) $Mot
	    } else {
		set Txl($Nom,$Tete) $Mot
	    }
	}
	if {$WholeLine} {
	    if {$CoLi=="CoLi"} {
		set Txl(WholeLine,$Nom) $Ligne
	    } else {
		set Txl($Nom,WholeLine) $Ligne
	    }
	}
    }

    return $aTxl
}

proc DeleteJunkdir {{Qui ""}} {

    NousAllonsAuBoulot
    if {[OuiOuNon "Do I delete all files '$Qui*' in [pwd] ?"]} {
	if {[OuiOuNon "Sure that I delete all files '$Qui*'in [pwd] ?"]} {
	    set Ask 1
	    foreach Fichier [glob "$Qui*"] {
		if {[file isdirectory $Fichier]} { continue }
		File delete $Fichier
	    }
	}
    }
    OnRevientDuBoulot
    return 
}

proc CorrigeValiGNSiPresenceName {} {
    set LesCorriges {}
    foreach Nom [ListeDesPABs] {
	set ValiGN [ValiGN $Nom]
	if { ! [regexp {^Name=([^;]+);} $ValiGN Match GN]} { continue }
	lappend LesCorriges "$Nom $GN $ValiGN" 
	InformeSansDemander $Nom "=ValiGN: $GN"
    }
    return $LesCorriges
}

proc CorrigeLesOrganismesDansDisphy {} {
    global RepertoireDuGenome

    foreach Fichier [glob "$RepertoireDuGenome/disphy/[PreFixe]*"] {
	set Nom [file tail $Fichier]
	LeDescriptif PourQuIlSoitCharge $Nom
	set LesLignes [LesLignesDuFichier $Fichier]
	if { ! [regexp "ukno|uukn|xxxx|iinc" [join $LesLignes "\n"]]} { continue }
	set Nouveau {}
	foreach Ligne $LesLignes {
	    scan $Ligne "%s %d %s" Orga Dist Access
#	    set UnPrecis [regexp {^PAE[0-9]+} $Access] 
	    if {[regexp "ukno|uukn|xxxx|iinc" $Orga]} {
		set OldOrga $Orga
		set MeilleurOrga [OrgaDuAccess $Access Court]
		if {$MeilleurOrga!=""} { set Orga $MeilleurOrga }
		Espionne "$Nom $Access $OldOrga $Orga"
	    }
	    foreach O [SplitOrgas $Orga] {
		lappend Nouveau "$O $Dist $Access"
	    }
	}
	Espionne [SauveLesLignes $Nouveau dans $Fichier]
    }
    CreeDistancesPhyloAvecLesMSFs
}

proc CreeToutesLesSynthetases {{QueLaListe ""}} {
    global RepertoireDuGenome
    global ListeDesPABs

    if {$QueLaListe==""} { set QueLaListe 0 } else { set QueLaListe 1 }

    if { ! [info exists ListeDesPABs]}  { ChargeLesPABs }
    
    if { ! [file exists "$RepertoireDuGenome/coembl"]} { File mkdir "$RepertoireDuGenome/coembl" }
    foreach Nom $ListeDesPABs {
	set FichierMSF "$RepertoireDuGenome/clustalw/$Nom"
	set AA3 [string range [NomDeGene $Nom] 0 2]
	if {$QueLaListe} {
	    lappend LesNomsAAs "$Nom $AA3"
	    continue
	}
	set Destination "$RepertoireDuGenome/coembl/$Nom"
	if { ! [file exists $Destination]} { File mkdir $Destination }
	CreeLesSynthetases $FichierMSF $Destination $AA3
    }
    if {$QueLaListe} {
	Espionne [SauveLesLignes $LesNomsAAs dans "$RepertoireDuGenome/fiches/lookup"]
    }
}

proc Lance {Aligneur Selection} {
    global LaFenetreDesMSF

    set Num [NomDe ""]
    switch -regexp $Aligneur {
	"All" {
	    foreach a [Aligneurs] {
		if {[Aligneurs $a]} {
		    set MSF [AlignePar $a $Selection "Batch" $Num]
		    lappend ListeDesMSF $MSF
		}
	    }
	    set Fenetre [AfficheVariable [join $ListeDesMSF "\n"] \
		    "AvecShowAvecEtudeMSF" "Wait all be Highlighted ...\nThen reselect and press a function. "]
	    BoutonneLaFenetre $Fenetre "Log" "AfficheLogDesMSF \[selection get\]"
	    foreach Fichier $ListeDesMSF {
		set LaFenetreDesMSF($Fichier) $Fenetre
	    }	    
	}
	"clustalw|dialign|pileup|prrp" {
	    AlignePar $Aligneur $Selection "Batch" $Num
	}
	default {
	}
    }
}

proc AlignePar {Aligneur Selection Mode {NomOuNum ""} } {
    global Commandes

    if { $NomOuNum == ""} {
	set NomNum [pid].[NomDe ""]
    }
    if { [regexp {^[a-zA-Z]} $NomOuNum ] } {
	set NomNum ${NomOuNum}[NomDe ""]
    }
    if { [regexp {^[0-9]} $NomOuNum ] } {
	set NomNum $NomOuNum
    }
    if { [regexp {^\.[0-9]} $NomOuNum ] } {
	set NomNum $NomOuNum
    }
    set Tmp tmp.$NomNum
    
	
    if { $Mode == "Batch" } {
	set In  $Tmp.$Aligneur.inp
	set Out $Tmp.$Aligneur.out
	set Log $Tmp.$Aligneur.log
	set FOF [FichierFOF $Selection $Tmp]
	SauveLesLignes [FOFtoTFAs $FOF] dans $In
	catch {set Canal [open "| [set Commandes($Aligneur)] $In $Out $Log"]} Message
	fconfigure $Canal -blocking false -buffering line
	fileevent $Canal readable "ClosCanalEtMontreMSF $Aligneur $Canal $Out.msf $Log"
	Warne "$Aligneur est lance en batch"
	return "$Out.msf"
    }

    if { $Mode == "Interactif" } {
	set In  $Tmp.inp
	Sauve [ConcatLesTFAs $Selection] dans $In
	set LesFichiersCrees [list "$In"]
	foreach Ali [split $Aligneur "+"] {
	    set Out $Tmp.$Ali.out
	    set Log $Tmp.$Ali.log
	    Warne "$Ali lance en interactif ... un peu de patience. Merci."
	    eval exec "[set Commandes($Aligneur)] $In $Out $Log"
	    Warne "                                                            ... j'ai fini."
	    File delete -force $Out
	    File delete -force $Log
	    lappend LesFichiersCrees "$Out.msf"
	}
	if {[regexp "+" $Aligneur]} {
	    return $LesFichierCrees
	} else {
	    return "$Out.msf"
	}
    }
}

proc CocheAligneurs {} {
    global Aligneurs retourCoche AligneursCochons
    
    Gs "Rien"
    
    set w [NomDe coche]
    catch {destroy $w}
    toplevel $w
    wm title $w "Merci de cocher ..."
    wm iconname $w "Coche"
    
    frame  $w.buttons
    pack   $w.buttons -side bottom -fill x -pady 2m
    button $w.buttons.dismiss -text "Dismiss" -background red    -foreground white \
	    -command "set retourCoche($w) Dismiss"
    pack   $w.buttons.dismiss -side left -expand 1
    button $w.buttons.defaut -text "Default"  -background yellow -foreground black \
	    -command "set retourCoche($w) Defaut"
    pack   $w.buttons.defaut -side left -expand 1
    button $w.buttons.accept -text "Accept"   -background green  -foreground black \
	    -command "set retourCoche($w) Accept"
    pack   $w.buttons.accept -side left -expand 1

    set i 0
    foreach a [Aligneurs] {
	set AligneursCochons($a) [Aligneurs $a]
	set b $w.b$a
	checkbutton $b -text "$a" -variable AligneursCochons($a) -relief flat
	pack $b -side top -pady 2 -anchor w
    }

    tkwait variable retourCoche($w)
    if { [set retourCoche($w)] == "Defaut" } {
	foreach a [Aligneurs] {
	    set AligneursCochons($a) [Aligneurs $a "Defaut"] 
	}
	while { [set retourCoche($w)] == "Defaut" } {
	    unset retourCoche($w)
	    tkwait variable retourCoche($w)
	}
    }
    if { [set retourCoche($w)] != "Dismiss" } {
	foreach a [Aligneurs] {
	    set Aligneurs($a) [set AligneursCochons($a)] 
	}
    }
    unset retourCoche($w)
    catch { unset $AligneursCoches }
    foreach a [Aligneurs] {
	if {[Aligneurs $a]} {
	    set AligneursCoches($a) 1
	}
    }
    destroy $w
}

proc Aligneurs {{LeQuel ""} {Defaut ""}} {
    Wup "Returns array Aligneurs, AligneursCoches or Aligneur($LeQuel)" 
    global Aligneurs AligneursCoches AligneursDefaut

    if { ! [info exists Aligneurs]} {
	set Aligneurs(clustalw) 1
	set Aligneurs(dialign)  0
	set Aligneurs(pileup)   0
	set Aligneurs(prrp)     0
	foreach {a ValAligneurs} [array get Aligneurs] {
	    set AligneursDefaut($a) $ValAligneurs
	    if {$ValAligneurs} {
		set AligneursCoches($a) $ValAligneurs
	    }
	}
    }

    if {$LeQuel==""} {
	return [array names Aligneurs]
    }
    if {$LeQuel=="Coches"} {
	return [array names AligneursCoches]
    }
    if { $Defaut == "" } {
	if {[info exists Aligneurs($LeQuel)]} {
	    return [set Aligneurs($LeQuel)]
	} else {
	    return 0
	}
    } else {
	if {[info exists AligneursDefaut($LeQuel)]} {
	    return [set AligneursDefaut($LeQuel)]
	} else {
	    return 0
	}
    }
}

proc DuGrec Fichier {
    foreach C [split [ContenuDuFichier $Fichier] ""] {
	if {$C > "z" || $C == "?"} {
	    Espionne "Grec >$C< [string range $Nouveau end-10 end]"
	    if { ! [info exists Remplace($C)]} {
		set Remplace($C) [Entre]
	    }
	    set C [set Remplace($C)]
	}
	lappend Nouveau $C
    }
    Espionne [Sauve [join $Nouveau ""] dans $Fichier.nouveau]
    exit
}

proc YaPABouTROUouTRNAouARNenDebutDe Texte {
    if {[YaPABenDebutDe $Texte]} { return 1 }
    if {[regexp {^TROU|^TRNA|^ARN} $Texte]} { return 1 }
    return 0
}

proc EstPABouTROUouTRNAouARN Texte {
    if {[EstUnPAB $Texte]} { return 1 }
    #if {[regexp -nocase {^(TROU|TRNA|ARN)[0-9]+[nN]?} $Texte]} { return 1 }
    if {[regexp -nocase {^(TROU|TRNA|ARN|rRNA|ncRNA)} $Texte]} { return 1 }
    return 0
}

proc YaPABouTROUouTRNAouARNdans Texte {
    if {[YaPABdans $Texte]} { return 1 }
    if {[regexp -nocase {TROU|TRNA|ARN} $Texte]} { return 1 }
    return 0
}

proc YaPABenDebutDe Texte {
    if {[regexp "^[PreFixe]" $Texte]} { return 1 }
    return 0
}

proc YaPABdans Texte {
    if {[OnTraite "REFUNI" "NonStrict"] && [regexp {^(AGAM|SCER|XTRO)[0-9\.]+} $Texte]} { return 1 }
    if {[regexp "[PreFixe]" $Texte]} { return 1 }
    return 0
}

proc EstUnPAB Texte {
    if {[OnTraite "REFUNI" "NonStrict"] && [regexp {^(AGAM|SCER|XTRO)[0-9\.]+} $Texte]} { return 1 }
    return [regexp "^[ExpressionReguliereDesPABs]$" $Texte]
}

proc ExpressionReguliereDesPABs {} {
    global ConfigChargee
    if { ! [info exists ConfigChargee] || ! $ConfigChargee } { return "EXPRESSION_REGULIERE_DES_PABS_NON_VALIDE" }
    return "^[PreFixe]\[0-9\\.\]+"
}

proc PreFixe {{Nouveau ""}} {
    global PrefixeDesORFs

    if {$Nouveau!=""} { set PrefixeDesORFs $Nouveau }

    if { ! [info exists PrefixeDesORFs]} { set PrefixeDesORFs "ORF" }
    return $PrefixeDesORFs
}

proc NumeroDu Nom {
    if {[regexp {[^0-9]([0-9]+)$} $Nom Match Numero]} { return $Numero }
    return ""
}

proc MoyenneDesPourcentages {} {
    global RepertoireDuGenome

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/pourcentageidentite-orga"] {
	scan $Ligne "%s %s %d" Nom Orga PI
	if { [info exists Cumul($Orga)] } {
	    incr Cumul($Orga) $PI
	    incr Nombre($Orga)
	} else {
	    set Cumul($Orga) 0
	    set Nombre($Orga) 0
	}
    }
    foreach {Orga ValCumul} [array get Cumul] {
	lappend Liste "$Orga [expr $ValCumul/[set Nombre($Orga)]]"
    }
    set ListeTriee [lsort -decreasing -command CompareLesIntegers $Liste]
    foreach Texte $ListeTriee {
	puts "Moyenne des pourcentages d'identite pour $Texte"
    }
}

proc ListonsLesTrous {LongMotif Offset} {
    global RepertoireDuGenome
    global ListeDesTROUs

    if { ! [info exists ListeDesTROUs]} { ChargeLesTROUs }

    foreach Boite $ListeDesTROUs {
	set Nom    [Box $Boite nom]
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]

	set Long [expr $Fin-$Debut+1]

	if {[info exists Histo($Long)]} {
	    incr Histo($Long)
	} else {
	    set Histo($Long) 1
	}
	set DF [Maxi $Debut [expr $Fin-$Offset-$LongMotif]]
	set FF [Mini $Fin [expr $Fin-$Offset+$LongMotif]]
	set SeqF [BoutADN $DF $FF "F"]

	set DR [Maxi $Debut [expr $Debut+$Offset-$LongMotif]]
	set FR [Mini $Fin [expr $Debut+$Offset+$LongMotif]]
	set SeqR [BoutADN $DR $FR "R"]
	set Entamme "f${SeqF}r${SeqR}"
	set Termine "f${SeqF}r${SeqR}"

	append Entammes $Entamme
	append Termines $Termine

#	lappend LesTrousDeLongueur($Long) "[BoutADN $Debut $Fin "F"] f $Nom"
#	lappend LesTrousDeLongueur($Long) "[BoutADN $Debut $Fin "R"] r $Nom"
    }

    regsub -all "A|T" $Entammes "-" Entammes
    regsub -all "C|G" $Entammes "O" Entammes
    regsub -all "A|T" $Termines "-" Termines
    regsub -all "C|G" $Termines "O" Termines

    for {set i 0} {$i<[string length $Entammes]-$LongMotif} {incr i} {
	set MotifE [string range $Entammes $i [expr $i+$LongMotif-1]]
	set MotifT [string range $Termines $i [expr $i+$LongMotif-1]]
 	if { ! [regexp "f|r" $MotifE]} {
	    if {[info exists HistoE($MotifE)]} {
		incr HistoE($MotifE)
	    } else {
		set HistoE($MotifE) 1
	    }
	}
 	if { ! [regexp "f|r" $MotifT]} {
	    if {[info exists HistoT($MotifT)]} {
		incr HistoT($MotifT)
	    } else {
		set HistoT($MotifT) 1
	    }
	}
    }
     foreach MotifE [array names HistoE] {
	lappend HME "[set HistoE($MotifE)] $MotifE"
    }
     foreach MotifT [array names HistoT] {
	lappend HMT "[set HistoT($MotifT)] $MotifT"
    }
    set E [lsort -command CompareLesIntegersEnDebut $HME]
    set T [lsort -command CompareLesIntegersEnDebut $HMT]
    foreach t $T {
	puts "$t"
    }
    return 
    set Sortie {}
    foreach Long [lsort -decreasing -integer [array names Histo]] {
	puts "$Long [set Histo($Long)]"
	if {$D<=$Long && $Long<=$F} {
	    set Sortie [concat $Sortie [set LesTrousDeLongueur($Long)]]
	}
    }
    puts [join [lsort $Sortie] "\n"]
}

proc HistogrammeDuTas {Fichier {LesTabs ""}} {

    if {$LesTabs==""} {
	set LesTabs {10 20 30 40 50 60 70 80 90 100}
    }

    set LesSCs {}
    foreach Ligne [lrange [LesLignesDuFichier $Fichier] 2 end] {
	if { ! [YaPABdans $Ligne]} { continue }
	scan $Ligne "%s %d %s %d" Nom FF SC PI

	if {$Fichier == "rr-phor.tas" || $Fichier == "rr-pfur.tas" } {
	    set SC XX
	}

	if {[lsearch $LesSCs $SC] < 0 } { lappend LesSCs $SC }
	set OldTab -1
	foreach Tab $LesTabs {
	    if {$OldTab < $PI && $PI <= $Tab} {
		if {[info exists Histo($SC,$Tab)]} {
		    incr Histo($SC,$Tab)
		} else {
		    set Histo($SC,$Tab) 1
		}
		break
	    }
	    set OldTab $Tab
	} 
    }

    foreach SC $LesSCs {
	foreach Tab $LesTabs {
	    if {[info exists Histo($SC,$Tab)]} {
		puts "$SC $Tab [set Histo($SC,$Tab)]"
	    } else {
		puts "$SC $Tab 0"
	    }
	}
    }
}

proc MontreTousCeuxQuiSont {CommeCa {Orga ""}} {
    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }

    Wup "OrgaPi n'existe plus ... le reecrire si necessaire." 

    foreach Boite $ListeDeBoites {
	set Nom [Box $Boite nom]
	if { ! [regexp $CommeCa [Cas $Nom]]} { continue }
#	MontreNomSuperClassePI $Nom $Orga
	puts "$Nom [Cas $Nom] [FiabiliteFonction $Nom] [ClasseFonctionnelle $Nom] [NomDeGene $Nom] [Definition $Nom]"
	puts "        [join [lrange [PhylonOrgaEtDistance $Nom] 0 16] "  "]"
	puts "        [join [lrange [OrgaPi $Nom] 0 16] "  "]"
    }
}

proc MontreNomSuperClassePI {Nom Orga} {
    puts "$Nom [FiabiliteFonction $Nom] [SuperClasse [ClasseFonctionnelle $Nom]] [PourcentageIdentiteOrga $Nom $Orga]"
}

proc NomCompletDeLaSuperClasse SP {
    if {[regexp "Hy" $SP] } { return "Hypothtical protein" }
    if {[regexp "NC" $SP] } { return "Not Classified" }
    if {[regexp "CP" $SP] } { return "Cellular Processing" }
    if {[regexp "Tl" $SP] } { return "TransLation" }
    if {[regexp "RT" $SP] } { return "Replication and Transcription" }
    if {[regexp "CE" $SP] } { return "Cellular Envelope" }
    if {[regexp "Me" $SP] } { return "Metabolisme" }
    if {[regexp "tR" $SP] } { return "tRNAs tranfert RiboNucleic Acids" }
    if {[regexp "RR" $SP] } { return "rRNAs Ribosomal RiboNucleic Acids" }
    if {[regexp "IG" $SP] } { return "InterGenic region" }
    FaireLire "SuperClasse $SP inconnue ... I call it 'Unknown SuperClass"
    return "Unknown SuperClass"
}

proc SuperClasse Classe {
    if {[regexp {^00}                     $Classe]} { return "Hy" }
    if {[regexp {000}                     $Classe]} { return "Hy" }
    if {[regexp {161}                     $Classe]} { return "Hy" }
    if {[regexp {153}                     $Classe]} { return "NC" }
    if {[regexp {^14|^08|121|151}         $Classe]} { return "CP" }
    if {[regexp {^11}                     $Classe]} { return "Tl" }
    if {[regexp {^09|^10}                 $Classe]} { return "RT" }
    if {[regexp {^13|^03}                 $Classe]} { return "CE" }
    if {[regexp {^01|^02|^04|^05|^06|^07} $Classe]} { return "Me" }
    if {[regexp {191}                     $Classe]} { return "tR" }
    if {[regexp {192}                     $Classe]} { return "RR" }
    if {[regexp {200}                     $Classe]} { return "IG" }
    FaireLire "Class $Classe unknown ... I call it 'UK'"
    return "UK"
}


proc CreePourcentageIdentite {{Banque "genomes"}} {
    global RepertoireDuGenome
    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }

    foreach Boite $ListeDeBoites {
	set Nom [Box $Boite nom]
	set Fichier "$RepertoireDuGenome/tblastn$Banque/$Nom"

	puts "$Nom $Fichier"
	if { ! [file exists $Fichier]} { continue }

	Wup "Commentariser ci-dessus (pour les paralogues par ex.) ou les 2 ci-dessous ou l'un"
	lappend Liste "$Nom [join [OuATapeTBlastN $Fichier $Banque ListeDesOrganismes] " "]"
	Wup "Je rappelle que je triche en cachant le pourcentage dans score"
	lappend Liste "$Nom [join [OuATapeTBlastN $Fichier $Banque ListeDesScores] " "]"
    }
    SauveLesLignes $Liste dans "$RepertoireDuGenome/fiches/pourcentageidentite.$Banque.arenommer"
}

proc ToggleCanva {K Tag} {
    global Action
    global CouleurDuFond

    if { ! [info exists Action]} { set Action "raise" }
    if { $Action == "raise" } {
	set Action "lower"
	set Couleur $CouleurDuFond
    } else {
	set Action "raise"
	set Couleur "black"
    }

    $K itemconfigure $Tag -fill $Couleur
    $K $Action $Tag

}

proc Cas Nom {
    global RepertoireDuGenome
    global LesCas

    if { ! [info exists LesCas]} {
	if {[file exists "$RepertoireDuGenome/fiches/lescas"]} {
	    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/lescas"] {
		scan $Ligne "%s %s" PAB Cas
		set LesCas($PAB) $Cas
	    }
	} else {
	    set LesCas Bidon
	}
    }
    if {[info exists LesCas($Nom)]} {
	return [set LesCas($Nom)]
    } else {
	return "CasNonConnu"
    }
}

proc ElimineLesEnterres {} {
    global RepertoireDuGenome

    ChargeLesPABs

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdespabs"] {
	scan $Ligne "%s" Nom 

	if {[Enterre $Nom]} {
	    lappend ListeDesEnterres $Ligne
	} else {
	    lappend ListeDesBornesDesPABs  $Ligne
	}
    }

    set ListeDesEnterres [lsort $ListeDesEnterres]
    set ListeDesBornesPABs [lsort -command CompareLesMilieux $ListeDesBornesDesPABs]

    Espionne [SauveLesLignes $ListeDesEnterres   dans "$RepertoireDuGenome/fiches/bornesdesenterres.arenommer"]
    Espionne [SauveLesLignes $ListeDesBornesDesPABs dans "$RepertoireDuGenome/fiches/bornesdespabs.arenommer"]
}

proc Note Nom {
    global RepertoireDuGenome

    set FichierNote "$RepertoireDuGenome/notes/$Nom"
    if {[file exists $FichierNote]} { return [ContenuDuFichier $FichierNote] }
    return ""    
}

proc CreeToutesLesNotesPourCollection {} {
    global RepertoireDuGenome

    set RepNotes "$RepertoireDuGenome/notes"
    if { ! [file exists $RepNotes]} { File mkdir $RepNotes }

    foreach Boite [ListeDeBoites] {
	set Note {}
	set Nom    [Box $Boite nom]

	set Access [Narcisse $Nom]
	if {$Access==""} {
	    set TexteAccess "This ORF couldn't yet be found in database."
	} else {
	    set TexteAccess "$Access is its database accession number."
	}

	lappend Note "$Nom [NomDeGene $Nom]"
	lappend Note "[DefinitionApproximative $Nom]"

	set MD [MDScore $Nom]
	if {$MD > -9999.0} { lappend Note "MD score of multialignment $MD" }

	if {[set TexteNote [ExtraitInfo $Nom "Note"]]!=""} {
	    lappend Note $TexteNote
	}

	lappend Note ""

	set Texte [RecapitulatifDesOrthologues $Nom "TPMA"]
	if { $Texte != "" } { lappend Note "$Texte" }

	SauveLesLignes $Note dans "$RepNotes/$Nom"
    }
    return ""
} 

proc CreeToutesLesNotes {{Liste ""}} {
    global RepertoireDuGenome
    global Org1 Org2

    if {[OnTraiteDesCDNAs]}      { return [CreeToutesLesNotesPourCDNA] }
    if {[OnTraiteUneCollection]} { return [CreeToutesLesNotesPourCollection] }

    set RepNotes "$RepertoireDuGenome/notes"
    if { ! [file exists $RepNotes]} { File mkdir $RepNotes }

    if {$Liste==""} { set Liste [ListeDesPABs] }

    foreach Boite $Liste {
	set Note {}
	set Nom    [Box $Boite nom]
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]	

	set Long [expr ($Fin - $Debut + 1)/3]
	set CF [ClasseFonctionnelle $Nom]
	if {$CF==000} { set $CF "" } 

	set Access [Narcisse $Nom]
	if {$Access==""} {
	    set TexteAccess "This ORF couldn't yet be found in database."
	} else {
	    set TexteAccess "$Access"
	}

	lappend Note "$Nom"
	lappend Note ""
	set GN [NomDeGene $Nom]
	if {$GN!="" && $GN!=$Nom} {
	    lappend Note "Gene Name : $GN"
	} 
	lappend Note "Accession number : $TexteAccess"
	lappend Note "Function : [DefinitionApproximative $Nom]"
	set FF [FiabiliteFonction $Nom]
	set FDR "Unknown"
	if { $FF == 9 } { set FDR "Function definition reliability: High" }
	if { $FF == 7 } { set FDR "Function definition reliability: Good" }
	if { $FF == 5 } { set FDR "Function definition reliability: Low" }
	if { $FF == 3 } { set FDR "Function definition reliability: motif on small region" }
	if { $FF == 1 } { set FDR "Function definition reliability: any function detected" }
	if { $FF == 0 } { set FDR "Function definition reliability: no homology found" }
#	lappend Note $FDR
	lappend Note ""
	if {$Orient=="F"} { set Sens "+" } else { set Sens "-" } 
	lappend Note "Genome localisation : $Debut $Fin $Sens  $Long AA"
	lappend Note ""
 	set Texte [ExtraitInfo $Nom "PMID"]
	if { $Texte != "" } { lappend Note "PMID : $Texte\n" }

	set CompoATGC [CompositionEn ATGC $Nom]
	if { $CompoATGC != "" } {
	    scan $CompoATGC "%d %d %d %d %d %d" GC AT A T G C
	    lappend Note "ATGC composition : GC=$GC %  AT=$AT %  A=$A %  T=$T %  G=$G %  C=$C %"
	}
	set Texte [Overlap $Nom]
	if { $Texte != "" } { lappend Note "Overlap : $Texte" }

	set Texte [ShineDalgarno $Nom "Nice"]
	if { $Texte != "" } { lappend Note $Texte }

	lappend Note ""

	set Avant [TexteOMO $Nom Avant]
	set Apres [TexteOMO $Nom Apres]
	if {$Avant!="" || $Apres!=""} {
	    lappend Note "Two genes cluster maintenance"
	}
	if {$Avant!=""} { lappend Note "  with previous : [TexteOMO $Nom Long]" }
	if {$Apres!=""} { lappend Note "  with next     : [TexteOMO $Apres Long]" }
	
	set Texte [SignalDAutresHomologues $Nom]
	if { $Texte != "" } { lappend Note "Other homologs : $Texte" }

	lappend Note ""

	set nCops [NombreDeCopainsDansBlast $Nom]
	lappend Note "BlastP hits count : $nCops"

	if {0 && [info exists Org1] && [YaPABdans $Nom] && ! [ExisteOrthologueDans $Org1 $Nom]} {
	    lappend Note "Ortholog not found in [Glossaire $Org1 Complet]"
	}
	if {0 && [info exists Org1] && [YaPABdans $Nom] && ! [ExisteOrthologueDans $Org2 $Nom]} {
	    lappend Note "Ortholog not found in [Glossaire $Org2 Complet]"
	}
	set nParalogues [NombreDeParaloguesDe $Nom]
	if {$nParalogues==-1} {
	    set Texte ""
	} elseif {$nParalogues==0} {
	    set Texte "Paralogs : not found"
	} else {
	    set Texte "Paralogs : $nParalogues were found"
	}
	if { $Texte != "" } { lappend Note $Texte }
	lappend Note ""

	set pTBN [PourcentageDeGenomesCompletsOrthologuesDansTBlastN $Nom]
	set pDBC [PourcentageDeGenomesCompletsOrthologuesDansDbClustal $Nom]
	set nGinTBN [PourcentageDeGenomesCompletsOrthologuesDansTBlastN   "Count"]
	set nGinDBC [PourcentageDeGenomesCompletsOrthologuesDansDbClustal "Count"]
	lappend Note "Orthologuous organisms (within the $nGinDBC studied complete genomes)"
	lappend Note "  percentage in TBlastN   : $pTBN %  of $nGinTBN"
	lappend Note "  percentage in DbClustal : $pDBC %  of $nGinDBC"
	lappend Note ""
	
	set Texte [RecapitulatifDesOrthologues $Nom "TPMA"]
	if { $Texte != "" } { lappend Note "$Texte" }
	
	lappend Note ""
	set MD [MDScore $Nom]
	if {$MD > -9999.0} { lappend Note "NormMD : score of multialignment $MD" }
	lappend Note ""
 	set Start [StartCodonReport $Nom "Start"]
	set Texte $Start
	if {[regexp {[0-9]+} $Start Pos]} {
	    set Summary [StartCodonSummary $Nom $Pos]
	    if { ! [regexp "NoSummary" $Summary] } {
		scan $Summary "%d" iGGT
		set GGT ""
		if {$iGGT>0} {
		    set GGT [string trim [string range $Summary 55 end]]
		    append Texte " with ShineDalgarno at $iGGT $GGT"
		}
	    }
	}
	Espionne "$Nom $Texte"
	lappend Note "Proposed start codon : $Texte"
	set Texte [CAI $Nom]
	if {$Texte!=""} { lappend Note "Codon Adaptation Index : $Texte" }
	set Hi [Hydrophobicity $Nom "Hydro"]
	set Hn [Hydrophobicity $Nom "nHelices"]
	if {$Hi!=-999} { lappend Note "Hydrophobicity : Index $Hi ,  $Hn predicted helices" }
	lappend Note ""

	lappend Note [ContenuDuFichier $RepertoireDuGenome/prottfa/$Nom]
	lappend Note ""
	lappend Note [ContenuDuFichier $RepertoireDuGenome/nuctfa/$Nom]
	set MaxD 0
	foreach Ligne $Note {
	    if {[regexp -indices { \: } $Ligne Indices]} {
		scan $Indices "%d" D
		set MaxD [Maxi $MaxD $D]
	    }
	}
	incr MaxD 2
	set LaBelleNote {}
	foreach Ligne $Note {
	    if {[regexp -indices { \: } $Ligne Indices]} {
		scan $Indices "%d" D
		set nPoints [string repeat "." [expr $MaxD - $D]]
		regsub { \: } $Ligne " $nPoints : " Ligne
	    }
	    lappend LaBelleNote $Ligne
	}
	SauveLesLignes $LaBelleNote dans "$RepNotes/$Nom"
    }
    return $LaBelleNote
} 

proc SignalDAutresHomologues Nom {
    set AutresHomologues [ExtraitInfo $Nom "AutresHomologues"]
    if { ! [regexp "signal" $AutresHomologues]} { return "" }
    return "$AutresHomologues"
}

proc NomDeGeneIssuDeDefinitionApproximativePourTous {{Ask ""}} {
    global InformeSansDemander

    if {[info exists InformeSansDemander]} { set Memo $InformeSansDemander }
    if {$Ask==""} { set Ask 1 } else { set Ask 0 }
    set InformeSansDemander [expr ! $Ask]
    foreach Nom [ListeDesPABs] {
	set GNDA [NomDeGeneIssuDeDefinitionApproximative $Nom]
	if {$GNDA==""} { continue }
	if {$Ask} {
	    set OldGN [NomDeGene $Nom]
	    if {$OldGN=="" || [YaPABdans $OldGN]} {
		set Message "use $GNDA "
	    } else {
		set Message "replace $OldGN with $GNDA "
	    }
	    if { ! [OuiOuNon "Can I $Message as Gene Name for $Nom ?"]} { continue }
	}
	Informe $Nom "ValiGN: $GNDA"
	if {$Ask && [OuiOuNon "Do I stop asking ?"]} {
	    set Ask 0
	    set InformeSansDemander 1
	}
    }
    if {[info exists Memo]} {
	set InformeSansDemander $Memo
    } else {
	unset InformeSansDemander
    }
}

proc NomDeGeneIssuDeDefinitionApproximative Nom {
    set DA [DefinitionApproximative $Nom]
    regsub -nocase {\(taken from [a-z]*\)} $DA "" DA
    set DA [string trim $DA]
    if { ! [regexp -nocase {\([a-z_\-]+\)$} $DA Match]} { return "" }
    regsub -all {[\(\)]} $Match "" GNDA
    return $GNDA
}

proc NomDeGene Nom {
    set ValiGN [ExtraitInfo $Nom "ValiGN"]

    if {$ValiGN == ""} {
	return $Nom
    } else { 
	return $ValiGN
    }
} 

proc BestDefinitionOfDbClustalPourTous {} {
    foreach Nom [ListeDesPABs] {
	set DE [BestDefinitionOfDbClustal $Nom]
	Espionne "$Nom $DE"
	InformeSansDemander $Nom "DE_DbClustal: $DE"
    }
}

proc BestDefinitionOfDbClustal Nom {
    global NotreOS
    global NotreOrga
    foreach {Orga Dist Access} [LesOrgaDistAccessDesOrthologues $Nom] {
	if {$Orga==$NotreOrga} { continue }
	if {[EstUnAccessPDB $Access]} {
	    set OS [OrganismeDuPDB $Access]
	    set DE [TextePDB $Access "KEYWDS"]
	} else {
	    set OS [OrgaDuAccess $Access]
	    set DE [DefinitionDuAccess $Access]
	}
	if {$DE=="" || [regexp -nocase "hypothetical" $DE]} { continue }
	return "$DE (from $OS $Access dist=$Dist)" 
    }
    return ""
}

proc BestDefinitionOfLeonPourTous {} {
    foreach Nom [ListeDesPABs] {
	set DE [BestDefinitionOfLeon $Nom]
	if {$DE==""} { continue }
	Espionne "$Nom $DE"
	InformeSansDemander $Nom "DE_Leon: $DE"
    }
}

proc BestDefinitionOfLeon Nom {
    set NotreOS    [NotreOS]
    set NotreOrga  [NotreOrga]
    set NotreTaxId [NotreTaxId]

    set FichierLeon "[RepertoireDuGenome]/leonLeo/$Nom"
    if { ! [file exists $FichierLeon]} {
	set FichierLeon "[RepertoireDuGenome]/leonLeo/$Nom.msf"
    }
    if { ! [file exists $FichierLeon]} { return "" }
    set n [DecortiqueUnMSF $FichierLeon LesNomsDeSequences]
    foreach NomSeq $LesNomsDeSequences] {
	set Dae [DaedalusHit $NomSeq $Nom]
	if {$Dae!=""} {
	    set TaxId [ChampDaedalus TaxId $NomSeq $Nom] 
	    if {$TaxId==$NotreTaxId} { continue }
	}
	set Orga
	if {$Orga==$NotreOrga} { continue }
	if {[EstUnAccessPDB $Access]} {
	    set OS [OrganismeDuPDB $Access]
	    set DE [TextePDB $Access "KEYWDS"]
	} else {
	    set OS [OrgaDuAccess $Access]
	    set DE [DefinitionDuAccess $Access]
	}
	if {$DE=="" || [regexp -nocase "hypothetical" $DE]} { continue }
	return "$DE (from $OS $Access dist=$Dist)" 
    }
    return ""
}

proc BestDefinitionOfBlastXPourTous {{SeuilExpect ""} {ForbidenWordInDE ""} {RepDuBlast ""} {UseFirstDE ""} {NoAccessInHit ""}} {
    foreach Nom [ListeDesPABs] {
	set DE [BestDefinitionOfBlastX $Nom $SeuilExpect $ForbidenWordInDE $RepDuBlast $UseFirstDE $NoAccessInHit]
	if {$DE==""} { continue }
	Espionne "$Nom $DE"
	InformeSansDemander $Nom "DE_BlastX: $DE"
    }
}

proc BestDefinitionOfBlastPPourTous {{SeuilExpect ""} {ForbidenWordInDE ""} {RepDuBlast ""} {UseFirstDE ""} {NoAccessInHit ""}} {
    foreach Nom [ListeDesPABs] {
	set DE [BestDefinitionOfBlastP $Nom $SeuilExpect $ForbidenWordInDE $RepDuBlast $UseFirstDE $NoAccessInHit]
	if {$DE==""} { continue }
	Espionne "$Nom $DE"
	InformeSansDemander $Nom "DE_BlastP: $DE"
    }
}

proc BestDefinitionOfBlastX {Nom {SeuilExpect ""} {ForbidenWordInDE ""} {RepDuBlast ""} {UseFirstDE ""} {NoAccessInHit ""}} {
    if {$RepDuBlast==""} { set RepDuBlast "blastx" }
    return [BestDefinitionOfBlastP $Nom $SeuilExpect $ForbidenWordInDE $RepDuBlast $UseFirstDE $NoAccessInHit]
}

proc BestDefinitionOfBlastP {Nom {SeuilExpect ""} {ForbidenWordInDE ""} {RepDuBlast ""} {UseFirstDE ""} {NoAccessInHit ""}} {
    global RepertoireDuGenome
    global NotreOS
    global NotreOrga

    Wup "Attention ca marche AUSSI pour BlastX  avec RepDuBlast"

    if {$RepDuBlast==""} { set RepDuBlast "blastp" }
    if {$ForbidenWordInDE==""} { set ForbidenWordInDE "hypotheticalxxxxxxxxxxxxxxxxxxxx" }
    if {$SeuilExpect==""} { set SeuilExpect 0.001 }

    set FichierBlastP "$RepertoireDuGenome/$RepDuBlast/$Nom"
    if { ! [file exists $FichierBlastP]} { return "No blastp" }

    #rR depuis 2021/10/11 on peut dire qu'il n'y a pas d'access
    set lAccessOrNoAccessInHit lAccess
    if {[string equal -nocase $NoAccessInHit "NoAccessInHit"]} { set lAccessOrNoAccessInHit "NoAccessInHit" }
    DecortiqueBlast $FichierBlastP "SansSeuilExpect" "SansLimiteDeNombre" Query lBanqueId $lAccessOrNoAccessInHit lDE lProfil lPN
    if {[string equal -nocase $NoAccessInHit "NoAccessInHit"]} { set lAccess $lBanqueId }
    foreach BanqueId $lBanqueId Access $lAccess DE $lDE PN $lPN {
	Espionne $BanqueId $Access $DE
	if {$PN>$SeuilExpect} { continue }
	if {[regexp -nocase {^UniRef[0-9]+_(.+)} $BanqueId Match A]} {
	    set Access $A
	}
	if {[regexp {\:} $BanqueId]} {
	    set N [StringApres ":" dans $BanqueId]
	    if {[EstUnPAB $N]} {continue}
	}
	if {$DE=="" || [regexp -nocase $ForbidenWordInDE $DE]} { continue }
	Espionne DE $DE
	if {[string equal -nocase $UseFirstDE "UseFirstDE"]} {
	    return "$DE (from FirstHit WithDefinition $Access expect=$PN)" 
	}
	if {[EstUnAccessPDB $BanqueId]} {
	    set aPDB $BanqueId
	    set OS [OrganismeDuPDB $aPDB]
	    set DE [TextePDB $aPDB "KEYWDS"]
	} else {
	    if {[regexp -nocase {^UniRef[0-9]+_(.+)*} $Access Match Acc]} {
		set Access $Acc
	    } 
	    #	    set OS [QuestionDeScience QuidSeq "QuidOSOfAC $Access"]
	    set OS ""
	    set DE ""
	    #rR j'ai interverti les  DecortiqueLesLignesEMBL avec LesChampsInteressantsDuAccess
	    if {1 || $OS==""} {
		set LEmbl [LaSequenceDesBanques $BanqueId $Access AOk "OnVeutEmbl"]
		if {$LEmbl=={}} { continue }
		DecortiqueLesLignesEMBL $LEmbl IDlu AClu DElu GNlu OSlu OClu OXlu
		set OS $OSlu
		set DE $DElu
		regsub -all {[ \n\t]+} $DE " " DE
		set DE [string trim $DE]
	    }
	    if {$DE==""} {
		ScanLaListe [LesChampsInteressantsDuAccess $Access $Access "OS" "DE" ] OS DE
	    }
	    regsub -all {[ \n\t]+} $DE " " DE
	    set DE [string trim $DE]
	    set OS [string trim $OS]
	    Espionne $DE
	}
	if {$DE=="" || $OS==""} { continue }
	return "$DE (from $OS $Access expect=$PN)" 
	return $DE
    }
    return ""
}

proc DefinitionRapide Nom {
    return [Definition $Nom "ApproxDansInfo"]
}

proc DefinitionApproximative Nom {
    return [Definition $Nom "Approx"]
}

proc Definition {Nom {Approx ""}} {
    set ValiDE [ExtraitInfo $Nom "ValiDE"]

    if {$ValiDE != ""} { return $ValiDE }

    if {[OnTraiteDesCDNAs]} { return "" }

    if {$Approx!=""} {
	set DE [ExtraitInfo $Nom "DEJ"]
	if {$DE!=""} { return "$DE"}

	set DE [ExtraitInfo $Nom "SpineDef"]
	if {$DE!=""} { return "$DE"}

	set DE [ExtraitInfo $Nom "DE_GenBank"]
	if {$DE!=""} { return "$DE (taken from Genbank)"}

	set DE [ExtraitInfo $Nom "DE_Narcisse"]
	if {$DE!=""} { return "$DE (taken from database)"}

	set DE [ExtraitInfo $Nom "DE_DbClustal"]
	if {$DE!=""} { return "DE_BestDbClustal: $DE" }

	set DE [ExtraitInfo $Nom "DE_BlastP"]
	if {$DE!=""} { return "DE_BlastP: $DE" }
	set DE [ExtraitInfo $Nom "DE_BlastX"]
	if {$DE!=""} { return "DE_BlastX: $DE" }

	if {[regexp "ApproxDansInfo" $Approx]} { return "DE not yet established" }

	set DE [BestDefinitionOfDbClustal $Nom]
	if {$DE!=""} { return "DE_BestDbClustal: $DE" }

	set DE [BestDefinitionOfBlastP $Nom]
	if {$DE!=""} { return "DE_BestBlastP: $DE" }
	set DE [BestDefinitionOfBlastX $Nom]
	if {$DE!=""} { return "DE_BestBlastX: $DE" }
    }
    return "Hypothetical protein or DE not known"
} 

proc ClasseFonctionnelle Nom {
    global SourceClasseFonctionnelle
    global RepertoireDuGenome

    if {[info exists SourceClasseFonctionnelle]} {
	return [ClasseFonctionnelleDans$SourceClasseFonctionnelle $Nom]
    }

    set FichierFonctionsValidees "$RepertoireDuGenome/fiches/fonctionsvalidees"
    if {[regexp "casimir" $RepertoireDuGenome] || ! [file exists $FichierFonctionsValidees]} {
	set SourceClasseFonctionnelle "Info"
    } else {
	set SourceClasseFonctionnelle [ChoixParmiJoli {"Info" "FonctionsValidees"} {} \
		{"Functional classes in Info files" "Functional classes in FonctionsValidees"}]
    }
    return [ClasseFonctionnelle $Nom]
}

proc ClasseFonctionnelleDansInfo Nom {

    if {[regexp "TROU" $Nom]} { return 200 }

    set ValiCF [ExtraitInfo $Nom "ValiCF"]

    set CF 00
    if {[regexp "unknown" $ValiCF]} { set ValiCF 153 }
    scan $ValiCF "%d" CF

    return [format "%3.3d" $CF]
} 

proc ClasseFonctionnelleDansFonctionsValidees Nom {
    global ClasseFonctionnelle
    global RepertoireDuGenome

    if {[info exists ClasseFonctionnelle($Nom)]} { return [set ClasseFonctionnelle($Nom)] }
    if {[info exists ClasseFonctionnelle("EstCharge")]} {
	if {[regexp "TROU" $Nom]} { return 200 }
	return 153
    }

    set ClasseFonctionnelle("EstCharge") 1

    set FichierFonctionsValidees "$RepertoireDuGenome/fiches/fonctionsvalidees"
    if {[file exists $FichierFonctionsValidees]} {
	foreach Ligne [LesLignesDuFichier $FichierFonctionsValidees] {
	    if { ! [regexp {^[A-Z]} $Ligne]} { continue }
	    scan $Ligne "%s %s %s" PAB FF CF
	    set PABY $PAB
	    if {[regexp {PAB[0-9]+} $PAB]} { regsub PAB $PAB [PreFixe] PABY }
	    Espionne "set ClasseFonctionnelle($PABY) $CF"
	    set ClasseFonctionnelle($PABY) $CF
	}
    }
    return [ClasseFonctionnelleDansFonctionsValidees $Nom]
} 

proc CreeLesInfosDesTRNAs {} {
    global RepertoireDuGenome
    global ListeDeBoites
    global ListeDesTRNAs

    ChargeLesTRNAs

    foreach TRNA $ListeDesTRNAs {
	set AA [string range $TRNA 4 6]
	set Codon [string range $TRNA 7 9]
	set Info {}
	lappend Info "Nom: $TRNA"
	lappend Info "ValiDE: tRNA $AA $Codon"
	lappend Info "ValiGN: tRNA-$AA-$Codon"
	lappend Info "ValiCF: 191"
	Espionne [SauveLesLignes $Info dans "$RepertoireDuGenome/infos/$TRNA"]
    }
}

proc RenommeTousLesFichiersDesSousRepertoires {Ancien Nouveau} {
    global RepertoireDuGenome

    foreach Fichier [glob "$RepertoireDuGenome/*/$Ancien"] {
	if { ! [file isfile $Fichier]} { continue }
	set DirName [file dirname $Fichier]
	regsub -all $Ancien [ContenuDuFichier $Fichier] $Nouveau NouveauContenu
	Espionne [Sauve $NouveauContenu dans "$DirName/$Nouveau"]
    }

}

proc RenommageAFaire {} {
    global RepertoireDuGenome
    
    foreach Ligne [LesLignesDuFichier "renommage.afaire"] {
	scan $Ligne "%s %s" Nouveau Ancien
	RenommeTousLesFichiersDesSousRepertoires $Ancien $Nouveau
	lappend LesAnciens $Ancien
	lappend LesNouveaux $Nouveau
    }

    foreach Fichier [glob "$RepertoireDuGenome/fiches/*"] {
	if { ! [file isfile $Fichier]} { continue }
	set Contenu [ContenuDuFichier $Fichier]
	foreach Ancien $LesAnciens Nouveau $LesNouveaux {
	    regsub -all $Ancien $Contenu $Nouveau Contenu
	}
	Espionne [Sauve $Contenu dans "$Fichier"]
    }
}

proc RepriseDesPABsCitesDans FOF {
    foreach Nom [LesLignesDuFichier $FOF] {
	ReprisePAB $Nom
    }
}

proc ReprisePAB Nom {
    global RepertoireDuGenome
    global ListeDeBoites
    global ListeDesTROUs
    global ADN TDN RAC

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }
    if { ! [info exists ADN]} { ChargeADNetTDNetRAC }

    set Debut  [Box $Nom debut]
    set Fin    [Box $Nom fin]
    set Orient [Box $Nom orient]

    set Reprises [ExtraitInfo $Nom "Fusion"]

    if {[llength $Reprises] == 0} { return "" }

    foreach  Reprise [split $Reprises "/"] {
	set LesChamps [split [string trim $Reprise] " "]
	set SequenceLimite [lindex $LesChamps 0]
	set PABaCreer      [lindex $LesChamps 2]
	set Commentaire    $Reprise
	
	Espionne "$Commentaire"

	if {[file exists "$RepertoireDuGenome/prottfa/$PABaCreer"]} {
	    if {[OuiOuNon "J'ecrase $PABaCreer, si non j'abandonne $PABaCreer."]} {
		continue
	    }
	}

	switch -regexp -- $SequenceLimite {
	    {^\-\-\-} { set Offset -2 }
	    {^\-\-}   { set Offset -1 }
	    {^\-}     { set Offset -0 }
	    {\*$}     { set Offset  1 }
	    default { FaireLire "Ca merde pour $Nom $sequenceLimite"; continue}
	}
	regsub -all -- {[^A-Za-z]} $SequenceLimite "" SequenceLimite

	if {$Offset <=0} {
	    if {$Orient == "F"} {
		set D [expr $Debut-3+$Offset]
		set F [expr $D + [string length $SequenceLimite]*3 - 1]
		set AntiSens -1
	    } else {
		set F [expr $Fin+3-$Offset]
		set D [expr $F - [string length $SequenceLimite]*3 + 1]
		set AntiSens  1
	    }
	    set InsisteEncore 10000
	    while {$InsisteEncore} {
		set SeqNuc [BoutADN $D $F $Orient]
		set SeqPro [SeqNucToSeqPro $SeqNuc]
		if {$SequenceLimite == $SeqPro} { break }
		incr D $AntiSens
		incr F $AntiSens
	    }
	    if {$SequenceLimite != $SeqPro} {
		FaireLire "Je ne trouve pas $SequenceLimite devant $Nom. J'abandonne."
		return ""
	    }
	    if {$Orient == "F"} {
		set NouveauDebut $D
		set F [expr $NouveauDebut+2]
		while { [AAduCodon [BoutADN [incr F  1] [incr F  2] $Orient]] != "\*" } { }
		set NouvelleFin [incr F -3]
	    } else {
 		set NouvelleFin  $F
		set D [expr $NouvelleFin]
		while { [AAduCodon [BoutADN [incr D -5] [incr D  2] $Orient]] != "\*" } { }
		set NouveauDebut [incr D 1]
	    }
	    Wup "Ici on a donc etendu la proteine en devant."
	} else {	    
	    if {$Orient == "F"} {
		set D [expr $Debut+3]
		set F [expr $D + [string length $SequenceLimite]*3 - 1]
		set AntiSens +3
	    } else {
		set F [expr $Fin-3]
		set D [expr $F - [string length $SequenceLimite]*3 + 1]
		set AntiSens -3
	    }
	    while {1} {
		set SeqNuc [BoutADN $D $F $Orient]
		set SeqPro [SeqNucToSeqPro $SeqNuc]
		if {[regexp {\*} $SeqPro]} {
		    FaireLire "Je ne trouve pas $SeqenceLimite derriere $Nom."
		    break
		}
		if {$SequenceLimite == $SeqPro} { break }
		incr D $AntiSens
		incr F $AntiSens
	    }
	    if {$Orient == "F"} {
		set NouvelleFin  $F
		set NouveauDebut $Debut
	    } else {
		set NouveauDebut $D
		set NouvelleFin  $Fin
	    }
	    Wup "Ici on a donc etendu la proteine derriere."
	}

	set SeqNuc [BoutADN $NouveauDebut $NouvelleFin $Orient]
	set SeqPro [SeqNucToSeqPro $SeqNuc]

	Espionne "$PABaCreer $NouveauDebut $NouvelleFin $Orient"

	set NUC [SequenceFormatTFA $SeqNuc "$PABaCreer $NouveauDebut $NouvelleFin $Orient" "nucbrut"]
	Espionne [Sauve $NUC dans "$RepertoireDuGenome/nuctfa/$PABaCreer"]
	set TFA [SequenceFormatTFA $SeqPro "$PABaCreer $NouveauDebut $NouvelleFin $Orient" "protbrut"]
	Espionne [Sauve $TFA dans "$RepertoireDuGenome/prottfa/$PABaCreer"]

	Box $PABaCreer nom    $PABaCreer
	Box $PABaCreer debut  $NouveauDebut
	Box $PABaCreer fin    $NouvelleFin
	Box $PABaCreer orient $Orient

    }
}

proc ExtraireDe {Ligne aNom aDebut aFin aOrient} {
    upvar $aNom    Nom
    upvar $aDebut  Debut
    upvar $aFin    Fin
    upvar $aOrient Orient

    regsub ">" $Ligne "" Ligne
    set nChampsLus [scan $Ligne "%s %s %s %s" Nom Debut Fin Orient]
    if {$nChampsLus == 1} {
	if {[OuiOuNonMemo "I couldn't read 'Debut Fin Orient' reading fiches/bornesdespabs\n\
		Do I use default values 0 999 F ?"]} {
	    set Debut 0
	    set Fin 999
	    set Orient "F"
	} else {
	    if {[OuiOuNon "Do I exit ?"]} { Boum }
	    return 
	}
    }
    if { $nChampsLus == 3 } { 
	set Orient "F"
	if { [expr $Fin < $Debut] } {
	    set Temp  $Debut
	    set Debut $Fin
	    set Fin   $Temp
	    set Orient "R"
	}
    }
    return
}

proc DiagnostiquePhyloFolle Nom {
    global RepertoireDuGenome
    global PhylosFolles

    set ListeOrgas [Phylon $Nom]
    if {[llength $ListeOrgas] == 0} { return {} }
    foreach Orga $ListeOrgas {
	if {[PyroLike $Orga]} { continue }
	if {[ArkaeaLike $Orga]} { lappend Folie [string toupper $Orga] ; break }
	lappend Folie $Orga
    }
    return $Folie
}

proc DiagnostiqueLesPhylosFolles {} {
    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }

    foreach Boite $ListeDeBoites {
	set Nom    [Box $Boite nom]    

	if { ! [PhyloFolle $Nom] } { continue }

	set Folie [DiagnostiquePhyloFolle $Nom]
	if { $Folie == {} } { continue }
	puts "$Nom [join $Folie " "]"
    }
}

proc UsageDesCodonsEtCodeCirculaire {} {
    #rR on veut voir si le code circulaire préférencie l'ensemble X0 ci-dessous
    foreach Codon [list AAC AAT ACC ATC ATT CAG CTC CTG GAA GAC GAG GAT GCC GGC GGT GTA GTC GTT TAC TTC] {
	set X($Codon) 1
	set Codon1 "[string range $Codon 1 end][string index $Codon 0]"
	set Codon2 "[string range $Codon1 1 end][string index $Codon1 0]"
	set X1($Codon1) 1
	set X2($Codon2) 1
    }
    set NbCodons 0
    foreach Nom [ListeDesPABs] {
	set FiNuc [GscopeFile $Nom nuctfa]
	if {[FileAbsent $FiNuc]} { continue }
	set Seq [QueLaSequenceDuFichierTFA $FiNuc]
	set Seq [string toupper $Seq]
	foreach {A B C} [split $Seq ""] {
	    set Codon "$A$B$C"
	    if { ! [regexp {^[ATGC][ATGC][ATGC]$} $Codon]} { continue }
	    lappend LesCodons $Codon
	    incr Frame0($Codon)
	    incr NbCodons
	}
	set Seq "[string range $Seq 1 end]X"
	foreach {A B C} [split $Seq ""] {
	    set Codon "$A$B$C"
	    if { ! [regexp {^[ATGC][ATGC][ATGC]$} $Codon]} { continue }
	    lappend LesCodons $Codon
	    incr Frame1($Codon)
	}
	set Seq "[string range $Seq 1 end]X"
	foreach {A B C} [split $Seq ""] {
	    set Codon "$A$B$C"
	    if { ! [regexp {^[ATGC][ATGC][ATGC]$} $Codon]} { continue }
	    lappend LesCodons $Codon
	    incr Frame2($Codon)
	}
    }
    set LesCodons [lsort -unique $LesCodons]
    set LesN0 {}
    set LesN1 {}
    set LesN2 {}
    foreach Codon $LesCodons {
	if { ! [info exists Frame0($Codon)]} {
	    set N 0
	} else {
	    set N $Frame0($Codon)
	}
	lappend LesCodonsDe0($N) $Codon
	lappend LesN0 $N

	if { ! [info exists Frame1($Codon)]} {
	    set N 0
	} else {
	    set N $Frame1($Codon)
	}
	lappend LesCodonsDe1($N) $Codon
	lappend LesN1 $N

	if { ! [info exists Frame2($Codon)]} {
	    set N 0
	} else {
	    set N $Frame2($Codon)
	}
	lappend LesCodonsDe2($N) $Codon
	lappend LesN2 $N
    }
    set LesN0 [lsort -integer -unique -decreasing $LesN0]
    set LesN1 [lsort -integer -unique -decreasing $LesN1]
    set LesN2 [lsort -integer -unique -decreasing $LesN2]

    set LesCodonsTries0 {}
    foreach N $LesN0 {
	LConcat LesCodonsTries0 $LesCodonsDe0($N)
    } 

    set LesCodonsTries1 {}
    foreach N $LesN1 {
	LConcat LesCodonsTries1 $LesCodonsDe1($N)
    } 

    set LesCodonsTries2 {}
    foreach N $LesN2 {
	LConcat LesCodonsTries2 $LesCodonsDe2($N)
    }

    set LesCircu0 {}
    foreach Codon $LesCodonsTries0 {
	if {[info exists Frame0($Codon)]} { set F $Frame0($Codon) } else { set P 0 }
	if {[info exists X($Codon)]} {
	    lappend LesCircu0 $Codon
	    lappend LesPourCent0 [format "%3d" [expr ($F*10000)/$NbCodons]]
	} else {
	    lappend LesCircu0 "   "
	    lappend LesPourCent0 [format "%3d" [expr ($F*10000)/$NbCodons]]
	}
    }

    set LesCircu1 {}
    foreach Codon $LesCodonsTries1 {
	if {[info exists Frame1($Codon)]} { set F $Frame1($Codon) } else { set P 0 }
	if {[info exists X1($Codon)]} {
	    lappend LesCircu1 $Codon
	    lappend LesPourCent1 [format "%3d" [expr ($F*10000)/$NbCodons]]
	} else {
	    lappend LesCircu1 "   "
	    lappend LesPourCent1 [format "%3d" [expr ($F*10000)/$NbCodons]]
	}
    }

    set LesCircu2 {}
    foreach Codon $LesCodonsTries2 {
	if {[info exists Frame2($Codon)]} { set F $Frame2($Codon) } else { set P 0 }
	if {[info exists X2($Codon)]} {
	    lappend LesCircu2 $Codon
	    lappend LesPourCent2 [format "%3d" [expr ($F*10000)/$NbCodons]]
	} else {
	    lappend LesCircu2 "   "
	    lappend LesPourCent2 [format "%3d" [expr ($F*10000)/$NbCodons]]
	}
    }
    set LeMessage {} 
    lappend LeMessage [join $LesCircu0       " "]
    lappend LeMessage [join $LesCodonsTries0 " "]
    lappend LeMessage [join $LesPourCent0    " "]
    lappend LeMessage ""
    lappend LeMessage [join $LesCircu1       " "]
    lappend LeMessage [join $LesCodonsTries1 " "]
    lappend LeMessage [join $LesPourCent1    " "]
    lappend LeMessage ""
    lappend LeMessage [join $LesCircu2       " "]
    lappend LeMessage [join $LesCodonsTries2 " "]
    lappend LeMessage [join $LesPourCent2    " "]
    set Message [join $LeMessage "\n"]
    return [Affiche $Message "" "CodonOrderFor_[NotreOS]"]
}

proc AfficheUsageDesCodons {{Nom ""}} {
    if {$Nom==""} { set Nom [Entre [PreFixe]] }

    set UC [UsageDesCodons $Nom]
    set YaEuEntete 0
    set YaEuPourCent 0
    set LesA {}
    set LesCodons {}
    foreach Ligne [split $UC "\n"] {
	regsub -all {[ \t]+} $Ligne " " Ligne
	set Ligne [string trim $Ligne]
	if {$Ligne==""} { continue }
	set LesMots [LesMotsDuTexte $Ligne]
	if {[regexp -nocase {[A-Z]} $Ligne]} {
	    set LesADeLaLigne {}
	    set LesCodonsDeLaLigne {}
	    foreach {A Codon} $LesMots {
		lappend LesA $A
		lappend LesCodons $Codon
		lappend LesADeLaLigne $A
		lappend LesCodonsDeLaLigne $Codon
	    }
	    set YaEuEntete 1
	    continue
	}
	if {$YaEuEntete} {
	    set YaEuEntete 0
	    foreach A $LesADeLaLigne Codon $LesCodonsDeLaLigne P $LesMots {
		set Gde($A)     $P
		set Gde($Codon) $P
		lappend LesG  $P
		lappend LesADeG($P) $A
		lappend LesCodonDdeG($P) $Codon
	    }
	    set YaEuPourCent 1
	    continue
	}
	if {$YaEuPourCent} {
	    set YaEuPourCent 0
	    foreach A $LesADeLaLigne Codon $LesCodonsDeLaLigne P $LesMots {
		set Lde($A)     $P
		set Lde($Codon) $P
		lappend LesL  $P
		lappend LesADeL($P) $A
		lappend LesCodonDdeL($P) $Codon
	    }
	    continue
	}
    }
    set LesG [lsort -integer -unique -decreasing $LesG]
    set LesL [lsort -integer -unique -decreasing $LesL]

    foreach Codon [list AAC AAT ACC ATC ATT CAG CTC CTG GAA GAC GAG GAT GCC GGC GGT GTA GTC GTT TAC TTC] {
	set X($Codon) 1
    }

    set CodonsG ""
    set PourCentG ""
    foreach G $LesG {
	foreach Codon $LesCodonDdeG($G) {
	    if {[info exists X($Codon)]} {
		append CircuG   [format " %s %s" [AAduCodon $Codon] $Codon]
	    } else {
		append CircuG   [format " %s %s" " " "   "]
	    }
	    set PourCent $G
	    append CodonsG   [format " %s %s" [AAduCodon $Codon] $Codon]
	    append PourCentG [format " %5d" $PourCent]
	}
    }

    set Codons ""
    set PourCent ""
    foreach L $LesL {
	foreach Codon $LesCodonDdeL($L) {
	    if {[info exists X($Codon)]} {
		append CircuL   [format " %s %s" [AAduCodon $Codon] $Codon]
	    } else {
		append CircuL   [format " %s %s" " " "   "]
	    }
	    set PourCent $L
	    append CodonsL   [format " %s %s" [AAduCodon $Codon] $Codon]
	    append PourCentL [format " %5d" $PourCent]
	}
    }

    
    set Message $UC
    append Message "\n"
    append Message "\n"
    append Message $CircuG
    append Message "\n"
    append Message $CodonsG
    append Message "\n"
    append Message $PourCentG
    append Message "\n"
    append Message "\n"
    append Message $CircuL
    append Message "\n"
    append Message $CodonsL
    append Message "\n"
    append Message $PourCentL

    set Circu ""
    append Message "\n"
    append Message $Circu

    return [Affiche $Message "" "CodonUsageOf_$Nom"]
}

proc UsageDesCodons {NomVoulu} {
    global UsageDesCodons
    global RepertoireDuGenome
    global ListeDeBoites

    if {[info exists UsageDesCodons($NomVoulu)]} { return [set UsageDesCodons($NomVoulu)] }
    if {[info exists UsageDesCodons("EstCharge")]} { return "" }

    set FichierUsageDesCodons "$RepertoireDuGenome/fiches/usagedescodons"

    if {[file exists $FichierUsageDesCodons]} {
	array set UsageDesCodons [split [ContenuDuFichier $FichierUsageDesCodons] ":"]
	if {[info exists UsageDesCodons($NomVoulu)]} { return [set UsageDesCodons($NomVoulu)] }
	return ""
    }

    if { ! [OuiOuNon "Do I calculate now UsageDesCodons ?" 0]} {
	set UsageDesCodons("EstCharge") 1
	return ""
    }

    set NombreDeCodons 0
    foreach Boite [ListeDeBoites] {
	set Nom    [Box $Boite nom]
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]

	if { ! [YaPABdans $Nom]} { continue }
	if {[Enterre $Nom]} { continue }

	if {$Orient == "F"} {
	    incr Fin 3
	} else {
	    incr Debut -3
	}

	if {[OuiOuNonMemo "Do I use the genome DNA file for CodonW?"]} {
	    set SeqNuc [BoutADN $Debut $Fin $Orient]
	} else {
	    set Rep [RepDesNucPourCodonW]
	    set SeqNuc [QueLaSequenceDuFichierTFA [GscopeFile $Nom $Rep]]
	}

	for {set i 0} {$i <= [expr $Fin-$Debut]} {incr i 3} {
	    set Codon [string range $SeqNuc $i [expr $i+2]]
	    if { ! [info exists CodonUsage($Codon)]} {
		if { ! [regexp {^[ATGC][ATGC][ATGC]$} $Codon]} {
		    continue
		}
		lappend ListeDesCodons $Codon
		set CodonUsage($Codon) 0
	    }
	    incr CodonUsage($Codon)
	    incr NombreDeCodons
	    if { ! [info exists CodonUsage($Codon,$Nom)]} { 
		set CodonUsage($Codon,$Nom) 0
	    }
	    incr CodonUsage($Codon,$Nom) 
	}
	lappend ListeDesLongueurs [expr ($Fin-$Debut+1)/3]
	lappend ListeDesNoms $Nom
    }    

    Espionne "J'ai compte $NombreDeCodons codons"

    set UC {}
    set OldPremiereBase "X"
    foreach Codon [lsort $ListeDesCodons] {
	set PremiereBase [string index $Codon 0]
	if {$PremiereBase != $OldPremiereBase} {
	    if { $OldPremiereBase != "X" } {
		lappend UC $Codons
		lappend UC $PourCent
		lappend UC "" 
	    }
	    set Codons   ""
	    set PourCent "" 
	}
	set OldPremiereBase [string index $Codon 0]
	append Codons   [format " %s %s" [AAduCodon $Codon] $Codon]
	append PourCent [format " %5d" [expr round(10000.*[set CodonUsage($Codon)]/$NombreDeCodons)]]
    }
    lappend UC $Codons
    lappend UC $PourCent
    lappend UC "" 
    set UsageDesCodons(Global) "\n[join $UC "\n"]"

    foreach Nom $ListeDesNoms Longueur $ListeDesLongueurs {
	Espionne $Nom
	set UC {}
	set OldPremiereBase "X"
	foreach Codon [lsort $ListeDesCodons] {
	    set PremiereBase [string index $Codon 0]
	    if {$PremiereBase != $OldPremiereBase} {
		if { $OldPremiereBase != "X" } {
		    lappend UC $Codons
		    lappend UC $PourCent
		    lappend UC $PourNom
		    lappend UC "" 
		}
		set Codons   ""
		set PourCent "" 
		set PourNom  ""
	    }
	    set OldPremiereBase [string index $Codon 0]
	    append Codons   [format " %s %s" [AAduCodon $Codon] $Codon]
	    append PourCent [format " %5d" [expr round(10000.*[set CodonUsage($Codon)]/$NombreDeCodons)]]
	    if {[info exists CodonUsage($Codon,$Nom)]} {
		set CodonUsageDuNom [set CodonUsage($Codon,$Nom)]
	    } else {
		set CodonUsageDuNom 0
	    }
	    append PourNom  [format " %5d" [expr round(10000.*$CodonUsageDuNom/$Longueur)]]
	}
	lappend UC $Codons
	lappend UC $PourCent
	lappend UC $PourNom
	lappend UC "" 
	set UsageDesCodons($Nom) "\n[join $UC "\n"]"
    }
    set UsageDesCodons("EstCharge") 1

    Sauve [join [array get UsageDesCodons] ":"] dans $FichierUsageDesCodons

    if {[info exists UsageDesCodons($NomVoulu)]} { return [set UsageDesCodons($NomVoulu)] }
    return ""
}

proc ClustalX {MSF {IsFile ""}} {

    if {$IsFile=="IsFile"} {
	set FichierMSF $MSF
    } else {
	set FichierMSF [TmpFile "msf"]
	Sauve $MSF dans $FichierMSF
    } 

    exec clustalx $FichierMSF &
}

proc NJPlotMSF {MSF {IsFile ""}} {
    if {$IsFile=="IsFile"} {
	set Delete 0
	set FichierMSF $MSF
    } else {
	set Delete 1
	set FichierMSF [Sauve $MSF dans "[TmpFile].msf"] 
    } 
    set FichierPhylo [CreeLeFichierPhylo $FichierMSF "[TmpFile].ph"]
    if {$Delete} { file delete -force $FichierMSF }
    return [NJPlotPH $FichierPhylo]
}

proc NJPlotPH FichierPhylo {
    exec njplot $FichierPhylo &
    return $FichierPhylo
}

proc CreeLeFichierFonctionsValidees {} {
    global RepertoireDuGenome
    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }
    
    foreach Boite $ListeDeBoites {
	set Nom [Box $Boite nom]

	if {[Enterre $Nom]} { continue }

	set ValiDE [ExtraitInfo $Nom "ValiDE"]
	set ValiGN [ExtraitInfo $Nom "ValiGN"]
	set ValiCF [ExtraitInfo $Nom "ValiCF"]

	if {$ValiDE == "" } { continue }

	set CF [ClasseFonctionnelle $Nom]

	set FF [FiabiliteFonction $Nom]
	if {$FF == ""} { set FF "0" }
	lappend Liste [format "%3.3d %s %s %3.3d %-15s %s" $CF $Nom $FF $CF $ValiGN $ValiDE]	
    }
    set Liste [concat $Liste  [LesLignesDuFichier "$RepertoireDuGenome/aful/rolefamille"]]
    set ListeTriee [lsort $Liste]
    set Liste {}
    foreach Ligne $ListeTriee {
	lappend Liste [string range $Ligne 4 end]
    }
    Espionne [SauveLesLignes $Liste dans "$RepertoireDuGenome/fiches/fonctionsvalidees"]
} 

proc PyroLike Orga {
    if {[regexp "paby|phor|pfur|txxx|pkod|psp|pwoe|thyd" $Orga]} { return 1 }
    return 0
}

proc ArkaeaLike Orga {
    if {[PyroLike $Orga] || \
	    [regexp "mjan|aful|mthe|aper|ssol|saci|mvan|hsal|hvol|hcut|hhal|damb|dmob|dthe|dsp" $Orga]} {
	return 1
    }
    return 0
}

proc PhyloFolle Nom {
    global RepertoireDuGenome
    global PhylosFolles

    if {[info exists PhylosFolles]} {
	if {[info exists PhylosFolles($Nom)]} {
	    return [set PhylosFolles($Nom)]
	} else {
	    return -1
	}
    }

    set FichierPhylosFolles "$RepertoireDuGenome/fiches/phylosfolles"
    
    if {[file exists $FichierPhylosFolles]} {
	foreach Ligne [LesLignesDuFichier $FichierPhylosFolles] {
	    scan $Ligne "%s %s" Nom Folie
	    set PhylosFolles($Nom) $Folie
	}
	return [PhyloFolle $Nom]
    }

    set ListeOrgas [Phylon $Nom]
    if {[llength $ListeOrgas] == 0} { return -1 }
    foreach Orga $ListeOrgas {
	if {$Orga == "xxxx" || [PyroLike $Orga]} { continue }
	if {[ArkaeaLike $Orga]} { return 0 }
	return 1
    }
    return 0
}

proc ChargePhylons {} {
    global RepertoireDuGenome
    global Phylons PhylonsOrgaEtDistance

    if { ! [file exists "$RepertoireDuGenome/fiches/distancesphylo"]} {
	set Phylons Bidon
	set PhylonsOrgaEtDistance Bidon
	return
    }

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/distancesphylo"] {
	set Liste [split $Ligne " "]
	set Nom [lindex $Liste 0]
	set ListeOrgaDistance [lrange $Liste 1 end]
	set ListeOrgas {} 
	foreach {Orga Distance Access} $ListeOrgaDistance {
	    lappend ListeOrgas $Orga
	}
	set Phylons($Nom) $ListeOrgas
	set PhylonsOrgaEtDistance($Nom) $ListeOrgaDistance
    }
    
    set FichierPhylosFolles "$RepertoireDuGenome/fiches/phylosfolles"
    if { ! [file exists $FichierPhylosFolles] && \
	    [OuiOuNon "Dois-je creer le fichier $FichierPhylosFolles ? "]} {
	foreach Nom [array names Phylons] {
	    lappend ListePhylons "$Nom [PhyloFolle $Nom]"
	}
	Espionne [SauveLesLignes $ListePhylons dans $FichierPhylosFolles]
    }
}

proc Phylon Nom {
    global Phylons

    if { ! [info exists Phylons] } { ChargePhylons }

    if {[info exists Phylons($Nom)]} { return [set Phylons($Nom)] }
    return {}

}

proc PhylonOrgaEtDistance Nom {
    global Phylons
    global PhylonsOrgaEtDistance

    if { ! [info exists Phylons] } { ChargePhylons }

    if {[info exists PhylonsOrgaEtDistance($Nom)]} { return [set PhylonsOrgaEtDistance($Nom)] }
    return {}

}


proc CreeLesFichiersTFAsNUCsAvecBornesDesPABsEtADN {} {
    global RepertoireDuGenome

    if { ! [OuiOuNon "Je recree les sequences dans $RepertoireDuGenome"]} { return }

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdespabs"] {

	ExtraireDe $Ligne Nom Debut Fin Orient

	if {[file exists "$RepertoireDuGenome/prottfa/$Nom"]} { continue }

	set SeqNuc [BoutADN $Debut $Fin $Orient]
	set SeqPro [SeqNucToSeqPro $SeqNuc]
	
	set NUC [SequenceFormatTFA $SeqNuc "$Nom $Debut $Fin $Orient $Cut" "nucbrut"]
	Espionne [Sauve $NUC dans "$RepertoireDuGenome/nuctfa/$Nom"]
	
	set TFA [SequenceFormatTFA $SeqPro "$Nom $Debut $Fin $Orient $Cut" "protbrut"]
	Espionne [Sauve $TFA dans "$RepertoireDuGenome/prottfa/$Nom"]

    }
}

proc BornesDeSeraphinVersCasimir {} {
    global RepertoireDuGenome
    global ListeDesPABs
    global ListeDesTRNAs
    global ListeDesARNs

    if { ! [regexp "bys" $RepertoireDuGenome]} {
	FaireLire "Il fallait lancer setgscope bys"
	exit
    }

    ChargeLesPABs
    set NouvellesBornes {}
    foreach Boite $ListeDesPABs {
	set Nom    [Box $Boite nom]
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]

	lappend NouvellesBornes "$Nom [CasimirDu $Debut] [CasimirDu $Fin] $Orient"
    }
    Espionne [SauveLesLignes $NouvellesBornes dans "$RepertoireDuGenome/../casimir/fiches/bornesdespabs.arenommer"]

    ChargeLesTRNAs
    set NouvellesBornes {}
    foreach Boite $ListeDesTRNAs {
	set Nom    [Box $Boite nom]
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]

	lappend NouvellesBornes "$Nom [CasimirDu $Debut] [CasimirDu $Fin] $Orient"
    }
    Espionne [SauveLesLignes $NouvellesBornes dans "$RepertoireDuGenome/../casimir/fiches/bornesdestrnas.arenommer"]

    ChargeLesARNs
    set NouvellesBornes {}
    foreach Boite $ListeDesARNs {
	set Nom    [Box $Boite nom]
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]

	lappend NouvellesBornes "$Nom [CasimirDu $Debut] [CasimirDu $Fin] $Orient"
    }
    Espionne [SauveLesLignes $NouvellesBornes dans "$RepertoireDuGenome/../casimir/fiches/bornesdesarns.arenommer"]



} 

proc CasimirDu Ser {
    global ListeSeraphin ListeCasimir

    if { ! [info exists ListeSeraphin]} { ChargeSeraphinEtCasimir }

    set iPrecedent -999999 
    set jPrecedent -999999 
    foreach i $ListeSeraphin j $ListeCasimir {
	if { [expr $iPrecedent <= $Ser] && [expr $Ser < $i] } {
	    return [expr $jPrecedent+$Ser-$iPrecedent]
	}
	set iPrecedent $i
	set jPrecedent $j
    }
    return [expr $jPrecedent+$Ser-$iPrecedent]
}

proc SeraphinDu Cas {
    global ListeSeraphin ListeCasimir

    if { ! [info exists ListeSeraphin]} { ChargeSeraphinEtCasimir }

    set iPrecedent -999999 
    set jPrecedent -999999 
    foreach i $ListeSeraphin j $ListeCasimir {
	if { [expr $jPrecedent <= $Cas] && [expr $Cas < $j] } {
	    return [expr $iPrecedent+$Cas-$jPrecedent]
	}
    }
    return [expr $iPrecedent+$Cas-$jPrecedent]
}

proc ChargeSeraphinEtCasimir {} {
    global RepertoireDuGenome
    global ListeSeraphin ListeCasimir

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/../bys/erreurssequence.liste"] {

	if {[regexp "ij" $Ligne]} { continue }

	scan $Ligne "%s %d %d" iOUj iSer jCas

	lappend ListeSeraphin $iSer
	lappend ListeCasimir  $jCas
    }
} 

proc Validation {{Sens "-increasing"}} {
    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }

    set JeVeuxFaire 1
    if { $Sens == "Voir"} {
	set Sens "-increasing"
	set JeVeuxFaire 0
    }
    set JeVeuxVoir [expr ! $JeVeuxFaire]


    foreach Boite [lsort $Sens $ListeDeBoites] {
	set Nom [Box $Boite nom]
	if {[FiabiliteFonction $Nom] != 5} { continue }
 	if {$JeVeuxFaire && [ExtraitInfo $Nom "ValiDE"] != "" || \
	    $JeVeuxVoir  && [ExtraitInfo $Nom "ValiDE"] == ""  } { continue }

    puts $Nom
    continue
	
	if { [QueDitAful $Nom] && ! [OuiOuNon "Au suivant ?"] } { break } 
    }

}

proc MarqueLesErreursDeSequence K {
    global RepertoireDuGenome
    
    set PosY 1
    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/erreurssequence.liste"] {
	scan $Ligne "%s %d %d" CodeType PositioTDNnsAncien PositioTDNnsNouveau
	if {$CodeType == "ij"} { set Couleur "black" ; set Texte "| Substitution en $PositioTDNnsAncien"}
	if {$CodeType == "i" } { set Couleur "red" ; set Texte "| Deletion en $PositioTDNnsAncien"}
	if {$CodeType ==  "j"} { set Couleur "red" ; set Texte "| Insertion en $PositioTDNnsAncien"}
	$K create text \
		$PositioTDNnsNouveau  [expr ([incr PosY]%3 + 1)*12 - 60] \
		-text $Texte \
		-anchor w \
		-font {Courier 12} \
		-fill $Couleur
    }

}

proc SimilitudeSurUneZone {i j} {
    global ADN CDN

    set Score 0
    set l $j
    for {set k $i} {$k < [expr $i+10]} {incr k} {
	if {[string index $ADN $k] == [string index $CDN $l]} { incr Score }
	incr l
    }
    return $Score
}

proc PointeLesErreursDeSequence {} {
    global RepertoireDuGenome
    global ADN CDN

    JeMeSignale "Patience"

    set f [open "$RepertoireDuGenome/adn" "r"]
    gets $f ADN
    close $f

    set f [open "$RepertoireDuGenome/../casimir/adn" "r"]
    gets $f CDN
    close $f

    JeMeSignale "FinPatience"

    set LongueurSeraphin [string length $ADN]
    set LongueurCasimir  [string length $CDN]

    set i 1
    set j 1
    while 1 {
	if {[string index $ADN $i] == [string index $CDN $j]} {
	    if {$i >= $LongueurSeraphin} { break }
	    incr i
	    incr j
	    continue
	}
	set MeilleurScoreEnK 0
	for {set K $i} {$K < [expr $i+10]} {incr K} {
	    set MeilleurScoreEnK [Maxi $MeilleurScoreEnK [SimilitudeSurUneZone $K $j]]
	    set MeilleurK($MeilleurScoreEnK) $K
	} 
	set MeilleurScoreEnL 0
	for {set L $j} {$L < [expr $j+10]} {incr L} {
	    set MeilleurScoreEnL [Maxi $MeilleurScoreEnL [SimilitudeSurUneZone $i $L]]
	    set MeilleurL($MeilleurScoreEnL) $L
	}

	puts "[string range $ADN [expr $i] [expr $i+30]] $i"
	puts "[string range $CDN [expr $j] [expr $j+30]] $j"
	puts "[set MeilleurK($MeilleurScoreEnK)] $MeilleurScoreEnK"
	puts "[set MeilleurL($MeilleurScoreEnL)] $MeilleurScoreEnL"
	if {$MeilleurScoreEnK==$MeilleurScoreEnL} {
	    if {1 && [OuiOuNon "Je saute les 2 ?"]} { incr i; incr j; lappend Acte "ij $i $j"; continue}
	}
	if {$MeilleurScoreEnK>$MeilleurScoreEnL} {
	    if {1 && [OuiOuNon "Je saute le 1er ?"]} { incr i; lappend Acte "i  $i $j"; continue}
	}
	if {$MeilleurScoreEnK<$MeilleurScoreEnL} {
	    if {1 && [OuiOuNon "Je saute le 2nd ?"]} { incr j; lappend Acte " j $i $j"; continue}
	}
	if {[OuiOuNon "Alors je saute les 2 ?"]} { incr i; incr j; lappend Acte "ij $i $j"; continue}
	if {[OuiOuNon "Alors je saute le 1er ?"]} { incr i; lappend Acte "i  $i $j"; continue}
	if {[OuiOuNon "Alors je saute le 2nd ?"]} { incr j; lappend Acte " j $i $j"; continue}	
    }
    Espionne [SauveLesLignes $Acte dans "$RepertoireDuGenome/erreurssequence.liste.nouveau"]

}

proc CompareLesExpectsDesSegments {TexteA TexteB} {

    scan $TexteA "%s %s %s %s %s %s %s %f" Trou Sens Frame BanqueId Debut Fin Long a
    scan $TexteB "%s %s %s %s %s %s %s %f" Trou Sens Frame BanqueId Debut Fin Long b

    if {[expr double($a) <  double($b)]} { return -1}
    if {[expr double($a) == double($b)]} { return  0}
    if {[expr double($a)  > double($b)]} { return  1}
}

proc CreeLeFichierFonctionsDecouvertes {} {
    global RepertoireDuGenome
    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }

    foreach Boite $ListeDeBoites {
	set Nom [Box $Boite nom]
	set AF [NomDuMeilleurAful $Nom]
	if {$AF == ""} { continue }
	scan [MeilleurAful $Nom] "%s %s %f %s" AF AFok PN Raison
	if { ! $AFok} { continue }
	set TexteAF [lindex [DonneesAful $AF] 0]
	if {$TexteAF == "" } {
	    set RoFa "  00"
	    set TexteAF "$AF $RoFa sans reference fonctionnelle"
	} else {
	    scan $TexteAF "%s %d" AF RoFa
	}
	set FF [FiabiliteFonction $Nom]
	if {$FF == ""} { set FF "0" }
	lappend Liste [format "%3.3d %s %s %7s %s" $RoFa $Nom $FF $PN $TexteAF]	
    }
    set Liste [concat $Liste  [LesLignesDuFichier "$RepertoireDuGenome/aful/rolefamille"]]
    set ListeTriee [lsort $Liste]
    set Liste {}
    foreach Ligne $ListeTriee {
	lappend Liste [string range $Ligne 4 end]
    }
    Espionne [SauveLesLignes $Liste dans "$RepertoireDuGenome/fiches/fonctionsdecouvertes"]
} 

proc TexteOMO {NomVoulu {Format "Court"}} {
    global RepertoireDuGenome
    global TexteOMO 

    if { ! [YaPABdans $NomVoulu]} { return "" }

    if { ! [info exists TexteOMO]} {
	set FichierOMO "$RepertoireDuGenome/fiches/organismesayantmemeoperon"
	if { ! [ file exists $FichierOMO]} {
	    set TexteOMO Bidon
	    return 
	}
	
	foreach Ligne [LesLignesDuFichier $FichierOMO] {
	    
	    set LesMots [split $Ligne " "]
	    set Nom [lindex $LesMots 0]
	    set Voisin [lindex $LesMots 1]
	    set iOMO [string length "$Nom $Voisin xxxx"]
	    set sOMO [string trim [string range $Ligne $iOMO end]]
	    set Texte ""
	    for {set i 0} {$i < [string length $sOMO]} {incr i 5} {
		set C [string index $sOMO $i] 
		if { $C != " " } {
		    append Texte $C
		} else {
		    append Texte "."
		}
	    }
	    set TexteOMO($Nom,Court)    $Texte
	    set TexteOMO($Nom,Long)     $Ligne
	    set TexteOMO($Nom,Avant)    $Voisin
	    set TexteOMO($Voisin,Apres) $Nom
	}
    }
    if { ! [info exists TexteOMO($NomVoulu,$Format)]} { return ""}
    return [set TexteOMO($NomVoulu,$Format)]
}

proc MiseAJourDesPABCrees {} {
    global RepertoireDuGenome

    foreach Trou [LesLignesDuFichier "$RepertoireDuGenome/creepab3.liste"] {
	set CreePABDejaVu 0
	regsub "TROU" $Trou "[PreFixe]" Nom
	set Nom [string range $Nom 0 6]
	set InfoDuPAB {}
	lappend InfoDuPAB "Nom: $Nom"
	foreach Ligne  [LesLignesDuFichier "$RepertoireDuGenome/infos/$Trou"] {
	    if {[regexp "^Nom:" $Ligne]} { continue }
	    if {[regexp ": $" $Ligne]} { continue }
	    if {[regexp "^CreePAB:" $Ligne]} {
		if {$CreePABDejaVu} {
		    FaireLire "$Trou contient plusieurs CreePAB.\nCreer infos +1000 manuellement, avec emacs."
		}
		set CreePABDejaVu 1
		regsub "CreePAB" $Ligne "DuTrou" Ligne
		append Ligne " du $Trou"
	    }
	    lappend InfoDuPAB $Ligne
	}
	Espionne [SauveLesLignes $InfoDuPAB dans "$RepertoireDuGenome/infos/$Nom"]
    }
}

proc InformeLesMetsCorriges {} {
    global ListeDeBoites
    global RepertoireDuGenome
    global InformeSansDemander

    Wup "Je lis le fichier metscorriges qui n'est que les 1eres lignes"
    Wup " des fichiers gcgs contenant 'Cut ...'"

    set InformeSansDemander 1

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/metscorriges"] { 
	set Nom [lindex [split $Ligne " "] 0]

	set iCut [string first "Cut" $Ligne]
#	set iFin [expr [string first "Length" $Ligne]-1]
	set Zone [string range $Ligne $iCut end]
	set Append "NewStartCodon: $Zone"

	Informe $Nom $Append
	Espionne "\n$Nom\n$Append"
    }
}


proc LesOffsetsDePfur {} {
    global RepertoireDuGenome

    Wup "Il y a une sequence non utilisee, je la saute."

    set Offset 0
    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/db/pfur"] {
	if {[regexp ">" $Ligne]} {
	    scan $Ligne ">%s" Courant
	    if {[regexp "MM4to38\-10429" $Courant]} { puts $Ligne; continue }
	    puts "$Courant $Offset"
	} else {
	    if {[regexp "MM4to38\-10429" $Courant]} { puts $Ligne; continue }
	    incr Offset [string length $Ligne]
	}
    }
}

proc DessineOrgaEtSesPlaces {{Fichier ""} {PourGif ""}} {
    global RepertoireDuGenome
    global LesOrdresPourGif
    global LigneOriginePhylo
    
    if {$Fichier==""} { set Fichier "$RepertoireDuGenome/fiches/orgaetsesplaces.tout_le_monde" }
 
    set LesLignes [LesLignesDuFichier $Fichier]
    set n [llength $LesLignes]

    set Titre "PhyloRank"

    set LC 25
    set HL 20

    set nColonnes 13
    set nLignes $n

    set Fonte {Courier 15}
    set TailleTexteOrga [font measure $Fonte [string repeat "M" 26]] 
    set EspacementHorizontal 15
    set EspaceVertical 40
    set PosYEntete [expr $EspaceVertical/2]

    set DecalageDesRectangles [expr $EspacementHorizontal + $TailleTexteOrga + $EspacementHorizontal] 
    set LargeurVoulue [expr $DecalageDesRectangles + $nColonnes*$LC + $EspacementHorizontal]
    set HauteurVoulue [expr $EspaceVertical + ($nLignes+2)*$HL]


    if {$PourGif != ""} {
	set PourGif 1
	set Canvas    NeRienFaire
	set Bind      NeRienFaire
	set Pack      NeRienFaire
	set Fram      NeRienFaire
	set Button    NeRienFaire
	set Scrollbar NeRienFaire
	set Grid      NeRienFaire
	set FonctionRejetteLaBoite "RejetteLaBoite"
	set LesOrdresPourGif {}
	set w "PourGif"
	set K "OrdrePourGif"
    } else {
	set PourGif 0
	set Canvas    canvas
	set Bind      bind
	set Pack      pack
	set Fram      frame
	set Button    button
	set Scrollbar scrollbar
	set Grid      grid
	set FonctionRejetteLaBoite "NeRejettePasLaBoite"
	set K [UnCanva $LargeurVoulue $HauteurVoulue $LargeurVoulue $HauteurVoulue]     
	regsub ".canvas" $K "" w
	wm title $w "$Titre"
	wm iconname $w "$Titre"
    }

    $K configure -background "lightgrey"
    $K create rectangle 0 0 $LargeurVoulue $HauteurVoulue -fill grey -tags [list "Cadre"]

    $K create text \
	    [expr $DecalageDesRectangles/2] [expr $EspaceVertical/2] \
	    -text $Titre \
	    -font {Courier 12} \
	    -anchor c


    set MettreEntete 1
    set iEmeOrga 0
    if {[info exists ValeurMaxiDuTableau]} { unset ValeurMaxiDuTableau }
    foreach Ligne $LesLignes {

	if { ! [regexp -nocase {[a-z]} $Ligne] } { continue }
	if {[regexp "^#" $Ligne] } { continue }
	scan $Ligne "%s" Orga
	set Complet [Glossaire $Orga Complet]
	if { $Orga == "xxxx" } { continue }

	set Phylum [PhylumDuGenome $Complet]
	if {$Phylum=="X"} { set Phylum [PhylumDuOrganisme $Complet] }

	set Couleur "black"
	if {$Phylum=="B"} { set Couleur "darkgreen" }
	if {$Phylum=="A"} { set Couleur "blue" }
	if {$Phylum=="E"} { set Couleur "red" }

	incr iEmeOrga

	set LigneOriginePhylo($K,$Orga) $Ligne
	Espionne $Ligne
	set TexteOrga [string range $Complet 0 25]
	$K create text \
		$EspacementHorizontal [expr $EspaceVertical + $iEmeOrga*$HL] \
		-text $TexteOrga \
		-anchor w \
		-font $Fonte \
		-tags [list "$Complet" "$Orga" "TexteOrga" "Ligne_$iEmeOrga"] \
		-fill $Couleur


	Wup "Attention ces valeurs doivent correspondre a CreeLaTable"
	set OffsetColonne 18
	set ValeurVide "    "
	set LargeurValeur [string length $ValeurVide]

	set Reste [string range $Ligne $OffsetColonne end]
	set Valeurs $Reste
	while {[regexp "  " $Valeurs]} { regsub -all "  " $Valeurs " " Valeurs }
	set ValeurMaxiDeLaLigne [MaxiDeLaListe [lrange [split [string trim $Valeurs] " "] 0 end-1]]
	
	set Colonne 0
	set Rang 0
	while {[regexp {[0-9]} $Reste]} {
	    set SPP [string range $Reste 0 [expr $LargeurValeur-1]]
	    set Reste [string range $Reste [expr $LargeurValeur+1] end]
	    incr Colonne
	    incr Rang
	    if {$MettreEntete} {
		set PosX [expr $DecalageDesRectangles + $Colonne*$LC]
		set Texte $Rang
		$K create text \
			$PosX $PosYEntete \
			-width 20 \
			-text $Texte \
			-font {Courier 6} \
			-anchor n \
			-fill "black"
	    }
	    if { $SPP == $ValeurVide} { continue }
	    set PP 0
	    scan $SPP "%d" PP
	    if {$PP==0} { continue }
	    if { ! [info exists ValeurMaxiDuTableau]} { set ValeurMaxiDuTableau $PP }
	    if {$PP>$ValeurMaxiDuTableau} { set PP $ValeurMaxiDuTableau }
	    set DuTableau 0
	    if {$DuTableau} {
		set p [expr (1.*$PP)/$ValeurMaxiDuTableau]
	    } else {
		set p [expr (1.*$PP)/$ValeurMaxiDeLaLigne]
	    }
	    if {[regexp {[0-9]} $Reste]} {
		set Couleur [Nuance [expr $p] 0.5 0.1]
	    } else {
		set Couleur "lightgrey"
	    } 

	    if {$PourGif} {
		set LesTags [list "WebClic" "gscope:AfficheLesConcernesDeCeRang \{$Complet\} $SPP $Rang $Fichier"]
	    } else {
		set LesTagsR [list "$Complet" "$SPP" "$Rang"             "Affichable" "Ligne_$iEmeOrga"]
		set LesTagsT [list "$Complet" "$SPP" "$Rang" "TexteRang" "Affichable" "Ligne_$iEmeOrga"]
	    }

	    set PosX [expr $DecalageDesRectangles + $Colonne*$LC]
	    $K create rect \
		    [expr $PosX-$LC/3] [expr $EspaceVertical + $iEmeOrga*$HL-$HL/3] \
		    [expr $PosX+$LC/3] [expr $EspaceVertical + $iEmeOrga*$HL+$HL/3] \
		    -tags $LesTagsR \
		    -outline $Couleur \
		    -fill $Couleur
	    $K create text \
		    [expr $PosX+$LC/3] [expr $EspaceVertical + $iEmeOrga*$HL] \
		    -text $PP \
		    -font {Courier 6} \
		    -anchor e \
		    -tags $LesTagsT \
		    -fill "black"
	}
	set MettreEntete 0
    }

    $K configure -height [Mini 800 [expr ($iEmeOrga+1)*$HL]]

    set Boutons $w.buttons
    $Button $Boutons.toggle -text "Hide both/Orga/Rank\nSave order"
      $Bind $Boutons.toggle <1> "ToggleTextePhylo $K Both"
      $Bind $Boutons.toggle <2> "ToggleTextePhylo $K Orga"
      $Bind $Boutons.toggle <3> "ToggleTextePhylo $K Rank"
      $Bind $Boutons.toggle <Shift-1> "SavePhylOrder $K $Fichier"
      $Pack $Boutons.toggle -side left -expand 1

#    $Pack $K

    $K bind "Affichable" <1> "AfficheLesConcernesDeCeRang $K %x %y $Fichier"
    $K bind all <Shift-2> "ChangeOrdrePhylo $K %x %y $HL -1 $iEmeOrga"
    $K bind all <Shift-3> "ChangeOrdrePhylo $K %x %y $HL  1 $iEmeOrga"

    if {$PourGif } { return $LesOrdresPourGif }
    if { 0 && [PourWscope] } {
	return $w
    } else {
	return $K
    }
}

proc SavePhylOrder {K OrgaEtSesPlaces} {
    global LigneOriginePhylo

    set PossibleFichier "${OrgaEtSesPlaces}_2"
    while {1} {
	set NouveauOrgaEtSesPlaces [FichierPourSaveAs $PossibleFichier]
	if {$NouveauOrgaEtSesPlaces==""} { return "" }
	if {[regexp "orgaetsesplaces" $NouveauOrgaEtSesPlaces]} { break }
    }
    regsub "orgaetsesplaces" $OrgaEtSesPlaces "pabretenus" PabsRetenus
    regsub "orgaetsesplaces" $NouveauOrgaEtSesPlaces "pabretenus" NouveauPabsRetenus

    foreach Id [$K find withtag "TexteOrga"] {
	set LesTags [$K gettags $Id]
	set iLigne [lsearch -regexp $LesTags "Ligne_"]
	set Ligne [lindex $LesTags $iLigne]
	set i [IntegerApres "Ligne_" dans $Ligne]
	lappend Liste "$i [lindex $LesTags 1]"
    }
    set ListeTriee [lsort -command CompareLesIntegersEnDebut $Liste]
    foreach Couple $ListeTriee {
	regsub {[0-9]+ +} $Couple "" Orga
	lappend Sortie [set LigneOriginePhylo($K,$Orga)]
    }
    File copy $PabsRetenus $NouveauPabsRetenus
    return [SauveLesLignes $Sortie dans $NouveauOrgaEtSesPlaces]
}

proc ToggleTextePhylo {K {Qui "Both"}} {
    global ToggleTextePhylo

    if { ! [info exists ToggleTextePhylo($K)]} {
	set ToggleTextePhylo($K) "raise"
    }

    set Etat [set ToggleTextePhylo($K)]
    if {$Etat=="raise"} { set Etat "lower" } else { set Etat "raise" }

    if {$Qui=="Both" || $Qui=="Orga"} {
	$K $Etat "TexteOrga"
    }
    if {$Qui=="Both" || $Qui=="Rank"} {
	$K $Etat "TexteRang"
    }

    set ToggleTextePhylo($K) $Etat

    return $Etat
}
 
proc ChangeOrdrePhylo {K x y HL Sens nOrgas} {

    set Id [$K find withtag current]
    set LesTags [$K gettags $Id]
    set iLigne [lsearch -regexp $LesTags "Ligne_"]
    set Ligne [lindex $LesTags $iLigne]
    set i [IntegerApres "Ligne_" dans $Ligne]
    set d [expr $i+$Sens]

    if {[expr $d<1] || [expr $d>$nOrgas]} { return $i }

    $K move $Ligne 0 [expr $Sens*$HL]

    set Autre "Ligne_[expr $i+$Sens]"
    $K move $Autre 0 [expr -$Sens*$HL]

    set LesUns    [$K find withtag $Ligne]
    set LesAutres [$K find withtag $Autre]

    foreach Id $LesUns {
	set LesTags [$K gettags $Id]
	set i [lsearch -exact $LesTags $Ligne]
	set LesNouveaux [lreplace $LesTags $i $i $Autre]
	$K itemconfigure $Id -tags $LesNouveaux
    }

    foreach Id $LesAutres {
	set LesTags [$K gettags $Id]
	set i [lsearch -exact $LesTags $Autre]
	set LesNouveaux [lreplace $LesTags $i $i $Ligne]
	$K itemconfigure $Id -tags $LesNouveaux
    }

    return $d
}

proc ComptonsLesATGC {} {
    global ADN TDN RAC
    if { ! [info exists ADN]} { ChargeADNetTDNetRAC }

    set l [string length $ADN]

    set nA 0
    set nT 0
    set nG 0
    set nC 0

    for {set i 1} {$i < $l} {incr i} {
	set c [string index $ADN $i]
	if { $c == "A" } { incr nA }
	if { $c == "T" } { incr nT }
	if { $c == "G" } { incr nG }
	if { $c == "C" } { incr nC }
    }
    set l [expr $nA + $nT +$nG + $nC]
    puts " $l bases"
    puts " "
    puts " A $nA [format %5.2f [expr (100.*$nA)/$l]]%"
    puts " T $nT [format %5.2f [expr (100.*$nT)/$l]]%"
    puts " G $nG [format %5.2f [expr (100.*$nG)/$l]]%"
    puts " C $nC [format %5.2f [expr (100.*$nC)/$l]]%"
    puts " "
    puts "AT [expr $nA+$nT] [format %5.2f [expr (100.*($nA+$nT))/$l]]%"
    puts "GC [expr $nG+$nC] [format %5.2f [expr (100.*($nG+$nC))/$l]]%"
}

proc Comptons {} {
    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }

    set Compteur(Total) 0
    set Compteur(FF)  0
    set Compteur(FF0) 0
    set Compteur(FF1) 0
    set Compteur(FF3) 0
    set Compteur(FF5) 0
    set Compteur(FF7) 0
    set Compteur(FF9) 0
    set Compteur(Enterres) 0
    set Compteur(Decedes) 0

    set Compteur(hTotal) 0
    set Compteur(hFF)  0
    set Compteur(hFF0) 0
    set Compteur(hFF1) 0
    set Compteur(hFF3) 0
    set Compteur(hFF5) 0
    set Compteur(hFF7) 0
    set Compteur(hFF9) 0
    set Compteur(hEnterres) 0
    set Compteur(hDecedes) 0

    set Compteur(fTotal) 0
    set Compteur(fFF)  0
    set Compteur(fFF0) 0
    set Compteur(fFF1) 0
    set Compteur(fFF3) 0
    set Compteur(fFF5) 0
    set Compteur(fFF7) 0
    set Compteur(fFF9) 0
    set Compteur(fEnterres) 0
    set Compteur(fDecedes) 0

    foreach Boite $ListeDeBoites {
	set Nom [Box $Boite nom]
	if { ! [YaPABdans $Nom]} { continue }
	set FFx "FF[FiabiliteFonction $Nom]"
	incr Compteur(Total)
	incr Compteur($FFx)
	if {[Enterre $Nom]} { incr Compteur(Enterres) }
	if {[Decede  $Nom]} { incr Compteur(Decedes) }
	if {[Enterre $Nom] && [ExisteOrthologueDans "phor" $Nom]} { incr Compteur(hEnterres) }
	if {[Enterre $Nom] && [ExisteOrthologueDans "pfur" $Nom]} { incr Compteur(fEnterres) }
	if {[Decede  $Nom] && [ExisteOrthologueDans "phor" $Nom]} { incr Compteur(hDecedes) }
	if {[Decede  $Nom] && [ExisteOrthologueDans "pfur" $Nom]} { incr Compteur(fDecedes) }
	if {[ExisteOrthologueDans "phor" $Nom]} { incr Compteur(hTotal); incr Compteur(h$FFx)}
	if {[ExisteOrthologueDans "pfur" $Nom]} { incr Compteur(fTotal); incr Compteur(f$FFx)}
    }

    foreach Valeur [lsort [array names Compteur]] {
	puts [format "%10s %d" $Valeur [set Compteur($Valeur)]]
    }
}

proc StatistiquesSurLesProteines {{QuelleListe ""} {EnContinu ""}} {

    if {$QuelleListe==""} { set QuelleListe ListeDesPABs }
    set EnContinu [string equal -nocase "Continu" $EnContinu]

    if {[regexp "^ListeDes" $QuelleListe]} {
	set Liste [eval $QuelleListe]
    } else {
	set Liste $QuelleListe
    }

    set nTotal 0
    foreach Nom $Liste {
	set Debut [Box $Nom debut]
	set Fin   [Box $Nom fin]

	set Long [expr $Fin - $Debut +1]

	if { ! [info exists Compteur($Long)]} { set Compteur($Long) 0 }
	incr Compteur($Long) 
	incr nTotal
    }

    set LesLongueurs [lsort -integer [array names Compteur]]

    set Precedent 0
    foreach Long $LesLongueurs {
	set Cumul($Long) [expr $Precedent + [set Compteur($Long)]]
	set Precedent [set Cumul($Long)]
    }

    if {$EnContinu} {
	set LesLongueursAVoir [NombresEntre [lindex $LesLongueurs 0] [lindex $LesLongueurs end]]
    } else {
	set LesLongueursAVoir $LesLongueurs
    }


    foreach Long $LesLongueursAVoir {
	if {[info exists Compteur($Long)]} {
	    set N [set Compteur($Long)]
	    set C [set Cumul($Long)]
	} else {
	    set N 0
	}
	set S [expr ($C/18)%80]
	puts [format "%5d %5d %5d %s" $Long $N $C [string repeat "*" $S]]
    }
    return [list [array get Compteur] [array get Cumul]]
}

proc CreeLeFichierDistancesPhylo {} {
    global RepertoireDuGenome
    global ListeDeBoites
    global ListeDesPABs

    set TenirCompteDeFiabiliteFonction 0

    set FichierDistancesPhylo "$RepertoireDuGenome/fiches/distancesphylo"

    if {[file exists $FichierDistancesPhylo]} {
	if { ! [OuiOuNon "$FichierDistancesPhylo\n already exists. Do I replace it ?"]} {
	    return ""
	}
    }

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }
    
    foreach Nom [ListeDesPABs] {
	if {$TenirCompteDeFiabiliteFonction && [FiabiliteFonction $Nom] < 3 } { continue }
	set Liste [ListeTrieeDesDistancesPhylos $Nom]
	if {[llength $Liste] > 0} {
	    set NomListe "$Nom [join  $Liste " "]"
	    lappend ListeDesNomListe $NomListe
	}
    }
    return [SauveLesLignes $ListeDesNomListe dans $FichierDistancesPhylo]
}

proc RemplaceAccessParOrganismeDansFichierPhyloPourTous {{Nom ""}} {
    if {$Nom==""} {
	set Liste [ListeDesPABs]
    } else {
	set Liste [list $Nom]
    }

    foreach Nom $Liste {
	set FiPhy    "[RepertoireDuGenome]/phylos/$Nom"
	set FiPhyOrg "[RepertoireDuGenome]/phylosOrg/$Nom"
	if {[file exists $FiPhyOrg]} { continue }
	if { ! [file exists $FiPhy]} { continue }
	set BonFiPhyOrg [RemplaceAccessParOrganismeDansFichierPhylo $Nom]
	Espionne $BonFiPhyOrg
    }    
}

proc RemplaceAccessParOrganismeDansFichierPhylo {Nom {Out ""}} {

    if {[regexp "/" $Nom]} {
	set Fichier $Nom
	if {$Out==""} {
	    regsub -nocase {(.ph|)$} $Fichier "-org&" FichierOut
	} else {
	    set FichierOut $Out
	}
    } else {
	set Fichier "[RepertoireDuGenome]/phylos/$Nom"
	if {$Out==""} {
	    set Rep "[RepertoireDuGenome]/phylosOrg"
	    if { ! [file exists $Rep]} { file mkdir $Rep }
 	    set FichierOut "$Rep/$Nom"
	} else {
	    set FichierOut $Out
	}
    }
    if { ! [file exists $Fichier]} { return "" }
    set i 0
    set Texte [ContenuDuFichier $Fichier]
    set LesAccess {}
    set LesIndices {}
    set N 0
    while {[regexp -start $i -indices {[^\n\)\(\,\:]+\:} $Texte Indices]} {
	if {[incr N]>99999} { break }
	scan $Indices "%d %d" D F
	set i $F
	set Access [string range $Texte $D [expr $F -1]]
	regsub -nocase "^VARSPLIC_" $Access "VARSPLIC:" Access
	lappend LesAccess $Access
	lappend LesIndices $Indices
    }

    set Format "Demi"
    set LesAccessOrga [LesOrgasDesAccess $LesAccess $Format]
    set Inconnu [Glossaire "Inconnu inconnu" $Format]

    set LesAO [RetourneLaListe $LesAccessOrga]
    set LesIn [RetourneLaListe $LesIndices]

    foreach AO $LesAO Indices $LesIn {
	scan $AO "%s" Access
	set Orga [StringSuivant "$Access " dans $AO]
	if {$Orga=="" || $Orga==$Inconnu} { set Orga $Access }
	scan $Indices "%d %d" D F
	incr F -1
	Espionne "$Access $Orga $D $F"
	set Texte [string replace $Texte $D $F $Orga]
    }
    if {$Out=="GetText"} { return $Texte }
    return [Sauve $Texte dans $FichierOut]
}

proc CreeLeFichierPhylo {FichierMSF FichierPhylo} {
    if {[catch {exec clustalw $FichierMSF -tree -outtreefile=$FichierPhylo} Message]} {
	return "Erreur in CreeLeFichierPhylo\n$Message"
    }
    return $FichierPhylo
}

proc CreeLesFichiersPhylos {{Nom ""}} {

    set Repertoire "[RepertoireDuGenome]/phylos"
    if { ! [file exists $Repertoire]} { File mkdir $Repertoire }
    
    if { $Nom != ""} {
	set ListeATester [list $Nom]
    } else {
	set ListeATester [ListeDesPABs]
    }

    foreach Nom $ListeATester {
	set FichierPhylo "[RepertoireDuGenome]/phylos/$Nom"
	if {[file exists $FichierPhylo]} { continue }
	set FichierMSF "[RepertoireDuGenome]/msf/$Nom"
	if { ! [file exists $FichierMSF]} { continue }
	set Premiere [PremiereLigneDuFichier $FichierMSF]
	if {$Premiere==""} { continue }
	if {[regexp "Clustalw inutile" $Premiere]} { continue }
	if {[regexp "NoSequencesToAlign" $Premiere]} { continue }

	Espionne [CreeLeFichierPhylo $FichierMSF $FichierPhylo]
    }
    return
}

proc CompleteLeFichierErreurs Fichier {
    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }

    foreach Ligne [LesLignesDuFichier $Fichier] {
	set Nom ""
	if {[YaPABenDebutDe $Ligne]} {
	    set Nom [string range $Ligne 0 6]
	}
	if {[regexp {^TROU[0-9][0-9]+[A-FN]} $Ligne]} {
	    set Nom [string range $Ligne 0 8]
	}
	if { $Nom != "" } { 
	    set Ligne [format "%8.8s %8.8s %s" [Box $Nom debut] [Box $Nom fin] $Ligne]
	}
	Espionne $Ligne
    }
}

proc EstUneFeuille Arbre {
    return [expr [llength $Arbre] == 1]
}

proc NomDeLaFeuille Arbre {
    return [lindex $Arbre 0]
}

proc CetteFeuilleEstLaCible Arbre {
    global Cible
    if {$Cible == [NomDeLaFeuille $Arbre]} { return 1 }
    return 0
}

proc Dedouble {Arbre aG ax aD ay} {
    upvar $aG G
    upvar $ax x
    upvar $aD D
    upvar $ay y

    if {[llength $Arbre] == 3} {
	set Arbre [list \
		[lindex $Arbre 0] \
		[lindex $Arbre 2] \
		[lindex $Arbre 1] \
		[lindex $Arbre 2] \
	]
    }

    set G [lindex $Arbre 0]
    set x [lindex $Arbre 1]
    set D [lindex $Arbre 2]
    set y [lindex $Arbre 3]
}

proc AppendEtRetourneDistance {Arbre Distance} {
    global ListeDistanceDeChaqueFeuille
    global MiniOuSomme

    JeMeSignale

    if { $Distance == "Inconnue" } {
	if {[EstUneFeuille $Arbre]} {
	    if {[CetteFeuilleEstLaCible $Arbre]} {
		if {$MiniOuSomme == "Mini"} {
		    set Distance 9999999.
		} else {
		    set Distance 0.0
		}
		return $Distance
	    } else {
		return "Inconnue"
	    }
	} else {
	    Dedouble $Arbre G x D y
	    set RetourG [AppendEtRetourneDistance $G "Inconnue"]
	    if { $RetourG != "Inconnue"} {
		if {$MiniOuSomme == "Mini"} {
		    set Dis [Mini $RetourG [Mini $x $y]]
		} else {
		    set Dis [expr $RetourG+$x+$y]
		}
		AppendEtRetourneDistance $D $Dis
		if {$MiniOuSomme == "Mini"} {
		    set Dis [Mini $RetourG $x]
		} else {
		    set Dis [expr $RetourG+$x]
		}
		return $Dis
	    }
	    set RetourD [AppendEtRetourneDistance $D "Inconnue"]
	    if { $RetourD != "Inconnue"} {
		if {$MiniOuSomme == "Mini"} {
		    set Dis [Mini $RetourD [Mini $x $y]]
		} else {
		    set Dis [expr $RetourD+$y+$x]
		}
		AppendEtRetourneDistance $G $Dis
		if {$MiniOuSomme == "Mini"} {
		    set Dis [Mini $RetourD $y]
		} else {
		    set Dis [expr $RetourD+$y]
		}
		return $Dis
	    }
	    return "Inconnue"
	}  
    } else {
	if {[EstUneFeuille $Arbre]} {
	    lappend ListeDistanceDeChaqueFeuille "[NomDeLaFeuille $Arbre] $Distance"
	    return $Distance
	} else {
	    Dedouble $Arbre G x D y
	    if {$MiniOuSomme == "Mini"} {
		set Dis [Mini $Distance $x]
	    } else {
		set Dis [expr $Distance+$x]
	    }
	    AppendEtRetourneDistance $G $Dis
	    if {$MiniOuSomme == "Mini"} {
		set Dis [Mini $Distance $y]
	    } else {
		set Dis [expr $Distance+$y]
	    }
	    AppendEtRetourneDistance $D $Dis
	}
    }
}

proc Boo Fichier {
    Espionne [ArbreBootstrapEnListe [ContenuDuFichier $Fichier]]
    exit
}

proc ArbreBootstrapEnListeOld {TextePH} {
    regsub -all "\n" $TextePH "" t
    regsub -all {[0-9]\.[0-9]*} $t "" t
    regsub -all {[\]]} $t "" t
    regsub -all {[\[]} $t "" t
    regsub -all {\:\)} $t ":9999.\)" t
    regsub -all {\(} $t {[list } t
    regsub -all ","  $t " " t
    regsub -all ":"  $t " " t
    regsub -all {\)} $t {]} t
    regsub -all {;}  $t "" t
    eval set Arbre $t
    if {[llength $Arbre] == 6} {
	set Arbre [list [lrange $Arbre 0 3] 0.0 [lindex $Arbre 4] [lindex $Arbre 5]]
    }
    return $Arbre 
}

proc ArbreBootstrapEnListe TextePH {
    regsub -all "\n" $TextePH "" t
    regsub -all {\:[0-9]\.[0-9]*} $t ":" t
    regsub -all {[\]\[]} $t "" t
    regsub -all {\(} $t {[list } t
    regsub -all ","  $t " " t
    regsub -all ":,"  $t ":" t
    regsub -all {:\)}  $t ":" t
    regsub -all ":"  $t " " t
    regsub -all {\)} $t {]} t
    regsub -all {;}  $t "" t
    exit
    eval set Arbre $t
    if {[llength $Arbre] == 4} {
	set Arbre [list \
		[list [lindex $Arbre 0] [lindex $Arbre 1] [lindex $Arbre 3]] \
		[lindex $Arbre 2] \
		[lindex $Arbre 3]]
    }
    return $Arbre 
}

proc AfficheArbre Arbre {
    global AfficheArbreIndent
    if {[EstUneFeuille $Arbre]} {
	Espionne "[string repeat " " $AfficheArbreIndent]+ $Arbre"
	return
    }
    set A1 [lindex $Arbre 0] 
    set D1 [lindex $Arbre 1] 
    set A2 [lindex $Arbre 2] 
    set D2 [lindex $Arbre 3] 
    Espionne "[string repeat " " $AfficheArbreIndent]+ $D1"
    incr AfficheArbreIndent
    AfficheArbre $A1
    incr AfficheArbreIndent -1
    Espionne "[string repeat " " $AfficheArbreIndent]+ $D2"
    incr AfficheArbreIndent
    AfficheArbre $A2
    incr AfficheArbreIndent -1
}

proc TestArbreEnListe {{args ""}} {
    global AfficheArbreIndent 
    set AfficheArbreIndent 0
    if {$args != ""} {set Fic $args} {set Fic "/genomics/link/ARP/phylos/ARP47"}
    set Arbre [ArbreEnListe [ContenuDuFichier $Fic]]
    AfficheArbre $Arbre
    exit
}

proc ArbreEnListe TextePH {
    regsub -all "\n" $TextePH "" t
    regsub -all {\(} $t {[list } t
    regsub -all ","  $t " " t
    regsub -all ":"  $t " " t
    regsub -all {\)} $t {]} t
    regsub -all {;}  $t "" t
    eval set Arbre $t
    if {[llength $Arbre] == 6} {
	set Arbre [list [lrange $Arbre 0 3] 0.0 [lindex $Arbre 4] [lindex $Arbre 5]]
    }
    return $Arbre 
}

proc ReBaptiseLaSequenceTFA {Sequence NomDeBapteme} {
    Wup "On remplace la premiere ligne."
    set ListeDesLignes [split $Sequence "\n"]
    set PremiereLigne ">$NomDeBapteme"
    return [join [lreplace $ListeDesLignes 0 0 $PremiereLigne] "\n"]
}

proc ReBaptiseLaSequenceGCG {Sequence NomDeBapteme} {
    Wup "On remplace le premier mot de la ligne des '..'"
    Wup "MAis attention avant c'etait autrement ..."

    set ListeDesLignes [split $Sequence "\n"]
    set iPP [lsearch -regexp $ListeDesLignes {\.\.}]
    if {$iPP<0} { FaireLire "$Sequence is not in GCG format." ; return $Sequence }
    set LignePP [lindex $ListeDesLignes $iPP]
    scan $LignePP "%s" AncienNom
    regsub "$AncienNom" $LignePP "$NomDeBapteme " BonneLignePP
    return [join [lreplace $ListeDesLignes $iPP $iPP $BonneLignePP] "\n"]
}

proc PrrpDesMSF {} {
    global RepertoireDuGenome
    global ListeDeBoites

    if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }

    foreach Boite $ListeDeBoites {
	set Nom [Box $Boite nom]
	if { [regexp {[5-9]} [FiabiliteFonction $Nom]] } {
	    set FichierPrrp     "$RepertoireDuGenome/prrp/$Nom"
	    if {[file exists $FichierPrrp]} { continue }
	    set FichierClustalw "$RepertoireDuGenome/clustalw/$Nom"
	    if {[file exists $FichierClustalw]} {
		PrrpDuMSF $FichierClustalw
	    }
	}
    }
}

proc PrrpDuMSF FichierMSF {
    global RepertoireDuGenome

    set DirDesPrrp "$RepertoireDuGenome/prrp"

    if {[YaPABdans $FichierMSF]} {
	set Nom [file tail $FichierMSF]
    }

    DecortiqueUnMSF $FichierMSF LesSequencesDansLOrdre Sequences
    foreach NomSeq $LesSequencesDansLOrdre {
	set Sequence [set Sequences($NomSeq)]
	set NomFichier "$NomSeq[NomDe ""]"
	lappend ListeDeFichiers [Sauve [TexteBrutToGCG $Sequence $NomFichier] dans $NomFichier]
    }
    set MSF [AlignePar "prrp" [join $ListeDeFichiers "\n"] "Interactif" $Nom]
    File rename $MSF "$DirDesPrrp/$Nom"
}

proc RepereNucOuBox {Ca K} {
    if {[YaPABouTROUouTRNAouARNenDebutDe $Ca]} { return [RepereBox $Ca $K] }
    set Nar [Narcisse $Ca]
    if {[YaPABouTROUouTRNAouARNenDebutDe $Nar]} { return [RepereBox $Nar $K] }
    if { ! [regexp {^[0-9]*$} $Ca]} { return [RepereBox $Ca $K] }
    if {[regexp {^[0-9]{,6}$} $Ca]} { return [RepereBox [Prefixe]$Ca $K] }
    return [RepereNuc $Ca $K]
}

proc RepereNuc {Position K} {
    global RepertoireDuGenome
    global ScrollRectangleOriginal IdScrollRectangle

    scan $Position "%s" Position

    if { ! [regexp {^[0-9]+$} $Position]} {return ""}

    if {[regexp "rond" $K]} {
	Aiguille "$Position" "black" $K "RepereBox" $Position
	return $K
    }

    scan "[$K coords [set IdScrollRectangle($K)]]" "%f %f %f %f" xMin  yMin  xMax  yMax
    scan "[set ScrollRectangleOriginal($K)]"      "%f %f %f %f" xMinO yMinO xMaxO yMaxO

    set Fraction [expr ($Position-$xMinO)/($xMaxO-$xMinO)]
    $K xview moveto $Fraction
    if {$K!="OrdrePourGif"} {
	ShowNuc $K 0 20 "Point" $Position
    } 
    $K xview scroll -5 units

    if { $K=="OrdrePourGif"} { return "Fraction $Fraction" }
    return $K
}

proc QuiEstLa {DebutSeq FinSeq Banque} {
    global ListeDeBoites
    global AQuiEstCeDebut
    global AQuiEstCetteFin
    global LesDebuts
    global LesFins
    global LesDebutsTries
    global LesFinsTries

    set OrientSeq "F"
    if {[expr $DebutSeq > $FinSeq]} {
	set Toto $DebutSeq
	set DebutSeq $FinSeq
	set FinSeq $Toto
	set OrientSeq "R"
    }
    if {$Banque == "phor"} {
	return "Pour Phor faut attendre"
    }

    if { $Banque == "paby" } {
	if { ! [info exists AQuiEstCeDebut]} {
	    if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }
	    
	    foreach Boite $ListeDeBoites {
		set Nom    [Box $Boite nom]
		if {[regexp "TROU" $Nom]} { continue }
		set Debut  [Box $Boite debut]
		set Fin    [Box $Boite fin]
		set Orient [Box $Boite orient]
		lappend AQuiEstCeDebut($Debut) $Nom
		lappend AQuiEstCetteFin($Fin)  $Nom
		lappend LesDebuts $Debut 
		lappend LesFins   $Fin
	    }
	    
	    set LesDebutsTries [lsort -integer $LesDebuts]
	    set LesFinsTries   [lsort -integer $LesFins]
	}
	
	set ppDebut [lindex $LesDebutsTries 0]
	set pgDebut [lindex $LesDebutsTries end]
	set nDebuts [llength $LesDebutsTries]
	set Probable [expr  ($DebutSeq-$ppDebut)*$nDebuts/($pgDebut-$ppDebut)]
	
	if {[expr $Probable < 6]} {
	    set Probable 6
	} elseif {[expr $Probable > [llength $LesDebutsTries]-1-6]} {
	    set Probable [expr [llength $LesDebutsTries]-1-6]
	} else {
	    if {[expr [lindex $LesDebutsTries $Probable] < $DebutSeq]} {
		while { [expr [lindex $LesDebutsTries $Probable] < $DebutSeq] } { incr Probable }
	    } else {
		while { [expr [lindex $LesDebutsTries $Probable] > $DebutSeq] } { incr Probable -1}
	    }
	}
	
	set Touches {}
	foreach X [lrange $LesDebutsTries [expr $Probable-6] [expr $Probable+6]] {
	    foreach Lui [set AQuiEstCeDebut($X)] {
		if {[Box $Lui orient] != $OrientSeq} { continue }
		if { [Box $Lui debut] <= $DebutSeq && $DebutSeq <= [Box $Lui fin] \
			|| [Box $Lui debut] <= $FinSeq && $FinSeq <= [Box $Lui fin] } {
		    lappend Touches $Lui
		} elseif {$DebutSeq <= [Box $Lui debut] && [Box $Lui debut] <= $FinSeq \
			||  $DebutSeq <= [Box $Lui fin] && [Box $Lui fin] <= $FinSeq } {
		    lappend Touches $Lui
		} 
	    }
	}
	return $Touches
    }
}

proc OffsetDansEnteteSegAli {Ligne {BanqueBlast ""}} {
    scan $Ligne "%s" BanqueAccess
    regsub ">" $BanqueAccess "" BanqueAccess

    scan [OffsetEtOrganismeDuFragment $BanqueAccess $BanqueBlast] "%d" Offset
    return $Offset
}

proc CreeOuATapeBlastX {{Banque ""} {AvecOrganismes ""} {AvecPositions ""} {AvecDupliques ""}} {
    global RepertoireDuGenome
    global ListeDeBoites

    if {$Banque==""} { set Banque "protall" }
    if {$AvecOrganismes==""} { set AvecOrganismes 0 }
    if {$AvecPositions ==""} { set AvecPositions  1 }
    if {$AvecDupliques ==""} { set AvecDupliques  0 }

    Wup "AvecOrganismes+AvecPositions  or  AvecDupliques"

    set FichierOuATape "$RepertoireDuGenome/fiches/ouatapebx.$Banque"

    if {[file exists $FichierOuATape]} {
	if {[OuiOuNon "$FichierOuATape\nalready exists. Do I replace it ?"]} {
	    File delete $FichierOuATape
	} else {
	    if {[OuiOuNon "Do I keep the existing lines from \n $FichierOuATape \n ?"]} {
		foreach Ligne [LesLignesDuFichier $FichierOuATape] {
		    scan $Ligne "%s" Nom
		    if { ! [info exists DejaVu($Nom)]} { set DejaVu($Nom) 0 }
		    incr DejaVu($Nom)
		}
	    } 
	}
    }

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }


    foreach Boite $ListeDeBoites {
	set Nom [Box $Boite nom]
	set Fichier "$RepertoireDuGenome/blastx/$Nom"
	if { ! [file exists $Fichier]} { continue }
	Espionne $Fichier

	if {$AvecOrganismes && ! [info exists DejaVu($Nom)]} {
	    set Organismes [join [OuATapeBlastX $Fichier "ListeDesOrganismes"] "\n"]
	    AppendAuFichier $FichierOuATape "$Nom $Organismes"
	}
	if {$AvecPositions && (! [info exists DejaVu($Nom)] || [set DejaVu($Nom)]<2)} {
	    set Positions  [join [OuATapeBlastX $Fichier "ListeDesPositions"] "\n"]
	    AppendAuFichier $FichierOuATape "$Nom $Positions"
	}
	if {$AvecDupliques && ! [info exists DejaVu($Nom)]} {
	    set Dupliques [join [OuATapeBlastX $Fichier "ListeDesDupliques"] "\n"]
	    AppendAuFichier $FichierOuATape "$Nom $Dupliques"
	}
    }
}

proc CreeOuATapeTBlastN {{Banque ""} {AvecOrganismes ""} {AvecPositions ""} {AvecDupliques ""}} {
    global RepertoireDuGenome
    global ListeDeBoites

    if {$Banque==""} { set Banque "genomes" }
    if {$AvecOrganismes==""} { set AvecOrganismes 0 }
    if {$AvecPositions ==""} { set AvecPositions  1 }
    if {$AvecDupliques ==""} { set AvecDupliques  0 }

    Wup "AvecOrganismes+AvecPositions  or  AvecDupliques"

    set FichierOuATape "$RepertoireDuGenome/fiches/ouatapetbn.$Banque"

    if {[file exists $FichierOuATape]} {
	if {[OuiOuNon "$FichierOuATape\nalready exists. Do I replace it ?"]} {
	    File delete $FichierOuATape
	} else {
	    if {[OuiOuNon "Do I keep the existing lines from \n $FichierOuATape \n ?"]} {
		foreach Ligne [LesLignesDuFichier $FichierOuATape] {
		    scan $Ligne "%s" Nom
		    if { ! [info exists DejaVu($Nom)]} { set DejaVu($Nom) 0 }
		    incr DejaVu($Nom)
		}
	    } 
	}
    }

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }


    foreach Boite $ListeDeBoites {
	set Nom [Box $Boite nom]
	set Fichier "$RepertoireDuGenome/tblastn$Banque/$Nom"
	if { ! [file exists $Fichier]} { continue }

	if {$AvecOrganismes && ! [info exists DejaVu($Nom)]} {
	    set Organismes [join [OuATapeTBlastN $Fichier $Banque "ListeDesOrganismes"] " "]
	    AppendAuFichier $FichierOuATape "$Nom $Organismes"
	}
	if {$AvecPositions && (! [info exists DejaVu($Nom)] || [set DejaVu($Nom)]<2)} {
	    set Positions  [join [OuATapeTBlastN $Fichier $Banque "ListeDesPositions"] " "]
	    AppendAuFichier $FichierOuATape "$Nom $Positions"
	}
	if {$AvecDupliques && ! [info exists DejaVu($Nom)]} {
	    set Dupliques [join [OuATapeTBlastN $Fichier $Banque "ListeDesDupliques"] " "]
	    AppendAuFichier $FichierOuATape "$Nom $Dupliques"
	}
    }
}

proc OuATapeTBlastN {Fichier Banque QuoiRetourner} {
    global PrecedentNom PrecedenteListe 


    if {$QuoiRetourner=="ListeDesOrganismes"} { set QuoiRetourner "LesOrgas" }
    if {$QuoiRetourner=="ListeDesPositions" } { set QuoiRetourner "LesHits" }
    if {$QuoiRetourner=="ListeDesPositionsVieux" } { set QuoiRetourner "LesHitsVieux" }

    Wup "Banque ne sert plus !"

    set Nom [file tail $Fichier]

    set DebutNom [Box $Nom debut]
    set FinNom   [Box $Nom fin]

    if {[info exists PrecedentNom] && $PrecedentNom==$Nom} {
	set ListeDesHomologues $PrecedenteListe
    } else {
	set ListeDesHomologues [ChaqueProteineDuTBlastN $Fichier]
    }
    set PrecedentNom $Nom
    set PrecedenteListe $ListeDesHomologues

    if {$ListeDesHomologues == {} } { return {}}

    catch {unset ListeDesDupliques}
    catch {unset ListeDesPositions}
    set LesBeauxHits {}
    foreach Homo $ListeDesHomologues {
	set lHomo [split $Homo "\t"]
	set i -1
	set Nom        [lindex $lHomo [incr i]]
	set nCops      [lindex $lHomo [incr i]]
	set nCopsSeq   [lindex $lHomo [incr i]]
	set BanqueId   [lindex $lHomo [incr i]]
	set Orga       [lindex $lHomo [incr i]]
	set Score      [lindex $lHomo [incr i]]
	set Expect     [lindex $lHomo [incr i]]
	set DebutQRel  [lindex $lHomo [incr i]]
	set FinQRel    [lindex $lHomo [incr i]]
	set DebutSbjct [lindex $lHomo [incr i]]
	set FinSbjct   [lindex $lHomo [incr i]]

	set LongSbjct [expr abs($FinSbjct-$DebutSbjct)+1]
	
	set DebutQuery [expr $DebutQRel+$DebutNom-1]
	set   FinQuery [expr   $FinQRel+$DebutNom-1]

	if { ! [info exists DejaVu($Orga)]} {
	    set DejaVu($Orga) 1
	    lappend LesBeauxOrgas $Orga
	}

	lappend LesBeauxHits "<BlastHit $BanqueId>\
		<PN $Expect>\
		<SC $Score>\
		<OX $Orga>\
		<DQ $DebutQuery>\
		<FQ $FinQuery>\
		<DS $DebutSbjct>\
		<FS $FinSbjct>\
		</BlastHit>"
	lappend LesHitsVieux [expr ($DebutQuery+$FinQuery)/2]
        lappend LesHitsVieux [expr ($DebutSbjct+$FinSbjct)/2]

    }
    if {$QuoiRetourner=="LesHits"} { return $LesBeauxHits }
    FaireLire "You use an old version of Gscope for OuATapeTBlastN"
    if {$QuoiRetourner=="LesOrgas"} { return $LesBeauxOrgas }
    if {$QuoiRetourner=="LesHitsVieux"} { return $LesHitsVieux }
    return ""
}

proc PNApres {Champ dans Texte} {
    return [ValeurApres $Champ dans $Texte "ExposantEventuellementMalFoutu"]
}

proc ChaqueProteineDuTBlastN {Fichier {AvecLaSeq ""}} {

    if {$AvecLaSeq==""} {
	set AvecLaSeq 0
    } else {
	set AvecLaSeq 1
    } 

    set Nom [file tail $Fichier]

    set SeuilDuTBlastN 0.001
#   set SeuilDuTBlastN 10.

    set nSequencesTrouves [DecortiqueBlast $Fichier \
	    $SeuilDuTBlastN "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN lPartieSegAli]
    if { $nSequencesTrouves == 0 } {
	set nCops 0
	return {}
    }


    set ListeDesHomologues {}
    set nCops 0
    set AttendreFinEntete 0
    set FinEntete 0
    foreach BanqueId $lBanqueId DE $lDE PN $lPN PartieSegAli $lPartieSegAli {
	set TaxId -1
	scan [OffsetEtOrganismeDuFragment "$BanqueId $DE"] "%d %s %s %d" Offset Genre Espece TaxId
	if {$TaxId>0} {
	    set Orga $TaxId
	} else {
	    set OrgaComplet "$Genre $Espece"
	    set Orga [Glossaire $OrgaComplet Court]
	}
	set nCopsDansCetteSequence 0
	foreach Ligne $PartieSegAli {
	    if { $AttendreFinEntete } {
		if { ! [regexp {[0-9a-zA-Z_]} $Ligne] } {
		    set AttendreFinEntete 0
		    set FinEntete 1
		} else {
		    append Entete $Ligne
		    continue
		}
	    }
	    if {[regexp {^>} $Ligne]} {
		set Entete $Ligne
		set AttendreFinEntete 1
	    }
	    if { $FinEntete } {
		set FinEntete 0
		set Offset [OffsetDansEnteteSegAli $Entete]
	    }
	    if { [regexp "^ Identities =" $Ligne] } {
		set Identities [StringApres "Identities =" dans $Ligne]
		set Positives  [StringApres "Positives ="  dans $Ligne]
		scan $Identities  "%d/%d" nId nTotal
		scan $Positives  "%d/%d" nPo nTotal
	    }
	    if { [regexp "^ Score =" $Ligne] } {
		if {[info exists Score]} {
		    incr nCops
		    incr nCopsDansCetteSequence
		    if { $AvecLaSeq } { 
			set EtLaSeq "\t$SeqSbjct"
		    } else {
			set EtLaSeq ""
		    }
		    Wup "Je triche en cachant dans Score le PourcentageIdentite"
		    set PourcentageIdentiteCacheDansScore [format "%6.2f" [expr (100.*$nId)/$nTotal]]
		    if {[catch {set Homologie "$Nom\t$nCops\t$nCopsDansCetteSequence\t$BanqueId\t$Orga\t$PourcentageIdentiteCacheDansScore\t$Expect\t$DebutQuery\t$FinQuery\t$DebutSbjct\t$FinSbjct$EtLaSeq"}]} { unset Score ; break }
		    lappend ListeDesHomologues $Homologie
		    unset Score
		    unset Expect
		    unset DebutQuery
		    unset DebutSbjct
		}
		set Score [FloatApres "Score =" dans $Ligne]
		catch {unset Expect}
		if {[regexp "Expect =" $Ligne]} { 
		    set Expect [PNApres "Expect =" dans $Ligne]
		}
		if {[regexp {Expect\([0-9]\) =} $Ligne Match]} { 
		    set Expect [PNApres $Match dans $Ligne]
		}
		if { ! [info exists Expect]} {
		    Warne "$Ligne\nwithout Expect ... I break"
		    catch {unset Score}
		    catch {unset Expect}
		    catch {unset DebutQuery}
		    catch {unset DebutSbjct}
		    break
		}
		catch {unset DebutQuery}
		catch {unset DebutSbjct}
		if { [expr $Expect > $SeuilDuTBlastN]} {
		    catch {unset Score}
		    catch {unset Expect}
		    catch {unset DebutQuery}
		    catch {unset DebutSbjct}
		    break
		}
	    }
	    if {[regexp "^  Database:" $Ligne] } {
		break
	    }
	    if {[regexp "^Query:?" $Ligne] } {
		if { ! [info exists DebutQuery]} {
		    #rR pour lire aussi les blast+ 2018/11/07
		    set Key "Query"
		    if {[regexp "Query:" $Ligne]} { set Key "Query:" }
		    set DebutQuery [IntegerApres $Key dans $Ligne]
		}
		set FinQuery [IntegerEnFin de $Ligne]
	    }
	    if {[regexp "^Sbjct:?" $Ligne] } {
		if { ! [info exists DebutSbjct]} {
		    set SeqSbjct ""
		    #rR pour lire aussi les blast+ 2018/11/07
		    set Key "Sbjct"
		    if {[regexp "Sbjct:" $Ligne]} { set Key "Sbjct:" }
		    set DebutSbjct [expr [IntegerApres $Key dans $Ligne] + $Offset]
		}
		regexp -indices {[0-9]+} $Ligne D
		set D [lindex $D 1]
		regexp -indices {[0-9]+} [string range $Ligne [incr D] end] F
		set F [expr [lindex $F 0]+$D-1]
		append SeqSbjct [string trim [string range $Ligne $D $F]]
		set FinSbjct [expr [IntegerEnFin de $Ligne] + $Offset]
	    }
	}
	if {[info exists Score] && [expr $Expect <= $SeuilDuTBlastN] } {
	    incr nCops
	    incr nCopsDansCetteSequence
	    if { $AvecLaSeq } { 
		set EtLaSeq "\t$SeqSbjct"
	    } else {
		set EtLaSeq ""
	    }
	    Wup "Je triche en cachant dans Score le PourcentageIdentite"
	    set PourcentageIdentiteCacheDansScore [format "%6.2f" [expr (100.*$nId)/$nTotal]]
	    if { ! [catch {set Homologie "$Nom\t$nCops\t$nCopsDansCetteSequence\t$BanqueId\t$Orga\t$PourcentageIdentiteCacheDansScore\t$Expect\t$DebutQuery\t$FinQuery\t$DebutSbjct\t$FinSbjct$EtLaSeq"}] } { 
		lappend ListeDesHomologues $Homologie
	    }
	}
	catch {unset Score}
	catch {unset Expect}
	catch {unset DebutQuery}
	catch {unset DebutSbjct}
    }
    return $ListeDesHomologues
}

proc ChaqueHitDuBlastP {Fichier {AvecLaSeq ""} {Cible ""}} {
    return [ChaqueProteineDuBlastX $Fichier $AvecLaSeq $Cible]
}

proc ChaqueProteineDuBlastX {Fichier {AvecLaSeq ""} {Cible ""}} {

    if {$AvecLaSeq==""} {
	set AvecLaSeq 0
    } else {
	set AvecLaSeq 1
    } 

    set Nom [file tail $Fichier]

    set SeuilExpect 0.001
    global SeuilExpectPourBlastX
    if {[info exists SeuilExpectPourBlastX]} {
	set SeuilExpect $SeuilExpectPourBlastX
    }
    set MaxList "SansLimiteDeNombre" 

    set nSequencesTrouves [DecortiqueBlast $Fichier \
	    $SeuilExpect $MaxList Query lBanqueId lAccess lDE lProfil lPN lPartieSegAli]
    if { $nSequencesTrouves == 0 } {
	set nCops 0
	return {}
    }


    set ListeDesHomologues {}
    set nCops 0
    set AttendreFinEntete 0
    set FinEntete 0
    foreach BanqueId $lBanqueId PN $lPN PartieSegAli $lPartieSegAli {
	if {$Cible!="" &&  ! [string equal -nocase $BanqueId $Cible]} { continue }
	set TaxId -1
	scan "0 Inconnu inconnu -1" "%d %s %s %d" Offset Genre Espece TaxId
	if {$TaxId>0} {
	    set Orga $TaxId
	} else {
	    set OrgaComplet "$Genre $Espece"
	    set Orga [Glossaire $OrgaComplet Court]
	}
	set nCopsDansCetteSequence 0
	foreach Ligne $PartieSegAli {
	    if { $AttendreFinEntete } {
		if { ! [regexp {[0-9a-zA-Z_]} $Ligne] } {
		    set AttendreFinEntete 0
		    set FinEntete 1
		} else {
		    append Entete $Ligne
		    continue
		}
	    }
	    if {[regexp {^>} $Ligne]} {
		set Entete $Ligne
		set AttendreFinEntete 1
	    }
	    if { $FinEntete } {
		set FinEntete 0
		set Offset 0
	    }
	    if { [regexp "^ Identities =" $Ligne] } {
		set Identities [StringApres "Identities =" dans $Ligne]
		set Positives  [StringApres "Positives ="  dans $Ligne]
		scan $Identities  "%d/%d" nId nTotal
		scan $Positives  "%d/%d" nPo nTotal
	    }
	    if { [regexp "^ Score =" $Ligne] } {
		if {[info exists Score]} {
		    incr nCops
		    incr nCopsDansCetteSequence
		    if { $AvecLaSeq } { 
			set EtLaSeq "\t$SeqSbjct"
		    } else {
			set EtLaSeq ""
		    }
		    Wup "Je triche en cachant dans Score le PourcentageIdentite"
		    set PourcentageIdentiteCacheDansScore [format "%6.2f" [expr (100.*$nId)/$nTotal]]
		    if {[catch {set Homologie "$Nom\t$nCops\t$nCopsDansCetteSequence\t$BanqueId\t$Orga\t$PourcentageIdentiteCacheDansScore\t$Expect\t$DebutQuery\t$FinQuery\t$DebutSbjct\t$FinSbjct$EtLaSeq"}]} { unset Score ; break }
		    lappend ListeDesHomologues $Homologie
		    unset Score
		    unset Expect
		    unset DebutQuery
		    unset DebutSbjct
		}
		set Score [FloatApres "Score =" dans $Ligne]
		catch {unset Expect}
		if {[regexp "Expect =" $Ligne]} { 
		    set Expect [PNApres "Expect =" dans $Ligne]
		}
		if {[regexp {Expect\([0-9]*\) =} $Ligne Match]} { 
		    set Expect [PNApres $Match dans $Ligne]
		}
		if { ! [info exists Expect]} {
		    Warne "$Ligne\nwithout Expect ... I break"
		    catch {unset Score}
		    catch {unset Expect}
		    catch {unset DebutQuery}
		    catch {unset DebutSbjct}
		    break
		}
		catch {unset DebutQuery}
		catch {unset DebutSbjct}
		if { [expr $Expect > $SeuilExpect]} {
		    catch {unset Score}
		    catch {unset Expect}
		    catch {unset DebutQuery}
		    catch {unset DebutSbjct}
		    break
		}
	    }
	    if {[regexp "^  Database:" $Ligne] } {
		break
	    }
	    if {[regexp "^Query:" $Ligne] } {
		if { ! [info exists DebutQuery]} {
		    #rR pour lire aussi les blast+ 2018/11/07
		    set Key "Query"
		    if {[regexp "Query:" $Ligne]} { set Key "Query:" }
		    set DebutQuery [IntegerApres $Key dans $Ligne]
		}
		set FinQuery [IntegerEnFin de $Ligne]
	    }
	    if {[regexp "^Sbjct:" $Ligne] } {
		if { ! [info exists DebutSbjct]} {
		    set SeqSbjct ""
		    #rR pour lire aussi les blast+ 2018/11/07
		    set Key "Sbjct"
		    if {[regexp "Sbjct:" $Ligne]} { set Key "Sbjct:" }
		    set DebutSbjct [expr [IntegerApres "Sbjct:" dans $Ligne] + $Offset]
		}
		regexp -indices {[0-9]+} $Ligne D
		set D [lindex $D 1]
		regexp -indices {[0-9]+} [string range $Ligne [incr D] end] F
		set F [expr [lindex $F 0]+$D-1]
		append SeqSbjct [string trim [string range $Ligne $D $F]]
		set FinSbjct [expr [IntegerEnFin de $Ligne] + $Offset]
	    }
	}
	if {[info exists Score] && [expr $Expect <= $SeuilExpect] } {
	    incr nCops
	    incr nCopsDansCetteSequence
	    if { $AvecLaSeq } { 
		set EtLaSeq "\t$SeqSbjct"
	    } else {
		set EtLaSeq ""
	    }
	    Wup "Je triche en cachant dans Score le PourcentageIdentite"
	    set PourcentageIdentiteCacheDansScore [format "%6.2f" [expr (100.*$nId)/$nTotal]]
	    if { ! [catch {set Homologie "$Nom\t$nCops\t$nCopsDansCetteSequence\t$BanqueId\t$Orga\t$PourcentageIdentiteCacheDansScore\t$Expect\t$DebutQuery\t$FinQuery\t$DebutSbjct\t$FinSbjct$EtLaSeq"}] } { 
		lappend ListeDesHomologues $Homologie
	    }
	}
	catch {unset Score}
	catch {unset Expect}
	catch {unset DebutQuery}
	catch {unset DebutSbjct}
    }
    return $ListeDesHomologues
}

proc SoleilsDesTBlastNs Selection {
    global RepertoireDuGenome

    foreach Nom [split $Selection "\n"] {
	lappend ListeDeBlasts "$RepertoireDuGenome/tblastngenomes/$Nom"
    }
    SoleilsDesBlasts [join $ListeDeBlasts "\n"]
}

proc SoleilsDesBlasts Selection {
    global GalerieCourante
    global ExpoCourante

    set ExpoCourante [NomDe expo]
    set GalerieCourante $ExpoCourante[NomDe galerie]

    CreeGalerie $GalerieCourante

    foreach Fichier [split $Selection "\n"] {
	GrapheBout $Fichier
    }

    ClosGalerieCourante
    ClosExpoCourante
}

proc OrganismeDeLaLigneTBlastN Ligne {

    JeMeSignale

    set Complet(taqu)    "Thermus aquaticus"
    set Complet(aaeol)   "Aquifex aeolicus"
    set Complet(aaeo)    "Aquifex aeolicus"
    set Complet(aful)    "Archaeoglobus fulgidus"
    set Complet(aper)    "Aeropyrum pernix"
    set Complet(bsub)    "Bacillus subtilis"
    set Complet(bburg)   "Borrelia burgdorferi"
    set Complet(bbur)    "Borrelia burgdorferi"
    set Complet(buch)    "Buchnera sp"
    set Complet(bsp)     "Buchnera sp"
    set Complet(baph)    "Buchnera aphidicola"
    set Complet(baphb)    "Buchnera aphidicola"
    set Complet(cjej)    "Campylobacter jejuni"
    set Complet(cpne)    "Chlamydia pneumoniae"
    set Complet(ctra)    "Chlamydia trachomatis"
    set Complet(drad)    "Deinococcus radiodurans"
    set Complet(ecoli)   "Escherichia coli"
    set Complet(ecol)    "Escherichia coli"
    set Complet(hinf)    "Haemophilus influenzae"
    set Complet(hpylo)   "Helicobacter pylori"
    set Complet(hpyl)    "Helicobacter pylori"
    set Complet(mthe)    "Methanobacterium thermoautotrophicum"
    set Complet(mtub)    "Mycobacterium tuberculosis"
    set Complet(mjan)    "Methanococcus jannaschii"
    set Complet(mgen)    "Mycoplasma genitalium"
    set Complet(mpneu)   "Mycoplasma pneumoniae"
    set Complet(mpne)    "Mycoplasma pneumoniae"
    set Complet(nmen)    "Neisseria meningitidis"
    set Complet(pae)     "Pyrobaculum aerophilum"
    set Complet(paby)    "Pyrococcus abyssi"
    set Complet(pfuri)   "Pyrococcus furiosus"
    set Complet(pfur)    "Pyrococcus furiosus"
    set Complet(pf)      "Pyrococcus furiosus"
    set Complet(phori)   "Pyrococcus horikoshii"
    set Complet(phor)    "Pyrococcus horikoshii"
    set Complet(ph)      "Pyrococcus horikoshii"
    set Complet(rprow)   "Rickettsia prowazekii"
    set Complet(rpro)    "Rickettsia prowazekii"
    set Complet(synecho) "Synechocystis sp"
    set Complet(syne)    "Synechocystis sp"
    set Complet(ssp)     "Synechocystis sp"
    set Complet(ssp.)    "Synechocystis sp"
    set Complet(tmar)    "Thermotoga maritima"
    set Complet(tpal)    "Treponema pallidum"
    set Complet(txxx)    "Thermococcus xxx"
    set Complet(uure)    "Ureaplasma urealyticum"
    set Complet(yeast)   "Saccharomyces cerevisiae"
    set Complet(yeas)    "Saccharomyces cerevisiae"
    set Complet(ye)      "Saccharomyces cerevisiae"
    
    set BanqueAccess [lindex [split $Ligne " "] 0]

    if {[regexp "_" $BanqueAccess] && ! [regexp "\:" $BanqueAccess]} {
	regsub "_" $BanqueAccess " " SansUnderscore
	set GloComplet [Glossaire $SansUnderscore Complet]
	if {$GloComplet != ""} { return $GloComplet }
    }

    set Banque [string tolower [lindex [split $BanqueAccess ":"] 0]]
    regsub {>} $Banque "" Banque

    if {[regexp -nocase "thermococcus" $Banque]} {
	return "Thermococcus xxx"
	return [Glossaire [set Complet(txxx)] Complet]
    }

    if {[regexp -nocase "PYRO_i_tot1.brut" $Banque]} {
	return "Pyrococcus horikoshii"
    }

    if {[regexp -nocase "PYRO_i_tot1.brut" $Banque]} {
	return "Pyrococcus horikoshii"
    }

    if {[regexp -nocase "ot3seq.fasta" $Banque]} {
	return "Pyrococcus horikoshii"
    }

    if {[regexp -nocase "^aero" $Banque]} {
	return "Aeropyrum pernix"
    }

    if {[regexp -nocase "^nmen" $Banque]} {
	return "Neisseria meningitidis"
    }

    if {[regexp -nocase "^MM4" $Banque]} {
	return "Pyrococcus furiosus"
    }

    if {[regexp -nocase "^DRA" $Banque]} {
	return "Deinococcus radiodurance"
    }

    if {[regexp -nocase "^UREA" $Banque]} {
	return "Ureaplasma urealyticum"
    }

    if {[regexp -nocase "^BUCH" $Banque]} {
	return "Buchnera sp"
    }

    set Access [string tolower [lindex [split $BanqueAccess ":"] 1]]
    if {[regexp "_" $Access]} {
	set Access [lindex [split $Access "_"] 0]
    }

    if {[info exists Complet($Access)]} {
	set Retour [Glossaire [set Complet($Access)] Complet]
	if {$Retour==""} { return "Inconnu inconnu" }
	return $Retour
    }
    if {[info exists Complet($Banque)]} {
	set Retour [Glossaire [set Complet($Banque)] Complet]
	if {$Retour==""} { return "Inconnu inconnu" }
	return $Retour
    }
    set Access [string range $Access 0 3]
    if {[info exists Complet($Access)]} {
	set Retour [Glossaire [set Complet($Access)] Complet]
	if {$Retour==""} { return "Inconnu inconnu" }
	return $Retour
    }
    if {[OuiOuNon "$Ligne incomprehensible.\n Sauriez-vous le definir ?" 0]} {
	FaireLire "Donner le nom complet de l'organisme en respectant Majuscule minuscule"
	set Organisme [Entre]
	set Complet($Ligne) $Organisme
	set Retour [Glossaire $Organisme Complet]
	if {$Retour==""} { return "Inconnu inconnu" }
	return $Retour 
    } else {
	return "Inconnu inconnu"
    }
}

proc PartieSegAli {Page LigneAccess} {
#   LogWscope "PartieSegAli [string length $Page] $LigneAccess"
    scan $LigneAccess "%s" Access
    regsub {\.+$} $Access "" Access
    set Cherche ">$Access "
    set OriCherche $Cherche
    set Debut [string first $Cherche $Page]
    while {$Debut<0} {
	set NewCherche [string range $Cherche 0 end-1]
	set Debut [string first $NewCherche $Page]
	if {$Debut>=0 && [string trim $Cherche]==$NewCherche} { break }  ;#rR rajouté 2017/07/10 pour >chr1 sans blanc derrière 
	if { ! [OuiOuNon "I cannot find the segment alignment for \"$Cherche\"\
		\nDo I continue to search with \"$NewCherche\" (one character less than before) ?\
		\nPlease notate that $NewCherche is no more equal to $OriCherche and it can be wrong ..."]} { return "I didn't find $LigneAccess" }
	set Cherche $NewCherche
	set Debut [string first $Cherche $Page]
    }
    set Fin [string first "\n>" $Page $Debut]
    if { $Fin < 0 } { set Fin "end" }
    return [string range $Page $Debut $Fin]
}

proc Deselecte K {
    global       RectangleDeSelectionNucleique
    global xDebutRectangleDeSelectionNucleique
    global yDebutRectangleDeSelectionNucleique
    global   xFinRectangleDeSelectionNucleique
    global   yFinRectangleDeSelectionNucleique
    global Piques

    foreach Nom [split [LesNomsPiques] "\n"] {
	Detoure $Nom $K
	unset Piques($Nom)
    }
    if {[info exists RectangleDeSelectionNucleique($K)]} {
	$K delete [set RectangleDeSelectionNucleique($K)]
	catch {unset       RectangleDeSelectionNucleique($K)}
	catch {unset xDebutRectangleDeSelectionNucleique($K)}
    }
}

proc FiabiliteFonction Nom {
    set FF [string range [ExtraitInfo $Nom "Fonction"] 0 0]
    if { $FF == "" } { return 0 }
    return $FF
}

proc MiseAJourAvecLesInfosDuGenoscope {} {
    global RepertoireDuGenome
    global InformeSansDemander

    set InformeSansDemander 1

    foreach Fichier [glob "$RepertoireDuGenome/DuGenoscope/infos.dir/*"] {
	set Nom [file tail $Fichier]
	Informe $Nom [ContenuDuFichier $Fichier]
    }
}

proc InfoInteressante Ligne {
    if {[regexp {^CNS-Adresse:} $Ligne]} { return 0 }
    if {[regexp {^CNS-Sequence:} $Ligne]} { return 0 }
    if {[regexp {^CNS-VieuxNom:} $Ligne]} { return 0 }
    if {[regexp {^CNS} $Ligne]} { return 1 }
    return 0
}

proc CreeLesInfosDuGenescope {Fichier Repertoire} {
    global RepertoireDuGenome

    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { $Ligne == "" } { continue }
	if {[regexp "^Nom: [ExpressionReguliereDesPABs]" $Ligne]} {
	    if {[info exists InfoCourante]} {
		Sauve [join $InfoCourante "\n"] dans "$Repertoire/$Nom"
	    }
	    scan $Ligne "%s %s" Bidon Nom
	    set InfoCourante {}
	}
	if {[InfoInteressante $Ligne]} {
	    lappend InfoCourante $Ligne
	}
    }
}
 
proc TCNI {} {
    global RepertoireDuGenome
    set CNI [ConcordanceNumerotationDesIntergenes ]
    set LesMemes [lindex $CNI 1]
    set LesModifies [lindex $CNI 2]
    EspionneL $LesMemes
    Espionne ""
    EspionneL $LesModifies
    exit
}

proc ConcordanceNumerotationDesIntergenes {Ancien Nouveau} {
    global RepertoireDuGenome

    set LesModifies {}


    foreach Ligne [LesLignesDuFichier $Ancien] {
	scan $Ligne "%s %d %d %s %s" A D F O L
	set AncienNom($D,$F) $A
	set AncienNomDebut($D) $A
	set AncienNomFin($F) $A
    }

    foreach Ligne [LesLignesDuFichier $Nouveau] {
	scan $Ligne "%s %d %d %s %d" N D F O L
	if {[info exists AncienNom($D,$F)]} {
	    set Nom [set AncienNom($D,$F)]
	    Espionne "Reprise complete $Nom $N"
	    lappend LesMemes    "$Nom $D $F $O $L"
	    lappend LesNouveaux "$Nom $D $F $O $L"
	    set DejaVu($Ligne) 1
	    set DejaUtilise($Nom) 1
	} else {
	    lappend LesModifies $Ligne
	} 
    }

    foreach Ligne [LesLignesDuFichier $Nouveau] {
	if {[info exists DejaVu($Ligne)]} { continue }
	scan $Ligne "%s %d %d %s %d" N D F O L
	if {[info exists AncienNomDebut($D)]} {
	    set Nom [set AncienNomDebut($D)]
	    if { ! [info exists DejaUtilise($Nom)]} {
		Espionne "Reprise debut $Nom $N"
		lappend LesNouveaux "$Nom $D $F $O $L"
		set DejaVu($Ligne) 1
		set DejaUtilise($Nom) 1
	    }
	}
    }

    foreach Ligne [LesLignesDuFichier $Nouveau] {
	if {[info exists DejaVu($Ligne)]} { continue }
	scan $Ligne "%s %d %d %s %d" N D F O L
	if {[info exists AncienNomFin($F)]} {
	    set Nom [set AncienNomFin($F)]
	    if { ! [info exists DejaUtilise($Nom)]} {
		Espionne "Reprise fin $Nom $N"
		lappend LesNouveaux "$Nom $D $F $O $L"
		set DejaVu($Ligne) 1
		set DejaUtilise($Nom) 1
	    }
	}
    }

    set Numero 10000
    foreach Ligne [LesLignesDuFichier $Nouveau] {
	if {[info exists DejaVu($Ligne)]} { continue }
	scan $Ligne "%s %d %d %s %d" N D F O L
	set Nom [format "INTERGENE%4.4d" [incr Numero -1]]
	Espionne "En desespoir $Nom $N"
	lappend LesNouveaux "$Nom $D $F $O $L"
	set DejaVu($Ligne) 1
	set DejaUtilise($Nom) 1
    }

    set LesNouveaux [lsort -command CompareLesMilieux $LesNouveaux]
    set LesMemes    [lsort -command CompareLesMilieux $LesMemes]
    set LesModifies [lsort -command CompareLesMilieux $LesModifies]
    return $LesNouveaux
}

proc SixBlastPsurPiques Selection {
    foreach Pique [split $Selection "\n"] {
	SixBlastPsurPique $Pique
    }
}

proc SixBlastPsurPique Pique {
    global ADN TDN RAC
    if { ! [info exists ADN] } { ChargeADNetTDNetRAC }


    set Debut [Box $Pique debut]
    set   Fin [Box $Pique fin]

    foreach Frame {a b c d e f} Orient {F F F R R R} Offset {1 2 3 1 2 3} {
	set DebutFrame [expr ($Debut/3)*3+$Offset]
	set   FinFrame [expr (  $Fin/3)*3+$Offset]
	set Nom "$Pique$Frame"
	set SeqNuc [BoutADN $DebutFrame $FinFrame $Orient]
	set SeqPro [SeqNucToSeqPro $SeqNuc]
	set TFA [SequenceFormatTFA $SeqPro $Nom "protbrut"]
	Blaste P $TFA "$Nom"
    }
}

proc SixBlastPsurZone K {
    global xDebutRectangleDeSelectionNucleique
    global yDebutRectangleDeSelectionNucleique
    global   xFinRectangleDeSelectionNucleique
    global   yFinRectangleDeSelectionNucleique

    if { ! [info exists xDebutRectangleDeSelectionNucleique($K)]} {
	FaireLire "IL faut selectionner une zone par <Shift-3>"
	return ""
    }

    set Debut [PositionCanvaOriginaleX $K [Mini \
	    [set xDebutRectangleDeSelectionNucleique($K)] \
	    [set   xFinRectangleDeSelectionNucleique($K)] \
	      ]]

    set   Fin [PositionCanvaOriginaleX $K [Maxi \
	    [set xDebutRectangleDeSelectionNucleique($K)] \
	    [set   xFinRectangleDeSelectionNucleique($K)] \
	      ]]

    foreach Frame {a b c d e f} Orient {F F F R R R} Offset {1 2 3 1 2 3} {
	set DebutFrame [expr ($Debut/3)*3+$Offset]
	set   FinFrame [expr (  $Fin/3)*3+$Offset]
	set Nom "${Orient}_${DebutFrame}_${FinFrame}"
	set SeqNuc [BoutADN $DebutFrame $FinFrame $Orient]
	set SeqPro [SeqNucToSeqPro $SeqNuc]
	set TFA [SequenceFormatTFA $SeqPro $Nom "protbrut"]
	Blaste P $TFA "$Nom"
    }
}

proc BlastXsurZone K {
    global xDebutRectangleDeSelectionNucleique
    global yDebutRectangleDeSelectionNucleique
    global   xFinRectangleDeSelectionNucleique
    global   yFinRectangleDeSelectionNucleique

    if { ! [info exists xDebutRectangleDeSelectionNucleique($K)]} {
	FaireLire "IL faut selectionner une zone par <Shift-3>"
	return ""
    }

    set Debut [PositionCanvaOriginaleX $K [Mini \
	    [set xDebutRectangleDeSelectionNucleique($K)] \
	    [set   xFinRectangleDeSelectionNucleique($K)] \
	      ]]

    set   Fin [PositionCanvaOriginaleX $K [Maxi \
	    [set xDebutRectangleDeSelectionNucleique($K)] \
	    [set   xFinRectangleDeSelectionNucleique($K)] \
	      ]]

    BlastXdeADN "X" $Debut $Fin
}

proc ShowNuc {K X Y Action {PositionNucleique 0}} {
    global ADN TDN RAC
    global OldX OldADN OldTDN OldPosD OldPosG OldLigne
    global       RectangleDeSelectionNucleique
    global xDebutRectangleDeSelectionNucleique
    global yDebutRectangleDeSelectionNucleique
    global   xFinRectangleDeSelectionNucleique
    global   yFinRectangleDeSelectionNucleique

    if { ! [info exists ADN]} { ChargeADNetTDNetRAC }

    set xVrai [$K canvasx $X]
    set yVrai [$K canvasy $Y]
    if { $Action == "Point" } {
	set xDebutRectangleDeSelectionNucleique($K) $xVrai
	set yDebutRectangleDeSelectionNucleique($K) $yVrai
    }

    if {[info exists OldLigne($K)]} {
	catch {$K delete [set OldADN($K)]}
	catch {$K delete [set OldTDN($K)]}
	catch {$K delete [set OldPosD($K)]}
	catch {$K delete [set OldPosG($K)]}
	catch {$K delete [set OldLigne($K)]}
	unset OldLigne($K)
	if { $PositionNucleique == 0 && $X == [set OldX($K)] } { return }
    }

    set x [$K canvasx $X]
    set y [$K canvasy $Y]

    if {$PositionNucleique > 0} {
	set i $PositionNucleique
    } else {
	set i [PositionCanvaOriginaleX $K [$K canvasx $X]]
    }

    set Orient "Inconnue"
    set BoiteTouchee [BoiteDuCourant $K $X $Y]
    if { $BoiteTouchee != "" } {
	if { [expr $i < ([Box $BoiteTouchee debut]+[Box $BoiteTouchee fin])/2]} {
	    set i [Box $BoiteTouchee debut]
	} else {
	    set i [expr [Box $BoiteTouchee fin]+1]
	}
	set x [PositionCanvaActuelleX $K $i]
	set y [expr $y-30]
	set Orient [Box $BoiteTouchee orient]
    }

    set ZoneADN [string range $ADN [expr $i-20] [expr $i+19]]
    set ZoneTDN [string range $TDN [expr $i-20] [expr $i+19]]
    set PositionD [format " %4.4d" $i]
    set PositionG [format "%4.4d " [expr $i-1]]

    set Fonte {Courier 10}
    set OldX($K) $X
    if { $Orient != "R" } {
	set OldADN($K)   [$K create text [expr $x] [expr $y-10] \
		-text $ZoneADN  -font $Fonte -anchor center]
    }
    if { $Orient != "F" } {
	set OldTDN($K)   [$K create text [expr $x] [expr $y+10] \
		-text $ZoneTDN  -font $Fonte -anchor center]
    }
    set OldPosD($K)  [$K create text $x [expr $y] -text $PositionD -font $Fonte -anchor w]
    set OldPosG($K)  [$K create text $x [expr $y] -text $PositionG -font $Fonte -anchor e]
    set OldLigne($K) [$K create line $x [expr $y-1000] $x [expr $y+1000]]

    if {[info exists RectangleDeSelectionNucleique($K)]} {
	$K delete [set RectangleDeSelectionNucleique($K)]
    }

    if { $Action == "Motion" } {
	set xFinRectangleDeSelectionNucleique($K) $xVrai
	set yFinRectangleDeSelectionNucleique($K) $yVrai
	set RectangleDeSelectionNucleique($K) [$K create rect \
		[set xDebutRectangleDeSelectionNucleique($K)] \
		[set yDebutRectangleDeSelectionNucleique($K)] \
		[set   xFinRectangleDeSelectionNucleique($K)] \
		[set   yFinRectangleDeSelectionNucleique($K)] \
		-outline "yellow" -width 3 \
		-tags "SelectionNucleique"] 
    }
}    

proc QueDitYvan Nom {
    global LesLignesDeYvan
    global RepertoireDuGenome

    if {! [info exists LesLignesDeYvan] } {
	set LesLignesDeYvan [LesLignesDuFichier "$RepertoireDuGenome/Yvan/Yvan_la_totale.txt"]
    }

    set i [lsearch -regexp $LesLignesDeYvan $Nom]
    if { $i == -1 } {
	set Message "Yvan ne dit rien"
    } else {
	set Message [join [lrange $LesLignesDeYvan [expr $i-1] [expr $i+1]] "\n"]
    }
    AfficheVariable "$Message\n\n[ContenuDuFichier $RepertoireDuGenome/infos/$Nom]" "GrandeLargeur"
    return $Message
}

proc QueDitCohen Nom {
    global RepertoireDuGenome

    set FichierCohen "$RepertoireDuGenome/cohen/$Nom"
    if {! [file exists $FichierCohen] } { FaireLire "Cohen ne dit rien" ; return "" }
    return [AfficheVariable [ContenuDuFichier $FichierCohen] "AvecRien"]
}

proc Presente Selection {
    global RepertoireDuGenome

    if {$Selection==""} { return "" }

    foreach Element [split $Selection "\n"] {
	if {[YaPABenDebutDe $Element]} {
	    set Element "$RepertoireDuGenome/prottfa/$Element"
	}
	if {[regexp {TRNA|RNA} $Element]} {
	    set Element "$RepertoireDuGenome/nuctfa/$Element"
	}
	if {[regexp {^TROU[0-9]+N$} $Element]} {
	    set Element "$RepertoireDuGenome/nuctfa/$Element"
	}
	if {[regexp {^TROU[0-9]+[A-F]$} $Element]} {
	    set Element "$RepertoireDuGenome/trousprottfa/$Element"
	}
	lappend Liste $Element
    }
    return [AfficheVariable [join $Liste "\n"] "AvecRienSansFetch"]
}

proc LesNomsPiques {} {
    global Piques

    if { ! [info exists Piques]} { return "" }
    set ListeDesPiques {}
    foreach Nom [array names Piques] {
	lappend ListeDesPiques $Nom
    }
    return [join $ListeDesPiques "\n"]
}

proc Entoure {Boite K} {
    global oldCouleurOutLine
    global oldLargeurOutLine

    if {[regexp "rond" $K]} { return "" }

    set Id [$K find withtag $Boite]

    set oldCouleurOutLine($K,$Boite) [$K itemcget $Id -outline] 
    set oldLargeurOutLine($K,$Boite) [$K itemcget $Id -width] 
    $K itemconfigure $Id -outline "pink" -width 8

    return [$K itemcget $Id -outline]
}

proc Detoure {Boite K} {
    global oldCouleurOutLine
    global oldLargeurOutLine

    set Id [$K find withtag $Boite]

    if {[info exists oldCouleurOutLine($K,$Boite)]} {
	$K itemconfigure $Id \
		-outline [set oldCouleurOutLine($K,$Boite)] \
		-width [set oldLargeurOutLine($K,$Boite)]
    }
    return [$K itemcget $Id -outline]
}

proc PiqueBox {K X Y Action} {
    global Piques

    set Boite [BoiteDuCourant $K $X $Y]
    if { $Boite == "" } { return $Boite}

    set Nom [Box $Boite nom]

    if { [info exists Piques($Nom)] } {
	unset Piques($Nom)
 	Detoure $Boite $K
	return $Boite
    }

    if { ! [info exists Piques($Boite)] } {
	set Piques($Nom) $Nom
	Entoure $Boite $K
	return $Boite
    }

}

proc MiseAJourDesNouveaux {} {
    global RepertoireDuGenome
    global InformeSansDemander

    set InformeSansDemander 1

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/DuGenoscope/nouveau"] {
	catch {unset Cop1 Cop2}

	set Append ""

	regexp "[ExpressionReguliereDesPABs]" $Ligne Nom
	regexp -indices "ExpressionReguliereDesPABs" $Ligne iNom
	scan $iNom "%d %d" Moi Prochain
	incr Prochain
	set Ligne [string range $Ligne $Prochain end]

	if { ! [regexp "[ExpressionReguliereDesPABs]" $Ligne Cop1] } {
	    Espionne "$Nom est nouveau"
	    set Append "Pris-nulle-part: Je suis un nouveau"
	} else {
	    regexp -indices "[ExpressionReguliereDesPABs]" $Ligne iCop1
	    scan $iCop1 "%d %d" Moi Prochain
	    incr Prochain
	    set Ligne [string range $Ligne $Prochain end]
	    regexp "[ExpressionReguliereDesPABs]" $Ligne Cop2
	    if { [info exists Cop2]} {
		Espionne "$Nom $Cop2"
		foreach Info [LesLignesDuFichier $RepertoireDuGenome/../aby/infos/$Cop1] {
		    append Append "\nPris-dans-$Cop2: $Info"
		}
	    }
	    Espionne "$Nom $Cop1"
	    foreach Info [LesLignesDuFichier $RepertoireDuGenome/../aby/infos/$Cop1] {
		append Append "\nPris-dans-$Cop1: $Info"
	    }
	}
	Informe $Nom $Append
    }
}

proc RangeLesFichiers Extension {
    global RepertoireDuGenome

    set Source [pwd]
    set Destination "$RepertoireDuGenome/$Extension"
    if { $Source == $Destination } {
	FaireLire "Attention tu es la ou tu veux ranger."
	return -1
    }
    foreach Fichier [glob $Source/*.$Extension] {
	RangeLeFichier $Fichier dans "$Destination"
    }
}

proc RangeLeFichier {Fichier dans Destination} {
    global RepertoireDuGenome

    set ConFi [ContenuDuFichier $Fichier]
    if {[regexp "[ExpressionReguliereDesPABs]" $ConFi Nom]} {
	set Destin "$Destination/$Nom"
	if { [Sauve $ConFi dans $Destin] == $Destin } {
		if { [file exists "$RepertoireDuGenome/clustalw/$Nom"]} {
		    File delete -force $Fichier
		}
	    return $Destin
	} else {
	    Warne "$Fichier n'a pas ete range en $Destin"
	    return ""
	}
    }
   Warne "$Fichier ne contient pas de nom en [PreFixe]xxxx"
   return ""
}

proc CreeLesFichiersTfas {} {
    global RepertoireDuGenome
    FaireLire "CreeLesFichiersTfas obsolete" 

    FaireLire "Attention, on ne tient pas compte des nouveaux [PreFixe]s"

    foreach TFA [split [ContenuDuFichier "$RepertoireDuGenome/DuGenoscope/pep"] ">"] {
	if { $TFA == "" } { continue }
	set Nom [string range $TFA 0 6]
	Sauve ">$TFA" dans "$RepertoireDuGenome/prottfa/$Nom"
    }
}

proc ChoisiEtAjouteChampsInfo Texte {
    global LesChampsInfo
    if { ! [info exists LesChampsInfo] } {
	lappend LesChampsInfo "Famille: "
	lappend LesChampsInfo "Famille: DOS"
	lappend LesChampsInfo "Famille: P62"
	lappend LesChampsInfo "Famille: SAP"
	lappend LesChampsInfo "Famille: Inconnue"
	lappend LesChampsInfo "Remarque: "
	lappend LesChampsInfo "Remarque: blastX"
	lappend LesChampsInfo "Remarque: TblastN"
	lappend LesChampsInfo "Remarque: profile"
	lappend LesChampsInfo "Remarque: analyse"
	lappend LesChampsInfo "CodonStart: "
	lappend LesChampsInfo "CodonStop: "
	lappend LesChampsInfo "Fantome: oui par condamnation rR"
	lappend LesChampsInfo "Enterre: oui force"
	lappend LesChampsInfo "Fonction: "
	lappend LesChampsInfo "Transmembrane: "
	lappend LesChampsInfo "Operon: "
	lappend LesChampsInfo "AutresHomologues: "
	lappend LesChampsInfo "CreePAB: "
    }
    set NouveauTexte [ChoixParmi $LesChampsInfo]
    if { $NouveauTexte != "" } {
	$Texte insert end "$NouveauTexte\n"
    }
}

proc ClasseNormalisee Texte {
    set ListeDesMots [split $Texte ";"]
    if { [llength $ListeDesMots] == 0 } { set Retour $Texte }
    if { [llength $ListeDesMots]  > 0 } { set Retour [lindex $ListeDesMots 0] }
    return [string trim $Retour "\."]
}

proc EspeceNormalisee Texte {
    set ListeDesMots [split $Texte " "]
    if { [llength $ListeDesMots] == 0 } { set Retour $Texte }
    if { [llength $ListeDesMots] == 1 } { set Retour [lindex $ListeDesMots 0] }
    if { [llength $ListeDesMots] >  1 } { set Retour [join [lrange $ListeDesMots 0 1] " "]}
    return [string trim $Retour "\."]
}

proc BoutADNDuTFA {Deb Fin Orient {FichierTFA ""}} {
    global BoutADNDuTFA

    if {$FichierTFA==""} { set FichierTFA $BoutADNDuTFA("Current")} 

    set BoutADNDuTFA("Current") $FichierTFA

    if { ! [info exists BoutADNDuTFA($FichierTFA)]} {
	set BoutADNDuTFA($FichierTFA) [QueLaSequenceDuFichierTFA $FichierTFA]
    }

    set LongueurTotale [expr [string length $BoutADNDuTFA($FichierTFA)]]
    if {$Fin=="end"} {set Fin $LongueurTotale}
    incr Deb -1 ; incr Fin -1
    set Seq [string range $BoutADNDuTFA($FichierTFA) $Deb $Fin]
    if {$Orient=="R"} {	set Seq [NucToReverseAndComplementNuc $Seq] }
    return $Seq
}

proc BoutADNDuTFAOldVersionSansMemoParFichier {Deb Fin Orient {FichierTFA ""}} {
    global BoutADNDuTFA  BoutADNDuTFAFichier

    if {$FichierTFA==""} { set FichierTFA $BoutADNDuTFAFichier } 

    if { ! [info exists BoutADNDuTFAFichier] || $BoutADNDuTFAFichier!=$FichierTFA} {
	set BoutADNDuTFAFichier $FichierTFA
	set BoutADNDuTFA [QueLaSequenceDuFichierTFA $FichierTFA]
    }

    set LongueurTotale [expr [string length $BoutADNDuTFA]]
    if {$Fin=="end"} {set Fin $LongueurTotale}
    incr Deb -1 ; incr Fin -1
    set Seq [string range $BoutADNDuTFA $Deb $Fin]
    if {$Orient=="R"} {	set Seq [NucToReverseAndComplementNuc $Seq] }
    return $Seq
}

proc BoutADN {{Debut 1} {Fin -1} {Orient "F"} {Banque ""} {aProbleme ""}} {
    global ADN TDN RAC
    global DerniereBase LongueurADN

    if {$aProbleme!=""} { upvar $aProbleme Probleme }

    if {$Banque!=""} { return [BoutADNDeLaBanque $Debut $Fin $Orient $Banque $aProbleme] }

    Wup "Attention on a mis un 'x' en position 0 pour que la 1ere base soit en 1"

    set Status "ADNetTDNetRACAvailable"
    if { ! [info exists ADN]} {	set Status [ChargeADNetTDNetRAC] }
    if {$Debut=="Existe"} {
	if {$Status=="ADNetTDNetRACNotAvailable"} { return 0 } else { return 1 }
    }

    if {$Status=="ADNetTDNetRACNotAvailable"} { return "" }

    if { ! [info exists DerniereBase]} {
	set LongueurADN [string length $ADN]
	set DerniereBase [expr $LongueurADN-1]
    }
    if {$Fin==-1} { set Fin $DerniereBase }

    if { $Orient == "F" } {
	if { $Debut>=1 && $Fin <= $DerniereBase } {
	    set Probleme 0
	    return [string range $ADN $Debut $Fin]
	} else {
	    if {$Debut < 1} {
		set Probleme [expr $Debut-1]
		return "[BoutADN [expr $DerniereBase+$Debut] $DerniereBase $Orient][BoutADN 1 $Fin $Orient]"
	    }
	    if {$Fin > $DerniereBase} {
		set Probleme [expr $Fin-$DerniereBase]
		return "[BoutADN $Debut $DerniereBase $Orient][BoutADN 1 [expr $Fin-$DerniereBase] $Orient]"
	    }
	}
    } else {
	if {$Debut>=1 && $Fin <=$DerniereBase} {
	    set Probleme 0
	    return [string range $RAC [expr $LongueurADN-$Fin] [expr $LongueurADN-$Debut]]
	} else {
	    if {$Debut < 1} {
		set Probleme [expr $Debut-1]
		return "[BoutADN 1 $Fin $Orient][BoutADN [expr $DerniereBase+$Debut] $DerniereBase $Orient]"
	    }
	    if {$Fin > $DerniereBase} {
		set Probleme [expr $Fin-$DerniereBase]
		return "[BoutADN 1 [expr $Fin-$DerniereBase] $Orient][BoutADN $Debut $DerniereBase $Orient]"
	    }
	}
    }
}

proc InformeParSuppressionDuChampPourTous Champ {
    foreach Boite [ListeDeBoites] {
	set Nom [Box $Boite nom]
	InformeParSuppressionDuChamp $Nom $Champ
    }
    return 
}

proc InformeParSuppressionDuChamp {Nom Champ {PourVoir ""}} {
    global RepertoireDuGenome

    if {$PourVoir==""} {
	set PourVoir 0
    } else {
	set PourVoir 1
    }

    Wup "Deletes all fields begining with 'Champ' in the infos files (Champ can be with or without ':' )"
    Wup "Attention use 'ABC:' to remove the Champ ABC (and not ABCD ...)"
 
    if {[regexp {\:} $Champ]} { regsub {\:} $Champ {\:} Champ }

    set FichierInfo "$RepertoireDuGenome/infos/$Nom"
    if { ! [file exists $FichierInfo]} { return "" }
    set NouvellesLignes {}
    set YaSuppression 0
    foreach Ligne [LesLignesDuFichier $FichierInfo] {
	if {[regexp "^$Champ" $Ligne]} {
	    set YaSuppression 1
	    continue
	}
	lappend NouvellesLignes $Ligne 
    }
    if { ! $PourVoir && $YaSuppression} {
	SauveLesLignes $NouvellesLignes dans $FichierInfo
    }
    return [join $NouvellesLignes "\n"]
}

proc InformeParMiseAJourPourTous {{Commande ""} {Champ ""} {Test 0} {Ask 0}} {
    global RepertoireDuGenome
    global InformeSansDemander

    Wup "Evals Commande and appends it to info, field Champ if not empty."
    Wup "If Test is 1 nothing happends"

    set Test [expr $Test != 0]
    set Ask  [expr $Ask  != 0]
    if {$Commande==""} {
	set Commande [Entre "\[PutHereTheCommand \$Nom\]"]
	if {$Commande==""} { return "" }
    }

    if { ! [info exists InformeSansDemander]} { set InformeSansDemander 0 }
    set MemoInformeSansDemander $InformeSansDemander
    set InformeSansDemander [expr ! $Ask] 

    set n 0
    foreach Boite [ListeDeBoites] { 
	set Nom [Box $Boite nom]
	eval set Valeur $Commande
	if {$Valeur==""} { continue }
	incr n
	if {$Champ!=""} {
	    set Append "$Champ: $Valeur"
	} else {
	    set Append $Valeur
	}
	if {$Test} {
	    Espionne "$Nom ... $Append"
	} else {
	    Informe $Nom $Append
	}
    }
    set InformeSansDemander $MemoInformeSansDemander
    return "$n infos/ files were updated"
}

proc ChargeCodonPreference {} {
    global CodonPreference CodonPreferenceMini CodonPreferenceMaxi
    global RepertoireDuGenome

    if { ! [file exists "$RepertoireDuGenome/DuGenoscope/codon_preference"]} {
	set CodonPreference Bidon
	return 
    }

    set CodonPreferenceMini  999.9
    set CodonPreferenceMaxi -999.9
    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/DuGenoscope/codon_preference"] {
	scan $Ligne "%s %s %f" Nom Bidon Preference
	set CodonPreference($Nom) $Preference
	set CodonPreferenceMini [Mini $Preference $CodonPreferenceMini]
	set CodonPreferenceMaxi [Maxi $Preference $CodonPreferenceMaxi]
    }
}

proc AideEnLigne Selection {
    global GscopeDir

    set LesMots [split [join [split $Selection "\n"] " "] " "]

    set Aucun 1
    foreach Mot $LesMots {
	set FichierHelp "$GscopeDir/help/gscope_[string tolower $Mot]_help.txt" 
	if {[file exists "$FichierHelp"]} {
	    AfficheFichier "$FichierHelp" "AvecAide"
	    set Aucun 0
	}
    }
    if { $Aucun } {
	FaireLire "Pas d'aide disponible.\nSelectionner une ligne avec des mots en MAJUSCULE"
    } 
}

proc Toggle SaVariable {
    upvar $SaVariable MaVariable
    set MaVariable [expr ! $MaVariable]
    return $MaVariable
}

proc ExtraitTouteInfo Nom {
    return [ExtraitInfo $Nom]
}

proc ValiDE Nom {
    set DE [ExtraitInfo $Nom "ValiDE:"]
    if {$DE==""} { set DE [ExtraitInfo $Nom "ValiDEProt:"] }
    if {[string equal -nocase "no value" $DE]} { set DE "" }
    return $DE
}

proc ValiGN Nom {
    set GN [ExtraitInfo $Nom "ValiGN:"]
    if {$GN==""} { set GN [ExtraitInfo $Nom "ValiGNProt:"] }
    if {[string equal -nocase "no value" $GN]} { set GN "" }
    return $GN
}

proc ExtraitInfo {Nom {Champ ""}} {
    global RepertoireDuGenome
    global ListeDeBoites
    global InfoEnMemoire
    global ListeDesContenuInfo
    global LesInfosRestentSurDisque

    if { ! [regexp -nocase {[a-z]} $Nom]} { return "" }

    if {0 && [info exists LesInfosRestentSurDisque]} {
	if { ! [file exists "$RepertoireDuGenome/infos/$Nom"]} { return "" }
	set Info [ContenuDuFichier "$RepertoireDuGenome/infos/$Nom"]
    } else {
	if { ! [info exists InfoEnMemoire($Nom)]} {
	    if { ! [info exists InfoEnMemoire(Temoin)]} {
		foreach Boite [ListeDeBoites] {
		    if { ! [regexp -nocase {[a-z]} $Boite]} { continue }
		    set FichierInfo "$RepertoireDuGenome/infos/$Boite"
		    if {[file exists $FichierInfo]} {
			set InfoEnMemoire($Boite) [ContenuDuFichier $FichierInfo]
			lappend ListeDesContenuInfo [string toupper [set InfoEnMemoire($Boite)]] 
		    } else {
			lappend ListeDesContenuInfo [string toupper "Nom: $Boite"] 
		    }
		}
		set InfoEnMemoire(Temoin) "Info est charge en memoire"
	    }
	    if {! [info exists InfoEnMemoire($Nom)]} { 
		set FichierInfo "$RepertoireDuGenome/infos/$Nom"
		if {[file exists $FichierInfo]} {
		    set InfoEnMemoire($Nom) [ContenuDuFichier $FichierInfo]
		} else {
		    set InfoEnMemoire($Nom) ""
		}
	    }
	}
	set Info [set InfoEnMemoire($Nom)]
    }

#rR Attention tout est en majuscule si AllInfos
    if {$Nom=="AllInfos"} { return [join $ListeDesContenuInfo "\n"] }

    regsub {\:$} $Champ "" Champ

    if { $Champ == "" } { return $Info }

    set LesValeurs {}
    foreach Ligne [split $Info "\n"] {
	if { ! [regexp -nocase -- "^$Champ\: *" $Ligne] } { continue }
	regsub -nocase -- "^$Champ\: *" $Ligne "" Valeur
	lappend LesValeurs $Valeur
    }
    set Valeur [join $LesValeurs " / "]
    return $Valeur

    set Valeur ""
    set Separateur ""
    foreach Ligne [split $Info "\n"] {
	if {[regexp -nocase -- "^$Champ\:" $Ligne] } {
	    set iValeur [expr [string first ":" $Ligne]+1]
	    append Valeur "${Separateur}[string trim [string range $Ligne $iValeur end]]"
	    set Separateur " / "
	}
    }
    return $Valeur
}

proc FetchCat {Access {Quoi ""}} {
    #rR completement obsolete car fetch n'existe plus
    return ""
    return [exec fetchcat $Access $Quoi]
}

proc FetchNoms Access {
    #rR completement obsolete car fetch n'existe plus
    return ""
    return [FetchCat $Access LesNoms]
}

proc FetchTest Access {
    #rR completement obsolete car fetch n'existe plus
    return 0
    return [FetchCat $Access "LeTest"]
}

proc CorrigeLesOutliers {} {
    FaireLire "Attention obsolete"
    exit
    foreach Fichier [glob "[RepertoireDuGenome]/outlier/*"] {
	set Texte [ContenuDuFichier $Fichier]
	if {[regexp "^I\ndid" $Texte]} {
	    Espionne $Fichier
	    Sauve "I didn't find any Batrachochytrium_dendrobatidis or Fungi" dans $Fichier
	}
    }
    exit
}

proc OutlierOrganism {{Orga ""}} {
    global OutlierOrganism
    if {$Orga!=""} { if {[info exists OutlierOrganism]} { unset OutlierOrganism } }
    if { ! [info exists OutlierOrganism]} {
	set Orga ""
	FaireLire "Please enter the Organism to test as outlier"
	while {$Orga==""} { 
	    set Orga [string trim [Entre "Batrachochytrium dendrobatidis"]]
	    regsub -all " " $Orga "_" Orga
	    if {[Tax $Orga TaxId]==""} {
		FaireLire "I did not found the taxon '$Orga', please enter an otherone."
		set Orga ""
		continue
	    }
	}
	set OutlierOrganism $Orga
    }
    return $OutlierOrganism
}

proc ReferenceClade {{Orga ""}} {
    global ReferenceClade
    if {$Orga!=""} { if {[info exists ReferenceClade]} { unset ReferenceClade } }
    if { ! [info exists ReferenceClade]} {
	set Orga ""
	FaireLire "Please enter the Reference Clade"
	while {$Orga==""} { 
	    set Orga [string trim [Entre "Fungi"]]
	    regsub -all " " $Orga "_" Orga
	    if {[Tax $Orga TaxId]==""} {
		FaireLire "I did not found the taxon '$Orga', please enter an otherone."
		set Orga ""
		continue
	    }
	}
	set ReferenceClade $Orga
    }
    return $ReferenceClade
}

proc BeauScore {} {
    foreach Ligne [LesLignesDuFichier outlierscore] {
	scan $Ligne "%s %s" Nom S
	if {$S==""} { set S -2}
	set B [format "%8.1e" $S]
	Espionne $B
	lappend LesBeaux "$Nom $B"
    }
    SauveLesLignes $LesBeaux dans "[RepertoireDuGenome]/fiches/outlierscorebeaux" 
    exit
}

proc OutlierScore {{Nom ""}} {
    global OutlierScore

    if {[info exists OutlierScore($Nom)]} { return $OutlierScore($Nom)}
    if {[info exists OutlierScore("EstCharge")]} { return "" }
    set OutlierScore("EstCharge") 1

    set FichierOutlierScore "[Fiches]/outlierscore"
    if {[file exists $FichierOutlierScore]} {
	foreach Ligne [LesLignesDuFichier $FichierOutlierScore] {
	    scan $Ligne "%s" N
	    set Score ""
	    regsub "$N +" $Ligne "" Score
	    set OutlierScore($N) $Score
	}
	return [OutlierScore $Nom] 
    }

    set LesAbsents  {} 
    set LesPresents {} 
    foreach FichierOutlier [lsort [glob -nocomplain "[RepertoireDuGenome]/outlier/*"]] {
	set Queue [file tail $FichierOutlier]
	if { ! [EstUnPAB $Queue]} { continue }
	set BestOut ""
	set BestRef ""
	foreach Ligne [LesLignesDuFichier $FichierOutlier] {
	    set Ligne [string range $Ligne 0 40]
	    set Absent 0
	    if {[regexp "^I" $Ligne]} {
		set LesAbsents [list -1]
		lappend LesNomsDuScore(-1) $Queue
		set OutlierScore($Queue) "+999"
		set Absent 1
		break
	    }
	    if {[regexp {^\*} $Ligne]} {
		if {$BestOut==""} { set BestOut $Ligne ; regsub -all {\*} $BestOut " " BestOut }
		if {$BestRef!=""} { break }
	    } else {
		if {$BestRef==""} { set BestRef $Ligne }
		if {$BestOut!=""} { break }
	    }
	}
	if { $Absent } { continue }


	set PnOut 1e+10
	set PnRef 1e+10
	if {$BestOut!=""} { scan $BestOut "%s" PnOut ; regsub -nocase {([0-9]+).(e.*)} $PnOut "\\1.\\2" PnOut } 
	if {$BestRef!=""} { scan $BestRef "%s" PnRef ; regsub -nocase {([0-9]+).(e.*)} $PnRef "\\1.\\2" PnRef }
	if {$PnRef<1.e-200} {
	    if {$PnRef==$PnOut} { set Score 1. }
	    if {$PnOut>1.e-200} { set Score 99999 }
	} else {
	    set Score [expr $PnOut/$PnRef]
	}
	set Ori $Score
	if {$Score==""} {
	    set Score "+998"
	} else { 
	    set Score [format "%8.1e" $Score]
	    set Ori "$Ori/$Score"
	    regsub {[^e]+e} $Score "" Exp
	    if {[regexp {\+} $Score]} { set Signe "+" } else { set Signe "-" }
	    regsub {[\+\-]} $Exp "" N
	    if {$N==0} {
		set Exp "+0"
	    } else {
		set N [string trimleft $N "0"]
		set Exp "$Signe$N"
	    }
	}
	set Score [format "%4s = %s / %s" $Exp $PnOut $PnRef]
	lappend LesPresents $Exp
	lappend LesNomsDeExp($Exp) $Queue
	set OutlierScore($Queue) $Score
    }

    set LesPresents [lsort -unique -real $LesPresents]
    set LesAbsents  [lsort -unique -real $LesAbsents]
    foreach Exp $LesPresents {
	foreach N $LesNomsDeExp($Exp) {
	    lappend LesNomScore "$N $OutlierScore($N)"
	}
    }
    foreach Exp $LesAbsents {
	foreach N $LesNomsDuScore($Exp) {
	    lappend LesNomScore "$N $OutlierScore($N)"
	}
    }
    SauveLesLignes $LesNomScore dans $FichierOutlierScore
    return [OutlierScore $Nom]
}  

proc OutlierOrganismInBlastPourTous {{Outlier ""} {Clade ""} {Seuil ""}} {
    file mkdir "[RepertoireDuGenome]/outlier"
    set I 0
    foreach Nom [ListeDesPABs] {
	if {$I%100==0} { Espionne "outlier/$Nom" }
	incr I
	OutlierOrganismInBlast $Nom $Outlier $Clade $Seuil "Save"
    }
    
}

proc OutlierOrganismInBlast {Nom {Outlier ""} {Clade ""} {Seuil ""} {GetWhat ""}} {

    #rR quand on donne un outlier on n'utilise pas les fichiers ./outlier/Nom précalculés

    if {$GetWhat==""} { set GetWhat "Show" }

    set LaSortie {}
    if {$Outlier==""} {
	set FichierOutliers [GscopeFile $Nom outlier]
	if {[file exists $FichierOutliers]} {
	    set LaSortie [LesLignesDuFichier $FichierOutliers]
	}
    }

    if {$LaSortie=={}} {
	if {$Seuil==""} { set Seuil 99999 }
	
	if {$Outlier ==""} { set Outlier  [OutlierOrganism] }
	if {$Clade   ==""} { set Clade [ReferenceClade] }
	
	set iOutlier  [Tax $Outlier TaxId]
	set iClade    [Tax $Clade   TaxId]
	set LesOrgaTrie [LesLignesDuFichier [GscopeFile $Nom "taxobla"]]
	if {$LesOrgaTrie=={}} { return "The file taxobla/$Nom does not exist" }
	foreach Ligne $LesOrgaTrie {
	    lassign [split $Ligne "\t"] Expect Score TaxId OS Reste
	    set Score  [string trim $Score]
	    set Expect [string trim $Expect]
	    if {$Expect > $Seuil} { break }
	    set TaxId  [string trim $TaxId]
	    set OS     [string trim $OS]
	    set Reste  [string trim $Reste]
	    if {[QuestionDeScience "EVImm" "ret Descendant $iOutlier $TaxId ForceAncestorFirst"]} {
		lappend LaSortie "*** $Ligne"
	    } else {
		if {[QuestionDeScience "EVImm" "ret Descendant $iClade $TaxId ForceAncestorFirst"]} {
		    lappend LaSortie "    $Ligne"
		}
	    }
	}
	if {$LaSortie=={}} { set LaSortie [list "I didn't find any $Outlier or $Clade"] }
    }
    if {[regexp "/" $GetWhat] || [string equal -nocase "Save" $GetWhat]} {
	set FichierOutliers $GetWhat
	if {[string equal -nocase "Save" $GetWhat]} { set FichierOutliers [GscopeFile $Nom outlier] }
	return [SauveLesLignes $LaSortie dans $FichierOutliers]
    }
    if {[string equal -nocase "GetList" $GetWhat]} { return $LaSortie }
    if {[string equal -nocase "GetText" $GetWhat]} { return [join $LaSortie "\n"] }
    return [AfficheListe $LaSortie]
}

proc TestLODB {fileBlast} {
    set fileBlast "/genomics/link/CilioCarta/blastp/HSAP00001"
    set fileBlast "/home/kress/elephas.blastp"
    set blast [ContenuDuFichier $fileBlast]
    set B64 [Base64Encode $blast]
#    set orgas [QuestionDeScience EVImm "ret TaxonomyDuBlast $B64 - - GetText"]
    set orgas [TaxonomyDuBlast $B64 KeepAll - GetText]
    Espionne $orgas
}


proc LesHitsDuBlast {Fichier {SeuilExpect 0.001} {MaxListe 99999} {Quoi ""}}  {
    DecortiqueBlast $Fichier $SeuilExpect $MaxListe Query lBId lA lDE lProfil lPN
    set Retour {}
    set LesBId {}
    set LesA {}
    foreach BId $lBId A $lA DE $lDE PN $lPN {
	lappend LesBId $BId
	lappend LesA   $A
	set Hit "$PN $BId $A $DE"
	if {$Quoi=="BestHit"} { return $Hit }
	lappend Retour [format "%-75s %s" "$BId $A $DE" $PN]
    }
    if {[regexp "I" $Quoi]} { return $LesBId }
    if {[regexp "A" $Quoi]} { return $LesA }
    return $Retour
    exit
}

proc InformeFromBestBlastHitPourTous {} {
    set LesBest {}
    foreach Nom [ListeDesPABs] {
	lappend LesBest "$Nom [InformeFromBestBlastHit $Nom SansDemander]"
    }
    return $LesBest
}

proc InformeFromBestBlastHit {Nom {SansDemander ""}} {
    set Best [LesHitsDuBlast $Nom "" 1 "BestHit"]
    if {$Best==""} { return "" }
    scan $Best "%s %s %s" PN BId Ac
    set DE [join [lrange $Best 3 end]]
    set Bank ""
    if {[regexp {\|} $BId]} {
	lassign [split $BId "|"] Bank A I
	set DE "$Ac $DE"
	set BId $I
	set Ac $A
    } 
    Informe$SansDemander $Nom "=BestBlastHitID: $BId" 
    Informe$SansDemander $Nom "=BestBlastHitAC: $Ac" 
    Informe$SansDemander $Nom "=BestBlastHitDE: $DE" 
    Informe$SansDemander $Nom "=BestBlastHitPN: $PN" 
    return $Best
}

proc DecortiqueBlast {TexteOuListeOuFichier {CutPN ""} {MaxListe ""}  {aQuery ""} {alBanqueId ""} {alAccess ""} {alDE ""} {alProfil ""} {alPN ""} {alPartieSegAli ""}} {

    set NoAccessInHit 0
    if {$alAccess=="NoAccessInHit"} {
	set NoAccessInHit 1
	set alAccess ""
    }

    if {$CutPN==""} { set CutPN 0.001 }
    if {$MaxListe==""} { set MaxListe 99999 }

    if {$aQuery!="BlastHitCount" || $aQuery!="RetourneBlastTrie"} {
	if {$aQuery         !=""} { upvar $aQuery         Query        }
	if {$alBanqueId     !=""} { upvar $alBanqueId     lBanqueId    }
	if {$alAccess       !=""} { upvar $alAccess       lAccess      }
	if {$alDE           !=""} { upvar $alDE           lDE          }
	if {$alProfil       !=""} { upvar $alProfil       lProfil      }
	if {$alPN           !=""} { upvar $alPN           lPN          }
    }
    if {$alPartieSegAli != ""} {
	if { ! [string equal $alPartieSegAli "LongDefinition"]} {
	    upvar $alPartieSegAli lPartieSegAli
	}
	set OnVeutPartieSegAli 1
	set lPartieSegAli {}
    } else {
	set lPartieSegAli {}
	set OnVeutPartieSegAli 0
    }


    if {$aQuery=="RetourneBlastTrie"} { set RetourneBlastTrie 1 } else { set RetourneBlastTrie 0 }

    set AvecMemo 0
    if {$AvecMemo} {
	global MemoDecortique
	set LesVarMemo {FichierMemo NombreDeBons Query lBanqueId lAccess lDE lProfil lPN lPartieSegAli}
	set FichierMemo $TexteOuListeOuFichier
	if {[info exists MemoDecortique(FichierMemo)] && \
		! $RetourneBlastTrie && \
		$MemoDecortique(FichierMemo)==$FichierMemo} {
	    foreach V $LesVarMemo {
		set $V [set MemoDecortique($V)]
	    }
	    return $NombreDeBons
	}
	if {[info exists MemoDecortique]} { unset MemoDecortique }
    }

    set Fichier ""
    if {[EstUnPAB $TexteOuListeOuFichier] && [file exists [GscopeFile $TexteOuListeOuFichier blastp]]} {
	set ListeDesLignes [LesLignesDuFichier [GscopeFile $TexteOuListeOuFichier blastp]]
    } elseif {[regexp "\n" $TexteOuListeOuFichier]} {
	set ListeDesLignes [split $TexteOuListeOuFichier "\n"]
    } elseif {[regexp " " $TexteOuListeOuFichier]} {
	set ListeDesLignes $TexteOuListeOuFichier
    } elseif {[file exists $TexteOuListeOuFichier]} {
	set Fichier $TexteOuListeOuFichier
	set ListeDesLignes [LesLignesDuFichier $TexteOuListeOuFichier]
    } else {
	FaireLire "I don't know how to analyse the blast\n$TexteOuListeOuFichier\n\
		It's not a text, not a list, not a file"
	return ""
    }

    if {$ListeDesLignes=={}} {
	set Query ""
	set lBanqueId {}
	set lAccess {}
	set lDE {}
	set lProfil {}
	set lPN {}
	set lPartieSegAli {}
	return 0
    }

    if {$CutPN    == "" } { set CutPN    0.001 }
    if {$MaxListe == "" } { set MaxListe "SansLimiteDeNombre" }

    if {$CutPN    == "SansSeuilExpect"}    { set CutPN    9999.9 }
    set RenvoieLesHitsAvecSegAliUniquement 1
    if {$MaxListe == "SansLimiteDeNombreDuTout"} {
	set MaxListe "SansLimiteDeNombre"
	set RenvoieLesHitsAvecSegAliUniquement 0
    }
    if {$MaxListe == "SansLimiteDeNombre"} { set MaxListe 99999 }

    set lBanqueId {}
    set lAccess   {}
    set lDE       {}
    set lProfil   {}
    set lPN       {}
    set NombreDeBons 0

    set PremierMot ""
    scan [join [lrange $ListeDesLignes 0 3] " "]  "%s" PremierMot
    set RechercheDansFichier 1
    while {1} {
#	set PourBlastP  [string equal -nocase $PremierMot "BLASTP"]
#	set PourBallast [string equal -nocase $PremierMot "Ballast"]
#	set PourTBlastX [string equal -nocase $PremierMot "TBLASTX"]
#	set PourBlastN  [string equal -nocase $PremierMot "BLASTN"]
#	set PourTBlastN [string equal -nocase $PremierMot "TBLASTN"]
	set PourBlastP  [expr  ! [string compare $PremierMot "BLASTP"]]
	set PourBlastX  [expr  ! [string compare $PremierMot "BLASTX"]]
	set PourBallast [expr  ! [string compare $PremierMot "BALLAST"]]
	set PourTBlastX [expr  ! [string compare $PremierMot "TBLASTX"]]
	set PourBlastN  [expr  ! [string compare $PremierMot "BLASTN"]]
	set PourTBlastN [expr  ! [string compare $PremierMot "TBLASTN"]]
	if {[expr $PourBlastP+$PourBlastX+$PourBallast+$PourTBlastX+$PourBlastN+$PourTBlastN] == 1} {
	    break
	}
	if {$RechercheDansFichier && \
		[regexp "BLASTP|BLASTX|Ballast|TBLASTX|BLASTN|TBLASTN" \
		[join [lrange $ListeDesLignes 0 9] " "] PremierMot]} {
	    set RechercheDansFichier 0
	    continue
	}
	if {[OuiOuNon "I can't choose between BLASTP BLASTX Ballast TBLASTX BLASTN TBLASTN\n \
		Could you help me ?" 0]} {
	    set PremierMot [Entre "BLASTP"]
	} else {
	    if {[OuiOuNon "Do I use BLASTP ?" 0]} { set PremierMot "BLASTP" ; continue }
	    if {[OuiOuNon "Do I skipp ?"]} { return "" }
	    if {[OuiOuNon "Do I stop  ?"]} { exit }
	}
    }
    set PositionPN 0
    set PositionScore 1
    if {$PourBallast} {
	set TexteSPSA     "Sequences producing "
	set iProfil       62
	set FinDE         65
    } elseif {$PourTBlastX} { 
	set PositionPN    0
	set PositionScore 1
	set TexteSPSA     "Sequences producing "
	set FinDE         66
	set iProfil       67
    } else {
	set TexteSPSA     "Sequences producing "
	set FinDE         65
	set iProfil       66
    }

    set IndexQuery [lsearch -regexp $ListeDesLignes "Query="]
    if { $IndexQuery == -1 } {
	FaireLire "Please select also the \"Query=\" line."
	return -1
    }
    if {$aQuery=="BlastHitCount"} {
	set Query    "NotImportantForBlastHitCount"
	set Nomquery "NotImportantForBlastHitCount"
    } else {
	set PossiblePAB [file tail $Fichier]
	set Query    [QueryDeLaLigne [lindex $ListeDesLignes $IndexQuery] "DoNotCreateIt" $PossiblePAB]
	set NomQuery [file tail $Query]
    }
    if {[lsearch -regexp [lrange $ListeDesLignes 0 30] "No hits found"] != -1} {
	return 0
    }

    set IndexSPSA [lsearch -regexp $ListeDesLignes $TexteSPSA]
    if { $IndexSPSA == -1 } { return 0}
    set Saut 2
    if {[regexp -nocase {[a-z]} [lindex $ListeDesLignes [expr $IndexSPSA + 1]]]} { incr Saut }
    set PartieRestante [lrange $ListeDesLignes [incr IndexSPSA $Saut] end]

    set PartieEntete [lrange $ListeDesLignes 0 $IndexSPSA]

    set IndexPremierChevron [lsearch -regexp $PartieRestante {^>}]
    if { $IndexPremierChevron == -1 } {
	set PartieScores [lrange $PartieRestante 0 end]
	set PartieSegAli {}
    } else {
	set PartieScores [lrange $PartieRestante 0 [expr $IndexPremierChevron-1]]
	set PartieSegAli [lrange $PartieRestante $IndexPremierChevron end]
    }

    set OldPN -99999
    set zPN 0
    set IlFautTrier 0
    set EstUnPsiBlast 0
    set Profil 0
    foreach Ligne $PartieScores {
	if { $Ligne == "" } { continue }
	if { [regexp "Sequences not found previously" $Ligne] } {
	    set EstUnPsiBlast 1
	    continue
	}
	
	regsub "!" $Ligne " " Ligne

	if { $PourBallast && [regexp {\-{50}} $Ligne]} { continue }
	if { ! [regexp {[a-zA-Z]} $Ligne]} {
	    if {[regexp "^  Database\:" $Ligne]} { break }
	    if {[OuiOuNon "$Ligne\n do I skip this line ?"]} { continue }
	    if {[OuiOuNon "$Ligne\n do I stop processing ?"]} { break }
	}
	if {[regexp {\\\\End} $Ligne]} { break }
	if { [regexp {^[0-9a-zA-Z]} $Ligne]} {
	    set FromNCBI 0
	    set Access ""
	    #rR le NCBI ne met plus d'access mais il y a deux blancs ;)
	    if {[regexp {^([^ ]+)  } $Ligne Match B]} {
		regsub "  " $Ligne " $B " Ligne
		set FromNCBI 1
	    }
	    if {! [scan $Ligne "%s %s" BanqueId Access]} {break}
	    set OriginalBanqueId $BanqueId
	    set OriginalAccess   $Access
	    set AccessLu $Access
	    if {[regexp -nocase {^UniRef} $BanqueId]} {
		set Access $BanqueId
	    }
	    if {[regexp -nocase {[\(\)\{\}\[\]]} $Access]} {
		set Access $BanqueId
	    }
	    if { ! [EstUnAccessPDB $Access] && \
		    ([EstUnAccessPDB $BanqueId] || ! [regexp -nocase {[a-z_]} $Access])} {
		set Access $BanqueId
	    }
	    set Profil [expr ![string compare [string range $Ligne $iProfil $iProfil] "*"]]

	    #rR 2019/01/22
	    if {[regexp {[0-9]+% *$} $Ligne]} { regsub { +[0-9]+% *$} $Ligne "" Ligne }
	    set ScorePN [string trim $Ligne]
	    regsub -all { +} $ScorePN " " ScorePN
	    set LesMots [split $ScorePN " "]
	    set sScore [lindex $LesMots end-$PositionScore]
	    scan $sScore "%d" Score
	    set sPN    [lindex $LesMots end-$PositionPN]
	    if {$sScore=="" || $sPN==""} { break }
	    if {$FromNCBI} {
		set DE [StringSuivant "$OriginalBanqueId $OriginalBanqueId " dans $Ligne]
	    } else {
		set DE $Ligne
		set DE [StringSuivant "$OriginalBanqueId" dans $DE]
		if { ! [EstUnAccessPDB $OriginalBanqueId] && \
			 ! [regexp -nocase {[^a-z0-9_]} $AccessLu] &&\
			 ! [regexp -nocase {^UniRef} $BanqueId]} {
		    set DE [StringSuivant "$OriginalAccess" dans $DE]
		}
	    }
	    regsub "$sPN *$"       $DE "" DE
	    regsub "$sScore *$"    $DE "" DE
	    set DE [string trim $DE]
	} else {
	    if { ! $PourBallast} { 
		if {[regexp "^  Database\:" $Ligne]} { break }
		if {[OuiOuNon "$Ligne\n do I skip this line ?"]} { continue }
		if {[OuiOuNon "$Ligne\n do I stop processing ?"]} { break }
	    }
	    set Ligne [string trim $Ligne]
	    if {! [scan $Ligne "%s %s" BanqueId Access]} {
		if {[regexp "^  Database\:" $Ligne]} { break }
		if {[OuiOuNon "$Ligne\n do I skip this line ?"]} { continue }
		if {[OuiOuNon "$Ligne\n do I stop processing ?"]} { break }
	    }
	    set DE [string range $Ligne [string length "$BanqueId $Access "] end]
	    set Profil $OldProfil
	    set PN     $OldPN
	}
	
	regsub {^[eE]} $sPN "1e" sPN
#	scan $sPN "%f" PN
	set PN $sPN
	if {[catch { expr $PN > $CutPN } ]} {
	    Warne "Oh le vilain $PN"
	    set PN 1E-200
	}
	if { ! $PourBallast && [expr $PN > $CutPN] } {
	    break
	}
	#rR attention depuis 2013/10/16 on ameliore toujours DE ecrasant l'autre (avant il fallait OnVeutPartieSegAli) 
	if { $PartieSegAli!={} } {
	    set PartieSegAliRestante [lrange $PartieSegAli 0 end]                   ;#rR il y avait 1 ???? corrige 2013/10/16
	    set IndexProchainChevron [lsearch -start 1 -regexp $PartieSegAliRestante {^>}]
	    if { [expr $IndexProchainChevron == -1] } {
		set IndexProchainChevron [lsearch -start 1 -regexp $PartieSegAliRestante {^ *Database:}]
		if { [expr $IndexProchainChevron != -1] } {
		    set IndexFinSegAliCourante [expr $IndexProchainChevron-1]
		} else {
		    set IndexFinSegAliCourante end
		}
	    } else {
		set IndexFinSegAliCourante [expr $IndexProchainChevron-1]
	    }

	    set SegAliCourante [lrange $PartieSegAli 0 $IndexFinSegAliCourante]
	    if {$OnVeutPartieSegAli} { lappend lPartieSegAli $SegAliCourante }   ;#rR a mis le test ici pour toujours ameliorer la DE
	    set LeMeilleurDE {}
	    foreach LigneDuSegAli $SegAliCourante {
		if { ! [regexp -nocase {[0-9a-z]} $LigneDuSegAli]} { break } 
		set  MeilleurDE [string trim $LigneDuSegAli]
		regsub {^>[^ ]+ } $MeilleurDE "" MeilleurDE
		if { ! $FromNCBI } { regsub {^[^ ]+ } $MeilleurDE "" MeilleurDE }
		lappend LeMeilleurDE [string trim $MeilleurDE]
	    }
	    set MeilleurDE [join $LeMeilleurDE " "]
	    if {[string length $MeilleurDE] > [string length $DE]} {
		set DE $MeilleurDE
	    }
	    set PartieSegAli [lrange $PartieSegAliRestante $IndexProchainChevron end]
	}

	if {$OldPN>$PN} { set IlFautTrier 1 }
	set OldPN     $PN
	set OldProfil $Profil

	if {$NoAccessInHit} {
	    set DE "$Access $DE"
	    set Access "-"
	}	    
	
	lappend lBanqueId $BanqueId
	lappend lAccess   $Access
	lappend lDE       $DE
	lappend lProfil   $Profil
	lappend lPN       $PN
	lappend lScore    $Score

	set PNUnique "$PN [incr zPN]"
	lappend lPNUnique $PNUnique
	set LIduPN($PNUnique) $Ligne  
	set BIduPN($PNUnique) $BanqueId  
	set ACduPN($PNUnique) $Access
	set DEduPN($PNUnique) $DE
	set PRduPN($PNUnique) $Profil
	set PNduPN($PNUnique) $PN
	set SCduPN($PNUnique) $Score
	set SAduPN($PNUnique) [join $SegAliCourante "\n"]

	incr NombreDeBons

	if {$NombreDeBons >= $MaxListe } { break }
	if {$RenvoieLesHitsAvecSegAliUniquement && \
		$OnVeutPartieSegAli && $IndexFinSegAliCourante == "end" } { break }
    }

    if {$IlFautTrier} {
	set lPNUnique [lsort -real -index 0 $lPNUnique]
	set lLignes   {}
	set lBanqueId {}
	set lAccess   {}
	set lDE       {}
	set lProfil   {}
	set lPN       {}
	set lScore    {}
	foreach PNUnique $lPNUnique {
	    lappend lLignes   $LIduPN($PNUnique)
	    lappend lBanqueId $BIduPN($PNUnique)
	    lappend lAccess   $ACduPN($PNUnique)
	    lappend lDE       $DEduPN($PNUnique)
	    lappend lProfil   $PRduPN($PNUnique)
	    lappend lPN       $PNduPN($PNUnique)
	    lappend lScore    $SCduPN($PNUnique)
	    lappend lSegAli   $SAduPN($PNUnique)
	}
    }

    global ScoreDansProfil
    if {[info exists ScoreDansProfil] && $ScoreDansProfil && [info exists lScore]} { set lProfil $lScore }
    
    if {$RetourneBlastTrie} {
	if {$IlFautTrier} {
	    set BlastTrie    [join $PartieEntete "\n"]
	    append BlastTrie "\n"
	    append BlastTrie [join $lLignes      "\n"]
	    append BlastTrie "\n\n"
#rR	    append BlastTrie [join $PartieSegAli "\n"]
	    append BlastTrie [join $lSegAli      "\n"]
	    append BlastTrie "\n"
	    return $BlastTrie
	} else {
	    return [join $ListeDesLignes "\n"]
	}
    }
    if {$AvecMemo} {
	foreach V $LesVarMemo {
	    set MemoDecortique($V) [set $V]
	}

    }

    return $NombreDeBons
}

proc ChangeLaCommande Coco {
    global Commandes CommandesDefaut

    if { $Coco == "" } { return }
    set Commandes($Coco) [string trim [EntreTexte [set Commandes($Coco)]]]
    if { [Commandes($Coco)] == "" } {set Commandes($Coco) $CommandesDefaut($Coco) }
}

proc ChoixGN ListeDesGN {
    global retourChoixGN
    catch {destroy .choixGN}
    catch {unset retourChoixGN}
    toplevel .choixGN

    tk_optionMenu .choixGN.o retourChoixGN "Choisis le bon ..."
    foreach GN $ListeDesGN {
	.choixGN.o.menu add radiobutton -label $GN -variable retourChoixGN
    }
    pack .choixGN.o -side left -padx 25 -pady 25
    tkwait variable retourChoixGN
    destroy .choixGN
    return $retourChoixGN
}

proc TestChoixParmi {} {
    set LCP [ColorationsPossibles]
    set LCPT [LaTraduction $LCP]
    Espionne [ChoixParmiJoli $LCP {} $LCPT]
    exit
}

proc LesFrames {} {
    return [ChoixDesPresents [LesProceduresExistantes]]
}

proc ChoixDesPresents {Liste {ListeDeTextes {}} {Invite "Select ... and validate."}} {
    return [lindex [LesPresentsAbsentsIndifferents $Liste $ListeDeTextes $Invite] 0]
}

proc LesPresentsAbsentsIndifferents {Liste {ListeDeTextes {}} {Invite "Select ... and validate."}} {
    global retourChoixMultiple
    global ChoixMultipleRadio
    global validOk

    Wup "returns 3 lists"
    
    if {$ListeDeTextes=={}} {
	set ListeDeTextes $Liste
    }
    
    if {[llength $Liste] == 0 } { return {} }

    set n 0
    set LesLooks {}
    foreach Element $Liste {
	incr n
	set Look "a$n"
	lappend LesLooks $Look
    }

    if { [PourWscope] } {
	LesPAIs [ChoixMultiple $Look $ListeDeTextes]
    } else {
	set w [NomDe fenetre]
	catch {destroy $w}
	catch {unset validOk}
	toplevel $w
	wm geometry $w +300+100
	wm title $w "$Invite"
	
	set MaxWidth 0
	foreach Texte $ListeDeTextes {
	    if { [string length $Texte] > $MaxWidth } {
		set MaxWidth [string length $Texte]
	    }
	}
	
	frame $w.frame
	pack $w.frame -expand yes -fill both 
	set BouRad  "$w.frame.radios"
	set ScroHor "$w.frame.xscroll"
	set ScroVer "$w.frame.yscroll"
	scrollbar $ScroVer -command "$BouRad yview"
	scrollbar $ScroHor -command "$BouRad xview" \
		-orient horizontal 
	
	set CanvaScreenX 300
	set CanvaScreenY  25
	set HauteurUneLigne 25
	canvas $BouRad \
		-width  $CanvaScreenX \
		-height $CanvaScreenY \
		-xscrollcommand "$ScroHor set" \
		-yscrollcommand "$ScroVer set"
	
	set HauteurTotale 5
	foreach Look $LesLooks Element $Liste Texte $ListeDeTextes {
	    set FLook "$BouRad.$Look"
	    frame $FLook
	    radiobutton $FLook.radioP -relief flat -variable ChoixMultipleRadio($Look) -value p
	    radiobutton $FLook.radioA -relief flat -variable ChoixMultipleRadio($Look) -value a
	    radiobutton $FLook.radioI -relief flat -variable ChoixMultipleRadio($Look) -value i
	    label       $FLook.text   -width $MaxWidth -text $Texte -anchor "w"
	    pack $FLook.radioP $FLook.radioA $FLook.radioI $FLook.text -side left 
	    $BouRad create window  0 $HauteurTotale -anchor "nw" -window $FLook
	    incr HauteurTotale $HauteurUneLigne
	}
	$BouRad configure -scrollregion [list 0 0 $CanvaScreenX $HauteurTotale]
	
	grid $w.frame.radios  -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
	grid $w.frame.yscroll -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew
	grid $w.frame.xscroll -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
	grid rowconfig    $w.frame 0 -weight 1 -minsize 0
	grid columnconfig $w.frame 0 -weight 1 -minsize 0
	
	$BouRad configure -height [Mini [expr $HauteurTotale+60] 600]
	
	set Boutons $w.termine
	frame $Boutons
	button $Boutons.dismiss  -text "Dismiss" -background "red"   -command { set validOk 0 }
	button $Boutons.toutpresent -text "All +" -background "yellow" -command { 
	    foreach Look [array names ChoixMultipleRadio] {
		set ChoixMultipleRadio($Look) p
	    }
	}
	button $Boutons.toutabsent -text "All -" -background "orange" -command { 
	    foreach Look [array names ChoixMultipleRadio] {
		set ChoixMultipleRadio($Look) a
	    }
	}
	button $Boutons.toutindif -text "All X" -background "lightblue" -command {
	    foreach Look [array names ChoixMultipleRadio] {
		set ChoixMultipleRadio($Look) i
	    }
	}
	button $Boutons.validate -text "Validate"      -background "green" -command { set validOk 1 }
	
	pack $Boutons -side top
	pack $Boutons.dismiss $Boutons.toutpresent $Boutons.toutabsent $Boutons.toutindif $Boutons.validate -side left
	
	tkwait variable validOk
	destroy $w
	if { ! $validOk} { return [list {} {} {}] }
	foreach Look $LesLooks {
	    lappend LesPAIs [set ChoixMultipleRadio($Look)]
	}	
    }
    set retourChoixMultiple {}
    set LesPresents {}
    set LesAbsents {}
    set LesIndifferents {}
    foreach Look $LesLooks Element $Liste PAI $LesPAIs {
	if { $PAI == "p" } { lappend LesPresents     $Element }
	if { $PAI == "a" } { lappend LesAbsents      $Element }
	if { $PAI == "i" } { lappend LesIndifferents $Element }
    }
    return [list $LesPresents $LesAbsents $LesIndifferents]
}

proc ChoixMultiple {Liste {ListeDeTextes {}} {Invite "Select ..."}} {
    global retourChoixMultiple
    global ChoixMultipleRadio
    

    if {[PourWscope]} { return $Liste }

    if {$ListeDeTextes=="" } {
	set ListeDeTextes $Liste
    }
    
    if {[llength $Liste] == 0 } { return "" }
    
    set w [NomDe fenetre]
    catch {destroy $w}
    catch {unset validOk}
    toplevel $w
    wm geometry $w +300+100
    
    #tk_optionMenu $w.o retourChoixParmi $Invite
    #$w.o configure -background "Seagreen" -foreground "black" -bd 20
    #frame .question -height [llength $Liste] -width 10c
    set MaxWidth 0
    foreach Texte $ListeDeTextes {
	if { [string length $Texte] > $MaxWidth } {
	    set MaxWidth [string length $Texte]
	}
    }
    
    foreach Element $Liste Texte $ListeDeTextes {
	frame $w.$Element
	radiobutton $w.radio${Element}p -relief flat -variable ChoixMultipleRadio($Element) -value p
	radiobutton $w.radio${Element}a -relief flat -variable ChoixMultipleRadio($Element) -value a
	radiobutton $w.radio${Element}i -relief flat -variable ChoixMultipleRadio($Element) -value i
	text $w.text${Element} -height 1 -width $MaxWidth
	$w.text${Element} insert end $Texte
	
	#$w.o.menu add radiobutton -background $Couleur -foreground "black" \
	#	-label $Element -variable retourChoixParmi
    }
    
    frame  $w.termine
    button $w.dismiss  -text "Dismiss" -background "red"   -command { set validOk 0 }
    button $w.toutpresent -text "Present" -command { 
	foreach Element [array names ChoixMultipleRadio] {
	    set ChoixMultipleRadio($Element) p
	}
    }
    button $w.toutabsent -text "Absent" -command { 
	foreach Element [array names ChoixMultipleRadio] {
	    set ChoixMultipleRadio($Element) a
	}
    }
    button $w.toutindif -text "Indifferent" -command {
	foreach Element [array names ChoixMultipleRadio] {
	    set ChoixMultipleRadio($Element) i
	}
    }
    button $w.validate -text "Validate"      -background "green" -command { set validOk 1 }
    
    # pack $w.o
    set First ""
    foreach Element $Liste {
	pack $w.$Element
	pack $w.radio${Element}p $w.radio${Element}a $w.radio${Element}i $w.text${Element} -in $w.$Element -side left -fill both -expand 1
    }
    
    pack $w.termine -side top
    pack $w.toutpresent $w.toutabsent $w.toutindif $w.validate $w.dismiss -in $w.termine -side left
    
    tkwait variable validOk
    destroy $w
    
    set retourChoixMultiple {}
    foreach Element $Liste {
	set Var ChoixMultipleRadio($Element)
	if { [set $Var] == "p" } {
	    lappend retourChoixMultiple [string toupper $Element] 
	} else {
	    if { [set $Var] == "a" } {
		lappend retourChoixMultiple [string tolower $Element]
	    } else { 
		# lappend retourChoixMultiple $Element
	    }
	}
    }
    return $retourChoixMultiple
}

proc ClosCanalEtMontreBlaste {Canal Out} {
	close $Canal
	set Fenetre [AfficheFichier $Out "AvecGrapheAvecSegAlignementAvecAligneurs"]
    return
    if {[gets $Canal]} {
	return 1
    }
    gets $Canal Message
    set Texte "I got an error from batch blast with following message :\n$Message"
    set Fenetre [AfficheVariable $Texte "ErrorFromBlast"]
    return 0
}

proc ClosCanalEtMontreMSF {Aligneur Canal MSF Log} {
    global LaFenetreDesMSF

    close $Canal
    if { [info exists LaFenetreDesMSF($MSF)] } {
	Illumine $MSF [set LaFenetreDesMSF($MSF)]
    } else {
	set Fenetre [AfficheFichier $MSF "GrandeLargeurAvecEtudeMSF"]
	BoutonneLaFenetre $Fenetre "Log" "AfficheFichier $Log AvecRien"
    }
}

proc ClosExpoCourante {} {
    global ExpoCourante
    catch {unset ExpoCourante}
}

proc ClosGalerieCourante {} {
    global GalerieCourante
    global ExpoCourante
    global xPointDeRaccord yPointDeRaccord 

    catch {unset xPointDeRaccord}
    catch {unset yPointDeRaccord}
    catch {unset GalerieCourante}
}

proc CochonsLes {SesMachins SesMachinsDefaut} {
    upvar $SesMachins Machins
    upvar $SesMachinsDefaut MachinsDefaut
    global retourCoche
    global MachinsCochons 

    array set Machins [array get MachinsDefaut]

    set w [NomDe coche]
    catch {destroy $w}
    toplevel $w
    wm title $w "Merci de cocher ..."
    wm iconname $w "Coche"
    
    frame  $w.buttons
    pack   $w.buttons -side bottom -fill x -pady 2m
    button $w.buttons.dismiss -text "Dismiss" -background red    -foreground white \
	    -command "set retourCoche($w) Dismiss"
    pack   $w.buttons.dismiss -side left -expand 1
    button $w.buttons.defaut -text "Default"  -background yellow -foreground black \
	    -command "set retourCoche($w) Defaut"
    pack   $w.buttons.defaut -side left -expand 1
    button $w.buttons.accept -text "Accept"   -background green  -foreground black \
	    -command "set retourCoche($w) Accept"
    pack   $w.buttons.accept -side left -expand 1

    set i 0
    foreach a [array names Machins] {
	set MachinsCochons($a) [set Machins($a)]
	set b $w.b$a
	checkbutton $b -text "$a" -variable MachinsCochons($a) -relief flat
	pack $b -side top -pady 2 -anchor w
    }

    tkwait variable retourCoche($w)
    if { [set retourCoche($w)] == "Defaut" } {
	array set MachinsCochons [array get MachinsDefaut]
	while { [set retourCoche($w)] == "Defaut" } {
	    unset retourCoche($w)
	    tkwait variable retourCoche($w)
	}
    }
    if { [set retourCoche($w)] != "Dismiss" } {
        array set Machins [array get MachinsCochons]
    }
    unset retourCoche($w)
    destroy $w
    return $SesMachins
}

proc Colle w {
    global xPointDeRaccord yPointDeRaccord DejaEmpiles
    global GalerieCourante
    global ExpoCourante

    set LargeurDuMotif [LargeurDe $w]
    set HauteurDuMotif [HauteurDe $w]
    set OnEnEmpile 4
    set HauteurDuLe [expr $OnEnEmpile*$HauteurDuMotif]

    if { ! [info exists xPointDeRaccord] } {
	set DejaEmpiles 0
	set xPointDeRaccord 0
	set yPointDeRaccord 0
    } else {
	incr DejaEmpiles
	incr yPointDeRaccord $HauteurDuMotif
    }
    if { $DejaEmpiles >= $OnEnEmpile } {
	set DejaEmpiles 0
	set yPointDeRaccord 0
	incr xPointDeRaccord $LargeurDuMotif
	set ScrollRegion [$GalerieCourante.frame.mur cget -scrollregion]
	set SR0 [lindex $ScrollRegion 0]
	set SR1 [lindex $ScrollRegion 1]
	set SR2 [lindex $ScrollRegion 2]
	set SR3 [lindex $ScrollRegion 3]
	$GalerieCourante.frame.mur configure \
		-width "[expr $SR2 + $LargeurDuMotif]" \
		-height "$HauteurDuLe"
	$GalerieCourante.frame.mur configure \
		-scrollregion "$SR0 $SR1 [expr $SR2 + $LargeurDuMotif] $HauteurDuLe"
    }

    $GalerieCourante.frame.mur create window \
	    $xPointDeRaccord $yPointDeRaccord \
	    -window $w -anchor nw
}

proc CoordDuCourant {w} {
    set id [$w find withtag current]
    set x [lindex [$w coords $id] 0]
    set y [lindex [$w coords $id] 2]
    return "$x $y"
}

proc CouleurDePeau Access {

    set Orga [OrgaDuFetcheAccess $Access]
    return [Glossaire $Orga Couleur]
}

proc CouleurDePeauOsOc OsOc {

    set CouleurDeClasse(PROKARYOTA)     "green"
    set CouleurDeClasse(EUKARYOTA)      "skyblue"
    set CouleurDeClasse(EUBACTERIA)     "yellow"
    set CouleurDeClasse(ARCHAEBACTERIA) "brown"

    Espionne $OsOc
    foreach {Phylum VaCouleurDeClasse} [array get CouleurDeClasse] {
	if {[regexp -nocase [string range $Phylum 0 3] $OsOc]} {
	    return $ValCouleurDeClasse
	}
    }

    return [Glossaire $OsOc Couleur]
}

proc CreeExpo E {
    global ExpoCourante

    Warne "Creation de l'expo $E"

    toplevel $E
    button $E.cloture  -text "Cloture" -background green -command "ClosExpoCourante" 
    button $E.dismiss  -text "Dismiss" -background red   -command "ClosExpoCourante; destroy $E"

    pack $E.cloture -side top -fill x
    pack $E.dismiss -side top -fill x
}    

proc CreeGalerie G {
    global ExpoCourante

    CreeExpo $ExpoCourante

    Warne "Creation de la galerie $G"

    frame $G 
    pack  $G -expand yes -fill both 

    label $G.msg -wraplength 4i -justify left -text "$G" -relief sunken -borderwidth 1
    pack  $G.msg
    frame $G.frame -borderwidth 10
    pack  $G.frame -expand yes -fill both

    set Largeur 400
    set Hauteur 600

    canvas $G.frame.mur \
	    -width $Largeur -height $Hauteur \
	    -scrollregion "0 0 0 0" \
	    -confine true \
	    -background grey \
	    -xscrollcommand "$G.frame.xscroll set" \
	    -yscrollcommand "$G.frame.yscroll set"

    scrollbar $G.frame.yscroll -command "$G.frame.mur yview"
    scrollbar $G.frame.xscroll -command "$G.frame.mur xview" -orient horizontal

    grid              $G.frame.mur     -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
    grid              $G.frame.yscroll -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew
    grid              $G.frame.xscroll -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
    grid rowconfig    $G.frame 0 -weight 1 -minsize 0
    grid columnconfig $G.frame 0 -weight 1 -minsize 0

}

proc CreeImagette {} {
    global GalerieCourante
    global ExpoCourante
    global DejaEmpiles

    set OnEnEmpile 4

    if { [info exists GalerieCourante]} {
	set w $GalerieCourante.frame.mur[NomDe graphe]
    } else {
	if { ! [info exists ExpoCourante]} {
	    set DejaEmpiles 0
	    set ExpoCourante [NomDe expo]
	    CreeExpo $ExpoCourante
	}
	set w $ExpoCourante[NomDe graphe]
	incr DejaEmpiles
	if { $DejaEmpiles >= $OnEnEmpile } {
	    $ExpoCourante.cloture invoke
	    set DejaEmpiles 0
	}
    }
    frame $w -borderwidth 10
    Warne "Creation de $w"
    return $w
}

proc DecortiqueFetch {TexteGCG ChampsDuFetch} {

    upvar $ChampsDuFetch CDF

    set CDF(espece)     ""
    set CDF(classe)     ""
    set CDF(gn)         ""
    set CDF(definition) ""

    foreach Ligne [split $TexteGCG "\n"] {
	switch -regexp $Ligne {
	    "^OS" {
		append CDF(espece)     "[string trim [string range $Ligne 2 end]] "
	    }
	    "^OC" {
		append CDF(classe)     "[string trim [string range $Ligne 2 end]] "
	    }
	    "^GN" {
		append CDF(gn)         "[string trim [string range $Ligne 2 end]] "
	    }
	    "^DE" {
		append CDF(definition) "[string trim [string range $Ligne 2 end]] "
	    }
	}
    }
}

proc DeleteLesTmp {Selection Fenetre} {
    if { $Selection == "" } {
	FaireLire "Please select some files"
	return
    }
    foreach Fichier [split $Selection "\n"] {
	if { $Fichier != "" } {
	    File delete -force $Fichier
	}
    }
    destroy $Fenetre
    MenageLesTmp "Exit"
}

proc EffaceCourant {w} {
    global TexteMontreCourant
    if {[info exists TexteMontreCourant($w)]} { 
	$w delete $TexteMontreCourant($w)
	unset TexteMontreCourant($w)
    }
}

proc EnsoleilleLaSelection Selection {
    global GalerieCourante
    global ExpoCourante

    set ExpoCourante [NomDe expo]
    set GalerieCourante $ExpoCourante[NomDe galerie]

    CreeGalerie $GalerieCourante

    foreach Ligne [split $Selection "\n"] {
	set Access [lindex [split [string trim $Ligne] " "] 0]
	EtudieAccess $Access
    }

    ClosGalerieCourante
    ClosExpoCourante
}

proc EtudieAccess Access {
    set Orga [OrgaDuFetcheAccess $Access]
    if { $Orga == "Inconnu" } {
	Warne "$Access organisme inconnu .........."
	return
    } 
    set GN $Access
    if {[regexp ":" $Access]} {
	set GN [lindex [split $Access ":"] 1]
    }
    set gn [string tolower $GN]
    GrapheLesBouts [glob /chop/ripp/fodbs/topdb/$Orga/bout/$gn-topdb]
}

proc EtudieCourant w {
    set Access [NomDuCourant $w]
    EtudieAccess $Access
}

proc AfficheLesSortiesBlast Selection {
    foreach NomDuFichierBlast [split $Selection "\n"] {
	AfficheUneSortieBlast $NomDuFichierBlast
    }
}

proc AfficheUneSequence {{NomDuFichier ""} {AvecManiere ""}} {
    global RepertoireDuGenome
    Gs "Frame"
    
    if { $NomDuFichier == ""} {
	set NomDuFichier [ButineArborescence "All"]
	if { $NomDuFichier == "" } { return }
    }
    return [AfficheFichier $NomDuFichier "AvecFormate$AvecManiere"]
}

proc AfficheUneSortieBlast {{NomDuFichier ""} {AvecManiere ""}} {
    global RepertoireDuGenome
    Gs "Frame"
    
    if { $NomDuFichier == ""} {
	set NomDuFichier [ButineArborescence "All"]
	if { $NomDuFichier == "" } { return }
    }

    if { ! [regexp "/" $NomDuFichier] && [EstUnPAB $NomDuFichier]} {
	set Nom $NomDuFichier
	set NomDuFichier "[RepertoireDuGenome]/blastp/$Nom"
    }

    return [AfficheFichier $NomDuFichier "AvecGrapheAvecSegAlignementAvecAligneurs$AvecManiere"]
}

proc EtudieUneSortieMSF {{NomDuFichier ""}} {
    global RepertoireDuGenome
    Gs "Frame"
    
    if { $NomDuFichier == "" } {
	set NomDuFichier [ButineArborescence "All"]
	if { $NomDuFichier == "" } { return }
    }
    return [AfficheFichier $NomDuFichier "GrandeLargeurAvecLogAvecEtudeMSF"]
}

proc Expose w {
    global GalerieCourante
    global ExpoCourante

    if {[info exists GalerieCourante]} {
	Colle $w
    } else {
	pack $w -side bottom
    }   
}

proc FetcheCourant {w} {
    return [AfficheFetch [NomDuCourant $w]]
}

proc FichierFOF {Selection {Tmp ""}} {
    global RepertoireDuGenome
    global AccessDejaVus
    global FOFDejaVu

    Wup "Creates a file of filenames, each of one contains one of the sequences listed in the text Selection"

    JeMeSignale

    if { $Tmp == "" } {
	set FOF "tmp.[pid][NomDe ""].fof"
    } else {
	set FOF "$Tmp.fof"
    }

    if { [FormatDeLaSequence $Selection] == "tfas" } {
	TFAStoGCGs $Selection dans $FOF
	return "$FOF"
    } 

    if {[info exists FOFDejaVu($Selection)]} {
	Sauve $FOFDejaVu($Selection) dans $FOF
	return "$FOF"
    }

    set Liste [split $Selection "\n"]
    catch {unset AccessDejaVus}
    foreach Ligne $Liste {

	if { [regexp "^Query=" $Ligne] } {
	    set Access [QueryDeLaLigne $Ligne]
	    lappend ListeFOF $Access
	    set QueryAccess [file tail $Access]
	    continue
	}

	set AccessOuFichier [lindex [split [string trim $Ligne] " "] 0]
	if { $AccessOuFichier == "" } { continue }

	set ListeDeFichiers [glob -nocomplain -- $AccessOuFichier]
	if { $ListeDeFichiers != "" } {
	    foreach f $ListeDeFichiers {
		if {[file exists $f]} {
		    lappend ListeFOF $f
		}
	    }
	    continue
	}

	if {[regexp {\*} $AccessOuFichier]} {
	    set ListeDeAccess [split [FetchNoms $AccessOuFichier] " "]
	    if { [llength $ListeDeAccess] != 0 } {
		foreach f $ListeDeAccess {
		    lappend ListeFOF [Sauve [FetchCat "$f"] dans "[RepertoireDetravail]/$f"]
		}
	    }
	    continue
	}

	set Access $AccessOuFichier
	if {[regexp {^[a-zA-Z0-9_]+:[a-zA-Z0-9_]+[ !]* [a-zA-Z0-9_]+} $Ligne]} {
	    set Access [AccessDUneLigneBlast $Ligne]
	    if {[regexp {/} $Access]} {
		lappend ListeFOF $Access
		continue
	    }
	}

	if { [regexp {\:} $Access] } {
	    set Banque      [lindex [split $Access ":"] 0]
	    set NomDeAccess [lindex [split $Access ":"] 1]
	} else {
	    set NomDeAccess $Access
	}
	if {[info exists Banque]} {
	    set Sequence [Fetche "$Banque:$NomDeAccess"]
	    if { $Sequence != "" } {
		lappend ListeFOF [Sauve $Sequence dans "[RepertoireDeTravail]/$NomDeAccess"]
		continue
	    }
	}
	set Sequence [Fetche "protein:$NomDeAccess"]
	if { $Sequence != "" } {
	    lappend ListeFOF [Sauve $Sequence dans "[RepertoireDeTravail]/$NomDeAccess"]
	    continue
	}
	set Sequence [Fetche "$NomDeAccess"]
	if { $Sequence != "" } {
	    lappend ListeFOF [Sauve $Sequence dans "[RepertoireDeTravail]/$NomDeAccess"]
	    continue
	}
    }

    Sauve [join $ListeFOF "\n"] dans $FOF
    set FOFDejaVu($Selection) [ContenuDuFichier $FOF]
    return "$FOF"
}

proc FormateSequence {Sequence {NouveauFormat ""} {AncienFormat ""}} {
    if {$AncienFormat==""} { set AncienFormat [FormatDeLaSequence $Sequence] }
    if {$NouveauFormat==""} {
	set LesNouveauxPossibles [list \
		"to-TFA-without-numbers" \
		"to-TFA" \
		"to-EMBL" \
		"to-GCG" \
		"nuc-to-prot-TFA" \
		"nuc-to-prot-EMBL" \
		"nuc-to-prot-GCG" \
		"TFA-to-reverse-TFA" \
		"TFA-to-complement-TFA" \
		"TFA-to-rev-and-comp-TFA" \
		"nuc-to-reverse" \
		"nuc-to-complement" \
		"nuc-to-rev-and-comp" \
		]
	set N [llength $LesNouveauxPossibles]
	set I [ChoixParmiJoli [NombresEntre 1 $N] "" $LesNouveauxPossibles]
	if {$I==""} { return "" }
	set NouveauFormat [lsearch $LesNouveauxPossibles [expr $I-1]]
    }
    if { $AncienFormat == "tfas" && $NouveauFormat == "to-GCG" } {
	FaireLire "Multiple TFA to GCG is not yet possible"
	return ""
    }
    set II 0
    if { $I==[incr II]} { return [TexteTfaFromTexteTfaWithoutNumbers $Sequence]}
    if { $I==[incr II]} { return [SequenceFormatTFA            $Sequence "" $AncienFormat]}
    if { $I==[incr II]} { return [SequenceFormatEMBL           $Sequence "" $AncienFormat]}
    if { $I==[incr II]} { return [SequenceFormatGCG            $Sequence "" $AncienFormat]}
    if { $I==[incr II]} { return [NucToProtTFA                 $Sequence "" $AncienFormat]}
    if { $I==[incr II]} { return [NucToProtEMBL                $Sequence "" $AncienFormat]}
    if { $I==[incr II]} { return [NucToProtGCG                 $Sequence "" $AncienFormat]}
    if { $I==[incr II]} { return [TFAToReverseTFA              $Sequence ""]}
    if { $I==[incr II]} { return [TFAToComplementTFA           $Sequence ""]}
    if { $I==[incr II]} { return [TFAToReverseAndComplementTFA $Sequence ""]}
    if { $I==[incr II]} { return [NucToReverseNuc              $Sequence]}
    if { $I==[incr II]} { return [NucToComplementNuc           $Sequence]}
    if { $I==[incr II]} { return [NucToReverseAndComplementNuc $Sequence]}
    return ""
}

proc AddOrganismToOrgaCode {{NewOrga ""} {NewOrga2 ""}} {
JeMeSignale
    if {$NewOrga2!=""} { set NewOrga "$NewOrga $NewOrga2" }
    regsub "_" $NewOrga " " NewOrga

    
    set FichierOrganismes "[GscopeEtc]/gscope_listedesorganismes.txt"
    set FichierGlossaire  "[GscopeEtc]/gscope_glossaire"

    set Organismes [ContenuDuFichier $FichierOrganismes]
    if {$NewOrga!=""} {
	set Organismes "$NewOrga\n$Organismes"
    }
    if { ! [PourWscope]} {
	set Original $Organismes
	FaireLire "You can add other organisms 'Genus species' ... \n\
                  Doesn't matter for the alphabetical order or duplicates\n\
                  if it's a virus please enter 'Virus homo-sapiens-hiv'" 
	set  Organismes [EntreTexte $Organismes]
	if {$Organismes==""} { return "" }
    }
    set  Organismes [join [lsort -unique [split $Organismes "\n"]] "\n"]
    if {$Original!=$Organismes} {
	Garde $FichierOrganismes
	Sauve $Organismes dans $FichierOrganismes 
	file attribute $FichierGlossaire -permissions 0775
    }
    
    set LesOrganismes [split $Organismes "\n"]
    foreach Ligne $LesOrganismes {
	regsub -all { +} $Ligne " " Ligne
	set Ligne [string trim $Ligne]	
	if { ! [regexp -nocase {[a-z0-9\-]+ [a-z0-9\-]+\.?} $Ligne]} {
	    FaireLire "Invalid organism\n$Ligne\nOnly 2 words please : 'Homo sapiens'" 
	    continue
	}
	set Genre   [string tolower [lindex [split $Ligne " "] 0]]
	set espece  [string tolower [lindex [split $Ligne " "] 1]]
	set G	    [string toupper [string range $Genre 0 0]]
	set esp     [string range $espece 0 2]
	set gesp    [string tolower $G]$esp
	set Complet "$G[string range $Genre 1 end] $espece"
	set Pointe  "$G.$espece"
	set Demi    "$G[string range $Genre 1 3].[string range $espece 0 4]"
	lappend LeGlossaire "$gesp\t$Complet\t$Pointe\t$Demi"
    }
    
    Garde $FichierGlossaire
    SauveLesLignes $LeGlossaire dans $FichierGlossaire
    file attribute $FichierGlossaire -permissions 0775
    Glossaire "Reset"
    return [Glossaire]
}

proc TestGlossaire {} {
    Glossaire Reset
    Glossaire
    exit
}

proc OrganismePrioritaire {Orga} {
    global OrganismePrioritaire
    set ORGA [string toupper $Orga]
    if {[info exists OrganismePrioritaire($ORGA)]}       { return $OrganismePrioritaire($ORGA) }
    if {[info exists OrganismePrioritaire("EstCharge")]} { return $Orga }
    set OrganismePrioritaire("EstCharge") 1

    foreach Genome [LesGenomesComplets] {
	scan $Genome "%s %s" Genre Espece
	if {"$Genre $Espece"=="Pyrobaculum aerophilum"} {
	    set O "pae"
	} else {
	    set O [string index $Genre 0]
	    append O [string range $Espece 0 2]
	}
	set OrganismePrioritaire([string toupper $O]) $Genome
    }
    
    set OrganismePrioritaire(MKAN) "Methanopyrus kandleri"
    
    set OrganismePrioritaire(A.SP.) "Anabaena sp."
    set OrganismePrioritaire(H.SP.) "Halobacterium sp."
    set OrganismePrioritaire(S.SP.) "Synechocystis sp."
    
    set OrganismePrioritaire(A.SP)  "Anabaena sp."
    set OrganismePrioritaire(H.SP)  "Halobacterium sp."
    set OrganismePrioritaire(S.SP)  "Synechocystis sp."
    
    set OrganismePrioritaire(ASP.)  "Anabaena sp."
    set OrganismePrioritaire(HSP.)  "Halobacterium sp."
    set OrganismePrioritaire(SSP.)  "Synechocystis sp."
    
    set OrganismePrioritaire(ASP)   "Anabaena sp."
    set OrganismePrioritaire(HSP)   "Halobacterium sp."
    set OrganismePrioritaire(SSP)   "Synechocystis sp."

    set OrganismePrioritaire(LISTOFPRIORITAIRE) [array names OrganismePrioritaire]
    return [OrganismePrioritaire $Orga]
}

proc Glossaire {{Organisme ""} {Champ ""} {ChampSiOrgaSur2 ""}} {
    global Glossaire FichierGlossaire
    global GlossaireDesClasses
    global OrganismePrioritaire

    #rR Pour plus qu'il se plante on rend la meme chose
    if {[FileAbsent $FichierGlossaire]} { return $Organisme } 

    if {$Organisme==""} { set Organisme "ListOf"; set Champ "All" }
    set OOri $Organisme; set COri $Champ; 
    if {$Organisme=="Reset"} {
	if {[info exists Glossaire]} { unset Glossaire }
	return ""
    }

    if {$ChampSiOrgaSur2!=""} {
	set Organisme "$Organisme $Champ"
	set Champ $ChampSiOrgaSur2
    }
    if {$Champ==""} { set Champ "Complet" }

    regsub " sp$" $Organisme " sp." Organisme
    regsub -all -nocase {[^a-z0-9_\-'\.]} $Organisme " " Organisme
    set Organisme [OrthographeCanonique $Organisme]
    set Organisme [OrganismePrioritaire $Organisme]
    if {$Organisme=="" || \
	    $Organisme=="Unknown unknown" || \
	    $Organisme=="uunk" || \
	    $Organisme=="unkn" } {
	set Organisme "Inconnu inconnu"
    }
    regsub " " $Organisme "_" OrgaUnderscore
    if {[info exists Glossaire($OrgaUnderscore,$Champ)]} { return [set Glossaire($OrgaUnderscore,$Champ)] }
    set OrgaUnderscore [string totitle $OrgaUnderscore]
    if {[info exists Glossaire($OrgaUnderscore,$Champ)]} { return [set Glossaire($OrgaUnderscore,$Champ)] }
    set ORGANISME [string toupper $Organisme]
    if {[info exists Glossaire($ORGANISME,MonComplet)]} {
	return [Glossaire $Glossaire($ORGANISME,MonComplet) $Champ]
    }
    if {[info exists Glossaire("EstCharge")]} { return "" }
    set Glossaire("EstCharge") 1

    #rR Attention: if Organisme has : it's a list of organisms
    if {0 && [regexp ":" $Organisme]} {
	foreach O [SplitOrgas $Organisme] {
	    lappend GlosO [Glossaire $O $Champ]
	}
	return [join $GlosO ":"]
    }

    set Espece ""
    scan $Organisme "%s %s" Genre Espece
    set Organisme $Genre
    if {$Espece!=""} { append Organisme " $Espece" }
    if {[regexp -nocase {(^hsp|^H\.sp)[\.]*$} $Organisme]} { set Organisme "Halobacterium sp" }
    if {[regexp -nocase {(^bsp|^B\.sp)[\.]*$} $Organisme]} { set Organisme "Buchnera sp" }
    if {[regexp -nocase {(^ssp|^S\.sp)[\.]*$} $Organisme]} { set Organisme "Synechocystis sp" }
    if {[regexp -nocase {(^mtub|^M\.tub)$}    $Organisme]} { set Organisme "Mycobacterium tuberculosis" }
    if {[regexp -nocase {(^rpro|^R\.pro)$}    $Organisme]} { set Organisme "Rickettsia prowazekii" }
    if {[regexp -nocase {(^mthe|^M\.the)$}    $Organisme]} { set Organisme "Methanobacterium thermoautotrophicum" }
    if {[regexp -nocase {^M.thermoautotrop}   $Organisme]} { set Organisme "Methanobacterium thermoautotrophicum" }
    if {[regexp -nocase {^paer$}              $Organisme]} { set Organisme "Pseudomonas aeruginosa" }
    if {[regexp -nocase {^pae$}               $Organisme]} { set Organisme "Pyrobaculum aerophilum" }
    if {[regexp -nocase {^upar$}              $Organisme]} { set Organisme "Ureaplasma urealyticum" }
    if {[regexp -nocase {^rmel$}              $Organisme]} { set Organisme "Sinorhizobium meliloti" }
    if {[regexp -nocase {^rlot$}              $Organisme]} { set Organisme "Mesorhizobium loti" }

#    if {[info exists Glossaire($Organisme,$Champ)]} { return [set Glossaire($Organisme,$Champ)] }

    foreach Ligne [LesLignesDuFichier "$FichierGlossaire.classes"] {
	scan $Ligne "%s %s" Genre Espece
	set Classe [join [lrange [split $Ligne " "] 2 end] " "]
	set GlossaireDesClasses(${Genre}_$Espece) $Classe
    }
    
    set i 0
    set ListeDuGlossaire [LesLignesDuFichier $FichierGlossaire]
    set LongGlossaire [llength $ListeDuGlossaire]
    foreach Ligne $ListeDuGlossaire {
	lappend Glossaire(ListOf,All) $Ligne
	set lili [split $Ligne "\t"]
	set Court   [lindex $lili 0]
	set Complet [lindex $lili 1]
	set COMPLET [string toupper $Complet]
	set Pointe  [lindex $lili 2]
	set Demi    [lindex $lili 3]
	set Couleur [Nuance [expr {[incr i]*1.0/$LongGlossaire}]]
	set Angle   [expr {$i*2*3.141592/$LongGlossaire}]
	
	regsub " " $Complet "_" Orga
	regsub {\.$} $Court "" Court
	
	set Glossaire($Orga,Orga)    $Orga
	set Glossaire($Orga,Court)   $Court
	set Glossaire($Orga,Complet) $Complet
	set Glossaire($Orga,COMPLET) $COMPLET
	set Glossaire($Orga,Pointe)  $Pointe
	set Glossaire($Orga,Demi)    $Demi
	set Glossaire($Orga,Couleur) $Couleur
	set Glossaire($Orga,Angle)   $Angle
	set Glossaire($Orga,Tout)    ":$Court:$Complet:$COMPLET:$Pointe:$Demi:$Orga:"
	if {[info exists GlossaireDesClasses($Orga)]} {
	    set Classe [set GlossaireDesClasses($Orga)]
	} else {
	    set Classe "ClassUnknown"
	}
	set Glossaire($Orga,Classe) $Classe
	lappend Glossaire(ListOf,Organismes) $Orga
	lappend Glossaire(ListOf,Complet) [set Glossaire($Orga,Complet)]
	lappend Glossaire(ListOf,Entier)  [set Glossaire($Orga,Tout)]
    }
    
    set Glossaire(Pyrobaculum_aerophilum,Court)   "pae"
    
    set Orga "Inconnu_inconnu"
    set Glossaire($Orga,Orga)    $Orga
    set Glossaire($Orga,Court)   "iinc"
    set Glossaire($Orga,Complet) "Inconnu inconnu"
    set Glossaire($Orga,COMPLET) "INCONNU INCONNU"
    set Glossaire($Orga,Pointe)  "I.inconnu"
    set Glossaire($Orga,Demi)    "Inco.incon"
    set Glossaire($Orga,Couleur) grey
    set Glossaire($Orga,Angle)   5.
    set Glossaire($Orga,Tout)    ":Inconnu:Inconnu inconnu:INCONNU INCONNU:I.inconnu:Inco.incon:$Orga:"
    set Glossaire($Orga,Classe)  "ClassUnknown"    
    lappend Glossaire(ListOf,Organismes) $Orga
    lappend Glossaire(ListOf,Complet) [set Glossaire($Orga,Complet)]
    lappend Glossaire(ListOf,Entier)  [set Glossaire($Orga,Tout)]
    
    foreach Orga $Glossaire(ListOf,Organismes) {
	if { !  [regexp -nocase {[a-z]} $Orga]} { continue }
	foreach Field [split $Glossaire($Orga,Tout) ":"] {
	    if {$Field==""} { continue }
	    set FIELD [string toupper $Field]
	    if {$FIELD==[string toupper $Orga]} { continue }
	    lappend Glossaire(ListOf,FIELD) $FIELD
	    set Glossaire($FIELD,MonComplet) $Orga
	}
    }
    set Glossaire(ListOf,FIELD) [lsort -unique $Glossaire(ListOf,FIELD)]

    if {[string equal -nocase  $Champ "Couleur"] } { return "grey" }
    return [Glossaire $OOri $COri]
    #rR ******************************************************
    Wup "Faudra faire la suite proprement"
    set OrgaInconnu "Inconnu_inconnu"
    if {[info exists Glossaire($OrgaInconnu,$Champ)]} {
	return [set Glossaire($OrgaInconnu,$Champ)]
    }
    return ""
}

proc LesOrgasDesAccess {LesAccess {Champ "Complet"} {Nom ""}} {
    global RepertoireDuGenome
    global QuidSeqEstDisponible

    set LesAccessRestants $LesAccess
    set LesAccessRestantsEncore $LesAccessRestants
    set LesBonsAccessOrga {}
    if {$LesAccessRestants=={}} { return $LesBonsAccessOrga }

    Wup "With Descriptif ... not yet finish (because multiple OSs)"
    if {$Nom!=""} {
	set LesAccessRestantsEncore {}
	set FichierDescriptif "$RepertoireDuGenome/descriptifs/$Nom"
	if {[info exists $FichierDescriptif]} {
	    foreach Access $LesAccessRestants {
		set O [OrgaDuDescriptif $Access $Nom]
		if {$O==""} {
		    lappend LesBonsAccessOrga "$Access [Glossaire [set OrgaDe($Access)] $Champ]" 
		} else {
		    lappend LesAccessRestantsEncore $Access
		}
	    }
	}
    }
    if {$LesAccessRestantsEncore=={}} { return $LesBonsAccessOrga }
    set LesAccessRestants $LesAccessRestantsEncore

    Wup "With distancephylo"
    if {$Champ=="Court" && $Nom!=""} {
	set LesAccessRestantsEncore {}
	set LesODAs [LesOrgaDistAccessDesOrthologues $Nom]
	foreach {O D A} $LesODAs {
	    set OrgaDe($A) $O
	}
	set LesAccessRestantsRestants {}
	foreach Access $LesAccessRestants {
	    if {[info exists OrgaDe($Access)]} {
		lappend LesBonsAccessOrga "$Access [Glossaire [set OrgaDe($Access)] $Champ]" 
	    } else {
		lappend LesAccessRestantsEncore $Access
	    }
	}
    }
    if {$LesAccessRestantsEncore=={}} { return $LesBonsAccessOrga }
    set LesAccessRestants $LesAccessRestantsEncore

    Wup "For PDB or Ciona"
    set LesAccessRestantsEncore {}
    foreach Access $LesAccessRestants {
	if {[regexp {^ci[0-9]{10}$} $Access]} {
	    set Organisme "Ciona intestinalis"
	    lappend LesBonsAccessOrga "$Access [Glossaire $Organisme $Champ]" 
	} elseif {[EstUnAccessPDB $Access]} {
	    set Organisme [OrganismeDuPDB $Access]
	    lappend LesBonsAccessOrga "$Access [Glossaire $Organisme $Champ]" 
	} else {
	    lappend LesAccessRestantsEncore $Access
	}
    }
    if {$LesAccessRestantsEncore=={}} { return $LesBonsAccessOrga }
    set LesAccessRestants $LesAccessRestantsEncore

    Wup "For Ciona"

    Wup "With QuidSeq"
    if {[info exists QuidSeqEstDisponible] && $QuidSeqEstDisponible} {
	set TexteAccessOrga [QuestionDeScience QuidSeq "QuidOSsOfACs [join $LesAccessRestants "|"]"]
	regsub {[ \n]+$} $TexteAccessOrga "" TexteAccessOrga
	set LesAccessOrga [split $TexteAccessOrga "\n"]
	foreach AccessOrga $LesAccessOrga {
	    scan $AccessOrga "%s" Access
	    regsub "^$Access +" $AccessOrga "" Organismes
	    lappend LesBonsAccessOrga "$Access [Glossaire $Organismes $Champ]" 
	}
	return $LesBonsAccessOrga
    }

    Wup "Without QuidSeq"
    foreach Access $LesAccessRestantsEncore {
	set Orga [OrgaDuAccess $Access $Champ]
	lappend LesBonsAccessOrga "$Access $Orga"
    }
    return $LesBonsAccessOrga
}

proc LesChampsInteressantsDuAccess {BanqueId Access args} {

    set SeparateurDuChamp(AC) " "
    set SeparateurDuChamp(ID) " "
    set SeparateurDuChamp(OS) " "
    set SeparateurDuChamp(OC) " "
    set SeparateurDuChamp(OX) " "
    set LesChamps $args
    if {[regexp {^[A-Z][A-Z]$} $Access]} {
	set LesChamps [concat [list $Access] $args]
	set Access $BanqueId
    }
    foreach Champ $LesChamps {
	set ChampInteressant($Champ) 1
    }
    set LesLignesEMBL [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutEMBL"]
    if {$LesLignesEMBL==""} { return {} }
    foreach Ligne $LesLignesEMBL {
	scan $Ligne "%s" ChampLu
	if {[string equal $ChampLu "SQ"]} { break }
	if { ! [info exists ChampInteressant($ChampLu)]} { continue }
	regsub "$ChampLu   " $Ligne "" Ligne
	lappend LesValeurs($ChampLu) [string trim $Ligne]
    }
    set LeResultat {}
    foreach Champ $LesChamps {
	set Valeur ""
	set Sep "\n"
	if {[info exist SeparateurDuChamp($Champ)]} { set Sep $SeparateurDuChamp($Champ) }
	if {[info exists LesValeurs($Champ)]} { set Valeur [join $LesValeurs($Champ) $Sep] }
	lappend LeResultat $Valeur
    }
    return $LeResultat
}

proc OrgaDuAccess {Access {Champ "Complet"} {BanqueId ""}} {
    global QuidSeqEstDisponible
    
#    set Orga [BirdWeb UNIPROT $Access OS]

    if { ! [regexp -nocase {[a-z0-9]} $Access]} { return [Glossaire "" $Champ] }

    if {[info exists QuidSeqEstDisponible] && $QuidSeqEstDisponible} {
	set ACCESS [string toupper $Access]
	if {[regexp "PFOK|PFUR" $ACCESS]} {
	    set OS "Pyrococcus furiosus"
	} elseif {[regexp {^PAE[0-9]{4}} $ACCESS]} {
	    set OS "Pyrobaculum aerophilum"
	} elseif {[regexp "^TACI" $ACCESS]} {
	    set OS "Thermoplasma acidophilum"
	} elseif {[regexp "^PYAB" $ACCESS]} {
	    set OS "Pyrococcus abyssi"
	} else {
	    set OS [QuestionDeScience "ouragan:25000:QuidSeq" "QuidOSOfAC $ACCESS"]
	}
	if {$OS!=""} {
	    set Orga [Glossaire $OS $Champ]
	    return $Orga
	}
    }
    set OS [ChampDuDescriptif [LeDescriptif $Access] OS]
    if {$OS!=""} { return [Glossaire $OS $Champ] }
    
    if {$BanqueId==""} {
	set BanqueId $Access
	regsub -nocase {[a-z]+:} $BanqueId "" Access
    }
    set LesLignesEMBL [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutEMBL"]
    if {$LesLignesEMBL!=""} {
	set DE ""
	foreach Ligne $LesLignesEMBL {
	    if {[regexp "^DE" $Ligne]} {
		regsub "^DE   " $Ligne "" InfoDE 
		append DE " $InfoDE"
	    } 
	    if {[regexp "^OS" $Ligne]} { 
		set lili [split [string trim [string range $Ligne 2 end]] " "]
		set Genre  [lindex $lili 0] 
		regsub {[^A-Za-z]} [lindex $lili 1] "" Espece 
		set Organisme "$Genre $Espece"
		break
	    }
	}
	if {[info exists Organisme]} {
	    set Glo [Glossaire $Organisme $Champ]
	    if {$Glo!=""} { return $Glo }
	    return [OrganismeNormalise $Organisme $Champ]
	}
	if {[regexp {\[([^\]]+)]} $DE Match OS]} {
	    set G ""; set E ""
	    scan $OS "%s %s" G E
	    if {$E!=""} { set Organisme "$G $E" }
	    set Glo [Glossaire $Organisme $Champ]
	    if {$Glo!=""} { return $Glo }
	    return [OrganismeNormalise $Organisme $Champ]
	}
    } 
    return [Glossaire "" $Champ]
}

proc OrganismeNormalise {Organisme {Champ ""}} {
    if {$Champ==""} { set Champ "Complet" }
    set G ""
    set E ""
    scan $Organisme "%s %s" G E
    if {$Champ=="Complet"} { return "$G $E" }
    if {$Champ=="COMPLET"} { return [string toupper "$G $E"] }
    if {$Champ=="Court"}   { return [string tolower [string range $G 0 0] [string range $E 0 2]] }
    if {$Champ=="Demi"}    { return "[string range $G 0 3].[string range $E 0 4]" }
    if {$Champ=="Pointe"}  { return "[string range $G 0 0].[string range $E 0 end]" }
    return $Organisme
}

proc DefinitionDuAccess {BanqueId {Access ""}} {
    if {$Access==""} { set Access $BanqueId }
    set LesValeurs [LesChampsInteressantsDuAccess $BanqueId $Access "DE"]
    set DE [lindex $LesValeurs 0]
    regsub -all {[ \n\t]+} $DE " " DE
    set DE [string trim $DE]
    return $DE  
}

proc HauteurDe w {
    global Memo
    return [set Memo(HauteurDe$w)]
}

proc IllumineLeGroupeDe {Nom Fenetre {Ask ""} {Maniere ""}} {
    if {$Ask==""} { set Ask "Secator" }
    if {$Ask=="Ask"} { set Ask [ChoixParmi [list "Secator" "Dpc" "Oumy" \
	    "SecatorSelect" "DpcSelect" "OumySelect"]] }
    if {$Ask==""} { return "" }
    if {[regexp "Select" $Ask]} {
	set Select 1
	regsub "Select" $Ask "" Ask
    } else {
	set Select 0
    }
    foreach Access [Groupe$Ask $Nom $Nom "In"] {
	Illumine $Access $Fenetre
    }
    if { ! $Select} { return $Fenetre }
    global PagePropre
    set Page [set PagePropre($Fenetre)]
    return [AfficheRognure $Page [selection get] "GrandeLargeur$Maniere" "${Ask}_group_selection_of/$Nom"]    
}

proc LargeurDe w {
    global Memo
    return [set Memo(LargeurDe$w)]
}

proc ListeCompressee liste {
    set olde "HolaTriouPoilAuGenou"
    foreach e [lsort $liste] {
	if { $e != $olde } {
	    lappend Compresse $e
	    set olde $e
	}
    }
    return $Compresse
}

proc MenageLesTmp {Vert {Choix ""}} {
    global SortieAutorisee
    
    Gs "Frame"
    
    set KeepThis ".msf|.log|.blastp"
    set DeleteThis ""

    if {$Vert=="Rename" && $Choix==""} {
	set Choix $KeepThis
    }
    if {$Vert=="Delete" && $Choix==""} {
	set Choix $DeleteThis
    }

    if { [info exists SortieAutorisee] } {
	unset SortieAutorisee
    }
    regsub -all " " [eval glob -nocomplain -- tmp.*] "\n" LesTmp

    if { $LesTmp == "" } {
	set SortieAutorisee 1
	return ""
    }

    set Fenetre [AfficheVariable $LesTmp "SansFetchAvecShow" "Select, then Rename or Delete.\n    Or Accept Boum"]
    set bRename [BoutonneLaFenetre $Fenetre "Rename" "RenommeLesTmp \[selection get\] $Fenetre"]
    set bDelete [BoutonneLaFenetre $Fenetre "Delete" "DeleteLesTmp  \[selection get\] $Fenetre"]
    set bExit   [BoutonneLaFenetre $Fenetre "Accept Boum" "set SortieAutorisee 1; destroy $Fenetre"]
    $bExit configure -background "yellow" -foreground "black"
    Illumine $Choix $Fenetre
    [set b$Vert] configure -background "green" -foreground "black"

    return $Fenetre
}

proc MontreCourant {w x y} {
    global TexteMontreCourant
    set BBox [$w bbox all]
    set cx [expr ([lindex $BBox 2] + [lindex $BBox 0])/2]
    set cy [expr ([lindex $BBox 3] + [lindex $BBox 1])/2]
    if {[expr $x < $cx]} {
	set EW w
    } else {
	set EW e
    }
    if {[expr $y < $cy]} {
	set NS n
    } else {
	set NS s
    }
    set Ancre "$NS$EW"
    set X [$w canvasx [expr $x ]]
    set Y [$w canvasy [expr $y - 20 ]]

    if {[info exists TexteMontreCourant($w)]} {
	EffaceCourant $w
    }
    set Texte [NomDuCourant $w]
    set Queue ". .[string range $Texte [expr [string length $Texte]-20] end]"
    set TexteMontreCourant($w) [$w create text $X $Y -text "$Queue" -anchor $Ancre]
}

proc MontreOrganismes {{AvecRetour ""}} {
    
    Gs "Frame"

    if { [string equal -nocase $AvecRetour "AvecRetour"] } {
	set OptionRetour "AvecRetour"
    } else {
	set OptionRetour ""
    }	
    
    foreach Ligne [Glossaire Bidon Entier] {
	set LesMots [split [string trim $Ligne ":"] ":"]
	set i 0
	foreach Mot $LesMots {
	    incr i
	    if {[info exists Largeur($i)]} {
		set Largeur($i) [Maxi [set Largeur($i)] [string length $Mot]]
	    } else {
		set Largeur($i) [string length $Mot]
	    }
	}
    }
    foreach Ligne [Glossaire Bidon Entier] {
	set i 0
	set Texte ""
	foreach Mot [split [string trim $Ligne ":"] ":"] {
	    incr i
	    append Texte [format "%-[set Largeur($i)]s  " $Mot]
	}
	lappend LesTextes $Texte
    }

    return [AfficheVariable [join $LesTextes "\n"] "SansFetch$OptionRetour" "glossaire"]
}

proc NomDuCourant K {
    set LesTags [$K gettags [$K find withtag current]]
    foreach Tag $LesTags {
	if {[EstUnPAB $Tag]} { return $Tag }
    }
    return [lindex $LesTags 0] 
}

proc RenommeLesTmp {Selection Fenetre} {

    if { $Selection == "" } {
	FaireLire "Please select some files"
	return
    }
    set Nom [Entre "keep"]
    foreach Fichier [split $Selection "\n"] {
	regsub -- {^tmp} $Fichier $Nom Nouveau
	if { $Fichier != "" && $Nouveau != "" } {
	    File rename $Fichier $Nouveau
	}
    }
    destroy $Fenetre
    MenageLesTmp "Delete"
}

proc SeqIn {{Texte ""}} {
    if { $Texte == "" } {
	set T [EntreTexte]
    } else {
	set T $Texte
    }
    set T [string trim $T]    
    if { $T == "" } { return "" }
    if { ! [regexp {[a-zA-Z0-9_]} $T] } { return "" }

    #rR nom de fichier ou access
    if { ! [regexp {[\n ]} $T] } {
	if {[file isdirectory $T]} {
	    set ListeDeFichiers [glob -nocomplain -type f -- "$T/*"]
	    if {$ListeDeFichiers=={}} { return "" }
	    return [LOFtoTFAs $ListeDeFichiers "UseAccess"]
	}
	if {[regexp {[/\:]} $T] || [regexp -nocase {^[a-z0-9_]{4,12}$} $T] } {
	    scan $T "%s" Access
	    set LaSeq [LaSequenceDesBanques $Access $Access AccessOK "OnVeutNature"]
	    if {$LaSeq!={}} { return [join $LaSeq "\n"] }
	}
    }
    
    #rR on a une sequence avec un format connu ou une sequence brute
    set Format [FormatDeLaSequence $T]
    if {[regexp "tfas|tfa|gcg|gcgmaybe|embl" $Format]} {
	return $T
    }
    if {[regexp "brut" $Format]} {
	#rR sequence brute, on ne permet que les chiffres ou blanc
	regsub -all {[0-9 \t]} $T ""  T
	regsub -all {\*}       $T "X" T
	return [SequenceFormatTFA $T "" $Format]
    }
    Warne "Je ne sais pas quoi faire de\n$T"
    return ""
}

proc ShowFileOld {{Fichier ""}} {
    global LesAvecs LesAvecsDefaut TousLesAvecs 
    
    Gs "Frame"
    
    if { ! [info exists LesAvecs]} {
	set LesAvecs(AvecShow)       0
	set LesAvecs(AvecEtudeBlast) 0
	set LesAvecs(AvecRetour)     0
	set LesAvecs(AvecAligneurs)  0
	set LesAvecs(AvecLog)        0
	set LesAvecs(AvecBlaste)     0
	set LesAvecs(AvecGraphe)     0
	set LesAvecs(AvecAlignement) 0
	set LesAvecs(SansFetch)      0

	array set LesAvecsDefaut [array get LesAvecs]

	set Source [info body AfficheVariable]
	foreach Ligne [split [info body AfficheVariable] "\n"] {
	    if { ! [regexp -indices "Maniere" $Ligne Indices]} { continue }
	    scan $Indices "%d" iManiere
	    if { ! [regexp -indices "regexp" $Ligne Indices]} { continue }
	    scan $Indices "%d %d" iDebutRegexp iFinRegexp
	    set UnAvec [string range $Ligne [incr iFinRegexp 3] [incr iManiere -4]]
	    if {  ! [info exists LesAvecs($UnAvec)] } {
		if {[info exists LesAvecsDefaut($UnAvec)]} {
		    set LesAvecs($UnAvec) [set LesAvecsDefaut($UnAvec)]
		} else {
		    set LesAvecs($UnAvec) 0
		}
	    }
	    set TousLesAvecs($UnAvec) [set LesAvecs($UnAvec)]
	}
    }

    CochonsLes LesAvecs TousLesAvecs
    set AvecCeuxCi ""
    foreach Avec [array names LesAvecs] {
	if { [set LesAvecs($Avec)] } {
	    append AvecCeuxCi $Avec
	}
    }
    if {$Fichier == "" } {
	set Fichier [ButineArborescence All]
	if {$Fichier == ""} { return "" }
    }
    return [AfficheFichier $Fichier $AvecCeuxCi]
}

proc ShowFile {{Fichier ""}} {
    Gs "Frame"
    
    set LesAvecExistants {}
    set Source [info body AfficheVariable]
    foreach Ligne [split [info body AfficheVariable] "\n"] {
	if { ! [regexp -indices "Maniere" $Ligne Indices]} { continue }
	scan $Indices "%d" iManiere
	if { ! [regexp -indices "regexp" $Ligne Indices]} { continue }
	scan $Indices "%d %d" iDebutRegexp iFinRegexp
	set UnAvec [string range $Ligne [incr iFinRegexp 3] [incr iManiere -4]]
	lappend LesAvecExistants $UnAvec
    }

    set AvecCeuxCi [join [ChoixDesPresents $LesAvecExistants] ""]

    if {$Fichier == "" } {
	set Fichier [ButineArborescence All]
	if {$Fichier == ""} { return "" }
    }
    return [AfficheFichier $Fichier $AvecCeuxCi]
}

proc TFAtoGDE LesLignesTFA {

    Wup "On remplace les > par % avec juste le nom derriere >"

    set lesLignesGDE {}
    foreach Ligne $LesLignesTFA {
	if {[regexp "^>" $Ligne]} {
	    set Entete Ligne
	    regsub ">SEQ ID   " $Entete "%" Entete 
	    regsub ">"          $Entete "%" Entete 
	    regsub ","          $Entete " " Entete 
	    scan $Entete "%s" Ligne
	}
	lappend LesLignesGDE $Ligne
    }
    return $LesLignesGDE
}

proc GNduMarque Marque {

    set tid [lindex [split $Marque :] 0]
    set tc  [lindex [split $Marque :] 1]

    return [lindex [split [$tc itemcget [expr $tid +1] -text ] "\n"] 0]
}

proc DismissToutCePAB {Nom {Force ""}} {
    global LesFenetresDePAB
    global PagePropre

    if {$Nom=="" || ! [info exists LesFenetresDePAB($Nom)]} { return }

    if {$Force == "Force"} { set Force 1 } else { set Force 0 }
    if {$Force || [OuiOuNon "Je DISMISS tout $Nom ? "]} {
	foreach Fenetre [set LesFenetresDePAB($Nom)] {
	    if { ! [winfo exists $Fenetre]} { continue }
	    if {[info exists PagePropre($Fenetre)]} { unset PagePropre($Fenetre) }
	    after 10 destroy $Fenetre
	}
	unset LesFenetresDePAB($Nom)
    }
}

proc Censure Texte {
    set ListeDesLignes [split $Texte "\n"]
    set iNom [lsearch -regexp $ListeDesLignes "^Nom\: "]
    if {$iNom<0} {
	FaireLire "$Texte\n\n has no 'Nom:' field."
	if {[OuiOuNon "Do I skipp Censure ?"]} { return $Texte }
	set NouveauTexte ""
    } else {
	set LigneNom [lindex $ListeDesLignes $iNom]
	set NouveauTexte [string trim $LigneNom]
	set ListeDesLignes [lreplace $ListeDesLignes $iNom $iNom]
    }
    set OldLigne ""
    foreach Ligne [lsort -ascii $ListeDesLignes] {
	set Ligne [string trim $Ligne]
	if { $Ligne == $OldLigne } { continue }
	if { ! [regexp {\:} $Ligne] } { continue }
	append NouveauTexte "\n$Ligne"
	set OldLigne $Ligne
    }
    return $NouveauTexte
}

proc CourtOS OS {
    return [Glossaire $OS Court]
}

proc BeauGN GN {
    return $GN
}

proc CopieLeMeilleurCopainsInfo {Nom Selection} {
    if { $Selection == "" } {return ""}
    foreach Ligne [split $Selection "\n"] {
	set Sequence [Fetche [AccessDUneLigneBlast $Ligne]]
	if { $Sequence == "" } { continue }
	DecortiqueFetch $Sequence ChampsDuFetch
	set OS [Glossaire [EspeceNormalisee $ChampsDuFetch(espece)] Court]
	set OC [ClasseNormalisee $ChampsDuFetch(classe)]
	set GN $ChampsDuFetch(gn)
	set DE $ChampsDuFetch(definition)
	lappend lOS $OS
	lappend lOC $OC
	lappend lGN $GN
	lappend lDE $DE
	lappend ListeDeChoix "$OS / $OC / [BeauGN $GN] / $DE"
	lappend ListeDeCouleurs [CouleurDePeauOsOc "$OC"]
    }
    set Elu [ChoixParmi $ListeDeChoix $ListeDeCouleurs]

    if { $Elu == "" } { return "" }

    set i [lsearch -exact $ListeDeChoix $Elu]
    set OS [lindex $lOS $i]
    set OC [lindex $lOC $i]
    set GN [lindex $lGN $i]
    set DE [lindex $lDE $i]

    if {[regexp " OR " $GN]} {
	set BonGN [ChoixParmi [split $GN " "]]
	if { $BonGN == "OR" } {set BonGN $GN}
    } else {
	set BonGN $GN
    }
    
    set aDE "" 
    set aGN ""
    if { $DE != "" } { set aDE "DE: $DE\n" }
    if { $BonGN != "" } { set aGN "GN: $BonGN\n" }
    set Append [string trim "$aGN$aDE"]
    if { $Append != ""} {
	Informe $Nom $Append
    }
    return "$Append"
}


proc Fard {K X Y} {
    global TypeFard
    global KanvaAColorer

    set Nom [Box [BoiteDuCourant $K $X $Y] nom]
    set KanvaAColorer $K
    set Couleur [CouleurParTypeEtNom [set TypeFard($K)] $Nom $K]
    unset KanvaAColorer
    return $Couleur
} 

proc ChargeLesCodonsStart {} {
    global LesCodonsStart
    global LesAAsStart


    foreach Boite [ListeDesPABs] {
	set Nom    [Box $Boite nom]
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]

	if { $Orient == "F" } {
	    set Codon [BoutADN $Debut [expr $Debut+2] $Orient]
	} else {
	    set Codon [BoutADN [expr $Fin-2] $Fin $Orient]
	}
	set Codon [string toupper $Codon]                       ; #rR 2017/11/06
	set LesCodonsStart($Nom) $Codon
	set LesAAsStart($Nom) [AAduCodon $Codon]
    }
}

proc AAStart Nom {
    global LesAAsStart
    if {[info exists LesAAsStart($Nom)]} { return LesAAsStart($Nom) }
    if {[info exists LesAAsStart("EstCharge")]} { return "" }
    set LesAAsStart("EstCharge") 1
    ChargeLesCodonsStart
    return [AAsStart $Nom]
}

proc NucDuCodonStart Nom {
    global RepertoireDuGenome
    global LesCodonsStart
    global LesAAsStart

    if { ! [info exists LesCodonsStart]} {
	ChargeLesCodonsStart
    }

    if { [info exists LesCodonsStart($Nom)] && [YaPABdans $Nom]} {
	return [set LesCodonsStart($Nom)]
    } else {
	return ""
    }
}

proc TestAAduCodon {} {
    Espionne [AAduCodon Tga]
    Espionne [AAduCodon TGA W]
    Espionne [AAduCodon tGA]
    Espionne [AAduCodon ATG]
    Espionne [AAduCodon ATG S]
    Espionne [AAduCodon ATG]
    Espionne [AAduCodon Reset]
    Espionne [AAduCodon ATG]
    Espionne [AAduCodon tGA]
    exit

}

proc CodonsDuAA {AA} {
    return [CodeGenetique $AA Codons]
}

proc AAduCodon {Codon {AA ""}} {
    global CodonToAminoAcid
    global FichierTranslate

    if {$Codon=="Reset" && [info exists CodonToAminoAcid]} {unset CodonToAminoAcid ; return ""}

    if {[string length $Codon] != 3 } { return "-" }

    if {[regexp -nocase {[^ATGC]} $Codon]} { return "X" }

    if { ! [info exists CodonToAminoAcid("EstCharge")]} {
	set CodonToAminoAcid("EstCharge") 1
	set ListeDesLignes [split [ContenuDuFichier $FichierTranslate] "\n"]
	set IndexPointPoint [lsearch -regexp $ListeDesLignes {\.\.}]
	if { $IndexPointPoint == -1 } { Warne "$FichierTranslate merde."; exit}
	set PartieCodage [lrange $ListeDesLignes [incr IndexPointPoint 2] end]
	foreach Ligne $PartieCodage {
	    set fin [expr [string first "\!" $Ligne]-1]
	    set Interet [string range $Ligne 0 $fin]
	    if {[info exists a]} { unset a }
	    if {[info exists b]} { unset b }
	    if {[info exists c]} { unset c }
	    if {[info exists d]} { unset d }
	    if {[info exists e]} { unset e }
	    if {[info exists f]} { unset f }
	    if {[info exists g]} { unset g }
	    if {[info exists h]} { unset h }
	    scan $Interet "%s %s %s %s %s %s %s %s %s %s" A AAA a b c d e f g h
	    if {[info exists a]} { set CodonToAminoAcid([string toupper $a]) $A}
	    if {[info exists b]} { set CodonToAminoAcid([string toupper $b]) $A}
	    if {[info exists c]} { set CodonToAminoAcid([string toupper $c]) $A}
	    if {[info exists d]} { set CodonToAminoAcid([string toupper $d]) $A}
	    if {[info exists e]} { set CodonToAminoAcid([string toupper $e]) $A}
	    if {[info exists f]} { set CodonToAminoAcid([string toupper $f]) $A}
	    if {[info exists g]} { set CodonToAminoAcid([string toupper $g]) $A}
	    if {[info exists h]} { set CodonToAminoAcid([string toupper $h]) $A}
	}
	
	if { ![CodonStopPossible "TGA"] } { set CodonToAminoAcid(TGA) "W" }
    }
    set CODON [string toupper $Codon]
    if {$AA!=""} { set CodonToAminoAcid($CODON) $AA }
    if { ! [info exists CodonToAminoAcid($CODON)]} { return "X" }
    return [set CodonToAminoAcid($CODON)]
}

proc TestCA {} {
    return [CompareADNDesFichiersTFA "/genomics/link/ProGS/nuctfa/PGS002" "/genomics/link/ProGS/nuctfa/PGS502" SansAffichage]
}

proc CompareADNDesTextesTFA {T1 T2 {SansAffichage ""} {Titre ""}} {
    set DeuxPages $T1
    append DeuxPages "\n"
    append DeuxPages $T2
    return [VoisinADN $DeuxPages $SansAffichage $Titre]
}

proc CompareADNDesFichiersTFA {F1 F2 {SansAffichage ""} {Titre ""}} {
    set T1 [ContenuDuFichier $F1]
    set T2 [ContenuDuFichier $F2]
    return [CompareADNDesTextesTFA $T1 $T2 $SansAffichage $Titre]
}

proc CompareADN {Page {SansAffichage ""} {Titre ""}} {
    global CompareADN
    if {[info exists CompareADN]} {
	set DeuxPages $CompareADN
	append DeuxPages "\n$Page"
	unset CompareADN
	return [VoisinADN $DeuxPages $SansAffichage $Titre]
    }
    set CompareADN $Page
    set Message "Please click on the CompareADN button of an another window"
    FaireLire $Message
    return $Message
}

proc VoisinADN {NomOuTexte {Debut ""} {Fin ""} {Orient ""} {SansAffichage ""} {Titre ""}} {

    if {[regexp -nocase {[A-Z]} $Debut]} {
	set SansAffichage $Debut
	set Titre $Fin
	set Debut ""
	set Fin ""
    }

    set AvecReverse 1
    if {[EstPABouTROUouTRNAouARN $NomOuTexte]} {
	set Nom $NomOuTexte
	if {$Debut=="nuctfa"} {
	    set adn [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nuctfa"]]
	    set Debut 1
	    set Fin [string length $adn]
	    set LongN [expr $Fin-$Debut+1]
	    set DebutEtendu $Debut
	    set FinEtendu $Fin
	    set Orient "F"
	} else {
	    if {$Debut == "" } {
		set Nom    [Box $Nom nom]
		set Debut  [Box $Nom debut]
		set Fin    [Box $Nom fin]
		set Orient [Box $Nom orient]
	    }
	    
	    set LongN [expr $Fin-$Debut+1]
	    
	    set DebutEtendu [expr $Debut-900] 
	    set FinEtendu   [expr $Fin  +900]
	    
	    while { $DebutEtendu < 1             } { incr DebutEtendu 3}
	    while { $FinEtendu   > [LongueurADN] } { incr FinEtendu  -3}
	    
	    set adn [BoutADN $DebutEtendu $FinEtendu $Orient]
	}
    } else {
	if {[regexp "^>" $NomOuTexte]} {
	    set Nom [EnteteDuTexteTFA $NomOuTexte "access"] 
	    set adn [QueLaSequenceDuTexteTFA $NomOuTexte "ListOfTxt"]
	    if {[llength $adn]>1} {
		set AvecReverse 0
		ScanLaListe $adn adn AutreAdn
	    }
	} else {
	    if {[regexp -nocase {[^atgcn \n0-9\.]} $NomOuTexte] && \
		     ! [OuiOuNon "Do You really want to see the 6 frame translation of the whole text ?" 0] } {
		 return ""
	     }
	    set Nom "Six_frames_translation" 
	    regsub -nocase -all {[^a-z]} $NomOuTexte "" adn
	} 
	set Debut 1
	set Fin [string length $adn]
	set LongN [expr $Fin-$Debut+1]
	set DebutEtendu $Debut
	set FinEtendu $Fin
	set Orient "F"
    }

    if {$AvecReverse} {
	set tdn [ComplementString $adn]
    } else {
	set tdn $AutreAdn
    }

    set pep(0) ""
    set pep(1) ""
    set pep(2) ""
    set pep(3) ""
    set pep(4) ""
    set pep(5) ""
    for {set i 0} { $i < [string length $adn] } {incr i } {
	append pep([expr $i%3])   "[AAduCodon [string range $adn $i [expr $i+2]]]  "
	if {$AvecReverse} {
	    append pep([expr $i%3+3]) "[AAduCodon [ReverseString [string range $tdn $i [expr $i+2]]]]  "
	} else {
	    append pep([expr $i%3+3]) "[AAduCodon [string range $tdn $i [expr $i+2]]]  "
	}
    }
    set Blanc ""
    for {set i 0} {$i<6000} {incr i} {append Blanc " "}
 
    if {$Orient == "F" } {
	set OffsetAvant [expr $Debut-$DebutEtendu]
	set OffsetApres [expr $FinEtendu-$Fin]
    } else {
	set OffsetApres [expr $Debut-$DebutEtendu]
	set OffsetAvant   [expr $FinEtendu-$Fin]
    }
    set BlancAvant [string range $Blanc 0 [expr $OffsetAvant-1]]
    set BlancApres [string range $Blanc 0 [expr $OffsetApres-1]]
    set pepOriF [string range $pep(0) $OffsetAvant [expr [string length $pep(0)]-$OffsetApres] ]
    set pepOriR [string range $pep(3) $OffsetAvant [expr [string length $pep(3)]-$OffsetApres] ]
    set Regle [string range $Blanc 0 [expr $OffsetAvant%10-1]]
    for {set a [expr -($OffsetAvant/10)*10]} {$a < 0} {incr a 10} {
	set Marque "$a          "
	append Regle [string range $Marque 0 9]
    }
    for {set a 1} {$a<$LongN} {incr a 10} {
	set p [expr ($a+2)/3]
	set Marque "${a}<$p         "
	append Regle [string range $Marque 0 9]
    }
    append Regle [string range $Blanc 0 [expr ($LongN-1)%10-1]]
    for {set a 10} {$a<$OffsetApres} {incr a 10} {
	set Marque "+$a          "
	append Regle [string range $Marque 0 9]
    }
    set CodeGenetiqueN ""
    set CodeGenetiqueP ""
    foreach A {a c g t} {
	foreach B {a c g t} {
	    foreach C {a c g t} {
		set Codon "$A$B$C"
		set AA [AAduCodon $Codon]
		set AAA [UT $AA]
		append CodeGenetiqueN   "$Codon "
		append CodeGenetiqueAA  [string range "$AA      " 0 3] 
		append CodeGenetiqueAAA [string totitle [string range "$AAA     " 0 3]] 
	    }
	}
    }
    set Explication "Find below the 3 frames translation of the 2 DNA sequences. To find the differences use the horizontal scrollbar : an X indicates the mutation." 
    set CodeGenetique "$CodeGenetiqueN\n$CodeGenetiqueAA\n$CodeGenetiqueAAA"
    if {$AvecReverse} {
	set Texte "  $pep(2)\n $pep(1)\n$pep(0)\n$BlancAvant$pepOriF$BlancApres\n$adn\n$Regle\n$tdn\n  $BlancAvant$pepOriR$BlancApres\n  $pep(3)\n   $pep(4)\n    $pep(5)"
    } else {
	set Highlight ""
	foreach A [string toupper [split $adn ""]] T [string toupper [split $tdn ""]] {
	    if {$A==$T} { append Highlight " " } else { append Highlight "X" }
	}
#	set Texte "  $pep(2)\n  $pep(5)\n$adn\n$tdn\n$Regle\n\n $pep(1)\n $pep(4)\n$adn\n$tdn\n$Regle\n\n$pep(0)\n$pep(3)\n$adn\n$tdn\n$Regle\n$BlancAvant$pepOriF$BlancApres\n$BlancAvant$pepOriR$BlancApres\n\n$Highlight"
	set Texte "$Explication\nFrame+2\n  $pep(2)\n  $pep(5)\n$adn\n$tdn\n$Regle\n\nFrame+1\n $pep(1)\n $pep(4)\n$adn\n$tdn\n$Regle\n\nFrame+0\n$pep(0)\n$pep(3)\n$adn\n$tdn\n$Regle\n$Highlight\nDifferences are highlighted with X  ->"
    }
    append Texte "\nGenetic code\n$CodeGenetique"

    if {$SansAffichage!=""} {
	if {[PourWscope]} { set Texte "<pre>$Texte</pre>" }
	return $Texte
    }

    if {$Titre==""} { set Titre $Nom }
    return [AfficheVariable $Texte "GrandeLargeur" $Titre]

    Wup "AfficheVariable uses listbox, AfficheText uses widget text"
    return [AfficheTexte $Texte $Nom [expr $OffsetAvant-50]]
}

proc MultiAlignePlusieursAby {Aligneur Selection} {
    foreach FichierBlast [split $Selection "\n"] {
	set MSF [AligneLesHomologuesDuBlast $Aligneur $FichierBlast]
	if { $MSF == "" } {
	    Warne "Il n'y a pas de sequences a aligner dans $FichierBlast"
	} else {
	    Warne "Copie en $MSF"
	}
    }
}

proc HistogrammeDuNombreDeCopainsDansBlast {} {
    global NombreDeCopainsDansBlast
    if { ! [info exists NombreDeCopainsDansBlast] } {
	ChargeNombreDeCopainsDansBlast
    }
    foreach {Nom ValNombreDeCopainsDansBlast} [array get NombreDeCopainsDansBlast] {
	set nCops $ValNombreDeCopainsDansBlast
	if { $nCops > 2 } {
	    lappend Liste $nCops
	}
    } 
    Histogramme $Liste
}

proc HistogrammeDuFichier {Fichier {Sortie ""}} {
    set Liste {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%d" N
	lappend Liste $N
    }
    return [Histogramme $Liste $Sortie]
}

proc Histogramme {ListeDeNombres {Sortie ""}} {
    
    if {$Sortie==""} { set Sortie "Term" }

    set MaxLargeur 80

    set MaxnN -9999
    foreach n $ListeDeNombres {
	if { ! [info exists nN($n)] } { set nN($n) 0 }
	incr nN($n)
	if { [set nN($n)] > $MaxnN } { set MaxnN [set nN($n)] }
    }

    set ListeDeNombresTriee [lsort -integer $ListeDeNombres]

    set Debut [lindex $ListeDeNombresTriee 0] 
    set Fin   [lindex $ListeDeNombresTriee end]
    set LesN  [NombresEntre $Debut $Fin]

    set LesY {}
    foreach n $LesN {
	set x 0
	if {[info exists nN($n)]} { set x [set nN($n)] }
	if {$Sortie=="Nombre"} {
	    if {$x==0} { continue }
	    Espionne "[format %3d $n] $x"
	    continue
	}
	if {$Sortie=="Term"} {
	    set Largeur [expr int(1.0*$x*$MaxLargeur/$MaxnN)]
	    Espionne "[format %3d $n] [string repeat "." $Largeur]" 
	    continue
	}
	lappend LesY $x
    }
    if {$Sortie=="Graphe"} {
	return [Graphe $LesN $LesY]
    }
    if {$Sortie=="GetLists"} { return [list $LesN $LesY] }
    return ""
}

proc InformeSansDemander {Nom {Append ""}} {
    global InformeSansDemander

    if { ! [info exists InformeSansDemander]} { set InformeSansDemander 0 }
    
    set SauveInformeSansDemander $InformeSansDemander
    set InformeSansDemander 1
    set Retour [Informe $Nom $Append]
    set InformeSansDemander $SauveInformeSansDemander
    return $Retour
}

proc InformeSansDemanderParWscope {Nom Page} {
    InformeSansDemander $Nom $Page
    return [Informe $Nom]
}

proc Informe {Nom {Append ""}} {
    global RepertoireDuGenome
    global FenetreInfoOuverte
    global FenetreSignal
    global LesKanvasOuverts
    global ListeDesContenuInfo
    global InfoEnMemoire
    global InformeSansDemander
    global TypeCouleur
    global TypeCouleurDuLinge
    global RetourEntreTexte

    Gs "Text"
    
#    if {[PourWscope]} { return [XpertComment $Nom] }

    set FichierInfo "$RepertoireDuGenome/infos/$Nom"

    if {[regexp "\n" $Append]} {
	foreach Ligne [split $Append "\n"] {
	    if {[regexp "^Nom: " $Ligne]} { continue } 
	    set Inf [Informe $Nom $Ligne]
	}
	return $Inf
    }

    if {[regexp "^=CopyOf_" $Append]} {
	set Source [StringApres "_" dans $Append]
	return [Informe $Nom [ExtraitInfo $Source]]
    }

    set Remplace [regexp "^=" $Append]
    regsub {^[=+]} $Append "" Append

    if { ! [PourWscope] && [info exists FenetreInfoOuverte($Nom)]} {
	raise [set FenetreInfoOuverte($Nom)]
	if {$Append == ""} { return "[ContenuDuFichier $FichierInfo]" }
	if {[OuiOuNon "$Append\n doit etre rajoute a la page info $Nom\n \
		La page info est deja ouverte.\n \
		Dois-je abandonner ?"]} { return -1 }
	if {[OuiOuNon "Dois-je le faire maintenant ?"]} {
	    [set FenetreInfoOuverte($Nom)].text insert end "$Append\n"
	    return -2
	} 
	FaireLire "Vous ferez, plus tard, le couper-coller pour moi. Merci."
	return -3
    }

    set FenetreInfoOuverte($Nom) $Nom


    if {! [file exists $FichierInfo] || [file size $FichierInfo]==0} {
	set Information "Nom: $Nom"
	if {[file exists "$RepertoireDuGenome/beton/infomodele"]} {
	    append Information "\n[ContenuDuFichier $RepertoireDuGenome/beton/infomodele]"
	}
	Sauve $Information dans $FichierInfo
    }
    if {$Remplace} {
	scan $Append "%s" Champ
	set VieuxTextePurge [InformeParSuppressionDuChamp $Nom $Champ "PourVoir"]
    } else {
	set VieuxTextePurge [ContenuDuFichier $FichierInfo]
    }
    if { [info exists InformeSansDemander] && $InformeSansDemander } {
	set BonTexte "$VieuxTextePurge\n$Append"
    } else {
	if {[PourWscope]} { return [EntreTexte "$VieuxTextePurge\n$Append" "AvecRetourPourInforme" $FichierInfo] }
	set BonTexte [EntreTexte "$VieuxTextePurge\n$Append" [list "Show $Nom" "SeeAby Show $Nom"]]
    }
    if { $BonTexte != "" } {
	set TexteOk [Censure "$BonTexte"]
	Sauve $TexteOk dans $FichierInfo
	set InfoEnMemoire($Nom) $TexteOk 
	if {[info exists ListeDesContenuInfo]} {
	    set iTrouve [lsearch -regexp $ListeDesContenuInfo [string toupper "^Nom: $Nom"]]
	    set ListeDesContenuInfo [lreplace $ListeDesContenuInfo $iTrouve $iTrouve [string toupper $TexteOk]] 
	}
	if {[PourWscope]} { return $TexteOk }
	if {[info exists LesKanvasOuverts]} {
	    foreach K $LesKanvasOuverts {
		if { ! [info exists TypeCouleur($K)]} { continue }
		RetexteUneBoite $Nom [NomDeScene $Nom] $K
		OnColorieLesFrames 1
		RecoloreUneBoite $Nom [set TypeCouleur($K)] $K
		OnColorieLesFrames 0
		RecoloreUnLinge  $Nom [set TypeCouleurDuLinge($K)] $K
	    }
	}
    }
    if {[info exists FenetreSignal($Nom)]} {
	destroy [set FenetreSignal($Nom)]
	unset  FenetreSignal($Nom)
    }
    unset FenetreInfoOuverte($Nom)
    return $BonTexte
}

proc NombreDeCopainsDansBlast {{Nom ""}} {
    global NombreDeCopainsDansBlast
    
    if {[regexp -nocase {_?Reload_?} $Nom]} {
	if {[info exists NombreDeCopainsDansBlast]} { unset NombreDeCopainsDansBlast }
	regsub -nocase {_?Reload_?} $Nom "" Nom
	return [NombreDeCopainsDansBlast $Nom]
    }


    if {[info exists NombreDeCopainsDansBlast($Nom)]}        { return $NombreDeCopainsDansBlast($Nom) }
    if {[info exists NombreDeCopainsDansBlast("EstCharge")]} { return $NombreDeCopainsDansBlast("EstCharge") }
    set NombreDeCopainsDansBlast("EstCharge") -1

    set Fichier "[RepertoireDuGenome]/fiches/nombredecopainsdansblast"
    set NombreDeCopainsDansBlast(Filename) $Fichier

    if { ! [file exists $Fichier]} { return [set NombreDeCopainsDansBlast("EstCharge") -2] } 

    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { ! [regexp -nocase {[A-Z_0-9]+ +[0-9]+} $Ligne]} { continue }
	scan $Ligne "%s %d" NomLu nCops
	set NombreDeCopainsDansBlast($NomLu) $nCops
    }
    return [NombreDeCopainsDansBlast $Nom]
}

proc ChargeNombreDeCopainsDansBlast {} {
    #rR ne sert plus
    return [NombreDeCopainsDansBlast "Reload"]
}

proc CreeLeFichierNombreDeCopainsDansBlast {{Source ""} {SeuilExpect ""} {Extension ""}} {
    global RepertoireDuGenome

    while {$Source==""} {
	FaireLire "I'll create Blast Hit count, please choose the source information"
	set LesSources [list taxobla DifferentOX DaedalusHits apns blastx blastp tblastngenomes tblastnhuman "MyOwnBlastDirectory"]
	set LesTextes  [list \
		"Count different TaxId from Taxobla" \
		"Count different TaxId" \
		"Count all DaedalusHits" \
		"Use ./apns/* files (obsolete)" \
		"Count simply hits from BlastX" \
		"Count simply hits from BlastP" \
		"Count simply hits from TBlastN genomes" \
		"Count simply hits from TBlastN human" \
		"Count simply hits from MyOwnBlastDirectory" ]
	set Source [ChoixParmiJoli $LesSources {} $LesTextes]
	if {$Source=="MyOwnBlastDirectory"} {
	    FaireLire "Please give the name of Your own blast directory\nthe letters 'blast' must appear in your name"
	    set Source [Entre "blast"]
	}
	if {$Source=="" && [OuiOuNon "Do I cancel "]} { return "" }
    }
    if {$SeuilExpect==""} { set SeuilExpect 0.001 }


    set FichierNombreDeCopainsDansBlast "$RepertoireDuGenome/fiches/nombredecopainsdansblast$Extension"

    if {$Extension=="" && [OuiOuNon "Do You want to add an extension to \n\
	    $FichierNombreDeCopainsDansBlast"]} {
	set Extension [Entre ".$Source"]
	append FichierNombreDeCopainsDansBlast $Extension
    }

    set ListeNomNCops {}
    if {$Source=="DaedalusHits" || $Source=="DifferentOX"} {
	foreach Nom [ListeDesPABs] {
	    set FicDaedalus "[RepertoireDuGenome]/daedalushits/$Nom"
	    if { ! [file exists $FicDaedalus]} { continue }
	    set nCops 0
	    if {[info exists DejaVu]} { unset DejaVu }
	    foreach Ligne [LesLignesDuFichier $FicDaedalus] {
		set AncienneLigne $Ligne
		set PN [ValeurDeLaBalise PN Ligne]
		if {$PN==""} { continue ; FaireLire $AncienneLigne } 
		if { [expr $PN > $SeuilExpect] } { break }
		set OX [ValeurDeLaBalise OX Ligne]
		if {[info exists DejaVu($OX)]} { continue }
		incr nCops
		if {$Source=="DifferentOX"} { set DejaVu($OX) 1 }
	    }
	    lappend ListeNomNCops "$Nom $nCops"	    
	}
    } elseif {$Source=="apns"} {
	set ListeDesAPNs [concat \
		[glob -nocomplain "$RepertoireDuGenome/apns/*"] \
		[glob -nocomplain "$RepertoireDuGenome/trousapns/*"] \
		[glob -nocomplain "$RepertoireDuGenome/trouxsapns/*"] \
		[glob -nocomplain "$RepertoireDuGenome/trounsapns/*"] \
		]
	
	foreach FichierAPN [lsort $ListeDesAPNs] {
	    set Nom [file tail $FichierAPN]
	    set nCops 0
	    foreach Ligne [LesLignesDuFichier $FichierAPN] {
		scan $Ligne "%s %s %f" BanqueId Access PN
		if { [expr $PN > $SeuilExpect] } { break }
		incr nCops
	    }
	    lappend ListeNomNCops "$Nom $nCops"
	}
    } elseif {[regexp "blast" $Source]} {
	foreach Nom [ListeDesPABs] {
	    set FichierBlast "[RepertoireDuGenome]/$Source/$Nom"
	    if { ! [file exists $FichierBlast]} { continue }
	    set nCops [DecortiqueBlast $FichierBlast $SeuilExpect "" "BlastHitCount"]
	    Espionne "$Nom $nCops"
	    lappend ListeNomNCops "$Nom $nCops"
	}
    } elseif {[regexp "taxobla" $Source]} {
	foreach Nom [ListeDesPABs] {
	    set FichierTaxobla "[RepertoireDuGenome]/$Source/$Nom"
	    if { ! [file exists $FichierTaxobla]} { continue }
	    set nCops [llength [LesLignesDuFichier $FichierTaxobla]]
	    Espionne "$Nom $nCops"
	    lappend ListeNomNCops "$Nom $nCops"
	}
    } else {
	FaireLire "Please give the source for CreeLeFichierNombreDeCopainsDansBlast"
	return ""
    }
    set Fichier [SauveLesLignes $ListeNomNCops dans $FichierNombreDeCopainsDansBlast]
    return [NombreDeCopainsDansBlast "Reload_Filename"]
}

proc CreeLesFichiersNucTfa {{Liste {}}} {
    global RepertoireDuGenome
    global ListeDeBoites

    Espionne $Liste

    if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }

    Wup "On peut en faire un seul, a la demande"

    if { $Liste == {}} {
	set ListeATraiter $ListeDeBoites
    } else {
	set ListeATraiter $Liste
    }

    foreach Boite $ListeATraiter {

	set Nom    [Box $Boite nom]
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]

	Espionne "$Nom $Debut $Fin $Orient"
	Espionne "$RepertoireDuGenome/nuctfa/$Nom"
	if {[file exists "$RepertoireDuGenome/nuctfa/$Nom"]} { continue }

	CreeLeFichierDansNucTfa $Nom $Debut $Fin $Orient
    }
}

proc CreeLeFichierDansNucTfa {Nom Debut Fin Orient} {
    global RepertoireDuGenome
    global ADN TDN RAC

    JeMeSignale

    if { ! [info exists ADN]} { ChargeADNetTDNetRAC }

    catch {unset Nuc}
    if { $Orient == "F" } {
	set Nuc [string range $ADN $Debut $Fin]
    } else {
	set Nuc ""
	for {set i $Fin} {[expr {$i>=$Debut}]} {incr i -1} {
	    append Nuc [string range $TDN $i $i]
	}
    }
    
    set TFA [SequenceFormatTFA $Nuc $Nom "nucbrut"]
    return [Sauve $TFA dans "$RepertoireDuGenome/nuctfa/$Nom"]
#    set MauvaisNom "tmpreformatout.tmp"
#    set VraiDebut [expr [string first $MauvaisNom $GCG]+[string length $MauvaisNom]]
#    return [Sauve "${Nom}[string range $GCG $VraiDebut end]" dans "$RepertoireDuGenome/nuctfa/$Nom"]
}

proc EtudieLesProteinesDe GenomeCourant {
    global RepertoireDuGenome
    global ListeDeBoites
    
    Gs "Frame"
    
    if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }
    set FichiersPABs [glob "$RepertoireDuGenome/gcgs/*"]
    set FichiersTROUs [glob "$RepertoireDuGenome/trousgcgs/*"]
    set Page [join [lsort [concat $FichiersPABs $FichiersTROUs]] "\n"]
    return [AfficheVariable $Page "" "gcgs et trous"]
}

proc EtudieLesNucleiquesDe GenomeCourant {
    global RepertoireDuGenome
    global ListeDeBoites
    
    Gs "Frame"
    
    if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }
    set Fichiers "$RepertoireDuGenome/nuctfa/*"
    set Page [join [lsort [glob $Fichiers]] "\n"]
    return [AfficheVariable $Page "" "$Fichiers"]
}

proc SeeBlast Fichier {
    global RepertoireDuGenome
    set Nom [file tail $Fichier]
    AfficheUneSortieBlast "$RepertoireDuGenome/blasts/$Nom"
}

proc SeeADN FichierPep {
    global RepertoireDuGenome
    global ADN TDN RAC

    if { ! [info exists ADN] } { ChargeADNetTDNetRAC }

    set Nom [file tail $FichierPep]
    AfficheFichier "$RepertoireDuGenome/nuctfa/$Nom" "SansFetchAvecVoisinsAvecFormateAvecBlaste"
}

proc CreeADNetTDNetRACaPartirDuFichierBrut {Fichier {Start ""} {Extension ""}} {
    if {$Start==""} { set Start 0 }
    return [CreeADNetTDNetRAC [string range [ContenuDuFichier $Fichier] $Start end] $Extension]
}

proc CreeADNetTDNetRAC {SequenceBrute {Extension ""} {Rep ""}} {
    global RepertoireDuGenome
    global ADN TDN RAC

    if {$Rep==""} { set Rep [RepertoireDuGenome] }

    if {[file exists "$Rep/beton/adn$Extension"]} {
	if {[OuiOuNon "Les Fichiers $Rep/beton/adn$Extension ... existent deja.\nJe stoppe tout ?" 0]} { exit }
	if { [OuiOuNon "Je les garde ?" 0]} { return ""}
	if { ! [OuiOuNon "Je les recree ?" 1]} { return ""}
    }

    set Complement("X") "X"
    set Complement("x") "x"
    set Complement("A") "T" 
    set Complement("T") "A"
    set Complement("G") "C"
    set Complement("C") "G"
    set Complement("a") "t"
    set Complement("t") "a"
    set Complement("g") "c"
    set Complement("c") "g"
    set Complement("N") "N"
    set Complement("n") "n"

    set Complement("M") "K"
    set Complement("K") "M"
    set Complement("R") "Y"
    set Complement("Y") "R"
    set Complement("W") "W"
    set Complement("S") "S"

    set Complement("m") "k"
    set Complement("k") "m"
    set Complement("r") "y"
    set Complement("y") "r"
    set Complement("w") "w"
    set Complement("s") "s"

    set Complement("V") "B"
    set Complement("H") "D"
    set Complement("D") "H"
    set Complement("B") "V"
    set Complement("v") "b"
    set Complement("h") "d"
    set Complement("d") "h"
    set Complement("b") "v"

    set ADN "n"
    append ADN $SequenceBrute

    set L [string length $ADN]

    set TDN "n"
    set RAC "n"
    for {set i 1} {$i<$L} {incr i} {
	set D [string range $ADN $i $i]
	set F [string range $ADN [expr $L-$i] [expr $L-$i]]
	append TDN [set Complement("$D")]
	append RAC [set Complement("$F")]
    }

    set FichierADN "$Rep/beton/adn$Extension" ; Sauve $ADN dans $FichierADN
    set FichierTDN "$Rep/beton/tdn$Extension" ; Sauve $TDN dans $FichierTDN
    set FichierRAC "$Rep/beton/rac$Extension" ; Sauve $RAC dans $FichierRAC

    return [list $FichierADN $FichierTDN $FichierRAC]
}

proc TestPcrProduct {} {
    set Oli5 [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/oligos/P2081.tfa"]
    set Oli3 [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/oligos/P2193.tfa"]
    set Seq  [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/nuctfa/PGS990"]

    set R [QuestionDeScience "EVImm" "ret PcrProduct $Oli5 $Seq $Oli3 getfasta"]
    return $R
    return [PcrProduct $Oli5 $Seq $Oli3 "getfasta"]
}

proc PcrProduct {Oli5 Seq Oli3 {GetWhat ""}} {

    if {$GetWhat==""} { set GetWhat "GetFasta" }

    set H5 [SiteHybridisation $Oli5 $Seq "F"]
    set H3 [SiteHybridisation $Oli3 $Seq "R"]
    scan $H5 "%d %d %d %s" I5 IA5 Tm5 S5
    scan $H3 "%d %d %d %s" I3 IA3 Tm3 S3

    if {$IA5>$IA3} {
	set PPCR "X"
	set Entete "NoPcrProduct $I5 $IA5 $Tm5 $S5 $I3 $IA3 $Tm3 $S3"
    } else {
	set R3 [NucToReverseAndComplementNuc $Oli3]
	set SS [string range $Seq [expr $IA5 - 1] [expr $IA3 -1]]
	set PPCR "$Oli5$SS$R3"
	set Entete "PcrProduct $I5 $IA5 $Tm5 $S5 $I3 $IA3 $Tm3 $S3"
    }
    set TFA [SequenceFormatTFA $PPCR $Entete]
    if {[string equal -nocase "GetFasta" $GetWhat]} { return $TFA }
    return "$PPCR $I5 $IA5 $Tm5 $S5 $I3 $IA3 $Tm3 $S3"
}

proc SiteHybridisation {SeqO Sequence {FouR ""}} {
    if {$FouR==""} { set FouR "F" }

    set SO [string toupper $SeqO]
    if {$FouR=="R"} { set SO [NucToReverseAndComplementNuc $SO] }

    set SS [string toupper $Sequence]
    while 1 {
	set I [string first $SO $SS]
	Espionne "$I $SO"
	if {$I>0} { break }
	if {$SO==""} { break }
	if {$FouR=="F"} {
	    set SO [string range $SO 1 end]
	} else {
	    set SO [string range $SO 0 end-1]
	}
    }
    set LSO [string length $SO]
    set TmH 0
    foreach C [split $SO ""] {
	if {$C=="A" | $C=="T"} { incr TmH 2 }
	if {$C=="G" | $C=="C"} { incr TmH 4 }
    }
    if {$FouR=="F"} {
	set IDebut [expr $I + 1]
	set IApresOli5 [expr $IDebut + $LSO]
	return "$IDebut $IApresOli5 $TmH $SO"
    } else {
	set SO [NucToReverseAndComplementNuc $SO]
	set IAvantOli3 [expr $I - 1 + 1] 
	set IFin [expr $IAvantOli3 + $LSO] 
	return "$IFin $IAvantOli3 $TmH $SO"
    }
}


proc TestPDB {} {
    set Lpdbid [list 1c0a 1il2 1asy]

    source [HomeRipp]/oso.tcl
    SetupPDBObject
    foreach pdbid $Lpdbid {
	set file "/db/catalog/pdb/compressed_files/[string range $pdbid 1 2]/pdb${pdbid}.ent.gz"
	Structure create $pdbid
	set cok [$pdbid new $file "" 0 0]
	foreach c [$pdbid _chains] {
	    puts "$pdbid"
	    puts "$c [$pdbid _chainIs $c]"
	    #		set s [join [$pdbid _resname -chain A] ""]
	}
    }
    exit

    foreach pdbid $Lpdbid {
	Structure create $pdbid
	set Rep [string range $pdbid 1 2]
	set file "/db/catalog/pdb/compressed_files/[string range $pdbid 1 2]/pdb${pdbid}.ent.gz"
	set cok [$pdbid new $file "" 0 0]
	foreach c [$pdbid _chains] {
	    Espionne "$pdbid chain $c is [$pdbid _chainIs $c]"
	    Espionne "$pdbid chain $c is [$pdbid _chainIs $c]"
#	    Espionne [$pdbid _resname -chain $c]
	}
	$pdbid destroy
    }
    exit
}