proc LesPdbDesRecepteursNucleaires {} {
    NousAllonsAuBoulot "/genomics/link/ProGS/NuclearReceptor"
    set LesAccessPDB [LesLignesDuFichier "nuclearbinding_list.txt"]
    foreach Access $LesAccessPDB {
	set Access [string trim $Access]
	if {$Access==""} { continue }
	set a [string tolower $Access]
	set T [TextePDB $a "all"]
	if {$T==""} { lappend LesAbsents $Access; continue }
	Espionne [Sauve $T dans "$a.pdb"]
	lappend LesPresents $a
    }
    set P [AfficheListe $LesPresents "AvecFetche"]
    AfficheListe $LesAbsents
    OnRevientDuBoulot
    return $P
}

proc SpineIgbmcSite {} { 
    return "http://lbgi.fr/Spine"
}

proc CouleurDegradee {{Quoi ""}} {
    global CouleurDegradee NombreDeCouleursDegradees IemeCouleurDegradee

    if {[regexp {^[0-9]+$} $Quoi]} {
	set NombreDeCouleurs $Quoi
	set NombreDeCouleursDegradees $NombreDeCouleurs
	set IemeCouleurDegradee $NombreDeCouleurs
	return
    }

    set BackGround [Nuance [expr [incr IemeCouleurDegradee -1]/(1.*$NombreDeCouleursDegradees)]]
    set ForeGround "black"

    if {$Quoi==""} { set Quoi "BackGround" }
    if {$Quoi=="BackGround"} { return "$BackGround" }
    if {$Quoi=="ForeGround"} { return "$ForeGround" }
    if {$Quoi=="BackFore"}   { return "$BackGround $ForeGround" }
    if {$Quoi=="ForeBack"}   { return "$Foreground $BackGround" }
    return "$BackGround $ForeGround"
}

proc SpineSummaryOnWeb {{AvecMutant ""}} {

    if {$AvecMutant==""} { set AvecMutant "SansMutant" }
    if {$AvecMutant=="AvecMutant"} { set AvecMutant 1 } else { set AvecMutant 0 }
    if {$AvecMutant} {
	set AligneMutant "left"
	set TitreMutant "Mutant codes"
    } else {
	set AligneMutant "right"
	set TitreMutant "Mutant"
    }

    set Titre "Gscope summary of the Structural Genomics Targets of IGBMC"
    set Header ""
    Html_ZeroToBody $Titre $Header

    Html_Append [H_Balise $Titre "h3"]
    if {$AvecMutant} {
	Html_Href " ... same page without mutants"  [ReferenceGscope SpineSummaryOnWeb "SansMutant"]
    } else {
	Html_Href " ... same page with all mutants" [ReferenceGscope SpineSummaryOnWeb "AvecMutant"]
    }
    set NbCol 14
    CouleurDegradee $NbCol
    set Liste {}
    lappend Liste $NbCol
    lappend Liste "border='1' cellpadding='3' cellspacing='1'"
    lappend Liste ""
    lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap'"
    lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap'"
    lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap' align='$AligneMutant'"
    lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap' align='right'"
    lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap' align='center'"
    lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap' align='center'"
    lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap' align='center'"
    lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap' align='center'"
    lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap'"
    lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap'"
    lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap'"
    lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap'"
    lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap'"
    lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap'"

    lappend Liste "Please_TH_GscopeID"
    lappend Liste "Gene Name"
    lappend Liste "$TitreMutant"
    lappend Liste "PPCR"
    lappend Liste "Accession"
    lappend Liste "Link to Macsim"
    lappend Liste "at EBI"
    lappend Liste "Task status"
    lappend Liste "Function (see more ->)"
    lappend Liste "Organisms"
    lappend Liste "Contact"
    lappend Liste "Function"
    lappend Liste "Organisms"
    lappend Liste "Contact"

    set Summary [SpineSummary "RetourneTexte"]
    foreach Ligne [split $Summary "\n"] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	ScanLaLigneSpine $Ligne X Al Ac SpOk SpTsk Owner Or
	set Owner [AllToTitle $Owner]
	set TexteMutant " "
	if {$AvecMutant} {
	    set Code [CodeMutation $X]
	    if {$Code!=""} { set TexteMutant $Code }
	} else {
	    if {[EstUnPABMute $X]} { continue } 
	    set LesSitesDesMutants [LesMutantsDe $X Names]
	    set NombreDeMutants [llength $LesSitesDesMutants]
	    if {$NombreDeMutants>0} { set TexteMutant $NombreDeMutants }
	}
	set TextePPCR " "
	set LesVPPCRs [LesVirtualPPCRsDuPGS $X]
	set NbVPPCRs [llength $LesVPPCRs]
	if {$NbVPPCRs>0} { set TextePPCR $NbVPPCRs }
	if {[EstUnPAB $X]} {
	    set XRef [H_Href $X [ReferenceGscope FileMoi $X]]
	    set Definition [DefinitionRapide $X]
	}
	if {[regexp "XGS" $X]} {
	    set XRef $X
	    set Definition " "
	}

	set RefMacsim " "
	set SpineID [SpineID $X]
	if {$SpineID!=""} {
	    set RefMacsim [H_Href $SpineID \
		    "[SpineIgbmcSite]/Annotation/ShowTarget.cgi?TargetId=$SpineID"]
	}
	set SpineGscopeName [ExtraitInfo $X "SpineGscopeName"]
	if {$SpineGscopeName!=""} {
	    set RefMacsim [H_Href $SpineGscopeName \
		    "[SpineIgbmcSite]/Annotation/ShowTarget.cgi?TargetId=$SpineGscopeName"]
	}
	set AcRef [H_Href $Ac [WgetzSurWeb "$Ac" "" "GetUrl"]]
	if {$SpOk} {
	    set SpOkText "EBI"
	} else {
	    set SpOkText " "
	}
	regsub -all {[\<\>]} $Or " " OrRef
	regsub {^[^A-Z]+} $OrRef "" BeauOrRef
	lappend Liste $XRef
	lappend Liste $Al
	lappend Liste $TexteMutant
	lappend Liste $TextePPCR
	lappend Liste $AcRef
	lappend Liste $RefMacsim
	lappend Liste $SpOkText
	lappend Liste [NiceSpineTask $SpTsk]
	lappend Liste [string range $Definition 0 20]
	lappend Liste [H_Italic [string range $BeauOrRef 0 20]]
	lappend Liste [string range $Owner 0 20]
	lappend Liste $Definition
	lappend Liste [H_Italic $OrRef]
	lappend Liste $Owner
    }
    Html_TableFromList $Liste
    Html_BodyToEnd
    return [Html_Get "ZeroIt"]
} 

