#rR gscope_mascims.tcl 

proc CreateBlastDatabaseWithTfasDesCopains {{CreateLink ""}} {

    file mkdir [RepertoireDuGenome]/banques
    set LesTfas {}
    foreach Nom [ListeDesPABs] {
	set FicTfasCops [GscopeFile $Nom "tfasdescopains"]
	foreach Access [LaSequenceDuTFAs $FicTfasCops "LaListeDesAccess"] {
	    if {[info exists DejaVu($Access)]} { continue }
	    set DejaVu($Access) 1
	    set TFA [LaSequenceDuTFAs $FicTfasCops $Access]
	    set Seq [QueLaSequenceDuTexteTFA $TFA]
	    if {$Seq==""} {
		FaireLire "$Nom $Access"
	    } else {
		lappend LesTfas $TFA
	    }	    
	}
    }
    set FicAllTFAs [SauveLesLignes $LesTfas dans "[RepertoireDuGenome]/banques/AllTfasDesCopains"]
    NousAllonsAuBoulot "[RepertoireDuGenome]/banques"
    set B [file tail $FicAllTFAs]
    exec formatdb -i $B -p T
    if {[string equal -nocase $CreateLink "CreateLink"]} {
	while {[file exists blastpdatabase]} {
	    if { ! [OuiOnNon "blastpdatabase already exists in\n [pwd]\n Do you remove the link ? \nOtherwize You can do it later" 0]} { break } 
	}
	if { ! [file exists blastpdatabase]} { exec ln -s $B blastpdatabase }
    }
    OnRevientDuBoulot
    return $FicAllTFAs
}

proc TENRR {Seq {Frame ""} {Length ""} {Cardinality ""}} {
    #Espionne
    if {$Length==""}      { set Length 2 }
    if {$Cardinality==""} { set Cardinality 1 }
    if {$Frame==""} { set Frame 0 }
    #set CPost [list AA AC AT CA CT GA GC GG GT TA TT]
    #set CPre [list AC AT CC TC TT AG TG AA GC GT TA]
    set FicNuc [GscopeFile $Seq nuctfa]
    if {[file exists $FicNuc]} { set Seq [QueLaSequenceDuFichierTFA $FicNuc] } 
    regsub -all {[\-\.]} $Seq "" SeqNoGap
    set CPre ""
    set CPost ""
    foreach Codon [CirCode] {
	foreach {a b c} "[split $Codon {}]" {
	    #Espionne $b-$c
	    lappend CPre $b$c
	    lappend CPost $a$b
	}
    }
    #Espionne "Prefix:" $CPre
    #Espionne "Postfix:" $CPost
    set N [XMotifs $Seq $Frame $Length $Cardinality]
    #Espionne $N
    #array set XN $N
    set XM {}
    foreach {NC Positions} $N {
	foreach Position $Positions {
	    foreach DF $Position {
		lassign $Position D F
		set NewD [expr {$D}]
		set M ""
		if {[lsearch $CPre [string range $SeqNoGap $D-2 $D-1 ]]>=0} {
		    set M [string range $SeqNoGap $D-2 $D-1]
		    #Espionne $M
		    set NewD [expr {$D-2}]
		} else {
		    if {$D>1} {
			set M [string index $SeqNoGap $D-1]
			set NewD [expr {$D-1}]
		    }
		}
		set NewF [expr {$F+2}]
		if {[lsearch $CPost [string range $SeqNoGap $F+3 $F+4 ]]>=0} {
		    set M [string range $SeqNoGap $F+3 $F+4]
		    #Espionne $M
		    set NewF [expr {$F+4}]
		} else {
		    if {$F+3<[string length $SeqNoGap]} {
			set M [string index $SeqNoGap $F+3]
			set NewF [expr {$F+3}]	
		    }
		}
	    }
	    set NewN [expr {($NewF-$NewD)+1}]
	    set B [expr {$D-$NewD}]
	    set E [expr {$NewF-$F-2}]
	    #Espionne $NewN $NC
	    lassign [split $NC ","] N C
	    set NC $NewN,$C,$B,$E
	    #Espionne $NewN $NC
	    lappend NewArr($NC) [list $NewD $NewF]
	    set R [string range $SeqNoGap $NewD $NewF]
	    #Espionne $R $B $E
	}
    }
    #parray NewArr
    return [array get NewArr]
	  
}

proc RsfProtXFromRsfNucX {Nom} {
    
}

proc XMotifsFromRsfXX {FileRsf {Cc ""}} {
    #rR i took the program from Gopal for the rna 16S etc.
    set CC $Cc
    Espionne $CC
    set NewRsf $FileRsf
    regsub {\.rsf$} $NewRsf "" NewRsf
    append NewRsf "_R_$CC.rsf"
    set N [DecortiqueUnRSF $FileRsf LesNomsDesSequencesDansLOrdre Sequences TabRSF "" "AvecBornesLocales"]
    set NbCodons 2
    set Cardinality 1
    set Res {}
    foreach Access $LesNomsDesSequencesDansLOrdre {
	set SeqGap $Sequences($Access)
	#Espionne $Access
	regsub -all {[\-\.]} $SeqGap "" SeqNoGap
	set LeNew {}
	foreach Frame [list 0 1 2] {
	    set PositionsMotifs($Frame,$Access) {}
	    set NXM [TEN $SeqNoGap $CC $Frame $NbCodons $Cardinality]
	    array set NXMA $NXM
	    #parray XMA
	    foreach {NC ListOfCoo} $NXM {
		lassign [split $NC ","] N C B E
		if {$N<9} {continue}
		foreach DF $ListOfCoo {
		    set Color $N
		    if {$Color >=9} { set Color 9}
		    lassign $DF D F
		    incr D
		    incr F
		    set DG [PositionsLocalesVersGlobales $SeqGap $D]
		    set FG [PositionsLocalesVersGlobales $SeqGap $F]
 		    set AliFrame [expr {($DG+$B-1)%3}] 
		    #set Color $AliFrame
		    set len [expr {($F-$D)+1}]
		    lappend LeNew "feature $DG $FG $Color square solid X${Color}Motifs" 
		    lappend LeNew "  FT   X${Color}Motifs      $D     $F  ${AliFrame}Card${C}_$B-$len-$E"
		}
	    }
	}
	set FeaturesFor($Access) $LeNew
    }
   
    foreach Ligne [LesLignesDuFichier $FileRsf] {
	if {[regexp {^name (.+)$} $Ligne Match Access]} {
	    set CurrentAccess $Access
	    lappend LeNewRsf $Ligne
	    continue
	}
	if {[regexp {^sequence} $Ligne]} {
	    if {[info exists FeaturesFor($Access)]} { LConcat LeNewRsf $FeaturesFor($Access) }
	    lappend LeNewRsf $Ligne
	    continue
	}
	lappend  LeNewRsf $Ligne
    }
    return [SauveLesLignes $LeNewRsf dans $NewRsf]
}

proc XMotifsFromRsf {FileRsf {NewRsf ""} {NbCodons ""} {Cardinality ""} {ColorType ""}} {
    if {$NewRsf==""} {
	set NewRsf $FileRsf
	regsub {\.rsf$} $NewRsf "" NewRsf
	append NewRsf "_WithXMotifsRR.rsf"
    }
    set N [DecortiqueUnRSF $FileRsf LesNomsDesSequencesDansLOrdre Sequences TabRSF "" "AvecBornesLocales"]
    if {$NbCodons   ==""} { set NbCodons 2 }
    if {$Cardinality==""} { set Cardinality 1 }
    if {$NbCodons   =="ForceEmpty"} { set NbCodons "" }
    if {$Cardinality=="ForceEmpty"} { set Cardinality "" }

    set Couleur(0) 5
    set Couleur(1) 1
    set Couleur(2) 2
    
    foreach Access $LesNomsDesSequencesDansLOrdre {
	set SeqGap $Sequences($Access)
	regsub -all {[\-\.]} $SeqGap "" SeqNoGap
	set LeNew {}
	foreach Frame [list 0 1 2] {
	    set XM [XMotifs $SeqNoGap $Frame $NbCodons $Cardinality]
	    array set XMA $XM
	    #parray XMA
	    foreach {NC ListOfCoo} $XM {
		lassign [split $NC ","] N C
		foreach DF $ListOfCoo {
		    if {$ColorType=="Frame"} {
			set Color $Couleur($Frame)			
		    } else {
			set Color $N
			if {$Color >=5} { set Color 5 }
		    }
		    lassign $DF D F
		    incr D
		    incr F 3
		    set DG [PositionsLocalesVersGlobales $SeqGap $D]
		    set FG [PositionsLocalesVersGlobales $SeqGap $F]
		    if {$ColorType=="Frame"} {
			lappend LeNew "feature $DG $FG $Color square solid X${Frame}Motifs" 
			lappend LeNew "  FT   X${Frame}Motifs      $D     $F  Card$C"
		    } else {
			lappend LeNew "feature $DG $FG $Color square solid X${Color}Motifs" 
			lappend LeNew "  FT   X${Color}Motifs      $D     $F  Card$C"
		    }
		}
	    }
	}
	set FeaturesFor($Access) $LeNew
    }
    foreach Ligne [LesLignesDuFichier $FileRsf] {
	if {[regexp {^name (.+)$} $Ligne Match Access]} {
	    set CurrentAccess $Access
	    lappend LeNewRsf $Ligne
	    continue
	}
	if {[regexp {^sequence} $Ligne]} {
	    if {[info exists FeaturesFor($Access)]} { LConcat LeNewRsf $FeaturesFor($Access) }
	    lappend LeNewRsf $Ligne
	    continue
	}
	lappend  LeNewRsf $Ligne
    }
    return [SauveLesLignes $LeNewRsf dans $NewRsf]
}
#feature 7 21 0 square solid X0Motifs
#  FT   X0Motifs      7     21  5

proc CreateMacsimRsfFromMacsimXmlPourTous {{Keep ""}} {
    foreach Nom [ListeDesPABs] {
	Espionne [CreateMacsimRsfFromMacsimXml $Nom $Keep]
    }
    return ""
}

proc CreateMacsimRsfFromMacsimXml {Nom {Keep ""}} {
    set SedFile "/home/ripp/SedFileToCreateRsfFromXml.sed"
    if {[FileAbsent $SedFile]} {
	lappend LesSed "s/0 square solid X0Motifs/5 square solid X0Motifs/g"
	lappend LesSed "s/0 square solid X1Motifs/1 square solid X1Motifs/g"
	lappend LesSed "s/0 square solid X2Motifs/2 square solid X2Motifs/g"
	SauveLesLignes $LesSed dans $SedFile
    }
    set Keep [string equal -nocase $Keep "Keep"]
    set FicRsf [GscopeFile $Nom "macsimRsf"]
    set FicXml [GscopeFile $Nom "macsimXml"]
    if {[FileAbsent $FicXml]} { return "Error. I did not find $FicXml " }
    if {$Keep && [FilePresent $FicRsf]} { return $FicRsf }
    exec clustalw $FicXml -convert -output=RSF -outfile=$FicRsf
    exec sed -i --file=$SedFile $FicRsf
    return $FicRsf
}

proc AddConservationToMacsims {{Liste ""} {Destin ""}} {
    if {$Destin==""} { set Destin "macsimXmlConservation" }
    if {$Liste=={}} { set Liste [ListeDesPABs] }
    NousAllonsAuBoulot
    set LesCrees {}
    foreach Nom $Liste {
	Espionne $Nom
	set FicOri [GscopeFile $Nom "macsimXml"]
	if {[FileAbsent $FicOri]} { continue }
	set FicDes [GscopeFile $Nom $Destin]
	if {[FileExists $FicDes]} { continue }
	if {[FileExists "toto.xml"]} { file delete "toto.xml" }
	if {[catch {exec ordali $FicOri -batch -exe ComputeConservation} Message]} {
	    Espionne "$Nom planté avec message\n$Message"
	    continue
	}
	if {[FileAbsent "toto.xml"]} { Espionne "Bouhhhhh pas de toto.xml pour $Nom" ; continue }
	file rename -force toto.xml $FicDes
	lappend LesCrees $FicDes
    }
    OnRevientDuBoulot
    return $LesCrees
}

proc GroupMacsimsAvecFnote {{In ""} {Ou ""}} {
    set I 0
    set LeNew {}
    foreach Ligne [LesLignesDuFichier $In] {
	if {[regexp {<group>} $Ligne]} { set PreviousI $I ; set LigneDuGroup $Ligne}
	if {[regexp {<fnote>Group([0-9]+)</fnote>} $Ligne Match G]} {
	    if { ! [info exists DejaVu($PreviousI)]} {
		regsub {<group>[0-9]+</group>} $LigneDuGroup "<group>$G</group>" NewG
		set LeNew [lreplace $LeNew $PreviousI $PreviousI $NewG]
		set DejaVu($PreviousI) 1
	    }
	}
	lappend LeNew $Ligne
	incr I
    }
    return [SauveLesLignes $LeNew dans $Ou]
}
 
proc MacsimsVariables {{Init ""}} {
    #rR Si Init n initialise toutes les listes a vide et les tableau au tableau vide
    #rR On rend [list $LesL $LesT]
    #rR les strings (AlnScore, etc.) sont traités comme des listes

    set Init [regexp -nocase {^(Y|1|Init)} $Init]
    set LesL [list AlnName AlnScore AlnNote LNDG LNOrdali]
    foreach L $LesL {
	global $L
	if {$Init} { set $L {} }
    }

    set LesT [list Sequences TabSF TDesHydro TDesSeqnames TDespI TDesAccess TDesPhylum TDesGO TDuLineage TDesOrganismes TDesTaxId TDesFragment TDuGroupeDesSeqs TDesEC TDesComplex TDesBId TDesDescriptifs TDesMolW TDesStatus TDesWeight TDesSense TDesScore TDesScore TDesLength TColScore LesSeqsDuGroupe SDG LesSequencesAssocieesClassesCanon]
    foreach T $LesT {
	global $T
	if {$Init} { array set $T [list] }
    }
    return [list $LesL $LesT]
    
#    foreach t {TDesHydro TDesSeqnames TDespI TDesAccess TDesPhylum TDesGO TDuLineage TDesOrganismes TDesTaxId TDesFragment TDuGroupeDesSeqs TDesEC TDesComplex TDesBId TDesDescriptifs TDesMolW} {
#	array set $t [list]
#    }
#    return
}


proc TestDecortiqueUnMacsimXml {{Quoi ""}} {
    global Voir_dans_MacsimsVariables
    LesDefauts
    set FichierOuTexteXML "/genomics/link/CilioCarta2014/macsimXml/CIL006"
    set MacsimsVariables [DecortiqueUnMacsimXml $FichierOuTexteXML]
    lassign $MacsimsVariables LesL LesT    
    if {[array exists ::$Quoi]} {
	parray ::$Quoi
    } else {
	EspionneL [set ::$Quoi]
    }

    foreach T $LesT {
#	parray ::$T
    }

    return $MacsimsVariables
}

proc RunAAM {} {
    foreach D [NombresEntre 5001 22000 1000] {
        set Deb $D
        set Fin [expr $D + 999]
        set Fichier "AAM-Cons-$Deb-$Fin.tsv"
        Espionne "setgscoperr EHomsa; gscope puts AllAboutMacsimPourTous $Fichier $Deb $Fin >& Run-$Deb-$Fin.log"
        exec tcsh -c "setgscoperr EHomsa; gscope puts AllAboutMacsimPourTous $Fichier $Deb $Fin >& Run-$Deb-$Fin.log"
    }
    exit
}

proc AllAboutMacsimPourTous {Fichier {Debut ""} {Fin ""}} {
    #rR Fait pour Kirsley pour avoir des enrigistrements à charger en une table SQL
    set LeTout {} 
    if {[regexp {\,} $Debut ]} {
	set Liste [split $Debut ","]
    } else {
	if {$Debut!=""} { incr Debut -1 }
	if {$Debut==""} { set Debut 0 }
	if {$Fin==""} { set Fin "end" }
	if {[regexp {^[0-9]+$} $Fin]} { incr Fin -1 }
	set Liste [lrange [ListeDesPABs] $Debut $Fin]
    }
    foreach Nom $Liste {
	Espionne $Nom
	set Un [AllAboutMacsim $Nom OnlyListOf All]
	if {$Un==""} { continue }
	AppendAuFichier $Fichier $Un
	AllAboutMacsim $Nom "Unset"
	FromMacsim "UnsetAll"
    }
    return $Fichier
}

proc AllAboutMacsim {{Nom ""} {Qui ""} {Quoi ""}} {
    #rR Fait pour Kirsley pour avoir des enrigistrements à charger en une table SQL
    global AAM 
    if {[info exists AAM($Nom,$Qui,$Quoi)]} { return $AAM($Nom,$Qui,$Quoi) } 
    if {[info exists AAM($Nom,EstCharge)]}  { return "" }
    set AAM($Nom,EstCharge) 1

    set AccessReference [NIAG $Nom A]

    if {$Qui=="Unset"} {
	unset AAM
	return ""
    }

    if {$Qui=="" && $Quoi==""} { set Qui "ListOf" ; set Quoi "All" }

    set FicTfaCops [GscopeFile $Nom tfasdescopains]
    if {[FileExists $FicTfaCops]} {
	foreach Ligne [LesLignesDuFichier $FicTfaCops] {
	    append Ligne " ZZ=bidon"
	    if { ! [regexp {^>([^ ]+) } $Ligne Match Access]} { continue } 
	    if {[regexp {\|} $Access]} { lassign [split $Access "|"] Banque Access Id }
	    if {$Access==""} { continue }
	    if {$Access==$Nom} {
		set OX [NotreOX]
		set AAM($Nom,$Access,OX) $OX
		lappend AAM($Nom,$OX,ListOfAc) $Access
		lappend AAM($Nom,ListOf,OX) $OX
		continue
	    }	
	    set OX ""
	    if { ! [regexp { OX=([0-9]+)} $Ligne Match OX]} {
		set OSE ""
		if {[regexp { OS=([^=]+)=} $Ligne Match OSE]} {
		    regsub { [A-Z][A-Z]$} $OSE "" OS
		    set OX [Tax $OS TaxId]
		}
	    }
	    if {$OX==""} { continue }
	    set AAM($Nom,$Access,OX) $OX
	    lappend AAM($Nom,$OX,ListOfAc) $Access
	    lappend AAM($Nom,ListOf,OX) $OX
	}
	set AAM($Nom,ListOf,OX) [lsort -unique -integer $AAM($Nom,ListOf,OX)]
    }
    set LeTout {}
    set LesFT [FromMacsim $Nom ListOfFeatureType]
    foreach Access [FromMacsim $Nom ListOfNames] {
	set OX 0
	if {[info exists AAM($Nom,$Access,OX)]} { set OX $AAM($Nom,$Access,OX) }
	foreach FT $LesFT {
	    set LesFeatures [FromMacsim $Nom $FT $Access]
	    foreach Feature $LesFeatures {
		set LesV {}
		foreach {K V} [split $Feature " "] {
		    lappend LesV $V
		}
		set Valeurs [join $LesV "\t"]
		set Message "$Nom\t$OX\t$AccessReference\t$Access\t$Valeurs"
		lappend LeTout $Message
	    }
	}
    }
    set AAM($Nom,ListOf,All) [join $LeTout "\n"]
    #rR Pour ne pas mémoriser bêtement
    if { $Qui=="OnlyListOf" && $Quoi=="All" }  { set All $AAM($Nom,ListOf,All) ; unset AAM; return $All) } 
    if { $Qui=="ListOf" && $Quoi=="All" }  { return $AAM($Nom,ListOf,All) } 
    return [AllAboutMacsim $Nom $Qui $Quoi]
}


proc TestFromMacsim {} {
    Espionne [FromMacsim CIL007 Sequences G1PUE7_MYOLU]
    FromMacsim UnsetAll
    Espionne [FromMacsim CIL007 Sequences G1PUE7_MYOLU]
    FromMacsim CIL007 unset
    Espionne [FromMacsim CIL007 Sequences G1PUE7_MYOLU]
}

proc GlobalFromLocal {Seq Pos} {
    set L 0
    set G 0
    foreach C [split $Seq ""] {
	if {$C!="~" && $C!="-" && $C!="."} { incr L }
	incr G
	if {$L==$Pos} { return $G }
    }
    return 0
}

proc LocalFromGlobal {Seq Pos} {
    set L [string length [string map {"." "" "-" "" "~" ""} [string range $Seq 0 $Pos-1]]]
    return $L
}

