Index by: file name |
procedure name |
procedure call |
annotation
gscope_macsims.tcl
(annotations | original source)
#rR gscope_mascims.tcl
proc CreateBlastDatabaseWithTfasDesCopains {{CreateLink ""}} {
file mkdir [RepertoireDuGenome]/banques
set LesTfas {}
foreach Nom [ListeDesPABs] {
set FicTfasCops [GscopeFile $Nom "tfasdescopains"]
foreach Access [LaSequenceDuTFAs $FicTfasCops "LaListeDesAccess"] {
if {[info exists DejaVu($Access)]} { continue }
set DejaVu($Access) 1
set TFA [LaSequenceDuTFAs $FicTfasCops $Access]
set Seq [QueLaSequenceDuTexteTFA $TFA]
if {$Seq==""} {
FaireLire "$Nom $Access"
} else {
lappend LesTfas $TFA
}
}
}
set FicAllTFAs [SauveLesLignes $LesTfas dans "[RepertoireDuGenome]/banques/AllTfasDesCopains"]
NousAllonsAuBoulot "[RepertoireDuGenome]/banques"
set B [file tail $FicAllTFAs]
exec formatdb -i $B -p T
if {[string equal -nocase $CreateLink "CreateLink"]} {
while {[file exists blastpdatabase]} {
if { ! [OuiOnNon "blastpdatabase already exists in\n [pwd]\n Do you remove the link ? \nOtherwize You can do it later" 0]} { break }
}
if { ! [file exists blastpdatabase]} { exec ln -s $B blastpdatabase }
}
OnRevientDuBoulot
return $FicAllTFAs
}
proc TENRR {Seq {Frame ""} {Length ""} {Cardinality ""}} {
#Espionne
if {$Length==""} { set Length 2 }
if {$Cardinality==""} { set Cardinality 1 }
if {$Frame==""} { set Frame 0 }
#set CPost [list AA AC AT CA CT GA GC GG GT TA TT]
#set CPre [list AC AT CC TC TT AG TG AA GC GT TA]
set FicNuc [GscopeFile $Seq nuctfa]
if {[file exists $FicNuc]} { set Seq [QueLaSequenceDuFichierTFA $FicNuc] }
regsub -all {[\-\.]} $Seq "" SeqNoGap
set CPre ""
set CPost ""
foreach Codon [CirCode] {
foreach {a b c} "[split $Codon {}]" {
#Espionne $b-$c
lappend CPre $b$c
lappend CPost $a$b
}
}
#Espionne "Prefix:" $CPre
#Espionne "Postfix:" $CPost
set N [XMotifs $Seq $Frame $Length $Cardinality]
#Espionne $N
#array set XN $N
set XM {}
foreach {NC Positions} $N {
foreach Position $Positions {
foreach DF $Position {
lassign $Position D F
set NewD [expr {$D}]
set M ""
if {[lsearch $CPre [string range $SeqNoGap $D-2 $D-1 ]]>=0} {
set M [string range $SeqNoGap $D-2 $D-1]
#Espionne $M
set NewD [expr {$D-2}]
} else {
if {$D>1} {
set M [string index $SeqNoGap $D-1]
set NewD [expr {$D-1}]
}
}
set NewF [expr {$F+2}]
if {[lsearch $CPost [string range $SeqNoGap $F+3 $F+4 ]]>=0} {
set M [string range $SeqNoGap $F+3 $F+4]
#Espionne $M
set NewF [expr {$F+4}]
} else {
if {$F+3<[string length $SeqNoGap]} {
set M [string index $SeqNoGap $F+3]
set NewF [expr {$F+3}]
}
}
}
set NewN [expr {($NewF-$NewD)+1}]
set B [expr {$D-$NewD}]
set E [expr {$NewF-$F-2}]
#Espionne $NewN $NC
lassign [split $NC ","] N C
set NC $NewN,$C,$B,$E
#Espionne $NewN $NC
lappend NewArr($NC) [list $NewD $NewF]
set R [string range $SeqNoGap $NewD $NewF]
#Espionne $R $B $E
}
}
#parray NewArr
return [array get NewArr]
}
proc RsfProtXFromRsfNucX {Nom} {
}
proc XMotifsFromRsfXX {FileRsf {Cc ""}} {
#rR i took the program from Gopal for the rna 16S etc.
set CC $Cc
Espionne $CC
set NewRsf $FileRsf
regsub {\.rsf$} $NewRsf "" NewRsf
append NewRsf "_R_$CC.rsf"
set N [DecortiqueUnRSF $FileRsf LesNomsDesSequencesDansLOrdre Sequences TabRSF "" "AvecBornesLocales"]
set NbCodons 2
set Cardinality 1
set Res {}
foreach Access $LesNomsDesSequencesDansLOrdre {
set SeqGap $Sequences($Access)
#Espionne $Access
regsub -all {[\-\.]} $SeqGap "" SeqNoGap
set LeNew {}
foreach Frame [list 0 1 2] {
set PositionsMotifs($Frame,$Access) {}
set NXM [TEN $SeqNoGap $CC $Frame $NbCodons $Cardinality]
array set NXMA $NXM
#parray XMA
foreach {NC ListOfCoo} $NXM {
lassign [split $NC ","] N C B E
if {$N<9} {continue}
foreach DF $ListOfCoo {
set Color $N
if {$Color >=9} { set Color 9}
lassign $DF D F
incr D
incr F
set DG [PositionsLocalesVersGlobales $SeqGap $D]
set FG [PositionsLocalesVersGlobales $SeqGap $F]
set AliFrame [expr {($DG+$B-1)%3}]
#set Color $AliFrame
set len [expr {($F-$D)+1}]
lappend LeNew "feature $DG $FG $Color square solid X${Color}Motifs"
lappend LeNew " FT X${Color}Motifs $D $F ${AliFrame}Card${C}_$B-$len-$E"
}
}
}
set FeaturesFor($Access) $LeNew
}
foreach Ligne [LesLignesDuFichier $FileRsf] {
if {[regexp {^name (.+)$} $Ligne Match Access]} {
set CurrentAccess $Access
lappend LeNewRsf $Ligne
continue
}
if {[regexp {^sequence} $Ligne]} {
if {[info exists FeaturesFor($Access)]} { LConcat LeNewRsf $FeaturesFor($Access) }
lappend LeNewRsf $Ligne
continue
}
lappend LeNewRsf $Ligne
}
return [SauveLesLignes $LeNewRsf dans $NewRsf]
}
proc XMotifsFromRsf {FileRsf {NewRsf ""} {NbCodons ""} {Cardinality ""} {ColorType ""}} {
if {$NewRsf==""} {
set NewRsf $FileRsf
regsub {\.rsf$} $NewRsf "" NewRsf
append NewRsf "_WithXMotifsRR.rsf"
}
set N [DecortiqueUnRSF $FileRsf LesNomsDesSequencesDansLOrdre Sequences TabRSF "" "AvecBornesLocales"]
if {$NbCodons ==""} { set NbCodons 2 }
if {$Cardinality==""} { set Cardinality 1 }
if {$NbCodons =="ForceEmpty"} { set NbCodons "" }
if {$Cardinality=="ForceEmpty"} { set Cardinality "" }
set Couleur(0) 5
set Couleur(1) 1
set Couleur(2) 2
foreach Access $LesNomsDesSequencesDansLOrdre {
set SeqGap $Sequences($Access)
regsub -all {[\-\.]} $SeqGap "" SeqNoGap
set LeNew {}
foreach Frame [list 0 1 2] {
set XM [XMotifs $SeqNoGap $Frame $NbCodons $Cardinality]
array set XMA $XM
#parray XMA
foreach {NC ListOfCoo} $XM {
lassign [split $NC ","] N C
foreach DF $ListOfCoo {
if {$ColorType=="Frame"} {
set Color $Couleur($Frame)
} else {
set Color $N
if {$Color >=5} { set Color 5 }
}
lassign $DF D F
incr D
incr F 3
set DG [PositionsLocalesVersGlobales $SeqGap $D]
set FG [PositionsLocalesVersGlobales $SeqGap $F]
if {$ColorType=="Frame"} {
lappend LeNew "feature $DG $FG $Color square solid X${Frame}Motifs"
lappend LeNew " FT X${Frame}Motifs $D $F Card$C"
} else {
lappend LeNew "feature $DG $FG $Color square solid X${Color}Motifs"
lappend LeNew " FT X${Color}Motifs $D $F Card$C"
}
}
}
}
set FeaturesFor($Access) $LeNew
}
foreach Ligne [LesLignesDuFichier $FileRsf] {
if {[regexp {^name (.+)$} $Ligne Match Access]} {
set CurrentAccess $Access
lappend LeNewRsf $Ligne
continue
}
if {[regexp {^sequence} $Ligne]} {
if {[info exists FeaturesFor($Access)]} { LConcat LeNewRsf $FeaturesFor($Access) }
lappend LeNewRsf $Ligne
continue
}
lappend LeNewRsf $Ligne
}
return [SauveLesLignes $LeNewRsf dans $NewRsf]
}
#feature 7 21 0 square solid X0Motifs
# FT X0Motifs 7 21 5
proc CreateMacsimRsfFromMacsimXmlPourTous {{Keep ""}} {
foreach Nom [ListeDesPABs] {
Espionne [CreateMacsimRsfFromMacsimXml $Nom $Keep]
}
return ""
}
proc CreateMacsimRsfFromMacsimXml {Nom {Keep ""}} {
set SedFile "/home/ripp/SedFileToCreateRsfFromXml.sed"
if {[FileAbsent $SedFile]} {
lappend LesSed "s/0 square solid X0Motifs/5 square solid X0Motifs/g"
lappend LesSed "s/0 square solid X1Motifs/1 square solid X1Motifs/g"
lappend LesSed "s/0 square solid X2Motifs/2 square solid X2Motifs/g"
SauveLesLignes $LesSed dans $SedFile
}
set Keep [string equal -nocase $Keep "Keep"]
set FicRsf [GscopeFile $Nom "macsimRsf"]
set FicXml [GscopeFile $Nom "macsimXml"]
if {[FileAbsent $FicXml]} { return "Error. I did not find $FicXml " }
if {$Keep && [FilePresent $FicRsf]} { return $FicRsf }
exec clustalw $FicXml -convert -output=RSF -outfile=$FicRsf
exec sed -i --file=$SedFile $FicRsf
return $FicRsf
}
proc AddConservationToMacsims {{Liste ""} {Destin ""}} {
if {$Destin==""} { set Destin "macsimXmlConservation" }
if {$Liste=={}} { set Liste [ListeDesPABs] }
NousAllonsAuBoulot
set LesCrees {}
foreach Nom $Liste {
Espionne $Nom
set FicOri [GscopeFile $Nom "macsimXml"]
if {[FileAbsent $FicOri]} { continue }
set FicDes [GscopeFile $Nom $Destin]
if {[FileExists $FicDes]} { continue }
if {[FileExists "toto.xml"]} { file delete "toto.xml" }
if {[catch {exec ordali $FicOri -batch -exe ComputeConservation} Message]} {
Espionne "$Nom planté avec message\n$Message"
continue
}
if {[FileAbsent "toto.xml"]} { Espionne "Bouhhhhh pas de toto.xml pour $Nom" ; continue }
file rename -force toto.xml $FicDes
lappend LesCrees $FicDes
}
OnRevientDuBoulot
return $LesCrees
}
proc GroupMacsimsAvecFnote {{In ""} {Ou ""}} {
set I 0
set LeNew {}
foreach Ligne [LesLignesDuFichier $In] {
if {[regexp {<group>} $Ligne]} { set PreviousI $I ; set LigneDuGroup $Ligne}
if {[regexp {<fnote>Group([0-9]+)</fnote>} $Ligne Match G]} {
if { ! [info exists DejaVu($PreviousI)]} {
regsub {<group>[0-9]+</group>} $LigneDuGroup "<group>$G</group>" NewG
set LeNew [lreplace $LeNew $PreviousI $PreviousI $NewG]
set DejaVu($PreviousI) 1
}
}
lappend LeNew $Ligne
incr I
}
return [SauveLesLignes $LeNew dans $Ou]
}
proc MacsimsVariables {{Init ""}} {
#rR Si Init n initialise toutes les listes a vide et les tableau au tableau vide
#rR On rend [list $LesL $LesT]
#rR les strings (AlnScore, etc.) sont traités comme des listes
set Init [regexp -nocase {^(Y|1|Init)} $Init]
set LesL [list AlnName AlnScore AlnNote LNDG LNOrdali]
foreach L $LesL {
global $L
if {$Init} { set $L {} }
}
set LesT [list Sequences TabSF TDesHydro TDesSeqnames TDespI TDesAccess TDesPhylum TDesGO TDuLineage TDesOrganismes TDesTaxId TDesFragment TDuGroupeDesSeqs TDesEC TDesComplex TDesBId TDesDescriptifs TDesMolW TDesStatus TDesWeight TDesSense TDesScore TDesScore TDesLength TColScore LesSeqsDuGroupe SDG LesSequencesAssocieesClassesCanon]
foreach T $LesT {
global $T
if {$Init} { array set $T [list] }
}
return [list $LesL $LesT]
# foreach t {TDesHydro TDesSeqnames TDespI TDesAccess TDesPhylum TDesGO TDuLineage TDesOrganismes TDesTaxId TDesFragment TDuGroupeDesSeqs TDesEC TDesComplex TDesBId TDesDescriptifs TDesMolW} {
# array set $t [list]
# }
# return
}
proc TestDecortiqueUnMacsimXml {{Quoi ""}} {
global Voir_dans_MacsimsVariables
LesDefauts
set FichierOuTexteXML "/genomics/link/CilioCarta2014/macsimXml/CIL006"
set MacsimsVariables [DecortiqueUnMacsimXml $FichierOuTexteXML]
lassign $MacsimsVariables LesL LesT
if {[array exists ::$Quoi]} {
parray ::$Quoi
} else {
EspionneL [set ::$Quoi]
}
foreach T $LesT {
# parray ::$T
}
return $MacsimsVariables
}
proc RunAAM {} {
foreach D [NombresEntre 5001 22000 1000] {
set Deb $D
set Fin [expr $D + 999]
set Fichier "AAM-Cons-$Deb-$Fin.tsv"
Espionne "setgscoperr EHomsa; gscope puts AllAboutMacsimPourTous $Fichier $Deb $Fin >& Run-$Deb-$Fin.log"
exec tcsh -c "setgscoperr EHomsa; gscope puts AllAboutMacsimPourTous $Fichier $Deb $Fin >& Run-$Deb-$Fin.log"
}
exit
}
proc AllAboutMacsimPourTous {Fichier {Debut ""} {Fin ""}} {
#rR Fait pour Kirsley pour avoir des enrigistrements à charger en une table SQL
set LeTout {}
if {[regexp {\,} $Debut ]} {
set Liste [split $Debut ","]
} else {
if {$Debut!=""} { incr Debut -1 }
if {$Debut==""} { set Debut 0 }
if {$Fin==""} { set Fin "end" }
if {[regexp {^[0-9]+$} $Fin]} { incr Fin -1 }
set Liste [lrange [ListeDesPABs] $Debut $Fin]
}
foreach Nom $Liste {
Espionne $Nom
set Un [AllAboutMacsim $Nom OnlyListOf All]
if {$Un==""} { continue }
AppendAuFichier $Fichier $Un
AllAboutMacsim $Nom "Unset"
FromMacsim "UnsetAll"
}
return $Fichier
}
proc AllAboutMacsim {{Nom ""} {Qui ""} {Quoi ""}} {
#rR Fait pour Kirsley pour avoir des enrigistrements à charger en une table SQL
global AAM
if {[info exists AAM($Nom,$Qui,$Quoi)]} { return $AAM($Nom,$Qui,$Quoi) }
if {[info exists AAM($Nom,EstCharge)]} { return "" }
set AAM($Nom,EstCharge) 1
set AccessReference [NIAG $Nom A]
if {$Qui=="Unset"} {
unset AAM
return ""
}
if {$Qui=="" && $Quoi==""} { set Qui "ListOf" ; set Quoi "All" }
set FicTfaCops [GscopeFile $Nom tfasdescopains]
if {[FileExists $FicTfaCops]} {
foreach Ligne [LesLignesDuFichier $FicTfaCops] {
append Ligne " ZZ=bidon"
if { ! [regexp {^>([^ ]+) } $Ligne Match Access]} { continue }
if {[regexp {\|} $Access]} { lassign [split $Access "|"] Banque Access Id }
if {$Access==""} { continue }
if {$Access==$Nom} {
set OX [NotreOX]
set AAM($Nom,$Access,OX) $OX
lappend AAM($Nom,$OX,ListOfAc) $Access
lappend AAM($Nom,ListOf,OX) $OX
continue
}
set OX ""
if { ! [regexp { OX=([0-9]+)} $Ligne Match OX]} {
set OSE ""
if {[regexp { OS=([^=]+)=} $Ligne Match OSE]} {
regsub { [A-Z][A-Z]$} $OSE "" OS
set OX [Tax $OS TaxId]
}
}
if {$OX==""} { continue }
set AAM($Nom,$Access,OX) $OX
lappend AAM($Nom,$OX,ListOfAc) $Access
lappend AAM($Nom,ListOf,OX) $OX
}
set AAM($Nom,ListOf,OX) [lsort -unique -integer $AAM($Nom,ListOf,OX)]
}
set LeTout {}
set LesFT [FromMacsim $Nom ListOfFeatureType]
foreach Access [FromMacsim $Nom ListOfNames] {
set OX 0
if {[info exists AAM($Nom,$Access,OX)]} { set OX $AAM($Nom,$Access,OX) }
foreach FT $LesFT {
set LesFeatures [FromMacsim $Nom $FT $Access]
foreach Feature $LesFeatures {
set LesV {}
foreach {K V} [split $Feature " "] {
lappend LesV $V
}
set Valeurs [join $LesV "\t"]
set Message "$Nom\t$OX\t$AccessReference\t$Access\t$Valeurs"
lappend LeTout $Message
}
}
}
set AAM($Nom,ListOf,All) [join $LeTout "\n"]
#rR Pour ne pas mémoriser bêtement
if { $Qui=="OnlyListOf" && $Quoi=="All" } { set All $AAM($Nom,ListOf,All) ; unset AAM; return $All) }
if { $Qui=="ListOf" && $Quoi=="All" } { return $AAM($Nom,ListOf,All) }
return [AllAboutMacsim $Nom $Qui $Quoi]
}
proc TestFromMacsim {} {
Espionne [FromMacsim CIL007 Sequences G1PUE7_MYOLU]
FromMacsim UnsetAll
Espionne [FromMacsim CIL007 Sequences G1PUE7_MYOLU]
FromMacsim CIL007 unset
Espionne [FromMacsim CIL007 Sequences G1PUE7_MYOLU]
}
proc GlobalFromLocal {Seq Pos} {
set L 0
set G 0
foreach C [split $Seq ""] {
if {$C!="~" && $C!="-" && $C!="."} { incr L }
incr G
if {$L==$Pos} { return $G }
}
return 0
}
proc LocalFromGlobal {Seq Pos} {
set L [string length [string map {"." "" "-" "" "~" ""} [string range $Seq 0 $Pos-1]]]
return $L
}
proc FromMacsim {{Qui ""} {Quoi ""} {Quid ""}} {
#LogWscope "FromMacsim =$Qui=$Quoi=$Quid="
#rR Attention Laetita a elle un FromMacsims avec s
#rR Mis à jour par Raymond 2022/03/14
#rR FromMacsim permet d'interroger n'importe quel macsims au format XML
#rR On utilise DecortiqueUnMacsimXml qui crée pleins de variables globales
#rR La liste des variables globales existantes est accessible par
#rR FromMacsim FichierMacsims ListOfList
#rR FromMacsim FichierMacsims ListOfArray
#rR On indexe tout par le nom du fichier ou par le MD5 du Texte xml s'il est fourni
#rR Quand on interroge un Projet Gscope particulier (par exemple CilioCarta2014) le nom CIL123 suffit
#rR FromMacsim CIL006 ListOfList (rend la liste des listes qu'on peut interroger)
#rR FromMacsim CIL006 AlnName
#rR FromMacsim CIL006 LNOrdali
#rR FromMacsim CIL006 ListOfNames (rend la liste des noms des sequences)
#rR FromMacsim CIL006 ListOfFeatureType
#rR FromMacsim CIL006 Sequences get (rend la liste cle valeur cle valeur ...)
#rR FromMacsim CIL006 Sequences G1NTJ1_MYOLU (rend la sequence) ....... les array sont créés à la première demande puis stockés ;)
#rR FromMacsim CIL006 LocalFromGlobal33 G1NTJ1_MYOLU (rend la position local dans la sequence nogappee)
#rR FromMacsim CIL006 GlobalFromLocal33 G1NTJ1_MYOLU (rend la position global dans l'alignement de la pos local)
#rR FromMacsim CIL006 SeqFromLocal8-12 G1NTJ1_MYOLU (rend la sequence de 8 a 12 dans seq non gappee)
#rR FromMacsim CIL006 SeqFromGlobal20-45 G1NTJ1_MYOLU (rend la sequence entre les pos globales de la seq non gappee)
#rR FromMacsim CIL006 SeqGapFromLocal8-12 G1NTJ1_MYOLU (rend la sequence gappée des pos locales 8 a 12)
#rR FromMacsim CIL006 SeqGapFromGlobal20-45 G1NTJ1_MYOLU (rend la sequence gappée des pos globales 20 à 45)
#rR FromMacsim CIL006 BLOCK G1NTJ1_MYOLU (rend les features BLOCK)
#rR Les couleurs sont valables pour tous les macsims ;)
#rR FromMacsim MacsimsColor (rend la liste cle valeur cle valeur des Colorations utilisées)
#rR FromMacsim MacsimsColor names (rend les cles des Colorations utilisées)
#rR FromMacsim MacsimsColor ConsGlob (rend le couple foreground background pour les Conservation Globales)
#rR FromMacsim MacsimsColor Stock (rend les couleurs utilisées pour les Features)
#rR FromMacsim MacsimsColor 4 (rend la quatrième couleur utilisée pour les Features)
#rR On peut mettre un nom complet de fichier
#rR FromMacsim /ici/ou/la/toto.xml
#rR ou pour tout projet Gscope
#rR FromMacsim ProjetGscope/Prefixe12345 (qui évite de mettre /genomics/link/ProjetGscope/macsimXml/Prefixe12345)
#rR FIN HELP
if {$Qui==""} { set Qui "Help" }
global FromMacsim
global Defauts Couleurs
if { ! [info exists Couleurs] } {
LesDefauts
DefinitionPreferences
set FromMacsim(MacsimsColor) [array get Couleurs]
}
if {$Qui=="MacsimsColor"} {
if {$Quoi=="" || $Quoi=="get"} { return $FromMacsim(MacsimsColor) }
if {$Quoi=="names"} { return [array names Couleurs] }
if {[info exists Couleurs($Quoi)]} { return $Couleurs($Quoi) }
if {[regexp {^[0-9]+$} $Quoi]} { return [lindex $Couleurs(Stock) $Quoi] }
return ""
}
if { ! [info exists FromMacsim(PackageMD5Loaded)]} {
package require md5
set FromMacsim(PackageLoaded) 1
}
if {$Qui=="Help"} {
set LeHelp {}
foreach Ligne [split [info body FromMacsim] "\n"] {
if { ! [regexp " +#rR" $Ligne]} { continue }
lappend LeHelp $Ligne
if {[regexp " +#rR FIN HELP" $Ligne]} { break }
}
return [join $LeHelp "\n"]
}
if {$Qui=="UnsetAll"} {
#array unset FromMacsim
unset FromMacsim
set FromMacsim(PackageLoaded) 1
return ""
}
if {[regexp "\n" $Qui]} {
set MD5 [::md5::md5 -hex $Qui]
} else {
set MD5 $Qui
}
if {$Quoi=="unset"} {
if { ! [info exists FromMacsim($MD5,MD5)]} { return "" }
foreach Arr $FromMacsim($MD5,ListOfMemArr) {
array unset $Arr
}
array unset FromMacsim "$MD5,*"
return ""
}
#Espionne $MD5,$Quoi,$Quid
#rR a mis le prochain test ici le 2017/12/29
if {[info exists FromMacsim($MD5,$Quoi,$Quid)]} {
return $FromMacsim($MD5,$Quoi,$Quid)
}
if {[info exists FromMacsim($MD5,$Quoi)]} {
if {$Quid==""} {
return $FromMacsim($MD5,$Quoi)
} else {
#rR Attention, là on fait un traitement spécial ... on crée les array à la demande et on les mémorise pour plus tard ;)
if {[info exists FromMacsim($MD5,$Quoi,$Quid)]} {
return $FromMacsim($MD5,$Quoi,$Quid)
}
if {$Quid=="get"} { return $FromMacsim($MD5,$Quoi) }
#rR la suite n emarche pas !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
if { 1 && ! [info exists FromMacsim($MD5,Array_$Quoi)]} {
set Arr "Array_[::md5::md5 -hex Array_${Quoi}_$MD5]"
lappend FromMacsim($MD5,ListOfMemArr) $Arr
set FromMacsim($MD5,Array_$Quoi) $Arr
global [set Arr]
#rR 20170112 set ::[set Arr]($Quid) $FromMacsim($MD5,$Quoi) ;#rR a verifier c'est louche !!!!!!!!!!je ne comprends plus !!!!!!!!!!!!!!!!!!!!!!!!
#Espionne "$Quoi=$FromMacsim($MD5,$Quoi)="
array set ::[set Arr] $FromMacsim($MD5,$Quoi) ;#rR il y avait array set ???????!!!!!!!!!!!
}
if {[info exists FromMacsim($MD5,Array_$Quoi)]} {
set Arr $FromMacsim($MD5,Array_$Quoi)
if {$Quid=="names"} { return [array names ::[set Arr]] }
if {[info exists ::[set Arr]($Quid)]} { return [set ::[set Arr]($Quid)] }
return ""
}
#rR ce qui précède ne marche pas !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
}
}
if {[info exists FromMacsim($MD5,$Quoi)]} { return $FromMacsim($MD5,$Quoi) }
if {[info exists FromMacsim($MD5,EstCharge)]} {
if {[regexp {(LocalFromGlobal)([0-9]+)} $Quoi Match What Pos] || [regexp {(GlobalFromLocal)([0-9]+)} $Quoi Match What Pos]} {
if {[set Seq [FromMacsim $MD5 Sequences $Quid]]!=""} {
if {$What=="GlobalFromLocal"} { return [GlobalFromLocal $Seq $Pos] }
if {$What=="LocalFromGlobal"} { return [LocalFromGlobal $Seq $Pos] }
}
}
set Gap ""
if {[regexp {(Seq(Gap)?FromGlobal)([0-9]+)\-([0-9]+)$} $Quoi Match What Gap Deb Fin] || [regexp {(Seq(Gap)?FromLocal)([0-9]+)\-([0-9]+)$} $Quoi Match What Gap Deb Fin]} {
#Espionne $What $Gap $Deb $Fin
if {[set Seq [FromMacsim $MD5 Sequences $Quid]]!=""} {
regsub -all -nocase {[^a-z]} $Seq "" SeqNoGap
if {$Gap==""} { }
if {$What=="SeqGapFromGlobal"} {
return [string range "x$Seq" $Deb $Fin]
}
if {$What=="SeqFromGlobal"} {
set SeqVoulue [string range "x$Seq" $Deb $Fin]
regsub -all -nocase {[^a-z]} $SeqVoulue "" SeqVoulueNoGap
return $SeqVoulueNoGap
}
if {$What=="SeqFromLocal"} {
return [string range "x$SeqNoGap" $Deb $Fin]
}
if {$What=="SeqGapFromLocal"} {
if {$Fin>[string length $SeqNoGap]} { set Fin [string length $SeqNoGap] }
set D [GlobalFromLocal $Seq $Deb]
set F [GlobalFromLocal $Seq $Fin]
#Espionne $Seq
#Espionne $SeqNoGap
#Espionne 12345678901234567890
#Espionne $Deb $Fin
return [string range "x$Seq" $D $F]
}
}
}
return ""
}
if {[regexp "\n" $Qui]} {
set Xml $Qui
} else {
set Xml ""
if {[FileExists $Qui]} {
set Xml [ContenuDuFichier $Qui]
} elseif {[FileAbsent $Qui] && [file exists [GscopeFile $Qui "macsimXml"]]} {
set Qui [GscopeFile $Qui "macsimXml"]
set Xml [ContenuDuFichier $Qui]
} elseif {[FileExists "[RepertoireDuGenome]/$Qui"]} {
set Xml [ContenuDuFichier "[RepertoireDuGenome]/$Qui"]
} elseif {[regexp -nocase {^([^/]+)/(.+)$} $Qui Match Rep Pab]} {
if {[FileExists "/genomics/link/$Rep/macsimXml/$Pab"]} {
set Xml [ContenuDuFichier "/genomics/link/$Rep/macsimXml/$Pab"]
}
}
if {$Xml==""} { return "" }
}
set FromMacsim($MD5,MD5) $MD5
set FromMacsim($MD5,EstCharge) 1
if {[info exists ::TabSF]} { unset ::TabSF } ;#rR Fait le 2017/04/07
set MacsimsVariables [DecortiqueUnMacsimXml $Xml]
lassign $MacsimsVariables LesL LesT
foreach L $LesL {
set FromMacsim($MD5,$L) [set ::$L]
}
foreach T $LesT {
set FromMacsim($MD5,$T) [array get ::$T]
}
foreach {K V} [array get ::TDesAccess] {
set FromMacsim($MD5,TDesAccess,$K) $V
}
set FromMacsim($MD5,ListOfList) $LesL
set FromMacsim($MD5,ListOfArray) $LesT
set LesFeatureType {}
foreach {K V} [array get ::TabSF] {
if {0 && $K=="Amito_Homo.sapi"} { Espionne "$K\n$V" }
foreach Feature $V {
if {[regexp { target [^ ]+ } $Feature]} {
regsub { target [^ ]+ } $Feature " " Feature
}
set LesMots [split $Feature " "]
lassign $LesMots coord LG ftype FT fstart FStart fstop Fstop fcolor FColor fscore FScore fnote
set FNote [join [lrange $V 15 end] " "]
lappend LesFeatureType $FT
#lappend FromMacsim($MD5,$FT) $Feature
lappend FromMacsim($MD5,$FT,$K) $Feature
#Espionne $MD5 $FT $K $Feature
}
}
set FromMacsim($MD5,ListOfFeatureType) [lsort -unique $LesFeatureType]
set FromMacsim($MD5,ListOfNames) $::LNOrdali
lappend FromMacsim($MD5,ListOfList) ListOfFeatureType ListOfNames
# attention on triche un peu là
if {$Quoi=="MacsimsColor"} { return [FromMacsim $Quoi $Quid] }
return [FromMacsim $MD5 $Quoi $Quid]
}
proc DecortiqueUnMacsimXml {FichierOuTexteXML} {
# Repompe de DecortiqueUnMacsimXml2 qui est lui-même
# Repompe de rR pour parsing de xml
# fait tout d'un coup, plus de routines separées pour chaque chose
# Initialisation des strings, listes et tableaux. Et mise en global
set MacsimsVariables [MacsimsVariables "Initialise"]
lassign $MacsimsVariables LesL LesT
foreach L $LesL { global $L }
foreach T $LesT { global $T }
if {[file exists $FichierOuTexteXML]} {
set MacsimXml [ContenuDuFichier $FichierOuTexteXML]
set FromOrdalie 1
} else {
set MacsimXml $FichierOuTexteXML
set FromOrdalie 0
}
foreach e {eukaryota bacteria archaea viruses undefined} {
set LesSequencesAssocieesClassesCanon($e) {}
}
# Caution !! MacsimXml is not a list, but a text string !!
set DocMacsim [dom parse $MacsimXml]
set NoeudMacsim [$DocMacsim documentElement]
unset -nocomplain LesSeqsDuGroupe
# alignment header
set NoeudAli [$NoeudMacsim selectNodes "alignment"]
set AlnName [$NoeudAli selectNodes "string(aln-name)"]
set AlnScore [$NoeudAli selectNodes "string(aln-score)"]
set AlnNote [$NoeudAli selectNodes "string(aln-note)"]
set TColScore(Names) [list]
foreach NoeudLigne [$NoeudAli childNodes] {
set NodeName [$NoeudLigne nodeName]
if {[regexp {aln\-} $NodeName]} {
continue
}
if {[regexp {column\-} $NodeName]} {
DecortiqueColumnScore $NoeudLigne
} else {
DecortiqueNoeudXml $NoeudLigne TabSF
}
}
# Verifie qu'on n'a pas sequences en double !
set Ltmp $LNOrdali
set LNOrdali [list]
foreach n $Ltmp {
if {[string trim $n] eq ""} {continue}
lappend LNOrdali $n
}
if {[llength $LNOrdali] != [llength [lsort -unique $LNOrdali]]} {
set ld [DonneDoublons $LNOrdali]
FaireLire "Beware !\nSeveral sequences have the same name :[join $ld]"
}
# XML est indexe par le seq-name.
# Ramene tous les tableaux a une indexation par
# accession.
#IndexationParAccess
# premier grp = GroupeToutLeMonde
InitPremierGroupe
# Ajoute groupes du xml
set Lg [ReordonneGroupes [array names LesSeqsDuGroupe]]
if {[llength $Lg] > 1} {
set LNDG [concat $LNDG $Lg]
foreach g $Lg {
set LesSeqsDuGroupe($g) [lunique [set LesSeqsDuGroupe($g)]]
set SDG($g) [set LesSeqsDuGroupe($g)]
}
}
$DocMacsim delete
return $MacsimsVariables
}
proc ElimineLesMacsimsIncomplets {} {
set Rep [RepertoireDuGenome]
set I 0
set N 0
foreach Nom [ListeDesPABs] {
if {([incr I]%100)==0} { Espionne "au $I eme il y a deja $N problemes" }
if {0 && $Nom > "HSAP99999"} { break }
set FLL "leonLog/$Nom"
if {[FileAbsent $Rep/$FLL]} { continue }
set FLM "msfLeon/$Nom"
set FLX "msfLeon/$Nom.xml"
set FMX "macsimXml/$Nom"
set FMR "macsimRsf/$Nom"
# set NR [llength [glob -nocomplain "$Rep/$FMR*"]]
if {[file exists $Rep/$FLM] && [file exists $Rep/$FLX] && [file exists $Rep/$FMX] \
&& [file exists $Rep/$FMR] && [file exists $Rep/$FMR.tfa] \
&& [file exists $Rep/$FMR.txt] && [file exists $Rep/$FMR.html] \
&& ! [file exists $Rep/$FMR.log]} { continue }
incr N
lappend LeBilan "$Nom [file exists $Rep/$FLM] [file exists $Rep/$FLX] [file exists $Rep/$FMX] [file exists $Rep/$FMR] [file exists $Rep/$FMR.tfa] [file exists $Rep/$FMR.txt] [file exists $Rep/$FMR.html] [file exists $Rep/$FMR.log]"
}
set R [AfficheListe $LeBilan "AvecRetour"]
foreach Ligne $R {
scan $Ligne "%s" Nom
foreach D [list msfLeon macsimXml macsimRsf leonLog] {
foreach F [glob -nocomplain "$Rep/$D/$Nom*"] {
if {[OuiOuNonMemo "Ok to delete all wrong files in macsimXml macsimRsf leonLog msfLeon"]} {
file delete $F
Espionne "file delete $F"
} else {
Espionne "file to delete $F"
}
}
}
}
return $R
}
proc TailleDesTFAsDesCopains {} {
foreach Nom [ListeDesPABs] {
set FiTFAs [GscopeFile $Nom "tfasdescopains"]
if {[FileAbsent $FiTFAs]} { incr C(-1) ; lappend T(-1) $Nom; continue }
set TFAs [ContenuDuFichier $FiTFAs]
set N [regexp -all ">" $TFAs]
if { 0 <= $N && $N < 1 } { incr C(0) ; lappend T(0) $Nom; continue }
if { 1 <= $N && $N < 2 } { incr C(1) ; lappend T(1) $Nom; continue }
if { 2 <= $N && $N < 3 } { incr C(2) ; lappend T(2) $Nom; continue }
if { 3 <= $N && $N < 10 } { incr C(7) ; lappend T(7) $Nom; continue }
set D 0
set I 10
while {$D < 500} {
incr D $I ; set F $D ; incr F $I ; set M [expr ($D+$F)/2]
if { $D <= $N && $N < $F } { incr C($M) ; lappend T($M) $Nom; break }
}
}
foreach N [lsort -integer [array names C]] {
if {$C($N) > 10 } {
lappend LeResultat "$N $C($N)"
} else {
lappend LeResultat "$N $C($N) $T($N)"
}
}
AfficheListe $LeResultat
}
proc ClickDansSeq {K X Y} {
set Id [$K find withtag current]
set LesTags [$K gettags $Id]
if {[llength $LesTags]>2} { FaireLire [join $LesTags "\n"] ; return }
set NomSeq [lindex $LesTags 1]
AfficheFetch $NomSeq
}
proc EntreDansSeq {K X Y} {
global TitreOrigine
set Id [$K find withtag current]
set NomSeq [lindex [$K gettags $Id] 1]
if {! [info exists TitreOrigine($K)] } {
set TitreOrigine($K) [wm title [winfo toplevel $K]]
}
wm title [winfo toplevel $K] "$NomSeq [$K canvasx $X]"
}
proc SortDeSeq {K X Y} {
global TitreOrigine
wm title [winfo toplevel $K] [set TitreOrigine($K)]
}
proc CouleurDeLaLettre {Lettre {PourQui ""}} {
global CouleurDuFond
if {[regexp "HNR" [RepertoireDuGenome]]} {
if { $Lettre == " " } { return "white" }
if { $Lettre == "." } { return "white" }
if { $PourQui == "PourExpo" } { return "grey" }
} else {
if { $Lettre == " " } { return $CouleurDuFond }
if { $Lettre == "." } { return "grey" }
if { $PourQui == "PourExpo" } { return "red" }
}
if {[regexp -nocase {[PAGST]} $Lettre]} { return "yellow"}
if {[regexp -nocase {[DEQN]} $Lettre]} { return "green"}
if {[regexp -nocase {[KRH]} $Lettre]} { return "blue"}
if {[regexp -nocase {[ILMV]} $Lettre]} { return "red"}
if {[regexp -nocase {[FYW]} $Lettre]} { return "pink"}
if {[regexp -nocase {[CX]} $Lettre]} { return "black"}
Warne "$Lettre non colore"
return "purple"
}
proc DessineMoiLesMSF Selection {
global GalerieCourante
global ExpoCourante
global Memo
set ExpoCourante [NomDe expo]
set GalerieCourante $ExpoCourante[NomDe galerie]
CreeGalerie $GalerieCourante
foreach FichierMSF [split $Selection " ,\n"] {
set w [CreeImagette]
DessineMoiUnMSF $FichierMSF $FichierMSF "" $w
Espionne "[LargeurDe $w] [HauteurDe $w]"
Expose $w
}
}
proc DessineMoiUnMSF {TexteOuFichierMSF {NomDuFichierOrigine ""} {OnlyPDB "All"} {FenetreParent "NormalWindow"}} {
global CouleurDuFond
global DessinCourant
global ScrollRectangleOriginal IdScrollRectangle
global Memo
global LesOrdresPourGif
# if { ! [info exists CouleurDuFond]} { set CouleurDuFond "cadetblue" }
if { ! [info exists CouleurDuFond]} { set CouleurDuFond "white" }
if {[regexp "\n" $TexteOuFichierMSF]} {
set MSF $TexteOuFichierMSF
} else {
if { ! [file exists $TexteOuFichierMSF]} { return "" }
set MSF [ContenuDuFichier $TexteOuFichierMSF]
if {$NomDuFichierOrigine==""} { set NomDuFichierOrigine $TexteOuFichierMSF }
}
set AvecTexte 0
if {$OnlyPDB=="Ask"} {
set OnlyPDB [ChoixParmi {"OnlyPDB" "All"}]
}
set OnlyPDB [string equal -nocase $OnlyPDB "OnlyPDB"]
set PourGif ""
if {$FenetreParent=="PourGif"} {
set PourGif "PourGif"
} else {
if {$FenetreParent=="NormalWindow"} {
set w [NomDe "fenetre"]
} else {
set w $FenetreParent
}
}
set Nom [file tail $NomDuFichierOrigine]
DecortiqueUnMSF $MSF LesSequencesDansLOrdre Sequences
set LesBonnesSequencesDansLOrdre {}
foreach NomSeq $LesSequencesDansLOrdre {
if { $OnlyPDB && ! [EstUnPAB $NomSeq] && ! [EstUnAccessPDB $NomSeq] } { continue }
lappend LesBonnesSequencesDansLOrdre $NomSeq
}
if {[llength $LesBonnesSequencesDansLOrdre]<2} {
FaireLire "Only one sequence, no alignment to display."
return ""
}
set LesSequencesDansLOrdre $LesBonnesSequencesDansLOrdre
set NombreDeSequences [llength $LesSequencesDansLOrdre]
set MaxLongueurSequence 0
foreach NomSeq $LesSequencesDansLOrdre {
set MaxLongueurSequence [Maxi $MaxLongueurSequence [string length [set Sequences($NomSeq)]]]
}
set Titre $NomDuFichierOrigine
if {$PourGif != ""} {
set PourGif 1
set Canvas NeRienFaire
set Bind NeRienFaire
set Pack NeRienFaire
set Fram NeRienFaire
set Button NeRienFaire
set Scrollbar NeRienFaire
set Grid NeRienFaire
set Winfo NeRienFaire
set FonctionRejetteLaBoite "RejetteLaBoite"
set LesOrdresPourGif {}
set w "PourGif"
set K "OrdrePourGif"
} else {
set PourGif 0
set Canvas canvas
set Bind bind
set Pack pack
set Fram frame
set Button button
set Scrollbar scrollbar
set Grid grid
set Winfo winfo
set FonctionRejetteLaBoite "NeRejettePasLaBoite"
# set w [NomDe board]
# catch {destroy $w}
# toplevel $w
# wm title $w "$Titre"
# wm iconname $w "$Titre"
set K $w.canvas
}
set LargeurDUneLettre 1
set xDebut 0
set xFin [expr $MaxLongueurSequence*$LargeurDUneLettre]
# incr xDebut -50
# incr xFin 50
set CanvaSizeX [expr $xFin - $xDebut]
set CanvaScroMinX [expr $xDebut]
set CanvaScroMaxX [expr $xFin ]
set CanvaScreenX $CanvaSizeX
set HauteurDUneLettre [expr $LargeurDUneLettre*2]
set yDebut 0
set yFin [expr $NombreDeSequences*$HauteurDUneLettre]
set CanvaSizeY [expr $yFin - $yDebut]
set CanvaScroMinY [expr $yDebut]
set CanvaScroMaxY [expr $yFin ]
set CanvaScreenY [expr $CanvaSizeY]
#rR ça devait exister pour expo, je l'aivasi commenté mais je préfère l'enlever quand même (2017/11/24)
if {1} {
if { [regexp "expo" $w] } {
set NormalCanvaScreenX $CanvaScreenX
set CanvaScreenX 300
set CanvaScreenY [expr round($CanvaSizeY*(1.0*$CanvaScreenX)/$CanvaSizeX)]
set Papa $w
} else {
set KShSv $w.grid
$Fram $w
$Fram $KShSv
set Papa $KShSv
}
}
set K [UnCanva $CanvaScreenX $CanvaScreenY $CanvaScreenX $CanvaScreenY]
set i -1
foreach NomSeq $LesSequencesDansLOrdre {
incr i
set Seq [set Sequences($NomSeq)]
set lSeq [expr [string length $Seq]-1]
for {set j $lSeq} {$j>=0} {incr j -1} {
if {[string index $Seq $j] != "."} { set lSeq $j ; break }
}
incr lSeq
set SeqBlanc [string range $Seq 0 $lSeq]
for {set j $lSeq} {$j < $MaxLongueurSequence} {incr j} {
append SeqBlanc " "
}
set PosMinY [expr $i*$HauteurDUneLettre]
set PosMaxY [expr $PosMinY+$HauteurDUneLettre]
set PointEstBlanc 1
if {[info exists OldCouleur]} { unset OldCouleur }
set PosMinX 0
set PosMaxX 0
for {set j 0} {$j < $MaxLongueurSequence} {incr j} {
set Lettre [string index $SeqBlanc $j]
if { $Lettre != "." } { set PointEstBlanc 0 }
if { $PointEstBlanc && $Lettre == "." } { set Lettre " " }
if {1 || [regexp "expo" $w]} {
set Couleur [CouleurDeLaLettre $Lettre PourExpo]
if {($NomSeq=="QUERY_PROTEIN" || [EstUnPAB $NomSeq]) \
&& $Lettre != "." && $Lettre != " " } {
set Couleur "black"
}
if {[info exists OldCouleur] && ($Couleur!=$OldCouleur || [expr $j==$MaxLongueurSequence-1])} {
$K create rect $PosMinX $PosMinY $PosMaxX $PosMaxY \
-tags [list "Lettre"] \
-outline $OldCouleur \
-fill $OldCouleur
set PosMinX $PosMaxX
}
set OldCouleur $Couleur
incr PosMaxX $LargeurDUneLettre
continue
} else {
set PosMinX [expr $j*$LargeurDUneLettre]
set PosMaxX [expr $PosMinX+$LargeurDUneLettre]
set Couleur [CouleurDeLaLettre $Lettre]
$K create rect $PosMinX $PosMinY $PosMaxX $PosMaxY \
-tags [list "Lettre"] \
-outline $Couleur \
-fill $Couleur
if { $AvecTexte} {
set TxtCenX 0
set TxtCenY 0
set PosTxtX [expr ($PosMinX+$PosMaxX)/2 + $TxtCenX]
set PosTxtY [expr ($PosMinY+$PosMaxY)/2 + $TxtCenY]
if {[YaPABdans $NomSeq]} {
set CouleurTxt "black"
set FonteTxt {Courier 11}
} else {
set CouleurTxt "black"
set FonteTxt {Courier 10}
}
$K create text $PosTxtX $PosTxtY\
-tags [list "Texte" "$NomSeq"] \
-text $Lettre \
-anchor c \
-fill $CouleurTxt \
-font $FonteTxt
}
}
}
if {$PourGif} {
set LesTags [list "WebClic" "tembl:$NomSeq"]
set Couleur $CouleurDuFond
} else {
set LesTags [list "Seq" "$NomSeq"]
set Couleur ""
}
$K create rect $CanvaScroMinX $PosMinY $CanvaScroMaxX $PosMaxY \
-tags $LesTags \
-outline $Couleur \
-fill $Couleur
}
if {$PourGif} { return $LesOrdresPourGif }
if {1} {
set Clavier "[$Winfo parent $K].buttons"
TouchePour $Clavier NouvelleGamme
TouchePour $Clavier NouvelleCouleur "lightgrey"
TouchePour $Clavier "Description" "AfficheLesDescriptifs $NomDuFichierOrigine MemeOrdre"
TouchePour <2> "/all" "AfficheLesDescriptifs $Nom Natif"
TouchePour $Clavier "Taxonomy" "DessineMoiLaTaxonomy $NomDuFichierOrigine $NomDuFichierOrigine {} {} $HauteurDUneLettre same"
TouchePour <2> "/all" "AfficheLesDescriptifs $Nom Natif {} {} {OX OC} $Nom"
TouchePour <3> "/page" "AfficheLesDescriptifs $NomDuFichierOrigine MemeOrdre {} {} {OX OC} $Nom"
}
if { [regexp "expo" $w]} {
$K bind all <1> "DessineMoiUnMSF $MSF $NomDuFichierOrigine $OnlyPDB NormalWindow"
$K scale all 0 0 [expr (1.0*$CanvaScreenX)/$NormalCanvaScreenX] [expr (1.0*$CanvaScreenX)/$NormalCanvaScreenX]
set Memo(LargeurDe$w) [expr $CanvaScreenX+20]
set Memo(HauteurDe$w) [expr $CanvaScreenY+20]
} else {
$K bind "Seq" <1> "ClickDansSeq $K %x %y"
$K bind "Seq" <Enter> "EntreDansSeq $K %x %y"
$K bind "Seq" <Leave> "SortDeSeq $K %x %y"
set DessinCourant $K
}
if {$PourGif} { return $LesOrdresPourGif }
return $w
}
proc TestDecortiqueUnRSF {} {
set n [DecortiqueUnRSF "/genomics/link/CilioCarta2014/macsimRsf/CIL006" LesName Sequences TabRSF "" "AvecBornesLocales"]
foreach Name $LesName {
Espionne "name $Name [set TabRSF($Name,group)]"
set LesTypes [set TabRSF($Name,LesTypesDeFeatures)]
foreach Type $LesTypes {
Espionne "\nPour $Name : Type $Type"
EspionneL [set TabRSF($Name,Type,$Type)]
}
}
Espionne $TabRSF($Name,LesClefs)
exit
}
proc CouleurSeqlab X {
global CouleurSeqlab
global CouleurSeqlabLower
if { ! [info exists CouleurSeqlab]} {
set CouleurSeqlab [list ForestGreen Orange Magenta Red \
SkyBlue LimeGreen Blue Purple Black \
Grey30 Grey50 Grey65 Grey80 Grey90 Grey95 White Pink \
orangeRed LightBlue yellow green tomato cyan brown lightGreen fireBrick darkOrange \
goldenRod seagreen coral \
violet khaki navyblue salmon sienna turquoise darkgreen maroon springgreen \
mediumblue indianred dimgray light gray gray]
set LesCouples {}
set I 0
foreach Couleur $CouleurSeqlab {
incr I
lappend CouleurSeqlabLower [string tolower $Couleur]
lappend LesCouples "$I $Couleur"
}
}
if {$X=="LaListeDesCouplesMerci"} { return $LesCouples }
if {$X=="LaListeMerci"} { return $CouleurSeqlab }
if {[regexp -nocase {[A-Z]} $X]} {
set X [string tolower $X]
return [lsearch $CouleurSeqlabLower $X]
} else {
set Couleur [lindex $CouleurSeqlab $X]
if {$Couleur=="" } { set Couleur "Red" }
return $Couleur
}
}
proc FeatureSequence Seq {
#rR on cree une list BeforeSeq 1 3, Seq_1 4 8, Gap_1 8 12, Seq_2 13 20, AfterSeq 20 30
set DansEntame 1
set DansQueue 0
set FinEntame 0
set LesFeatures {}
set I 0
set L 0
set DebCourant 1
set DebLocal 0
set FinLocal 0
foreach AA [split $Seq ""] {
incr I
set IsSeq [regexp -nocase {[a-z]} $AA]
if {$IsSeq} { incr L ; incr FinLocal }
if { ! [info exists WasSeq]} { set WasSeq [expr ! $IsSeq] }
if { $IsSeq==$WasSeq } { incr FinCourant ; set WasSeq $IsSeq; continue }
if {[info exists FinCourant]} { lappend LesFeatures "$WasSeq $DebCourant $FinCourant $DebLocal $FinLocal" }
set DebCourant $I
set FinCourant $I
set DebLocal $L
set FinLocal $L
set WasSeq $IsSeq
}
if { ! [info exists WasSeq]} { return {} }
lappend LesFeatures "$WasSeq $DebCourant $FinCourant $DebLocal $FinLocal"
set LesFeatureSequence {}
set NS 0
set NG -1
set Last [llength $LesFeatures]
set I 0
set L 0
foreach F $LesFeatures {
incr I
scan $F "%d %d %d %d %d" T D F DL FL
if {$T==1} { incr NS ; incr L; lappend LaFeatureSequence "Seq_$NS $D $F $DL $FL" ; continue }
if {$NS==0} {
if {$NG==-1} { lappend LaFeatureSequence "BeforeSeq $D $F $DL $FL" ; set NG 0; continue }
} else {
incr NG
if {$I==$Last} {
lappend LaFeatureSequence "AfterSeq $D $F $DL $FL"
} else {
lappend LaFeatureSequence "Gap_$NG $D $F $DL $FL"
}
}
}
return $LaFeatureSequence
}
proc DuRSF {TexteOuFichierRSF Quoi} {
set N [DecortiqueUnRSF $TexteOuFichierRSF LesNomsDesSequencesDansLOrdre Sequences TabRSF "" "AvecBornesLocales"]
set TabRSF(N) $N
if {[info exists TabRSF($Quoi)]} { return $TabRSF($Quoi) }
return "NExistePas"
}
proc RsfFromRsf {TexteOuFichierRSF {LesAccess ""} {KeepOrReject ""}} {
if {$KeepOrReject==""} { set KeepOrReject "Keep" }
set Keep [string equal -nocase "Keep" $KeepOrReject]
if {[regexp {[ \t\n\,\;]} $LesAccess]} {
regsub -all {[ \t\n\,\;]+} $LesAccess " " LesAccess
set LesAccess [split [string trim $LesAccess]]
}
set LesACCESS {}
foreach Access $LesAccess {
lappend LesACCESS [string toupper $Access]
}
if {[regexp "\n" $TexteOuFichierRSF]} {
set LesLignes [split $TexteOuFichierRSF "\n"]
set FichierRSF "RSF"
} else {
set FichierRSF $TexteOuFichierRSF
set LesLignes [LesLignesDuFichier $FichierRSF]
}
if {[llength $LesLignes] < 2} { return "" }
set OnAttend 1
set LeCourant {}
foreach Ligne $LesLignes {
if {$OnAttend && [string index $Ligne 0]!="\{"} { continue }
set OnAttend 0
lappend LeCourant $Ligne
if {[regexp {^name (.+)$} $Ligne Match Access]} {
set ACCESS [string toupper $Access]
if {[info exists DejaVu($ACCESS)]} { FaireLire "DejaVu $Access !!!\nTant pis, le dernier sera le bon" }
set DejaVu($ACCESS) $Ligne
continue
}
if {[string index $Ligne 0]=="\}"} {
lappend LesAccessExistants $ACCESS
set LesLignesDe($ACCESS) $LeCourant
set LeCourant {}
}
}
set LeNew ""
lappend LeNew "!!RICH_SEQUENCE 1.0"
lappend LeNew ".."
if {$Keep} {
set LesAccessAGarder $LesACCESS
} else {
set LesAccessAGarder [ListsComplement $LesAccessExistants $LesACCESS]
}
foreach Access $LesAccessAGarder {
set ACCESS [string toupper $Access]
if { ! [info exists LesLignesDe($ACCESS)]} { continue }
LConcat LeNew $LesLignesDe($ACCESS)
}
return [join $LeNew "\n"]
}
proc DecortiqueUnRSF {TexteOuFichierRSF \
{aLesNomsDesSequencesDansLOrdre ""} {aSequences ""} \
{aTabRSF ""} {LesClefs ""} {AvecBornesLocales ""}} {
if {$aLesNomsDesSequencesDansLOrdre!=""} { upvar $aLesNomsDesSequencesDansLOrdre LesNomsDesSequencesDansLOrdre }
if {$aSequences !=""} { upvar $aSequences Sequences }
if {$aTabRSF !=""} { upvar $aTabRSF TabRSF }
#rR J'ai changé le défaut 2015/03/31
if {$AvecBornesLocales!=0} { set AvecBornesLocales 1 } else { set AvecBornesLocales 0 }
set LesNomsDesSequencesDansLOrdre {}
if {[regexp "\n" $TexteOuFichierRSF]} {
set LesLignes [split $TexteOuFichierRSF "\n"]
set FichierRSF "RSF"
} else {
set FichierRSF $TexteOuFichierRSF
set LesLignes [LesLignesDuFichier $FichierRSF]
}
if {[llength $LesLignes] < 2} { return 0 }
if {$LesClefs==""} { set LesClefs [list "name" "sequence" "type" "group" "feature" "descrip" "creator"] }
set ClefAvecListe(feature) 1
foreach Clef $LesClefs {
set ClefVoulue($Clef) 1
}
foreach Ligne $LesLignes {
if {[regexp {^!!RICH_SEQUENCE} $Ligne]} { continue }
if {[regexp {^(\{|\}|\.\.)} $Ligne]} { continue }
if { ! [regexp -nocase {[\.a-z0-9]} $Ligne]} { continue }
if {[regexp -nocase {^[a-z]} $Ligne]} {
scan $Ligne "%s" Clef
set Clef [string tolower $Clef]
set Valeur [StringSuivant "$Clef " dans $Ligne]
if {$Clef=="name"} {
#lm ajoute BonAccess et le string trim
set NameCourant [BonAccess [string trim $Valeur]]
lappend LesName $NameCourant
set NumeroDeClef 0
}
if { ! [info exists ClefVoulue($Clef)]} { continue }
if { ! [info exists ClefDejaVue($NameCourant,$Clef)]} {
set TabRSF($NameCourant,ListeDes,$Clef) {}
}
if {[info exists ClefAvecListe($Clef)]} {
incr NumeroDeClef
set ClefCourante "${Clef}_$NumeroDeClef"
} else {
set ClefCourante $Clef
}
lappend TabRSF($NameCourant,ListeDes,$Clef) $ClefCourante
set ClefDejaVue($NameCourant,$Clef) 1
set TabRSF($NameCourant,$ClefCourante) {}
regsub $Clef $Ligne "" Ligne
}
if { ! [info exists ClefVoulue($Clef)]} { continue }
set Valeur [string trim $Ligne]
if {$ClefCourante=="sequence"} {
set Valeur [string trim $Valeur]
if { ! [info exist TabRSF($NameCourant,$ClefCourante)]} { set TabRSF($NameCourant,$ClefCourante) "" }
append TabRSF($NameCourant,$ClefCourante) $Valeur
} else {
lappend TabRSF($NameCourant,$ClefCourante) $Valeur
}
continue
}
set TabRSF(LesTypesDeFeatures) {}
foreach Name $LesName {
set Seq [join $TabRSF($Name,sequence) ""]
set Seq [BonneSequencePourAlignement $Seq] ;#rR sur demande de Luc 2012/12/18
set Sequences($Name) $Seq
set TabRSF($Name,LesTypesDeFeatures) {}
if { ! [info exists TabRSF($Name,ListeDes,feature)]} {
set TabRSF($Name,ListeDes,feature) {}
}
set FeatureSequence [FeatureSequence $Seq]
foreach TDF $FeatureSequence {
scan $TDF "%s %d %d %d %d" T D F DL FL
if { ! [regexp "^Seq" $T]} { continue } ;#rR on n'affiche que la sequence et pas les gaps !!!!!!!
set LastFeature [lindex $TabRSF($Name,ListeDes,feature) end]
if {$LastFeature==""} {
set Feature "feature_1"
} else {
set NLast 0
regexp {feature_([0-9]+)} $LastFeature Match NLast
incr NLast
set Feature "feature_$NLast"
}
lappend TabRSF($Name,ListeDes,feature) $Feature
if {[regexp "^Before" $T]} { set C [CouleurSeqlab White] }
if {[regexp "^After" $T]} { set C [CouleurSeqlab White] }
if {[regexp "^Seq" $T]} { set C [CouleurSeqlab Grey80] } ;#rR il y avait 50
if {[regexp "^Gap" $T]} { set C [CouleurSeqlab Grey90] } ;#rR il y avait 80
set TabRSF($Name,$Feature) [list "$D $F $C square solid SEQUENCE" "FT SEQUENCE $DL $FL $T"]
}
foreach Feature [set TabRSF($Name,ListeDes,feature)] {
set DonneesDuFeature [lindex [set TabRSF($Name,$Feature)] 0]
scan $DonneesDuFeature "%d %d %d %s %s %s" D F C Forme EmptyFull FeatureType
set Couleur [CouleurSeqlab $C]
if { ! [info exists DejaVuCeTypeDeFeature($FeatureType)]} {
set DejaVuCeTypeDeFeature($FeatureType) 1
lappend TabRSF(LesTypesDeFeatures) $FeatureType
}
set SequencePointee [set Sequences($Name)]
if {$AvecBornesLocales} {
set BornesLocales [BornesLocales $SequencePointee $D $F]
} else {
set BornesLocales "$D $F"
}
scan $BornesLocales "%d %d" DL FL
if { ! [info exists TabRSF($Name,Type,$FeatureType)]} {
set TabRSF($Name,Type,$FeatureType) {}
lappend TabRSF($Name,LesTypesDeFeatures) $FeatureType
}
lappend TabRSF($Name,Type,$FeatureType) "$D $F $DL $FL $Couleur $Forme $EmptyFull \
[lrange [set TabRSF($Name,$Feature)] 1 end]"
}
}
set LesNomsDesSequencesDansLOrdre $LesName
set TabRSF(LesNomsDesSequences) $LesNomsDesSequencesDansLOrdre
return [llength $LesName]
}
proc CanvaVirtuel {args} {
#rR utilisé pour envoyer les ordres de Canva vers http par exemple (DessineMoiUnRSF)
global CanvaVirtuel
set Commande [lindex $args 0]
if {[regexp "GetActions" $Commande]} { set Actions [join $CanvaVirtuel "\n"] }
if {[regexp "Reset" $Commande] && [info exists CanvaVirtuel]} { unset CanvaVirtuel }
if {[regexp "GetActions" $Commande]} { return $Actions }
if {[regexp "Reset" $Commande]} { return "" }
lappend CanvaVirtuel [join $args " "]
return ""
}
proc GetOrderOfAlignment {TexteOuNomOuFichierRSF {WhichOne ""}} {
set Order [DessineMoiUnRSF $TexteOuNomOuFichierRSF "" "" "GetOrder"]
if {$WhichOne==""} { set WhichOne "Normal" }
if {[regexp -nocase "Alpha" $WhichOne]} { set Order [lsort -dictionary $Order] }
if {[regexp -nocase "Rever" $WhichOne]} { set Order [lreverse $Order] }
if {[regexp {[0-9]+} $WhichOne Match]} { set Order [lrange $Order 0 [incr Match -1]] }
return $Order
}
proc DessineMoiUnRSF {TexteOuNomOuFichierRSF {NomDuFichierOrigine ""} {FenetreParent ""} {AboutOrder ""} {WithSeq ""}} {
global CouleurDuFond
global DessinCourant
global ScrollRectangleOriginal IdScrollRectangle
global Memo
global LesOrdresPourGif
#rR a rajouté WithSeq pour permettre de passer la séquence pour chaque feature (dans les Tags)
set WithSeq [regexp -nocase "WithSeq" $WithSeq]
#rR FenetreParent can be a window name, NormalWindow, PourGif or PourCanVir
#rR AboutOrder permet de rendre l'ordre ou d'imposer un nouveau (les index séparés par un blanc)
set NewOrder ""
set GetOrder 0
if {$AboutOrder!=""} {
set GetOrder [string equal -nocase $AboutOrder "GetOrder"]
if { ! $GetOrder } {
regsub -all {[ \t\n,;]+} $AboutOrder " " AboutOrder
set NewOrder [split [string trim $AboutOrder] " "]
}
}
if {[PourWscope] && $FenetreParent==""} { set FenetreParent "PourCanVir" }
if { $FenetreParent==""} { set FenetreParent "NormalWindow" }
set AvecTexte 0
set PourGif 0
set PourCanVir 0
if {$FenetreParent=="PourGif"} {
set PourGif 1
} elseif {$FenetreParent=="PourCanVir"} {
CanvaVirtuel "Reset"
set PourCanVir 1
} else {
if {$FenetreParent=="NormalWindow"} {
set w [NomDe fenetre]
} else {
set w $FenetreParent
}
}
if { ! [info exists CouleurDuFond]} { set CouleurDuFond "cadetblue" }
set RSF ""
if {[regexp "\n" $TexteOuNomOuFichierRSF]} {
set FichierRSF "RSF"
set RSF $TexteOuNomOuFichierRSF
} else {
if {[regexp {\.msf$} $TexteOuNomOuFichierRSF]} {
regsub {\.msf$} $TexteOuNomOuFichierRSF "" TexteOuNomOuFichierRSF
}
set FichierRSF $TexteOuNomOuFichierRSF
set Queue [file tail $TexteOuNomOuFichierRSF]
if {[EstUnPAB $Queue]} {
set FichierRSF "[RepertoireDuGenome]/rsf/$Queue.rsf"
if { ! [file exists $FichierRSF]} {
set FichierRSF "[RepertoireDuGenome]/rsf/$Queue"
}
if { ! [file exists $FichierRSF]} {
set FichierRSF "[RepertoireDuGenome]/macsimRsf/$Queue.rsf"
}
if { ! [file exists $FichierRSF]} {
set FichierRSF "[RepertoireDuGenome]/macsimRsf/$Queue"
}
if { ! [file exists $FichierRSF]} {
set FichierRSF $TexteOuNomOuFichierRSF
}
}
if {[file exists $FichierRSF]} {
set RSF [ContenuDuFichier $FichierRSF]
}
}
if { ! [regexp {^!!RICH} $RSF]} { return "" }
if {$NomDuFichierOrigine==""} { set NomDuFichierOrigine $FichierRSF }
set Nom [file tail $NomDuFichierOrigine]
set NombreDeSequences [DecortiqueUnRSF $RSF LesSequencesDansLOrdre Sequences TabRSF "" "AvecBornesLocales"]
if {$GetOrder} { return $LesSequencesDansLOrdre }
if {$NewOrder!=""} { set LesSequencesDansLOrdre $NewOrder }
set MaxLongueurSequence 0
foreach NomSeq $LesSequencesDansLOrdre {
set MaxLongueurSequence [Maxi $MaxLongueurSequence [string length [set Sequences($NomSeq)]]]
}
#parray Sequences
set Titre $NomDuFichierOrigine
if {$PourGif} {
set PourGif 1
set Canvas NeRienFaire
set Bind NeRienFaire
set Pack NeRienFaire
set Fram NeRienFaire
set Button NeRienFaire
set Scrollbar NeRienFaire
set Grid NeRienFaire
set Winfo NeRienFaire
set FonctionRejetteLaBoite "RejetteLaBoite"
set LesOrdresPourGif {}
set w "PourGif"
set K "OrdrePourGif"
} elseif {$PourCanVir} {
CanvaVirtuel CanVir $NomDuFichierOrigine
set Canvas NeRienFaire
set Bind NeRienFaire
set Pack NeRienFaire
set Fram NeRienFaire
set Button NeRienFaire
set Scrollbar NeRienFaire
set Grid NeRienFaire
set Winfo NeRienFaire
set FonctionRejetteLaBoite "RejetteLaBoite"
set w "PourCanVir"
set K "CanvaVirtuel"
} else {
set PourGif 0
set Canvas canvas
set Bind bind
set Pack pack
set Fram frame
set Button button
set Scrollbar scrollbar
set Grid grid
set Winfo winfo
set FonctionRejetteLaBoite "NeRejettePasLaBoite"
set K "ToCreate"
}
set LargeurDUneLettre 1
set xDebut 0
set xFin [expr $MaxLongueurSequence*$LargeurDUneLettre]
# incr xDebut -50
# incr xFin 50
set CanvaSizeX [expr $xFin - $xDebut]
set CanvaScroMinX [expr $xDebut]
set CanvaScroMaxX [expr $xFin ]
#set CanvaScreenX $CanvaSizeX
set CanvaScreenX 1200
set HauteurDUneLettre [expr $LargeurDUneLettre*2]
set yDebut 0
set yFin [expr $NombreDeSequences*$HauteurDUneLettre]
set CanvaSizeY [expr $yFin - $yDebut]
set CanvaScroMinY [expr $yDebut]
set CanvaScroMaxY [expr $yFin ]
set CanvaScreenY [expr $CanvaSizeY]
if { [regexp "expo" $w] } {
set NormalCanvaScreenX $CanvaScreenX
set CanvaScreenX 300
set CanvaScreenY [expr round($CanvaSizeY*(1.0*$CanvaScreenX)/$CanvaSizeX)]
set Papa $w
}
if { ! $PourGif && ! $PourCanVir} {
set K [UnCanva $CanvaScroMaxX $CanvaScroMaxY $CanvaScreenX $CanvaScreenY "GonfleY" $NomDuFichierOrigine]
}
set IdCadre [$K find withtag "Cadre"]
$K itemconfigure $IdCadre -fill "white"
if {0} {
foreach Key [array names TabRSF] {
if { ! [regexp KAD7_HUMAN $Key]} { continue }
Espionne "$Key $TabRSF($Key)"
}
exit
}
set i -1
foreach NomSeq $LesSequencesDansLOrdre {
incr i
set PosMinY [expr $i*$HauteurDUneLettre]
set PosMaxY [expr $PosMinY+$HauteurDUneLettre]
set TextSeq $NomSeq
if {[info exists TabRSF($NomSeq,creator)]} {
append TextSeq " [join [set TabRSF($NomSeq,creator)] " "]"
}
if {[info exists TabRSF($NomSeq,descrip)]} {
append TextSeq " [join [set TabRSF($NomSeq,descrip)] " "]"
}
if {[info exists TabRSF($NomSeq,group)]} {
append TextSeq " MacsimsCluster [join [set TabRSF($NomSeq,group)] { }]"
}
foreach FeatureType [set TabRSF($NomSeq,LesTypesDeFeatures)] {
if {[info exists TabRSF($NomSeq,Type,$FeatureType)]} {
foreach Donnee [set TabRSF($NomSeq,Type,$FeatureType)] {
scan $Donnee "%d %d %d %d %s %s %s" D F dL fL Couleur Forme EmptyFull
set XduD [expr $D-1]
set XduF [expr $F]
set LesTags [list "Seq" $TextSeq $FeatureType $Donnee]
if {$WithSeq} {
set S [string range $Sequences($NomSeq) $XduD $XduF-1] ;#rR pas sûr du -1
lappend LesTags $S
}
$K create rect $XduD $PosMinY $XduF $PosMaxY \
-tags $LesTags \
-outline $Couleur \
-fill $Couleur
}
}
}
set SeqGlob $Sequences($NomSeq)
regsub -all {\.} $SeqGlob "" SeqLoc
regsub {^\.+} $SeqGlob "" SeqGlobD
set D [expr [string length $SeqGlob]-[string length $SeqGlobD]+1]
regsub {\.+$} $SeqGlobD "" SeqGlobDF
set Q [expr [string length $SeqGlobD]-[string length $SeqGlobDF]+1]
set F [expr $MaxLongueurSequence - $Q]
set XduD [expr $D-1]
set XduF $F
set LongLoc [string length $SeqLoc]
set Couleur "Grey75"
set Form "square"
set EmptyFull "solid"
set Donnee "$D $F 1 $LongLoc $Couleur $Form $EmptyFull"
set LesTags [list "GlobSeq" $TextSeq GLOBALSEQ $Donnee]
if {1 && $WithSeq} {
lappend LesTags $SeqGlobDF
}
$K create rect $XduD $PosMinY $XduF $PosMaxY \
-tags $LesTags \
-outline $Couleur \
-fill $Couleur
lappend TabRSF($NomSeq,LesTypesDeFeatures) "GLOBALSEQ"
if {$PourCanVir} {
set Couleur "transparent"
set Form "square"
set EmptyFull "solid"
set Donnee "$D $F 1 $LongLoc $Couleur $Form $EmptyFull"
set LesTags [list "ShowSequence" $TextSeq SHOWSEQUENCE $Donnee]
if {1 && $WithSeq} {
lappend LesTags $SeqGlobDF
}
$K create rect $XduD $PosMinY $XduF $PosMaxY \
-tags $LesTags \
-outline $Couleur \
-fill $Couleur
lappend TabRSF($NomSeq,LesTypesDeFeatures) "SHOWSEQUENCE"
set TabRSF($NomSeq,WholeSeq) $Sequences($NomSeq)
}
}
lappend TabRSF(LesTypesDeFeatures) "GLOBALSEQ"
if {$PourCanVir} { lappend TabRSF(LesTypesDeFeatures) "SHOWSEQUENCE" }
if {$PourCanVir} { return [CanvaVirtuel "GetActionsAndReset"] }
if {[info exists GrosBoutons]} {
set Boutons "[$Winfo parent $K].buttons"
foreach FeatureType $TabRSF(LesTypesDeFeatures) {
$Button $Boutons.t_$FeatureType -text "$FeatureType/lower/clear"
$Bind $Boutons.t_$FeatureType <1> "$K raise $FeatureType"
$Bind $Boutons.t_$FeatureType <2> "$K lower $FeatureType"
$Bind $Boutons.t_$FeatureType <3> "$K lower $FeatureType Cadre"
$Pack $Boutons.t_$FeatureType -side left -expand 1
}
} else {
set Clavier "[$Winfo parent $K].buttons"
TouchePour $Clavier NouvelleGamme
TouchePour $Clavier NouvelleCouleur "lightgrey"
TouchePour $Clavier "Description" "AfficheLesDescriptifs $NomDuFichierOrigine MemeOrdre"
TouchePour <2> "/all" "AfficheLesDescriptifs $Nom Natif"
TouchePour $Clavier "Taxonomy" "DessineMoiLaTaxonomy $NomDuFichierOrigine $NomDuFichierOrigine {} {} $HauteurDUneLettre same"
TouchePour <2> "/all" "AfficheLesDescriptifs $Nom Natif {} {} {OX OC} $Nom"
TouchePour <3> "/page" "AfficheLesDescriptifs $NomDuFichierOrigine MemeOrdre {} {} {OX OC} $Nom"
TouchePour $Clavier "BilanCilioCarta" "AfficheBilanCilioCarta $NomDuFichierOrigine"
set LesTypesDeFeatures $TabRSF(LesTypesDeFeatures)
set N [llength $LesTypesDeFeatures]
set BoutonsParClavier [Maxi 3 [expr $N/4]]
set nBoutons 0
set PremiereFois 1
foreach FeatureType $LesTypesDeFeatures {
if {$nBoutons%$BoutonsParClavier==0} {
TouchePour $Clavier NouvelleGamme
TouchePour $Clavier NouvelleCouleur "green"
if {$PremiereFois} {
TouchePour $Clavier "Clear all" "$K raise Cadre"
set PremiereFois 0
incr nBoutons
}
}
TouchePour $Clavier "$FeatureType" "$K raise $FeatureType"
TouchePour <2> "/low" "$K lower $FeatureType"
TouchePour <3> "/off" "$K lower $FeatureType Cadre"
incr nBoutons
}
}
if {$PourGif} { return $LesOrdresPourGif }
if { [regexp "expo" $w]} {
$K bind all <1> "DessineMoiUnRSF $RSF $NomDuFichierOrigine NormalWindow"
$K scale all 0 0 [expr (1.0*$CanvaScreenX)/$NormalCanvaScreenX] [expr (1.0*$CanvaScreenX)/$NormalCanvaScreenX]
set Memo(LargeurDe$w) [expr $CanvaScreenX+20]
set Memo(HauteurDe$w) [expr $CanvaScreenY+20]
} else {
$K bind "Seq" <1> "ClickDansSeq $K %x %y"
$K bind "Seq" <Enter> "EntreDansSeq $K %x %y"
$K bind "Seq" <Leave> "SortDeSeq $K %x %y"
set DessinCourant $K
}
if {$PourCanVir} { return [CanvaVirtuel "GetActionsAndReset"] }
if {$PourGif} { return $LesOrdresPourGif }
return $w
}
proc DifferentColor {{GetWhat ""}} {
global DifferentColor
if {$GetWhat==""} { set GetWhat "RGB" }
set GetWhat [string toupper $GetWhat]
if {$GetWhat=="RESET"} {
if {[info exists DifferentColor]} { unset DifferentColor }
return ""
}
#rR on utilise un angle pour Hue
if { ! [info exists DifferentColor(Ang)]} { set DifferentColor(Ang) -137.5 }
if { ! [info exists DifferentColor(Sat)]} { set DifferentColor(Sat) 1.0 }
if { ! [info exists DifferentColor(Bri)]} { set DifferentColor(Bri) 1.0 }
set Angle $DifferentColor(Ang)
set Angle [expr round($Angle+137.5)%360]
set Hue [expr $Angle/360.]
set DifferentColor(Ang) $Angle
set DifferentColor(Hue) $Hue
set Sat $DifferentColor(Sat)
set Sat [expr $Sat*0.98]
set DifferentColor(Sat) $Sat
return [ColorFromHSB $DifferentColor(Hue) $DifferentColor(Sat) $DifferentColor(Bri)]
}
proc DessineMoiLaTaxonomy {Source {NomDuFichierOrigine ""} {FenetreParent ""} {LargeurDUneBoite ""} {HauteurDUneBoite ""} {OutLineColor ""}} {
LogWscope "$Source $NomDuFichierOrigine"
LogWscope [RepertoireDuGenome]
if {[regexp "wali/store" $Source]} {
set Queue [file tail $Source]
if {[regexp {^(HSAP[0-9]+)([^0-9]|$)} $Queue Match Nom]} {
set Source /genomics/link/CilioCarta/descriptifs/$Nom
}
}
if {[OnTraite "Zero"]} { return "" }
#rR FenetreParent can be a window name, NormalWindow, PourGif or PourCanVir
set AvecTexte 0
set PourGif 0
set PourCanVir 0
if {[PourWscope] && $FenetreParent==""} { set FenetreParent "PourCanVir" }
if { $FenetreParent==""} { set FenetreParent "NormalWindow" }
if {$FenetreParent=="PourGif"} {
set PourGif 1
} elseif {$FenetreParent=="PourCanVir"} {
CanvaVirtuel "Reset"
set PourCanVir 1
} else {
if {$FenetreParent=="NormalWindow"} {
set w [NomDe fenetre]
} else {
set w $FenetreParent
}
}
# regsub {/macsim[^/]+/} $Source "/descriptifs/" DescFile
set LesIDOXOSOC [AfficheLesDescriptifs $Source MemeOrdre LaListe "" "ID AC OX OS OC"]
set INode 0
set Nom [file tail $NomDuFichierOrigine]
set Titre $NomDuFichierOrigine
if {$PourGif} {
set PourGif 1
set Canvas NeRienFaire
set Bind NeRienFaire
set Pack NeRienFaire
set Fram NeRienFaire
set Button NeRienFaire
set Scrollbar NeRienFaire
set Grid NeRienFaire
set Winfo NeRienFaire
set FonctionRejetteLaBoite "RejetteLaBoite"
set LesOrdresPourGif {}
set w "PourGif"
set K "OrdrePourGif"
} elseif {$PourCanVir} {
CanvaVirtuel CanVir $NomDuFichierOrigine
set Canvas NeRienFaire
set Bind NeRienFaire
set Pack NeRienFaire
set Fram NeRienFaire
set Button NeRienFaire
set Scrollbar NeRienFaire
set Grid NeRienFaire
set Winfo NeRienFaire
set FonctionRejetteLaBoite "RejetteLaBoite"
set w "PourCanVir"
set K "CanvaVirtuel"
} else {
set PourGif 0
set Canvas canvas
set Bind bind
set Pack pack
set Fram frame
set Button button
set Scrollbar scrollbar
set Grid grid
set Winfo winfo
set FonctionRejetteLaBoite "NeRejettePasLaBoite"
set K "ToCreate"
}
set BilanCilioExists [BilanCilio exists]
if {$BilanCilioExists} {
DifferentColor Reset
set ColorOf(Clade_) "white"
foreach Clade [BilanCilio ListOf Clade] {
regsub {[A-Z]+\_} $Clade "" Clade
if {[info exists ColorOf(Clade_$Clade)]} { continue }
set Color [DifferentColor]
set ColorOf(Clade_$Clade) $Color
}
}
set MaxLevel 0
set i -1
set AllNode {}
foreach Ligne $LesIDOXOSOC {
incr i
scan $Ligne "%s" ID
regsub "=.*" $ID "" ID
set VraiID [StringApres "ID:" dans $Ligne]
if {$VraiID!="" && ! [regexp "_" $ID]} { set ID $VraiID }
set OX [IntegerApres "OX:" dans $Ligne]
if {$OX=="" && [EstUnPAB $ID]} { set OX [NotreOX] }
set OC [string trim [StringSuivant "OC:" dans $Ligne] " \t"]
if {$OC=="" && [EstUnPAB $ID]} { set OC [NotreOC] }
regsub "OC:.*" $Ligne "" Ligne
set OS [string trim [StringSuivant "OS:" dans $Ligne] " \t"]
if {$OS=="" && [EstUnPAB $ID]} { set OS [NotreOS] }
regsub -all {[\. ]} $OC "" OC
set LesNode [split $OC ";"]
lappend LesNode $OS
# Espionne "[llength $LesNoeuds] $ID $OX $OS $OC"
set Level -1
set PrevNode ""
foreach Node $LesNode {
if { ! [info exists PreviousNode($Node)]} { set PreviousNode($Node) $PrevNode }
set PrevNode $Node
if { ! [info exists INodeOf($Node)]} {
set INodeOf($Node) [incr INode]
}
incr Level
lappend AllNode $Node
lappend IdsFromNode($Node) $ID
set LevelOfNode($Node) $Level
if {[info exists AreaOf($Node)]} { set AreaOf($Node) 0 }
incr AreaOf($Node) $Level
}
set MaxLevel [Maxi $MaxLevel $Level]
}
set NbLignes [expr $i+1]
set AllNode [lsort -unique $AllNode]
foreach Node $AllNode {
# Espionne "$Node [llength $PreviousNode($Node)] $LevelOfNode($Node)"
}
set PreferedOrganisms [list "Homo sapiens" "Mus musculus"]
set HighArea 9999
foreach O $PreferedOrganisms {
set AreaOf($O) [incr HighArea -1]
}
foreach {N A} [array get AreaOf] {
lappend ListOfArea $A
lappend NodesOfArea($A) $N
}
set ListOfArea [lsort -unique -integer -decreasing $ListOfArea]
DifferentColor Reset
foreach A $ListOfArea {
foreach Node $NodesOfArea($A) {
if {[info exists ColorOf($Node)]} { continue }
set Color [DifferentColor]
lappend ListOfColor $Color
set ColorOf($Node) $Color
set N $Node
while {[info exists PreviousNode($N)] && [set N $PreviousNode($N)]!=""} {
if {[info exists ColorOf($N)]} { break }
set ColorOf($N) $Color
}
}
}
if {$LargeurDUneBoite==""} { set LargeurDUneBoite 70 }
if {$HauteurDUneBoite==""} { set HauteurDUneBoite 15 }
if {$OutLineColor==""} {
if {$HauteurDUneBoite<5} {
set OutLineColor "same"
} else {
set OutLineColor "white"
}
}
set xDebut 0
set xFin [expr ($MaxLevel+2)*$LargeurDUneBoite]
set CanvaSizeX [expr $xFin - $xDebut]
set CanvaScroMinX [expr $xDebut]
set CanvaScroMaxX [expr $xFin ]
set CanvaScreenX $CanvaSizeX
set yDebut 0
set yFin [expr ($NbLignes+2)*$HauteurDUneBoite]
set CanvaSizeY [expr $yFin - $yDebut]
set CanvaScroMinY [expr $yDebut]
set CanvaScroMaxY [expr $yFin ]
set CanvaScreenY [expr $CanvaSizeY]
if { [regexp "expo" $w] } {
set NormalCanvaScreenX $CanvaScreenX
set CanvaScreenX 300
set CanvaScreenY [expr round($CanvaSizeY*(1.0*$CanvaScreenX)/$CanvaSizeX)]
set Papa $w
}
if { ! $PourGif && ! $PourCanVir} {
set K [UnCanva $CanvaScreenX $CanvaScreenY $CanvaScreenX $CanvaScreenY "GonfleY" $NomDuFichierOrigine]
}
set IdCadre [$K find withtag "Cadre"]
$K itemconfigure $IdCadre -fill "white"
set SepTexteNode "\n"
if {$PourCanVir} { set SepTexteNode " " }
set i -1
foreach Ligne $LesIDOXOSOC {
# regsub -all {[ \t]+} $Ligne " " Ligne ;#rR rajouté 2015/01/24
incr i
set PosMinY [expr $i*$HauteurDUneBoite]
set PosMaxY [expr $PosMinY+$HauteurDUneBoite]
scan $Ligne "%s" ID
regsub "=.*" $ID "" ID
set VraiID [StringApres "ID:" dans $Ligne]
if {$VraiID!="" && ! [regexp "_" $ID]} {
regsub "^$ID=" $Ligne $VraiID= Ligne ; #rR 2015/05/21 pour avoir le ID et non pas l'access
}
set OX [IntegerApres "OX:" dans $Ligne]
if {$OX=="" && [EstUnPAB $ID]} { set OX [NotreOX] }
set PlaceBilan 0
if {$BilanCilioExists} {
set Clade [BilanCilio $OX Clade]
regsub {^[A-Z]+_} $Clade "" Clade
if {$Clade=="" && $OX==9606} { set Clade "Mammalia" }
set Etat [BilanCilio $OX State]
set Couleur $ColorOf(Clade_$Clade)
if {$OutLineColor=="same"} {
set CouleurTrait $Couleur
} else {
set CouleurTrait $OutLineColor
}
set XduD [expr ($PlaceBilan) * $LargeurDUneBoite/2]
set XduF [expr $XduD + $LargeurDUneBoite/2 -1]
$K create rect $XduD $PosMinY $XduF $PosMaxY \
-tags [list "Clade" "$Clade $Etat" "$Clade$SepTexteNode$Ligne"] \
-outline $CouleurTrait \
-fill $Couleur
incr PlaceBilan
set Couleur "lightgrey"
if {$Etat==""} { set Couleur "#ffffffffffff" }
if {$Etat=="Y"} { set Couleur "#90b1eed89080" }
if {$Etat=="N"} { set Couleur "#ffffc0c4cbc4" }
if {$Etat=="L"} { set Couleur "#ffffcc500000" }
if {$Etat=="PR"} { set Couleur "#ffffcc500000" }
if {$OutLineColor=="same"} {
set CouleurTrait $Couleur
} else {
set CouleurTrait $OutLineColor
}
set XduD [expr ($PlaceBilan) * $LargeurDUneBoite/2]
set XduF [expr $XduD + $LargeurDUneBoite/2 -1]
$K create rect $XduD $PosMinY $XduF $PosMaxY \
-tags [list "State" "$Etat $Clade" "$Etat$SepTexteNode$Ligne"] \
-outline $CouleurTrait \
-fill $Couleur
incr PlaceBilan 1
}
set OC [string trim [StringSuivant "OC:" dans $Ligne] " \t"]
if {$OC=="" && [EstUnPAB $ID]} { set OC [NotreOC] }
regsub "OC:.*" $Ligne "" Ligne
set OS [string trim [StringSuivant "OS:" dans $Ligne] " \t"]
if {$OS=="" && [EstUnPAB $ID]} { set OS [NotreOS] }
regsub -all {[\. ]} $OC "" OC
set LesNode [split $OC ";"]
lappend LesNode $OS
# Espionne "[llength $LesNoeuds] $ID $OX $OS $OC"
set Level -1
set Ruban ""
set TexteDuNode ""
set Sep ""
set OffsetX 0
foreach Node $LesNode {
append TexteDuNode "$Sep$Node"
set Sep "; "
incr Level
if { ! [info exists INodeOf($Node)]} {
set INodeOf($Node) [incr INode]
}
append Ruban " [format %3.3d $INodeOf($Node)]"
set Couleur $ColorOf($Node)
set XduD [expr ($PlaceBilan + $Level) * $LargeurDUneBoite]
set XduF [expr $XduD + $LargeurDUneBoite -1]
if {$OutLineColor=="same"} {
set CouleurTrait $Couleur
} else {
set CouleurTrait $OutLineColor
}
$K create rect $XduD $PosMinY $XduF $PosMaxY \
-tags [list "Node" $TexteDuNode "$Node$SepTexteNode$Ligne"] \
-outline $CouleurTrait \
-fill $Couleur
# $K create text $XduD [expr $PosMinY+$HauteurDUneBoite/2] -text $Couleur -font {Courier 8} -anchor w
# $K create text 1200 [expr $PosMinY+$HauteurDUneBoite/2] -text "[format %-30s $OS] $OC $OS" -anchor w
}
# Espionne $Ruban
}
global PagePropre
set PagePropre($w) [join $LesIDOXOSOC "\n"]
#rR on pourrait peut-être mettre ça plus bas mais il faut d'abord redéfinir TouchePour
if {$PourCanVir} { return [CanvaVirtuel "GetActionsAndReset"] }
if {$PourGif} { return $LesOrdresPourGif }
$K bind "Node" <1> "ClickDansSeq $K %x %y"
$K bind "Node" <Enter> "EntreDansSeq $K %x %y"
$K bind "Node" <Leave> "SortDeSeq $K %x %y"
$K bind "Clade" <Enter> "EntreDansSeq $K %x %y"
$K bind "Clade" <Leave> "SortDeSeq $K %x %y"
$K bind "State" <Enter> "EntreDansSeq $K %x %y"
$K bind "State" <Leave> "SortDeSeq $K %x %y"
if {$HauteurDUneBoite==2} { set HBoite 15 } else { set HBoite 2 }
set Clavier "[$Winfo parent $K].buttons"
TouchePour $Clavier NouvelleGamme
TouchePour $Clavier NouvelleCouleur "lightgrey"
TouchePour $Clavier "Description" "AfficheLesDescriptifs $Source MemeOrdre"
TouchePour <2> "/all" "AfficheLesDescriptifs $Nom Natif"
TouchePour $Clavier "Taxonomy" "DessineMoiLaTaxonomy $Source $Source {} {} $HBoite"
TouchePour <2> "/all" "AfficheLesDescriptifs $Nom Natif {} {} {OX OC} $Nom"
TouchePour <3> "/page" "AfficheLesDescriptifs \[set PagePropre($w)\] MemeOrdre {} {} {OX OC} $Nom"
return $w
}
proc DetecteCopainsDoublons {} {
set LesDoubles {}
foreach Nom [ListeDesPABs] {
set Fichier [GscopeFile $Nom "tfasdescopains"]
if {[FileAbsent $Fichier]} { continue }
if {[info exists DejaVu]} { unset DejaVu }
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp {^>} $Ligne] } { append Seq($AccessCourant) $Ligne ; continue }
scan $Ligne "%s" Access
if {[info exists DejaVu($Access)]} {
lappend LesDoublons($Nom) $Access
lappend LesDoubles $Nom
lappend LesIduAccess($Access) [incr IduAccess($Access)]
set AccessCourant "${Access}_$IduAccess($Access)"
} else {
set DejaVu($Access) 1
set IduAccess($Access) 1
set AccessCourant "${Access}_$IduAccess($Access)"
}
}
}
set LesDoubles [lsort -unique $LesDoubles]
foreach Double $LesDoubles {
set LesDoublons($Double) [lsort -unique $LesDoublons($Double)]
set Seq1 $Seq(${Access}_1)
set YaDiff($Double) ""
foreach I $IduAccess($Access) {
set AccessCourant "${Access}_$I"jalviewApplet
if {$Seq1 ne $Seq($AccessCourant)} { set YaDiff($Double) "YaDiff" }
}
lappend LaSortie "$Double [join $LesDoublons($Double) " "] $YaDiff($Double)"
}
return [AfficheListe $LaSortie]
}
proc TheTrueMacsimsFile {Nom {Preference ""}} {
if {[regexp "/" $Nom]} {
if {[file exists $Nom]} { return $Nom }
if {[file exists $Nom.xml]} { return $Nom.xml }
if {[file exists $Nom.xml.gz]} { return $Nom.xml.gz }
if {[file exists $Nom.gz]} { return $Nom.gz }
}
if { ! [EstUnPAB $Nom]} { return $Nom }
foreach Dir [list "[RepertoireDuGenome]/macsimXml" "[RepertoireDuGenome]/macsims"] {
if {[file exists $Dir/$Nom]} { return $Dir/$Nom }
if {[file exists $Dir/$Nom.xml]} { return $Dir/$Nom.xml }
if {[file exists $Dir/$Nom.xml.gz]} { return $Dir/$Nom.xml.gz }
if {[file exists $Dir/$Nom.gz]} { return $Dir/$Nom.gz }
}
return $Nom
}
proc ReordonneRsf {NomOuFichierRsf LaListe {GetWhat ""}} {
if {$GetWhat==""} { set GetWhat "GetText" }
set Nom ""
if {[EstUnPAB $NomOuFichierRsf]} {
set Nom $NomOuFichierRsf
set FichierRsf [GscopeFile $Nom "macsimRsf"]
if {$LaListe=="OrderFromMsf"} {
set FichierMsf [GscopeFile $Nom "msf"]
DecortiqueUnMSF $FichierMsf LaListe
}
} else {
set FichierRsf $NomOuFichierRsf
}
set LeNouveau {}
set OnAttendOuvrante 1
set LeCourant {}
set LesAnciens {}
foreach Ligne [LesLignesDuFichier $FichierRsf] {
if {$OnAttendOuvrante} {
if { ! [regexp {^\{} $Ligne] } { lappend LeNouveau $Ligne ; continue }
set OnAttendOuvrante 0
}
if { [regexp {^\{} $Ligne]} {
lappend LeCourant $Ligne
continue
}
if { [regexp {^\}} $Ligne]} {
lappend LeCourant $Ligne
set T($Courant) [join $LeCourant "\n"]
set LeCourant {}
continue
}
if {[regexp "^name " $Ligne]} {
set Courant [StringApres "name" dans $Ligne]
lappend LesAnciens $Courant
}
lappend LeCourant $Ligne
}
if {$LaListe=="SameOrder"} { set LaListe $LesAnciens }
foreach Courant $LaListe {
if { ! [info exists T($Courant)] } { continue }
lappend LeNouveau $T($Courant)
}
set Nouveau [join $LeNouveau "\n"]
if {$GetWhat=="GetText" } { return $Nouveau }
if {$GetWhat=="SameFile"} { return [Sauve $Nouveau dans $FichierRsf] }
return [Sauve $Nouveau dans $GetWhat]
}
proc TestMacsimsOnWeb {} {
#set Msf [ContenuDuFichier [GscopeFile PGS779 "msf"]]
set Msf [ContenuDuFichier /home/moumou/alitest/FRAT01.msf]
set Xml [MacsimsOnWeb $Msf]
return $Xml
}
proc MacsimsOnWeb {Msf {FichierXml ""}} {
if {$FichierXml==""} { set FichierXml "GetXml" }
if { ! [regexp "\n" $Msf] && [file exists $Msf]} { set Msf [ContenuDuFichier $Msf] }
set Msf64 [Base64Encode $Msf]
set Query [::http::formatQuery "TexteMsf" $Msf64]
set Xml [HttpGetUrl "[LbgiUrl]/~ripp/cgi-bin/WscopeServer.tcl?science=Zero&commande=MacsimsFromText" $Query]
if {$FichierXml=="GetXml"} { return $Xml }
if {[regexp {^//} $FichierXml]} { regsub {^//} $FichierXml "[RepertoireDuGenome]/" FichierXml }
return [Sauve $Xml dans $FichierXml]
}
proc MacsimsFromText TexteMsf {
if { ! [regexp "\n" $TexteMsf] && [file exists $TexteMsf]} { set TexteMsf [ContenuDuFichier $TexteMsf] }
if { ! [regexp "\n" $TexteMsf]} { set TexteMsf [Base64Decode $TexteMsf] }
set FichierMsf "[TmpFile].msf"
Sauve $TexteMsf dans $FichierMsf
set Xml [Macsims $FichierMsf "GetXmlText"]
file delete $FichierMsf
return $Xml
}
proc Macsims {FichierMsf {FichierXml ""} {FichierRsf ""} {FichierLog ""} {Delete ""}} {
LogWscope "Macsims $FichierMsf $FichierXml $FichierRsf $FichierLog $Delete"
#rR y a encore un probleme ... 2011/04/20
if {$FichierXml==""} { set FichierXml "GetXmlText" }
if {$FichierRsf==""} { set FichierRsf "DeleteRsfFile" }
set GetRsf "GetRsfFile"
if {$FichierRsf=="GetRsfText" || $FichierRsf=="DeleteRsfFile"} {
set GetRsf $FichierRsf
set FichiersRsf "[TmpFile].rsf"
}
set GetXml "GetXmlFile"
if {$FichierXml=="GetXmlText" || $FichierXml=="DeleteXmlFile"} {
set GetXml $FichierXml
set FichierXml "[TmpFile].xml"
}
set Message [ExecuteMacsim $FichierMsf $FichierRsf]
if {$Message!=""} {
Warne $Message
if {$FichierLog!=""} { AppendAuFichier $FichierLog $Message }
}
set FichierRsfRsf "$FichierRsf.rsf"
set FichierRsfXml "$FichierRsf.xml"
if {[file exists $FichierRsfXml]} {
file rename $FichierRsfXml $FichierXml
}
if { ! [file exists $FichierRsfRsf]} {
set MonMessage "$FichierRsfRsf was not created. I got the message\n$Message"
Warne $MonMessage
if {$FichierLog!=""} { AppendAuFichier $FichierLog $MonMessage }
} else {
file rename $FichierRsfRsf $FichierRsf
}
foreach Mot [split $Delete "_"] {
set F "Fichier$Mot"
if {[regexp {\.$} $F]} {
set FSansPoint [string trimright $F "."]
if { ! [info exists $FSansPoint]} { continue }
foreach FF [glob -nocomplain "[set $FSansPoint].*"] {
file delete $FF
}
} else {
if { ! [info exists $F]} { continue }
foreach FF [glob -nocomplain "[set $F]*"] {
file delete $FF
}
}
}
if {$GetRsf=="DeleteRsfFile"} { file delete $FichierRsf }
if {$GetXml=="DeleteXmlFile"} { file delete $FichierXml }
if {$GetRsf=="GetRsfText"} {
set Rsf [ContenuDuFichier $FichierRsf]
file delete $FichierRsf
return $Rsf
}
if {$GetXml=="GetXmlText"} {
set Xml [ContenuDuFichier $FichierXml]
file delete $FichierXml
return $Xml
}
return $FichierXml
}
proc TestMacsimsInfo {} {
global MacsimsInfo
MacsimsInfo LoadXml "/genomics/link/SpliRet/macsimXml/SP0001"
parray MacsimsInfo
exit
EspionneL [MacsimsInfo ListOf Key1]
Espionne "================================="
EspionneL [MacsimsInfo ListOf FeaturesKeys]
foreach Access [MacsimsInfo Noms] {
Espionne "$Access [MacsimsInfo $Access Features]"
}
}
proc MacsimsInfo args {
global MacsimsInfo
#rR calls ParseMACSIMS from Nicolas Gagniere
set Qui [lindex $args 0]
set Quoi [lindex $args 1]
if {[regexp -nocase "LoadXml" $Qui]} {
set Fichier $Quoi
if {[info exists MacsimsInfo(File)]} {
if {[string equal -nocase "ReLoadXml" $Qui] \
|| $MacsimsInfo(File)!=$Fichier} {
unset MacsimsInfo
}
}
if { ! [info exists MacsimsInfo(File)]} {
if {[FileAbsent $Fichier]} {
FaireLire "$Fichier\ndoesn't exist"
return ""
}
ParseMACSIMS $Fichier MacsimsInfo
# parray MacsimsInfo; exit;
set MacsimsInfo(File) $Fichier
set LesKey1 {}
set LesFeaturesKeys {}
foreach X [array names MacsimsInfo] {
set LesKey [split $X ","]
set Key1 [lindex $LesKey 1]
lappend LesKey1 $Key1
if {$Key1=="Features"} {lappend LesFeaturesKeys [lindex $LesKey 3]}
}
set LesKey1 [ListeSansDoublon $LesKey1]
set MacsimsInfo(ListOf,Key1) $LesKey1
set LesFeaturesKeys [ListeSansDoublon $LesFeaturesKeys]
set MacsimsInfo(ListOf,FeaturesKeys) $LesFeaturesKeys
set args [lrange $args 2 end]
# parray MacsimsInfo
if {$args=={}} { return $MacsimsInfo(File) }
}
}
set Tout [join $args ","]
if {[info exists MacsimsInfo($Tout)]} { return $MacsimsInfo($Tout) }
return ""
}
proc UseExistingJalviewHtml {{Value ""}} {
global UseExistingJalviewHtml
if {$Value!=""} { set UseExistingJalviewHtml $Value }
if { ! [info exists UseExistingJalviewHtml]} { set UseExistingJalviewHtml [file exists "[RepertoireDuGenome]/webXXXXXXXXXX"] }
return $UseExistingJalviewHtml
}
proc JalviewHtml {FichierMacsim {JalviewJunkdir ""} {JalviewJunkdirUrl ""}} {
set CreateWebFile 0
if {0 && [EstUnPAB $FichierMacsim] && $JalviewJunkdir=="" && $JalviewJunkdirUrl=="" } {
set CreateWebFile 1
set Nom $FichierMacsim
set FichierJalviewHtml "[RepertoireDuGenome]/web/$Nom.jalview.html"
if {[UseExistingJalviewHtml] && [FileExists $FichierJalviewHtml]} {
return [ContenuDuFichier $FichierJalviewHtml]
}
}
if {[EstUnPAB $FichierMacsim]} { set FichierMacsim "[RepertoireDuGenome]/macsimXml/$FichierMacsim" }
if {$JalviewJunkdir ==""} { set JalviewJunkdir "[HomeRipp]/www/JalviewJunkdir" }
if {$JalviewJunkdirUrl==""} { set JalviewJunkdirUrl "/JalviewJunkdir" }
if {[FileAbsent $FichierMacsim]} {
# if {[regexp "^/" $FichierMacsim]} { return "" }
if {[FileExists "$FichierMacsim.xml"]} {
set FichierMacsim "$FichierMacsim.xml"
} else {
if {[FileExists "[RepertoireDuGenome]/$FichierMacsim"] } {
set FichierMacsim "[RepertoireDuGenome]/$FichierMacsim"
}
}
}
if {[FileAbsent $FichierMacsim] && [FileExists "$FichierMacsim.gz"]} {
set FichierMacsim "$FichierMacsim.gz"
}
if {[FileAbsent $FichierMacsim]} { return "Sorry, there is no file $FichierMacsim" }
set Macsim [ContenuDuFichier $FichierMacsim]
NousAllonsAuBoulot $JalviewJunkdir
set Racine [TmpFile "macsim2jal" "./"]
regsub {\./} $Racine "" Racine
Sauve $Macsim dans $Racine.xml
if {[catch {exec /biolo/macsim/macsim2jal "$Racine.xml" $Racine > [HomeRipp]/lolo.log} Message]} {
OnRevientDuBoulot
return "Error during macsim2jal with message=$Message="
}
file delete -force $Racine.xml
if {[FileAbsent $Racine.html]} {
file delete -force $Racine.txt
file delete -force $Racine.tfa
}
if {[FileAbsent $Racine.html]} { return "I didn't find $Racine.html" }
if {$CreateWebFile} {
set WebDir [file dirname $FichierJalviewHtml]
file mkdir $WebDir
regsub {.html$} $FichierJalviewHtml ".tfa" FichierJalviewTfa
regsub {.html$} $FichierJalviewHtml ".txt" FichierJalviewTxt
set Html [ContenuDuFichier $Racine.html]
regsub -all "value=\"$Racine" $Html "value=\"$Nom.jalview" Html
Sauve $Html dans $FichierJalviewHtml
file copy -force $Racine.tfa $FichierJalviewTfa
file copy -force $Racine.txt $FichierJalviewTxt
if {[UseExistingJalviewHtml]} { return [JalviewHtml $Nom] }
}
set Html [ContenuDuFichier $Racine.html]
OnRevientDuBoulot
regsub -all "value=\"$Racine" $Html "valuetype=\"ref\" value=\"$JalviewJunkdirUrl/$Racine" Html
regsub -all {archive=[^>]+\">} $Html "archive=\"[LbgiUrl]/Jalview/jalviewApplet.jar\">" Html
return $Html
}
proc XmlFromRsfMacsim {NomOuFichier {FichierXml ""}} {
return XmlFromRsf $NomOuFichier $FichierXml
}
proc XmlFromRsf {NomOuFichier {FichierXml ""}} {
set Nom ""
set Fichier $NomOuFichier
if { ! [regexp "/" $NomOuFichier]} {
if {[EstUnPAB $NomOuFichier]} {
set Nom $NomOuFichier
set FichierPossible "[RepertoireDuGenome]/macsimRsf/$Nom"
if {[FileExists $FichierPossible]} {
set Fichier $FichierPossible
}
}
}
if {[FileAbsent $Fichier]} {return ""}
if {$FichierXml==""} {
if {$Nom!=""} {
set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom"
} else {
regsub -nocase ".rsf$" $Fichier "" FichierXml
append FichierXml ".xml"
}
}
set GetText 0
if {$FichierXml=="GetText"} {
set GetText 1
set FichierXml "[TmpFile].xml"
}
if {[catch {exec clustalw $Fichier -convert -output=macsim -outfile=$FichierXml} Message]} {
return ""
}
if {$GetText} {
set TexteXml [ContenuDuFichier $FichierXml]
file delete $FichierXml
return $TexteXml
}
return $FichierXml
}
proc ConvertToMsf {{Source ""} {GetWhat ""}} {
set CleanSource 0
if {[regexp "\n" $Source]} {
set FiSource "[TmpFile].xxx"
Sauve $Source dans $FiSource
set CleanSource 1
} elseif { [llength $Source] > 1 } {
set FiSource "[TmpFile].xxx"
SauveLesLignes $Source dans $FiSource
set CleanSource 1
} else {
set FiSource $Source
if {[FileAbsent $FiSource]} { return "" }
}
set FiMsf $GetWhat
set CleanDestin 0
if {$GetWhat==""} { set GetWhat "GetText" }
if {$GetWhat=="GetText" || $GetWhat=="GetLines"} {
set FiMsf "[TmpFile].msf"
set CleanDestin 1
}
if {$GetWhat=="GetFile"} {
set FiMsf $FiSource
regsub {\.(rsf|tfa|tfas|msf)$} $FiMsf "" FiMsf
append FiMsf ".msf"
}
if {[catch {exec clustalw $FiSource -convert -outorder=input -output=gscope -outfile=$FiMsf} Message]} {
Warne $Message
set GetWhat "Error"
}
set Retour ""
if {$GetWhat=="GetText"} { set Retour [ContenuDuFichier $FiMsf] }
if {$GetWhat=="GetLines"} { set Retour [LesLignesDuFichier $FiMsf] }
if {$GetWhat=="GetFile"} { set Retour $FiMsf }
if {$CleanSource && [file exists $FiSource]} { file delete $FiSource }
if {$CleanDestin && [file exists $FiMsf]} { file delete $FiMsf }
return $Retour
}
proc RsfFromXmlMacsim {NomOuFichier {FichierRsf ""}} {
set Nom ""
set Fichier $NomOuFichier
if { ! [regexp "/" $NomOuFichier]} {
if {[EstUnPAB $NomOuFichier]} {
set Nom $NomOuFichier
set FichierPossible "[RepertoireDuGenome]/macsimXml/$Nom"
if {[FileExists $FichierPossible]} {
set Fichier $FichierPossible
}
}
}
if {[FileAbsent $Fichier]} {return ""}
if {$FichierRsf==""} {
if {$Nom!=""} {
set FichierRsf "[RepertoireDuGenome]/macsimRsf/$Nom"
} else {
regsub -nocase ".xml$" $Fichier "" FichierRsf
append FichierRsf ".rsf"
}
}
set GetText 0
if {$FichierRsf=="GetText"} {
set GetText 1
set FichierRsf "[TmpFile].rsf"
}
if {[catch {exec clustalw $Fichier -convert -output=RSF -outfile=$FichierRsf} Message]} {
return ""
}
if {$GetText} {
set TexteRSF [ContenuDuFichier $FichierRsf]
file delete $FichierRsf
return $TexteRSF
}
return $FichierRsf
}
proc SiteBips {} {
set SiteBips "http://bips.u-strasbg.fr/"
return $SiteBips
}
proc GroupEtNonSubgroupDansXml {} {
foreach Nom [ListeDesPABs] {
set Fichier "[RepertoireDuGenome]/macsimXml/$Nom"
if { ! [file exists $Fichier]} {
continue
}
set LesBonnes {}
foreach Ligne [LesLignesDuFichier $Fichier] {
if {[regexp "</?subgroup>" $Ligne]} { continue }
lappend LesBonnes $Ligne
}
SauveLesLignes $LesBonnes dans $Fichier
}
exit
}
proc ShowTarget Commande {
if {[regexp -nocase "ListAllTargets" $Commande]} {
return [FileMoi]
}
if {[regexp -nocase "TargetId=" $Commande Clef]} {
set SpineID [StringApres $Clef dans $Commande]
} else {
set SpineID $Commande
}
if {[EstUnPAB $SpineID]} {
set GscopeID $SpineID
} else {
set GscopeID [GscopeID $SpineID]
}
return [FileMoi macsimHtml $GscopeID]
}
proc DoctypeForMacsim {} {
return {<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE macsim SYSTEM "http://lbgi.fr/macsim.dtd">
}
}
proc RewriteXmlMsaToMacsimPourTous {} {
foreach Nom [ListeDesPABs] {
set Fichier "[RepertoireDuGenome]/macsimXmlMsa/$Nom"
if { ! [file exists $Fichier]} { continue }
regsub "/macsimXmlMsa/" $Fichier "/macsimXml/" FichierSortie
if {[file exists $FichierSortie]} { continue }
Espionne [RewriteXmlMsaToMacsim $Fichier $FichierSortie]
}
}
proc RewriteXmlMsaToMacsim {Fichier {FichierSortie ""}} {
if {$FichierSortie==""} { set FichierSortie $Fichier }
set AncienXML [ContenuDuFichier $Fichier]
set Root [[dom parse $AncienXML] documentElement]
set NouveauXml [DoctypeForMacsim]
append NouveauXml [$Root asXML -indent 1]
regsub "<MSA>" $NouveauXml "<macsim>" NouveauXml
regsub "</MSA>" $NouveauXml "</macsim>" NouveauXml
if {$FichierSortie=="GetIt"} { return $NouveauXml }
return [Sauve $NouveauXml dans $FichierSortie]
}
proc GscopeID SpineID {
global GscopeID
if {[info exists GscopeID($SpineID)]} { return $GscopeID($SpineID) }
if {[info exists GscopeID("EstCharge")]} { return "" }
set GscopeID("EstCharge") 1
foreach Nom [ListeDesPABs] {
if {[EstUnPABMute $Nom]} {continue}
set S [SpineID $Nom]
if {$S==""} { continue }
set GscopeID($S) $Nom
}
return [GscopeID $SpineID]
}
proc SpineID {Nom {Full ""}} {
set Tout [ExtraitInfo $Nom "SpineID"]
if {$Full=="Full"} {return $Tout}
set SpineID ""
scan $Tout "%s" SpineID
return $SpineID
}
proc LaSequenceColoree {Texte {Maniere ""} {Ftable ""} {AvecZones ""}} {
set LesLettres {}
set LesClasses {}
if {$AvecZones==""} { set AvecZones 0 }
if {$Maniere==""} { set Maniere "Seqlab" }
if {$Maniere=="Normal"} { return $Texte }
if {$Maniere=="Seqlab"} {
foreach AA [split $Texte ""] {
lappend LesLettres $AA
if {$AA==" "} { set AA "Space" }
if {$AA=="."} { set AA "Dot" }
if {$AA=="-"} { set AA "Hyphen" }
if {$AA=="~"} { set AA "Tilde" }
lappend LesClasses $AA
}
}
if {$Maniere=="Ftype"} {
set ItemVide "-1 -1 -1 -1 -1 -1"
PositionAutreDe Absolue 1 $Texte
set Fin 0
foreach Item $Ftable {
incr Fin
ScanLaListe $Item Ftype Fstart Fstop Fcolor Fscore Fnote
set AbsPos [regexp "^AbsolutePosition " $Fnote]
if {$AbsPos} {
set AvantProchain [expr $Fstart-1]
set Alpha $Fstart
set Omega $Fstop
} else {
set AvantProchain [expr [PositionAutreDe Relative $Fstart]-1]
set Alpha [PositionAutreDe Relative $Fstart]
set Omega [PositionAutreDe Relative $Fstop]
}
foreach I [NombresEntre $Fin $AvantProchain] {
set ItemEnPosition($I) $ItemVide
}
foreach I [NombresEntre $Alpha $Omega] {
set ItemEnPosition($I) $Item
}
set Fin $Omega
}
incr Fin
set Max [string length $Texte]
if {$Fin<=$Max} {
foreach I [NombresEntre $Fin $Max] {
set ItemEnPosition($I) $ItemVide
}
}
set IGap 0
set Mot ""
if {[info exists OldClasse]} { unset OldClasse }
if {[info exists OldColScoNot]} { unset OldColScoNot }
regsub -all -nocase {[^A-Z]} $Texte "" VraieSeq
foreach AA [split $Texte ""] {
incr IGap
set Item $ItemEnPosition($IGap)
ScanLaListe $Item Ftype Fstart Fstop Fcolor Fscore Fnote
set ColScoNot "$Fcolor $Fscore $Fnote"
set SS "$Fstart-$Fstop"
if {$Fstart==$Fstop} { set SS $Fstart }
if {[regexp "^AbsolutePosition" $Fnote]} { append SS " (absolute position)" }
if {$Fscore!=""} { append SS " $Fscore" }
regsub "^AbsolutePosition " $Fnote "" BelleFnote
set TexteBulle "$Ftype $SS $BelleFnote"
if {$Fcolor=="-1"} { set Classe "C999" } else { set Classe "C$Fcolor" }
if {[info exists OldColScoNot] && $ColScoNot!=$OldColScoNot} {
if {$OldItem==$ItemVide} { set Bulle "No feature" } else { set Bulle $OldTexteBulle }
if {$AvecZones} {
set L [string length $Mot]
set Mot "<img src='http://lbgi.fr/transdot.gif' class='transdot' height='1px' width='${L}px'/>"
lappend LesLettres $Mot
} else {
lappend LesLettres [H_Href $Mot "" "title='$Bulle' alt='$Bulle' name='$Bulle'"]
}
lappend LesClasses $OldClasse
set Mot $AA
set OldColScoNot $ColScoNot
set OldClasse $Classe
set OldItem $Item
set OldTexteBulle $TexteBulle
set OldFnote $Fnote
continue
}
set OldColScoNot $ColScoNot
set OldClasse $Classe
set OldItem $Item
set OldTexteBulle $TexteBulle
set OldFnote $Fnote
append Mot $AA
}
if {$Mot!=""} {
if {$Item==$ItemVide} { set Bulle "No feature" } else { set Bulle $OldTexteBulle }
if {$AvecZones} {
set L [string length $Mot]
set Mot "<img src='http://lbgi.fr/transdot.gif' class='transdot' height='1px' width='${L}px'/>"
lappend LesLettres [H_Href $Mot "" "title='$Bulle' alt='$Bulle' name='$Bulle'"]
} else {
lappend LesLettres [H_Href $Mot "" "title='$Bulle' alt='$Bulle' name='$Bulle'"]
}
lappend LesClasses $Classe
}
}
return [H_ColoredLetters $LesLettres $LesClasses]
}
proc H_StyleImageTransdot {} {
lappend LesClassesValeurs "transdot" "background-image: url(http://lbgi.fr/transdot.gif)"
return [H_StyleClassePourBalise "img" $LesClassesValeurs]
}
proc H_StyleSpanPadding {} {
lappend LesClassesValeurs "" "padding-top:3px; padding-bottom:3px"
return [H_StyleClassePourBalise "span" $LesClassesValeurs]
}
proc H_StyleDesCouleursColSco {} {
lappend LesClassesValeurs "cs0" "color:black ; background:lightgrey;"
lappend LesClassesValeurs "cs1" "color:white ; background:black;"
return [H_StyleClassePourBalise "span" $LesClassesValeurs "WithElement_a"]
}
proc H_StyleDesCouleursSeqlab {} {
foreach {A F B} [LesCouleursSeqlabDesAAs LaListeMerci] {
lappend LesClassesValeurs $A "color:$F ; background:$B;"
}
return [H_StyleClassePourBalise "span" $LesClassesValeurs "WithElement_a"]
}
proc H_StyleDesCouleursFtype {} {
foreach Couleur [CouleurSeqlab "LaListeMerci"] {
set N [CouleurSeqlab $Couleur]
if {$N<0} { set N 999 }
set Classe "C$N"
set Fg "Magenta"
set FgBg [LesCouleursSeqlabDesAAs "fg_and_bg_of_bg_$Couleur"]
scan $FgBg "%s" Fg
lappend LesClassesValeurs $Classe "color:$Fg ; background:$Couleur;"
#rR 2017/11/24
set ClasseCouleur "C$Couleur"
lappend LesClassesValeurs $ClasseCouleur "color:$Fg ; background:$Couleur;"
if {$Couleur!=[string tolower $Couleur]} {
set ClasseCouleur "C[string tolower $Couleur]"
lappend LesClassesValeurs $ClasseCouleur "color:$Fg ; background:$Couleur;"
}
}
return [H_StyleClassePourBalise "span" $LesClassesValeurs "WithElement_a"]
}
proc LesCouleursSeqlabDesAAs {AA {Hexa ""}} {
#rR rajout de Hexa
global LesCouleursSeqlabDesAAs
if {[regexp "fg_and_bg_of_bg" $AA]} { set AA [string tolower $AA] }
if {[string length $AA]==1} {
set AA [string toupper $AA]
}
if {$AA==" "} { set AA "Space" }
if {$AA=="."} { set AA "Dot" }
if {$AA=="-"} { set AA "Hyphen" }
if {$AA=="~"} { set AA "Tilde" }
if {[info exists LesCouleursSeqlabDesAAs($AA,$Hexa)]} {return $LesCouleursSeqlabDesAAs($AA,$Hexa)}
if {[info exists LesCouleursSeqlabDesAAs($AA)]} {return $LesCouleursSeqlabDesAAs($AA)}
if {[info exists LesCouleursSeqlabDesAAs("EstCharge")]} {
if {[regexp "fg_and_bg_of_bg" $AA]} { return "black unknown" }
return $LesCouleursSeqlabDesAAs("EstCharge")
}
lappend AFB I white magenta
lappend AFB L white magenta
lappend AFB M white magenta
lappend AFB V white magenta
lappend AFB R white blue
lappend AFB K white blue
lappend AFB F white red
lappend AFB Y white red
lappend AFB W white red
lappend AFB D white forestgreen
lappend AFB E white forestgreen
lappend AFB Q white green
lappend AFB P white black
lappend AFB G black orange
lappend AFB H black cyan
lappend AFB N black cyan
lappend AFB S white darkviolet
lappend AFB T white darkviolet
lappend AFB A white darkviolet
lappend AFB C white darkviolet
lappend AFB "Space" white darkslategrey
lappend AFB "Dot" white darkslategrey
lappend AFB "Hyphen" white darkslategrey
lappend AFB "Tilde" white darkslategrey
lappend AFB "NoValue" white darkslategrey
set LesCouleursSeqlabDesAAs(LaListeMerci) $AFB
foreach {A F B} $AFB {
lappend LesCouleursSeqlabDesAAs(ListeDesAAs) $A
lappend LesCouleursSeqlabDesAAs(ListeDesFGs) $F
lappend LesCouleursSeqlabDesAAs(ListeDesBGS) $B
set LesCouleursSeqlabDesAAs($A) "$F $B"
set LesCouleursSeqlabDesAAs($A,Hexa) "[ColorHexa $F] [ColorHexa $B]"
set LesCouleursSeqlabDesAAs(fg_and_bg_of_bg_$B) "$F $B"
set LesCouleursSeqlabDesAAs(fg_and_bg_of_bg_$B,hexa) "[ColorHexa $F] [ColorHexa $B]"
}
set LesCouleursSeqlabDesAAs("EstCharge") $LesCouleursSeqlabDesAAs(NoValue)
return [LesCouleursSeqlabDesAAs $AA]
}
proc LaFtableDansLOrdre {NoeudFtable {Quoi ""}} {
if {$Quoi==""} {set Quoi "AllTypes"}
set LesFtype {}
set LesFitem {}
foreach NoeudFitem [$NoeudFtable selectNodes "fitem"] {
set Ftype [$NoeudFitem selectNodes "string(ftype)"]
lappend LesFtype $Ftype
if {$Quoi=="TypeList"} { continue }
set Fstart [$NoeudFitem selectNodes "string(fstart)"]
set Fstop [$NoeudFitem selectNodes "string(fstop)"]
set Fcolor [$NoeudFitem selectNodes "string(fcolor)"]
set Fscore [$NoeudFitem selectNodes "string(fscore)"]
set Fnote [$NoeudFitem selectNodes "string(fnote)"]
if {$Quoi=="$Ftype" || $Quoi=="AllTypes"} {
set Fitem [list $Ftype $Fstart $Fstop $Fcolor $Fscore $Fnote]
lappend LesFitem $Fitem
}
}
if {$Quoi=="TypeList"} {
set LesFtype [lsort -unique $LesFtype]
return $LesFtype
}
set LesFitem [lsort -index 1 -integer $LesFitem]
return $LesFitem
}
proc HtmlFromMsf {NomOuFichier {Format ""} {FichierHtml ""} {TitreDeLaPage ""}} {
set Nom [file tail $NomOuFichier]
while 1 {
set FichierMsf $NomOuFichier
if {[regexp "/" $FichierMsf] && [file exists $FichierMsf]} { break }
if { ! [EstUnPAB $Nom]} { break }
if {[regexp "^/" $NomOuFichier]} { break }
set FichierMsf "[RepertoireDuGenome]/$NomOuFichier"
if {[file exists $FichierMsf]} { break }
set FichierMsf "[RepertoireDuGenome]/msf/$Nom"
if {[file exists $FichierMsf]} { break }
return ""
}
set FichierXml "[TmpFile $Nom].xml"
if {[catch {exec clustalw $FichierMsf -convert -outfile=$FichierXml -output=macsim} Message]} {
return "$Message"
}
if { ! [file exists $FichierXml]} { return "" }
return [HtmlFromXmlMacsim $FichierXml $Format $FichierHtml $TitreDeLaPage]
}
proc ReglePourAli {Largeur {Space ""} {Pointeur ""} {Pas ""} {Debut ""}} {
if {$Space==""} { set Space "\\ " }
if {$Debut==""} { set Debut 1 }
if {$Pas==""} { set Pas 10 }
if {$Pointeur==""} { set Pointeur "." }
if {$Pointeur=="NoPoint"} { set Pointeur "" }
set Regle "$Debut[string repeat " " [expr $Pas-[string length $Debut]-1]]"
set X [expr $Pas-[string length $Pointeur]]
set Format "$Pointeur%-${X}s"
set N $Pas
while {$N<$Largeur} {
append Regle [format $Format $N]
incr N $Pas
}
regsub -all " " $Regle $Space Regle
return $Regle
}
proc CreateAllHtmlFromXmlMacsim {NomOuFichier {Format ""} {RacineForAll ""} {TitreDeLaPage ""}} {
#rR attention inversion des args
return [HtmlFromXmlMacsim $NomOuFichier $Format "CreateAllHtml" $TitreDeLaPage $RacineForAll]
}
proc H_JavascriptPourWaliLite {} {
set LeJs {}
lappend LeJs "<script>"
lappend LeJs "function FontSize (valeur) \{"
lappend LeJs " var size = document.getElementById('divAlignement').style.getPropertyValue('font-size');"
lappend LeJs " var n = parseInt(size);"
lappend LeJs " console.log(valeur);"
lappend LeJs " if (valeur.match(/^\[\-\+\]/)) \{"
lappend LeJs " n = n + parseInt(valeur);"
lappend LeJs " \} else \{"
lappend LeJs " n = parseInt(valeur);"
lappend LeJs " \}"
lappend LeJs " if (n<1) \{ n = 12; \}"
lappend LeJs " document.getElementById('divAlignement').style.fontSize = n+'px';"
lappend LeJs " document.getElementById('FontSizeValue').innerHTML = 'FontSize '+n+' px';"
lappend LeJs "\}"
lappend LeJs ""
lappend LeJs "function ScrollInput (event) \{"
lappend LeJs " console.log(event.keyCode)"
lappend LeJs " console.log(event.which)"
lappend LeJs " var keyPressed = event.keyCode || event.which"
lappend LeJs " console.log(keyPressed)"
lappend LeJs " if ( keyPressed!=13 && keyPressed!=1 ) \{ return false; \}"
lappend LeJs " var valeur = document.getElementById('ScrollInput').value"
lappend LeJs " Scroll(valeur)"
lappend LeJs " return true"
lappend LeJs "\}"
lappend LeJs ""
lappend LeJs "function Scroll (valeur) \{"
#lappend LeJs " var scrollTarget = 'window'"
#lappend LeJs " var scrollTarget = document.getElementById('divAlignement')"
lappend LeJs " var FontSize = parseInt(document.getElementById('divAlignement').style.getPropertyValue('font-size'));"
lappend LeJs " var offset = window.pageXOffset || document.documentElement.scrollLeft;"
lappend LeJs " var offset = scrollTarget.scrollLeft;"
lappend LeJs " console.log(offset);"
lappend LeJs " offset = parseInt(offset);"
lappend LeJs " var delta = (1000./1600.)*parseInt(valeur)*FontSize;"
lappend LeJs " if (valeur.match(/^\[\-\+\]/)) \{"
lappend LeJs " offset = offset + delta;"
lappend LeJs " \} else \{"
lappend LeJs " offset = delta;"
lappend LeJs " \}"
lappend LeJs " if (offset<0) \{ offset = 0; \}"
lappend LeJs " offset = parseInt(offset);"
lappend LeJs " window.scrollTo(offset, 0);"
#lappend LeJs " scrollTarget.scrollTo(offset, 0);"
lappend LeJs " val = offset/((1000./1600.)*FontSize);"
lappend LeJs " document.getElementById('ScrollInput').value = Math.round(val);"
lappend LeJs "\}"
lappend LeJs ""
lappend LeJs "</script>"
set Js [join $LeJs "\n"]
return $Js
}
proc HtmlFromXmlMacsim {NomOuFichier {Format ""} {FichierHtml ""} {TitreDeLaPage ""} {RacineForAll ""} {LinkToPipealign ""}} {
global MemoXmlMacsim
package require tdom
set PathToXmlFile $NomOuFichier
regsub "^paligndepot" $PathToXmlFile "/tempor/palign/depot" PathToXmlFile
regsub "^misynpat" $PathToXmlFile "/home/ripp/msp/data/alignments" PathToXmlFile
#rR il y a des - pour pouvoir mettre des defauts non vides
if {$Format=="-"} { set Format "" }
if {$FichierHtml=="-"} { set FichierHtml "" }
if {$TitreDeLaPage=="-"} { set TitreDeLaPage "" }
if {$RacineForAll=="-"} { set RacineForAll "" }
if {$LinkToPipealign=="-"} { set LinkToPipealign "" }
set WithoutHeader [regexp -nocase "WithoutHeader" $FichierHtml]
if {$WithoutHeader} {
regsub -nocase "WithoutHeader" $FichierHtml "" FichierHtml
}
set WithLinkToPipealign 0
if {$LinkToPipealign!=""} {
set WithLinkToPipealign 1
set Science [file tail [RepertoireDuGenome]]
regsub "/Science/" $LinkToPipealign "/$Science/" LinkToPipealign
}
set AvecZones 0
if {[regexp -nocase "AvecZones" $Format]} {
set AvecZones 1
regsub -nocase "AvecZones" $Format "" Format
}
if {$Format==""} { set Format "Normal" }
set CouleurNormal [string equal -nocase $Format "Normal"]
set CouleurSeqLab [string equal -nocase $Format "SeqLab"]
set CouleurFtype [regexp -nocase "^Ftype_(.+)" $Format Match Ftype]
set DescriptionOnly [string equal -nocase "Description" $Format]
set Nom [file tail $NomOuFichier]
while 1 {
set FichierXml $PathToXmlFile
if {[regexp "/" $FichierXml]} { break }
if { ! [EstUnPAB $Nom]} { break }
set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom"
if {[file exists $FichierXml]} { break }
set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom.xml"
if {[file exists $FichierXml]} { break }
return ""
}
set LinkToRivet 0
if {[regexp -nocase "WithLinkToRivet_(.*)" $FichierHtml Match RivetLink]} {
set LinkToRivet 1
set FichierHtml "DisplayHtml"
}
set LinkToHtml 0
if {[regexp -nocase "WithLinkToHtml_(.*)" $FichierHtml]} {
set LinkToHtml 1
regsub -nocase "WithLinkToHtml_" $FichierHtml "" FichierHtml
}
set CreateAllHtml 0
if {[regexp "CreateAllHtml" $FichierHtml]} {
if {$RacineForAll=="" || $RacineForAll=="-"} { set RacineForAll "${FichierHtml}_" }
set CreateAllHtml 1
}
if {$FichierHtml=="" || $FichierHtml=="-" } { set FichierHtml "GetHtml" }
if {$FichierHtml=="macsimHtml"} {
if {[regexp "/macsimXml/" $FichierXml]} {
regsub "/macsimXml/" $FichierXml "/macsimHtml/" FichierHtml
} else {
set FichierHtml $FichierXml
}
regsub ".xml$" $FichierHtml "" FichierHtml
append FichierHtml ".html"
}
if {0 && [info exists MemoXmlMacsim($FichierXml)]} {
set NoeudMacsim $MemoXmlMacsim($FichierXml)
} else {
set MacsimXml [ContenuDuFichier $FichierXml]
set NoeudMacsim [[dom parse $MacsimXml] documentElement]
set MemoXmlMacsim($FichierXml) $NoeudMacsim
}
set TexteColoring "with $Format colors"
if {$Format=="Normal"} { set TexteColoring "without coloring" }
if {[info proc OnTraiteSpine]!="" && [OnTraiteSpine]} {
set Titre "Gscope summary of $Nom for Spine"
} else {
set Titre $TitreDeLaPage
if {$Titre=="" || $Titre=="-"} {
set DateEnvoi " created [Date Nice]"
set Titre "Wali-lite Macsim's output of $Nom [Alias $Nom] ($TexteColoring) $DateEnvoi"
} else {
append Titre " ($TexteColoring)"
}
}
set Header "<style> a {text-decoration:none;color:black;} body {margin:0px;} #divAlignement {background-color:white;} #Scroll button {font-size:12px;} #Scroll input {font-size:12px; width:3em;} </style>"
set CouleurColSco 1
if {$CouleurColSco} { append Header "\n[H_StyleDesCouleursColSco]" }
if {$CouleurSeqLab} { append Header "\n[H_StyleDesCouleursSeqlab]" }
if {$CouleurFtype} { append Header "\n[H_StyleDesCouleursFtype]" }
if { ! $AvecZones} { append Header "\n[H_StyleSpanPadding]" }
append Header "\n[H_JavascriptPourWaliLite]"
Html_ZeroToBody $Titre $Header
set NoeudAli [$NoeudMacsim selectNodes "alignment"]
set AlnName [$NoeudAli selectNodes "string(aln-name)"]
Html_Append "<div id='Scroll' style='position:fixed; right:10px; top:13em; z-index:1;'>"
Html_Append "Scroll "
Html_Append "<button width='8px' onclick='Scroll(\"-100\");'>-100</button>"
Html_Append "<button onclick='Scroll(\"-10\");'>-10</button>"
Html_Append "<button onclick='Scroll(\"-1\");'>-1</button>"
Html_Append "<input id='ScrollInput' onKeypress='ScrollInput(event)' value='0'/>"
Html_Append "<button onclick='Scroll(\"+1\");'>+1</button>"
Html_Append "<button onclick='Scroll(\"+10\");'>+10</button>"
Html_Append "<button onclick='Scroll(\"+100\");'>+100</button>"
Html_Append "</div>"
Html_Append "<!-- Debut du Header -->"
set PositionPourHeaderFixe [Html_GetPosition]
Html_Append "<div id='headerMobile' style='margin-top:0px;padding:10px 10px 5px 10px;width:100%;background-color:white;'>"
if { ! $WithoutHeader } { Html_Banner Wscope }
if { ! $LinkToHtml && ! $CreateAllHtml } {
if {[OnTraiteSpine]} {
set SpineID [ExtraitInfo $Nom "SpineID"]
set SpineRef [ExtraitInfo $Nom "SpineRef"]
set SpineDef [ExtraitInfo $Nom "SpineDef"]
set Entete $Titre
regsub "Wali\-lite" $Entete "" Entete
set Entete "<img width='50px' src='http://lbgi.fr/wali/images/logoWali'/> <i style='font-size:2em;'>Wali-lite</i> $Entete"
Html_Append [H_BalAtt $Entete "h4" "align='centre'"]
lappend Liste 2
lappend Liste "border='1' cellpadding='1' cellspacing='1'"
lappend Liste ""
lappend Liste "bgcolor='green' nowrap='nowrap'"
lappend Liste "bgcolor='orange' nowrap='nowrap'"
lappend Liste "GscopeID" $Nom
lappend Liste "SpineID" $SpineID
lappend Liste "SpineRef" [H_Href $SpineRef [WgetzSurWeb $SpineRef "" "GetUrl"]]
lappend Liste "SpineDef" $SpineDef
Html_TableFromList $Liste
}
}
set Entete $Titre
regsub "Wali-lite" $Entete "" Entete
set Entete "<img width='50px' src='http://lbgi.fr/wali/images/logoWali'/> <i style='font-size:2em;'>Wali-lite</i> $Entete"
append Entete " "
append Entete "<span onclick='FontSize(\"-1\");'>-</span>"
append Entete " "
append Entete "<span id='FontSizeValue'>FontSize 12 px</span>"
append Entete " "
append Entete "<span onclick='FontSize(\"+1\");'>+</span>"
append Entete " "
append Entete "<span onclick='FontSize(\"1\");'>1</span>"
append Entete " "
append Entete "<span onclick='FontSize(\"5\");'>5</span>"
append Entete " "
append Entete "<span onclick='FontSize(\"8\");'>8</span>"
append Entete " "
append Entete "<span onclick='FontSize(\"10\");'>10</span>"
append Entete " "
append Entete "<span onclick='FontSize(\"12\");'>12</span>"
append Entete " "
append Entete "<span onclick='FontSize(\"14\");'>14</span>"
append Entete " "
append Entete "<span onclick='FontSize(\"18\");'>18</span>"
Html_Append [H_BalAtt $Entete "h4"]
set LaHaut [Html_GetPosition]
Html_Append "</div>"
Html_Append "<!-- Fin du Header -->"
set DivAroundTheTable 0
Html_BaliseOpen "div" "id='divAlignement' style='font-family:courier; font-size:12px;'"
if {$DescriptionOnly} {
Html_BaliseOpen "table" "border='1' cellpadding='1' cellspacing='2'"
set MettreRegleAvant 0
} else {
set DivAroundTheTable 1
Html_BaliseOpen "div" "border='3' style='margin:5px;'"
Html_BaliseOpen "table" "border='0' cellpadding='0' cellspacing='0'"
set MettreRegleAvant 1
}
if {$AvecZones} {set MettreRegleAvant 0}
set TousLesColumnScore {}
foreach NoeudColumnScore [$NoeudAli selectNodes "column-score"] {
if {$AvecZones || $DescriptionOnly} { break }
set ColscoName [$NoeudColumnScore selectNodes "string(colsco-name)"]
set ColscoOwner [$NoeudColumnScore selectNodes "string(colsco-owner)"]
if {$ColscoOwner!=0} { continue }
set ColscoType [$NoeudColumnScore selectNodes "string(colsco-type)"]
set ColscoData [$NoeudColumnScore selectNodes "string(colsco-data)"]
set LesColonnes {}
if {[regexp {core.?block} $ColscoName]} {
foreach Score [split [string trim $ColscoData] " "] {
set Car "?"
if {$Score=="-1"} { set Car "." }
if {$Score=="0"} { set Car "<span class='cs0'>-</span>" }
if {$Score=="1"} { set Car "<span class='cs1'>|</span>" }
lappend LesColonnes $Car
}
} else {
if {[string equal -nocase $ColscoType "int"]} {
set LesCarPourInt "01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ"
foreach Score [split $ColscoData " "] {
set Car [lindex $LesCarPourInt $Score]
if {$Car==""} { set Car "?" }
lappend LesColonnes $Car
}
}
}
set Colonnes [join $LesColonnes ""]
if {$Colonnes!="" && $MettreRegleAvant} {
set MettreRegleAvant 0
set LargeurAlignement [llength $LesColonnes]
Html_BaliseOpen "tr"
Html_BaliseOpen "td"
Html_BaliseClose "td"
Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap'"
Html_Append [ReglePourAli $LargeurAlignement]
Html_BaliseClose "td"
Html_BaliseClose "tr"
}
Html_BaliseOpen "tr"
Html_BaliseOpen "td" "bgcolor='yellow' nowrap='nowrap'"
Html_Append "$ColscoName"
Html_BaliseClose "td"
Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap' onClick='javascript:alert(\\'Column score $ColscoName\\')'"
Html_Append $Colonnes
Html_BaliseClose "td"
Html_BaliseClose "tr"
}
set TousLesFtype {}
set PreviousGroup ""
foreach NoeudSequence [$NoeudAli selectNodes "sequence"] {
set SeqName [$NoeudSequence selectNodes "string(seq-name)"]
set NoeudInfo [$NoeudSequence selectNodes "seq-info"]
set Accession [$NoeudInfo selectNodes "string(accession)"]
set Definition [$NoeudInfo selectNodes "string(definition)"]
set Organisme [$NoeudInfo selectNodes "string(organism)"]
set Group [$NoeudInfo selectNodes "string(group)"]
if {[EstUnAccessPDB $Accession]} {
set Acc $Accession
regsub {_.*} $Acc "" Acc
} else {
set Acc "uniprot:$Accession"
}
#rR attention a verifier car j'y ai mis Uniprot pour depanner.
set Url [WgetzSurWeb "$Acc" "" "GetUrl"]
set SeqData [$NoeudSequence selectNodes "string(seq-data)"]
regsub -all -nocase {[^\.\-a-z]} $SeqData "" SeqData
set SeqData [string toupper $SeqData]
set NoeudFtable [$NoeudInfo selectNodes "ftable"]
if {$NoeudFtable==""} {
set MesFtype {}
set Ftable ""
} else {
set MesFtype [LaFtableDansLOrdre $NoeudFtable "TypeList"]
LConcat TousLesFtype $MesFtype
if {$CouleurFtype} {
set Ftable [LaFtableDansLOrdre $NoeudFtable "$Ftype"]
}
}
if {$MettreRegleAvant} {
set MettreRegleAvant 0
set LargeurAlignement [string length $SeqData]
Html_BaliseOpen "tr"
Html_BaliseOpen "td"
Html_BaliseClose "td"
Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap'"
Html_Append [ReglePourAli $LargeurAlignement]
Html_BaliseClose "td"
Html_BaliseClose "tr"
}
if {$PreviousGroup!=$Group} {
Html_BaliseOpen "tr"
Html_BaliseOpen "td" "style='text-align:right;'"
Html_Append "Group $Group"
Html_BaliseClose "td"
Html_BaliseClose "tr"
}
set PreviousGroup $Group
Html_BaliseOpen "tr"
if {$AvecZones} {
} else {
Html_BaliseOpen "td" "bgcolor='yellow' nowrap='nowrap'"
Html_Href $SeqName $Url "title='$Definition' target='_blank'"
Html_BaliseClose "td"
}
if {$DescriptionOnly} {
Html_BaliseOpen "td" "bgcolor='lightgreen' nowrap='nowrap'"
Html_Append " $Definition "
Html_BaliseClose "td"
Html_BaliseOpen "td" "bgcolor='green' nowrap='nowrap'"
Html_Append " $Organisme "
Html_BaliseClose "td"
} else {
Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap' \
onClick='javascript:alert(\\'$SeqName $Definition $Organisme\\')'"
if {$CouleurNormal} { Html_Append [LaSequenceColoree $SeqData "Normal"] }
if {$CouleurSeqLab} { Html_Append [LaSequenceColoree $SeqData "Seqlab"] }
if {$CouleurFtype} { Html_Append [LaSequenceColoree $SeqData "Ftype" $Ftable $AvecZones] }
Html_BaliseClose "td"
}
Html_BaliseClose "tr"
}
if { ! $DescriptionOnly && ! $AvecZones} {
Html_BaliseOpen "tr"
Html_BaliseOpen "td"
Html_BaliseClose "td"
Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap'"
Html_Append [ReglePourAli $LargeurAlignement]
Html_BaliseClose "td"
Html_BaliseClose "tr"
}
if {$DivAroundTheTable} { Html_BaliseClose "div" }
Html_BaliseClose "table"
Html_BaliseClose "span"
set AvecATV [file exists "[RepertoireDuGenome]/phylos"]
set AvecAutresBoutons [expr $WithLinkToPipealign || [OnTraiteSpine] || [OnTraiteBalibase] || [OnTraitePeroxisome] \
|| [MacsimExiste] || [OnTraite "KoAnno"]]
set LesBoutons {}
if {$AvecAutresBoutons} {
if { ! $LinkToHtml && ! $CreateAllHtml } {
lappend LesBoutons "Other infos" "FileMoi $Nom"
lappend LesBoutons "Description" "HtmlFromXmlMacsim $Nom Description"
if {$AvecATV} {
lappend LesBoutons "ATV PhyloTree" "ATV $Nom"
}
}
#rR je ne comprends pas bien comment c'était foutu avant car le if de AvecAutresBoutons couvrait toute la création des boutons Ftype :(
}
set LinkM $LinkToPipealign
set LinkS $LinkToPipealign
if {[regexp {^/pampas/} $LinkToPipealign]} {
regsub {/Macsims/*} $LinkM "/Macsims/-" LinkM
regsub {/Macsims/*} $LinkS "/Macsims/SeqLab" LinkS
}
lappend LesBoutons "No colors" "HtmlFromXmlMacsim $NomOuFichier - $FichierHtml $TitreDeLaPage $RacineForAll $LinkM"
lappend LesBoutons "AA colors" "HtmlFromXmlMacsim $NomOuFichier SeqLab $FichierHtml $TitreDeLaPage $RacineForAll $LinkS"
set TousLesFtype [lsort -unique $TousLesFtype]
foreach Ftype $TousLesFtype {
lappend LesBoutons "$Ftype" "HtmlFromXmlMacsim $NomOuFichier Ftype_$Ftype $FichierHtml $TitreDeLaPage $RacineForAll $LinkToPipealign"
}
Html_NewLine
set LeMenu {}
lappend LeMenu [Html_BaliseOpen "table" "border='1' cellpadding='1' cellspacing='3'"]
lappend LeMenu [Html_BaliseOpen "tr"]
foreach {Text Action} $LesBoutons {
if {$LinkToHtml || $CreateAllHtml} {
set Quoi [lindex [split $Action " "] 2]
set Queue [file tail $RacineForAll]
set RfA $RacineForAll
if {$RfA=="-"} { set RfA "" }
if {$Queue=="-"} { set Queue "" }
set UrlAction "${Queue}_$Quoi.html"
if {$CreateAllHtml && ! [info exists DejaFait($Quoi)]} {
set WH "" ; if {$WithoutHeader} { set WH "WithoutHeader" }
lappend AllHtml [HtmlFromXmlMacsim $FichierXml $Quoi "${WH}WithLinkToHtml_${RfA}_$Quoi.html" $TitreDeLaPage $RacineForAll]
set DejaFait($Quoi) 1
}
} elseif {$WithLinkToPipealign} {
if {[regexp {^/pampas/} $LinkToPipealign]} {
set FT [lindex [split $Action " "] 2]
set UrlAction $LinkToPipealign
regsub {/Macsims.*$} $UrlAction "/Macsims/$FT" UrlAction
} else {
set UrlAction "$LinkToPipealign?$Action"
}
regsub -all " " $UrlAction {\&} UrlAction
} elseif {$LinkToRivet} {
set UrlAction "$RivetLink?$Action WithLinkToRivet_$RivetLink"
} else {
regsub -all " " $Action {\&} Action
set UrlAction "[WscopeScience]&$Action"
}
lappend LeMenu [Html_BaliseOpen "td" "bgcolor='yellow' nowrap='nowrap'"]
lappend LeMenu [Html_Href $Text $UrlAction "title='Reload alignment'"]
lappend LeMenu [Html_BaliseClose "td"]
}
lappend LeMenu [Html_BaliseClose "tr"]
lappend LeMenu [Html_BaliseOpen "tr"]
foreach {Text Action} $LesBoutons {
if {[regexp "Ftype_" $Action]} {
regsub "Ftype_" $Action "AvecZonesFtype_" Action
set Text "no text"
}
if {$LinkToHtml || $CreateAllHtml} {
set Quoi [lindex [split $Action " "] 2]
set Queue [file tail $RacineForAll]
set UrlAction "${Queue}_$Quoi.html"
if {$CreateAllHtml && ! [info exists DejaFait($Quoi)]} {
set WH "" ; if {$WithoutHeader} { set WH "WithoutHeader" }
lappend AllHtml [HtmlFromXmlMacsim $FichierXml $Quoi "${WH}WithLinkToHtml_${RacineForAll}_$Quoi.html" $TitreDeLaPage $RacineForAll]
}
} elseif {$WithLinkToPipealign} {
if {[regexp {^/pampas/} $LinkToPipealign]} {
set FT [lindex [split $Action " "] 2]
set UrlAction $LinkToPipealign
regsub {/Macsims.*$} $UrlAction "/Macsims/$FT" UrlAction
} else {
set UrlAction "$LinkToPipealign?$Action"
}
regsub -all " " $UrlAction {\&} UrlAction
} elseif {$LinkToRivet} {
set UrlAction "$RivetLink/$Action WithLinkToRivet_$RivetLink"
} else {
regsub -all " " $Action {\&} Action
set UrlAction "[WscopeScience]&$Action"
}
lappend LeMenu [Html_BaliseOpen "td" "bgcolor='yellow' nowrap='nowrap'"]
lappend LeMenu [Html_Href $Text $UrlAction "title='Reload alignment'"]
lappend LeMenu [Html_BaliseClose "td"]
}
lappend LeMenu [Html_BaliseClose "tr"]
lappend LeMenu [Html_BaliseClose "table"]
lappend LeMenu [Html_NewLine]
Html_Insert $LaHaut [join $LeMenu "\n"]
#rR la fin du if AvecAutresBoutons était là !!!!!!!!!!!!!!!!! pourquoi ??????
set HtmlDejaFait [Html_Get]
if {[regexp {<!\-\- Debut du Header \-\->(.*)<!\-\- Fin du Header \-\->} $HtmlDejaFait Match HeaderMobile]} {
regsub "<div id='headerMobile' style='" $HeaderMobile "<div id='headerMobile' style='position:fixed;" HeaderFixe
Html_Insert $PositionPourHeaderFixe $HeaderFixe
}
Html_BodyToEnd
if {$CreateAllHtml} { return [join $AllHtml "\n"] }
if {$FichierHtml=="GetHtml"} { return [Html_Get] }
if {$FichierHtml=="ShowHtml"} { return [AfficheVariable [Html_Get] "" "macsimHtml/$Nom"] }
if {$FichierHtml=="DisplayHtml"} { puts [Html_Get]; return [Html_Get "ZeroIt"] }
return [Sauve [Html_Get] dans $FichierHtml]
}
proc MergeXmlForSpinePourTous {} {
foreach Nom [ListeDesPABs] {
MergeXmlForSpine $Nom
}
}
proc MergeXmlForSpine Nom {
set FichierXmlFromSpine "[RepertoireDuGenome]/XmlFromSpine/$Nom"
set FichierMacsimXml "[RepertoireDuGenome]/macsimXml/$Nom"
if { ! [file exists $FichierXmlFromSpine] || \
! [file exists $FichierMacsimXml]} { return "" }
set OneSpineXML [ContenuDuFichier $FichierXmlFromSpine]
set NoeudTarget [[dom parse $OneSpineXML] documentElement]
set ID [$NoeudTarget selectNodes "string(ID)"]
set Workpackage [$NoeudTarget selectNodes "string(workpackage)"]
set Workpackage [string trim $Workpackage]
set Sequence [$NoeudTarget selectNodes "string(sequence)"]
set ProteinName [$NoeudTarget selectNodes "string(proteinName)"]
set Species [$NoeudTarget selectNodes "string(species)"]
set LesNar {}
foreach NoeudDbID [$NoeudTarget selectNodes "databaseID"] {
set DatabaseID [$NoeudDbID selectNodes "string(.)"]
set Database [$NoeudDbID selectNodes "string(database)"]
set Release [$NoeudDbID selectNodes "string(release)"]
set Accession [$NoeudDbID selectNodes "string(accession)"]
set DB $Database
if {$Database=="not provided"} { set DB "unk" }
if {$Accession=="" || $Accession=="not provided"} {
set MonNar ""
} else {
set MonNar "$DB:$Accession"
}
lappend LesNar $MonNar
}
set Nar [join $LesNar ","]
set TexteOS ""
if {$Species!="" || $Species!="not provided"} {
set TexteOS "of $Species"
}
set MacsimXml [ContenuDuFichier $FichierMacsimXml]
set NoeudMacsim [[dom parse $MacsimXml] documentElement]
set NoeudAli [$NoeudMacsim selectNodes "alignment"]
set AlnName [$NoeudAli selectNodes "string(aln-name)"]
foreach NoeudSequence [$NoeudAli selectNodes "sequence"] {
set SeqName [$NoeudSequence selectNodes "string(seq-name)"]
if {$SeqName==$Nom} { break }
}
if {$SeqName!=$Nom} {
FaireLire "I can't find the seq-name $Nom in $FichierMacsimXml"
return ""
}
set Organism [$NoeudSequence selectNodes "string(seq-info)"]
return
}
proc DoctypeForOneSpineTarget {} {
return {<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE target SYSTEM "target.dtd">
}
}
proc ReadAllSpineXML {{Action ""} {Fichier ""}} {
Wup "Action can be 'ShowOnly' , 'CompareHeaders' or 'Append"
if {$Action==""} { set Action "ShowOnly" }
package require tdom
if {$Action=="Append"} {
set DernierPAB [DernierPAB "EnNumero"]
regsub "SPINE" $DernierPAB "" Numero
set Fin [Box $DernierPAB fin]
FaireLire "Please browse for the Xml file with the targets to append"
if {$Fichier==""} {
set Fichier [ButineArborescence All "[RepertoireDuGenome]/DeSpine/"]
}
} else {
set Numero 100000
set Fin 100
if {$Fichier==""} {
FaireLire "Please browse for the Xml file with all targets"
set Fichier [ButineArborescence All "[RepertoireDuGenome]/DeSpine/"]
}
}
if { ! [file exists $Fichier]} { return "" }
if { $Action=="Append" && ! [OuiOuNon "Are you sure to run \n\
ReadAllSpineXML $Fichier\n\
creating new PABs after $DernierPAB"]} { return "" }
set RepXmlFromSpine "[RepertoireDuGenome]/XmlFromSpine"
if { ! [file exists RepXmlFromSpine]} { file mkdir $RepXmlFromSpine }
set AllSpineXML [ContenuDuFichier $Fichier]
set Root [[dom parse $AllSpineXML] documentElement]
set LesNoeudsTarget [$Root selectNodes "//target"]
foreach NoeudTarget $LesNoeudsTarget {
incr Numero 10
set OneTargetXml [DoctypeForOneSpineTarget]
append OneTargetXml [$NoeudTarget asXML -indent 2]
set ID [$NoeudTarget selectNodes "string(ID)"]
set Workpackage [$NoeudTarget selectNodes "string(workpackage)"]
set Workpackage [string trim $Workpackage]
set Sequence [$NoeudTarget selectNodes "string(sequence)"]
set ProteinName [$NoeudTarget selectNodes "string(proteinName)"]
set Species [$NoeudTarget selectNodes "string(species)"]
set LesNar {}
foreach NoeudDbID [$NoeudTarget selectNodes "databaseID"] {
set DatabaseID [$NoeudDbID selectNodes "string(.)"]
set Database [$NoeudDbID selectNodes "string(database)"]
set Release [$NoeudDbID selectNodes "string(release)"]
set Accession [$NoeudDbID selectNodes "string(accession)"]
set DB $Database
if {$Database=="not provided"} { set DB "unk" }
if {$Accession=="" || $Accession=="not provided"} {
set MonNar ""
} else {
set MonNar "$DB:$Accession"
}
lappend LesNar $MonNar
}
set Nar [join $LesNar ","]
set TexteOS ""
if {$Species!="" || $Species!="not provided"} {
set TexteOS "of $Species"
}
set Nom "SPINE[format "%5.5d" $Numero]"
set Entete "$Nom SpineRef ($Nar) SpineDef ($ProteinName $TexteOS) SpineID ($ID of $Workpackage)"
if {$Action=="CompareHeaders"} {
set FichierTFA "[RepertoireDuGenome]/prottfa/$Nom"
set EnteteGscope [EnteteDuFichierTFA $FichierTFA]
regsub ">" $EnteteGscope "" EnteteGscope
if {$Entete!=$EnteteGscope} {
FaireLire "$Entete\n$EnteteGscope"
}
continue
}
if {$Action=="ShowOnly"} {
lappend LesEntetes $Entete
continue
}
if {$Action!="Append"} {
FaireLire "Illegal Action $Action in ReadAllSpineXml\nI'll create nothing !"
}
set FichierXmlFromSpine "$RepXmlFromSpine/$Nom"
Sauve $OneTargetXml dans $FichierXmlFromSpine
set TFA [SequenceFormatTFA $Sequence $Entete "protbrut"]
Sauve $TFA dans "[RepertoireDuGenome]/prottfa/$Nom"
set Debut [expr $Fin + 99]
set Fin [expr $Debut + 300]
set Orient "F"
Espionne "MiseAJourBornesDesPABs $Nom $Debut $Fin $Orient"
MiseAJourBornesDesPABs "$Nom $Debut $Fin $Orient"
}
if {$Action=="ShowOnly"} {
set Page [join $LesEntetes "\n"]
return [AfficheVariable $Page "GrandeLargeur" "AllSpineHeaders"]
}
exit
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.