proc DiffDesXml {} {
    set Lui [ContenuDuFichier "[RepXbgs]/SesTargets.xml"]
    set Moi [ContenuDuFichier "[RepXbgs]/SpineTargetsP10.xml"]
    while 1 {
	set SaTarget [ValeurDeLaBalise "target" Lui]
	set MaTarget [ValeurDeLaBalise "target" Moi]
	regsub -all " " $SaTarget "" SaTarget
	regsub -all " " $MaTarget "" MaTarget
	if {$SaTarget==""} { break }
	foreach SaLigne [split $SaTarget "\n"] MaLigne [split $MaTarget "\n"] {
	    set SaLigne [string trim $SaLigne] 
	    set MaLigne [string trim $MaLigne]
	    if {$SaLigne==$MaLigne} { continue }
	    if { ! [OuiOuNon "Show [string range $MaTarget 0 27] ?\n$SaLigne\n$MaLigne"]} { break }
	    AfficheVariable $SaTarget
	    AfficheVariable $MaTarget "AvecRetour"
	    
	    break
	}
    }
}

proc PDBsDuXGS XGS {
    global PDBsDuXGS
    if {[info exists PDBsDuXGS($XGS)]} { return $PDBsDuXGS($XGS) }
    if {[info exists PDBsDuXGS("EstCharge")]} { return {} }

    set PDBsDuXGS("EstCharge") 1

    set Fichier "[RepXbgs]/XGS_pdb.txt"
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s" XgsLu
	set PDBs [StringSuivant "PDB =" dans $Ligne]
	if {$PDBs==""} { continue }
	set PDBsDuXGS($XgsLu) $PDBs
    }
    return [PDBsDuXGS $XGS]
}

proc NosPDBs {} {
    foreach Nom [ListeDesPABs] {
	set PDBs [ExtraitInfo $Nom "PDB"]
	if {$PDBs==""} { continue }
	foreach PDB [split $PDBs "/"] {
	    set PDB [string trim $PDB]
	    Espionne "$Nom $PDB"
	    set Texte [TextePDB $PDB]
	    if {$Texte==""} { Espionne "$Nom $PDB =============" ; continue }
	    continue
	    
	    set Retour [AfficheVariable $Texte "AvecFormateAvecRetour" "PDB_$PDB/$Nom"]
	    if {[regexp -nocase "NMR" $Retour]} { Informe $Nom }
	}
    }
}

proc RequiredSpineTask SpTsk {
    global RequiredSpineTask

    if {[info exists RequiredSpineTask($SpTsk,4)]} { return [set RequiredSpineTask($SpTsk,4)] }
    if {[info exists RequiredSpineTask($SpTsk,3)]} { return [set RequiredSpineTask($SpTsk,3)] }
    if {[info exists RequiredSpineTask($SpTsk,2)]} { return [set RequiredSpineTask($SpTsk,2)] }
    if {[info exists RequiredSpineTask($SpTsk,1)]} { return [set RequiredSpineTask($SpTsk,1)] }
    if {[info exists RequiredSpineTask("EstCharge")]} { return {} }

    set RequiredSpineTask("EstCharge") 1

    set LesRequired(1) {}
    set LesRequired(2) {}
    set LesRequired(3) {}
    set LesRequired(4) {}
    foreach {Task Req NiceTask} [LaListeDesTasks] {
	foreach C [split $Req ""] {
	    if {$C==0} { continue }
	    set RequiredSpineTask($Task,$C) $LesRequired($C)
	    lappend LesRequired($C) $Task
	}
    }
    return [RequiredSpineTask $SpTsk]
}

proc VerifiePDB {} {
    foreach Nom [ListeDesPABs] {
	set PDB [ExtraitInfo $Nom "PDB"]
	set Task [ExtraitInfo $Nom "SpineTask"]
	if {$Task!="PDB"} { continue }
	Espionne "$Nom $Task $PDB"
    }
    foreach Nom [ListeDesPABs] {
	set PDB [ExtraitInfo $Nom "PDB"]
	set Task [ExtraitInfo $Nom "SpineTask"]
	if {$PDB==""} { continue }
	Espionne "$Nom $PDB $Task"
    }
}

proc CreateTargetId {GS} {
    global DejaVuSpineNumber

    if {$GS=="Reset"} {
	if {[info exists DejaVuSpineNumber]} { unset  DejaVuSpineNumber }
	return ""
    }
    if {[EstUnPABMute $GS]} { return "Mutant" }

    if {[regexp "XGS" $GS]} { regsub "XGS" $GS ""  SpineNumber }
    if {[regexp "PGS" $GS]} {
	regsub "PGS" $GS "0" SpineNumber
	set SpineNumber [string range $SpineNumber end-3 end]
    }
    if {[info exists DejaVuSpineNumber($SpineNumber)]} {
	FaireLire "I had already the SpineNumber $SpineNumber for \n\
		$DejaVuSpineNumber($SpineNumber)"
	return "Already seen"
    }
    set DejaVuSpineNumber($SpineNumber) $GS
    set TargetId "IGBMC-$SpineNumber-000"
    return $TargetId
}

proc InformeSpineIDPourTous {} {
    if {[PreFixe]!="PGS" && \
	    [OuiOuNon "Attention InformeSpineIDPourTous ne marche que pour ProGS. Je stoppe ?"]} { return } 
    CreateTargetId "Reset"
    foreach PGS [ListeDesPABs] {
	if {[EstUnPABMute $PGS]} { continue }
	set ProbableSpineID [CreateTargetId $PGS]
	if { ! [SpineOK $PGS]} { continue }
	set NomSpine [QuestionDeScience Spine "ret GscopeID $ProbableSpineID"]
	set SpineID  [QuestionDeScience Spine "ret SpineID $NomSpine Full"]
	if {$SpineID==""} { continue } 
	scan $SpineID "%s" NomDuSpineID
	if {$NomDuSpineID!=$ProbableSpineID} { FaireLire "$Nom $ProbableSpineID $SpineID" }
	Espionne "$PGS $SpineID $NomSpine"
	InformeSansDemander $PGS "=SpineID: $SpineID"
	InformeSansDemander $PGS "SpineGscopeName: $NomSpine"
    }
    exit
}

proc VerifieOrganismeDuPAB {} {
    foreach Nom [ListeDesPABs] {
	set OI [ExtraitInfo $Nom "Organism"]
	set OO [OrganismeDuPAB $Nom]
	if {$OI==$OO && $OI!=""} { continue }
	Espionne "$Nom\n$OI\n$OO\n"
    }
    exit
}

