Index by: file name |
procedure name |
procedure call |
annotation
gscope_xbgs.tcl
(annotations | original source)
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]
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.