proc FromMacsim {{Qui ""} {Quoi ""} {Quid ""}} {
    #LogWscope "FromMacsim =$Qui=$Quoi=$Quid="
    #rR Attention Laetita a elle un FromMacsims avec s
    #rR Mis à jour par Raymond 2022/03/14
    #rR FromMacsim permet d'interroger n'importe quel macsims au format XML
    #rR On utilise DecortiqueUnMacsimXml qui crée pleins de variables globales
    #rR La liste des variables globales existantes est accessible par
    #rR   FromMacsim FichierMacsims ListOfList
    #rR   FromMacsim FichierMacsims ListOfArray
    #rR On indexe tout par le nom du fichier ou par le MD5 du Texte xml s'il est fourni
    #rR Quand on interroge un Projet Gscope particulier (par exemple CilioCarta2014) le nom CIL123 suffit 
    #rR   FromMacsim CIL006 ListOfList             (rend la liste des listes qu'on peut interroger)
    #rR   FromMacsim CIL006 AlnName
    #rR   FromMacsim CIL006 LNOrdali
    #rR   FromMacsim CIL006 ListOfNames            (rend la liste des noms des sequences)
    #rR   FromMacsim CIL006 ListOfFeatureType
    #rR   FromMacsim CIL006 Sequences get          (rend la liste cle valeur cle valeur ...)
    #rR   FromMacsim CIL006 Sequences G1NTJ1_MYOLU (rend la sequence)  ....... les array sont créés à la première demande puis stockés ;)
    #rR   FromMacsim CIL006 LocalFromGlobal33 G1NTJ1_MYOLU     (rend la position local dans la sequence nogappee)
    #rR   FromMacsim CIL006 GlobalFromLocal33 G1NTJ1_MYOLU     (rend la position global dans l'alignement de la pos local)
    #rR   FromMacsim CIL006 SeqFromLocal8-12 G1NTJ1_MYOLU      (rend la sequence de 8 a 12 dans seq non gappee)
    #rR   FromMacsim CIL006 SeqFromGlobal20-45 G1NTJ1_MYOLU    (rend la sequence entre les pos globales de la seq non gappee)
    #rR   FromMacsim CIL006 SeqGapFromLocal8-12 G1NTJ1_MYOLU   (rend la sequence gappée des pos locales 8 a 12)
    #rR   FromMacsim CIL006 SeqGapFromGlobal20-45 G1NTJ1_MYOLU (rend la sequence gappée des pos globales 20 à 45)
    #rR   FromMacsim CIL006 BLOCK G1NTJ1_MYOLU                 (rend les features BLOCK)
    #rR Les couleurs sont valables pour tous les macsims ;)
    #rR   FromMacsim MacsimsColor           (rend la liste cle valeur cle valeur des Colorations utilisées)
    #rR   FromMacsim MacsimsColor names     (rend les cles des Colorations utilisées)
    #rR   FromMacsim MacsimsColor ConsGlob  (rend le couple foreground background pour les Conservation Globales)
    #rR   FromMacsim MacsimsColor Stock     (rend les couleurs utilisées pour les Features)
    #rR   FromMacsim MacsimsColor 4         (rend la quatrième couleur utilisée pour les Features)
    #rR On peut mettre un nom complet de fichier
    #rR   FromMacsim /ici/ou/la/toto.xml
    #rR ou pour tout projet Gscope
    #rR   FromMacsim ProjetGscope/Prefixe12345     (qui évite de mettre /genomics/link/ProjetGscope/macsimXml/Prefixe12345)
    #rR FIN HELP

    if {$Qui==""} { set Qui "Help" }

    global FromMacsim

    global Defauts Couleurs
    if { ! [info exists Couleurs] } {
	LesDefauts
	DefinitionPreferences
	set FromMacsim(MacsimsColor) [array get Couleurs]
    }
    if {$Qui=="MacsimsColor"} {
	if {$Quoi=="" || $Quoi=="get"} { return $FromMacsim(MacsimsColor) }
	if {$Quoi=="names"} { return [array names Couleurs] }
	if {[info exists Couleurs($Quoi)]} { return $Couleurs($Quoi) }
	if {[regexp {^[0-9]+$} $Quoi]} { return [lindex $Couleurs(Stock) $Quoi] }
	return ""
    }

    if { ! [info exists FromMacsim(PackageMD5Loaded)]} {
	package require md5
	set FromMacsim(PackageLoaded) 1
    }
    
    if {$Qui=="Help"} {
	set LeHelp {}
	foreach Ligne [split [info body FromMacsim] "\n"] {
	    if { ! [regexp " +#rR" $Ligne]} { continue }
	    lappend LeHelp $Ligne
	    if {[regexp " +#rR FIN HELP" $Ligne]} { break }
	}
	return [join $LeHelp "\n"]
    }
    
    if {$Qui=="UnsetAll"} {
	#array unset FromMacsim
	unset FromMacsim
	set FromMacsim(PackageLoaded) 1
	return ""
    }

    if {[regexp "\n" $Qui]} {
	set MD5 [::md5::md5 -hex $Qui]
    } else {
	set MD5 $Qui
    }
    if {$Quoi=="unset"} {
	if { ! [info exists FromMacsim($MD5,MD5)]} { return "" }
	foreach Arr $FromMacsim($MD5,ListOfMemArr) {
	    array unset $Arr
	}
	array unset FromMacsim "$MD5,*"
	return ""
    }
    #Espionne $MD5,$Quoi,$Quid
    #rR a mis le prochain test ici le  2017/12/29
    if {[info exists FromMacsim($MD5,$Quoi,$Quid)]} {
	return $FromMacsim($MD5,$Quoi,$Quid)
    }
    if {[info exists FromMacsim($MD5,$Quoi)]} {
	if {$Quid==""} {
	    return $FromMacsim($MD5,$Quoi)
	} else {
	    #rR Attention, là on fait un traitement spécial ... on crée les array à la demande et on les mémorise pour plus tard ;)
	    if {[info exists FromMacsim($MD5,$Quoi,$Quid)]} {
		return $FromMacsim($MD5,$Quoi,$Quid)
	    }
	    if {$Quid=="get"} { return $FromMacsim($MD5,$Quoi) }
	    #rR la suite n emarche pas !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	    if { 1 && ! [info exists FromMacsim($MD5,Array_$Quoi)]} {
		set Arr "Array_[::md5::md5 -hex Array_${Quoi}_$MD5]"
		lappend FromMacsim($MD5,ListOfMemArr) $Arr
		set FromMacsim($MD5,Array_$Quoi) $Arr
		global [set Arr]
#rR 20170112	set ::[set Arr]($Quid) $FromMacsim($MD5,$Quoi) ;#rR a verifier c'est louche !!!!!!!!!!je ne comprends plus !!!!!!!!!!!!!!!!!!!!!!!!
		#Espionne "$Quoi=$FromMacsim($MD5,$Quoi)="
		array set ::[set Arr] $FromMacsim($MD5,$Quoi)                 ;#rR il y avait array set ???????!!!!!!!!!!!
	    }
	    if {[info exists FromMacsim($MD5,Array_$Quoi)]} {
		set Arr $FromMacsim($MD5,Array_$Quoi)
		if {$Quid=="names"} { return [array names ::[set Arr]] }
		if {[info exists ::[set Arr]($Quid)]} { return [set ::[set Arr]($Quid)] }
		return ""
	    }
	    #rR ce qui précède ne marche pas !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	}
    }
    if {[info exists FromMacsim($MD5,$Quoi)]} { return $FromMacsim($MD5,$Quoi) }
    if {[info exists FromMacsim($MD5,EstCharge)]} {
	if {[regexp {(LocalFromGlobal)([0-9]+)} $Quoi Match What Pos] || [regexp {(GlobalFromLocal)([0-9]+)} $Quoi Match What Pos]} {
	    if {[set Seq [FromMacsim $MD5 Sequences $Quid]]!=""} {		
		if {$What=="GlobalFromLocal"} { return [GlobalFromLocal $Seq $Pos] }
		if {$What=="LocalFromGlobal"} { return [LocalFromGlobal $Seq $Pos] }
	    }
	}
	set Gap ""
	if {[regexp {(Seq(Gap)?FromGlobal)([0-9]+)\-([0-9]+)$} $Quoi Match What Gap Deb Fin] || [regexp {(Seq(Gap)?FromLocal)([0-9]+)\-([0-9]+)$} $Quoi Match What Gap Deb Fin]} {
	    #Espionne $What $Gap $Deb $Fin
	    if {[set Seq [FromMacsim $MD5 Sequences $Quid]]!=""} {
		regsub -all -nocase {[^a-z]} $Seq "" SeqNoGap
		if {$Gap==""} {  }
		if {$What=="SeqGapFromGlobal"} {
		    return  [string range "x$Seq" $Deb $Fin]
		}
		if {$What=="SeqFromGlobal"} {
		    set SeqVoulue [string range "x$Seq" $Deb $Fin]
		    regsub -all -nocase {[^a-z]} $SeqVoulue "" SeqVoulueNoGap
		    return $SeqVoulueNoGap
		}
		if {$What=="SeqFromLocal"} {
		    return [string range "x$SeqNoGap" $Deb $Fin]
		}
		if {$What=="SeqGapFromLocal"} {
		    if {$Fin>[string length $SeqNoGap]} { set Fin [string length $SeqNoGap] }
		    set D [GlobalFromLocal $Seq $Deb]
		    set F [GlobalFromLocal $Seq $Fin]
		    #Espionne $Seq
		    #Espionne $SeqNoGap
		    #Espionne 12345678901234567890
		    #Espionne $Deb $Fin
		    return [string range "x$Seq" $D $F]
		}
	    }
	}
	return ""
    }
    
    if {[regexp "\n" $Qui]} {
	set Xml $Qui
    } else {
	set Xml ""
	if {[FileExists $Qui]} {
	    set Xml [ContenuDuFichier $Qui]
	} elseif {[FileAbsent $Qui] && [file exists [GscopeFile $Qui "macsimXml"]]} {
	    set Qui [GscopeFile $Qui "macsimXml"]
	    set Xml [ContenuDuFichier $Qui]
	} elseif {[FileExists "[RepertoireDuGenome]/$Qui"]} {
	    set Xml [ContenuDuFichier "[RepertoireDuGenome]/$Qui"]
	} elseif {[regexp -nocase {^([^/]+)/(.+)$} $Qui Match Rep Pab]} {
	    if {[FileExists "/genomics/link/$Rep/macsimXml/$Pab"]} {
		set Xml [ContenuDuFichier "/genomics/link/$Rep/macsimXml/$Pab"]
	    }
	}
	if {$Xml==""} { return "" } 
    }
    set FromMacsim($MD5,MD5) $MD5
    set FromMacsim($MD5,EstCharge) 1

    if {[info exists ::TabSF]} { unset ::TabSF }             ;#rR Fait le 2017/04/07
    set MacsimsVariables [DecortiqueUnMacsimXml $Xml]
    lassign $MacsimsVariables LesL LesT
    foreach L $LesL {
	set FromMacsim($MD5,$L) [set ::$L]
    }
    foreach T $LesT {
	set FromMacsim($MD5,$T) [array get ::$T]
    }

    foreach {K V} [array get ::TDesAccess] {
	set FromMacsim($MD5,TDesAccess,$K) $V
    }
    set FromMacsim($MD5,ListOfList)  $LesL
    set FromMacsim($MD5,ListOfArray) $LesT
    set LesFeatureType {}
    foreach {K V} [array get ::TabSF] {
	if {0 && $K=="Amito_Homo.sapi"} { Espionne "$K\n$V" }
	foreach Feature $V {
	    if {[regexp { target [^ ]+ } $Feature]} {
		regsub { target [^ ]+ } $Feature " " Feature
	    }
	    set LesMots [split $Feature " "]
	    lassign $LesMots coord LG ftype FT fstart FStart fstop Fstop fcolor FColor fscore FScore fnote
	    set FNote [join [lrange $V 15 end] " "]
	    lappend LesFeatureType $FT
	    #lappend FromMacsim($MD5,$FT)    $Feature
	    lappend FromMacsim($MD5,$FT,$K) $Feature
	    #Espionne $MD5 $FT $K $Feature
	}
    }
    set FromMacsim($MD5,ListOfFeatureType) [lsort -unique $LesFeatureType]
    set FromMacsim($MD5,ListOfNames) $::LNOrdali
    lappend FromMacsim($MD5,ListOfList) ListOfFeatureType ListOfNames

    # attention on triche un peu là
    if {$Quoi=="MacsimsColor"} { return [FromMacsim $Quoi $Quid] }
    return [FromMacsim $MD5 $Quoi $Quid]
}

proc DecortiqueUnMacsimXml {FichierOuTexteXML} {
    # Repompe de DecortiqueUnMacsimXml2 qui est lui-même
    # Repompe de rR pour parsing de xml
    # fait tout d'un coup, plus de routines separées pour chaque chose
    
    # Initialisation des strings, listes et tableaux. Et mise en global 
    set MacsimsVariables [MacsimsVariables "Initialise"]
    lassign $MacsimsVariables LesL LesT
    foreach L $LesL { global $L }
    foreach T $LesT { global $T }

    
    if {[file exists $FichierOuTexteXML]} {
	set MacsimXml [ContenuDuFichier $FichierOuTexteXML]
	set FromOrdalie 1
    } else {
	set MacsimXml $FichierOuTexteXML
	set FromOrdalie 0
    }
    
    foreach e {eukaryota bacteria archaea viruses undefined} {
	set LesSequencesAssocieesClassesCanon($e) {}
    }
    
    # Caution !! MacsimXml is not a list, but a text string !!
    set DocMacsim   [dom parse $MacsimXml]
    set NoeudMacsim [$DocMacsim documentElement]
    

    unset -nocomplain LesSeqsDuGroupe
    
    # alignment header
    set NoeudAli [$NoeudMacsim selectNodes "alignment"]
    set AlnName  [$NoeudAli selectNodes "string(aln-name)"]
    set AlnScore [$NoeudAli selectNodes "string(aln-score)"]
    set AlnNote  [$NoeudAli selectNodes "string(aln-note)"]
    set TColScore(Names) [list]
    
    foreach NoeudLigne [$NoeudAli childNodes] {
	set NodeName [$NoeudLigne nodeName]
	if {[regexp {aln\-} $NodeName]} {
	    continue
	}
	if {[regexp {column\-} $NodeName]} {
	    DecortiqueColumnScore $NoeudLigne
	} else {
	    DecortiqueNoeudXml $NoeudLigne TabSF
	}
    }

    # Verifie qu'on n'a pas sequences en double !
    set Ltmp $LNOrdali
    set LNOrdali [list]
    foreach n $Ltmp {
	if {[string trim $n] eq ""} {continue}
	lappend LNOrdali $n
    }
    if {[llength $LNOrdali] != [llength [lsort -unique $LNOrdali]]} {
	set ld [DonneDoublons $LNOrdali]
	FaireLire "Beware !\nSeveral sequences have the same name :[join $ld]"
    }
    
    # XML est indexe par le seq-name. 
    # Ramene tous les tableaux a une indexation par
    # accession.
    #IndexationParAccess
    
    # premier grp = GroupeToutLeMonde
    InitPremierGroupe
    
    # Ajoute groupes du xml
    set Lg [ReordonneGroupes [array names LesSeqsDuGroupe]]
    if {[llength $Lg] > 1} {
	set LNDG [concat $LNDG $Lg]
	foreach g $Lg {
	    set LesSeqsDuGroupe($g) [lunique [set LesSeqsDuGroupe($g)]]
	    set SDG($g) [set LesSeqsDuGroupe($g)]
	}
    }

    $DocMacsim delete

    return $MacsimsVariables
}

proc ElimineLesMacsimsIncomplets {} {
    set Rep [RepertoireDuGenome]
    set I 0
    set N 0
    foreach Nom [ListeDesPABs] {
	if {([incr I]%100)==0} { Espionne "au $I eme il y a deja $N problemes" }
	if {0 && $Nom > "HSAP99999"} { break }
	set FLL "leonLog/$Nom"
	if {[FileAbsent $Rep/$FLL]} { continue } 
	set FLM "msfLeon/$Nom"
	set FLX "msfLeon/$Nom.xml"
	set FMX "macsimXml/$Nom"
	set FMR "macsimRsf/$Nom"
#	set NR [llength [glob -nocomplain "$Rep/$FMR*"]]
	if {[file exists $Rep/$FLM] && [file exists $Rep/$FLX] && [file exists $Rep/$FMX] \
		&& [file exists $Rep/$FMR]     && [file exists $Rep/$FMR.tfa] \
		&& [file exists $Rep/$FMR.txt] && [file exists $Rep/$FMR.html] \
		&& ! [file exists $Rep/$FMR.log]} { continue }
	incr N
	lappend LeBilan "$Nom [file exists $Rep/$FLM] [file exists $Rep/$FLX] [file exists $Rep/$FMX] [file exists $Rep/$FMR] [file exists $Rep/$FMR.tfa] [file exists $Rep/$FMR.txt] [file exists $Rep/$FMR.html]  [file exists $Rep/$FMR.log]"
    }
    set R [AfficheListe $LeBilan "AvecRetour"]
    foreach Ligne $R {
	scan $Ligne "%s" Nom
	foreach D [list msfLeon macsimXml macsimRsf leonLog] {
	    foreach F [glob -nocomplain "$Rep/$D/$Nom*"] {
		if {[OuiOuNonMemo "Ok to delete all wrong files in macsimXml macsimRsf leonLog msfLeon"]} {
		    file delete $F
		    Espionne "file delete $F"
		} else {
		    Espionne "file to delete $F"
		}
	    }
	}
    }
    return $R    
}

proc TailleDesTFAsDesCopains {} {
    foreach Nom [ListeDesPABs] {
	set FiTFAs [GscopeFile $Nom "tfasdescopains"]
	if {[FileAbsent $FiTFAs]} { incr C(-1) ; lappend T(-1) $Nom; continue } 
	set TFAs [ContenuDuFichier $FiTFAs]
	set N [regexp -all ">" $TFAs]
	if {  0 <= $N && $N <  1 } { incr C(0) ; lappend T(0) $Nom; continue }
	if {  1 <= $N && $N <  2 } { incr C(1) ; lappend T(1) $Nom; continue }
	if {  2 <= $N && $N <  3 } { incr C(2) ; lappend T(2) $Nom; continue }
	if {  3 <= $N && $N < 10 } { incr C(7) ; lappend T(7) $Nom; continue }
	set D 0
	set I 10
	while {$D < 500} {
	    incr D $I ;	set F $D ; incr F $I ; set M [expr ($D+$F)/2]
	    if {  $D <= $N && $N < $F } { incr C($M) ; lappend T($M) $Nom; break }
	}
    }
    foreach N [lsort -integer [array names C]] {
	if {$C($N) > 10 } {
	    lappend LeResultat "$N $C($N)"
	} else {
	    lappend LeResultat "$N $C($N) $T($N)"
	} 
    }
    AfficheListe $LeResultat
}

proc ClickDansSeq {K X Y} {
    set Id [$K find withtag current]

    set LesTags [$K gettags $Id]
    if {[llength $LesTags]>2} { FaireLire [join $LesTags "\n"] ; return }

    set NomSeq [lindex $LesTags 1]
    AfficheFetch $NomSeq
}

proc EntreDansSeq {K X Y} {
    global TitreOrigine
    set Id [$K find withtag current]
    set NomSeq [lindex [$K gettags $Id] 1]
    if {! [info exists TitreOrigine($K)] } {
	set TitreOrigine($K) [wm title [winfo toplevel $K]]
    }
    wm title [winfo toplevel $K] "$NomSeq [$K canvasx $X]"
}

proc SortDeSeq {K X Y} {
    global TitreOrigine
    wm title [winfo toplevel $K] [set TitreOrigine($K)]
}

proc CouleurDeLaLettre {Lettre {PourQui ""}} {
    global CouleurDuFond
    if {[regexp "HNR" [RepertoireDuGenome]]} {
	if { $Lettre == " " } { return "white" }
	if { $Lettre == "." } { return "white" }
	if { $PourQui == "PourExpo" } { return "grey" }
    } else {
	if { $Lettre == " " } { return $CouleurDuFond }
	if { $Lettre == "." } { return "grey" }
	if { $PourQui == "PourExpo" } { return "red" }
    }
    if {[regexp -nocase {[PAGST]} $Lettre]} { return "yellow"}
    if {[regexp -nocase {[DEQN]}  $Lettre]} { return "green"}
    if {[regexp -nocase {[KRH]}   $Lettre]} { return "blue"}
    if {[regexp -nocase {[ILMV]}  $Lettre]} { return "red"}
    if {[regexp -nocase {[FYW]}   $Lettre]} { return "pink"}
    if {[regexp -nocase {[CX]}    $Lettre]} { return "black"}
    Warne "$Lettre non colore"
    return "purple"
}