proc VerifieSpineDefDesMutants {} {
    foreach Nom [ListeDesPABs] {
	if { ! [EstUnPABMute $Nom]} { continue }
 	set Def [ExtraitInfo $Nom "SpineDef"]
	set Grand [GrandFrereDuMutant $Nom]
 	set DefGrand [ExtraitInfo "SpineDef" $Grand]
	if {$Def==$DefGrand} { continue }
	FaireLire "The definitions do not correspond \n\
		$Nom =$Def=\nmutant of \nGrand =$DefGrand=\nPlease informe $Nom"
	Informe $Nom "SpineDef: $DefGrand"
    }
}

proc VerifieSpineRefDesMutants {} {
    foreach Nom [ListeDesPABs] {
	if { ! [EstUnPABMute $Nom]} { continue }
 	set Ref [ExtraitInfo $Nom "SpineRef"]
	set Grand [GrandFrereDuMutant $Nom]
 	set RefGrand [ExtraitInfo $Grand "SpineRef"]
	if {$Ref==$RefGrand} { continue }
	FaireLire "The SpineRefs do not correspond \n\
		$Nom =$Ref=\nmutant of \n$Grand =$RefGrand=\nPlease informe $Nom"
	Informe $Nom "SpineRef: $RefGrand"
    }
}

proc SpineRefParNarcisse {} {
    foreach Nom [ListeDesPABs] {
 	set Ref [ExtraitInfo $Nom "SpineRef"]
	if {$Ref!=""} { continue }
	set Nar [Narcisse $Nom]
	if {$Nar==""} { continue }
	if {[regexp {\:} $Nar]} {
	    set Ref $Nar
	} else {
	    set Ref "uniprot:$Nar"
	}
	Espionne "$Nom $Ref"
	InformeSansDemander $Nom "SpineRef: $Ref"
    }
}

proc RepXbgs {} {
    return "[RepertoireDuGenome]/Xbgs"
}

proc InformeParSpinePourTous {} {
    foreach Nom [ListeDesPABs] {
	set Entete [EnteteDuFichierTFA "[RepertoireDuGenome]/prottfa/$Nom"]
	set E $Entete
	foreach Clef {SpineID SpineDef SpineRef} {
	    if {[set iDeb [string first "$Clef (" $E]]<0} { continue }
	    set iFin [string last ")" $E]
	    set Val [string range $E $iDeb [incr iFin -1]]
	    set Old [ExtraitInfo $Nom $Clef]
	    regsub "$Clef \\(" $Val "" Val
	    set Val [string trim $Val]
	    set Valeur($Clef) $Val
	    set E [string range $E 0 [incr iDeb -1]]
	    Espionne "$Clef $Val"

	    if {$Old==$Val} { continue }
	    if {$Old!="" && \
		    [OuiOuNon "For $Nom I had $Clef: \n$Old and got \n$Val\nDo I keep ?"]} {
		continue
	    }
	    if {$Clef=="SpineRef"} {
		InformeSansDemander $Nom "SpineRef: $Val"
	    }
	    if {$Clef=="SpineID"} {
		InformeSansDemander $Nom "SpineID: $Val"
	    }
	    if {$Clef=="SpineDef"} {
		InformeSansDemander $Nom "SpineDef: $Val"
	    }
	}source /biolo/srs/setsrs.com

    }
    
}

proc NiceSpineTask TaskCode {
    global NiceSpineTask
    if {[info exists NiceSpineTask($TaskCode)]} { return [set NiceSpineTask($TaskCode)] }
    if {[info exists NiceSpineTask("EstCharge")]} { return $TaskCode }
    set NiceSpineTask("EstCharge") 1
    foreach {Code R Nice} [LaListeDesTasks] {
	set NiceSpineTask($Code) $Nice
    }
    return [NiceSpineTask $TaskCode]
}

proc LaListeDesTasks {{Ordre ""}} {

    set LaListe [list \
	    ?    0 "Selected" \
	    Sele 1234 "Selected" \
	    PCR  123 "PCR" \
	    Clon 123 "Cloned" \
	    Expr 123 "Expressed" \
	    Solu 123 "Soluble" \
	    Puri 123 "Purified" \
	    ScUp 123 "Scale-up" \
	    InCr 2 "In crystallization" \
	    Crys 2 "Crystallized" \
	    CrDi 2 "Diffraction-quality Crystals" \
	    NaDi 2 "Native diffraction-data" \
	    PhDi 2 "Phasing diffraction-data" \
	    NMRa 3 "NMR Assigned" \
	    HSQC 3 "HSQC" \
	    3d   2 "Crystal Structure" \
	    NMR  3 "NMR Structure" \
	    PDB  2 "In PDB" \
	    MoFu 0 "Molecular Function" \
	    Biol 0 "Biological Process" \
	    Cell 0 "Cellular Component" \
	    STOP 4 "Work Stopped" \
	    Othe 0 "Other"]
    if {[regexp "Reverse" $Ordre]} { return [RetourneLaListe $LaListe] }
    return $LaListe
}

proc LesMemesDansPGSetXGS {} {
    Wup "Recherche les target identiques dans XGS et PGS ..."
    Wup "Il faut, apres, supprimer la ligne du XGS dans XGS.txt"

    set Page [SpineSummary "RetourneTexte"]
    foreach Ligne [split $Page "\n"] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	ScanLaLigneSpine $Ligne X Al Ac SpOk SpTsk Owner Or
	if {[EstUnPAB $X]} {
	    lappend DejaVuAl($Al) $Ligne
	    lappend DejaVuAc($Ac) $Ligne
	    continue
	}
	if {[regexp "XGS" $X]} {
	    set Vu ""
	    if {[info exists DejaVuAl($Al)]} {
		append Vu [join $DejaVuAl($Al) "\n"]
	    }
	    if {[info exists DejaVuAc($Ac)]} {
		append Vu [join $DejaVuAc($Ac) "\n"]
	    }
	    if {$Vu==""} { continue }
	    set Memes "$Ligne\n\n$Vu"
	    set R [AfficheVariable $Memes "AvecRetourGrandeLargeur"]
	}
    }
}

proc InformeSpineDefPourTous {} {
    foreach Nom [ListeDesPABs] {
	set DE [SpineDefinition $Nom]
	if {$DE==""} { continue }
	Espionne "$Nom $DE"
	InformeSansDemander $Nom "SpineDef: $DE"
    }
}

proc AfficheSpineDefinitions {} {
    set Page [SpineSummary "RetourneTexte"]
    foreach Ligne [split $Page "\n"] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	ScanLaLigneSpine $Ligne X Al Ac SpOk SpTsk Owner Or
	set DE [SpineDefinition $X]
	set BelleDE [format "%-50s" $DE]
#	regsub "$Or" $Ligne "$BelleDE $Or" Texte
	set Texte "$Ligne $BelleDE"
	lappend LeTout $Texte
    }
    return [AfficheVariable [join $LeTout "\n"] "" coucou]
}

