# HDA Homolog Detection Agreement, X-HDA and its Clusters 

proc CorrigeBspBaph {} {
    exit
    file mkdir "[RepertoireDuGenome]/bilan_xhda_new"
    foreach Nom [ListeDesPABs] {
	set Fichier "[RepertoireDuGenome]/bilan_xhda/$Nom"
	if { ! [file exists $Fichier]} { continue }
	set Nouveau {}
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    if {[regexp -nocase " BSP "  $Ligne]} { continue }
	    if {[regexp -nocase " BAPH " $Ligne]} {
		 regsub -nocase " BAPH " $Ligne " BSP " LigneBSP
		lappend Nouveau $LigneBSP
	    }
	    lappend Nouveau $Ligne	    
	}
	Espionne [SauveLesLignes $Nouveau dans "[RepertoireDuGenome]/bilan_xhda_new/$Nom"]
    }
    Espionne "Il faut encore renommer bilan_xhda_new"
    exit 

    foreach O [FamiliarOrganism "LaListeMerci"] {
	FaireLire "On y va pour $O" 
	set Court [string totitle [Glossaire $O Court]]
	if {$Court=="Saur"} { set Court "Saur2" }
	foreach Type [list blastp tblastn msf] {
	    set FichierOO "/genomics/$Court/fiches/oo$Type"
	    if { ! [file exists $FichierOO]} { continue }
	    set Vieux [Garde $FichierOO]
	    Espionne $Vieux
	    set Nouveau {}
	    foreach Ligne [LesLignesDuFichier $Vieux] {
		if {[regexp "BAPH BAPH " $Ligne]} {
		    regsub  "BAPH BAPH " $Ligne "BSP BAPH " Ligne
		}
		if {[regexp "Baph Baph " $Ligne]} {
		    regsub  "Baph Baph " $Ligne "Bsp Baph " Ligne
		}
		if {[regexp "baph baph " $Ligne]} {
		    regsub  "baph baph " $Ligne "bsp baph " Ligne
		}
		lappend Nouveau $Ligne
	    }
	    Espionne [SauveLesLignes $Nouveau dans $FichierOO]
	}
    }
}

proc DpcShow {{FichierDesProfils ""} {FichierTextOnX ""}} {
    
    if {$FichierDesProfils==""} { 
	set RepXHDA "[RepertoireDuGenome]/xhda"
	set FichierDesProfils "$RepXHDA/TousLesBilans_PourNuca.dpc"
    }
    if {! [file exists $FichierDesProfils]} { 
	set FichierDesProfils [ButineArborescence "All"]
	if {$FichierDesProfils==""} { return "" }
    }
    
    if {$FichierTextOnX==""} {
	set FichierTextOnX "[RepertoireDuGenome]/xhda/OrgaOrdonne.nuca"
	if { ! [file exists $FichierTextOnX]} { 
	    set FichierTextOnX ""
	}
    }
    
    Espionne "exec dpc_show $FichierDesProfils $FichierTextOnX &"
    exec dpc_show $FichierDesProfils $FichierTextOnX &

}