proc DessineMoiLesMSF Selection {
    global GalerieCourante
    global ExpoCourante
    global Memo

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

    CreeGalerie $GalerieCourante

    foreach FichierMSF [split $Selection " ,\n"] {
	set w [CreeImagette]
	DessineMoiUnMSF $FichierMSF $FichierMSF "" $w

	Espionne "[LargeurDe $w] [HauteurDe $w]"

	Expose $w
    }
}

proc DessineMoiUnMSF {TexteOuFichierMSF {NomDuFichierOrigine ""} {OnlyPDB "All"} {FenetreParent "NormalWindow"}} {
    global CouleurDuFond
    global DessinCourant
    global ScrollRectangleOriginal IdScrollRectangle
    global Memo
    global LesOrdresPourGif


#    if { ! [info exists CouleurDuFond]} { set CouleurDuFond "cadetblue" } 
    if { ! [info exists CouleurDuFond]} { set CouleurDuFond "white" } 

    if {[regexp "\n" $TexteOuFichierMSF]} {
	set MSF $TexteOuFichierMSF
    } else {
	if { ! [file exists $TexteOuFichierMSF]} { return "" }
	set MSF [ContenuDuFichier $TexteOuFichierMSF]
	if {$NomDuFichierOrigine==""} { set NomDuFichierOrigine $TexteOuFichierMSF }
    }

    set AvecTexte 0

    if {$OnlyPDB=="Ask"} {
	set OnlyPDB [ChoixParmi {"OnlyPDB" "All"}]
    }

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

    set PourGif ""
    if {$FenetreParent=="PourGif"} {
	set PourGif "PourGif"
    } else {
	if {$FenetreParent=="NormalWindow"} {
	    set w [NomDe "fenetre"]
	} else {
	    set w $FenetreParent
	}
    }

    set Nom [file tail $NomDuFichierOrigine]

    DecortiqueUnMSF $MSF LesSequencesDansLOrdre Sequences

    set LesBonnesSequencesDansLOrdre {}
    foreach NomSeq $LesSequencesDansLOrdre {
	if { $OnlyPDB && ! [EstUnPAB $NomSeq] && ! [EstUnAccessPDB $NomSeq] } { continue }
	lappend LesBonnesSequencesDansLOrdre $NomSeq
    }
    if {[llength $LesBonnesSequencesDansLOrdre]<2} {
	FaireLire "Only one sequence, no alignment to display."
	return ""
    }
    set LesSequencesDansLOrdre $LesBonnesSequencesDansLOrdre

    set NombreDeSequences [llength $LesSequencesDansLOrdre]
    set MaxLongueurSequence 0
    foreach NomSeq $LesSequencesDansLOrdre {
	set MaxLongueurSequence [Maxi $MaxLongueurSequence [string length [set Sequences($NomSeq)]]]
    }

    set Titre $NomDuFichierOrigine

    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 Winfo     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 Winfo     winfo
	set FonctionRejetteLaBoite "NeRejettePasLaBoite"
#	set w [NomDe board]
#	catch {destroy $w}
#	toplevel $w
#	wm title $w "$Titre"
#	wm iconname $w "$Titre"
	set K       $w.canvas
    }


    set LargeurDUneLettre 1
    set xDebut 0
    set xFin   [expr $MaxLongueurSequence*$LargeurDUneLettre]
#    incr xDebut -50
#    incr xFin    50
    set CanvaSizeX    [expr $xFin - $xDebut]
    set CanvaScroMinX [expr $xDebut]
    set CanvaScroMaxX [expr $xFin  ]
    set CanvaScreenX  $CanvaSizeX

    set HauteurDUneLettre [expr $LargeurDUneLettre*2]
    set yDebut 0
    set yFin   [expr $NombreDeSequences*$HauteurDUneLettre]
    set CanvaSizeY    [expr $yFin - $yDebut]
    set CanvaScroMinY [expr $yDebut]
    set CanvaScroMaxY [expr $yFin  ]
    set CanvaScreenY  [expr $CanvaSizeY]

    #rR ça devait exister pour expo, je l'aivasi commenté mais je préfère l'enlever quand même (2017/11/24)
    if {1} {
	if { [regexp "expo" $w] } {
	    set NormalCanvaScreenX $CanvaScreenX
	    set CanvaScreenX 300
	    set CanvaScreenY [expr round($CanvaSizeY*(1.0*$CanvaScreenX)/$CanvaSizeX)]
	    set Papa $w
	} else {
	    set KShSv   $w.grid
	    $Fram $w
	    $Fram $KShSv
	    set Papa    $KShSv
	}
    }

    set K [UnCanva $CanvaScreenX $CanvaScreenY $CanvaScreenX $CanvaScreenY]

    set i -1
    foreach NomSeq $LesSequencesDansLOrdre {
	incr i
	set Seq [set Sequences($NomSeq)]
	set lSeq [expr [string length $Seq]-1]
	for {set j $lSeq} {$j>=0} {incr j -1} {
	    if {[string index $Seq $j] != "."} { set lSeq $j ; break }
	}
	incr lSeq
	set SeqBlanc [string range $Seq 0 $lSeq]
	for {set j $lSeq} {$j < $MaxLongueurSequence} {incr j} {
	    append SeqBlanc " "
	}
	set PosMinY [expr $i*$HauteurDUneLettre] 
	set PosMaxY [expr $PosMinY+$HauteurDUneLettre]
	set PointEstBlanc 1
	if {[info exists OldCouleur]} { unset OldCouleur }
	set PosMinX 0
	set PosMaxX 0
	for {set j 0} {$j < $MaxLongueurSequence} {incr j} {
	    set Lettre [string index $SeqBlanc $j]
	    if { $Lettre != "." } { set PointEstBlanc 0 }
	    if { $PointEstBlanc && $Lettre == "." } { set Lettre " " }
	    if {1 || [regexp "expo" $w]} {
		set Couleur [CouleurDeLaLettre $Lettre PourExpo]
		if {($NomSeq=="QUERY_PROTEIN" || [EstUnPAB $NomSeq]) \
			&& $Lettre != "." && $Lettre != " " } {
		    set Couleur "black"
		}
		if {[info exists OldCouleur] && ($Couleur!=$OldCouleur || [expr $j==$MaxLongueurSequence-1])} {
		    $K create rect $PosMinX $PosMinY $PosMaxX $PosMaxY \
			    -tags [list "Lettre"] \
			    -outline $OldCouleur \
			    -fill $OldCouleur
		    set PosMinX $PosMaxX
		}
		set OldCouleur $Couleur
		incr PosMaxX $LargeurDUneLettre
		continue
	    } else {
		set PosMinX [expr $j*$LargeurDUneLettre] 
		set PosMaxX [expr $PosMinX+$LargeurDUneLettre]
		set Couleur [CouleurDeLaLettre $Lettre]
		$K create rect $PosMinX $PosMinY $PosMaxX $PosMaxY \
			-tags [list "Lettre"] \
			-outline $Couleur \
			-fill $Couleur
		
		if { $AvecTexte} { 
		    set TxtCenX 0
		    set TxtCenY 0
		    set PosTxtX [expr ($PosMinX+$PosMaxX)/2 + $TxtCenX]
		    set PosTxtY [expr ($PosMinY+$PosMaxY)/2 + $TxtCenY]
		    if {[YaPABdans $NomSeq]} {
			set CouleurTxt "black"
			set FonteTxt {Courier 11}
		    } else {
			set CouleurTxt "black"
			set FonteTxt {Courier 10}
		    }
		    $K create text $PosTxtX $PosTxtY\
			    -tags [list "Texte" "$NomSeq"] \
			    -text $Lettre \
			    -anchor c \
			    -fill $CouleurTxt \
			    -font $FonteTxt
		}
	    }
	}
	if {$PourGif} {
	    set LesTags [list "WebClic" "tembl:$NomSeq"]
	    set Couleur $CouleurDuFond
	} else {
	    set LesTags [list "Seq" "$NomSeq"]
	    set Couleur ""
	}
	$K create rect $CanvaScroMinX $PosMinY $CanvaScroMaxX $PosMaxY \
		-tags $LesTags \
		-outline $Couleur \
		-fill $Couleur
    }

    if {$PourGif} { return $LesOrdresPourGif }

    if {1} {
 	set Clavier "[$Winfo parent $K].buttons"
	TouchePour $Clavier NouvelleGamme
	TouchePour $Clavier NouvelleCouleur "lightgrey"
	TouchePour $Clavier "Description"       "AfficheLesDescriptifs $NomDuFichierOrigine MemeOrdre"
	TouchePour <2>      "/all"              "AfficheLesDescriptifs $Nom                 Natif"
	TouchePour $Clavier "Taxonomy"          "DessineMoiLaTaxonomy  $NomDuFichierOrigine $NomDuFichierOrigine {} {} $HauteurDUneLettre same"
	TouchePour <2>      "/all"              "AfficheLesDescriptifs $Nom                 Natif     {} {} {OX OC} $Nom"
	TouchePour <3>      "/page"             "AfficheLesDescriptifs $NomDuFichierOrigine MemeOrdre {} {} {OX OC} $Nom"
    }

    if { [regexp "expo" $w]} { 
	$K bind all <1>   "DessineMoiUnMSF $MSF $NomDuFichierOrigine $OnlyPDB NormalWindow" 
	$K scale all 0 0  [expr (1.0*$CanvaScreenX)/$NormalCanvaScreenX] [expr (1.0*$CanvaScreenX)/$NormalCanvaScreenX] 
	set Memo(LargeurDe$w) [expr $CanvaScreenX+20]
	set Memo(HauteurDe$w) [expr $CanvaScreenY+20]
    } else {
	$K bind "Seq" <1>       "ClickDansSeq $K %x %y"
	$K bind "Seq" <Enter>   "EntreDansSeq $K %x %y"
	$K bind "Seq" <Leave>   "SortDeSeq $K %x %y"
	set DessinCourant $K
    }

    if {$PourGif} { return $LesOrdresPourGif }
    return $w
}

proc TestDecortiqueUnRSF {} {
    set n [DecortiqueUnRSF "/genomics/link/CilioCarta2014/macsimRsf/CIL006" LesName Sequences TabRSF "" "AvecBornesLocales"]

    foreach Name $LesName {
	Espionne "name $Name [set TabRSF($Name,group)]"
	set LesTypes [set TabRSF($Name,LesTypesDeFeatures)]
	foreach Type $LesTypes {
		Espionne "\nPour $Name : Type $Type"
		EspionneL [set TabRSF($Name,Type,$Type)]
	}
    }

    Espionne $TabRSF($Name,LesClefs)
    exit
}

proc CouleurSeqlab X {
    global CouleurSeqlab
    global CouleurSeqlabLower
    if { ! [info exists CouleurSeqlab]} {
	set CouleurSeqlab [list ForestGreen Orange Magenta Red \
		SkyBlue LimeGreen Blue Purple Black \
		Grey30 Grey50 Grey65 Grey80 Grey90 Grey95 White Pink \
		orangeRed LightBlue yellow green tomato cyan brown lightGreen fireBrick darkOrange \
		goldenRod seagreen coral \
		violet khaki navyblue salmon sienna turquoise darkgreen maroon springgreen \
		mediumblue indianred dimgray light gray gray]
	set LesCouples {}
	set I 0 
	foreach Couleur $CouleurSeqlab {
	    incr I
	    lappend CouleurSeqlabLower [string tolower $Couleur]
	    lappend LesCouples "$I $Couleur"
	}
    }

    if {$X=="LaListeDesCouplesMerci"} { return $LesCouples }
    if {$X=="LaListeMerci"} { return $CouleurSeqlab }
    if {[regexp -nocase {[A-Z]} $X]} {
	set X [string tolower $X]
	return [lsearch $CouleurSeqlabLower $X]
    } else {
	set Couleur [lindex $CouleurSeqlab $X] 
	if {$Couleur=="" } { set Couleur "Red" }
	return $Couleur
    }
}

proc FeatureSequence Seq {
    #rR on cree une list BeforeSeq 1 3, Seq_1 4 8, Gap_1 8 12, Seq_2 13 20, AfterSeq 20 30
    set DansEntame 1
    set DansQueue 0
    set FinEntame 0
    set LesFeatures {}
    set I 0
    set L 0
    set DebCourant 1
    set DebLocal 0
    set FinLocal 0
    foreach AA [split $Seq ""] {
	incr I
	set IsSeq [regexp -nocase {[a-z]} $AA]
	if {$IsSeq} { incr L ; incr FinLocal }
	if { ! [info exists WasSeq]} { set WasSeq [expr ! $IsSeq] }
	if { $IsSeq==$WasSeq } { incr FinCourant ; set WasSeq $IsSeq; continue }
	if {[info exists FinCourant]} { lappend LesFeatures "$WasSeq $DebCourant $FinCourant $DebLocal $FinLocal" }
	set DebCourant $I
	set FinCourant $I
	set DebLocal $L
	set FinLocal $L
	set WasSeq $IsSeq
    }
    if { ! [info exists WasSeq]} { return {} }
    lappend LesFeatures "$WasSeq $DebCourant $FinCourant $DebLocal $FinLocal"
    set LesFeatureSequence {}
    set NS 0
    set NG -1
    set Last [llength $LesFeatures]
    set I 0
    set L 0
    foreach F $LesFeatures {
	incr I
	scan $F "%d %d %d %d %d" T D F DL FL
	if {$T==1} { incr NS ; incr L; lappend LaFeatureSequence "Seq_$NS $D $F $DL $FL"   ; continue } 
	if {$NS==0} {
	    if {$NG==-1} { lappend LaFeatureSequence "BeforeSeq $D $F $DL $FL" ; set NG 0; continue }
	} else {
	    incr NG
	    if {$I==$Last} {
		lappend LaFeatureSequence "AfterSeq $D $F $DL $FL"
	    } else {
		lappend LaFeatureSequence "Gap_$NG $D $F $DL $FL"
	    }
	}
    } 
    return $LaFeatureSequence 
}

proc DuRSF {TexteOuFichierRSF Quoi} {
    set N [DecortiqueUnRSF $TexteOuFichierRSF LesNomsDesSequencesDansLOrdre Sequences TabRSF "" "AvecBornesLocales"]
    set TabRSF(N) $N
    if {[info exists TabRSF($Quoi)]} { return $TabRSF($Quoi) }
    return "NExistePas"
}

proc RsfFromRsf {TexteOuFichierRSF {LesAccess ""} {KeepOrReject ""}} {
    if {$KeepOrReject==""} { set KeepOrReject "Keep" }
    set Keep   [string equal -nocase "Keep" $KeepOrReject]
    if {[regexp {[ \t\n\,\;]} $LesAccess]} {
	regsub -all {[ \t\n\,\;]+} $LesAccess " " LesAccess
	set LesAccess [split [string trim $LesAccess]]
    }
    set LesACCESS {}
    foreach Access $LesAccess {
	lappend LesACCESS [string toupper $Access]
    }
    if {[regexp "\n" $TexteOuFichierRSF]} {
	set LesLignes [split $TexteOuFichierRSF "\n"]
	set FichierRSF "RSF"
    } else {
	set FichierRSF $TexteOuFichierRSF
	set LesLignes [LesLignesDuFichier $FichierRSF]
    }
    if {[llength $LesLignes] < 2} { return "" }    

    set OnAttend 1
    set LeCourant {}
    foreach Ligne $LesLignes {
	if {$OnAttend && [string index $Ligne 0]!="\{"} { continue }
	set OnAttend 0
	lappend LeCourant $Ligne
	if {[regexp {^name (.+)$} $Ligne Match Access]} {
	    set ACCESS [string toupper $Access]
	    if {[info exists DejaVu($ACCESS)]} { FaireLire "DejaVu $Access !!!\nTant pis, le dernier sera le bon" }
	    set DejaVu($ACCESS) $Ligne
	    continue
	}
	if {[string index $Ligne 0]=="\}"} {
	    lappend LesAccessExistants $ACCESS
	    set LesLignesDe($ACCESS) $LeCourant
	    set LeCourant {}
	}
    }
    set LeNew ""
    lappend LeNew "!!RICH_SEQUENCE 1.0"
    lappend LeNew ".."
    if {$Keep} {
	set LesAccessAGarder $LesACCESS
    } else {
	set LesAccessAGarder [ListsComplement $LesAccessExistants $LesACCESS]
    }
    foreach Access $LesAccessAGarder {
	set ACCESS [string toupper $Access]
	if { ! [info exists LesLignesDe($ACCESS)]} { continue }
	LConcat LeNew $LesLignesDe($ACCESS)
    }
    return [join $LeNew "\n"]
}

proc DecortiqueUnRSF {TexteOuFichierRSF \
			  {aLesNomsDesSequencesDansLOrdre ""} {aSequences ""} \
			  {aTabRSF ""} {LesClefs ""} {AvecBornesLocales ""}} {
    if {$aLesNomsDesSequencesDansLOrdre!=""} { upvar $aLesNomsDesSequencesDansLOrdre LesNomsDesSequencesDansLOrdre }
    if {$aSequences                    !=""} { upvar $aSequences Sequences }
    if {$aTabRSF                       !=""} { upvar $aTabRSF TabRSF }

    #rR J'ai changé le défaut 2015/03/31
    if {$AvecBornesLocales!=0} { set AvecBornesLocales 1 } else { set AvecBornesLocales 0 } 
 
    set LesNomsDesSequencesDansLOrdre {}

    if {[regexp "\n" $TexteOuFichierRSF]} {
	set LesLignes [split $TexteOuFichierRSF "\n"]
	set FichierRSF "RSF"
    } else {
	set FichierRSF $TexteOuFichierRSF
	set LesLignes [LesLignesDuFichier $FichierRSF]
    }

    if {[llength $LesLignes] < 2} { return 0 }

    if {$LesClefs==""} { set LesClefs [list "name" "sequence" "type" "group" "feature" "descrip" "creator"] }
    set ClefAvecListe(feature) 1
    foreach Clef $LesClefs {
	set ClefVoulue($Clef) 1
    }

    foreach Ligne $LesLignes {
	if {[regexp {^!!RICH_SEQUENCE}      $Ligne]} { continue }
	if {[regexp {^(\{|\}|\.\.)}         $Ligne]} { continue }
	if { ! [regexp -nocase {[\.a-z0-9]} $Ligne]} { continue }
	if {[regexp  -nocase {^[a-z]} $Ligne]} {
	    scan $Ligne "%s" Clef
	    set Clef [string tolower $Clef]
	    set Valeur [StringSuivant "$Clef " dans $Ligne]
	    if {$Clef=="name"} {
		#lm ajoute BonAccess et le string trim
		set NameCourant [BonAccess [string trim $Valeur]]
		lappend LesName $NameCourant
		set NumeroDeClef 0
	    }
	    if { ! [info exists ClefVoulue($Clef)]} { continue }
	    if { ! [info exists ClefDejaVue($NameCourant,$Clef)]} {
		set TabRSF($NameCourant,ListeDes,$Clef) {}
	    }
	    if {[info exists ClefAvecListe($Clef)]} {
		incr NumeroDeClef
		set ClefCourante "${Clef}_$NumeroDeClef"
	    } else {
		set ClefCourante $Clef
	    }
	    lappend TabRSF($NameCourant,ListeDes,$Clef) $ClefCourante
	    set ClefDejaVue($NameCourant,$Clef) 1
	    set TabRSF($NameCourant,$ClefCourante) {}
	    regsub $Clef $Ligne "" Ligne
	}
	if { ! [info exists ClefVoulue($Clef)]} { continue }
	set Valeur [string trim $Ligne]
	if {$ClefCourante=="sequence"} {
	    set Valeur [string trim $Valeur]
	    if { ! [info exist TabRSF($NameCourant,$ClefCourante)]} { set TabRSF($NameCourant,$ClefCourante) "" } 
	    append TabRSF($NameCourant,$ClefCourante) $Valeur
	} else {
	    lappend TabRSF($NameCourant,$ClefCourante) $Valeur
	}
	continue
    }
    set TabRSF(LesTypesDeFeatures) {}
    foreach Name $LesName {
	set Seq [join $TabRSF($Name,sequence) ""]
	set Seq [BonneSequencePourAlignement $Seq] ;#rR sur demande de Luc 2012/12/18			
	set Sequences($Name) $Seq
	set TabRSF($Name,LesTypesDeFeatures) {}

	if { ! [info exists TabRSF($Name,ListeDes,feature)]} {
	    set TabRSF($Name,ListeDes,feature) {}
	}
	set FeatureSequence [FeatureSequence $Seq]
	foreach TDF $FeatureSequence {
	    scan $TDF "%s %d %d %d %d" T D F DL FL
	    if { ! [regexp "^Seq" $T]} { continue } ;#rR on n'affiche que la sequence et pas les gaps !!!!!!!
	    set LastFeature [lindex $TabRSF($Name,ListeDes,feature) end]
	    if {$LastFeature==""} {
		set Feature "feature_1"
	    } else {
		set NLast 0
		regexp {feature_([0-9]+)} $LastFeature Match NLast
		incr NLast
		set Feature "feature_$NLast"
	    }
	    lappend TabRSF($Name,ListeDes,feature) $Feature
	    if {[regexp "^Before" $T]} { set C [CouleurSeqlab White] }
	    if {[regexp "^After"  $T]} { set C [CouleurSeqlab White] }
	    if {[regexp "^Seq"    $T]} { set C [CouleurSeqlab Grey80] }   ;#rR il y avait 50
	    if {[regexp "^Gap"    $T]} { set C [CouleurSeqlab Grey90] }   ;#rR il y avait 80
	    set TabRSF($Name,$Feature) [list "$D $F $C square solid SEQUENCE" "FT SEQUENCE $DL $FL  $T"]
	}

	foreach Feature [set TabRSF($Name,ListeDes,feature)] {
	    set DonneesDuFeature [lindex [set TabRSF($Name,$Feature)] 0]
	    scan $DonneesDuFeature "%d %d %d %s %s %s" D F C Forme EmptyFull FeatureType
	    set Couleur [CouleurSeqlab $C]
	    if { ! [info exists DejaVuCeTypeDeFeature($FeatureType)]} {
		set DejaVuCeTypeDeFeature($FeatureType) 1
		lappend TabRSF(LesTypesDeFeatures) $FeatureType 
	    }
	    set SequencePointee [set Sequences($Name)]
	    if {$AvecBornesLocales} {
		set BornesLocales [BornesLocales $SequencePointee $D $F]
	    } else {
		set BornesLocales "$D $F"
	    }
	    scan $BornesLocales "%d %d" DL FL
	    if { ! [info exists TabRSF($Name,Type,$FeatureType)]} {
		            set TabRSF($Name,Type,$FeatureType) {}
		lappend TabRSF($Name,LesTypesDeFeatures) $FeatureType
	    }
	    lappend TabRSF($Name,Type,$FeatureType) "$D $F $DL $FL $Couleur $Forme $EmptyFull \
		    [lrange [set TabRSF($Name,$Feature)] 1 end]"
	}
    }
    set LesNomsDesSequencesDansLOrdre $LesName
    set TabRSF(LesNomsDesSequences) $LesNomsDesSequencesDansLOrdre
    return [llength $LesName]
}