proc LesDefinitionsBienParenthesees Texte {
    set Niveau 0
    set LesDefs {}
    set Lu ""
    set LesCars [split $Texte ""]
    lappend LesCars "."
    set DernierMis "turlututu"
    foreach C $LesCars { 
	if {$C=="("} {
	    if {$Niveau==0} {
		set AMettre [string trim $Lu " .;"]
		if {$AMettre!=$DernierMis} { lappend LesDefs $AMettre ; set DernierMis $AMettre } 
	    }
	    incr Niveau
	    append Lu $C 
	    continue
	}
	if {$C==")"} {
	    incr Niveau -1
	    append Lu $C
	    continue
	}
	append Lu $C
	if {$C==" " || $C=="." || $C==";"} {
	    set AMettre [string trim $Lu " .;"]
	    if {$AMettre!=$DernierMis} { lappend LesDefs $AMettre ; set DernierMis $AMettre } 
	}
    }
    set AMettre [string trim $Lu " .;"]
    if {$AMettre!=$DernierMis} { lappend LesDefs $AMettre ; set DernierMis $AMettre } 
    return $LesDefs
}

proc SpineDef Nom {
    return [ExtraitInfo $Nom "SpineDef:"]
}

proc SpineDefinition Nom {
    return [SpineDef $Nom]
}

proc OldSpineDefinition SPI {
    global SpineDefinition

    if {[info exists SpineDefinition($SPI)]} { return [set SpineDefinition($SPI)] }
    if {[info exists SpineDefinition("EstCharge")]} {
	if {[EstUnPABMute $SPI]} {
	    return [SpineDefinition [GrandFrereDuMutant $SPI]]
	}
	return ""
    }

    set FichierSpineDef "[RepXbgs]/SpineDefinitions.txt"
    if {[file exists $FichierSpineDef]} {
	array set SpineDefinition [LesLignesDuFichier $FichierSpineDef]
	set Complete 0
	if {[OuiOuNon "Do You want to complete $FichierSpineDef ?"]} {
	    set Complete 1
	} else {
	    set SpineDefinition("EstCharge") ""
	    return [SpineDefinition $SPI]
	}
    } else {
	set Complete 0
    }

    set Page [SpineSummary "RetourneTexte"]
    foreach Ligne [split $Page "\n"] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	Espionne $Ligne
	ScanLaLigneSpine $Ligne X Al Ac SpOk SpTsk Owner Or
	if {$Complete && [info exists SpineDefinition($X)]} { continue }
	if {[OuiOuNon "Do We stop now ?" 0]} { break }
	if {$Ac=="AC_no"||$Ac=="AC_not"} {set SpineDefinition($X) "" ; continue }
	set LesLignesEMBL [LaSequenceDesBanques $Ac $Ac acOk "OnVeutEMBL"]
	set LesBrutDE [LeChampDesLignesEMBL $LesLignesEMBL "DE"]
	if {$LesBrutDE=={}} { set SpineDefinition($X) "" ; continue }
	set LesDE {}
	foreach DE $LesBrutDE {
	    regsub "DE   " $DE "" DE
	    lappend LesDE $DE
	}
	set PremDE [lindex $LesDE 0]
	set ToutDE [join $LesDE " "]
	Espionne "[join $LesBrutDE "\n"]\n$PremDE\n$ToutDE"
	if {$ToutDE!="" && [string length $ToutDE]<50} {
	    set SpineDefinition($X) $ToutDE
	    continue
	}
	set LesDefBienParenth [LesDefinitionsBienParenthesees $ToutDE]
	lappend LesDefBienParenth "EditByMyself"
	set Bonne [ChoixParmi $LesDefBienParenth]
	if {$Bonne!="" && $Bonne!="EditByMyself"} {
	    set SpineDefinition($X) $Bonne
	    continue
	}
	while 1 {
	    set BonDE [Entre $ToutDE]
	    if {$BonDE!=""} { 
		set SpineDefinition($X) $PremDE
		break
	    }
	    if {[OuiOuNon "Do I use an empty string ?"]} {
		set SpineDefinition($X) ""
		break
	    }
	}
    }
    SauveLesLignes [array get SpineDefinition] dans $FichierSpineDef
    return [SpineDefinition $SPI]
}

proc ScanLaLigneSpine {Ligne {aGS ""} {aAlias ""} {aAccess ""} {aSpOk ""} {aSpTsk ""} {aOwner ""} {aOrga ""} {aPrenom ""} {aNom ""}} {
    if {$aGS    !=""} { upvar $aGS     GS }
    if {$aAlias !=""} { upvar $aAlias  Alias }
    if {$aAccess!=""} { upvar $aAccess Access }
    if {$aSpOk  !=""} { upvar $aSpOk   SpOk }
    if {$aSpTsk !=""} { upvar $aSpTsk  SpTsk }
    if {$aOwner !=""} { upvar $aOwner  Owner }
    if {$aOrga  !=""} { upvar $aOrga   Orga }
    if {$aPrenom!=""} { upvar $aPrenom Prenom }
    if {$aNom   !=""} { upvar $aNom    Nom }

    scan $Ligne "%s %s %s %s %s %s %s" GS Alias Access SpOk SpTsk Prenom Nom
    set Owner "$Prenom $Nom"
    set Orga [string trim [StringSuivant "$Prenom $Nom" dans $Ligne]]
    return $GS
}

proc HistoDesSpineTasks {{SpineOnly ""} {Action ""}} {

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

    if {$SpineOnly==""} { set SpineOnly "AllToGether" }
    set  SpineOnly [regexp -nocase "SpineOnly" $SpineOnly]

    set Page [SpineSummary "RetourneTexte"]
    foreach Ligne [split $Page "\n"] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	ScanLaLigneSpine $Ligne X Al Ac SpOk SpTsk Owner Or
#	if {[EstUnPABMute $X]} { continue }
	if { $SpineOnly && ! $SpOk } { continue }
	if {$SpTsk=="?"} { set SpTsk "Sele" }
	if { ! [info exists H($SpTsk)]} { set H($SpTsk) 0 }
	incr H($SpTsk)
    }
    set Cumul 0
    foreach {NiceSpTsk R SpTsk} [LaListeDesTasks "Reverse"] {
	if { ! [info exists H($SpTsk)]} { continue }
	incr Cumul [set H($SpTsk)] 
	lappend Sortie [format "%3d %s" $Cumul $NiceSpTsk]
    }
    set LesLignesHisto [RetourneLaListe $Sortie]
    set Histo [join $LesLignesHisto "\n"]
    if {$Action=="Show"} { 
	return [AfficheVariable $Histo "" "Our_Spine_status"]
    }
    return $Histo
}