proc ListeDesFamilles {} {
    set LesFamilles {}
    foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/xhda/famille/*.fam"] {
	set Queue [file tail $Fichier]
	regsub ".fam$" $Queue "" Famille
	lappend LesFamilles $Famille
    }
    return $LesFamilles
}

proc CoherenceDesFamilles {} {

    set FichierCoherenceDesFamilles "[RepertoireDuGenome]/xhda/coherence_des_familles"

    foreach Famille [ListeDesFamilles] {
	set LesChefsDeFamille $Famille
	set LesMembres [LesMembresDeLaFamille $Famille]
	Espionne "\n\nVcho $LesMembres"
	if {$LesMembres=={}} { continue }
	catch {unset MesPABs}
	catch {unset SesPABs}
	set LesPABs {}
	foreach {GDB Membre} $LesMembres {
	    lappend LesPABs $Membre
	    set EstMembre($Famille,$Membre) 1
	}
	foreach {GDB Membre} $LesMembres {
	    set SesMembres [QuestionDeScience $GDB "ret LesMembresDeLaFamille $Membre"]
	    if {$SesMembres=={}} { continue }
	    set Chef $Membre
	    lappend LesChefsDeFamille $Chef
	    foreach {GDBautre Autre} $SesMembres {
		lappend LesPABs $Autre
		set EstMembre($Chef,$Autre) 1
	    }
	}
	set LesChefsDeFamille [lsort -unique $LesChefsDeFamille]
	set LesPABs [lsort -unique $LesPABs]
	set LesLignes {}
	foreach Chef $LesChefsDeFamille {
	    set Ligne [format "%9s :" $Chef]
	    foreach PAB $LesPABs {
		regsub -all "." $PAB "." Vide
		if {[info exists EstMembre($Chef,$PAB)]} {
		    set Mot $PAB
		} else {
		    set Mot $Vide
		}
		append Ligne " $Mot"
	    }
	    lappend LesLignes "$Famille $Ligne"
	}
	Espionne ""
	EspionneL $LesLignes
	set Texte [join $LesLignes "\n"]
	AppendAuFichier $FichierCoherenceDesFamilles $Texte
    }
}

proc HomologDetectionAgreement {Nom {Quoi "Value"}} {
    global HomologDetectionAgreement

    if {$Nom=="Reset" || $Quoi=="Reset"} {
	if {[info exists HomologDetectionAgreement]} {
	    unset HomologDetectionAgreement
	}
	ChoixDesGenomesCompletsPresentsAbsents Ask [LesGenomesComplets]
	return
    }

    if { ! [info exists HomologDetectionAgreement(Value,Value)]} {
	set VaCoSi [list \
		"NoValue"           "white"  "HomDetectionAgree NoValue"           \
		"AllAbsent"         "red"    "HomDetectionAgree AllAbsent"         \
		"AllPresent"        "green"  "HomDetectionAgree AllPresent"        \
		"AtLeastOneMistake" "yellow" "HomDetectionAgree AtLeastOneMistake" \
		"Variable"          "orange" "HomDetectionAgree Variable"          \
		"IncoherentValue"   "grey"   "HomDetectionAgree IncoherentValue" ]
	foreach {Va Co Si} $VaCoSi {
	    set HomologDetectionAgreement($Va,Value)  $Va
	    set HomologDetectionAgreement($Va,Color)  $Co
	    set HomologDetectionAgreement($Va,Signif) $Si
	}
    }

    if {[info exists HomologDetectionAgreement($Nom,Value)]} {
	set V [set HomologDetectionAgreement($Nom,Value)]
	return [set HomologDetectionAgreement($V,$Quoi)]
    }
    if {[info exists HomologDetectionAgreement("EstCharge",Value)]} {
	set V [set HomologDetectionAgreement("EstCharge",Value)]
	return [set HomologDetectionAgreement($V,$Quoi)]
    }

    set LesGENO [ChoixDesGenomesCompletsPresentsAbsents]
    set LesGeno {}
    foreach G $LesGENO {
	lappend LesGeno [string totitle $G]
    }
    Espionne "I'll create  HomologDetectionAgreement for [join $LesGeno " "]"
    foreach NomLu [ListeDesPABs] {
	set OoN  " [ORGAorgaDesTBlastNs $NomLu] "
	set OoP  " [ORGAorgaDesBlastPs  $NomLu] "
	set OoMA " [ORGAorgaDesMSFs     $NomLu] "
	if {[info exists R]} { unset R }
	if {[info exists OldAbsent]}  { unset OldAbsent }
	if {[info exists OldPresent]} { unset OldPresent }
	set Absent  0
	set Present 0
	set Autre   1
	foreach GENO $LesGENO Geno $LesGeno {
	    set N [regexp " $GENO " $OoN]
	    set P [regexp " $GENO " $OoP]
	    set M [regexp " $Geno " $OoMA]
	    set A [regexp " $GENO " $OoMA]
	    if {$A} { set P 1 }
	    if { ! $N && ! $P } { continue }
	    set Absent  [expr !$P && !$N && !$A]
	    set Present [expr  $P &&  $N &&  $A]
	    set Mistake [expr !$P &&  $N && !$A]
	    set Autre   [expr !$Absent && !$Present && !$Mistake]
	    if { $Mistake } { set R "AtLeastOneMistake" ; break }
	    if { $Autre   } { set R "Variable" ; continue }
	    if { ! [info exists OldAbsent]}  { set OldAbsent  $Absent }
	    if { ! [info exists OldPresent]} { set OldPresent $Present }
	    if {$Absent !=$OldAbsent}  { set R "Variable" ; continue }
	    if {$Present!=$OldPresent} { set R "Variable" ; continue }
	}
	if { ! [info exists R]} {
	    if {$Absent } { set R "AllAbsent" }
	    if {$Present} { set R "AllPresent" }
	    if { $Autre } { set R "Variable" }
	}
	set HomologDetectionAgreement($NomLu,Value) $R
    }
    set HomologDetectionAgreement("EstCharge",Value) "NoValue"
    return [HomologDetectionAgreement $Nom $Quoi]
}

proc AfficheBilanXHda {{Selection ""}} {

    global RepertoireDuGenome
 
    Wup "Affiche parmi la liste des bilans, ceux voulus"
   
    set RepBilan "$RepertoireDuGenome/bilan_xhda"
    
    if {$Selection==""} {
	foreach FichierBilan [glob -nocomplain "$RepBilan/*"] {
	    set LeBilan [File tail $FichierBilan]
	    lappend LesBilans $LeBilan
	}
	set Selection [ChoixDesPresents [lsort $LesBilans]]
    }
    set Selection [join $Selection "\n"]

    return [CreeEtAfficheUnBilanHDACroises $Selection]
}

proc CreeEtAfficheUnBilanHDACroises {Selection {Option ""}} {
    global RepertoireDuGenome
    set Liste {}
    foreach Ligne [split $Selection "\n"] {
	scan $Ligne "%s" Nom
	lappend Liste $Nom
    }
    if {$Liste=={}} { return "" }


    set FichierBilan "[TmpFile].bilan"
    set FichierBilan [CreeUnBilanHDACroises $Liste $FichierBilan]
    #Jean a rajouter Option et le if
    if {$Option=="AvecTri"} { return [ShowHDACroises $FichierBilan "Delete" "AvecTri"] }

    return [ShowHDACroises $FichierBilan "Delete"]  
}

proc CreeUnBilanHDACroises {Liste {FichierACreer ""}} {
    global RepertoireDuGenome

    if {$FichierACreer==""} {
	FaireLire "Please give the file name to create"
	set FichierACreer [Entre "$RepertoireDuGenome/Bilan/bilan_"]
    }
    if {$FichierACreer==""} { return "" }

    set LesBons {}
    foreach Nom $Liste {
	set FichierBilan "$RepertoireDuGenome/bilan_xhda/$Nom"
	if { ! [file exists $FichierBilan]} { continue }
	LConcat LesBons [LesLignesDuFichier $FichierBilan]
    }
    return [SauveLesLignes $LesBons dans $FichierACreer]
}

proc DisplayBilanHDACroises {K Index} {
    global IndexDisplayBilanHDACroises
    
    if { ! [info exists IndexDisplayBilanHDACroises($K)]} { set IndexDisplayBilanHDACroises($K) 2 }

    if {$Index == $IndexDisplayBilanHDACroises($K) } {
	set Efface 1
	set IndexDisplayBilanHDACroises($K) 9999
    } else {
	set Efface 0
	set IndexDisplayBilanHDACroises($K) $Index
    }

    foreach Id [$K find withtag "TexteRang"] {
	if {$Efface} {
	    set Texte " "
	} else {
	    set MesTags [$K gettags $Id]
	    set TexteDevoile [lindex $MesTags 1]
	    set A "coucou"
	    set P "voila"
	    scan $TexteDevoile "%s %s %s %s %s %s" G E F N P A
	    if {$P=="voila"} {
		set A $N
		set P $F
		set N $E
		set F $G
		set E "unknown"
		set G "Unknown"
	    }
	    if {$A=="coucou"} {
		set A $P
		set P $N
		set N $F
		set F $E
		set E "unknown"
		set G "Unknown"
	    }
	    
	    set Texte [lindex [list bidon $N $P $A] $Index]
	}
	$K itemconfigure $Id -text $Texte
    }
}

proc ShowHDACroises {{Fichier ""} {Delete ""} {Option ""}} {
    set Fichier [LectureBilanHDACroises LesFamilles LesOrgCibles Bilan $Fichier]
    if {$Fichier=={}} { return "" }
    if {$Delete=="Delete"} {
	File delete -force $Fichier
	set Fichier "X-hda"
    }
    
    #Jean a rajoute
    if {$Option=="AvecTri"} {
	set LesXs $LesFamilles
	set LesYs $LesOrgCibles
	set Ordre "SampledBAE"
	set LesGenoTries [LesGenomesDansLeBonOrdre $Ordre]
	
	foreach Y $LesYs {
	    set JExiste($Y) 1
	}
	
	foreach G $LesGenoTries {
	    set Y [string toupper [Glossaire $G Court]]
	    if { ! [info exists JExiste($Y)]} { continue }
	    lappend LesYsTries $Y
	}
	#set Fichier [File tail $Fichier]
	
	set LesFamilles  $LesXs
	set LesOrgCibles $LesYsTries
    }

    return [DessineBilanHDACroises $LesFamilles $LesOrgCibles Bilan $Fichier]
}

proc SauveBilanHDACroisesDuCanvas {K {Fichier ""}} {
    global MemoBilanHDACroises

    set LesXs [set MemoBilanHDACroises($K,LesXs)]
    set LesYs [set MemoBilanHDACroises($K,LesYs)]
    foreach {C V} [array get MemoBilanHDACroises] {
	regsub "$K," $C "" C
	set T($C) $V
    }

    return [SauveBilanHDACroises $LesXs $LesYs T $Fichier]
}

proc SauveBilanHDACroises {LesFamilles LesOrgCibles aBilan {Fichier ""}} {
    upvar $aBilan Bilan
    global RepertoireDuGenome 

    set FichierDefaut "$RepertoireDuGenome/fiches/bilan_hda_croises"
    if {$Fichier=="AskForFile"} {
	set Fichier [FichierPourSaveAs $FichierDefaut]
	if {$Fichier==""} { return "" }
    }
    if {$Fichier==""} {
	set Fichier $FichierDefaut
    }
    set Sortie [list]
    foreach Fam $LesFamilles {
	foreach Org $LesOrgCibles {
	    lappend Sortie "$Fam $Org [join [set Bilan($Fam,$Org)] " "]"
	}
    }
    return [SauveLesLignes $Sortie dans $Fichier]
}

proc LectureBilanHDACroises {aLesFamilles aLesOrgCibles aBilan {Fichier ""}} {
    global RepertoireDuGenome
    upvar $aLesFamilles LesFamilles
    upvar $aLesOrgCibles LesOrgCibles 
    upvar $aBilan Bilan

    set LesFamilles  [list]
    set LesOrgCibles [list]

    set FichierDefaut "$RepertoireDuGenome/fiches/bilan_hda_croises"
    if {$Fichier=="AskForFile"} {
	set Fichier [ButineArborescence "All" $FichierDefaut]
	if {$Fichier==""} { return "" }
    }
    if {$Fichier==""} {
	set Fichier $FichierDefaut
    }
    if {![file exists $Fichier]} {return ""}

    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s %s %s %s %s" Fam Org TblastN BlastP Jaune
	set Bilan($Fam,$Org) [list $TblastN $BlastP $Jaune]
	if {![info exists DejaVuF($Fam)]} {
	    lappend LesFamilles $Fam
	    set DejaVuF($Fam) 1
	}	
	if {![info exists DejaVuO($Org)]} {
	    lappend LesOrgCibles $Org
	    set DejaVuO($Org) 1
	}
    }
    return $Fichier
}

proc AffichePourLaFamilleHDACroises {K Quoi} {
    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]
    set Famille [lindex $MesTags 1]

    if {$Quoi==1} {
	if {[EstUnPAB $Famille]} {return [SearchOnBoard $Famille]}
	set LesMembres [LesMembresDeLaFamilleHDACroises $Famille]
	return [AfficheVariable [join $LesMembres "\n"] "" "HDA_family_members_$Famille"]
    }

    if {$Quoi==2} {
	if {[EstUnPAB $Famille]} {return [AfficheLesMembresDeLaFamille $Famille]}
    }

    if {$Quoi==3} {
	if {[EstUnPAB $Famille]} {return [AfficheLeClusterXHda $Famille]}
    }
    return ""
}

proc TriBilanHDACroises {K Index SurQui} {
    global MemoBilanHDACroises

    set LesXs [set MemoBilanHDACroises($K,LesXs)]
    set LesYs [set MemoBilanHDACroises($K,LesYs)]

    foreach {C V} [array get MemoBilanHDACroises] {
	regsub "$K," $C "" C
	set T($C) $V
    }

    if {$SurQui=="SurOrganisme"} {

	set Ordres {"bidon" "BAE" "SampledBAE" "Alpha"}
	set Ordre [lindex $Ordres $Index]
	set LesGenoTries [LesGenomesDansLeBonOrdre $Ordre]

	foreach Y $LesYs {
	    set JExiste($Y) 1
	}

	set LesVYs {}
	foreach G $LesGenoTries {
	    set Y [string toupper [Glossaire $G Court]]
	    if { ! [info exists JExiste($Y)]} { continue }
	    lappend LesYsTries $Y
	}
	set Titre "X-HDA sorted by Organisms ($Ordre)"
	return [DessineBilanHDACroises $LesXs $LesYsTries T $Titre]
    }

    if {$SurQui=="SurFamille"} {

	set Id [$K find withtag current]
	set MesTags [$K gettags $Id]
	set Famille [lindex $MesTags 1]
	
	set LesVYs {}
	foreach Y $LesYs {
	    set V [set T($Famille,$Y)]
	    set VY [split $V " "]
	    lappend VY $Y
	    lappend LesVYs $VY
	    set YduVY($VY) $Y
	}
	set LesVYsTries [lsort -decreasing -index [expr $Index-1] -integer $LesVYs]
	set LesYsTries {}
	foreach VY $LesVYsTries {
	    set Y [set YduVY($VY)]
	    lappend LesYsTries $Y
	}
	set Titre "X-HDA sorted by $Famille ($Index)"
	return [DessineBilanHDACroises $LesXs $LesYsTries T $Titre]
    }

    if {$SurQui=="SurLaMoyenne"} {
	Wup "il faut trier LesXs en fonction de la valeur du Bilan"
	set Id [$K find withtag current]
	set MesTags [$K gettags $Id]
	set Complet [lindex $MesTags 0]
	set Orga    [lindex $MesTags 1]

	set LesVXs {}
	foreach X $LesXs {
	    
	    set Famille $X
	    set V [set T($Famille,$Orga)]
	    set VX [split $V " "]
	    lappend VX $X
	    lappend LesVXs $VX
	    set XduVX($VX) $X
	}
	set LesVXsTries [lsort -decreasing -index [expr $Index-1] -integer $LesVXs]
	set LesXsTries {}
	foreach VX $LesVXsTries {
	    set X [set XduVX($VX)]
	    lappend LesXsTries $X
	}
	set Titre "X-HDA sorted with $Complet ($Index)"
	return [DessineBilanHDACroises $LesXsTries $LesYs T $Titre]
    }
}

proc DevoileLesValeursHDACroises {K X Y Action} {
    global RepertoireDuGenome

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Texte [lindex $MesTags 1]
    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    if {$X>400} { set EW "e" } else { set EW "w" }
    if {$Y< 50} { set EW "n$EW" }
    place $M -x $X -y [expr $Y-20] -anchor $EW
    return $M
}

proc TexteHDACroises {V Fam Orga {Quoi ""}} {

    if {$Quoi=="Devoile"} { return "$Fam $Orga [join $V " "]" }

    set T [lindex $V 0]
    set P [lindex $V 1]
    set J [lindex $V 2]
    if {1 || [CouleurHDACroises $V]=="O"} { return "$P" }
    return " "
}

proc DessineBilanHDACroises {LesXs LesYs aT {Titre ""} {PourGif ""}} {
    upvar $aT T
    global RepertoireDuGenome
    global MemoBilanHDACroises

    if {$Titre==""} { set Titre "Cross-linked Homolog Detection Agreement" }
    if {[regexp "/" $Titre]} { set Titre [file tail $Titre] }
    set LC 25
    set HL 20

    set nLignes   [llength $LesYs]
    set nColonnes [llength $LesXs]

    set CouleursHDA(O) "orange"
    set CouleursHDA(B) "blue"
    set CouleursHDA(V) "green"
    set CouleursHDA(R) "red"
    set CouleursHDA(J) "yellow"
    set CouleursHDA(LJ) "lightyellow"

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

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

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

    set MemoBilanHDACroises($K,LesXs) $LesXs
    set MemoBilanHDACroises($K,LesYs) $LesYs
    foreach {C V} [array get T] {
	if {$C=="LesXs" || $C=="LesYs"} { continue } 
	set MemoBilanHDACroises($K,$C) $V
    }
    $K configure -background "lightgrey"
    $K create rectangle 0 0 $LargeurVoulue $HauteurVoulue -fill grey -tags [list "Cadre"]

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

    set iEmeOrga 0
    set MettreEntete 1 
    set MettreEnpied 0
    foreach Orga [concat $LesYs [list "LigneSupplementaire"]] {
	    
	if {$Orga=="LigneSupplementaire"} {
	    set MettreEnpied 1
	    incr iEmeOrga
	} else {
	    set Couleur "black"
	    set Complet [Glossaire $Orga Complet]
	    
	    set Phylum [PhylumDuGenome $Complet]
	    if {$Phylum=="X"} { set Phylum [PhylumDuOrganisme $Complet] }
	    
	    set Couleur "black"
	    if {$Phylum=="B"} { set Couleur "darkgreen" }
	    if {$Phylum=="A"} { set Couleur "blue" }
	    if {$Phylum=="E"} { set Couleur "red" }
	    if {[SampledOrganism $Orga]} { set Couleur "darkorange" }
	    incr iEmeOrga
	    
	    set TexteOrga [string range $Complet 0 25]
	    $K create text \
		    $EspacementHorizontal [expr $EspaceVertical + $iEmeOrga*$HL] \
		    -text $TexteOrga \
		    -anchor w \
		    -font $Fonte \
		    -tags [list "$Complet" "$Orga" "TexteOrga" "Ligne_$iEmeOrga"] \
		    -fill $Couleur
	}

	set ValeurVide ""
	set Colonne 0
	set Rang 0
	foreach X $LesXs {

	    incr Colonne
	    incr Rang

	    if {$MettreEntete || $MettreEnpied} {
		if {$MettreEnpied} { 
		    set PosYEntete [expr $EspaceVertical + $iEmeOrga*$HL]
		}
		set PosX [expr $DecalageDesRectangles + $Colonne*$LC]
		set Texte $X
		$K create text \
			$PosX $PosYEntete \
			-width 20 \
			-text $Texte \
			-font {Courier 6} \
			-anchor n \
			-tags [list "Famille" $Texte "TexteOrga"] \
			-fill "black"
	    }
	    if {[info exists T($X,$Orga)]} {
		set V [set T($X,$Orga)]
	    } else {
		set V $ValeurVide
	    }		

	    if { $V == $ValeurVide} { continue }
	    set Couleur [set CouleursHDA([CouleurHDACroises $V])]
	    set Texte        [TexteHDACroises $V $X $Complet]
	    set TexteDevoile [TexteHDACroises $V $X $Complet Devoile]
	    if {$PourGif} {
		set LesTags [list "WebClic" "gscope:AfficheLesConcernesDeCeRang \{$Complet\} $V $Rang Coucou"]
	    } else {
		set LesTagsR [list $Complet $TexteDevoile $Rang             "Affichable" "Ligne_$iEmeOrga"]
		set LesTagsT [list $Complet $TexteDevoile $Rang "TexteRang" "Affichable" "Ligne_$iEmeOrga"]
	    }

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

    $K configure -height [expr $EspaceVertical + ($iEmeOrga+2)*$HL]

    set   B [BoutonneLaFenetre $w "Hide Both/Org/Val\n Sort BAE/SmplBAE/Alph\nAverage tN/P/abs"]
    bind $B <1>         "ToggleTextePhylo $K Both"
    bind $B <2>         "ToggleTextePhylo $K Orga"
    bind $B <3>         "ToggleTextePhylo $K Rank"
    bind $B <Shift-1>   "TriBilanHDACroises $K 1 SurOrganisme" 
    bind $B <Shift-2>   "TriBilanHDACroises $K 2 SurOrganisme" 
    bind $B <Shift-3>   "TriBilanHDACroises $K 3 SurOrganisme" 
    bind $B <Control-1> "TriBilanHDACroises $K 1 SurLaMoyenne" 
    bind $B <Control-2> "TriBilanHDACroises $K 2 SurLaMoyenne" 
    bind $B <Control-3> "TriBilanHDACroises $K 3 SurLaMoyenne" 
         $B configure -background "green"

    set   B [BoutonneLaFenetre $w "Save X-HDA\nOther Show/Ask/New\nDisplay tN/P/A"]
    bind $B <1>         "SauveBilanHDACroisesDuCanvas $K AskForFile"
    bind $B <Shift-1>   "ShowHDACroises {}"
    bind $B <Shift-2>   "ShowHDACroises AskForFile"
    bind $B <Shift-3>   "NewHDACroises" 
    bind $B <Control-1> "DisplayBilanHDACroises $K 1" 
    bind $B <Control-2> "DisplayBilanHDACroises $K 2" 
    bind $B <Control-3> "DisplayBilanHDACroises $K 3" 
         $B configure -background "green"

    $K bind "Famille"    <1>         "AffichePourLaFamilleHDACroises $K 1" 
    $K bind "Famille"    <2>         "AffichePourLaFamilleHDACroises $K 2" 
    $K bind "Famille"    <3>         "AffichePourLaFamilleHDACroises $K 3" 
    $K bind "Famille"    <Shift-1>   "TriBilanHDACroises $K 1 SurFamille" 
    $K bind "Famille"    <Shift-2>   "TriBilanHDACroises $K 2 SurFamille" 
    $K bind "Famille"    <Shift-3>   "TriBilanHDACroises $K 3 SurFamille"

    $K bind "TexteOrga"  <Shift-1>   "TriBilanHDACroises $K 1 SurLaMoyenne" 
    $K bind "TexteOrga"  <Shift-2>   "TriBilanHDACroises $K 2 SurLaMoyenne" 
    $K bind "TexteOrga"  <Shift-3>   "TriBilanHDACroises $K 3 SurLaMoyenne" 
    $K bind "Affichable" <Enter>     "DevoileLesValeursHDACroises $K %x %y Enter"
    $K bind "Affichable" <Leave>     "DevoileLesValeursHDACroises $K %x %y Leave"
    $K bind "Affichable" <1>         ""
    $K bind "Affichable" <Control-2> "ChangeOrdrePhylo $K %x %y $HL -1 $iEmeOrga"
    $K bind "Affichable" <Control-3> "ChangeOrdrePhylo $K %x %y $HL  1 $iEmeOrga"

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

proc LesAccessDesOrganismesSample {Nom {Quoi ""}} {
    global MemoLesAccessTarget MemoLesOrganismesTarget MemoNomTarget

    if {$Quoi==""} { set Quoi "LesAccessMerci" }

    if {$Quoi=="LesOrganismesMerci" && [info exists MemoNomTarget] && $MemoNomTarget==$Nom} {
	return $MemoLesOrganismesTarget
    }
    if {$Quoi=="LesAccessMerci" && [info exists MemoNomTarget] && $MemoNomTarget==$Nom} {
	return $MemoLesAccessTarget
    }
    set LesAccess {}
    set LesOrganismes {}
    foreach Organisme [SampledOrganism LaListeMerci] {
	set Bid ""
	set Acc ""
	scan [BidAccessDeLOrganisme $Organisme $Nom] "%s %s" Bid Acc
	if {$Acc==""} { continue }
	lappend LesOrganismes $Organisme
	lappend LesAccess $Acc
    }
    set MemoNomTarget $Nom
    set MemoLesAccessTarget $LesAccess
    set MemoLesOrganismesTarget $LesOrganismes
    if {$Quoi=="LesAccessMerci"} { return $LesAccess }
    if {$Quoi=="LesOrganismesMerci"} { return $LesOrganismes }
    return $LesAccess
}

proc BidAccessDeLOrganisme {Orga Nom} {
    global RepertoireDuGenome

    regsub "_" $Orga " " Orga

    set APNsOnly 1

    set SeuilExpect 0.001
    set MaxListe     250

    if {[info exists BidAccessDeLOrganisme(Courant)] && [set BidAccessDeLOrganisme(Courant)]!=$Nom} {
	unset BidAccessDeLOrganisme
	set BidAccessDeLOrganisme(Courant) $Nom
    }
    if {[info exists BidAccessDeLOrganisme($Nom,$Orga)]} { return [set BidAccessDeLOrganisme($Nom,$Orga)] }
    if {[info exists BidAccessDeLOrganisme($Nom,"EstCharge")]} { return "" }

    set FichierAPNs "[RepertoireDuGenome]/apns/$Nom"
    if {[file exists $FichierAPNs]} {
	set nLu 0
	foreach Ligne [LesLignesDuFichier $FichierAPNs] {
	    incr nLu
	    scan $Ligne "%s %s %s" BanqueId Access Expect
	    if {[EstUnAccessPDB $BanqueId]} { continue }
	    if {$Expect > $SeuilExpect} { break }
	    if {$nLu    > $MaxListe   } { break }
	    set GEs ""
	    regsub " *$BanqueId +$Access +$Expect *" $Ligne "" GEs
	    if { ! [regexp -nocase {[a-z]} $GEs]} { continue }
	    set LesGEs [split $GEs ":"]
	    foreach GE $LesGEs {
		if {[info exists DejaVu($GE)]} { continue }
		set DejaVu($GE) 1
		set BidAccessDeLOrganisme($Nom,$GE) "$BanqueId $Access $Expect"
	    }
	}
    }

    if {[info exists BidAccessDeLOrganisme($Nom,$Orga)]} { return [set BidAccessDeLOrganisme($Nom,$Orga)] }

    if {$APNsOnly} { return "" }

    set OBP [OrthoBlastP $Nom $Orga]
    if {$OBP != "OrthoBlastPNonValide"} {
	if { ! $OBP } { return "" }
	set LesOs [OrthoBlastP $Nom]
	regsub " " $Orga "_" GenreEspece
	set i [lsearch $LesOs $GenreEspece]
	
	set Fichier "$RepertoireDuGenome/blastp/$Nom"
	if { ! [file exists $Fichier]} { return "" }
	DecortiqueBlast $Fichier 0.001 "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN
	Espionne "Recherche de $Orga en $i ratee"
	set LesBids [Zippe [lrange $lBanqueId $i end] [RetourneLaListe [lrange $lBanqueId 0 [expr $i-1]]]]
	set LesAccs [Zippe [lrange $lAccess   $i end] [RetourneLaListe [lrange $lAccess   0 [expr $i-1]]]]
	foreach Bid $LesBids Access $LesAccs {
	    foreach Organisme [split [OrgaDuAccess $Access Complet $Bid] ":"] {
		if {[Glossaire $Organisme Complet]==$Orga} { return "$Bid $Access" }
	    }
	}
	return ""
    }
    return ""
}

proc AfficheLesMembresDeLaFamille Nom {
    
    set MembresDeLaFamille [LesMembresDeLaFamille $Nom]

    set Texte [join $MembresDeLaFamille "\n"]
    
    set Fen [AfficheVariable $Texte "AvecRien" "${Nom}Les Membres de sa Famille"]
    
    #Jean a rajoute 
    set   B [BoutonneLaFenetre $Fen "X-HDA Sel/Sort\nAll/Sort\nInfo Cluster//DpcShow"]
    #set   B [BoutonneLaFenetre $Fen "Show X-HDA sel/all"]
    bind $B <1>       "CreeEtAfficheUnBilanHDACroises \[selection get\]"
    bind $B <2>       "CreeEtAfficheUnBilanHDACroises \[selection get\] AvecTri"
    bind $B <Shift-1> "CreeEtAfficheUnBilanHDACroises \[set PagePropre($Fen)\]"
    bind $B <Shift-2> "CreeEtAfficheUnBilanHDACroises \[set PagePropre($Fen)\] AvecTri"
    bind $B <Control-1> "AfficheLesInfosDuCluster"
    bind $B <Control-3> "DpcShow"
    
         $B configure -background "green"

    return $Fen
}

proc AfficheLeClusterXHda Nom {

    set LeClusterXHda [LeClusterXHda $Nom]
  
    if {$LeClusterXHda=={}} {
	FaireLire "No cluster available"
	return ""
    }
    foreach PAB $LeClusterXHda {
	set DE [DefinitionApproximative $PAB]
	lappend LeTexte "$PAB $DE"
    }

    #Jean a rajoute Tri et bind3
    set Texte [join $LeTexte "\n"]
    set Fen [AfficheVariable $Texte "AvecRien" "${Nom}_X-HDA_cluster"]
    set   B [BoutonneLaFenetre $Fen "X-HDA Sel/Sort\nAll/Sort\nInfoClust/OntoClust/Dpc"]
    bind $B <1>       "CreeEtAfficheUnBilanHDACroises \[selection get\]"
    bind $B <2>       "CreeEtAfficheUnBilanHDACroises \[selection get\] AvecTri"
    bind $B <Shift-1> "CreeEtAfficheUnBilanHDACroises \[set PagePropre($Fen)\]"
    bind $B <Shift-2> "CreeEtAfficheUnBilanHDACroises \[set PagePropre($Fen)\] AvecTri"
    bind $B <Control-1> "AfficheLesInfosDuCluster"
    bind $B <Control-2> "OntologyDesClusters \[set PagePropre($Fen)\]"
    bind $B <Control-3> "DpcShow"
         $B configure -background "green"

    return $Fen
}

proc OntologyDesClusters {Selection} {
    
    foreach Ligne [split $Selection "\n"] {
	scan $Ligne "%s" Nom
	lappend Liste $Nom
    }
    if {$Liste=={}} { return "" }
    
    IllustreOntologyDesBoitesGscope $Liste
}

proc AfficheLesInfosDuCluster {} {
    
    set ClusterOuNom [Entre "ClusterOuNom: "] 

    if {[regexp "^ClusterOuNom:" $ClusterOuNom]} {
	regsub "^ClusterOuNom: " $ClusterOuNom "" ClusterOuNom  
    }
    scan $ClusterOuNom "%s" ClusterOuNom 
    
    Espionne "Question $ClusterOuNom"
    
    set Fen [AfficheVariable [LesInfosDuCluster $ClusterOuNom] "" "Les Info de $ClusterOuNom"] 

    return $Fen
}

proc InfoDuCluster { {ClusterOuNom ""} {Quoi ""}} {

    Wup "Rend les membres du cluster Numero X ou du PAB X, sa taille, son numero"

    global RepertoireDuGenome
    global MemoTaille MemoLesMembres MemoClusterOuNom MemoNumero

    if {$ClusterOuNom=="LaListeMerci"} { set Quoi "LaListeMerci" }

    if {$ClusterOuNom==""} {return "No Query"}
    if {$Quoi==""} {set Quoi "Membres"}
    if {$Quoi!="Membres" && $Quoi!="Taille" && $Quoi!="Numero" && $Quoi!="LaListeMerci"} {
	return "Quoi must be Membres, Taille or Numero"
    } 

    if {$Quoi=="Membres" && [info exists MemoLesMembres] && $MemoClusterOuNom==$ClusterOuNom} {
	return $MemoLesMembres
    }
    if {$Quoi=="Numero" && [info exists MemoNumero] && $MemoClusterOuNom==$ClusterOuNom} {
	return $MemoNumero
    }
    if {$Quoi=="Taille" && [info exists MemoTaille] && $MemoClusterOuNom==$ClusterOuNom} {
	return $MemoTaille
    }

    set FichierDesClusters "$RepertoireDuGenome/xhda/TousLesBilans_PourNuca.dpc"

    set LesMembresDuCluster {}
    set StopSurCluster 0
    foreach Ligne [LesLignesDuFichier $FichierDesClusters] {
	if { ! [regexp -nocase {[a-z]+} $Ligne] || [regexp -nocase "^Number of clusters" $Ligne]} { continue }
	if {[regexp -nocase {^Cluster} $Ligne]} {	    
	    if {$StopSurCluster} { break }
	    set LesMembresDuCluster {}

	    scan $Ligne "%s %s %s" Groupe Numero Taille

	    lappend LesNumeros $Numero

	    regsub "$Groupe +$Numero +; +size=" $Ligne "" Taille

	    #if {! [expr $Numero==$ClusterOuNom]} {continue}
	    if {! [string equal $Numero $ClusterOuNom]} {continue}
	    set StopSurCluster 1
	    continue
	}
	
	scan $Ligne "%s" PAB
	lappend LesMembresDuCluster $PAB
	if {[string equal $PAB $ClusterOuNom]} { set StopSurCluster 1}
	#   if {$PAB==$ClusterOuNom} { set StopSurCluster 1}
    }

    if {$Quoi=="LaListeMerci"}  {return [lsort -integer -unique $LesNumeros]}

    if {! [string equal $Numero $ClusterOuNom] && [expr [lsearch -exact $LesMembresDuCluster $ClusterOuNom]<0]} {
	return "No info available for $ClusterOuNom"
    }
    
    set MemoNumero       $Numero
    set MemoMembres      $LesMembresDuCluster
    set MemoTaille       $Taille
    set MemoClusterOuNom $ClusterOuNom
  
    if {$Quoi=="Numero"}  {return $Numero}
    if {$Quoi=="Taille"}  {return $Taille}
    if {$Quoi=="Membres"} {return $LesMembresDuCluster}
}

proc LesInfosDuCluster { {NomDuCluster ""} } {

    Wup "Rend la taille et les membres du cluster Numero X ou du PAB X"

    if {! [regexp -nocase {[a-z]+ || [0-9]+} $NomDuCluster]} {return "No Query"}
    
    set LesMembres [InfoDuCluster $NomDuCluster]
    set Taille     [InfoDuCluster $NomDuCluster Taille]
    set Numero     [InfoDuCluster $NomDuCluster Numero]

    set TexteMembres [join $LesMembres " "]
    regsub -all "[PreFixe]" $TexteMembres "" TexteMembres
    return "Cluster $Numero\nTaille: $Taille\nMembres: $TexteMembres"
}


proc ColorationDesClustersXHdaDesNomsPiques {Nom {Quoi "Couleur"}} {
    global ColorationDesClustersXHda

    JeMeSignale

    if {$Nom=="Reset" && [info exists ColorationDesClustersXHda]} {
	unset ColorationDesClustersXHda
	return 
    }

    if {[info exists ColorationDesClustersXHda($Nom,$Quoi)]} {
	return  [set ColorationDesClustersXHda($Nom,$Quoi)]
    }

    if {[info exists ColorationDesClustersXHda]} {
	if {[info exists ColorationDesClustersXHda("EstCharge",$Quoi)]} {
	    return  [set ColorationDesClustersXHda("EstCharge",$Quoi)]
	} else {
	    return "lightgrey"
	}
    }

    set ColorationDesClustersXHda("EstCharge",Couleur) "grey"
    set ColorationDesClustersXHda("EstCharge",Signif)  "not_in_same_cluster"

    set LesPiques [LesNomsPiques]
    if {$LesPiques=={}} {
	set ColorationDesClustersXHda("EstCharge",Couleur) "white"
	set ColorationDesClustersXHda("EstCharge",Signif)  "no_reference_was_choosen"
	return [ColorationDesClustersXHdaDesNomsPiques $Nom $Quoi]
    }
    
    set n [llength $LesPiques]
    set LesCouleurs [CouleursDuBleuAuRouge $n]
    
    foreach Pique $LesPiques Couleur $LesCouleurs {
	set Signif "same cluster as $Pique"
	set LeClusterXHda [LeClusterXHda $Pique]
	if {$LeClusterXHda=={}} { continue }
	set Premier [lindex $LeClusterXHda 0]
	if {[info exists DejaVu($Premier)]} { continue }
	set DejaVu($Premier) $Pique
	foreach PAB $LeClusterXHda {
	    set ColorationDesClustersXHda($PAB,Couleur) $Couleur
	    set ColorationDesClustersXHda($PAB,Signif)  $Signif
	}
    }
    return [ColorationDesClustersXHdaDesNomsPiques $Nom $Quoi]
}

proc LeClusterXHda { Query {Quoi ""} {FichierCluster ""} } {
    global RepertoireDuGenome
    global LeClusterXHda

    if {$Quoi==""} { set Quoi "LesMembres" }

    if {[info exists LeClusterXHda(Query)] && [set LeClusterXHda(Query)]==$Query} {
	if {[info exists LeClusterXHda($Quoi)]} {
	    return [set LeClusterXHda($Quoi)] 
	}
    }
    
    if {$FichierCluster==""} {
	set LesFDPC [glob -nocomplain "$RepertoireDuGenome/xhda/*.dpc"]
	set FichierCluster [ChoixParmi $LesFDPC] 
	if {$FichierCluster==""} { return {} }
    }

    set OnVeutToutLeMonde 0
    set OnVeutToutLeMondeAvecGroupe 0
    set OutQuery 0

    if {$Query=="OnVeutToutLeMonde"} { set OnVeutToutLeMonde 1 }
    if {$Query=="OnVeutToutLeMondeAvecGroupe"} { set OnVeutToutLeMondeAvecGroupe 1 }

    set LeGroupe {}
    set OnLeTient 0
    set Numero ""
    foreach Ligne [LesLignesDuFichier $FichierCluster] {
	if { ! [regexp -nocase {[a-z]+} $Ligne] || [regexp -nocase "^Number of clusters" $Ligne]} { continue }
	if {[regexp -nocase {^Cluster [0-9]+|^unclustered seq} $Ligne]} {
	    if {$OnLeTient} { break }
	    set Numero ""
	    scan $Ligne "%s %s" Groupe Numero
	    set Taille [IntegerApres "size=" dans $Ligne]
	    if { ! [regexp {^[0-9]} $Numero]} { set Numero -1 }
	    set LeGroupe {}
	    if {$Query==$Numero} { set OnLeTient 1 }
	    continue
	}
	scan $Ligne "%s" Access
	if {[string toupper $Access]==[string toupper $Query]} {
	    set OnLeTient 1
	    if {$OutQuery} { continue }
	}
	lappend ToutLeMondeAvecGroupe "$Access $Numero" 
	lappend ToutLeMonde $Access
	lappend LeGroupe $Access
    }

    if { ! $OnLeTient } { set LeGroupe {} }

    set LeClusterXHda(Numero)     $Numero
    set LeClusterXHda(LesMembres) $LeGroupe
    set LeClusterXHda(Taille)     $Taille
    set LeClusterXHda(Query)      $Query
    
    if {$Quoi=="Numero" } { return $Numero }
    if {$Quoi=="Taille" } { return $Taille }
    if {$OnVeutToutLeMonde} { return $ToutLeMonde }
    if {$OnVeutToutLeMondeAvecGroupe} { return $ToutLeMondeAvecGroupe }
    if {$Groupe=="unclustered"} {
	return $ToutLeMonde
    } else {
	return $LeGroupe
    }
}

proc CreeLesFamillesDesSelectionnesPourTous {} {
    
    return [CreeLesFamillesDesSelectionnes "LaTotale" "NoAsk"]
}

proc CreeLesFamillesDesSelectionnes {{LaSelection ""} {Ask ""}} {

    Wup "A partir du Board on selectionne des PABs, ou si rien n'est choisi LaListeDesPABs"
    Wup "Avec CreeListeCandidatsPour on creer les premiers candidats"
    Wup "On garde dans stone_NomFam la liste des premiers candidats"
    Wup "A partir des premiers on fait LaFamilleElargie, sauve dans /famille/nom.fam"
    Wup "si Ask vide on repond sinon on ne repond pas, LaTotale pour la ListeDesPABs"
   
    global RepertoireDuGenome
    global NotreOS
    
    set RepXHDA    "$RepertoireDuGenome/xhda"
    set RepFamille "$RepertoireDuGenome/xhda/famille"
    set RepStone   "$RepFamille/stone"
    set OrgaChoisi [Glossaire $NotreOS Complet]
    set UseExisting 1

    if {! [File exists $RepXHDA]} { File mkdir $RepXHDA }

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

    if {$LaSelection==""} {
	set LaSelection [LesNomsPiques]
    }

    if {$LaSelection=={} || $LaSelection=="LaTotale"} {
	if { $Ask &&  ! [OuiOuNon "Do I use all PABs ? " 0]} { return "" }
	set LaSelection [ListeDesPABs]
    }
    
    foreach PAB $LaSelection {
	if {[OnTraiteUneCollection]} {
	    regsub -all "/" [NomDeScene $PAB] "_" Famille 
	} else {
	    set Famille $PAB
	}
	if { ! [info exists DejaVu($Famille)]} {
	    lappend LesFamilles $Famille
	    set DejaVu($Famille) 1
	}
	lappend LesPABsDeLaFamille($Famille) $PAB
    }

    set LesChoix {}
    foreach Famille $LesFamilles {
	foreach PAB [set LesPABsDeLaFamille($Famille)] {
	    lappend LesChoix "$PAB $Famille"
	}
    }

    set Choix [join $LesChoix "\n"]
    if { $Ask } { set Choix [EntreTexte $Choix] }
    set Choix [string trim $Choix]
    if {$Choix==""} { return "" }
   
    if {[info exists DejaVu]} {
	unset DejaVu
	unset LesFamilles
	unset LesPABsDeLaFamille
    }

    set LesFamilles {}
    foreach Ligne [split $Choix "\n"] {
	scan $Ligne "%s %s" PAB Famille
	if { ! [info exists DejaVu($Famille)]} {
	    lappend LesFamilles $Famille
	    set DejaVu($Famille) 1
	}
	lappend LesPABsDeLaFamille($Famille) $PAB
    }

    if {! [file exists "$RepFamille"]} { File mkdir $RepFamille }
    if {! [file exists "$RepStone"]}   { File mkdir $RepStone }

    foreach Famille $LesFamilles {
	global NomDuFichierPierre ; set NomDuFichierPierre "$RepStone/stone_$Famille"
	if {$UseExisting && [file exists $NomDuFichierPierre]} {
	    Espionne "stone_$Famille already exists, I use it."
	    Degrave LesCandidatsDeLaFamille
	} else {
	    set LesCandidatsDeLaFamille {}
	    foreach PAB [set LesPABsDeLaFamille($Famille)] {
		set ListePremiersCandidats [CreeListeCandidatsPour $PAB $OrgaChoisi $Famille]
		LConcat LesCandidatsDeLaFamille $ListePremiersCandidats
	    }
	    set LesCandidatsDeLaFamille [lsort -unique $LesCandidatsDeLaFamille]	    
	    Grave LesCandidatsDeLaFamille
	    ClosPierre
	}
	set CandidatsDUneFamille($Famille) $LesCandidatsDeLaFamille
    }
 
    foreach Famille $LesFamilles {
	set LesCandidatsDeLaFamille [set CandidatsDUneFamille($Famille)]
	if {! [file exists $RepFamille]} {File mkdir $RepFamille}
	set FichierFamille "$RepFamille/$Famille.fam"

	if {$UseExisting && [file exists $FichierFamille]} {
	    Espionne "$Famille.fam already exists I keep it."
	    continue
	}
	SauveLesLignes [LaFamilleElargie $LesCandidatsDeLaFamille $Famille] dans $FichierFamille
    }
    unset CandidatsDUneFamille
    Espionne "Fin"
}

proc NewHDACroisesPourTous {} {
    global RepertoireDuGenome
    
    set RepFamille "$RepertoireDuGenome/xhda/famille"

    foreach fichier [lsort [glob -nocomplain "$RepFamille/*.fam"]] {
	NewHDACroises $fichier "SansDessine" "Sauve"
    }
}

proc NewHDACroises {{LeChoixDesFichiersFamille ""} {Ask ""} {Sauve ""}} {    

    Wup "Permet a partir de fichiers .fam de faire le HDA croise, de les afficher et les sauver"

    global RepertoireDuGenome

    set LesFamilles {}
    set LaSelectionProbable {}
    set RepFamille "$RepertoireDuGenome/xhda/famille"
    set RepBilan   "$RepertoireDuGenome/bilan_xhda"
    set UseExisting 1

    if {$Ask==""} {set Ask 1} else {set Ask 0}
    if {$Sauve==""} {set Sauve 0} else {set Sauve 1}
    if {! [file exists $RepBilan]} {File mkdir $RepBilan}

    global LesOrgsCibles
    if { ! [info exists LesOrgsCibles]} {
	set LesOrgsCibles {}
	foreach ligne [LesGenomesComplets] {
	    lappend LesOrgsCibles [string toupper [Glossaire $ligne Court]]
	}
	
    }
    if {$LeChoixDesFichiersFamille==""} {	
	foreach file [lsort [glob -nocomplain "$RepFamille/*.fam"]] {
	    set Queue [file tail $file]
	    lappend LaSelectionProbable  $file
	    lappend LaSelectionProbableQ $Queue
	}
	set LeChoixDesFichiersFamille [ChoixDesPresents $LaSelectionProbable $LaSelectionProbableQ]
    }
    if {$LeChoixDesFichiersFamille==""} { return "" }

    set ListeCandidat {}
    foreach fichier $LeChoixDesFichiersFamille {
	if { ! [file exists $fichier] || [file size $fichier]==0} {continue}
	set ListePourOdile {}
	set Famille [file tail $fichier]
	regsub {\.[a-z]+$} $Famille "" Famille

	if {$UseExisting && [file exists "$RepBilan/$Famille"]} {
	    Espionne "$Famille exists I continue"
	    continue
	}
	Espionne "\n$Famille"

	set ListeCandidat  [LesLignesDuFichier $fichier]
	foreach ligne $ListeCandidat {
	    scan $ligne "%s %s %s" FamilleComplete PAB GDBName
	    lappend ListePourOdile    $GDBName
	    lappend ListePourOdile    $PAB
	    lappend LesPABs($Famille) $PAB
	}
	EspionneL "ListeGDBName_PABs: $ListePourOdile"
	
	if {$ListePourOdile=={}} { continue }

	lappend LesFamilles $Famille

	BilanHDAParFamille $LesOrgsCibles $Famille $ListePourOdile BilanChiffre
    }

    if {$LesFamilles=={}} { return "" }

    if {$Ask} {
	DessineBilanHDACroises $LesFamilles $LesOrgsCibles BilanChiffre
    }
    
    if {$Sauve} {
	set FichierBilanASauver "$RepertoireDuGenome/bilan_xhda/[lindex $LesFamilles 0]"
	Espionne $FichierBilanASauver
	SauveBilanHDACroises $LesFamilles $LesOrgsCibles BilanChiffre $FichierBilanASauver
    }
}

proc NarcissePourLOrganisme {Access Organisme} {
    
    set GName [LesNomsGscopeDeLOrganisme $Organisme]

    if {$GName == {}} { return "" }

    set BoiteDuAccess ""
    foreach nomG $GName { 
	set BoiteDuAccess [QuestionDeScience $nomG "ret Narcisse $Access"] 
	
	if {$BoiteDuAccess == "" && [regexp -nocase {[a-z]{3}} $Access]} {	
	    set LeEmbl [LaSequenceDesBanques $Access $Access accessOk "OnVeutEMBL"]
	
	    if {$LeEmbl == ""} { continue }

	    set LigneAC [lindex $LeEmbl 1] 
	    
	    if { ! [regexp "^AC   " $LigneAC]} { continue }
	    
	    scan $LigneAC "%s %s" bidon AC
	    set BoiteDuAccess [QuestionDeScience $nomG "ret Narcisse $AC"] 
	} 
	if {$BoiteDuAccess != ""} { break }	
    }
    return $BoiteDuAccess
}

proc CreeListeCandidatsPour {{PABVoulu ""} {CandidatOrga ""} {Famille "famille"}} {

    Wup "Rend une liste Access Orga pour PABVoulu"
     
    set ListeAccessCandidat {}
    set   ListeOrgaCandidat {}
    set       ListeCandidat {}

    set CandidatAccess [Narcisse $PABVoulu]
   
    Espionne "Boite $PABVoulu"
    Espionne "Orga $CandidatOrga"
    Espionne "Access Candidat $CandidatAccess"

    set ListeAccessCandidat [LesAccessDesOrganismesSample $PABVoulu]
    set ListeOrgaCandidat   [LesAccessDesOrganismesSample $PABVoulu "LesOrganismesMerci"]

    EspionneL "ListeAccessCandidat1 $ListeAccessCandidat"
    EspionneL "ListeOrgaCandidat2 $ListeOrgaCandidat"
    
    foreach AC $ListeAccessCandidat OG $ListeOrgaCandidat {
	lappend ListeCandidat "$AC $OG"
    } 
    
    if { $CandidatAccess != ""} {
	lappend ListeCandidat "$CandidatAccess $CandidatOrga"
    }
    set ListeCandidat [lsort -unique $ListeCandidat]
 
    EspionneL "$ListeCandidat"
    return $ListeCandidat
}

proc LaFamilleElargie {ListeCandidat {Famille "famille"}} {
    
    Wup "Rend la liste complete FamillePoissonPecheurs PAB GDBName pour une liste access-orga"
    
    set ListeDesPABs {}
    
    foreach Candidat $ListeCandidat {
	set CandidatAccess [lindex $Candidat 0]
	set CandidatOrga   [lrange $Candidat 1 end]
	Espionne "\nCandidat $CandidatOrga"
	Espionne "Access $CandidatAccess"
	
	set NomGscope [LesNomsGscopeDeLOrganisme $CandidatOrga]
	Espionne "Nom Gscope: $NomGscope"
	
	foreach nomG $NomGscope { 
	    Espionne $nomG
	    
	    if {$nomG == "BsuX"}      { continue }
	    if {$nomG == "BiZar"}     { continue }
	    if {$nomG == "VchoDemo"}  { continue }

	    set BoiteDuGenome [QuestionDeScience $nomG "ret Narcisse $CandidatAccess"] 
	    
	    if {$BoiteDuGenome == "" && [regexp -nocase {[a-z]{3}} $CandidatAccess]} {	
		set LeEmbl [LaSequenceDesBanques $CandidatAccess $CandidatAccess accessOk "OnVeutEMBL"]
		if {$LeEmbl == ""} {continue}
		scan [lindex $LeEmbl 1] "%s %s" bidon AC
		set BoiteDuGenome [QuestionDeScience $nomG "ret Narcisse $AC"] 
	    }     

	    if {$BoiteDuGenome == ""} {continue}
	    Espionne "BoiteDuGenome $BoiteDuGenome"
	    
	    set ListeAccessEnPlus [QuestionDeScience $nomG \
		    "ret LesAccessDesOrganismesSample $BoiteDuGenome"]
	    set ListeOrgaEnPlus [QuestionDeScience $nomG \
		    "ret LesAccessDesOrganismesSample $BoiteDuGenome LesOrganismesMerci"]

	    Espionne "coucou1 $ListeAccessEnPlus"  
	    Espionne "coucou2 $ListeOrgaEnPlus"

	    foreach AC $ListeAccessEnPlus OG $ListeOrgaEnPlus {
		#Espionne "$AC $OG"

		set PAB [NarcissePourLOrganisme $AC $OG]
		if {$PAB == ""} { continue }

		lappend ListeDesPABs $PAB
		lappend AdePAB($PAB) $AC

		set Poisson [Glossaire $OG Court]
		set FPP "$Famille $Poisson $nomG"

		if { ! [info exists FPPdePAB($PAB)] || [lsearch [set FPPdePAB($PAB)] $FPP] < 0} {
		    lappend FPPdePAB($PAB) $FPP
		}
	    }
	}
    }
    set LesFpPPP {}
    foreach PAB [lsort -unique $ListeDesPABs] {
	set LesPecs {}
	foreach FPP [set FPPdePAB($PAB)] {
	    scan $FPP "%s %s %s" Fam Poi Pec
	    lappend LesPecs $Pec
	}
	set Liste [concat [list $Fam $Poi] $LesPecs]
	set FpPPP [join $Liste "_"]
	lappend LesFpPPP $FpPPP
	set PABdeFpPPP($FpPPP) $PAB
    }

    set Sortie {}
    foreach FpPPP [lsort $LesFpPPP] {
	set PAB     [set PABdeFpPPP($FpPPP)]
	set GDBName [file tail [GenomeDu $PAB]]

	lappend Sortie "$FpPPP $PAB $GDBName"
    }
    EspionneL $Sortie
   
    return $Sortie
}

proc CreeBilanIndividuel { {Fichier ""} } {
    
    global RepertoireDuGenome
    
    set RepXHda "$RepertoireDuGenome/xhda"

    if {$Fichier==""} {
	set BilanTotal "$RepXHda/BilanXHdaTotal"
	if {! [File exists $BilanTotal]} {return "$BilanTotal does not exists"}
    }

    foreach ligne [LesLignesDuFichier $BilanTotal] {
	Espionne $ligne
	scan $ligne "%s" NomDeFamille
	AppendAuFichier "$RepertoireDuGenome/bilan_xhda/$NomDeFamille" $ligne
    }
}

proc ReunitLesBilansXHDA { {Nom ""} } {

    Wup "Reunit les fichiers de bilans en un seul par defaut BilanXHdaTotal"

    global RepertoireDuGenome
    
    set RepXHda "$RepertoireDuGenome/xhda"
    set BilanLaTotale {}
    set RepBilan "$RepertoireDuGenome/bilan_xhda"

    if { $Nom!="" } {
	set FichierBilanLaTotale "$RepXHda/$Nom"
    } else {
	set FichierBilanLaTotale "$RepXHda/BilanXHdaTotal"
    }

    set LesFichiersBilan [glob -nocomplain "$RepBilan/*"]
    #EspionneL $LesFichiersBilan

    foreach file $LesFichiersBilan {
	foreach ligne  [LesLignesDuFichier $file] {
	    lappend BilanLaTotale $ligne
	}
    }
    set BilanLaTotale [lsort -unique $BilanLaTotale] 

    return [SauveLesLignes $BilanLaTotale dans $FichierBilanLaTotale]
}

proc PourNucaPourTous {} {

    Wup "Permet de convertir tous les bilansXHDA en 1 fichier utilisable pour Nuca"

    global RepertoireDuGenome
    
    set RepBilan "$RepertoireDuGenome/bilan_xhda"

    set LesFamilles [glob -nocomplain "$RepBilan/*"]

    return "[PourNuca $LesFamilles "" "TousLesBilans"] created."
} 

proc PourNuca { LesFamilles {LesOrgas ""} {FichierXHDA ""} } {
 
    Wup "Permet de convertir un fichier BilanXHda en fichier pour Nuca fournit B T ou J"
    
    global RepertoireDuGenome

    set RepXHda  "$RepertoireDuGenome/xhda"
    set RepBilan "$RepertoireDuGenome/bilan_xhda"

    set LesFichiersFamille {}
   

    if {! [regexp "/" $LesFamilles]} {
	foreach file $LesFamilles {
	    lappend LesFichiersFamille "$RepBilan/$file" 
	}
    } else {
	set LesFichiersFamille $LesFamilles
    }
    Espionne $LesFichiersFamille
    
    if {$LesOrgas=="" || $LesOrgas=="Tous"} {
	foreach orga [LesGenomesCompletsAuFormat Court] {
	    lappend LesORGAs [string toupper $orga]
	}
    }
    Espionne $LesORGAs

    if {$FichierXHDA==""} {set FichierXHDA  "$RepXHda/TousLesBilans"}
    
    if { ! [regexp "/" $FichierXHDA]} {
	set FichierXHDA "$RepXHda/$FichierXHDA"
    }
       
    set FichierNUCA "${FichierXHDA}_PourNuca"
    
    foreach File $LesFichiersFamille {
	foreach ligne [LesLignesDuFichier $File] {
	    scan $ligne "%s %s %d %d %d" PAB Orga T B J
	    
	    if {! [regexp -all -nocase "$Orga" $LesORGAs]} { continue }

	    set BDePABOrga($PAB,$Orga) $B
#	    set TDePABOrga($PAB,$Orga) $T
#	    set JDePABOrga($PAB,$Orga) $J
	    
	    if { ! [info exists DejaVu($PAB)]} {
		lappend LesPABs $PAB
		set DejaVu($PAB) 1
	    }
	    if { ! [info exists DejaVu($Orga)]} {
		lappend LesOrgas $Orga
		set DejaVu($Orga) 1
	    }
	}
    }
    set n [llength $LesPABs]
    set d [llength $LesOrgas]
    
    set LesLignes [list "$n\t$d"]
    
    set FichierOrgasOrdonnes "$RepXHda/OrgaOrdonne.nuca"
    set Res [SauveLesLignes $LesOrgas dans $FichierOrgasOrdonnes]
    
    foreach PAB $LesPABs {
	set Ligne "$PAB"
	foreach Orga $LesOrgas {	    
	    append Ligne "\t[set BDePABOrga($PAB,$Orga)]"	   
#	    append Ligne "\t[set TDePABOrga($PAB,$Orga)]"	   
#	    append Ligne "\t[set JDePABOrga($PAB,$Orga)]"	   
	}
	lappend LesLignes $Ligne
    }
    return [SauveLesLignes $LesLignes dans $FichierNUCA]
}

proc RenommeBilan {} {

    Wup "Renomme les fichier Bilan* en .bilan"
    
    global RepertoireDuGenome
    
    set RepXHda "$RepertoireDuGenome/xhda"
    set LesFichiersBilan {}
    set LesBilans {}

    set LesFichiersBilan [glob -nocomplain "$RepXHda/bilan*"]
    foreach file $LesFichiersBilan {
	lappend LesBilans [file tail $file] 
    }
    EspionneL $LesBilans
    
    foreach file $LesBilans {
	set Nom $file
	regsub "^bilan_" $Nom "" Nom
	set Nom "$Nom.bilan" 
	#Espionne $Nom
	set Resu [file rename -force "$RepXHda/$file" "$RepXHda/$Nom"]
    }
}

proc RelitFichierNuca {FichierNuca} {

    Wup "Relit une sortie Nuca et permet de la relire en fichier .traiter"

    global RepertoireDuGenome

    set RepXHda "$RepertoireDuGenome/xhda"

    if { ! [regexp "/" $FichierNuca]} {
	set FichierNuca "$RepXHda/$FichierNuca"
    }
    if { ! [file exists $FichierNuca]} {
	FaireLire "$FichierNuca doesn't exist. I cancel RelitFichierNuca"
	return ""
    }
    
    set NewFile {}
    foreach ligne [LesLignesDuFichier $FichierNuca] {
	if { [regexp "Number of clusters" $ligne] } {
	    lappend NewFile $ligne
	    continue
	}
	if { [regexp "^Cluster" $ligne] } {
	    lappend NewFile $ligne
	    continue
	}
	if {$ligne==""} {
	    lappend NewFile "\n"
	    continue
	}
	scan $ligne "%s" PAB
	
	lappend NewFile $PAB
    }

    set FichierNewFile "$FichierNuca.traiter"
    return "[SauveLesLignes $NewFile dans $FichierNewFile] created."
}

proc LesLoupesDeTous { {Fichier ""} } {

    Wup "Rend les Loupes ou jaunes de tous les organismes et PABs classes par PAB ou par Orga dans LoupeDeTous.parpab et LoupeDeTous.parorga"

    global RepertoireDuGenome
    
    set RepXHda  "$RepertoireDuGenome/xhda"
    set RepBilan "$RepertoireDuGenome/bilan_xhda"

    if { $Fichier!="" && ! [regexp "/" $Fichier]} {
	set FichierBilan "$RepBilan/$Fichier"
    }

    if { $Fichier=="" } { 
	set FichierBilan ""
    }
    
    set LesOrgas [LesLoupes "LesOrganismesMerci" "Tous" $FichierBilan]
    set LesPABs  [LesLoupes "LesPABsMerci" "Tous" $FichierBilan]

    set Resultat {}
    foreach element $LesOrgas {
	lappend Resultat "[lrange $element 0 end] [LesLoupes $element "Tous" $FichierBilan]"
    }
    set Ok [SauveLesLignes $Resultat dans "$RepXHda/LoupeDeTous.parorga"]
    
    set Resultat {}
    foreach element $LesPABs {
	lappend Resultat "$element [join [LesLoupes $element "Tous" $FichierBilan] " "]"	
    }
    set Ok [SauveLesLignes $Resultat dans "$RepXHda/LoupeDeTous.parpab"]

    return ""
}

proc LesLoupesDiaBac { {Fichier ""} } {

    Wup "Rend les Loupes ou jaunes uniquement des DiaBacs classes par PAB ou par Orga dans LoupeDiaBac.parpab et LoupeDiaBac.parorga"

    global RepertoireDuGenome
    
    set RepXHda  "$RepertoireDuGenome/xhda"
    set RepBilan "$RepertoireDuGenome/bilan_xhda"

    if { $Fichier!="" && ! [regexp "/" $Fichier]} {
	set FichierBilan "$RepBilan/$Fichier"
    }

    if { $Fichier=="" } { 
	set FichierBilan ""
    }
    
    set LesOrgas [LesLoupes "LesOrganismesMerci" "SampledOnly" $FichierBilan]
    set LesPABs  [LesLoupes "LesPABsMerci" "SampledOnly" $FichierBilan]

    set Resultat {}
    foreach element $LesOrgas {
	lappend Resultat "[lrange $element 0 end] [LesLoupes $element "SampledOnly" $FichierBilan]"
    }
    set Ok [SauveLesLignes $Resultat dans "$RepXHda/LoupeDiaBac.parorga"]
    
    set Resultat {}
    foreach element $LesPABs {
	lappend Resultat "$element [join [LesLoupes $element "SampledOnly" $FichierBilan] " "]"	
    }
    set Ok [SauveLesLignes $Resultat dans "$RepXHda/LoupeDiaBac.parpab"]

    return ""
}

proc LesLoupes { {OrgaOuPAB ""} {SampledOnly ""} {FichierBilan ""} } {

    Wup "Determine dans un fichier bilanXHDA les loupes,rend des orgas pour un PAB, et vice versa"
    Wup "Ceci pour les Sampled uniquement ou Tous leurs PABs (si orga) leurs orgas (si PAB)"
    Wup "Rend aussi laListecomplete des Orgas ou PABs loupes"
    global RepertoireDuGenome
    global LesLoupes

    if {[info exists LesLoupes($OrgaOuPAB)]} { return [set LesLoupes($OrgaOuPAB)] }
    if {[info exists LesLoupes]} { return ""}

    if {$SampledOnly=="Tous"} {set SampledOnly 0} else {set SampledOnly 1}

    set RepXHda  "$RepertoireDuGenome/xhda"
    set RepBilan "$RepertoireDuGenome/bilan_xhda"

    if {$FichierBilan==""} {
	set LesFichiersBilan [glob -nocomplain "$RepBilan/*"]
    }

    if { $FichierBilan!="" && ! [regexp "/" $FichierBilan]} {
	set LesFichiersBilan "$RepBilan/$FichierBilan"
    }
    #EspionneL $LesFichiersBilan 

    set LesPABsLoupes {}
    foreach file $LesFichiersBilan {
	if { ! [file exists $file]} { continue }
	
	foreach ligne [LesLignesDuFichier $file] {
	    scan $ligne "%s %s %d %d %d" PAB Orga T B J

	    if { $ligne == "" } { continue }
	    if {[CouleurHDACroises [list $T $B $J]]=="J"} { 
		set Organisme [Glossaire $Orga Complet]

		if {$SampledOnly && ! [SampledOrganism $Organisme]} { continue }
		
		lappend LesLoupes($PAB) $Organisme
		lappend LesLoupes($Organisme) $PAB

		if { ! [info exists DejaVu($PAB)]} {
		    lappend LesPABsLoupes $PAB
		    set DejaVu($PAB) 1
		}
		if { ! [info exists DejaVu($Organisme)]} {
		    lappend LesOrganismesLoupes $Organisme
		    set DejaVu($Organisme) 1
		}
	    }
	}
    }

    if {! [info exists LesOrganismesLoupes]} {
	set LesLoupes(LesOrganismesMerci) "Aucun"
    } else {
	set LesLoupes(LesOrganismesMerci) $LesOrganismesLoupes
    }

    if {! [info exists LesOrganismesLoupes]} {
	set LesLoupes(LesPABsMerci) "Aucun"
    } else {
	set LesLoupes(LesPABsMerci) $LesPABsLoupes
    }

    return [LesLoupes $OrgaOuPAB]
}

proc LitLoupesParPAB {Fichier Qui} {

    set LesVraisOrgas {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {! [regexp -nocase {[a-z]+} $Ligne]} {continue}
	    
	scan $Ligne "%s" PAB
	if {$PAB!=$Qui} {continue}
	
	set LesOrgas [StringSuivant "$PAB" dans $Ligne]
	foreach {Genre Espece} $LesOrgas {
	    lappend LesVraisOrgas "$Genre $Espece"
	}
    }  
    return [lsort $LesVraisOrgas]
} 

proc LitLoupesParORGA {Fichier Qui} {

    set LesPABs {}
    set ORGA [Glossaire $Qui Complet]

    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {! [regexp -nocase {[a-z]+} $Ligne]} {continue}
	    
	scan $Ligne "%s %s" Genre Espece
	set Organisme "$Genre $Espece"
	
	if {$Organisme!=$Qui && $Organisme!=$ORGA} {continue}
	set LesPABs [StringSuivant "$Espece" dans $Ligne]
    }  
    return [lsort $LesPABs]
} 

proc LesLoupesDe {Quoi} {

    global RepertoireDuGenome 

    set RepXHda "$RepertoireDuGenome/xhda"
    
    if {[EstUnPAB $Quoi]} {
	set Fichier "$RepXHda/LoupeDeTous.parpab"
	if {[File exists $Fichier]} {
	    return [LitLoupesParPAB $Fichier $Quoi]
	} else { return "$Fichier do not exists" }
    } else {
	set Fichier "$RepXHda/LoupeDeTous.parorga"
	if {[File exists $Fichier]} {
	    return [LitLoupesParORGA $Fichier $Quoi]
	} else { return "$Fichier do not exists" }
    }
}

proc LesMembresDeLaFamille Nom {
    
    global RepertoireDuGenome 
    
    set RepFamille "$RepertoireDuGenome/xhda/famille"

    if {[file exists "$RepFamille/${Nom}.fam"] && [file size "$RepFamille/${Nom}.fam"]!=0} {
	set FichierFamille "$RepFamille/${Nom}.fam"
    } else { 
	return ""
    }

    foreach ligne [LesLignesDuFichier $FichierFamille] {
	scan $ligne "%s %s %s" FPP PAB orga
	set Famille [lindex [split $FPP "_"] 0]

	lappend LesORGAsPABs $orga
	lappend LesORGAsPABs $PAB 
    }
    return $LesORGAsPABs
}

proc CreonsLesLoupesRR {} {

    global RepertoireDuGenome 
    
    set RepXHDA "$RepertoireDuGenome/xhda"
    set FichierDesLoupes "$RepXHDA/Loupe.parpab"

    set LesFamilles {}

    if {![file exists $FichierDesLoupes]} { return "Loupe.parpab does not exists" }

    foreach ligne [LesLignesDuFichier $FichierDesLoupes] {
	set OrgaLoupes {}
	
	scan $ligne "%s" Famille
	regsub "$Famille " $ligne "" ligne 
	
	set n [llength $ligne]
	for {set i 0} {$i<$n} {incr i 2} {
	    set Genre  [lindex $ligne $i] 
	    set Espece [lindex $ligne [expr $i+1]] 
	    lappend OrgaLoupes "$Genre $Espece"
	}

	if { ! [info exists DejaVu($Famille)]} {
	    lappend LesFamilles $Famille
	    set DejaVu($Famille) 1
	}
	    
	set OrgaLoupeDeLaFamille($Famille) $OrgaLoupes
	#Espionne "OrgaLoupe $OrgaLoupes"
    }
    #Espionne "LesFamilles $LesFamilles"

    foreach Fam $LesFamilles {
	#Espionne "Fam $Fam"

	set LesGenOrfs [LesMembresDeLaFamille $Fam]
	#Espionne "LesGenOrfs $LesGenOrfs"
	#Espionne "Tab [set OrgaLoupeDeLaFamille($Fam)]"
	
	foreach OrgaJaune [set OrgaLoupeDeLaFamille($Fam)] { 
	    set OrgaJaune [string toupper [Glossaire $OrgaJaune Court]]
	    #Espionne "OrgaJaune $OrgaJaune"
	    #Espionne "Slut CreonsLeJaune $Fam $OrgaJaune $LesGenOrfs"
	    CreonsLeJaune $Fam $OrgaJaune $LesGenOrfs
	}
    }
}

proc ProtocoleXHDA {} {

    Espionne "Creation des familles:\n\tCreeLesFamillesDesSelectionnes LaTotale NoAsk\n"
    Espionne "Creation des bilans X-HDA:\n\tNewHDACroisesPourTous\n"
    Espionne "Creation du fichier pour Dpc:\n\tPourNucaPourTous\n"
    Espionne "Pour lancer Dpc:\n\t/biolo/secator/dpc TousLesBilans_PourNuca write_coordinates\n"
    Espionne "Pour repertorier les proteines ratees chez Tous:\n\tLesLoupesDeTous\nGenere 2 fichiers .parpab .parorga\n"
    Espionne "Pour repertorier les proteines ratees seulement chez DiaBac:\n\tLesLoupesDiaBac\nGenere 2 fichiers .parpab .parorga\n"
    Espionne "On peut ensuite relire les rates par PAB ou par Orga:\n\tLesLoupesDe\n"
    Espionne "Pour visualiser les profils de Dpc:\n\tDpcShow TousLesBilans_PourNuca.dpc OrgaOrdonnes.nuca\n"
    Espionne "Le Fichier demande pour avoir les orga en X sur les profils:\n\txhda\OrgaOrdonnes.nuca\n"
    Espionne "Pour les infos d'un cluster:\n\t InfoSurLeCluster NumeroOuPAB"

}

proc LeBilanTriePourJean { {Fichier ""} } {

    global RepertoireDuGenome

    set RepBilan "$RepertoireDuGenome/bilan_xhda"

    if {! [regexp "/" $Fichier]} {
	set Fichier "$RepBilan/$Fichier" 
    }

    set Fichier [LectureBilanHDACroises LesFamilles LesOrgCibles Bilan $Fichier]
    if {$Fichier=={}} { return "" }
 
    set LesXs $LesFamilles
    set LesYs $LesOrgCibles
    set Ordre "SampledBAE"
    set LesGenoTries [LesGenomesDansLeBonOrdre $Ordre]
    
    foreach Y $LesYs {
	set JExiste($Y) 1
    }
    
    foreach G $LesGenoTries {
	set Y [string toupper [Glossaire $G Court]]
	if { ! [info exists JExiste($Y)]} { continue }
	lappend LesYsTries $Y
    }
    set Titre "X-HDA sorted by Organisms ($Ordre)"
    set Fichier [File tail $Fichier]

    return [DessineBilanHDACroises $LesXs $LesYsTries Bilan $Fichier]
}