proc CanvaVirtuel {args} {
    #rR utilisé pour envoyer les ordres de Canva vers http par exemple (DessineMoiUnRSF)
    global CanvaVirtuel
    
    set Commande [lindex $args 0]

    if {[regexp "GetActions" $Commande]} { set Actions [join $CanvaVirtuel "\n"] }
    if {[regexp "Reset"      $Commande] && [info exists CanvaVirtuel]} { unset CanvaVirtuel }
    if {[regexp "GetActions" $Commande]} { return $Actions }
    if {[regexp "Reset"      $Commande]} { return "" }

    lappend CanvaVirtuel [join $args " "]
    return ""
}

proc GetOrderOfAlignment {TexteOuNomOuFichierRSF {WhichOne ""}} {
    set Order [DessineMoiUnRSF $TexteOuNomOuFichierRSF "" "" "GetOrder"]
    if {$WhichOne==""} { set WhichOne "Normal" }
    if {[regexp -nocase "Alpha" $WhichOne]} { set Order [lsort -dictionary $Order] }
    if {[regexp -nocase "Rever" $WhichOne]} { set Order [lreverse $Order] }
    if {[regexp {[0-9]+} $WhichOne Match]}  { set Order [lrange $Order 0 [incr Match -1]] }
    return $Order
}

proc DessineMoiUnRSF {TexteOuNomOuFichierRSF {NomDuFichierOrigine ""} {FenetreParent ""} {AboutOrder ""} {WithSeq ""}} {
    global CouleurDuFond
    global DessinCourant
    global ScrollRectangleOriginal IdScrollRectangle
    global Memo
    global LesOrdresPourGif
    #rR a rajouté WithSeq pour permettre de passer la séquence pour chaque feature (dans les Tags)
    set WithSeq [regexp -nocase "WithSeq" $WithSeq]

    #rR FenetreParent can be a window name, NormalWindow, PourGif or PourCanVir

    #rR AboutOrder permet de rendre l'ordre ou d'imposer un nouveau (les index séparés par un blanc)
    set NewOrder ""
    set GetOrder 0
    if {$AboutOrder!=""} {
	set GetOrder [string equal -nocase $AboutOrder "GetOrder"]
	if { ! $GetOrder } {
	    regsub -all {[ \t\n,;]+} $AboutOrder " " AboutOrder
	    set NewOrder [split [string trim $AboutOrder] " "]
	}
    }

    if {[PourWscope] && $FenetreParent==""} { set FenetreParent "PourCanVir" }
    if {                $FenetreParent==""} { set FenetreParent "NormalWindow" }
    set AvecTexte 0
    set PourGif 0
    set PourCanVir 0

    if {$FenetreParent=="PourGif"} {
	set PourGif 1
    } elseif {$FenetreParent=="PourCanVir"} {
	CanvaVirtuel "Reset"
	set PourCanVir 1
    } else {
	if {$FenetreParent=="NormalWindow"} {
	    set w [NomDe fenetre]
	} else {
	    set w $FenetreParent
	}
    }

    if { ! [info exists CouleurDuFond]} { set CouleurDuFond "cadetblue" } 

    set RSF ""
    if {[regexp "\n" $TexteOuNomOuFichierRSF]} {
	set FichierRSF "RSF"
	set RSF $TexteOuNomOuFichierRSF
    } else {
	if {[regexp {\.msf$} $TexteOuNomOuFichierRSF]} {
	     regsub {\.msf$} $TexteOuNomOuFichierRSF "" TexteOuNomOuFichierRSF
	}
	set FichierRSF $TexteOuNomOuFichierRSF
	set Queue [file tail $TexteOuNomOuFichierRSF]
	if {[EstUnPAB $Queue]} {
	    set FichierRSF "[RepertoireDuGenome]/rsf/$Queue.rsf"
	    if { ! [file exists $FichierRSF]} {
		set FichierRSF "[RepertoireDuGenome]/rsf/$Queue"
	    }
	    if { ! [file exists $FichierRSF]} {
		set FichierRSF "[RepertoireDuGenome]/macsimRsf/$Queue.rsf"
	    }
	    if { ! [file exists $FichierRSF]} {
		set FichierRSF "[RepertoireDuGenome]/macsimRsf/$Queue"
	    }
	    if { ! [file exists $FichierRSF]} {
		set FichierRSF $TexteOuNomOuFichierRSF
	    }
	}
	if {[file exists $FichierRSF]} {
	    set RSF [ContenuDuFichier $FichierRSF]
	}
    }
    if { ! [regexp {^!!RICH} $RSF]} { return "" }
    if {$NomDuFichierOrigine==""} { set NomDuFichierOrigine $FichierRSF }


    set Nom [file tail $NomDuFichierOrigine]

    set NombreDeSequences [DecortiqueUnRSF $RSF LesSequencesDansLOrdre Sequences TabRSF "" "AvecBornesLocales"]

    if {$GetOrder} { return $LesSequencesDansLOrdre }
    if {$NewOrder!=""} { set LesSequencesDansLOrdre $NewOrder }
    set MaxLongueurSequence 0
    foreach NomSeq $LesSequencesDansLOrdre {
	set MaxLongueurSequence [Maxi $MaxLongueurSequence [string length [set Sequences($NomSeq)]]]
    }
#parray Sequences

    set Titre $NomDuFichierOrigine

    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 Winfo     NeRienFaire
	set FonctionRejetteLaBoite "RejetteLaBoite"
	set LesOrdresPourGif {}
	set w "PourGif"
	set K "OrdrePourGif"
    } elseif {$PourCanVir} {
	CanvaVirtuel CanVir $NomDuFichierOrigine 
	set Canvas    NeRienFaire
	set Bind      NeRienFaire
	set Pack      NeRienFaire
	set Fram      NeRienFaire
	set Button    NeRienFaire
	set Scrollbar NeRienFaire
	set Grid      NeRienFaire
	set Winfo     NeRienFaire
	set FonctionRejetteLaBoite "RejetteLaBoite"
	set w "PourCanVir"
	set K "CanvaVirtuel"
    } 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 Winfo     winfo
	set FonctionRejetteLaBoite "NeRejettePasLaBoite"
	set K "ToCreate"
    }


    set LargeurDUneLettre 1
    set xDebut 0
    set xFin   [expr $MaxLongueurSequence*$LargeurDUneLettre]
#    incr xDebut -50
#    incr xFin    50
    set CanvaSizeX    [expr $xFin - $xDebut]
    set CanvaScroMinX [expr $xDebut]
    set CanvaScroMaxX [expr $xFin  ]
    #set CanvaScreenX  $CanvaSizeX
    set CanvaScreenX  1200

    set HauteurDUneLettre [expr $LargeurDUneLettre*2]
    set yDebut 0
    set yFin   [expr $NombreDeSequences*$HauteurDUneLettre]
    set CanvaSizeY    [expr $yFin - $yDebut]
    set CanvaScroMinY [expr $yDebut]
    set CanvaScroMaxY [expr $yFin  ]
    set CanvaScreenY  [expr $CanvaSizeY]

    if { [regexp "expo" $w] } {
	set NormalCanvaScreenX $CanvaScreenX
	set CanvaScreenX 300
	set CanvaScreenY [expr round($CanvaSizeY*(1.0*$CanvaScreenX)/$CanvaSizeX)]
	set Papa $w
    }

    if { ! $PourGif && ! $PourCanVir} {
	set K [UnCanva $CanvaScroMaxX $CanvaScroMaxY $CanvaScreenX $CanvaScreenY "GonfleY" $NomDuFichierOrigine]
    }

    set IdCadre [$K find withtag "Cadre"]
    $K itemconfigure $IdCadre -fill "white"

    if {0} {
	foreach Key [array names TabRSF] {
	    if { ! [regexp KAD7_HUMAN $Key]} { continue }
	    Espionne "$Key $TabRSF($Key)"
	}
	exit
    }


    set i -1
    foreach NomSeq $LesSequencesDansLOrdre {
	incr i
	set PosMinY [expr $i*$HauteurDUneLettre] 
	set PosMaxY [expr $PosMinY+$HauteurDUneLettre]
	set TextSeq $NomSeq 
	if {[info exists TabRSF($NomSeq,creator)]} {
	    append TextSeq " [join [set TabRSF($NomSeq,creator)] " "]"
	}
	if {[info exists TabRSF($NomSeq,descrip)]} {
	    append TextSeq " [join [set TabRSF($NomSeq,descrip)] " "]"
	}
	if {[info exists TabRSF($NomSeq,group)]} {
	    append TextSeq " MacsimsCluster [join [set TabRSF($NomSeq,group)] { }]"
	}
	foreach FeatureType [set TabRSF($NomSeq,LesTypesDeFeatures)] {
	    if {[info exists TabRSF($NomSeq,Type,$FeatureType)]} {
		foreach Donnee [set TabRSF($NomSeq,Type,$FeatureType)] {
		    scan $Donnee "%d %d %d %d %s %s %s" D F dL fL Couleur Forme EmptyFull
		    set XduD [expr $D-1]
		    set XduF [expr $F]
		    set LesTags [list "Seq" $TextSeq $FeatureType $Donnee]
		    if {$WithSeq} {
			set S [string range $Sequences($NomSeq) $XduD $XduF-1]   ;#rR pas sûr du -1
			lappend LesTags $S
		    }
		    $K create rect $XduD $PosMinY $XduF $PosMaxY \
				-tags $LesTags \
				-outline $Couleur \
				-fill $Couleur
		}
	    }
	}
	set SeqGlob $Sequences($NomSeq)
	regsub -all {\.}  $SeqGlob "" SeqLoc
	regsub {^\.+} $SeqGlob "" SeqGlobD
	set D [expr [string length $SeqGlob]-[string length $SeqGlobD]+1]
	regsub {\.+$} $SeqGlobD "" SeqGlobDF
	set Q [expr [string length $SeqGlobD]-[string length $SeqGlobDF]+1]
	set F [expr $MaxLongueurSequence - $Q]
	set XduD [expr $D-1]
	set XduF $F
	set LongLoc [string length $SeqLoc]
	set Couleur "Grey75"
	set Form "square"
	set EmptyFull "solid"
	set Donnee "$D $F 1 $LongLoc $Couleur $Form $EmptyFull"
	set LesTags [list "GlobSeq" $TextSeq GLOBALSEQ $Donnee]
	if {1 && $WithSeq} {
	    lappend LesTags $SeqGlobDF
	}
	$K create rect $XduD $PosMinY $XduF $PosMaxY  \
	    -tags $LesTags \
	    -outline $Couleur \
	    -fill $Couleur
	lappend TabRSF($NomSeq,LesTypesDeFeatures) "GLOBALSEQ"

	if {$PourCanVir} {
	    set Couleur "transparent"
	    set Form "square"
	    set EmptyFull "solid"
	    set Donnee "$D $F 1 $LongLoc $Couleur $Form $EmptyFull"
	    set LesTags [list "ShowSequence" $TextSeq SHOWSEQUENCE $Donnee]
	    if {1 && $WithSeq} {
		lappend LesTags $SeqGlobDF
	    }
	    $K create rect $XduD $PosMinY $XduF $PosMaxY  \
		-tags $LesTags \
		-outline $Couleur \
		-fill $Couleur
	    lappend TabRSF($NomSeq,LesTypesDeFeatures) "SHOWSEQUENCE"
	    set TabRSF($NomSeq,WholeSeq) $Sequences($NomSeq)
	}
    }
    lappend TabRSF(LesTypesDeFeatures) "GLOBALSEQ"
    if {$PourCanVir} { lappend TabRSF(LesTypesDeFeatures) "SHOWSEQUENCE" }
    if {$PourCanVir} { return [CanvaVirtuel "GetActionsAndReset"] }  
    if {[info exists GrosBoutons]} {
	set Boutons "[$Winfo parent $K].buttons"
	foreach FeatureType $TabRSF(LesTypesDeFeatures) {
	    $Button $Boutons.t_$FeatureType -text "$FeatureType/lower/clear"
	    $Bind   $Boutons.t_$FeatureType <1> "$K raise $FeatureType"
	    $Bind   $Boutons.t_$FeatureType <2> "$K lower $FeatureType"
	    $Bind   $Boutons.t_$FeatureType <3> "$K lower $FeatureType Cadre"
	    $Pack   $Boutons.t_$FeatureType -side left -expand 1
	}
    } else {
	set Clavier "[$Winfo parent $K].buttons"
	TouchePour $Clavier NouvelleGamme
	TouchePour $Clavier NouvelleCouleur "lightgrey"
	TouchePour $Clavier "Description"       "AfficheLesDescriptifs $NomDuFichierOrigine MemeOrdre"
	TouchePour <2>      "/all"              "AfficheLesDescriptifs $Nom                 Natif"
	TouchePour $Clavier "Taxonomy"          "DessineMoiLaTaxonomy  $NomDuFichierOrigine $NomDuFichierOrigine {} {} $HauteurDUneLettre same"
	TouchePour <2>      "/all"              "AfficheLesDescriptifs $Nom                 Natif     {} {} {OX OC} $Nom"
	TouchePour <3>      "/page"             "AfficheLesDescriptifs $NomDuFichierOrigine MemeOrdre {} {} {OX OC} $Nom"
	TouchePour $Clavier "BilanCilioCarta"   "AfficheBilanCilioCarta $NomDuFichierOrigine"
	set LesTypesDeFeatures $TabRSF(LesTypesDeFeatures)
	set N [llength $LesTypesDeFeatures]
	set BoutonsParClavier [Maxi 3 [expr $N/4]]
	set nBoutons 0
	set PremiereFois 1
	foreach FeatureType $LesTypesDeFeatures {
	    if {$nBoutons%$BoutonsParClavier==0} {
		TouchePour $Clavier NouvelleGamme
		TouchePour $Clavier NouvelleCouleur "green"
		if {$PremiereFois} {
		    TouchePour $Clavier "Clear all" "$K raise Cadre"
		    set PremiereFois 0
		    incr nBoutons
		}
	    }
	    TouchePour $Clavier "$FeatureType" "$K raise $FeatureType"
	    TouchePour <2>      "/low"         "$K lower $FeatureType"
	    TouchePour <3>      "/off"         "$K lower $FeatureType Cadre"
	    incr nBoutons
	}
    }

    if {$PourGif} { return $LesOrdresPourGif }
 
    if { [regexp "expo" $w]} { 
	$K bind all <1>   "DessineMoiUnRSF $RSF $NomDuFichierOrigine NormalWindow" 
	$K scale all 0 0  [expr (1.0*$CanvaScreenX)/$NormalCanvaScreenX] [expr (1.0*$CanvaScreenX)/$NormalCanvaScreenX] 
	set Memo(LargeurDe$w) [expr $CanvaScreenX+20]
	set Memo(HauteurDe$w) [expr $CanvaScreenY+20]
    } else {
	$K bind "Seq" <1>       "ClickDansSeq $K %x %y"
	$K bind "Seq" <Enter>   "EntreDansSeq $K %x %y"
	$K bind "Seq" <Leave>   "SortDeSeq $K %x %y"
	set DessinCourant $K
    }

    if {$PourCanVir} { return [CanvaVirtuel "GetActionsAndReset"] }
    if {$PourGif} { return $LesOrdresPourGif }
    return $w
}

proc DifferentColor {{GetWhat ""}} {
    global DifferentColor

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

    set GetWhat [string toupper $GetWhat]

    if {$GetWhat=="RESET"} {
	if {[info exists DifferentColor]} { unset DifferentColor }
	return ""
    }
    #rR on utilise un angle pour Hue 
    if { ! [info exists DifferentColor(Ang)]} { set DifferentColor(Ang) -137.5 }
    if { ! [info exists DifferentColor(Sat)]} { set DifferentColor(Sat) 1.0 }
    if { ! [info exists DifferentColor(Bri)]} { set DifferentColor(Bri) 1.0 }
    set Angle $DifferentColor(Ang)
    set Angle [expr round($Angle+137.5)%360]
    set Hue   [expr  $Angle/360.]
    set DifferentColor(Ang) $Angle
    set DifferentColor(Hue) $Hue

    set Sat $DifferentColor(Sat)
    set Sat [expr $Sat*0.98]
    set DifferentColor(Sat) $Sat
    
    return [ColorFromHSB $DifferentColor(Hue) $DifferentColor(Sat) $DifferentColor(Bri)]
}