proc RankOfSpineTask Task {
    global RankOfSpineTask
    if {[info exists RankOfSpineTask($Task)]} { return $RankOfSpineTask($Task) }
    if {[info exists RankOfSpineTask("EstCharge")]} { return 0 }
    set RankOfSpineTask("EstCharge") 1
    set i 0
    foreach {T R N} [LaListeDesTasks] {
	set RankOfSpineTask($T) $i
	incr i
    }
    return [RankOfSpineTask $Task]
}

proc SpineTaskLatest PAB {
    return [lindex [SpineTaskOrdered $PAB] end]
}

proc SpineTask {PAB {Valeur ""}} {

    Wup "Pour les XGS on ne passe pas par ExtraitInfo"
    global SpineTask
    if {$Valeur!=""} { set SpineTask($PAB) $Valeur }
    if {[info exists SpineTask($PAB)]} { return [set SpineTask($PAB)] }
    Wup "Fin XGS"

    set Tasks [ExtraitInfo $PAB "SpineTask"]
    if {$Tasks==""} { set Tasks "?" }
    return $Tasks
}

proc SpineTaskOrdered {PAB} {

    set Tasks [SpineTask $PAB]
    if {$Tasks==""} { set Task [list "?"] }

    while {[regexp {[0-9]/} $Tasks Match]} {
	regsub "/" $Match "-" BonMatch
	regsub -all $Match $Tasks $BonMatch Tasks
    }
    set LesTasksOrdonnees {}
    foreach Task [split $Tasks "/"] {
	set Task [string trim $Task]
	scan $Task "%s" SpTsk
	lappend LesTasks "[RankOfSpineTask $SpTsk] $Task"
    }
    set LesTasksOrdonnees {}
    foreach Task [lsort -index 0 -integer $LesTasks] {
	regsub {[0-9]+ } $Task "" Task
	lappend LesTasksOrdonnees $Task
    }
    return $LesTasksOrdonnees
}

proc LesTAFs {} {
    foreach F [glob "*.nuctfa"] {
	regsub ".nuctfa" $F "-protein.blastx" B
	set Sequence [QueLaSequenceDuFichierTFA $F]
	Blaste "X" $Sequence $B "/catalog/blast/protein"
    }
    exit
    foreach D [glob "*.dna"] {
	regsub ".dna" $D "" T
	if {[regexp "ec" $T]} { set Entete "$T $T Encephalitozoon cuniculi Tbp Associated Factor" }
	if {[regexp "y"  $T]} { set Entete "$T $T Saccharomyces cerevisiae Tbp Associated Factor" }
	if {[regexp "h"  $T]} { set Entete "$T $T Homo sapiens Tbp Associated Factor" }
	set TFA [SequenceFormatTFA [ContenuDuFichier $D] $Entete "gcg"]
	Sauve $TFA dans "$T.nuctfa"
    }
    exit
}

proc OrganismeDesXGSs {} {
    set FichierXGS "[RepXbgs]/XGS.txt"
    set LesNouveauxXGSs {}
    foreach Ligne [LesLignesDuFichier $FichierXGS] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { lappend LesNouveauxXGSs $Ligne ; continue }
	ScanLaLigneSpine $Ligne X Al Ac SpOk SpTsk Owner Or
	if {[regexp "AC_" $Ac]} {
	    lappend LesNouveauxXGSs $Ligne
	    continue
	}
	set OXs [TaxIdDuAccess $Ac]
	if {$OXs==""} {
	    lappend LesNouveauxXGSs $Ligne
	    continue
	}
	set TextOr "<"
	set LesTextOrs {}
	foreach OX [split $OXs " "] {
	    lappend LesTextOrs "<[Tax $OX Name]>"
	}
	set BonOr "$OXs <[join $LesTextOrs "+"]>"
	if { ! [regexp "NoOrganism" $Or]} {
	    if {$Or==$BonOr || ! [OuiOuNon "Do I replace \n$Or\n with\n $BonOr ?"]} { 
		lappend LesNouveauxXGSs $Ligne
		continue
	    }
	}
	set NouvelleLigne [format "%s %-15s %-15s %1s %-4s  %-20s %s" $X $Al $Ac $SpOk $SpTsk "$Pr $No" $BonOr]
	lappend LesNouveauxXGSs $NouvelleLigne
    }
    SauveLesLignes $LesNouveauxXGSs dans $FichierXGS
}

proc AfficheLesSpines {Page {KO ""}} {
    foreach Ligne [split $Page "\n"] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	ScanLaLigneSpine $Ligne X Al Ac SpOk 
	if {$SpOk} {
	    lappend LesBons $Ligne
	} else {
	    lappend LesMauvais $Ligne
	}	
    }
    if {$KO=="KO"} {
	set NewPage [join $LesMauvais "\n"]
    } else {
	set NewPage [join $LesBons "\n"]
    }
    return [AfficheVariable $NewPage]
}

proc InformePDB {} {
    set Fichier "[RepXbgs]/PdbOfNuclearReceptorsIGBMC.list"
    foreach Ligne [LesLignesDuFichier $Fichier] {
	set Alias ""
	scan $Ligne "%s %s" aPDB Alias
	if {$Alias==""} { continue }
	lappend LesPdbsDuAlias($Alias) $aPDB
    }

    set LesPDBsOk {}
    foreach PAB [ListeDesPABs] {
	set Alias [Alias $PAB]
	if { ! [info exists LesPdbsDuAlias($Alias)]} { continue }
	foreach aPDB [set LesPdbsDuAlias($Alias)] {
	    set FichierBlast "[RepertoireDuGenome]/blastp/$PAB"
	    if { ! [file exists $FichierBlast]} { FaireLire "no blastp for $PAB" ; continue }
	    set Fen [AfficheFichier $FichierBlast "AvecSegAlignement"]
	    Illumine $aPDB $Fen
	    set Info [Informe $PAB "PDB: $aPDB"]
	    if {$Info==""} { continue }
	    lappend LesPDBsOk "$PAB $Alias $aPDB"
	}
    }
    SauveLesLignes $LesPDBsOk dans LesPDBsOk
    return $LesPDBsOk
}

proc UnPetitNomPourNosPdbs {} {
    set Fichier "[RepXbgs]/PdbOfNuclearReceptorsIGBMC.list"
    set OldAlias ""
    foreach Ligne [LesLignesDuFichier $Fichier] {
	set Alias ""
	scan $Ligne "%s %s" aPDB Alias
	if {$Alias==""} { set Alias $OldAlias }
	set TextePDB [TextePDB $aPDB]
	if {$TextePDB==""} { continue }
	set Id [AfficheVariable $TextePDB]
	update idletask
	set NewAlias [Entre $Alias]
	set OldAlias $NewAlias
	lappend LesBons "$aPDB $NewAlias"
	destroy $Id
    }
    SauveLesLignes $LesBons dans $Fichier
    return $LesBons
}

proc NosPdbofNuclearReceptors {} {
    foreach Nom [People LaListeDes Noms] {
	regsub -all {\-} $Nom "|" Nom
	lappend NosNoms $Nom
    }
    set Nous [join $NosNoms "|"]
    Espionne $Nous

    set NosPdbs {}
    foreach aPDB [LesLignesDuFichier "[RepXbgs]/PdbOfNuclearReceptors.list"] {
	set aPDB [string tolower $aPDB]
	set TextePDB [TextePDB $aPDB "AUTHOR"]
	if {$TextePDB==""} { continue }
	if {[regexp $Nous $TextePDB Match]} {
	    if { ! [OuiOuNon "J'accepte $Match"]} { continue }
	    set OK [AfficheVariable [TextePDB $aPDB] "AvecRetour"]
	    if {$OK==""} { continue }
	    lappend NosPdbs $aPDB
	}
    }
    Espionne [SauveLesLignes $NosPdbs dans PdbofNuclearReceptorsIGBMC.list]
    return $NosPdbs
}

proc SpineOK {PAB {Alias ""} {Valeur ""}} {
    global SpineOK

    if {$Valeur!=""} {
	set SpineOK($PAB)   $Valeur
	set SpineOK($Alias) $Valeur
	return $Valeur
    }

    if {$Alias==""} { set Alias "AAAAAAAAAAAAAAAAAAA" }

    if {[info exists SpineOK($PAB)]} { return [set SpineOK($PAB)] }
    if {[info exists SpineOK($Alias)]} { return [set SpineOK($Alias)] }
    if {[info exists SpineOK("EstCharge")]} { return 1 }
    set SpineOK("EstCharge") 1

    foreach PABlu [ListeDesPABs] {
	set SpOK [ExtraitInfo $PABlu "SpineOK"]
	if {[regexp -nocase "No" $SpOK] || [EstUnPABMute $PABlu]} {
	    set SpineOK($PABlu) 0
	} else {
	    set SpineOK($PABlu) 1
	}
	set AliasLu [Alias $PABlu]
    }
    return [SpineOK $PAB $Alias]

    Wup "La suite est obsolete"
    foreach Ligne [LesLignesDuFichier "[RepXbgs]/ListeComplementaire.txt"] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	scan $Ligne "%s" Alias
	set SpineOK($Alias) [regexp {\*} $Ligne]
    }
	if {[info exists SpineOK($AliasLu)] && [set SpineOK($AliasLu)]!=[set SpineOK($PABlu)]} {
	    FaireLire "$PABlu [set SpineOK($PABlu)] [set SpineOK($AliasLu)] $AliasLu"
	}

}

proc SequencePourSpine {PAB Access} {
    if {[EstUnPAB $PAB]} {
	set Fichier "[RepertoireDuGenome]/prottfa/$PAB"
	if { ! [file exists $Fichier]} { return "" }
	return [QueLaSequenceDuFichierTFA $Fichier]
    }
    if {[regexp "AC_no" $Access]} { return "" }
    set lEMBL [LaSequenceDesBanques $Access $Access aAccessOK "OnVeutEMBL"]
    if {$lEMBL=={}} { return "" }
    set TFA [SequenceFormatTFA [join $lEMBL "\n"] "$Access"]
    set Seq [QueLaSequenceDuTexteTFA $TFA]
    return $Seq
}

proc OrganismePourSpine Organisme {
    return [OrganismeFormate $Organisme "Name"]

    Wup "reste obsolete"
    if {[regexp "<" $Organisme]} {
	set Texte [StringSuivant "<" dans $Organisme]
	regsub -all { +[0-9]+ *$} $Texte "" Texte 
	regsub -all {[<>]} $Texte "" Bon
	return $Bon
    }
    if {[regexp {^[0-9]+} $Organisme Match]} {
	set Bon [Tax $Match]
	return $Bon
    }
    return $Organisme
}

proc CreateSpineXML {{Selection ""} {FichierSpineXML ""}} {


    CreateTargetId "Reset"

    if {$FichierSpineXML==""} {
	set FichierSpineXML "[RepXbgs]/SpineTargetsP10.xml"
    }

    if {$Selection=="Show"} {
	return [AfficheFichier $FichierSpineXML]
    } 

    if {$Selection==""} {
	set Selection [SpineSummary "RetourneTexte"]
    }

    set LesLignes [split $Selection "\n"]

    lappend lXML "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    lappend lXML "<!DOCTYPE targets SYSTEM \"http://lbgi.fr/Spine/public/xml/target.dtd\">"

    lappend lXML "<targets>"
    foreach Ligne $LesLignes {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	OneToSpine $Ligne lXML
    }
    lappend lXML "</targets>"
    if {$Selection=="Show"} {
	return [AfficheVariable [join $lXML "\n"] "" "XML_for_Spine"]
    } 

    if { ! [OuiOuNon "Ok to create a new $FichierSpineXML"]} { return "" } 

    regsub ".xml$" $FichierSpineXML "[Date].xml" FichierSpineXMLDate
            SauveLesLignes $lXML dans $FichierSpineXML
    return [SauveLesLignes $lXML dans $FichierSpineXMLDate]
}