proc DessineMoiLaTaxonomy {Source {NomDuFichierOrigine ""} {FenetreParent ""} {LargeurDUneBoite ""} {HauteurDUneBoite ""} {OutLineColor ""}} { 
    LogWscope "$Source $NomDuFichierOrigine"
    LogWscope [RepertoireDuGenome]

    if {[regexp "wali/store" $Source]} {
	set Queue [file tail $Source]
	if {[regexp {^(HSAP[0-9]+)([^0-9]|$)} $Queue Match Nom]} {
	    set Source /genomics/link/CilioCarta/descriptifs/$Nom
	}
    }

    if {[OnTraite "Zero"]} { return "" }

    #rR FenetreParent can be a window name, NormalWindow, PourGif or PourCanVir

    set AvecTexte 0
    set PourGif 0
    set PourCanVir 0
    if {[PourWscope] && $FenetreParent==""} { set FenetreParent "PourCanVir" }
    if {                $FenetreParent==""} { set FenetreParent "NormalWindow" }
    if {$FenetreParent=="PourGif"} {
	set PourGif 1
    } elseif {$FenetreParent=="PourCanVir"} {
	CanvaVirtuel "Reset"
	set PourCanVir 1
    } else {
	if {$FenetreParent=="NormalWindow"} {
	    set w [NomDe fenetre]
	} else {
	    set w $FenetreParent
	}
    }

#    regsub {/macsim[^/]+/} $Source "/descriptifs/" DescFile
    set LesIDOXOSOC [AfficheLesDescriptifs $Source MemeOrdre LaListe "" "ID AC OX OS OC"]
    set INode 0
    set Nom [file tail $NomDuFichierOrigine]
    set Titre $NomDuFichierOrigine

    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 Winfo     NeRienFaire
	set FonctionRejetteLaBoite "RejetteLaBoite"
	set LesOrdresPourGif {}
	set w "PourGif"
	set K "OrdrePourGif"
    } elseif {$PourCanVir} {
	CanvaVirtuel CanVir $NomDuFichierOrigine 
	set Canvas    NeRienFaire
	set Bind      NeRienFaire
	set Pack      NeRienFaire
	set Fram      NeRienFaire
	set Button    NeRienFaire
	set Scrollbar NeRienFaire
	set Grid      NeRienFaire
	set Winfo     NeRienFaire
	set FonctionRejetteLaBoite "RejetteLaBoite"
	set w "PourCanVir"
	set K "CanvaVirtuel"
    } 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 Winfo     winfo
	set FonctionRejetteLaBoite "NeRejettePasLaBoite"
	set K "ToCreate"
    }

    set BilanCilioExists [BilanCilio exists]
    if {$BilanCilioExists} {
	DifferentColor Reset
	set ColorOf(Clade_) "white"
	foreach Clade [BilanCilio ListOf Clade] {
	    regsub {[A-Z]+\_} $Clade "" Clade
	    if {[info exists ColorOf(Clade_$Clade)]} { continue }
	    set Color [DifferentColor]
	    set ColorOf(Clade_$Clade) $Color
	}
    }

    set MaxLevel 0
    set i -1
    set AllNode {}
    foreach Ligne $LesIDOXOSOC {
	incr i
	scan $Ligne "%s" ID
	regsub "=.*" $ID "" ID
	set VraiID [StringApres "ID:" dans $Ligne]
	if {$VraiID!="" && ! [regexp "_" $ID]} { set ID $VraiID } 
	set OX [IntegerApres "OX:" dans $Ligne]
	if {$OX=="" && [EstUnPAB $ID]} { set OX [NotreOX] }
 
	set OC [string trim [StringSuivant "OC:" dans $Ligne] " \t"]
	if {$OC=="" && [EstUnPAB $ID]} { set OC [NotreOC] }

	regsub "OC:.*" $Ligne "" Ligne
	set OS [string trim [StringSuivant "OS:" dans $Ligne] " \t"]
	if {$OS=="" && [EstUnPAB $ID]} { set OS [NotreOS] }
	regsub -all {[\. ]} $OC "" OC
	set LesNode [split $OC ";"]
	lappend LesNode $OS
#	Espionne "[llength $LesNoeuds] $ID $OX $OS $OC"
	set Level -1
	set PrevNode ""
	foreach Node $LesNode {
	    if { ! [info exists PreviousNode($Node)]} { set PreviousNode($Node) $PrevNode }
	    set PrevNode $Node
	    if { ! [info exists INodeOf($Node)]} {
		set INodeOf($Node) [incr INode]
	    }
	    incr Level
	    lappend AllNode $Node
	    lappend IdsFromNode($Node) $ID
	    set     LevelOfNode($Node) $Level
	    
	    if {[info exists AreaOf($Node)]} { set AreaOf($Node) 0 }
	    incr AreaOf($Node) $Level
	    
	}
	set MaxLevel [Maxi $MaxLevel $Level]
    }
    set NbLignes [expr $i+1]
    set AllNode [lsort -unique $AllNode]
    foreach Node $AllNode {
#	Espionne "$Node [llength $PreviousNode($Node)] $LevelOfNode($Node)"
    }

    set PreferedOrganisms [list "Homo sapiens" "Mus musculus"]
    set HighArea 9999
    foreach O $PreferedOrganisms {
	set AreaOf($O) [incr HighArea -1]
    }
    foreach {N A} [array get AreaOf] {
	lappend ListOfArea $A
	lappend NodesOfArea($A) $N
    }
    set ListOfArea [lsort -unique -integer -decreasing $ListOfArea]
    DifferentColor Reset
    foreach A $ListOfArea {
	foreach Node $NodesOfArea($A) {
	    if {[info exists ColorOf($Node)]} { continue }
	    set Color [DifferentColor]
	    lappend ListOfColor $Color
	    set ColorOf($Node) $Color
	    set N $Node
	    while {[info exists PreviousNode($N)] && [set N $PreviousNode($N)]!=""} {
		if {[info exists ColorOf($N)]} { break }
		set ColorOf($N) $Color
	    }
	}
    }

    if {$LargeurDUneBoite==""} { set LargeurDUneBoite 70 }
    if {$HauteurDUneBoite==""} { set HauteurDUneBoite 15 }
    if {$OutLineColor==""} {
	if {$HauteurDUneBoite<5} {
	    set OutLineColor "same"
	} else {
	    set OutLineColor "white"
	}
    }

    set xDebut 0
    set xFin   [expr ($MaxLevel+2)*$LargeurDUneBoite]

    set CanvaSizeX    [expr $xFin - $xDebut]
    set CanvaScroMinX [expr $xDebut]
    set CanvaScroMaxX [expr $xFin  ]
    set CanvaScreenX  $CanvaSizeX

    set yDebut 0
    set yFin   [expr ($NbLignes+2)*$HauteurDUneBoite]
    set CanvaSizeY    [expr $yFin - $yDebut]
    set CanvaScroMinY [expr $yDebut]
    set CanvaScroMaxY [expr $yFin  ]
    set CanvaScreenY  [expr $CanvaSizeY]

    if { [regexp "expo" $w] } {
	set NormalCanvaScreenX $CanvaScreenX
	set CanvaScreenX 300
	set CanvaScreenY [expr round($CanvaSizeY*(1.0*$CanvaScreenX)/$CanvaSizeX)]
	set Papa $w
    }

    if { ! $PourGif && ! $PourCanVir} {
	set K [UnCanva $CanvaScreenX $CanvaScreenY $CanvaScreenX $CanvaScreenY "GonfleY" $NomDuFichierOrigine]
    }

    set IdCadre [$K find withtag "Cadre"]
    $K itemconfigure $IdCadre -fill "white"

    set SepTexteNode "\n"
    if {$PourCanVir} { set SepTexteNode " " }

    

    set i -1
    foreach Ligne $LesIDOXOSOC {
#	regsub -all {[ \t]+} $Ligne " " Ligne   ;#rR rajouté 2015/01/24
	incr i
	set PosMinY [expr $i*$HauteurDUneBoite] 
	set PosMaxY [expr $PosMinY+$HauteurDUneBoite]
	scan $Ligne "%s" ID
	regsub "=.*" $ID "" ID
	set VraiID [StringApres "ID:" dans $Ligne]
	if {$VraiID!="" && ! [regexp "_" $ID]} {
	    regsub "^$ID=" $Ligne $VraiID= Ligne            ; #rR 2015/05/21  pour avoir le ID et non pas l'access 
	}
	set OX [IntegerApres "OX:" dans $Ligne]
	if {$OX=="" && [EstUnPAB $ID]} { set OX [NotreOX] } 

	set PlaceBilan 0
	if {$BilanCilioExists} {
	    set Clade [BilanCilio $OX Clade]
	    regsub {^[A-Z]+_} $Clade "" Clade
	    if {$Clade=="" && $OX==9606} { set Clade "Mammalia" }
	    set Etat [BilanCilio $OX State]

	    set Couleur $ColorOf(Clade_$Clade)
	    if {$OutLineColor=="same"} {
		set CouleurTrait $Couleur
	    } else {
		set CouleurTrait $OutLineColor
	    }		
	    set XduD [expr ($PlaceBilan) * $LargeurDUneBoite/2]
	    set XduF [expr $XduD  + $LargeurDUneBoite/2 -1]
	    $K create rect $XduD $PosMinY $XduF $PosMaxY \
		-tags [list "Clade" "$Clade $Etat" "$Clade$SepTexteNode$Ligne"] \
		-outline $CouleurTrait \
		-fill $Couleur
	    
	    incr PlaceBilan
	    set Couleur "lightgrey"
	    if {$Etat==""}   { set Couleur "#ffffffffffff" }
	    if {$Etat=="Y"}  { set Couleur "#90b1eed89080" }
	    if {$Etat=="N"}  { set Couleur "#ffffc0c4cbc4" }
	    if {$Etat=="L"}  { set Couleur "#ffffcc500000" }
	    if {$Etat=="PR"} { set Couleur "#ffffcc500000" }
	    if {$OutLineColor=="same"} {
		set CouleurTrait $Couleur
	    } else {
		set CouleurTrait $OutLineColor
	    }		
	    set XduD [expr ($PlaceBilan) * $LargeurDUneBoite/2]
	    set XduF [expr $XduD  + $LargeurDUneBoite/2 -1]
	    $K create rect $XduD $PosMinY $XduF $PosMaxY \
		-tags [list "State" "$Etat $Clade" "$Etat$SepTexteNode$Ligne"] \
		-outline $CouleurTrait \
		-fill $Couleur
	    incr PlaceBilan 1
	}
 
	set OC [string trim [StringSuivant "OC:" dans $Ligne] " \t"]
	if {$OC=="" && [EstUnPAB $ID]} { set OC [NotreOC] }
	regsub "OC:.*" $Ligne "" Ligne
	set OS [string trim [StringSuivant "OS:" dans $Ligne] " \t"]
	if {$OS=="" && [EstUnPAB $ID]} { set OS [NotreOS] }

	regsub -all {[\. ]} $OC "" OC

	set LesNode [split $OC ";"]
	lappend LesNode $OS
#	Espionne "[llength $LesNoeuds] $ID $OX $OS $OC"
	set Level -1
	set Ruban ""
	set TexteDuNode ""
	set Sep ""
	set OffsetX 0
	foreach Node $LesNode {
	    append TexteDuNode "$Sep$Node"
	    set Sep "; "
	    incr Level
	    if { ! [info exists INodeOf($Node)]} {
		set INodeOf($Node) [incr INode]
	    }
	    append Ruban " [format %3.3d $INodeOf($Node)]"
	    set Couleur $ColorOf($Node)
	    set XduD [expr ($PlaceBilan + $Level) * $LargeurDUneBoite]
	    set XduF [expr $XduD  + $LargeurDUneBoite -1]
	    if {$OutLineColor=="same"} {
		set CouleurTrait $Couleur
	    } else {
		set CouleurTrait $OutLineColor
	    }		
	    $K create rect $XduD $PosMinY $XduF $PosMaxY \
		-tags [list "Node" $TexteDuNode "$Node$SepTexteNode$Ligne"] \
		-outline $CouleurTrait \
		-fill $Couleur
#	     $K create text $XduD [expr $PosMinY+$HauteurDUneBoite/2] -text $Couleur -font {Courier 8} -anchor w
#	     $K create text 1200 [expr $PosMinY+$HauteurDUneBoite/2] -text "[format %-30s $OS] $OC $OS" -anchor w
	}
#	Espionne $Ruban
    }
    global PagePropre
    set PagePropre($w) [join $LesIDOXOSOC "\n"]

    #rR on pourrait peut-être mettre ça plus bas mais il faut d'abord redéfinir TouchePour
    if {$PourCanVir} { return [CanvaVirtuel "GetActionsAndReset"] }
    if {$PourGif} { return $LesOrdresPourGif }

    $K bind "Node" <1>       "ClickDansSeq $K %x %y"
    $K bind "Node" <Enter>   "EntreDansSeq $K %x %y"
    $K bind "Node" <Leave>   "SortDeSeq $K %x %y"

    $K bind "Clade" <Enter>   "EntreDansSeq $K %x %y"
    $K bind "Clade" <Leave>   "SortDeSeq $K %x %y"
    $K bind "State" <Enter>   "EntreDansSeq $K %x %y"
    $K bind "State" <Leave>   "SortDeSeq $K %x %y"

    if {$HauteurDUneBoite==2} { set HBoite 15 } else { set HBoite 2 }

    set Clavier "[$Winfo parent $K].buttons"
    TouchePour $Clavier NouvelleGamme
    TouchePour $Clavier NouvelleCouleur "lightgrey"
    TouchePour $Clavier "Description"       "AfficheLesDescriptifs $Source   MemeOrdre"
    TouchePour <2>      "/all"              "AfficheLesDescriptifs $Nom      Natif"
    TouchePour $Clavier "Taxonomy"          "DessineMoiLaTaxonomy  $Source $Source {} {} $HBoite"
    TouchePour <2>      "/all"              "AfficheLesDescriptifs $Nom      Natif     {} {} {OX OC} $Nom"
    TouchePour <3>      "/page"             "AfficheLesDescriptifs \[set PagePropre($w)\] MemeOrdre {} {} {OX OC} $Nom"

    return $w
}

proc DetecteCopainsDoublons {} {
    set LesDoubles {}
    foreach Nom [ListeDesPABs] {
	set Fichier [GscopeFile $Nom "tfasdescopains"]
	if {[FileAbsent $Fichier]} { continue }
	if {[info exists DejaVu]} { unset DejaVu }
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    if { ! [regexp {^>} $Ligne] } { append Seq($AccessCourant) $Ligne ; continue }
	    scan $Ligne "%s" Access
	    if {[info exists DejaVu($Access)]} {
		lappend LesDoublons($Nom) $Access
		lappend LesDoubles $Nom
		lappend LesIduAccess($Access) [incr IduAccess($Access)]
		set AccessCourant "${Access}_$IduAccess($Access)"
	    } else {
		set DejaVu($Access) 1
		set IduAccess($Access) 1
		set AccessCourant "${Access}_$IduAccess($Access)"
	    }
	}
    }
    set LesDoubles [lsort -unique $LesDoubles]
    foreach Double $LesDoubles {
	set LesDoublons($Double) [lsort -unique $LesDoublons($Double)]
	set Seq1 $Seq(${Access}_1)
	set YaDiff($Double) ""
	foreach I $IduAccess($Access) {
	    set AccessCourant "${Access}_$I"jalviewApplet
	    if {$Seq1 ne $Seq($AccessCourant)} { set YaDiff($Double) "YaDiff" }
	    
	}
	lappend LaSortie "$Double [join $LesDoublons($Double) " "] $YaDiff($Double)"
    }
    return [AfficheListe $LaSortie]
}

proc TheTrueMacsimsFile {Nom {Preference ""}} {
    if {[regexp "/" $Nom]} {
	if {[file exists $Nom]}        { return $Nom }
	if {[file exists $Nom.xml]}    { return $Nom.xml }
	if {[file exists $Nom.xml.gz]} { return $Nom.xml.gz }
	if {[file exists $Nom.gz]}     { return $Nom.gz }
    }
    if { ! [EstUnPAB $Nom]} { return $Nom }
    foreach Dir [list "[RepertoireDuGenome]/macsimXml" "[RepertoireDuGenome]/macsims"] {
	if {[file exists $Dir/$Nom]}        { return $Dir/$Nom }
	if {[file exists $Dir/$Nom.xml]}    { return $Dir/$Nom.xml }
	if {[file exists $Dir/$Nom.xml.gz]} { return $Dir/$Nom.xml.gz }
	if {[file exists $Dir/$Nom.gz]}     { return $Dir/$Nom.gz }
    }
    return $Nom
}