proc OneToSpine {Ligne alXML} {
    upvar $alXML lXML

    set [SpineIgbmcSite]

    ScanLaLigneSpine $Ligne GS Alias Access SpOk SpTsk Owner Organisme
    if { ! $SpOk } { return }
    if {[regexp "^AC_no" $Access]} { set Access "" }

    set TargetId [CreateTargetId $GS]
    if {[regexp "^Mutant" $TargetId]} { return "" }
    if {[regexp "^Already seen" $TargetId]} { return "" }

    set WP "WP10.10 Human targets I - cancer"
    set Sequence [SequencePourSpine $GS $Access]
    set SpiDef [SpineDefinition $GS]
    set ProteineName "$Alias $SpiDef"
    set SpeciesName [OrganismePourSpine $Organisme]
    set DataBase "UniProt"
    set Accession $Access
    set LesSpineTask [SpineTaskOrdered $GS]
    set Date "2004-09-10"
    set LabID "P10"
    set Laboratoire "Departement de Biologie et Genomique Structurales de l'IGBMC  1, rue Laurent Fries  67404 Illkirch Strasbourg France"
    set URL "[SpineIgbmcSite]/index.html"
    set Contact "Dino.Moras@igbmc.u-strasbg.fr"
    set Remarks ""
    set AnnotationUrl "[SpineIgbmcSite]/Annotation/ShowTarget.cgi?TargetId=$TargetId"

    Espionne "$GS $Alias $Access $SpeciesName"

    if {[EstUnPAB $GS]} {
	set PDBs [ExtraitInfo $GS "PDB"]
    } else {
	set PDBs [PDBsDuXGS $GS]
    }
    set LesPBDs {}
    foreach PDB [split $PDBs "/"] {
	lappend LesPBDs [string trim $PDB]
    }

    lappend lXML "  <target>"
    lappend lXML "    <ID>$TargetId</ID>"
    lappend lXML "    <workpackage>$WP</workpackage>"
    lappend lXML "    <sequence>$Sequence</sequence>"
    lappend lXML "    <proteinName>$ProteineName</proteinName>"
    lappend lXML "    <species>$SpeciesName</species>"
    lappend lXML "    <databaseID>"
    lappend lXML "      <database>$DataBase</database>"
    lappend lXML "      <release></release>"
    lappend lXML "      <accession>$Accession</accession>"
    lappend lXML "    </databaseID>"
    foreach PDB $LesPBDs {
	lappend lXML "    <databaseID>"
	lappend lXML "      <database>PDB</database>"
	lappend lXML "      <accession>$PDB</accession>"
	lappend lXML "    </databaseID>"
    }

    foreach TaskAndDate $LesSpineTask {
	set TaskMereDate $Date 
	scan $TaskAndDate "%s %s" TaskMere TaskMereDate
	set LesRequired [RequiredSpineTask $TaskMere]
	lappend LesRequired $TaskAndDate
	foreach TaskLue $LesRequired {
	    scan $TaskLue "%s" Task
	    if {[info exists DejaVu($Task)]} { continue }
	    set DejaVu($Task) 1
	    set TaskDate $TaskMereDate

	    set NiceTask [NiceSpineTask $Task]
	    lappend lXML "    <status access=\"PUBLIC\">"
	    lappend lXML "      <task>$NiceTask</task>"
	    lappend lXML "      <date>$TaskDate</date>"
	    lappend lXML "      <labID>$LabID</labID>"
	    lappend lXML "      <lab>$Laboratoire</lab>"
	    lappend lXML "      <funding-project>SPINE</funding-project>"
	    lappend lXML "      <url>$URL</url>"
	    lappend lXML "      <contact>$Contact</contact>"
	    lappend lXML "      <remarks>$Remarks</remarks>"
	    lappend lXML "    </status>"
	}
    }
    lappend lXML "    <annotationUrl>$AnnotationUrl</annotationUrl>"
    lappend lXML "  </target>"

    return
}

proc RefreshFichierXGS aNouveauXGS {
    upvar $aNouveauXGS NouveauXGS

    set FichierXGS "[RepXbgs]/XGS.txt"
    set LesNouveauxXGSs {}
    foreach Ligne [LesLignesDuFichier $FichierXGS] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { lappend LesNouveauxXGSs $Ligne ; continue }
	ScanLaLigneSpine $Ligne XGS
	if {[info exists NouveauXGS($XGS)]} {
	    set NouvelleLigne [set NouveauXGS($XGS)]
	    regsub { [01]$} $Ligne "" Ligne]
	    lappend LesNouveauxXGSs $NouvelleLigne
	} else {
	    lappend LesNouveauxXGSs $Ligne
	}
    }
    if {$LesNouveauxXGSs=={}} { return "" }
    return [SauveLesLignes $LesNouveauxXGSs dans $FichierXGS]
}

proc XGSPourOwner Selection {
    if {[regexp "\n" $Selection]} {
	foreach Ligne [split $Selection "\n"] {
	    XGSPourOwner $Ligne
	}
	return
    }
    if { ! [regexp -nocase {[a-z]} $Selection]} { return "" }
    ScanLaLigneSpine $Selection XGS
    set LigneCorrigee [Entre $Selection]
    
    if {$LigneCorrigee==""} { return "" }
    ScanLaLigneSpine $LigneCorrigee X Al Ac SpOk SpTsk Owner Or
    set NouvelleLigne [format "%s %-15s %-15s %1s %-4s  %-20s %s" $X $Al $Ac $SpOk $SpTsk $Owner $Or]
    set NouveauXGS($XGS) $NouvelleLigne
    return [RefreshFichierXGS NouveauXGS]
}

proc MemeOwner Selection {
    set LesLignes [split $Selection "\n"]
    foreach Ligne $LesLignes {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	ScanLaLigneSpine $Ligne PAB
	if {[EstUnPAB $PAB]} {
	    set Owner [ExtraitInfo $PAB "Owner"]
	} else {
	    ScanLaLigneSpine $Ligne P Al Ac SpOk SpTsk Owner
	}
	set OwnerDeLaLigne($Ligne) $Owner
    }
    lappend LesLignes "NewOwner"
    set BonneLigne [ChoixParmi $LesLignes]
    if {$BonneLigne=="NewOwner"} {
	set Nouveau [ChoixParmi [People LaListeDes PrenomNom]]
    } else {
	if {$BonneLigne==""} {
	    set Nouveau ""
	} else {
	    set Nouveau [set OwnerDeLaLigne($BonneLigne)]
	}
    }
    Espionne $Nouveau
    if {$Nouveau==""} { set Nouveau [Entre "No OWNER"] }
    foreach Ligne $LesLignes {
	scan $Ligne "%s" PAB
	if {[regexp "^XGS" $PAB]} {
	    ScanLaLigneSpine $Ligne X Al Ac SpOk SpTsk Owner
	    set NouvelleLigne [format "%s %-15s %-15s %1s %-4s  %-20s %s" $X $Al $Ac $SPOk $SpTsk $Nouveau $Or]
	    Espionne "NL $NouvelleLigne"
	    set NouveauXGS($PAB) $NouvelleLigne
	}	    
	if { ! [EstUnPAB $PAB]} { continue }
	InformeSansDemander $PAB "=Owner: $Nouveau"
    }
    if { ! [info exists NouveauXGS]} { return }
    return [RefreshFichierXGS NouveauXGS]
}