proc ReordonneRsf {NomOuFichierRsf LaListe {GetWhat ""}} {

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

    set Nom ""
    if {[EstUnPAB $NomOuFichierRsf]} {
	set Nom $NomOuFichierRsf
	set FichierRsf [GscopeFile $Nom "macsimRsf"]
	if {$LaListe=="OrderFromMsf"} {
	    set FichierMsf [GscopeFile $Nom "msf"]
	    DecortiqueUnMSF $FichierMsf LaListe
	}
    } else {
	set FichierRsf $NomOuFichierRsf
    }

    set LeNouveau {}
    set OnAttendOuvrante 1
    set LeCourant {}
    set LesAnciens {}
    foreach Ligne [LesLignesDuFichier $FichierRsf] {
	if {$OnAttendOuvrante} {
	    if { ! [regexp {^\{} $Ligne] } { lappend LeNouveau $Ligne ;	continue }
	    set OnAttendOuvrante 0
	}
	if { [regexp {^\{} $Ligne]} {
	    lappend LeCourant $Ligne
	    continue
	} 
	if { [regexp {^\}} $Ligne]} {
	    lappend LeCourant $Ligne
	    set T($Courant) [join $LeCourant "\n"]
	    set LeCourant {}
	    continue
	}
	if {[regexp "^name " $Ligne]} {
	    set Courant [StringApres "name" dans $Ligne]
	    lappend LesAnciens $Courant
	}
	lappend LeCourant $Ligne
    }

    if {$LaListe=="SameOrder"} { set LaListe $LesAnciens }

    foreach Courant $LaListe {
	if { ! [info exists T($Courant)] } { continue }
	lappend LeNouveau $T($Courant)
    }
    set Nouveau [join $LeNouveau "\n"]
    if {$GetWhat=="GetText" } { return $Nouveau }
    if {$GetWhat=="SameFile"} { return [Sauve $Nouveau dans $FichierRsf] }
    return [Sauve $Nouveau dans $GetWhat]
}

proc TestMacsimsOnWeb {} {
    #set Msf [ContenuDuFichier [GscopeFile PGS779 "msf"]]
    set Msf [ContenuDuFichier /home/moumou/alitest/FRAT01.msf]
    set Xml [MacsimsOnWeb $Msf]
    return $Xml
}

proc MacsimsOnWeb {Msf {FichierXml ""}} {
    if {$FichierXml==""} { set FichierXml "GetXml" }
    if { ! [regexp "\n" $Msf] && [file exists $Msf]} { set Msf [ContenuDuFichier $Msf] }
    set Msf64 [Base64Encode $Msf]
    set Query [::http::formatQuery "TexteMsf" $Msf64]
    set Xml [HttpGetUrl "[LbgiUrl]/~ripp/cgi-bin/WscopeServer.tcl?science=Zero&commande=MacsimsFromText" $Query]
    if {$FichierXml=="GetXml"} { return $Xml }
    if {[regexp {^//} $FichierXml]} { regsub {^//} $FichierXml "[RepertoireDuGenome]/" FichierXml }
    return [Sauve $Xml dans $FichierXml]
}

proc MacsimsFromText TexteMsf {
    if { ! [regexp "\n" $TexteMsf] && [file exists $TexteMsf]} { set TexteMsf [ContenuDuFichier $TexteMsf] }
    if { ! [regexp "\n" $TexteMsf]} { set TexteMsf [Base64Decode $TexteMsf] }
    set FichierMsf "[TmpFile].msf"
    Sauve $TexteMsf dans $FichierMsf
    set Xml [Macsims $FichierMsf "GetXmlText"]
    file delete $FichierMsf
    return $Xml
}

proc Macsims {FichierMsf {FichierXml ""} {FichierRsf ""} {FichierLog ""} {Delete ""}} {
LogWscope "Macsims $FichierMsf $FichierXml $FichierRsf $FichierLog $Delete"

    #rR y a encore un probleme ... 2011/04/20 
    if {$FichierXml==""} { set FichierXml "GetXmlText" } 
    if {$FichierRsf==""} { set FichierRsf "DeleteRsfFile" }

    set GetRsf "GetRsfFile"
    if {$FichierRsf=="GetRsfText" || $FichierRsf=="DeleteRsfFile"} {
	set GetRsf $FichierRsf
	set FichiersRsf "[TmpFile].rsf"
    }
    set GetXml "GetXmlFile"
    if {$FichierXml=="GetXmlText" || $FichierXml=="DeleteXmlFile"} {
	set GetXml $FichierXml
	set FichierXml "[TmpFile].xml"
    }

    set Message [ExecuteMacsim $FichierMsf $FichierRsf]

    if {$Message!=""} {
	Warne $Message
	if {$FichierLog!=""} { AppendAuFichier $FichierLog $Message }
    }
    set FichierRsfRsf "$FichierRsf.rsf"
    set FichierRsfXml "$FichierRsf.xml"
    if {[file exists $FichierRsfXml]} {
	file rename $FichierRsfXml $FichierXml
    }
    if { ! [file exists $FichierRsfRsf]} {
	set MonMessage "$FichierRsfRsf was not created. I got the message\n$Message"
	Warne $MonMessage
	if {$FichierLog!=""} { AppendAuFichier $FichierLog $MonMessage }
    } else {
	file rename $FichierRsfRsf $FichierRsf
    }
    foreach Mot [split $Delete "_"] {
	set F "Fichier$Mot"
	if {[regexp {\.$} $F]} {
	    set FSansPoint [string trimright $F "."]
	    if { ! [info exists $FSansPoint]} { continue }
	    foreach FF [glob -nocomplain "[set $FSansPoint].*"] {
		file delete $FF
	    }
	} else {
	    if { ! [info exists $F]} { continue }
	    foreach FF [glob -nocomplain "[set $F]*"] {
		file delete $FF
	    }
	}
    }
    if {$GetRsf=="DeleteRsfFile"} { file delete $FichierRsf }
    if {$GetXml=="DeleteXmlFile"} { file delete $FichierXml }
    if {$GetRsf=="GetRsfText"} {
	set Rsf [ContenuDuFichier $FichierRsf]
	file delete $FichierRsf
	return $Rsf
    }
    if {$GetXml=="GetXmlText"} {
	set Xml [ContenuDuFichier $FichierXml]
	file delete $FichierXml
	return $Xml
    }
    return $FichierXml
}

proc TestMacsimsInfo {} {
    global MacsimsInfo
    MacsimsInfo LoadXml "/genomics/link/SpliRet/macsimXml/SP0001"
parray MacsimsInfo
exit
    EspionneL [MacsimsInfo ListOf Key1]
    Espionne "================================="
    EspionneL [MacsimsInfo ListOf FeaturesKeys]
    foreach Access [MacsimsInfo Noms] {
	Espionne "$Access [MacsimsInfo $Access Features]"
    }
}

proc MacsimsInfo args {
    global MacsimsInfo

#rR calls ParseMACSIMS from Nicolas Gagniere

    set Qui  [lindex $args 0]
    set Quoi [lindex $args 1]

    if {[regexp -nocase "LoadXml" $Qui]} { 
	set Fichier $Quoi
	if {[info exists MacsimsInfo(File)]} {
	    if {[string equal -nocase "ReLoadXml" $Qui] \
		    || $MacsimsInfo(File)!=$Fichier} {
		unset MacsimsInfo
	    }
	}
	if { ! [info exists MacsimsInfo(File)]} {
	    if {[FileAbsent $Fichier]} {
		FaireLire "$Fichier\ndoesn't exist"
		return ""
	    }
	    ParseMACSIMS $Fichier MacsimsInfo 
#	    parray MacsimsInfo; exit; 

	    set MacsimsInfo(File) $Fichier
	    set LesKey1 {}
	    set LesFeaturesKeys {}
	    foreach X [array names MacsimsInfo] {
		set LesKey [split $X ","]
		set Key1 [lindex $LesKey 1]
		lappend LesKey1 $Key1
		if {$Key1=="Features"} {lappend LesFeaturesKeys [lindex $LesKey 3]}  
	    }
	    set LesKey1 [ListeSansDoublon $LesKey1]
	    set MacsimsInfo(ListOf,Key1) $LesKey1
	    set LesFeaturesKeys [ListeSansDoublon $LesFeaturesKeys]
	    set MacsimsInfo(ListOf,FeaturesKeys) $LesFeaturesKeys
	    
	    set args [lrange $args 2 end]
	    #	parray MacsimsInfo
	    if {$args=={}} { return $MacsimsInfo(File) }
	}
    }

    set Tout [join $args ","]
    if {[info exists MacsimsInfo($Tout)]} { return $MacsimsInfo($Tout) }
    return ""
}

proc UseExistingJalviewHtml {{Value ""}} {
    global UseExistingJalviewHtml
    if {$Value!=""} { set UseExistingJalviewHtml $Value }
    if { ! [info exists UseExistingJalviewHtml]} { set UseExistingJalviewHtml [file exists "[RepertoireDuGenome]/webXXXXXXXXXX"] }
    return $UseExistingJalviewHtml
}

proc JalviewHtml {FichierMacsim {JalviewJunkdir ""} {JalviewJunkdirUrl ""}} {
    set CreateWebFile 0
    if {0 && [EstUnPAB $FichierMacsim] && $JalviewJunkdir=="" && $JalviewJunkdirUrl=="" } {
	set CreateWebFile 1
	set Nom $FichierMacsim
	set FichierJalviewHtml "[RepertoireDuGenome]/web/$Nom.jalview.html"
	if {[UseExistingJalviewHtml] && [FileExists $FichierJalviewHtml]} { 
	    return [ContenuDuFichier $FichierJalviewHtml]
	}
    }
    if {[EstUnPAB $FichierMacsim]}  { set FichierMacsim "[RepertoireDuGenome]/macsimXml/$FichierMacsim" }
    if {$JalviewJunkdir   ==""} { set JalviewJunkdir    "[HomeRipp]/www/JalviewJunkdir" }
    if {$JalviewJunkdirUrl==""} { set JalviewJunkdirUrl "/JalviewJunkdir" }
    if  {[FileAbsent $FichierMacsim]} {
#	if {[regexp "^/" $FichierMacsim]} { return "" }
	if {[FileExists "$FichierMacsim.xml"]} {
	    set FichierMacsim "$FichierMacsim.xml"
	} else {
	    if {[FileExists "[RepertoireDuGenome]/$FichierMacsim"] } {
		set FichierMacsim "[RepertoireDuGenome]/$FichierMacsim"
	    }
	}
    }
    if {[FileAbsent $FichierMacsim] && [FileExists "$FichierMacsim.gz"]} {
	set FichierMacsim "$FichierMacsim.gz"
    }
    if {[FileAbsent $FichierMacsim]} { return "Sorry, there is no file $FichierMacsim" }
    set Macsim [ContenuDuFichier $FichierMacsim]
    NousAllonsAuBoulot $JalviewJunkdir

    set Racine [TmpFile "macsim2jal" "./"]
    regsub {\./} $Racine "" Racine
    Sauve $Macsim dans $Racine.xml
    if {[catch {exec /biolo/macsim/macsim2jal "$Racine.xml" $Racine > [HomeRipp]/lolo.log} Message]} {
	OnRevientDuBoulot
	return "Error during macsim2jal with message=$Message="
    }
    file delete -force $Racine.xml
    if {[FileAbsent $Racine.html]} {
	file delete -force $Racine.txt
	file delete -force $Racine.tfa
    }
    if {[FileAbsent $Racine.html]} { return "I didn't find $Racine.html" }
    if {$CreateWebFile} {
	set WebDir [file dirname $FichierJalviewHtml]
	file mkdir $WebDir
	regsub {.html$} $FichierJalviewHtml ".tfa" FichierJalviewTfa 
	regsub {.html$} $FichierJalviewHtml ".txt" FichierJalviewTxt
	set Html [ContenuDuFichier $Racine.html]
	regsub -all "value=\"$Racine" $Html "value=\"$Nom.jalview" Html
	Sauve $Html dans              $FichierJalviewHtml  
	file copy -force $Racine.tfa  $FichierJalviewTfa  
	file copy -force $Racine.txt  $FichierJalviewTxt
	if {[UseExistingJalviewHtml]} { return [JalviewHtml $Nom] }
    }  
    set Html [ContenuDuFichier $Racine.html]
    OnRevientDuBoulot

    regsub -all "value=\"$Racine"  $Html "valuetype=\"ref\" value=\"$JalviewJunkdirUrl/$Racine" Html
    regsub -all {archive=[^>]+\">} $Html "archive=\"[LbgiUrl]/Jalview/jalviewApplet.jar\">"  Html
    return $Html
}

proc XmlFromRsfMacsim {NomOuFichier {FichierXml ""}} {
    return XmlFromRsf $NomOuFichier $FichierXml
}

proc XmlFromRsf {NomOuFichier {FichierXml ""}} {
    set Nom ""
    set Fichier $NomOuFichier
    if { ! [regexp "/" $NomOuFichier]} {
	if {[EstUnPAB $NomOuFichier]} {
	    set Nom $NomOuFichier
	    set FichierPossible "[RepertoireDuGenome]/macsimRsf/$Nom"
	    if {[FileExists $FichierPossible]} {
		set Fichier $FichierPossible
	    }
	}
    }
    if {[FileAbsent $Fichier]} {return ""}
    if {$FichierXml==""} {
	if {$Nom!=""} {
	    set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom"
	} else {
	    regsub -nocase ".rsf$" $Fichier "" FichierXml
	    append FichierXml ".xml"
	}
    }
    set GetText 0
    if {$FichierXml=="GetText"} {
	set GetText 1
	set FichierXml "[TmpFile].xml"
    }
    if {[catch {exec clustalw $Fichier -convert -output=macsim -outfile=$FichierXml} Message]} {
	return ""
    }
    if {$GetText} {
	set TexteXml [ContenuDuFichier $FichierXml]
	file delete $FichierXml
	return $TexteXml
    }
    return $FichierXml
}

proc ConvertToMsf {{Source ""} {GetWhat ""}} {
    set CleanSource 0
    if {[regexp "\n" $Source]} {
	set FiSource "[TmpFile].xxx"
	Sauve $Source dans $FiSource
	set CleanSource 1
    } elseif { [llength $Source] > 1 } {
	set FiSource "[TmpFile].xxx"
	SauveLesLignes $Source dans $FiSource
	set CleanSource 1
    } else {
	set FiSource $Source
	if {[FileAbsent $FiSource]} { return "" }
    }
    set FiMsf $GetWhat
    set CleanDestin 0
    if {$GetWhat==""} { set GetWhat "GetText" }
    if {$GetWhat=="GetText" || $GetWhat=="GetLines"} {
	set FiMsf "[TmpFile].msf"
	set CleanDestin 1
    }
    if {$GetWhat=="GetFile"} {
	set FiMsf $FiSource
	regsub {\.(rsf|tfa|tfas|msf)$} $FiMsf "" FiMsf
	append FiMsf ".msf"
    }
    if {[catch {exec clustalw $FiSource -convert -outorder=input -output=gscope -outfile=$FiMsf} Message]} {
	Warne $Message
	set GetWhat "Error"
    }
    set Retour ""
    if {$GetWhat=="GetText"}  { set Retour [ContenuDuFichier $FiMsf] }
    if {$GetWhat=="GetLines"} { set Retour [LesLignesDuFichier $FiMsf] }
    if {$GetWhat=="GetFile"}  { set Retour $FiMsf }
    if {$CleanSource && [file exists $FiSource]} { file delete $FiSource }
    if {$CleanDestin && [file exists $FiMsf]}    { file delete $FiMsf }
    return $Retour
}

proc RsfFromXmlMacsim {NomOuFichier {FichierRsf ""}} {
    set Nom ""
    set Fichier $NomOuFichier
    if { ! [regexp "/" $NomOuFichier]} {
	if {[EstUnPAB $NomOuFichier]} {
	    set Nom $NomOuFichier
	    set FichierPossible "[RepertoireDuGenome]/macsimXml/$Nom"
	    if {[FileExists $FichierPossible]} {
		set Fichier $FichierPossible
	    }
	}
    }
    if {[FileAbsent $Fichier]} {return ""}
    if {$FichierRsf==""} {
	if {$Nom!=""} {
	    set FichierRsf "[RepertoireDuGenome]/macsimRsf/$Nom"
	} else {
	    regsub -nocase ".xml$" $Fichier "" FichierRsf
	    append FichierRsf ".rsf"
	}
    }
    set GetText 0
    if {$FichierRsf=="GetText"} {
	set GetText 1
	set FichierRsf "[TmpFile].rsf"
    }
    if {[catch {exec clustalw $Fichier -convert -output=RSF -outfile=$FichierRsf} Message]} {
	return ""
    }
    if {$GetText} {
	set TexteRSF [ContenuDuFichier $FichierRsf]
	file delete $FichierRsf
	return $TexteRSF
    }
    return $FichierRsf
}

proc SiteBips {} {
    set SiteBips "http://bips.u-strasbg.fr/"
    return $SiteBips
}

proc GroupEtNonSubgroupDansXml {} {
    foreach Nom [ListeDesPABs] {
	set Fichier "[RepertoireDuGenome]/macsimXml/$Nom"
	if { ! [file exists $Fichier]} {
	    continue
	}
	set LesBonnes {}
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    if {[regexp "</?subgroup>" $Ligne]} { continue }
	    lappend LesBonnes $Ligne
	}
	SauveLesLignes $LesBonnes dans $Fichier
    }
    exit
}

proc ShowTarget Commande {
    if {[regexp -nocase "ListAllTargets" $Commande]} {
	return [FileMoi]
    }
    if {[regexp -nocase "TargetId=" $Commande Clef]} {
	set SpineID [StringApres $Clef dans $Commande]
    } else {
	set SpineID $Commande
    }
    if {[EstUnPAB $SpineID]} { 
	set GscopeID $SpineID
    } else {    
	set GscopeID [GscopeID $SpineID]
    }    
    return [FileMoi macsimHtml $GscopeID]
}

proc DoctypeForMacsim {} {
    return {<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE macsim SYSTEM "http://lbgi.fr/macsim.dtd">
}
}

proc RewriteXmlMsaToMacsimPourTous {} {
    foreach Nom [ListeDesPABs] {
	set Fichier "[RepertoireDuGenome]/macsimXmlMsa/$Nom"
	if { ! [file exists $Fichier]} { continue }
	regsub "/macsimXmlMsa/" $Fichier "/macsimXml/" FichierSortie
	if {[file exists $FichierSortie]} { continue }
	Espionne [RewriteXmlMsaToMacsim $Fichier $FichierSortie]
    }
}

proc RewriteXmlMsaToMacsim {Fichier {FichierSortie ""}} {

    if {$FichierSortie==""} { set FichierSortie $Fichier }
    
    set AncienXML [ContenuDuFichier $Fichier]
    set Root [[dom parse $AncienXML] documentElement]
    set    NouveauXml [DoctypeForMacsim]
    append NouveauXml [$Root asXML -indent 1]
    regsub "<MSA>" $NouveauXml "<macsim>" NouveauXml
    regsub "</MSA>" $NouveauXml "</macsim>" NouveauXml
    if {$FichierSortie=="GetIt"} { return $NouveauXml }
    return [Sauve $NouveauXml dans $FichierSortie]
}

proc GscopeID SpineID {
    global GscopeID
    if {[info exists GscopeID($SpineID)]} { return $GscopeID($SpineID) }
    if {[info exists GscopeID("EstCharge")]} { return "" }

    set GscopeID("EstCharge") 1
    foreach Nom [ListeDesPABs] {
	if {[EstUnPABMute $Nom]} {continue}
	set S [SpineID $Nom]
	if {$S==""} { continue }
	set GscopeID($S) $Nom
    }
    return [GscopeID $SpineID]
}

proc SpineID {Nom {Full ""}} {
    set Tout [ExtraitInfo $Nom "SpineID"]
    if {$Full=="Full"} {return $Tout}
    set SpineID ""
    scan $Tout "%s" SpineID
    return $SpineID
}

proc LaSequenceColoree {Texte {Maniere ""} {Ftable ""} {AvecZones ""}} {

    set LesLettres {}
    set LesClasses {}

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

    if {$Maniere==""} { set Maniere "Seqlab" }

    if {$Maniere=="Normal"} { return $Texte }

    if {$Maniere=="Seqlab"} {
	foreach AA [split $Texte ""] {
	    lappend LesLettres $AA
	    if {$AA==" "} { set AA "Space" }
	    if {$AA=="."} { set AA "Dot" }
	    if {$AA=="-"} { set AA "Hyphen" }
	    if {$AA=="~"} { set AA "Tilde" }
	    lappend LesClasses $AA
	}
    }

    if {$Maniere=="Ftype"} {
	set ItemVide "-1 -1 -1 -1 -1 -1"
	PositionAutreDe Absolue 1 $Texte 
        set Fin 0
	foreach Item $Ftable {
	    incr Fin
	    ScanLaListe $Item Ftype Fstart Fstop Fcolor Fscore Fnote
	    set AbsPos [regexp "^AbsolutePosition " $Fnote]

	    if {$AbsPos} {
		set AvantProchain [expr $Fstart-1]
		set Alpha $Fstart
		set Omega $Fstop
	    } else {
		set AvantProchain [expr [PositionAutreDe Relative $Fstart]-1]
		set Alpha [PositionAutreDe Relative $Fstart]
		set Omega [PositionAutreDe Relative $Fstop]
	    }
	    foreach I [NombresEntre $Fin $AvantProchain] {
		set ItemEnPosition($I) $ItemVide
	    }
	    
	    foreach I [NombresEntre $Alpha $Omega] {
		set ItemEnPosition($I) $Item
	    }
	    set Fin $Omega
	}
	incr Fin
	set Max [string length $Texte]
	if {$Fin<=$Max} {
	    foreach I [NombresEntre $Fin $Max] {
		set ItemEnPosition($I) $ItemVide
	    }
	    
	}
	set IGap 0
	set Mot ""
	if {[info exists OldClasse]} { unset OldClasse }
	if {[info exists OldColScoNot]} { unset OldColScoNot }
	regsub -all -nocase {[^A-Z]} $Texte "" VraieSeq
	foreach AA [split $Texte ""] {
	    incr IGap
	    set Item $ItemEnPosition($IGap)
	    ScanLaListe $Item Ftype Fstart Fstop Fcolor Fscore Fnote
	    set ColScoNot "$Fcolor $Fscore $Fnote"
	    set SS "$Fstart-$Fstop"
	    if {$Fstart==$Fstop} { set SS $Fstart }
	    if {[regexp "^AbsolutePosition" $Fnote]} { append SS " (absolute position)" }
	    if {$Fscore!=""} { append SS " $Fscore" }
	    regsub "^AbsolutePosition " $Fnote "" BelleFnote
	    set TexteBulle "$Ftype $SS $BelleFnote"
	    if {$Fcolor=="-1"} { set Classe "C999" } else { set Classe "C$Fcolor" }
	    if {[info exists OldColScoNot] && $ColScoNot!=$OldColScoNot} {
		if {$OldItem==$ItemVide} { set Bulle "No feature" } else { set Bulle $OldTexteBulle }
		if {$AvecZones} {
		    set L [string length $Mot]
  	            set Mot "<img src='http://lbgi.fr/transdot.gif' class='transdot' height='1px' width='${L}px'/>"
		    lappend LesLettres $Mot
		} else {
		    lappend LesLettres [H_Href $Mot "" "title='$Bulle' alt='$Bulle' name='$Bulle'"]
		}
		lappend LesClasses $OldClasse
		set Mot $AA
		set OldColScoNot $ColScoNot
		set OldClasse $Classe
		set OldItem $Item
		set OldTexteBulle $TexteBulle
		set OldFnote $Fnote
		continue
	    }
	    set OldColScoNot $ColScoNot
	    set OldClasse $Classe
	    set OldItem $Item
	    set OldTexteBulle $TexteBulle
	    set OldFnote $Fnote
	    append Mot $AA
	}
	if {$Mot!=""} {
	    if {$Item==$ItemVide} { set Bulle "No feature" } else { set Bulle $OldTexteBulle }
	    if {$AvecZones} {
		set L [string length $Mot]
		set Mot "<img src='http://lbgi.fr/transdot.gif' class='transdot' height='1px' width='${L}px'/>"
		lappend LesLettres [H_Href $Mot "" "title='$Bulle' alt='$Bulle' name='$Bulle'"]
	    } else {
		lappend LesLettres [H_Href $Mot "" "title='$Bulle' alt='$Bulle' name='$Bulle'"]
	    }
	    lappend LesClasses $Classe
	}
    }
    return [H_ColoredLetters $LesLettres $LesClasses]
}

proc H_StyleImageTransdot {} {
    lappend LesClassesValeurs "transdot" "background-image: url(http://lbgi.fr/transdot.gif)"
    return [H_StyleClassePourBalise "img" $LesClassesValeurs]
}

proc H_StyleSpanPadding {} {
    lappend LesClassesValeurs "" "padding-top:3px; padding-bottom:3px" 
    return [H_StyleClassePourBalise "span" $LesClassesValeurs]
}

proc H_StyleDesCouleursColSco {} {
    lappend LesClassesValeurs "cs0" "color:black ; background:lightgrey;" 
    lappend LesClassesValeurs "cs1" "color:white ; background:black;"
    return [H_StyleClassePourBalise "span" $LesClassesValeurs "WithElement_a"]
}

proc H_StyleDesCouleursSeqlab {} {
    foreach {A F B} [LesCouleursSeqlabDesAAs LaListeMerci] {
	lappend LesClassesValeurs $A "color:$F ; background:$B;" 
    }
    return [H_StyleClassePourBalise "span" $LesClassesValeurs "WithElement_a"]
}

proc H_StyleDesCouleursFtype {} {
    foreach Couleur [CouleurSeqlab "LaListeMerci"] {
	set N [CouleurSeqlab $Couleur]
	if {$N<0} { set N 999 }
	set Classe "C$N"
	set Fg "Magenta"
	set FgBg [LesCouleursSeqlabDesAAs "fg_and_bg_of_bg_$Couleur"]
	scan $FgBg "%s" Fg
	lappend LesClassesValeurs $Classe "color:$Fg ; background:$Couleur;" 

	#rR 2017/11/24
	set ClasseCouleur "C$Couleur"
	lappend LesClassesValeurs $ClasseCouleur "color:$Fg ; background:$Couleur;"
	if {$Couleur!=[string tolower $Couleur]} {
	    set ClasseCouleur "C[string tolower $Couleur]"
	    lappend LesClassesValeurs $ClasseCouleur "color:$Fg ; background:$Couleur;"
	}
    }
    return [H_StyleClassePourBalise "span" $LesClassesValeurs "WithElement_a"]
}

proc LesCouleursSeqlabDesAAs {AA {Hexa ""}} {
    #rR rajout de Hexa
    global LesCouleursSeqlabDesAAs

    if {[regexp "fg_and_bg_of_bg" $AA]} { set AA [string tolower $AA] }
    
    if {[string length $AA]==1} {
	set AA [string toupper $AA]
    }
    if {$AA==" "} { set AA "Space" }
    if {$AA=="."} { set AA "Dot" }
    if {$AA=="-"} { set AA "Hyphen" }
    if {$AA=="~"} { set AA "Tilde" }
    if {[info exists LesCouleursSeqlabDesAAs($AA,$Hexa)]} {return $LesCouleursSeqlabDesAAs($AA,$Hexa)} 
    if {[info exists LesCouleursSeqlabDesAAs($AA)]} {return $LesCouleursSeqlabDesAAs($AA)} 
    if {[info exists LesCouleursSeqlabDesAAs("EstCharge")]} {
	if {[regexp "fg_and_bg_of_bg" $AA]} { return "black unknown" }
	return $LesCouleursSeqlabDesAAs("EstCharge")
    }
    lappend AFB I white magenta
    lappend AFB L white magenta
    lappend AFB M white magenta
    lappend AFB V white magenta
    lappend AFB R white blue
    lappend AFB K white blue
    lappend AFB F white red
    lappend AFB Y white red
    lappend AFB W white red
    lappend AFB D white forestgreen
    lappend AFB E white forestgreen
    lappend AFB Q white green
    lappend AFB P white black
    lappend AFB G black orange
    lappend AFB H black cyan
    lappend AFB N black cyan
    lappend AFB S white darkviolet
    lappend AFB T white darkviolet
    lappend AFB A white darkviolet
    lappend AFB C white darkviolet
    lappend AFB "Space"   white darkslategrey
    lappend AFB "Dot"     white darkslategrey
    lappend AFB "Hyphen"  white darkslategrey
    lappend AFB "Tilde"   white darkslategrey
    lappend AFB "NoValue" white darkslategrey
    
    set LesCouleursSeqlabDesAAs(LaListeMerci) $AFB
    foreach {A F B} $AFB {
	lappend LesCouleursSeqlabDesAAs(ListeDesAAs) $A
	lappend LesCouleursSeqlabDesAAs(ListeDesFGs) $F
	lappend LesCouleursSeqlabDesAAs(ListeDesBGS) $B
	set LesCouleursSeqlabDesAAs($A) "$F $B"
	set LesCouleursSeqlabDesAAs($A,Hexa) "[ColorHexa $F] [ColorHexa $B]"
	set LesCouleursSeqlabDesAAs(fg_and_bg_of_bg_$B) "$F $B"
	set LesCouleursSeqlabDesAAs(fg_and_bg_of_bg_$B,hexa) "[ColorHexa $F] [ColorHexa $B]"
    }
    set LesCouleursSeqlabDesAAs("EstCharge") $LesCouleursSeqlabDesAAs(NoValue)
    return [LesCouleursSeqlabDesAAs $AA]
}

proc LaFtableDansLOrdre {NoeudFtable {Quoi ""}} {
    if {$Quoi==""} {set Quoi "AllTypes"}
    set LesFtype {}
    set LesFitem {}
    foreach NoeudFitem [$NoeudFtable selectNodes "fitem"] {
	set Ftype  [$NoeudFitem selectNodes "string(ftype)"]
	lappend LesFtype $Ftype
	if {$Quoi=="TypeList"} { continue }
	set Fstart [$NoeudFitem selectNodes "string(fstart)"]
	set Fstop  [$NoeudFitem selectNodes "string(fstop)"]
	set Fcolor [$NoeudFitem selectNodes "string(fcolor)"]
	set Fscore [$NoeudFitem selectNodes "string(fscore)"]
	set Fnote  [$NoeudFitem selectNodes "string(fnote)"]
	if {$Quoi=="$Ftype" || $Quoi=="AllTypes"} {
	    set Fitem [list $Ftype $Fstart $Fstop $Fcolor $Fscore $Fnote]
	    lappend LesFitem $Fitem 
	}
    }
    if {$Quoi=="TypeList"} {
	set LesFtype [lsort -unique $LesFtype]
	return $LesFtype
    }
    set LesFitem [lsort -index 1 -integer $LesFitem]
    return $LesFitem
}

proc HtmlFromMsf  {NomOuFichier {Format ""} {FichierHtml ""} {TitreDeLaPage ""}} {
    set Nom [file tail $NomOuFichier]
    while 1 {
	set FichierMsf $NomOuFichier
	if {[regexp "/" $FichierMsf] && [file exists $FichierMsf]} { break }
	if { ! [EstUnPAB $Nom]} { break }
	if {[regexp "^/" $NomOuFichier]} { break }
	set FichierMsf "[RepertoireDuGenome]/$NomOuFichier"
	if {[file exists $FichierMsf]} { break }
	set FichierMsf "[RepertoireDuGenome]/msf/$Nom"
	if {[file exists $FichierMsf]} { break }
	return ""
    }
    set FichierXml "[TmpFile $Nom].xml"
    if {[catch {exec clustalw $FichierMsf -convert -outfile=$FichierXml -output=macsim} Message]} {
	return "$Message"
    }
    if { ! [file exists $FichierXml]} { return "" }
    return [HtmlFromXmlMacsim $FichierXml $Format $FichierHtml $TitreDeLaPage]
}

proc ReglePourAli {Largeur {Space ""} {Pointeur ""} {Pas ""} {Debut ""}} {

    if {$Space==""} { set Space "\\&nbsp;" }

    if {$Debut==""} { set Debut 1 }
    if {$Pas==""} { set Pas 10 }
    if {$Pointeur==""} { set Pointeur "." }
    if {$Pointeur=="NoPoint"} { set Pointeur "" }

    set Regle "$Debut[string repeat " " [expr $Pas-[string length $Debut]-1]]"
    set X [expr $Pas-[string length $Pointeur]]
    set Format "$Pointeur%-${X}s"
    set N $Pas
    while {$N<$Largeur} {
	append Regle [format $Format $N]
	incr N $Pas
    }
    regsub -all " " $Regle $Space Regle 
    return $Regle
}

proc CreateAllHtmlFromXmlMacsim {NomOuFichier {Format ""} {RacineForAll ""} {TitreDeLaPage ""}} {
    #rR attention inversion des args
    return [HtmlFromXmlMacsim $NomOuFichier $Format "CreateAllHtml" $TitreDeLaPage $RacineForAll]
}

proc H_JavascriptPourWaliLite {} {
    set LeJs {}
    lappend LeJs "<script>"
    lappend LeJs "function FontSize (valeur) \{"
    lappend LeJs "  var size = document.getElementById('divAlignement').style.getPropertyValue('font-size');"
    lappend LeJs "  var n = parseInt(size);"
    lappend LeJs "  console.log(valeur);"
    lappend LeJs "  if (valeur.match(/^\[\-\+\]/)) \{"
    lappend LeJs "    n = n + parseInt(valeur);"
    lappend LeJs "  \} else \{"
    lappend LeJs "    n = parseInt(valeur);"
    lappend LeJs "  \}"
    lappend LeJs "  if (n<1) \{ n = 12; \}"
    lappend LeJs "  document.getElementById('divAlignement').style.fontSize = n+'px';"
    lappend LeJs "  document.getElementById('FontSizeValue').innerHTML = 'FontSize '+n+' px';"
    lappend LeJs "\}"
    lappend LeJs ""
    lappend LeJs "function ScrollInput (event) \{"
    lappend LeJs "  console.log(event.keyCode)"
    lappend LeJs "  console.log(event.which)"
    lappend LeJs "  var keyPressed = event.keyCode || event.which"
    lappend LeJs "  console.log(keyPressed)"
    lappend LeJs "  if ( keyPressed!=13 && keyPressed!=1 ) \{ return false; \}"
    lappend LeJs "  var valeur = document.getElementById('ScrollInput').value"
    lappend LeJs "  Scroll(valeur)"
    lappend LeJs "  return true"
    lappend LeJs "\}"
    lappend LeJs ""
    lappend LeJs "function Scroll (valeur) \{"
    #lappend LeJs "  var scrollTarget = 'window'"
    #lappend LeJs "  var scrollTarget = document.getElementById('divAlignement')"
    lappend LeJs "  var FontSize = parseInt(document.getElementById('divAlignement').style.getPropertyValue('font-size'));"
    lappend LeJs "  var offset = window.pageXOffset || document.documentElement.scrollLeft;"
    lappend LeJs "  var offset = scrollTarget.scrollLeft;"
    lappend LeJs "  console.log(offset);"
    lappend LeJs "  offset = parseInt(offset);"
    lappend LeJs "  var delta = (1000./1600.)*parseInt(valeur)*FontSize;"
    lappend LeJs "  if (valeur.match(/^\[\-\+\]/)) \{"
    lappend LeJs "    offset = offset + delta;"
    lappend LeJs "  \} else \{"
    lappend LeJs "    offset = delta;"
    lappend LeJs "  \}"
    lappend LeJs "  if (offset<0) \{ offset = 0; \}"
    lappend LeJs "  offset = parseInt(offset);"
    lappend LeJs "  window.scrollTo(offset, 0);"
    #lappend LeJs "  scrollTarget.scrollTo(offset, 0);"
    lappend LeJs "  val = offset/((1000./1600.)*FontSize);"
    lappend LeJs "  document.getElementById('ScrollInput').value = Math.round(val);"
    lappend LeJs "\}"
    lappend LeJs ""

    lappend LeJs "</script>"
    set Js [join $LeJs "\n"]
    return $Js
}


proc HtmlFromXmlMacsim {NomOuFichier {Format ""} {FichierHtml ""} {TitreDeLaPage ""} {RacineForAll ""} {LinkToPipealign ""}} {
    global MemoXmlMacsim

    package require tdom

    set PathToXmlFile $NomOuFichier
    regsub "^paligndepot" $PathToXmlFile "/tempor/palign/depot" PathToXmlFile
    regsub "^misynpat"    $PathToXmlFile "/home/ripp/msp/data/alignments" PathToXmlFile

    #rR il y a des - pour pouvoir mettre des defauts non vides
    if {$Format=="-"}          { set Format "" }
    if {$FichierHtml=="-"}     { set FichierHtml "" }
    if {$TitreDeLaPage=="-"}   { set TitreDeLaPage "" }
    if {$RacineForAll=="-"}    { set RacineForAll "" }
    if {$LinkToPipealign=="-"} { set LinkToPipealign "" }

    set WithoutHeader [regexp -nocase "WithoutHeader" $FichierHtml]
    if {$WithoutHeader} {
	regsub -nocase "WithoutHeader" $FichierHtml "" FichierHtml
    }
    
    set WithLinkToPipealign 0
    if {$LinkToPipealign!=""} {
	set WithLinkToPipealign 1
	set Science [file tail [RepertoireDuGenome]]
	regsub "/Science/" $LinkToPipealign "/$Science/" LinkToPipealign
    }

    set AvecZones 0
    if {[regexp -nocase "AvecZones" $Format]} {
	set AvecZones 1
	regsub -nocase "AvecZones" $Format "" Format
    }

    if {$Format==""} { set Format "Normal" }
    set CouleurNormal [string equal -nocase $Format "Normal"]
    set CouleurSeqLab [string equal -nocase $Format "SeqLab"]
    set CouleurFtype  [regexp -nocase "^Ftype_(.+)" $Format Match Ftype]
    set DescriptionOnly [string equal -nocase "Description" $Format]
    set Nom [file tail $NomOuFichier]
    while 1 {
	set FichierXml $PathToXmlFile
	if {[regexp "/" $FichierXml]} { break }
	if { ! [EstUnPAB $Nom]} { break }
	set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom"
	if {[file exists $FichierXml]} { break }
	set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom.xml"
	if {[file exists $FichierXml]} { break }
	return ""
    }

    set LinkToRivet 0
    if {[regexp -nocase "WithLinkToRivet_(.*)" $FichierHtml Match RivetLink]} {
	set LinkToRivet 1
	set FichierHtml "DisplayHtml"
    }
    set LinkToHtml 0
    if {[regexp -nocase "WithLinkToHtml_(.*)" $FichierHtml]} {
	set LinkToHtml 1
	regsub -nocase "WithLinkToHtml_" $FichierHtml "" FichierHtml
    }
    set CreateAllHtml 0
    if {[regexp "CreateAllHtml" $FichierHtml]} {
	if {$RacineForAll=="" || $RacineForAll=="-"} { set RacineForAll "${FichierHtml}_" }
	set CreateAllHtml 1
    }

    if {$FichierHtml=="" || $FichierHtml=="-" } { set FichierHtml "GetHtml" }
    if {$FichierHtml=="macsimHtml"} {
	if {[regexp "/macsimXml/" $FichierXml]} {
	    regsub "/macsimXml/" $FichierXml "/macsimHtml/" FichierHtml
	} else {
	    set FichierHtml $FichierXml
	}
	regsub ".xml$" $FichierHtml "" FichierHtml
	append FichierHtml ".html"
    }

    if {0 && [info exists MemoXmlMacsim($FichierXml)]} {
	set NoeudMacsim $MemoXmlMacsim($FichierXml)
    } else {
	set MacsimXml [ContenuDuFichier $FichierXml]
	set NoeudMacsim [[dom parse $MacsimXml] documentElement]
	set MemoXmlMacsim($FichierXml) $NoeudMacsim
    }
    set TexteColoring "with $Format colors"
    if {$Format=="Normal"} { set TexteColoring "without coloring" }
    if {[info proc OnTraiteSpine]!="" && [OnTraiteSpine]} {
	set Titre "Gscope summary of $Nom for Spine"
    } else {
	set Titre $TitreDeLaPage
	if {$Titre=="" || $Titre=="-"} {
	    set DateEnvoi "  created [Date Nice]"
	    set Titre "Wali-lite Macsim's output of $Nom [Alias $Nom] ($TexteColoring) $DateEnvoi"
	} else {
	    append Titre " ($TexteColoring)"
	}
    }

    set Header "<style> a {text-decoration:none;color:black;} body {margin:0px;} #divAlignement {background-color:white;} #Scroll button {font-size:12px;} #Scroll input {font-size:12px; width:3em;} </style>"
    set  CouleurColSco 1
    if {$CouleurColSco} { append Header "\n[H_StyleDesCouleursColSco]" }
    if {$CouleurSeqLab} { append Header "\n[H_StyleDesCouleursSeqlab]" }
    if {$CouleurFtype}  { append Header "\n[H_StyleDesCouleursFtype]"  }
    if { ! $AvecZones}  { append Header "\n[H_StyleSpanPadding]"       }

    append Header "\n[H_JavascriptPourWaliLite]"

    Html_ZeroToBody $Titre $Header

    set NoeudAli [$NoeudMacsim selectNodes "alignment"]
    set AlnName  [$NoeudAli selectNodes "string(aln-name)"]


    Html_Append "<div id='Scroll' style='position:fixed; right:10px; top:13em; z-index:1;'>"
    Html_Append "Scroll "
    Html_Append "<button width='8px' onclick='Scroll(\"-100\");'>-100</button>"
    Html_Append "<button onclick='Scroll(\"-10\");'>-10</button>"
    Html_Append "<button onclick='Scroll(\"-1\");'>-1</button>"
    Html_Append "<input id='ScrollInput' onKeypress='ScrollInput(event)' value='0'/>"
    Html_Append "<button onclick='Scroll(\"+1\");'>+1</button>"
    Html_Append "<button onclick='Scroll(\"+10\");'>+10</button>"
    Html_Append "<button onclick='Scroll(\"+100\");'>+100</button>"
    Html_Append "</div>"

    Html_Append "<!-- Debut du Header -->"

    set PositionPourHeaderFixe [Html_GetPosition]
    Html_Append "<div id='headerMobile' style='margin-top:0px;padding:10px 10px 5px 10px;width:100%;background-color:white;'>" 

    if { ! $WithoutHeader } { Html_Banner Wscope }
    if { ! $LinkToHtml && ! $CreateAllHtml } {
	if {[OnTraiteSpine]} {
	    set SpineID  [ExtraitInfo $Nom "SpineID"]
	    set SpineRef [ExtraitInfo $Nom "SpineRef"]
	    set SpineDef [ExtraitInfo $Nom "SpineDef"]
	    set Entete $Titre
	    regsub "Wali\-lite" $Entete "" Entete
	    set Entete "<img width='50px' src='http://lbgi.fr/wali/images/logoWali'/> <i style='font-size:2em;'>Wali-lite</i> &nbsp;&nbsp; $Entete"
	    Html_Append [H_BalAtt $Entete "h4" "align='centre'"]
	    
	    lappend Liste 2
	    lappend Liste "border='1' cellpadding='1' cellspacing='1'"
	    lappend Liste ""
	    lappend Liste "bgcolor='green' nowrap='nowrap'"
	    lappend Liste "bgcolor='orange' nowrap='nowrap'"
	    
	    lappend Liste "GscopeID"  $Nom
	    lappend Liste "SpineID"   $SpineID
	    lappend Liste "SpineRef"  [H_Href $SpineRef [WgetzSurWeb $SpineRef "" "GetUrl"]]
	    lappend Liste "SpineDef"  $SpineDef
	    Html_TableFromList $Liste
	}
    }

    set Entete $Titre
    regsub "Wali-lite" $Entete "" Entete
    set Entete "<img width='50px' src='http://lbgi.fr/wali/images/logoWali'/> <i style='font-size:2em;'>Wali-lite</i> &nbsp;&nbsp; $Entete"
    append Entete "&nbsp;&nbsp;&nbsp;&nbsp;"
    append Entete "<span onclick='FontSize(\"-1\");'>-</span>"
    append Entete "&nbsp;&nbsp;"
    append Entete "<span id='FontSizeValue'>FontSize 12 px</span>"
    append Entete "&nbsp;&nbsp;"
    append Entete "<span onclick='FontSize(\"+1\");'>+</span>"
    append Entete "&nbsp;&nbsp;"
    append Entete "<span onclick='FontSize(\"1\");'>1</span>"
    append Entete "&nbsp;&nbsp;"
    append Entete "<span onclick='FontSize(\"5\");'>5</span>"
    append Entete "&nbsp;&nbsp;"
    append Entete "<span onclick='FontSize(\"8\");'>8</span>"
    append Entete "&nbsp;&nbsp;"
    append Entete "<span onclick='FontSize(\"10\");'>10</span>"
    append Entete "&nbsp;&nbsp;"
    append Entete "<span onclick='FontSize(\"12\");'>12</span>"
    append Entete "&nbsp;&nbsp;"
    append Entete "<span onclick='FontSize(\"14\");'>14</span>"
    append Entete "&nbsp;&nbsp;"
    append Entete "<span onclick='FontSize(\"18\");'>18</span>"
    Html_Append [H_BalAtt $Entete "h4"]

    set LaHaut [Html_GetPosition]
    Html_Append "</div>"
    Html_Append "<!-- Fin du Header -->"

    set DivAroundTheTable 0
    Html_BaliseOpen "div" "id='divAlignement' style='font-family:courier; font-size:12px;'"
    if {$DescriptionOnly} {
	Html_BaliseOpen "table" "border='1' cellpadding='1' cellspacing='2'"
	set MettreRegleAvant 0
    } else {
	set DivAroundTheTable 1
	Html_BaliseOpen "div" "border='3' style='margin:5px;'"
	Html_BaliseOpen "table" "border='0' cellpadding='0' cellspacing='0'"
	set MettreRegleAvant 1
    }
    if {$AvecZones} {set MettreRegleAvant 0} 
    set TousLesColumnScore {}
    foreach NoeudColumnScore [$NoeudAli selectNodes "column-score"] {
	if {$AvecZones || $DescriptionOnly} { break }
	set ColscoName  [$NoeudColumnScore selectNodes "string(colsco-name)"]
	set ColscoOwner [$NoeudColumnScore selectNodes "string(colsco-owner)"]
	if {$ColscoOwner!=0} { continue }
	set ColscoType  [$NoeudColumnScore selectNodes "string(colsco-type)"]
	set ColscoData  [$NoeudColumnScore selectNodes "string(colsco-data)"]
	
	set LesColonnes {}
	if {[regexp {core.?block} $ColscoName]} {
	    foreach Score [split [string trim $ColscoData] " "] {
		set Car "?"
		if {$Score=="-1"} { set Car "." }
		if {$Score=="0"}  { set Car "<span class='cs0'>-</span>" }
		if {$Score=="1"}  { set Car "<span class='cs1'>|</span>" }
		lappend LesColonnes $Car
	    }
	} else {
	    if {[string equal -nocase $ColscoType "int"]} {
		set LesCarPourInt "01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ"
		foreach Score [split $ColscoData " "] {
		    set Car [lindex $LesCarPourInt $Score]
		    if {$Car==""} { set Car "?" }
		    lappend LesColonnes $Car
		}		    
	    }
	}
	set Colonnes [join $LesColonnes ""]
	if {$Colonnes!="" && $MettreRegleAvant} {
	    set MettreRegleAvant 0
	    set LargeurAlignement [llength $LesColonnes]

	    Html_BaliseOpen "tr"
	    Html_BaliseOpen "td"
	    Html_BaliseClose "td"
	    Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap'" 
	    Html_Append [ReglePourAli $LargeurAlignement]
	    Html_BaliseClose "td"
	    Html_BaliseClose "tr"
	}

	Html_BaliseOpen "tr"

	Html_BaliseOpen "td" "bgcolor='yellow' nowrap='nowrap'"
	Html_Append "$ColscoName"
	Html_BaliseClose "td"

	Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap' onClick='javascript:alert(\\'Column score $ColscoName\\')'"
	Html_Append $Colonnes
	Html_BaliseClose "td"

	Html_BaliseClose "tr"
    }
    set TousLesFtype {}
    set PreviousGroup ""
    foreach NoeudSequence [$NoeudAli selectNodes "sequence"] {
	set SeqName    [$NoeudSequence selectNodes "string(seq-name)"]
	set NoeudInfo  [$NoeudSequence selectNodes "seq-info"]
	set Accession  [$NoeudInfo     selectNodes "string(accession)"]
	set Definition [$NoeudInfo     selectNodes "string(definition)"]
	set Organisme  [$NoeudInfo     selectNodes "string(organism)"]
	set Group      [$NoeudInfo     selectNodes "string(group)"]
	if {[EstUnAccessPDB $Accession]} {
	    set Acc $Accession
	    regsub {_.*} $Acc "" Acc
	} else {
	    set Acc "uniprot:$Accession"
	}
	#rR attention a verifier car j'y ai mis Uniprot pour depanner.
	set Url [WgetzSurWeb "$Acc" "" "GetUrl"]
	set SeqData [$NoeudSequence selectNodes "string(seq-data)"]
	regsub -all -nocase {[^\.\-a-z]} $SeqData "" SeqData
	set SeqData [string toupper $SeqData]
	
	set NoeudFtable [$NoeudInfo selectNodes "ftable"]
	if {$NoeudFtable==""} {
	    set MesFtype {}
	    set Ftable ""
	} else {
	    set MesFtype [LaFtableDansLOrdre $NoeudFtable "TypeList"]
	    LConcat TousLesFtype $MesFtype
	    if {$CouleurFtype} {
		set Ftable [LaFtableDansLOrdre $NoeudFtable "$Ftype"]
	    }
	}
	if {$MettreRegleAvant} {
	    set MettreRegleAvant 0
	    set LargeurAlignement [string length $SeqData]	    
	    Html_BaliseOpen "tr"
	    Html_BaliseOpen "td"
	    Html_BaliseClose "td"
	    Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap'" 
	    Html_Append [ReglePourAli $LargeurAlignement]
	    Html_BaliseClose "td"
	    Html_BaliseClose "tr"
	}

	if {$PreviousGroup!=$Group} {
	    Html_BaliseOpen "tr"
	    Html_BaliseOpen "td" "style='text-align:right;'"
	    Html_Append "Group $Group"
	    Html_BaliseClose "td"
	    Html_BaliseClose "tr"
	}
	set PreviousGroup $Group

	Html_BaliseOpen "tr"

	if {$AvecZones} {
	} else {
	    Html_BaliseOpen "td" "bgcolor='yellow' nowrap='nowrap'"
	    Html_Href $SeqName $Url "title='$Definition' target='_blank'"
	    Html_BaliseClose "td"
	}
	if {$DescriptionOnly} {
	    Html_BaliseOpen "td" "bgcolor='lightgreen' nowrap='nowrap'"
	    Html_Append " $Definition "
	    Html_BaliseClose "td"
	    Html_BaliseOpen "td" "bgcolor='green' nowrap='nowrap'"
	    Html_Append " $Organisme "
	    Html_BaliseClose "td"
	} else {
	    Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap' \
		    onClick='javascript:alert(\\'$SeqName $Definition $Organisme\\')'"
	    if {$CouleurNormal} { Html_Append [LaSequenceColoree $SeqData "Normal"] }
	    if {$CouleurSeqLab} { Html_Append [LaSequenceColoree $SeqData "Seqlab"] }
	    if {$CouleurFtype}  { Html_Append [LaSequenceColoree $SeqData "Ftype" $Ftable $AvecZones] }
	    Html_BaliseClose "td"
	}

	Html_BaliseClose "tr"
    }
    if { ! $DescriptionOnly && ! $AvecZones} {
	Html_BaliseOpen  "tr"
	Html_BaliseOpen  "td"
	Html_BaliseClose "td"
	Html_BaliseOpen  "td" "color='black' bgcolor='white' nowrap='nowrap'" 
	Html_Append [ReglePourAli $LargeurAlignement]
	Html_BaliseClose "td"
	Html_BaliseClose "tr"
    }

    if {$DivAroundTheTable} { Html_BaliseClose "div" }
    Html_BaliseClose "table"
    Html_BaliseClose "span"

    set AvecATV [file exists "[RepertoireDuGenome]/phylos"]

    set AvecAutresBoutons [expr $WithLinkToPipealign || [OnTraiteSpine] || [OnTraiteBalibase] || [OnTraitePeroxisome] \
	    || [MacsimExiste] || [OnTraite "KoAnno"]]
    set LesBoutons {}
    if {$AvecAutresBoutons} {
	if { ! $LinkToHtml && ! $CreateAllHtml } {
	    lappend LesBoutons "Other infos" "FileMoi $Nom"
	    lappend LesBoutons "Description" "HtmlFromXmlMacsim $Nom Description"
	    if {$AvecATV} {
		lappend LesBoutons "ATV PhyloTree" "ATV $Nom"
	    }
	}
	#rR je ne comprends pas bien comment c'était foutu avant car le if de AvecAutresBoutons couvrait toute la création des boutons Ftype :(
    }

    set LinkM $LinkToPipealign
    set LinkS $LinkToPipealign
    if {[regexp {^/pampas/} $LinkToPipealign]} {
	regsub {/Macsims/*} $LinkM "/Macsims/-" LinkM
	regsub {/Macsims/*} $LinkS "/Macsims/SeqLab" LinkS
    }
    lappend LesBoutons "No colors" "HtmlFromXmlMacsim $NomOuFichier - $FichierHtml $TitreDeLaPage $RacineForAll $LinkM"
    lappend LesBoutons "AA colors" "HtmlFromXmlMacsim $NomOuFichier SeqLab $FichierHtml $TitreDeLaPage $RacineForAll $LinkS"
    set TousLesFtype [lsort -unique $TousLesFtype]
    foreach Ftype $TousLesFtype {
	lappend LesBoutons "$Ftype" "HtmlFromXmlMacsim $NomOuFichier Ftype_$Ftype $FichierHtml $TitreDeLaPage $RacineForAll $LinkToPipealign"
    }
    Html_NewLine
    
    set LeMenu {}
    lappend LeMenu [Html_BaliseOpen "table" "border='1' cellpadding='1' cellspacing='3'"]
    lappend LeMenu [Html_BaliseOpen "tr"]
    foreach {Text Action} $LesBoutons {
	if {$LinkToHtml || $CreateAllHtml} {
	    set Quoi [lindex [split $Action " "] 2]
	    set Queue [file tail $RacineForAll]
	    set RfA $RacineForAll
	    if {$RfA=="-"} { set RfA "" }
	    if {$Queue=="-"} { set Queue "" }
	    set UrlAction "${Queue}_$Quoi.html"
	    if {$CreateAllHtml && ! [info exists DejaFait($Quoi)]} {
		set WH "" ; if {$WithoutHeader} { set WH "WithoutHeader" }
		lappend AllHtml [HtmlFromXmlMacsim $FichierXml $Quoi "${WH}WithLinkToHtml_${RfA}_$Quoi.html" $TitreDeLaPage $RacineForAll]
		set DejaFait($Quoi) 1
	    }
	} elseif {$WithLinkToPipealign} {
	    if {[regexp {^/pampas/} $LinkToPipealign]} {
		set FT [lindex [split $Action " "] 2]
		set UrlAction $LinkToPipealign
		regsub {/Macsims.*$}  $UrlAction "/Macsims/$FT" UrlAction 
	    } else {
		set UrlAction "$LinkToPipealign?$Action"
	    }
	    regsub -all " " $UrlAction {\&} UrlAction
	} elseif {$LinkToRivet} {
	    set UrlAction "$RivetLink?$Action WithLinkToRivet_$RivetLink"
	} else {
	    regsub -all " " $Action {\&} Action
	    set UrlAction "[WscopeScience]&$Action"
	}
	lappend LeMenu [Html_BaliseOpen "td" "bgcolor='yellow' nowrap='nowrap'"]
	lappend LeMenu [Html_Href $Text $UrlAction "title='Reload alignment'"]
	lappend LeMenu [Html_BaliseClose "td"]
    } 
    lappend LeMenu [Html_BaliseClose "tr"]
    lappend LeMenu [Html_BaliseOpen "tr"]
    foreach {Text Action} $LesBoutons {
	if {[regexp "Ftype_" $Action]} {
	    regsub "Ftype_" $Action "AvecZonesFtype_" Action
	    set Text "no text"
	}
	if {$LinkToHtml || $CreateAllHtml} {
	    set Quoi [lindex [split $Action " "] 2]
	    set Queue [file tail $RacineForAll]
	    set UrlAction "${Queue}_$Quoi.html"
	    if {$CreateAllHtml && ! [info exists DejaFait($Quoi)]} {
		set WH "" ; if {$WithoutHeader} { set WH "WithoutHeader" }
		lappend AllHtml [HtmlFromXmlMacsim $FichierXml $Quoi "${WH}WithLinkToHtml_${RacineForAll}_$Quoi.html" $TitreDeLaPage $RacineForAll]
	    }
	} elseif {$WithLinkToPipealign} {
	    if {[regexp {^/pampas/} $LinkToPipealign]} {
		set FT [lindex [split $Action " "] 2]
		set UrlAction $LinkToPipealign
		regsub {/Macsims.*$}  $UrlAction "/Macsims/$FT" UrlAction 
	    } else {
		set UrlAction "$LinkToPipealign?$Action"
	    }
	    regsub -all " " $UrlAction {\&} UrlAction
	} elseif {$LinkToRivet} {
	    set UrlAction "$RivetLink/$Action WithLinkToRivet_$RivetLink"
	} else {
	    regsub -all " " $Action {\&} Action
	    set UrlAction "[WscopeScience]&$Action"
	}
	lappend LeMenu [Html_BaliseOpen "td" "bgcolor='yellow' nowrap='nowrap'"]
	lappend LeMenu [Html_Href $Text $UrlAction "title='Reload alignment'"]
	lappend LeMenu [Html_BaliseClose "td"]
    } 
    lappend LeMenu [Html_BaliseClose "tr"]
    lappend LeMenu [Html_BaliseClose "table"]
    lappend LeMenu [Html_NewLine]
    
    Html_Insert $LaHaut [join $LeMenu "\n"]
    #rR la fin du if AvecAutresBoutons était là !!!!!!!!!!!!!!!!! pourquoi ??????


    set HtmlDejaFait [Html_Get]
    if {[regexp {<!\-\- Debut du Header \-\->(.*)<!\-\- Fin du Header \-\->} $HtmlDejaFait Match HeaderMobile]} {
	regsub "<div id='headerMobile' style='" $HeaderMobile "<div id='headerMobile' style='position:fixed;" HeaderFixe
	Html_Insert $PositionPourHeaderFixe $HeaderFixe 
    }

    Html_BodyToEnd

    if {$CreateAllHtml} { return [join $AllHtml "\n"] }

    if {$FichierHtml=="GetHtml"} { return [Html_Get] }
    if {$FichierHtml=="ShowHtml"} { return [AfficheVariable [Html_Get] "" "macsimHtml/$Nom"] }
    if {$FichierHtml=="DisplayHtml"} { puts [Html_Get]; return [Html_Get "ZeroIt"] }
    return [Sauve [Html_Get] dans $FichierHtml] 
    
}

proc MergeXmlForSpinePourTous {} {
    foreach Nom [ListeDesPABs] {
	MergeXmlForSpine $Nom
    }
}

proc MergeXmlForSpine Nom {
    set FichierXmlFromSpine "[RepertoireDuGenome]/XmlFromSpine/$Nom"
    set FichierMacsimXml    "[RepertoireDuGenome]/macsimXml/$Nom"

    if { ! [file exists $FichierXmlFromSpine] || \
	    ! [file exists $FichierMacsimXml]} { return "" }
 
    set OneSpineXML [ContenuDuFichier $FichierXmlFromSpine]

    set NoeudTarget [[dom parse $OneSpineXML] documentElement]
    set ID          [$NoeudTarget selectNodes "string(ID)"] 
    set Workpackage [$NoeudTarget selectNodes "string(workpackage)"]
    set Workpackage [string trim $Workpackage]
    set Sequence    [$NoeudTarget selectNodes "string(sequence)"]
    set ProteinName [$NoeudTarget selectNodes "string(proteinName)"] 
    set Species     [$NoeudTarget selectNodes "string(species)"]
    set LesNar {}
    foreach NoeudDbID [$NoeudTarget selectNodes "databaseID"] {
	set DatabaseID  [$NoeudDbID selectNodes "string(.)"]
	set Database    [$NoeudDbID selectNodes "string(database)"]
	set Release     [$NoeudDbID selectNodes "string(release)"]
	set Accession   [$NoeudDbID selectNodes "string(accession)"]
	set DB $Database
	if {$Database=="not provided"} { set DB "unk" }
	if {$Accession=="" || $Accession=="not provided"} {
	    set MonNar ""
	} else {
	    set MonNar "$DB:$Accession"
	}
	lappend LesNar $MonNar
    }
    set Nar [join $LesNar ","]
    set TexteOS ""
    if {$Species!="" || $Species!="not provided"} {
	set TexteOS "of $Species"
    }

    set MacsimXml [ContenuDuFichier $FichierMacsimXml]
    set NoeudMacsim [[dom parse $MacsimXml] documentElement]

    set NoeudAli [$NoeudMacsim selectNodes "alignment"]
    set AlnName  [$NoeudAli selectNodes "string(aln-name)"]
    foreach NoeudSequence [$NoeudAli selectNodes "sequence"] {
	set  SeqName [$NoeudSequence selectNodes "string(seq-name)"]
	if {$SeqName==$Nom} { break }
    }
    if {$SeqName!=$Nom} {
	FaireLire "I can't find the seq-name $Nom in $FichierMacsimXml"
	return ""
    }
    set Organism [$NoeudSequence selectNodes "string(seq-info)"]
    return
}

proc DoctypeForOneSpineTarget {} {
    return {<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE target SYSTEM "target.dtd">
}
}

proc ReadAllSpineXML {{Action ""} {Fichier ""}} {

    Wup "Action can be 'ShowOnly' , 'CompareHeaders' or 'Append"

    if {$Action==""} { set Action "ShowOnly" }

    package require tdom

    if {$Action=="Append"} {
	set DernierPAB [DernierPAB "EnNumero"]
	regsub "SPINE" $DernierPAB "" Numero
	set Fin [Box $DernierPAB fin]
	FaireLire "Please browse for the Xml file with the targets to append"
	if {$Fichier==""} {
	    set Fichier [ButineArborescence All "[RepertoireDuGenome]/DeSpine/"]
	}
    } else {
	set Numero 100000
	set Fin 100
	if {$Fichier==""} {
	    FaireLire "Please browse for the Xml file with all targets"
	    set Fichier [ButineArborescence All "[RepertoireDuGenome]/DeSpine/"]
	}
    }

    if { ! [file exists $Fichier]} { return "" }

    if { $Action=="Append" && ! [OuiOuNon "Are you sure to run \n\
	    ReadAllSpineXML $Fichier\n\
	    creating new PABs after $DernierPAB"]} { return "" }


    set RepXmlFromSpine "[RepertoireDuGenome]/XmlFromSpine"
    if { ! [file exists RepXmlFromSpine]} { file mkdir $RepXmlFromSpine }

    set AllSpineXML [ContenuDuFichier $Fichier]

    set Root [[dom parse $AllSpineXML] documentElement]


    set LesNoeudsTarget [$Root selectNodes "//target"]
    foreach NoeudTarget $LesNoeudsTarget {
	incr Numero 10
	set    OneTargetXml [DoctypeForOneSpineTarget]
	append OneTargetXml [$NoeudTarget asXML -indent 2]

	set ID          [$NoeudTarget selectNodes "string(ID)"] 
	set Workpackage [$NoeudTarget selectNodes "string(workpackage)"]
	set Workpackage [string trim $Workpackage]
	set Sequence    [$NoeudTarget selectNodes "string(sequence)"]
	set ProteinName [$NoeudTarget selectNodes "string(proteinName)"] 
	set Species     [$NoeudTarget selectNodes "string(species)"]
	set LesNar {}
	foreach NoeudDbID [$NoeudTarget selectNodes "databaseID"] {
	    set DatabaseID  [$NoeudDbID selectNodes "string(.)"]
	    set Database    [$NoeudDbID selectNodes "string(database)"]
	    set Release     [$NoeudDbID selectNodes "string(release)"]
	    set Accession   [$NoeudDbID selectNodes "string(accession)"]
	    set DB $Database
	    if {$Database=="not provided"} { set DB "unk" }
	    if {$Accession=="" || $Accession=="not provided"} {
		set MonNar ""
	    } else {
		set MonNar "$DB:$Accession"
	    }
	    lappend LesNar $MonNar
	}
	set Nar [join $LesNar ","]
	set TexteOS ""
	if {$Species!="" || $Species!="not provided"} {
	    set TexteOS "of $Species"
	}

	set Nom "SPINE[format "%5.5d" $Numero]"
	set Entete "$Nom SpineRef ($Nar) SpineDef ($ProteinName $TexteOS) SpineID ($ID of $Workpackage)" 

	if {$Action=="CompareHeaders"} {
	    set FichierTFA "[RepertoireDuGenome]/prottfa/$Nom"
	    set EnteteGscope [EnteteDuFichierTFA $FichierTFA]
	    regsub ">" $EnteteGscope "" EnteteGscope
	    if {$Entete!=$EnteteGscope} {
		FaireLire "$Entete\n$EnteteGscope"
		
	    }
	    continue
	}

	if {$Action=="ShowOnly"} {
	    lappend LesEntetes $Entete
	    continue
	}

	if {$Action!="Append"} {
	    FaireLire "Illegal Action $Action in ReadAllSpineXml\nI'll create nothing !"
	}

	set FichierXmlFromSpine "$RepXmlFromSpine/$Nom"
	Sauve $OneTargetXml dans $FichierXmlFromSpine
	set TFA [SequenceFormatTFA $Sequence $Entete "protbrut"]
	Sauve $TFA dans "[RepertoireDuGenome]/prottfa/$Nom"
	set Debut [expr $Fin + 99]
	set Fin   [expr $Debut + 300]
	set Orient "F"
	Espionne "MiseAJourBornesDesPABs $Nom $Debut $Fin $Orient" 
	MiseAJourBornesDesPABs "$Nom $Debut $Fin $Orient"
    }
    if {$Action=="ShowOnly"} {
	set Page [join $LesEntetes "\n"]
	return [AfficheVariable $Page "GrandeLargeur" "AllSpineHeaders"]
    }    
    exit
}