proc SpineSummary {{Action ""}} {
    global FenSpineSummary

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

    if {$Action=="Show" && [info exists FenSpineSummary] && [winfo exists $FenSpineSummary]} {
	after 1000 destroy $FenSpineSummary
	unset FenSpineSummary
    }

    foreach PAB [ListeDesPABs] {
	set Narcisse [Narcisse $PAB]
	if {$Narcisse==""} { set Narcisse "AC_no" }
	set Alias [Alias $PAB]
	set Owner [ExtraitInfo $PAB "Owner"]
	set Organisme [OrganismeDuPAB $PAB]
	set DejaVu($Alias) $PAB
	set SpineOK [SpineOK $PAB $Alias]
	set SpineTaskAvecDate [SpineTaskLatest $PAB]
	scan $SpineTaskAvecDate "%s" SpineTask
	lappend LaListe [format "%-7s %-20s %-15s %1s %-4s  %-30s %s" \
		$PAB $Alias $Narcisse $SpineOK $SpineTask $Owner $Organisme]
    }
    set FichierXGS "[RepXbgs]/XGS.txt"
    set LesXGSs [LesLignesDuFichier $FichierXGS]
    set LesBeauxXGSs {}
    foreach Ligne $LesXGSs {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	ScanLaLigneSpine $Ligne XGS Al Ac SpOk SpTsk Owner Or
	SpineOK $XGS $Al $SpOk
	SpineTask $XGS $SpTsk
	lappend LesBeauxXGSs [format "%-7s %-20s %-15s %1s %-4s  %-30s %s" \
		$XGS $Al $Ac $SpOk $SpTsk $Owner $Or]
    }
#   set Page "[join $LesBeauxXGSs "\n"]\n\n[join $LaListe "\n"]"
    set Page "[join $LaListe "\n"]\n\n[join $LesBeauxXGSs "\n"]"
    if {$Action=="RetourneTexte"} { return $Page }
    set FenSpineSummary [AfficheVariable $Page "AvecXbgsGrandeLargeur" "StructuralGenomicsTargets"]
    return $FenSpineSummary
}

proc PeopleOld {{Qui ""} {Quoi ""}} {
    global People

    if {$Qui=="" && $Quoi==""} { set Qui "LaListeDes" ; set Quoi "PrenomNom" } 

    if {[info exists People($Qui,$Quoi)]} { return [set People($Qui,$Quoi)] }
    if {[info exists People("EstCharge")]} { return "" }

    set People("EstCharge") 1

    set FichierPeople "[GscopeEtc]/gscope_people.txt"
    if {[file exists $FichierPeople]} {
	array set People [LesLignesDuFichier $FichierPeople]
	return [People $Qui $Quoi]
    }
    foreach Ligne [LesLignesDuFichier "/tools/wwwbio3d/People/nomprenom.txt"] {
	scan $Ligne "%s %s" Nom Prenom
	set IN [string range $Nom 0 2]
	set IP [string range $Prenom 0 1]
	set IPN "$IP$IN"
	set PN "$Prenom $Nom"
	set People($PN,) $IPN
	if { ! [info exists People($IPN,)]} {
	    set People($IPN,) $PN
	} else {
	    FaireLire "[set People($IPN,)] et $Ligne"
	    append People($IPN,) " or $PN"
	}
	lappend People(LaListeDes,Initiales) $IPN
	lappend People(LaListeDes,Noms) $Nom
	lappend People(LaListeDes,Prenoms) $Prenom
	lappend People(LaListeDes,NomPrenom) "$Nom $Prenom"
	lappend People(LaListeDes,PrenomNom) "$Prenom $Nom"
    }
    if {[OuiOuNon "Do I save People ?"]} {
	SauveLesLignes [array get People] dans $FichierPeople
    }
    return [People $Qui $Quoi]
}

proc People {{Qui ""} {Quoi ""} {Quoi2 ""}} {
    global People
    if {$Quoi2!=""} { set Qui "${Qui}_$Quoi" ; set Quoi $Quoi2 }

    if {$Qui=="" && $Quoi==""} { set Qui "LaListeDes" ; set Quoi "PrenomNom" } 

    if {[info exists People($Qui,$Quoi)]} { return [set People($Qui,$Quoi)] }
    if {[info exists People("EstCharge")]} { return "" }

    set People("EstCharge") 1

#    set UPNA [HttpGetTextFromUrl "[LbgiUrl]/~ripp/cgi-bin/peopleBio3d.tcsh"]
    set UPNA ""
    if {$UPNA==""} {
	FaireLire "people.tcl ne marche pas. Je lis le fichier directement"
	foreach Ligne [LesLignesDuFichier "/tools/wwwbio3d/People/nomprenom.txt"] {
	    scan $Ligne "%s %s" Nom Prenom
	    set IN [string range $Nom 0 2]
	    set IP [string range $Prenom 0 1]
	    set IPN "$IP$IN"
	    set PN "$Prenom $Nom"
	    set People($PN,) $IPN
	    if { ! [info exists People($IPN,)]} {
		set People($IPN,) $PN
	    } else {
		FaireLire "[set People($IPN,)] et $Ligne"
		append People($IPN,) " or $PN"
	    }
	    lappend People(LaListeDes,Initiales) $IPN
	    lappend People(LaListeDes,Noms) $Nom
	    lappend People(LaListeDes,Prenoms) $Prenom
	    lappend People(LaListeDes,NomPrenom) "$Nom $Prenom"
	    lappend People(LaListeDes,PrenomNom) "$Prenom $Nom"
	}
    }

    foreach Ligne [split $UPNA "\n"] {
	if { ! [regexp {^[^ ]+ [^ ]+ [^ ]+ [^ ]+$} $Ligne]} { continue }
	scan $Ligne "%s %s %s %s" Username Prenom Nom Adresse
	set IN [string range $Nom 0 2]
	set IP [string range $Prenom 0 1]
	set IPN "$IP$IN"
	set PN "$Prenom $Nom"
	set People($PN,) $IPN
	if { ! [info exists People($IPN,)]} {
	    set People($IPN,) $PN
	} else {
	    FaireLire "$IPN [set People($IPN,)] et $Ligne"
	    append People($IPN,) " or $PN"
	}
	set People($Username,Nom)           $Nom
	set People($Username,Prenom)        $Prenom
	set People($Username,PrenomNom)     "$Prenom $Nom"
	set People($Username,NomPrenom)     "$Nom $Prenom"
	set People($Username,Adresse)       $Adresse
	set People(${Prenom}_$Nom,Username) $Username
	set People(${Nom}_$Prenom,Username) $Username
	set People(${Prenom}_$Nom,Adresse)  $Adresse
	set People(${Nom}_$Prenom,Adresse)  $Adresse

	lappend People(LaListeDes,Initiales) $IPN
	lappend People(LaListeDes,Noms)      $Nom
	lappend People(LaListeDes,Prenoms)   $Prenom
	lappend People(LaListeDes,NomPrenom) "$Nom $Prenom"
	lappend People(LaListeDes,PrenomNom) "$Prenom $Nom"
	lappend People(LaListeDes,Adresses)  $Adresse
	lappend People(LaListeDes,Usernames) $Username
    }

    return [People $Qui $Quoi]
}