Index by: file name |
procedure name |
procedure call |
annotation
gscope_html.tcl
(annotations | original source)
#rR gscope_html.tcl
#rR il y a ici des procedures H_Xyz et HTMl_Xyz
#rR les H_Xyz creent du html et le rendent
#rR les Html_Xyz creent du html et le rajoutent a une variable globale qui s'appelle H (c'est debile je sais)
#rR tout n'est pas vraiment bien fait ... il y a souvent un melange des deux.
#rR a priori certaines des Html_Xyz rendent que ce qu'elle ont rajoute
#rR Html_Get rend tout
#rR Html_Get ZeroIt rend tout et annule le H
proc GetPdbForNgl {{Access ""}} {
return [TextePDB $Access All "" "OnTheWeb"]
}
proc NglViewer {FichierPdb} {
set Site [ZincrSite]
LogWscope "site=$Site FileToViewWithNgl=$FichierPdb"
set Html [Chabada "TemplateNglWali.html" "_site_=$Site" "_FileToViewWithNgl_=$FichierPdb" ]
return $Html
}
proc Html_SymTree LesGD {
#rR Crée un html avec deux colonnes, celle de gauche cadrée à droite et inversement (en sapin).
set Css "
<style type='text/css'>
.SymTree {
width:100%;
}
.SymTree * {
vertical-align:middle;
}
.SymTree td {
padding-top:0.5em;
padding-bottom:0.5em;
}
.SymTree tr td:first-child {
padding-right:0.5em;
width:50%;
text-align:right;
}
.SymTree tr td:nth-child(2) {
padding-left:0.5em;
width:50%;
}
</style>
"
set LeHtml {}
lappend LeHtml $Css
lappend LeHtml "<table class='SymTree'>"
lappend LeHtml " <tbody>"
foreach {G D} $LesGD {
if {$G==""} { set G " " }
if {$D==""} { set D " " }
lappend LeHtml " <tr>"
lappend LeHtml " <td>"
lappend LeHtml $G
lappend LeHtml " </td>"
lappend LeHtml " <td>"
lappend LeHtml $D
lappend LeHtml " </td>"
lappend LeHtml " </tr>"
}
lappend LeHtml " </tbody>"
lappend LeHtml "</table>"
set Html [join $LeHtml "\n"]
return $Html
}
proc CurlOLDmarchePAS {Url {Fichier ""} {FicOut ""}} {
#rR ne marche pas encore. Voir gscope_bird avec BirdFromQueryFile
package require http
set Queue [file tail $Fichier]
set Query [::http::formatQuery "upload" [ContenuDuFichier $Fichier]]
set Headers [list \
Content-type application/octet-stream \
Content-Disposition "inline; filename=\"$Queue\"" \
Content-Transfer-Encoding binary \
]
Espionne $Query
Espionne $Headers
set GetText 0
if {$FicOut==""} { set FicOut "GetText" }
if {$FicOut=="GetText"} { set GetText 1 ; set FicOut [TmpFile] }
#rR from Kroc http://wfr.tcl.tk/1409
set fout [open $FicOut w]
set tok [::http::geturl $Url -headers $Headers -query $Query -binary 1 -channel $fout]
::http::wait $tok
close $fout
if { ! $GetText} { return $FicOut }
set Texte [ContenuDuFichier $FicOut]
file delete $FicOut
return $Texte
}
proc Wget {url args} {
#rR from Kroc http://wfr.tcl.tk/1409
# Nom du fichier de sortie :
if {[llength $args] && [lindex $args 0] eq "-O"} {
set fichier [lrange $args 1 end]
} else {
set fichier [file tail $url]
}
# Téléchargement :
if {![catch {
package require http
set fout [open $fichier w]
set tok [http::geturl $url -binary 1 -channel $fout]
http::wait $tok
close $fout
}]} {
return [expr [http::ncode $tok] != 200]
}
return 1
}
proc Pubmed {PubmedId {What ""}} {
if {$What==""} {
set What "GetText"
if {[PourWscope]} { set What "GetHtml" }
}
set PubmedId [join $PubmedId ","]
regsub -all " +" $PubmedId "," PubmedId
set Url http://www.ncbi.nlm.nih.gov/pubmed/$PubmedId?report=medline&format=text
if {[catch {set Texte [ContenuDuFichier $Url]} Message]} {
return "ErrorPubmed: I got the message $Message"
}
if {$What=="GetHtml"} { return $Texte }
set BonTexte ""
if {[regexp {<pre>(.*)</pre>} $Texte Match BonTexte]} { set Texte $BonTexte }
if {$What=="GetText"} { return $BonTexte }
if {$What=="GetList"} { return [split $BonTexte "\n"] }
append BonTexte "\nZZZZZZ - Bidon"
set OldK ""
foreach Ligne [split $BonTexte "\n"] {
if {[regexp {^([A-Z]+) *\- (.*)} $Ligne Match K Info]} {
if {$OldK!=""} { lappend LesInfosDe($OldK) $CurrentInfo }
set CurrentInfo $Info
set OldK $K
continue
}
append CurrentInfo " [string trim $Ligne]"
}
if {[info exists LesInfosDe(TI)] } { set LesInfosDe(Title) [lindex $LesInfosDe(TI) 0] }
if {[info exists LesInfosDe(AB)] } { set LesInfosDe(Abstract) [lindex $LesInfosDe(AB) 0] }
if {[info exists LesInfosDe(DP)] } { set LesInfosDe(Date) [lindex $LesInfosDe(DP) 0] }
if {[info exists LesInfosDe(SO)] } { set LesInfosDe(Journal) [lindex $LesInfosDe(SO) 0] }
if {[info exists LesInfosDe(AU)] } { set LesInfosDe(Authors) [join $LesInfosDe(AU) ";"] }
if {[info exists LesInfosDe(FAU)]} { set LesInfosDe(FullAuthors) [join $LesInfosDe(FAU) ";"] }
if {[info exists LesInfosDe(AU)] } { set LesInfosDe(FirstAuthor) [lindex $LesInfosDe(AU) 0] }
if {[info exists LesInfosDe(AU)] } { set LesInfosDe(LastAuthor) [lindex $LesInfosDe(AU) end] }
if {[info exists LesInfosDe(FAU)]} { set LesInfosDe(FirstFullAuthor) [lindex $LesInfosDe(FAU) 0] }
if {[info exists LesInfosDe(FAU)]} { set LesInfosDe(LastFullAuthor) [lindex $LesInfosDe(FAU) end] }
if {[info exists LesInfosDe($What)]} { return $LesInfosDe($What) }
return ""
}
proc WebInforme Nom {
#rR je ne sais pas qui l'utilise !!
set Info [ExtraitInfo $Nom]
Html_ZeroToBody
Html_Banner Wscope
Html_BackTo $Nom
Html_Append "<br/>"
Html_Append "<h3>"
Html_Append "Search any string within the infos files of [Science]"
Html_Append "<br/> to search a Gene Name exactly, use the search string '<tt>ValiGN: Pax6</tt>' (with ':' and one space)"
Html_Append "</h3>"
Html_Append "<form style=\"border:2px solid black; padding:15px;\" action='[WscopeScience]' method='POST'>"
Html_Append " <p>"
Html_Append " <input type='hidden' name='science' value='[Science]'>"
Html_Append " <input type='hidden' name='procedure' value='RepereBoxEtFileMoi'>"
Html_Append " <label for='SearchString'>Search string : </label>"
Html_Append " <input type='text' name='SearchString' id='SearchString' value=''>"
Html_Append " "
Html_Append " <select name='WhichOne'>"
Html_Append " <option>ListAll</option>"
Html_Append " <option>FirstOne</option>"
Html_Append " <option>NextOne</option>"
Html_Append " </select>"
Html_Append " "
Html_Append " <label for='SynonymString'>GeneName Synonym : </label>"
Html_Append " <input type='text' name='SynonymString' id='SynonymString' value=''>"
Html_Append " "
Html_Append " <input type='submit' value='Search'>"
Html_Append " </p>"
Html_Append "</form>"
#LP
if {[OnTraite "EVImm"]} {
Html_Append "<h3>or do a blast search</h3>"
Html_Append "<iframe src=\"[LbgiUrl]/~gagniere/BlastEVI/index.php\" style=\"width:100%; height:450px;\"></iframe>"
}
#LP
Html_BodyToEnd
return [Html_Get]
}
proc WscopeWebForm args {
global PagePropre
set Fenetre ""
set LaSelection {}
set Bouton ""
set TexteB ""
set VarToSet ""
foreach {k v} $args {
if {$k=="fenetre"} {
set Fenetre $v
continue
}
if {$k=="selectedlines"} {
regsub -all {\[} $v "\\\[" v
regsub -all {\]} $v "\\\]" v
regsub -all {\"} $v "\\\"" v
regsub -all {\$} $v "\\\$" v
lappend LaSelection $v
continue
}
set Bouton $k
set TexteB $v
if {$k=="vartoset"} {
set VarToSet $v
}
}
regsub "_" $Fenetre "." PFenetre
set Selection [join $LaSelection "\n"]
set LesInfosDuBouton [TouchePourWscope "LesInfosDuBouton" $Bouton]
if {$LesInfosDuBouton=={}} {
return [GuideMoi "Sorry, it seems the Gscope process was canceled on the server. I just restarted it, running a new session."]
}
lassign $LesInfosDuBouton Clavier Texte Commande Maniere Couleur
regsub {\[selection get\]} $Commande "\"$Selection\"" Commande
# LogWscope [string range $Commande 0 100]
if {[regexp {set VariableDeRetour\(([^\)]+)\) (.*)} $Commande Match Var Val]} {
set Val [string trim $Val "\""]
global VariableDeRetour ; set VariableDeRetour($Var) $Val ;#rR servira peut etre un jour
if {$VarToSet!=""} { global $VarToSet ; set $VarToSet $Val }
return "Please kill this window and go back to the calling window to continue your Job"
return "<script language='javascript'>window.close()</script>'"
}
LogWscope [string range $Commande 0 1000]
if {[catch {set R [eval $Commande]} Message]} { LogWscope $Message; return $Message }
if {$R==""} { set R "Nothing to display" }
return $R
}
proc TouchePourWscope {QuoiOuClavier {QuiOuTexte ""} {Commande ""} {Maniere ""} {Couleur ""}} {
global TouchePourWscope
#rR TouchePourWscope est appele au fur et a mesure de la contruction des boutons par AfficheVariable
#rR il sera interroge ensuite pour creer la WebForm
#rR et puis pour traiter l'appel utilisateur
#rR Finalement detruit par Dismiss si tout est fait dans les regles de l'art
#rR cas ou il faut rendre qq chose *************************************************************************
set Quoi $QuoiOuClavier
set Qui $QuiOuTexte
set Retour "OnNeDemandeRien"
if {[regexp "LesInfosDuBouton" $Quoi]} {
set Bouton $Qui
set Fenetre ""
regexp {_[^_]+} $Bouton Fenetre
set Retour ""
if {[info exists TouchePourWscope($Fenetre,$Bouton)]} { set Retour $TouchePourWscope($Fenetre,$Bouton) }
return $Retour
}
if {[regexp "LesBoutonsDeLaFenetre" $Quoi]} {
set Fenetre $Qui
if {[info exists TouchePourWscope($Fenetre,Boutons)]} { set Retour $TouchePourWscope($Fenetre,Boutons) }
}
if {[regexp "RemiseAZero" $Quoi]} {
set Fenetre $Qui
if {[info exists TouchePourWscope($Fenetre)]} {
foreach k $TouchePourWscope($Fenetre) {
if {[info exists TouchePourWscope($Fenetre,$k)]} { unset $TouchePourWscope($Fenetre,$k) }
}
unset TouchePourWscope($Fenetre)
}
return $Retour
}
if {$Retour!="OnNeDemandeRien"} { return $Retour }
#rr fin cas rendre qq chose ********************************************************************************
set Clavier $QuoiOuClavier
regsub -all {[\.\-]} $Clavier "_" Clavier
if { ! [info exists TouchePourWscope(IndexTouche)]} { set TouchePourWscope(IndexTouche) 0 }
incr TouchePourWscope(IndexTouche)
set Texte $QuiOuTexte
if {[regexp "NoWeb" $Maniere]} { return "" }
set Fenetre ""
if {[info exists TouchePourWscope(FenetreCourante)]} { set Fenetre $TouchePourWscope(FenetreCourante) }
if {[regexp {_[^_]+} $Clavier FenetreDuClavier]} { set Fenetre $FenetreDuClavier }
set TouchePourWscope(FenetreCourante) $Fenetre
if {[regexp {^<([^>]+)>} $Clavier Match NumTouche]} {
set Clavier $TouchePourWscope(ClavierCourant)
append Clavier $NumTouche
} else {
set TouchePourWscope(ClavierCourant) $Clavier
append Clavier "1"
}
append Clavier "_$TouchePourWscope(IndexTouche)"
if {$Texte=="NouvelleGamme"} {
lappend TouchePourWscope($Fenetre,Boutons) "NouvelleGamme"
return ""
}
if {$Texte=="NouvelleCouleur"} {
set TouchePourWscope(Couleur) $Commande
return $TouchePourWscope(Couleur)
}
if {$Couleur==""} {
if { ! [regexp {^ */} $Texte] && [info exists TouchePourWscope(PropreCouleur)]} {unset TouchePourWscope(PropreCouleur) }
if { ! [info exists TouchePourWscope(Couleur)]} { set TouchePourWscope(Couleur) "red" }
set Couleur $TouchePourWscope(Couleur)
} else {
if { ! [regexp {^ */} $Texte]} { set TouchePourWscope(PropreCouleur) $Couleur }
}
if {[info exists TouchePourWscope(PropreCouleur)]} { set Couleur $TouchePourWscope(PropreCouleur) }
set LesInfosDuBouton [list $Clavier $Texte $Commande $Maniere $Couleur]
set TouchePourWscope($Fenetre,$Clavier) $LesInfosDuBouton
lappend TouchePourWscope($Fenetre,Boutons) $LesInfosDuBouton
return $Clavier
}
proc Html_TouchePour LesBoutons {
set Local {}
lappend Local "<div styrl='border:1px;'>"
set CreateDiv 1
set CloseDiv 0
foreach Bouton $LesBoutons {
lassign $Bouton Clavier Texte Commande Maniere Couleur
if {$Couleur=="grey"} { set Couleur "lightgrey" }
if {$Couleur=="green"} { set Couleur "lightgreen" }
if {$Clavier=="NouvelleGamme"} {
if {$CloseDiv} { lappend Local "</div>" ; set CloseDiv 0 }
set CreateDiv 1
continue
}
regsub "^ */" $Texte "" NiceTexte
set W1 "30ex"
set W21 "16ex" ; set W22 "14ex"
set W31 "16ex" ; set W32 "8ex" ; set W33 "6ex"
set OnClique "onclick='jeClique(\"$NiceTexte\");'"
if {[regexp "^onclick='" $Commande]} { regsub "^onclick='" $Commande "onclick='jeClique(\"$NiceTexte\");" OnClique }
set B "<input $OnClique style='width:$W1;margin:0px 0ex 0px 0ex;background-color:$Couleur;' name='$Clavier' id='$Clavier' type='submit' value='$NiceTexte'/>"
if {[regexp "^ */" $Texte]} {
set OldB [lindex $Local end]
if {[regexp "width:$W1;" $OldB]} {
regsub "width:$W1;" $OldB "width:$W21;" NewOldB
set Local [lreplace $Local end end]
regsub "width:$W1;" $B "width:$W22;" B
set B $NewOldB$B
}
if {[regexp "width:$W22;" $OldB]} {
regsub "width:$W22;" $OldB "width:$W32;" OldB
regsub "width:$W21;" $OldB "width:$W31;" OldB
set Local [lreplace $Local end end]
regsub "width:$W1;" $B "width:$W33;" B
set B $OldB$B
}
lappend Local $B
continue
}
if {$CreateDiv} {
lappend Local "<div style=''>"
set CloseDiv 1
set CreateDiv 0
} else {
lappend Local "<br/>"
}
lappend Local $B
}
if {$CloseDiv} { lappend Local "</div>" ; set CloseDiv 0}
lappend Local "</div>"
return [join $Local "\n"]
}
proc Html_Listbox {Texte {Fenetre ""} {Titre ""} {Maniere ""}} {
global VariableToSetForWscope
set VariableToSet ""
if {[info exists VariableToSetForWscope]} { set VariableToSet $VariableToSetForWscope }
set ClasseDuSelect ""
if {[regexp "AvecRetour" $Maniere]} { set ClasseDuSelect "style='background:lightgreen;'" }
set LesOptions {}
set BonTexte [Html_Teletype $Texte "WithoutPre"]
set Width 50
set NbLignes 5
foreach Ligne [split $BonTexte "\n"] {
set Width [Maxi $Width [string length $Ligne]]
regsub -all " " $Ligne {\ } LigneAvecBlanc
regsub -all {\*} $Ligne "\%2A" Ligne
lappend LesOptions "<option class='courier' value='$Ligne'>$LigneAvecBlanc</option>"
incr NbLignes
}
set Options [join $LesOptions "\n"]
incr Width 2
if {$Width >70} { set Width 70 }
set Height $NbLignes
if {$Height>40} { set Height 40 }
regsub -all {[\.\-]} $Fenetre "_" Fenetre
lappend Local "<script language='javascript'>"
lappend Local "var quiClique='NoBody';"
lappend Local "function jeClique(qui) \{ quiClique = qui; \}"
lappend Local "function killWindowIfDismiss () \{ "
lappend Local " if (quiClique==='Dismiss') \{ "
lappend Local " setTimeout(\"window.close()\",1000);"
lappend Local " return false;"
lappend Local " \}"
lappend Local " if (quiClique==='Validate sel.' || quiClique==='Validate') \{ "
lappend Local " setTimeout(\"window.close()\",1000);"
lappend Local " \}"
lappend Local " if (quiClique==='Select all') \{ "
lappend Local " return false;"
lappend Local " \}"
lappend Local " return true; "
lappend Local "\}"
lappend Local "function selectAll() \{"
lappend Local " var listBox = document.getElementById('DoOnListSelect');"
lappend Local " for(i=0; i<listBox.length; i++) \{"
lappend Local " listBox.options\[i\].selected='selected';"
lappend Local " \}"
lappend Local " return false;"
lappend Local "\}"
lappend Local "</script>"
lappend Local "<div style='margin-left:10%;'>"
lappend Local "<form target='_blank' onsubmit='return killWindowIfDismiss();' action='[WscopeScience]' method='POST'>"
lappend Local "<input type='hidden' name='science' value='[Science]'>"
lappend Local "<input type='hidden' name='procedure' value='WscopeWebForm'/>"
lappend Local "<input type='hidden' name='fenetre' value='$Fenetre'/>"
lappend Local "<input type='hidden' name='vartoset' value='$VariableToSet'/>"
lappend Local "<table border='1'><tbody><tr>"
lappend Local "<td valign='top'>"
lappend Local [Html_TouchePour [TouchePourWscope "LesBoutonsDeLaFenetre" $Fenetre]]
lappend Local "</td>"
lappend Local "<td valign='top'>"
if {[regexp "PourInforme" $Maniere]} {
lappend Local "<textarea id='DoOnListSelect' name='selectedlines' cols=150 rows=30 $ClasseDuSelect>"
lappend Local $BonTexte
lappend Local "</textarea>"
} else {
lappend Local "<select class='courier' id='DoOnListSelect' name='selectedlines' $ClasseDuSelect multiple "
lappend Local " size='$Height' style='overflow:auto;'>"
lappend Local $Options
lappend Local "</select>"
}
lappend Local "</td>"
lappend Local "</tr><tbody></table>"
lappend Local "</form>"
lappend Local "</div>"
return [join $Local "\n"]
}
proc Html_TextToListbox {{TexteOuNomDuFichier ""} {Fenetre ""} {Titre ""} {Header ""} {RefDocType ""} {Maniere ""}} {
if {[regexp " " $TexteOuNomDuFichier] || ! [file exists $TexteOuNomDuFichier]} {
set NomDuFichier "Raw text"
set Texte $TexteOuNomDuFichier
} else {
set NomDuFichier $TexteOuNomDuFichier
set Texte [ContenuDuFichier $NomDuFichier]
}
if {$Titre==""} { set Titre $NomDuFichier }
lappend Local [Html_Zero]
lappend Local [Html_Doctype $RefDocType]
lappend Local [Html_BeginHtml]
lappend Local [Html_Header $Titre $Header]
lappend Local [Html_BeginBody]
lappend Local [Html_Banner Wscope]
lappend Local [Html_Append "<h3 class='darkgreen'>$Titre</h3>"]
lappend Local [Html_Listbox $Texte $Fenetre $Titre $Maniere]
lappend Local [Html_EndBody]
lappend Local [Html_EndHtml]
Html_Zero
return [join $Local "\n"]
}
proc XpertCommentNew {Nom {NewInfo ""}} {
return [Html_DuTexteTelQuel [InformeSansDemander $Nom "XpertComment: $NewInfo"]]
set Info [ExtraitInfo $Nom]
regsub -all "\n" $Info "<br/>\n" Info
return [Html_DuTexteTelQuel "$Info\n<br/>XpertComment: $NewInfo"]
}
proc XpertComment Nom {
set Info [ExtraitInfo $Nom]
regsub -all "\n" $Info "<br/>\n" Info
set Date [Date Nice]
regsub -all " " $Date "_" Date
regsub -all "\:" $Date "h" Date
Html_ZeroToBody
Html_Banner Wscope
Html_Append "<br/>"
Html_Append "<h3>"
Html_Append "Please add your comment at the end"
Html_Append "</h3>"
Html_Append "<form style=\"border:2px solid black; padding:15px;\" action='[WscopeScience]' method='POST'>"
Html_Append " <p>"
Html_Append " <input type='hidden' name='science' value='[Science]'/>"
Html_Append " <input type='hidden' name='procedure' value='XpertCommentNew'/>"
Html_Append " <input type='hidden' name='Nom' value='$Nom'/>"
Html_Append "$Info<br/>"
Html_Append "XpertComment: <input size='80' name='NewInfo' id='NewInfo' value='$Date '/>"
Html_Append " <input type='submit' value='Submit'/>"
Html_Append " </p>"
Html_Append "</form>"
Html_BodyToEnd
return [Html_Get]
}
proc CssWscope {} {
global CssWscope
if {0 && [info exists CssWscope]} { return $CssWscope }
set CssWscope {}
lappend CssWscope "<style type=\"text/css\">"
lappend CssWscope " body \{"
lappend CssWscope " background-color:#D0F0D0;"
# lappend CssWscope " background-image:url(/logos/WscopeBackground.png);"
lappend CssWscope " background-repeat:repeat;"
lappend CssWscope " background-position:top center;"
# lappend CssWscope " margin-left:20px;"
lappend CssWscope " \}"
lappend CssWscope " .darkgreen \{color:DarkGreen;\}"
lappend CssWscope " .margin25 \{margin-left:25%;\}"
lappend CssWscope " .mb10 \{margin-bottom:0px;\}"
lappend CssWscope " .courier \{font-family:\"courier new\", monospace, monospace;\}"
lappend CssWscope " a \{text-decoration:none;\}"
# lappend CssWscope " h1 \{text-align:center; color: DarkGreen;\}"
# lappend CssWscope " h2 \{text-align:center; color: DarkGreen;\}"
# lappend CssWscope " h3 \{text-align:center; color: DarkGreen;\}"
lappend CssWscope " </style>"
set CssWscope [join $CssWscope "\n"]
return $CssWscope
}
proc Html_DuFichierJpg Fichier {
#attention ne marche pas .....
set Queue [file tail $Fichier]
lappend H "Content-type: image/jpeg"
lappend H "Content-Disposition: inline; filename=\"$Queue\""
lappend H "Content-Transfer-Encoding: binary"
lappend H ""
lappend H [ContenuDuFichier $Fichier]
return [join $H "\n"]
}
proc FromNCBI {Id {Db ""} {Format ""}} {
if {$Db==""} {
set Db "nucleotide"
if {[regexp "^NP" $Id]} { set Db "protein" }
}
set Query "http://www.ncbi.nlm.nih.gov/entrez/viewer.fcgi?db=$Db&val=$Id"
set Page [HttpGetTextFromUrl $Query]
regsub -nocase -nocase {^.+<pre[^>]*>\n*} $Page "" Page
regsub -nocase -nocase {</pre>.*} $Page "" Page
regsub -all {\<} $Page "<" Page
regsub -all {\>} $Page ">" Page
regsub -all {\"} $Page "\"" Page
return $Page
}
proc FromEutilsNCBI {Id {Db ""} {Format ""}} {
if {$Db=="" && [regexp {^rs([0-9]+)$} $Id Match N]} {
set Id $N
set Db "snp"
}
if {$Format==""} { set Format "XML" }
set Query "http://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=$Db&id=$Id&report=$Format"
set Page [HttpGetTextFromUrl $Query]
return $Page
regsub -nocase {^.+<pre[^>]*>\n*} $Page "" Page
regsub -nocase {</pre>.*} $Page "" Page
regsub -all {\<} $Page "<" Page
regsub -all {\>} $Page ">" Page
regsub -all {\"} $Page "\"" Page
return $Page
}
proc ATV {NomFichierOuUrlPhylo {EnExec ""}} {
if {$EnExec==""} { set EnExec "EnHtml" }
if {$EnExec=="EnExec"} { set EnExec 1 } else { set EnExec 0 }
set Nom $NomFichierOuUrlPhylo
set FichierPhylo $NomFichierOuUrlPhylo
if {[regexp "/" $FichierPhylo]} {
set RepPhylo [file dirname $FichierPhylo]
} else {
if {[EstUnPAB $Nom]} {
while 1 {
set RepPhylo "phylosOrg"
set FichierPhylo "[RepertoireDuGenome]/$RepPhylo/$Nom"
if {[file exists $FichierPhylo]} { break }
set RepPhylo "phylos"
set FichierPhylo "[RepertoireDuGenome]/$RepPhylo/$Nom"
if {[file exists $FichierPhylo]} { break }
return ""
}
}
}
if {$EnExec} {
if {$FichierPhylo!="" && ! [file exists $FichierPhylo]} { return "" }
if {[catch {exec atv $FichierPhylo &} Message]} {
return 0
}
return 1
}
if {[EstUnPAB $Nom]} {
set UrlPhylo "[WscopeScience]&FileMoi&$RepPhylo&$Nom"
} else {
set UrlPhylo $NomFichierOuUrlPhylo
}
Html_ZeroToBody
Html_Append "<applet code='forester.atv_awt.ATVapplet.class'"
Html_Append " archive='[WscopeApplet]/ATVapplet.jar' width='200' height='50'>"
Html_Append " <param name='url_of_tree_to_load' value='$UrlPhylo'>"
Html_Append "</applet>"
Html_BodyToEnd
return [Html_Get]
}
proc H_Redirect {Url {Texte ""}} {
if {$Texte==""} { set Texte "Please visit $Url" }
return [H_Href $Texte $Url]
}
proc H_ColoredLetters {LesLettres LesCouleurs} {
set TexteColore ""
foreach Lettre $LesLettres Couleur $LesCouleurs {
append TexteColore "<span class='$Couleur'>$Lettre</span>"
}
return $TexteColore
}
proc Html_TableFromList {Liste} {
set NbColonnes [lindex $Liste 0]
set AttTable [lindex $Liste 1]
set AttLigne [lindex $Liste 2]
foreach C [NombresEntre 0 [expr $NbColonnes - 1]] {
set AttColon($C) [lindex $Liste [expr $C + 3]]
}
set DebutValeurs [expr $NbColonnes + 3]
lappend Local [Html_BaliseOpen "table" $AttTable]
set C 0
foreach Valeur [lrange $Liste $DebutValeurs end] {
if {$C==0} {
set TdTh "td"
if {[regexp "^Please_TH_" $Valeur]} {
regsub "^Please_TH_" $Valeur "" Valeur
set TdTh "th"
}
lappend Local [Html_BaliseOpen "tr" $AttLigne]
}
lappend Local [Html_BaliseOpen $TdTh $AttColon($C)]
lappend Local [Html_Append $Valeur]
lappend Local [Html_BaliseClose $TdTh]
set C [expr ($C+1)%$NbColonnes]
if {$C==0} { lappend Local [Html_BaliseClose "tr"]}
}
lappend Local [Html_BaliseClose "table"]
return [join $Local "\n"]
}
proc H_StyleClassePourBalise {Balise LesClassesValeurs {WithElement ""}} {
if {[regexp {WithElement_(.+)} $WithElement Match Element]} {
set WithElement 1
} else {
set WithElement 0
}
lappend Local "<style type=\"text/css\">"
set Dot "."
foreach {Classe Valeur} $LesClassesValeurs {
if {$Classe==""} { set Dot "" } else { set Dot "." }
lappend Local " $Balise$Dot$Classe \{$Valeur\}"
if {$WithElement} { lappend Local " $Balise$Dot$Classe $Element \{$Valeur\}" }
}
lappend Local "</style>"
return [join $Local "\n"]
}
proc WgetzSurWeb {molid {url ""} {GetUrl ""}} {
set SiteRSCB "http://www.rcsb.org"
set SiteIGBMC "http://bips.u-strasbg.fr"
set WGetz "srsbin/cgi-bin/wgetz"
set SwTr "swissprot_SP_sptrembl"
# set SwTrNw "swissprot_SP_sptrembl_SP_sptnew"
set Defauts(UrlPdbHome) "$SiteIGBMC/PipeAlign/get_pdb_file.cgi?XXXX"
# set Defauts(UrlSRSHome) "$SiteIGBMC/$WGetz?-e+\[\{$SwTr\}-acc:XXXX\]|\[swissprot-id:XXXX\]+-vn+2"
set Defauts(UrlSRSHome) "http://www.ncbi.nlm.nih.gov/sites/entrez?Db=protein&Cmd=DetailsSearch&Term=XXXX"
set Defauts(UrlRefSeqH) "$SiteIGBMC/$WGetz?-e+\[\{REFSEQ\}-acc:XXXX\]|\[REFSEQ-id:XXXX\]+-vn+2"
set Defauts(UrlSRSWorld) "$SiteIGBMC/$WGetz?-e+\[\{$SwTr\}-acc:XXXX\]|\[swissprot-id:XXXX\]+-vn+2"
set Defauts(UrlPdbWorld) "$SiteRSCB/pdb/cgi/export.cgi/XXXX.pdb?format=PDB&pdbId=XXXX&compression=None"
set Defauts(UrlUniprot) "http://www.uniprot.org/uniprot/XXXX"
set site "UNK"
if {$url == ""} {
if {[EstUnAccessPDB $molid]} {
set site "Pdb"
set url $Defauts(UrlPdbHome)
} else {
set site "SRS"
if {[regexp "^NM" $molid]} {
set url $Defauts(UrlRefSeqH)
} else {
set url $Defauts(UrlUniprot)
}
}
}
if {[regexp "\:" $molid]} { set molid [StringApres ":" dans $molid] }
regsub -all "XXXX" $url $molid url
if {$GetUrl=="GetUrl"} { return $url }
set LesLignes {}
set TexteHTML [HttpGetTextFromUrl $url]
if {$TexteHTML!=""} {
set LesLignes [split $TexteHTML "\n"]
} else {
HttpCopy $url LesLignes
}
if {$site == "UNK"} {return $LesLignes}
if {$site == "SRS"} {
set TexteHTML [join $LesLignes "\n"]
set Texte [ValeurDeLaBalise "pre" TexteHTML]
set LesLignes [split $Texte "\n"]
}
set head "[string range [lindex $LesLignes 0] 0 1]"
if { $head != "HE" && $head != "ID"} {
set LesLignes {}
regsub -all "XXXX" [set Defauts(Url${site}World)] $molid url
HttpCopy $url LesLignes
if {$site=="SRS"} {
set TexteHTML [join $LesLignes "\n"]
set Texte [ValeurDeLaBalise "pre" TexteHTML]
set LesLignes [split $Texte "\n"]
}
set head "[string range [lindex $LesLignes 0] 0 1]"
if { $head != "HE" && $head != "ID"} {
set LesLignes "ERREUR"
if {$site == "Pdb"} {
if {[file exists "${molid}.pdb"]} {
set LesLignes [LesLignesDuFichier "${molid}.pdb"]
set head "[string range [lindex $LesLignes 0] 0 1]"
if { $head != "HE"} {set LesLignes "ERREUR"}
}
}
}
}
set LesBonnesLignes {}
foreach Ligne $LesLignes {
if {[regexp -nocase "<A HREF" $Ligne]} {
set V [ValeurDeLaBalise A Ligne "NePasRogner"]
regsub -nocase {<A HREF.+</A>} $Ligne $V Ligne
}
lappend LesBonnesLignes $Ligne
}
return $LesBonnesLignes
}
proc OliWeb {} {
set Page [FormulaireOliWeb]
return $Page
}
proc H_AskAndGetFile {} {
}
proc H_TexteArea {{Texte ""} Name {Rows 5} {Cols 80}} {
return [H_BalAtt $Texte TEXTAREA "name $Name rows $Rows cols $Cols"]
}
proc FormulaireOliWeb {} {
set LH {}
lappend LH [H_Open [H_BalAtt [H_Pivot] FORM \
"ACTION [WscopeServer]?ProGS&TraiteOliWebOrder METHOD post"]]
lappend LH "Select all 5' signals"
lappend LH [H_BR]
lappend LH [H_MorceauxChoisis [LesSignaux] "SigAv"]
lappend LH [H_BR]
lappend LH "Cut and Paste your nucleic sequence"
lappend LH [H_BR]
lappend LH [H_TexteArea "" "Sequence"]
lappend LH [H_BR]
lappend LH "If necessary give fragment limits"
lappend LH [H_TexteArea "" "Fragment" 1 20]
lappend LH " please use following conventions"
lappend LH [H_Open [H_Balise [H_Pivot] PRE]]
lappend LH "Counting AMINO ACIDS :"
lappend LH " 25 58 (from Amino acid 25 to Amino Acid 58) ***USE ONLY NUMBERS***)"
lappend LH "or G25 H58 (from Glycine 25 to Histidine 58 ***USE UPPERCASE LETTERS***)"
lappend LH "Counting NUCLEIC BASES :"
lappend LH " g62 n97 (from guanine 62 to base 97 ***USE LOWERCASE LETTERS***)"
lappend LH [H_Close]
lappend LH "Select all 3' signals"
lappend LH [H_MorceauxChoisis [LesSignaux] "SigAp"]
lappend LH [H_BalAtt "" INPUT "VALUE Reset TYPE reset"]
lappend LH [H_BalAtt "" INPUT "VALUE Submit TYPE submit"]
lappend LH [H_Close]
return [join $LH "\n"]
}
proc H_ChoixParmi {Liste Name {AvecReset ""} {AvecSubmit ""}} {
if {[regexp -nocase "AvecReset" $AvecReset] } { set AvecReset 1 } else { set AvecReset 0 }
if {[regexp -nocase "AvecSubmit" $AvecSubmit]} { set AvecSubmit 1 } else { set AvecSubmit 0 }
set LeTexteCP {}
lappend LeTexteCP [H_Open [H_BalAtt [H_Pivot] SELECT "NAME $Name"]]
lappend LeTexteCP [H_BalAtt ". . . . . . ." OPTION]
foreach Ligne $Liste {
lappend LeTexteCP [H_BalAtt $Ligne OPTION]
}
lappend LeTexteCP [H_Close]
if {$AvecReset} {
lappend LeTexteCP [H_BalAtt "" INPUT "VALUE Reset TYPE reset"]
}
if {$AvecSubmit} {
lappend LeTexteCP [H_BalAtt "" INPUT "VALUE Submit TYPE submit"]
}
return [join $LeTexteCP "\n"]
}
proc H_MorceauxChoisis {Liste NomGeneric {AvecReset ""} {AvecSubmit ""} {MaxCandidats ""}} {
if {[regexp -nocase "AvecReset" $AvecReset] } { set AvecReset 1 } else { set AvecReset 0 }
if {[regexp -nocase "AvecSubmit" $AvecSubmit]} { set AvecSubmit 1 } else { set AvecSubmit 0 }
if {$MaxCandidats==""} { set MaxCandidats 9 }
set LeTexteHMC {}
for {set C 1} {$C<$MaxCandidats} {incr C} {
set Name [format "%s%3.3d" $NomGeneric $C]
lappend LeTexteHMC [H_ChoixParmi $Liste $Name]
lappend LeTexteHMC [H_BR]
}
if {$AvecReset} {
lappend LeTexteHMC [H_BalAtt "" INPUT "VALUE Reset TYPE reset"]
}
if {$AvecSubmit} {
lappend LeTexteHMC [H_BalAtt "" INPUT "VALUE Submit TYPE submit"]
}
return [join $LeTexteHMC "\n"]
}
proc Test_H_Open_Close {} {
lappend LT [H_Open [H_BalAtt [H_Pivot] Coucou "a b c d"]]
lappend LT [H_Open [H_Color [H_Pivot]]]
lappend LT "These lines will"
lappend LT "be enclosed"
lappend LT "between Opens and Closes"
lappend LT [H_Close]
lappend LT [H_Close]
EspionneL $LT
}
proc H_Pivot {} {
return "JeSuIsLePiVoT"
}
proc H_Open {Texte} {
global H_OpenClose
Wup "H_Open and H_Close allows to encapsulate a text. See Test_H_Open_Close"
set Pivot [H_Pivot]
set i [string first [H_Pivot] $Texte]
set Open [string range $Texte 0 [expr $i-1]]
set Close [string range $Texte [expr $i+[string length $Pivot]] end]
lappend H_OpenClose $Close
return $Open
}
proc H_Close {} {
global H_OpenClose
Wup "H_Open and H_Close allows to encapsulate a text. See Test_H_Open_Close"
set Close [lindex $H_OpenClose end]
set H_OpenClose [lrange $H_OpenClose 0 end-1]
return $Close
}
proc DescDuRepertoire {Rep {PleaseAlign ""}} {
global DescDuRepertoire
if {$PleaseAlign=="PleaseAlign"} { set PleaseAlign 1 } else { set PleaseAlign 0 }
set Rep [file tail $Rep]
if {[info exists DescDuRepertoire($Rep)]} {
set Desc [set DescDuRepertoire($Rep)]
if {$PleaseAlign} {
set Blanc "$Rep ..............................................."
regsub $Rep [string range $Blanc 0 30] "" Blanc
return "$Blanc $Desc"
} else {
return $Desc
}
}
if {[info exists DescDuRepertoire("EstCharge")]} {return ""}
set DescDuRepertoire("EstCharge") 1
set DescDuRepertoire(descriptifs) "brief description of each homolog sequence"
set DescDuRepertoire(leonLog) "log file of Leon"
set DescDuRepertoire(notes) "summary of most important information concerning each sequence"
set DescDuRepertoire(infos) "working file used as manual annotation tools for each sequence"
set DescDuRepertoire(nuctfa) "fasta format file of nucleic sequence"
set DescDuRepertoire(nucembl) "swissprot format file of nucleic sequence"
set DescDuRepertoire(prottfa) "fasta format file of protein sequence"
set DescDuRepertoire(protembl) "swissprot format file of protein sequence"
set DescDuRepertoire(psiblastp) "Psiblast against protall (swissprot; sptrembl, sptnew, pdb)"
set DescDuRepertoire(blastp) "BlastP against protall (swissprot; sptrembl, sptnew, pdb)"
set DescDuRepertoire(blastngenembl) "all BlastN againstgenembl"
set DescDuRepertoire(tblastngenomes) "all TBlastN against complete microbial genomes"
set DescDuRepertoire(apns) "it contains a summary of blast hits"
set DescDuRepertoire(daedalushits) "better than apns. It contains also TaxId, Definition, Class, etc. "
set DescDuRepertoire(tfasdescopains) "fasta file containing all sequences used in multiple alignment"
set DescDuRepertoire(msf) "multiple alignment of complete sequences with DbClustal"
set DescDuRepertoire(msfToHtml) "converts the msf file to a MacsimXml and displays it with macsimHtml"
set DescDuRepertoire(msfLeon) "multiple alignment file after Leon's currating process"
set DescDuRepertoire(msffam) "multiple alignment file restricted to familiar organisms only"
set DescDuRepertoire(msf2) "second multiple alignment of complete sequences with DbClustal"
set DescDuRepertoire(rascal) "multiple alignment of complete sequences with DbClustal and Rascal"
set DescDuRepertoire(macsimXml) "Macsim's analysis of multiple alignment in Xml format"
set DescDuRepertoire(macsimRsf) "Macsim's analysis of multiple alignment in Rsf format"
set DescDuRepertoire(macsimHtml) "Macsim's analysis of multiple alignment in Html format"
set DescDuRepertoire(macsimJalview) "See the Macsim with the Jalview java applet (needs JRE1.5)"
set DescDuRepertoire(description) "give a summary of all orthologues (AC, GN, Definition, Organism, ..."
set DescDuRepertoire(aliinout) "why we keep or reject a sequence in the multiple alignment"
set DescDuRepertoire(phylos) "phylogenetic tree of the multiple alignment (text file)"
set DescDuRepertoire(AtvOfphylos) "phylogenetic tree of the multiple alignment displayed by ATV"
set DescDuRepertoire(phylosOrg) "phylogenetic tree of the multiple alignment with Organism names (text file)"
set DescDuRepertoire(AtvOfphylosOrg) "phylogenetic tree of the multiple alignment with Organism names displayed by ATV"
set DescDuRepertoire(disphy) "phylogenetic distance from the multiple alignment"
set DescDuRepertoire(ver) "nuc or prot sequence used to start the analysis"
return [DescDuRepertoire $Rep $PleaseAlign]
}
proc TexteEntreChevrons Texte {
set i [string first "<" $Texte]
if {$i<0} { return "" }
set Bon ""
set N 1
foreach C [split [string range $Texte [incr i] end] ""] {
if {$C==">" && $N==1} { return $Bon }
append Bon $C
if {$C=="<"} { incr N }
if {$C==">"} { incr N -1}
}
return $Bon
}
proc AfficheMoi args {
set Pro [lindex $args 0]
if { ! [HtmlAuthorize $Pro]} { Expe "Error from Gscope : $Pro isn't authorized" ; return "" }
set Retour [eval $args]
return [Html_DuTexteTelQuel $Retour]
}
proc LocaliseLesTfasDuSeqCheck {{Qui ""}} {
global LocaliseLesTfasDuSeqCheck
if {[info exists LocaliseLesTfasDuSeqCheck($Qui)]} { return $LocaliseLesTfasDuSeqCheck($Qui) }
if {[info exists LocaliseLesTfasDuSeqCheck("EstCharge")]} { return "" }
set LocaliseLesTfasDuSeqCheck("EstCharge") 1
set RepPossibles "[RepertoireDuGenome]/atelier/*"
set LesFichiers [glob -nocomplain "$RepPossibles/*.tfa"]
foreach Fichier $LesFichiers {
lappend LocaliseLesTfasDuSeqCheck(ListOfFilepathes) $Fichier
set Queue [file tail $Fichier]
lappend LocaliseLesTfasDuSeqCheck($Queue) $Fichier
lappend LocaliseLesTfasDuSeqCheck(ListOfFilenames) $Queue
regsub -nocase ".tfa$" $Queue "" Name
lappend LocaliseLesTfasDuSeqCheck($Name) $Fichier
lappend LocaliseLesTfasDuSeqCheck(ListOfNames) $Name
}
return [LocaliseLesTfasDuSeqCheck $Qui]
}
proc InsereHrefSeqcheckOligoDans {Ligne S P {PGS ""}} {
set LigneAvecRef $Ligne
set ET "EtCoMeRcIaL"
if {$P!=""} {
set Ref "[WscopeScience] $ET ShowOli $ET P1456"
set HRef [H_Href $P $Ref]
regsub " $P " $LigneAvecRef " $HRef " LigneAvecRef
}
set LesFicSeq [LocaliseLesTfasDuSeqCheck $S]
set LesNouvellesLignesAvecRef {}
foreach FicSeq $LesFicSeq {
set DirSeq [file dirname $FicSeq]
set Qui [file tail $FicSeq]
regsub "[RepertoireDuGenome]/" $DirSeq "" Quoi
set Ref "[WscopeScience] $ET FileMoi $ET $Quoi $ET $Qui"
set HRef [H_Href $S $Ref]
regsub " $S " $LigneAvecRef " $HRef " NouvelleLigneAvecRef
lappend LesNouvellesLignesAvecRef $NouvelleLigneAvecRef
}
if {$LesNouvellesLignesAvecRef!={}} {
set LigneAvecRef [join $LesNouvellesLignesAvecRef "\n"]
}
regsub -all " $ET " $LigneAvecRef {\&} LigneAvecRef
return $LigneAvecRef
}
proc InsereHrefAccessDans {Ligne BanqueId {Access ""}} {
set ET "EtCoMeRcIaL"
set Ref "[WscopeScience] $ET AfficheMoi $ET SequenceDesBanques $ET $BanqueId $ET $Access"
set HRef [H_Href $Access $Ref]
regsub -all {\:} $Access "\\:" AA
regsub $AA $Ligne $HRef LigneAvecRef
regsub -all " $ET " $LigneAvecRef {\&} LigneAvecRef
return $LigneAvecRef
}
proc ContenuDuFichierAvecReferences {Fichier {LesTextesRefs {}} {Ref "NoRefAtAll"}} {
if {$Ref!="NoRefAtAll"} { set LesTextesRefs [list $LesTextesRefs $Ref] }
if {$LesTextesRefs!={}} {
set Page [ContenuDuFichier $Fichier]
foreach {T R} $LesTextesRefs {
regsub -all $T $Page [H_Href $T $R] Page
}
return $Page
}
set Nom [file tail $Fichier]
set Rep [file tail [file dirname $Fichier]]
if {$Rep=="aliinout"} {
set LeTexte {}
foreach Ligne [LesLignesDuFichier $Fichier] {
set Access ""
scan $Ligne "%s %s" BanqueId Access
set LigneAvecRef [InsereHrefAccessDans $Ligne $BanqueId $Access]
lappend LeTexte $LigneAvecRef
}
return [join $LeTexte "\n"]
}
if {$Rep=="infos"} {
set LeTexte [list "<<<KeepChevrons"]
foreach Ligne [LesLignesDuFichier $Fichier] {
set LigneAvecRef $Ligne
if {[regexp "^SeqCheck" $Ligne]} {
scan $Ligne "%s %s %s" SC FicSeq P
set LigneAvecRef [InsereHrefSeqcheckOligoDans $Ligne $FicSeq $P $Nom]
}
lappend LeTexte $LigneAvecRef
}
lappend LeTexte "KeepChevrons>>>"
return [join $LeTexte "\n"]
}
return [ContenuDuFichier $Fichier]
}
proc HrefPourGetz {Access {Banque ""}} {
if {$Banque==""} { set Banque "protein" }
}
proc Html_Banner {{Qui ""}} {
if {$Qui==""} { set Qui "Wscope" }
set Banner {}
if {$Qui=="Bips"} {
lappend Banner [Html_Append "<!-- >Banniere commune du site et renvoi vers portail de la plate-forme<-->"]
lappend Banner [Html_Append "<table cellspacing='0' cellpadding='0' width='100%' NCOLS='2'>"]
lappend Banner [Html_Append "<tr valign='top'>"]
lappend Banner [Html_Append "<td><a href='[SiteBips]'"]
lappend Banner [Html_Append "onMouseover=\"LOGO.src='[SiteBips]Images/Back_to_platform_hover.gif'; FOND.src='[SiteBips]Images/Fond_backto_hover.gif';\""]
lappend Banner [Html_Append "onMouseout=\"LOGO.src='[SiteBips]Images/Back_to_platform.gif'; FOND.src='[SiteBips]Images/Fond_backto.gif';\">"]
lappend Banner [Html_Append "<img src=\"[SiteBips]Images/Back_to_platform.gif\" name='LOGO'"]
lappend Banner [Html_Append "title=\"Go back to Plate-Forme Bio-Informatique de Strasbourg\" border='0' width='169' height='33'></a></td>"]
lappend Banner [Html_Append "<td width='100%'><img name='FOND' src='[SiteBips]Images/Fond_backto.gif' height='33' width='100%'></td>"]
lappend Banner [Html_Append "</tr></table>"]
return $Banner
}
if {$Qui=="Wscope" && [Science]!="Actinome"} {
lappend Banner [Html_Append "<center>"]
lappend Banner [Html_Append "<table><tbody>"]
lappend Banner [Html_Append "<tr>"]
lappend Banner [Html_Append " <td rowspan='3'>"]
lappend Banner [Html_Append " <img style='margin-right:20px;' src='/logos/Gscope24x70.jpg'/>"]
lappend Banner [Html_Append " </td>"]
lappend Banner [Html_Append " <td><h3 class='darkgreen mb10'>This page is generated on the fly by Wscope from the Gscope Database [Science]</h3></td>"]
lappend Banner [Html_Append " <td rowspan='3'>"]
lappend Banner [Html_Append " <img style='margin-left:20px;' src='/logos/Gscope24x70.jpg'/>"]
lappend Banner [Html_Append " </td>"]
lappend Banner [Html_Append "</tr>"]
lappend Banner [Html_Append "<tr>"]
lappend Banner [Html_Append " <td align='center'>"]
lappend Banner [Html_BackTo]
lappend Banner [Html_Append " </td>"]
lappend Banner [Html_Append " </tr>"]
lappend Banner [Html_Append "<tr><td align='center'><small>[CaVa]</small></td></tr>"]
lappend Banner [Html_Append "</tbody></table>"]
lappend Banner [Html_Append "</center>"]
set FichierHelp "[Fiches]/help.html"
if {[FileAbsent $FichierHelp]} { set FichierHelp "[Fiches]/help.html" } ; #rR ????? faut trouver autre chose !!
if {[FileExists $FichierHelp]} {
set QueueHelp [file tail $FichierHelp]
lappend Banner [Html_Append "<center><h4><a href=[WscopeScience]&FicheMoi&$QueueHelp>Get Help</a></h4></center>"]
}
return [join $Banner "\n"]
}
}
proc Html_BackTo {{Nom ""}} {
if {$Nom==""} { set Nom [DerniereVisite] }
set BackTo {}
if {1} {
lappend BackTo [Html_Append "<small>"]
lappend BackTo [Html_Append "Back to "]
}
if {[OnTraiteEVImm] || [OnTraiteGGmm] || [OnTraiteGGWmm] || [OnTraiteEVIhs] || [OnTraiteGGhs] || [OnTraiteGGWhs] || [OnTraiteRetGene]} {
lappend BackTo [Html_Append " • "]
lappend BackTo [Html_Href " Genoret" [GenoretUrl] "title='GenoretDatabase home page'"]
lappend BackTo [Html_Append " • "]
lappend BackTo [Html_Href " GenoretGenes" [GenoretGenesUrl] "title='GenoretGenes home page'"]
}
if {1} {
lappend BackTo [Html_Append " • "]
lappend BackTo [Html_Href " ICube" "http://icube.unistra.fr" \
"title='ICube - home page'"]
lappend BackTo [Html_Append " • "]
lappend BackTo [Html_Href " CSTB" "http://icube-cstb.unistra.fr" \
"title='Complex Systems and Translational Bioinformatics - home page'"]
lappend BackTo [Html_Append " • "]
lappend BackTo [Html_Href " LBGI" [LbgiUrl] \
"title='LBGI BioInformatique et Génomique Intégratives - home page'"]
lappend BackTo [Html_Append " • "]
lappend BackTo [Html_Href "WelcomeToWscope" "[WscopeScience]&WelcomeToWscope" \
"title='Lists all Gscope Projects'"]
lappend BackTo [Html_Append " • "]
lappend BackTo [Html_Href "[Science]" "[WscopeScience]" \
"title='[Science] general information entry point'"]
lappend BackTo [Html_Append " • "]
lappend BackTo [Html_Href "List" "[WscopeScience]&FileMoi" \
"title='all entry points for [Science]'"]
if {$Nom!=""} {
lappend BackTo [Html_Append " • "]
lappend BackTo [Html_Href "$Nom" "[WscopeScience]&FileMoi&$Nom" \
"title='See all available data about $Nom'"]
}
lappend BackTo [Html_Append " • "]
lappend BackTo [Html_Href "Search" "[WscopeScience]&RechercheMoi" \
"title='search any word in (the infos files of) [Science]'"]
}
if {[OnTraiteBalibase]} {
lappend BackTo [Html_Append " • "]
lappend BackTo [Html_Href "BAliBASE home page" \
"/balibase/index.html"]
}
if {[OnTraite "KoAnno"]} {
lappend BackTo [Html_Append " • "]
lappend BackTo [Html_Href "KoAnno home page" \
"http://lbgi.fr/~brelivet/KoAnno"]
}
if {1} {
lappend BackTo [Html_Append "</small>"]
lappend BackTo [Html_NewLine]
}
return [join $BackTo "\n"]
}
proc Science {{Value ""}} {
global Science
if {$Value!=""} { set Science $Value }
if {[info exists Science]} { return $Science }
if {[info proc RepertoireDuGenome]!=""} { return [file tail [RepertoireDuGenome]] }
return "ScienceUnknown"
}
proc SciencePublic Science {
if {$Science=="Peroxisome"} {return 1}
if {$Science=="Balibase"} {return 1}
if {$Science=="CR"} {return 1}
return 0
}
proc ContenuMisAJourDuFichier Fichier {
set Texte [ContenuDuFichier $Fichier]
while {[regexp {_([A-Z][a-zA-Z0-9]+)_} $Texte Match Pro]} {
if {[regexp "isn't a procedure" [info args $Pro]]} { continue }
set Val [$Pro]
regsub $Match $Texte $Val Texte
}
return $Texte
}
proc WelcomeToWscope {{ReScan ""} {Order ""}} {
PourWscope 1
if {$Order==""} { set Order 0 }
set ReScan [regexp -nocase "ReScan" $ReScan]
set Science [Science]
set RepExisting "[GscopeDatabaseDir Zero]/fiches"
set LesFichiersExistingProjects [lsort -decreasing [glob -nocomplain "$RepExisting/ExistingProjects*.txt"]]
set FichierExistingProjects [lindex $LesFichiersExistingProjects 0]
set Memorise 0
if {$ReScan || [FileAbsent $FichierExistingProjects]} {
set Date [Date "YMD_HMS"]
set FichierExistingProjects "$RepExisting/ExistingProjects_$Date.txt"
set Memorise 1
}
if {[FileAbsent $FichierExistingProjects]} {
set LesTexteAffiche {}
foreach FichierMiniConfig [lsort [glob "/genomics/link/*/beton/miniconfig"]] {
set NomGscope [file tail [file dirname [file dirname $FichierMiniConfig]]]
if {[regexp -nocase {^Old|Old$|^Hidden|Hidden$} $NomGscope]} { continue }
regsub "miniconfig$" $FichierMiniConfig "deny" FichierDeny
if {[file exists $FichierDeny]} { continue }
set OrganismeLu "Unknown organism name"
set Prefixe ""
foreach Ligne [LesLignesDuFichier $FichierMiniConfig] {
if {[regexp "^NotreOS " $Ligne]} {
scan $Ligne "%s %s %s" Bidon Genre Espece
regsub {\.$} $Espece "" Espece
set OrganismeLu "$Genre $Espece"
continue
}
if {[regexp "PrefixeDesORFs" $Ligne]} {
set Prefixe [StringApres "PrefixeDesORFs" dasn $Ligne]
continue
}
}
set Owner [StringApres "owner" dans [file attributes $FichierMiniConfig]]
set Date [DateOfFile $FichierMiniConfig "NiceYMD"]
set NbPab 0
set FichierBornes "[file dirname [file dirname $FichierMiniConfig]]/fiches/bornesdespabs"
if {[file exists $FichierBornes]} { set NbPab [llength [LesLignesDuFichier $FichierBornes]] }
if {[regexp -nocase {^[0-9]} $NomGscope] && $Owner=="jmuller"} { continue } ;#rR on enleve jmuller numerique
set TexteAffiche "$NomGscope\t$OrganismeLu\t$NbPab\t$Prefixe\t$Owner\t$Date"
lappend LesTexteAffiche $TexteAffiche
}
SauveLesLignes $LesTexteAffiche dans $FichierExistingProjects
} else {
set LesTexteAffiche [LesLignesDuFichier $FichierExistingProjects]
}
set LesTexteAffiche [lsort -dictionary $LesTexteAffiche]
set NbProject [llength $LesTexteAffiche]
if {$Order!=0} {
#rR on retrie !
set LesLTA {}
foreach TA $LesTexteAffiche {
set LTA [split $TA "\t"]
lappend LesLTA $LTA
set TAdu($LTA) $TA
}
set LesLTATrie [lsort -index $Order -dictionary $LesLTA]
set LesNouveauTexteAffiche {}
foreach LTA $LesLTATrie {
lappend LesNouveauTexteAffiche $TAdu($LTA)
}
set LesTexteAffiche $LesNouveauTexteAffiche
}
set LesRefText {}
foreach TexteAffiche $LesTexteAffiche {
scan $TexteAffiche "%s" NomGscope
regsub "=.*" $NomGscope "" NomGscope
lappend LesRefText "[WscopeServer]?$NomGscope&GuideMoi" $TexteAffiche
}
set DateVersion [file tail $FichierExistingProjects]
regexp {[0-9]+_[0-9]+} $DateVersion DateVersion
regsub {[0-9][0-9]$} $DateVersion "" DateVersion
set AboutVersion "Last update: $DateVersion (if too old please <a href='[WscopeServer]?$Science&WelcomeToWscope&ReScan'>update</a> it)"
set Titre "<div style='margin:0 auto;'>"
append Titre "<h4 class='darkgreen margin25'>Click one of these $NbProject Gscope Projects in following list</h4>"
append Titre "<h5 class='margin25'>$AboutVersion Order by "
set C 0
foreach Header [list Project Orga NbProt Prefixe Owner Date] {
append Titre " <a href='[WscopeServer]?Zero&WelcomeToWscope&UseMemo&$C'>$Header</a>"
incr C
}
append Titre "</h4>"
append Titre "</div>"
set Html [Html_ListOfRefs $LesRefText $Titre "PleaseSplitText"]
return $Html
}
proc WelcomeToMe {} {
PourWscope 1
set FichierPresentation "[RepertoireDuGenome]/html/index.html"
if {[file exists $FichierPresentation]} { return [ContenuDuFichier $FichierPresentation] }
set NomGscope [file tail [RepertoireDuGenome]]
set PreFixe [PreFixe]
set Organisme [NotreOS]
if {$Organisme=="Inconnu inconnu"} { set Organisme "" }
set TexteAffiche "$NomGscope $PreFixe $Organisme"
return [H_Href $TexteAffiche "[WscopeServer]?$NomGscope&GuideMoi"]
}
proc EnvVars {} {
global env
#rR attention cet env est celui du cafedessciences et pas du cgi ... :'(
foreach {K V} [array get env] {
lappend KVs "$K=$V="
}
set Text [join $KVs "\n"]
return [Html_DuTexteTelQuel $Text]
}
proc ReferenceGscope args {
return "[WscopeScience]&[join $args "&"]"
}
proc WscopeSite {} {
#rR .................................................... essai du 2014/05/15 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
set WscopeSite ""
# set WscopeSite "http://www.lbgi.fr"
}
proc ScienceIsPublic {{Science ""}} {
if {$Science==""} { set Science [Science] }
set PublicSciences [list \
SynMito Peroxisome Spine ImAnnoGenes \
Balibase KoAnno Actinome \
SpliRet SpliRetMouse SpliRetRat \
EVImm GGmm GGWmm EVIhs GGhs GGWhs \
YEAH Zero \
RetGene ProGS TroisPrima ]
return [expr [lsearch $PublicSciences [Science]]>=0]
}
proc WscopeCgibin {} {
#rR il vaut mieux utiliser WscopeServer !!! mais c'est pas encore tres clair pour moi
if {[ScienceIsPublic]} {
set RepCgi "~ripp/cgi-bin"
} else {
set RepCgi "gag/cgi-bin"
}
set WscopeCgibin "[WscopeSite]/$RepCgi"
return $WscopeCgibin
}
proc WscopeApplet {} {
if {[SciencePublic [Science]]} {
set RepApplet "~ripp/gagapplet"
} else {
set RepApplet "gag/applet"
}
set WscopeApplet "[WscopeSite]/$RepApplet"
return $WscopeApplet
}
proc HttpReferer {} {
package require http
set referer [::http::header "Referer"]
return $referer
}
proc RequestUriFromWscope {{Value ""}} {
LogWscope "RequestUriFromWscope =$Value="
global RequestUriFromWscope
if {$Value=="unset"} {
if {[info exists RequestUriFromWscope]} { unset RequestUriFromWscope }
return ""
}
if {$Value!=""} { set RequestUriFromWscope $Value }
if {[info exists RequestUriFromWscope]} { LogWscope "$RequestUriFromWscope"; return $RequestUriFromWscope }
return ""
}
proc WscopeServer {{NewValue ""}} {
# set WscopeServer "[WscopeCgibin]/GscopeServer"
# return $WscopeServer
#rR AAAAAA Attention pas encore fini
#rR cette procédure doit rendre WscopeServer.tcl soit par le chemin WscopeServer soit par wscoperr
#rR Mais ... WscopeServer.tcl ne marche pas encore bien.
#rR en fait il faut corriger WscopeServer.tcl pour qu'il soit comme gscope_html_server.tcsh
global WscopeServer
#rR j'ai collé ça la dedans !!!!!! Je suppose que c'est pour rendre le meme que l'appelant.
if {[RequestUriFromWscope]!=""} {
regsub "/.*" [RequestUriFromWscope] "" Server
return $Server
}
#rR on peut aussi le positionner dans gscope lui même
if {$NewValue!=""} { set WscopeServer $NewValue }
if {[info exists WscopeServer]} { return $WscopeServer }
#rR là est le défaut :
if {[ScienceIsPublic]} {
set WscopeServer "wscoperr"
} else {
set WscopeServer "WscopeServer"
}
return $WscopeServer
}
proc WscopeScience {{NewValue ""}} {
global WscopeScience
if {$NewValue!=""} { set WscopeScience $NewValue }
if {[info exists WscopeScience]} { return $WscopeScience }
set WscopeScience "[WscopeServer]?[Science]"
return $WscopeScience
}
proc GenoretScience {} {
set GenoretScience "[GenoretServer]?Genoret"
return $GenoretScience
}
proc GenoretServer {} {
set GenoretServer "[GenoretUrl]/cgi-bin/GenoretServer.tcsh"
return $GenoretServer
}
proc GenoretUrl {} {
set GenoretUrl "http://genoret.lbgi.fr/genoret"
return $GenoretUrl
}
proc GenoretGenesUrl {} {
set GenoretGenesUrl "http://genoret.lbgi.fr/GenoretGenes"
return $GenoretGenesUrl
}
proc LbgiUrl {} {
set LbgiUrl "http://www.lbgi.fr"
return $LbgiUrl
}
proc AnalyseMoi args {
PourWscope 1
return [Html_DuTexteTelQuel [join $args " "]]
}
proc RepereBoxEtFileMoi {Texte {Quoi ""} {Quoi2 ""} {Comment ""}} {
PourWscope 1
if {$Quoi=="ListAll"} {
if {$Quoi2!=""} {
set Synonym $Quoi2
set Synonyms [GscopeSynonyms $Synonym "GscopeIds"]
if {$Synonyms!={}} {
set Synonyms [join $Synonyms " "]
return [FileMoi "GscopeIdsList" $Synonyms $Comment]
}
return ""
}
return [FileMoiSearchList $Texte $Comment]
}
if {$Texte=="Next" || $Quoi=="NextOne"} {
set Nom [RepereBox "" "" "Next"]
} else {
set Nom [RepereBox $Texte]
}
set Quoi $Quoi2
if {$Nom==""} {
return [Html_DuTexteTelQuel "Sorry, I found nothing"]
} else {
if {$Quoi==""} {
return [FileMoi $Nom ]
} else {
return [FileMoi $Quoi $Nom $Comment]
}
}
}
proc RechercheMoi {} {
Html_ZeroToBody
Html_Banner Wscope
Html_Append "<br/>"
Html_Append "<h3 class='darkgreen'>"
Html_Append "Search any string within the infos files of [Science]"
Html_Append "<br/> <small>to search a Gene Name exactly, use the search string '<tt>ValiGN: Pax6</tt>' (with ':' and one space)</small>"
Html_Append "</h3>"
Html_Append "<form style=\"border:2px solid black; padding:15px;\" action='[WscopeScience]' method='POST'>"
Html_Append " <p>"
Html_Append " <input type='hidden' name='science' value='[Science]'>"
Html_Append " <input type='hidden' name='procedure' value='RepereBoxEtFileMoi'>"
Html_Append " <label for='SearchString'>Search string : </label>"
Html_Append " <input type='text' name='SearchString' id='SearchString' value=''>"
Html_Append " "
Html_Append " <select name='WhichOne'>"
Html_Append " <option>ListAll</option>"
Html_Append " <option>FirstOne</option>"
Html_Append " <option>NextOne</option>"
Html_Append " </select>"
Html_Append " "
Html_Append " <label for='SynonymString'>GeneName Synonym : </label>"
Html_Append " <input type='text' name='SynonymString' id='SynonymString' value=''>"
Html_Append " "
Html_Append " <input type='submit' value='Search'>"
Html_Append " </p>"
Html_Append "</form>"
#lP
if {[Science]=="EVImm" || [OnTraite REFUNI]} {
set RG [file tail [RepertoireDuGenome]]
Html_Append "<h3>or do a blast search</h3>"
Html_Append "<iframe src='[LbgiUrl]/Gagniere/BlastEVI/index.php?rg=$RG' style='width:100%; height:450px;'></iframe>"
} else {
set RG [file tail [RepertoireDuGenome]]
set PreFixe [PreFixe]
set refWikiBlastOnGscope "[LbgiUrl]/wikili/index.php/Blast_On_Gscope_Project"
Html_Append "<h3>or do a blast search within all $PreFixe of $RG (see <a href='$refWikiBlastOnGscope' target='_blank'>Wiki</a>)</h3>"
Html_Append "<iframe src='[LbgiUrl]/Gagniere/BlastProGS/index.php?rg=$RG&pf=$PreFixe' style='width:100%; height:550px'></iframe>"
}
#rR
Html_BodyToEnd
return [Html_Get]
}
proc WscopeLinks {{Context ""} {Qui ""}} {
if {$Context==""} { set Context "GuideMoi" }
set Fichier "[RepertoireDuGenome]/fiches/WscopeLinks$Context.txt"
if {[FileAbsent $Fichier]} { return {} }
set LesRT {}
foreach Ligne [LesLignesDuFichier $Fichier] {
if {[regexp {^\#} $Ligne]} { continue }
regsub -all {\[Alias \$Qui\]} $Ligne [Alias $Qui] Ligne
regsub -all {\$\{Qui\}} $Ligne $Qui Ligne
regsub -all {\$Qui} $Ligne $Qui Ligne
regsub {\[Science\]} $Ligne [Science] Ligne
regsub {\[PreFixe\]} $Ligne [PreFixe] Ligne
regsub {\[LbgiUrl\]} $Ligne [LbgiUrl] Ligne
regsub {\[GenoretGenesUrl\]} $Ligne [GenoretGenesUrl] Ligne
regsub {\[WscopeServer\]} $Ligne [WscopeServer] Ligne
regsub {\[WscopeScience\]} $Ligne [WscopeScience] Ligne
regsub -all {\t+} $Ligne "\t" Ligne
set RT [split $Ligne "\t"]
set Ref [lindex $RT 0]
set Text [join [lrange $RT 1 end] "\t"] ;#rR 2014/12/21 on garde les tab dans le texte.
regsub -all {\&} $Ref "\&" Ref
lappend LesRT $Ref $Text
}
return $LesRT
}
proc GuideMoi {{Message ""}} {
if {$Message==""} { set Message "Please choose ..." }
set Science [file tail [RepertoireDuGenome]]
PourWscope 1
set WikiRef "[LbgiUrl]/wikili/index.php/Gscope"
if {[Science]=="ProGS"} { set WikiRef "[LbgiUrl]/wikili/index.php/Gscope_Clonage" }
set N [llength [ListeDesPABs]]
if {[OnTraite MSP]} {
lappend LesRefText "[WscopeScience]&OuSontLesMutations" "OuSontLesMutations ?"
}
lappend LesRefText "[LbgiUrl]/wikili/index.php/Gscope" "Get help from Wiki"
lappend LesRefText "[WscopeScience]&RechercheMoi" "Search for a gene, a description, etc..."
lappend LesRefText "[WscopeScience]&FileMoi" "List all $N sequences [PreFixe]"
lappend LesRefText "[WscopeScience]&FicheMoi" "List information files"
lappend LesRefText "[WscopeScience]&SynonymsPourTous&&GetHtml&GscopeSyn" "List all $N sequences Synonyms"
lappend LesRefText "[WscopeScience]&SynonymsPourTous&&GetHtml&SynGscope" "List all Synonyms GscopeIds"
lappend LesRefText "[WscopeScience]&Environ" "Show environment"
lappend LesRefText "[WscopeScience]&Inventaire" "Inventory"
LConcat LesRefText [WscopeLinks]
if {[PreFixe]=="HNR"} {
foreach FiTxt [lsort [glob -nocomplain "[Fiches]/OrganismesPresents-*.txt"]] {
regsub "[Fiches]/OrganismesPresents\-" $FiTxt "" Bank
regsub ".txt" $Bank "" Bank
lappend LesRefText "[WscopeServer]?HNR&GenomiqueComparativeParBlast&$Bank" "Genomique Comparative par <b>$Bank</b>"
}
}
if {[Science]=="RetGene"} {
lappend LesRefText "" ""
lappend LesRefText "[WscopeScience]&RetGeneMutationOnWeb" "Summary of all mutations"
}
if {[OnTraiteUCSCGenomes]} {
lappend LesRefText "" ""
lappend LesRefText "[WscopeScience]&CytoBandUcsc&ListOf&Organisms" "List of available organisms for CytoBandUcsc"
lappend LesRefText "[WscopeScience]&CytoBandUcsc&Human&List&Of&CytoBands" "Human CytoBands"
lappend LesRefText "[WscopeScience]&CytoBandUcsc&Mouse&List&Of&CytoBands" "Mouse CytoBands"
}
return [Html_ListOfRefs $LesRefText "<h3 class='darkgreen margin25' style='margin-left:25%'>$Message</h3>"]
}
proc FicheMoi {{Qui ""} {Comment ""}} {
PourWscope 1
if {$Qui==""} {
set LesFiches [lsort [glob "[RepertoireDuGenome]/fiches/*"]]
set LesRefText {}
foreach Fichier $LesFiches {
set Fiche [file tail $Fichier]
lappend LesRefText "[WscopeScience]&FicheMoi&$Fiche" $Fiche
}
return [Html_ListOfRefs $LesRefText "<h3 class='darkgreen margin25'>Please click to see the corresponding file</h3>"]
}
if {$Comment==""} { set Comment "EnHTML" }
set LesProbable {}
lappend LesProbable "[RepertoireDuGenome]/fiches/$Qui"
#rR on peut en rajouter d'autres ici ##################################################rR"
if {[regexp "^rR/" $Qui]} {
regsub "^rR/" $Qui "[HomeRipp]/" Qui
lappend LesProbable $Qui
}
foreach Probable $LesProbable {
if {[FileAbsent $Probable]} { continue }
set Titre "[file tail [RepertoireDuGenome]]/fiches/$Qui"
set Texte [ContenuDuFichier $Probable]
#rR un peu de pudeur ...
if {[file tail $Qui]=="gscope_canalsql.tcl"} {
regsub -all {\{ *set Password [^\}]*\}} $Texte "\{ set Password xxxxxx \}" Texte
}
if {[regexp {\.html?$} $Qui]} { return $Texte }
return [Html_DuTexteTelQuel $Texte $Titre]
}
return "Sorry, I can't find the file $Qui"
}
proc DerniereVisite {{Nom ""}} {
global DerniereVisite
if {$Nom=="Reset"} {
if {[info exists DerniereVisite]} { unset DerniereVisite }
return ""
}
if {$Nom!=""} { set DerniereVisite $Nom }
if {[info exists DerniereVisite]} { return $DerniereVisite }
return ""
}
proc FileMoiSignalIntensityImages Nom {
set Titre "All images for Signal Intensityof $Nom"
Html_ZeroToBody
Html_Banner Wscope
Html_Append $Titre
foreach FicImage [glob -nocomplain "[RepertoireDuGenome]/transcriptomique/SignalIntensityImages/$Nom*.png"] {
set Queue [file tail $FicImage]
Html_Append "<br/>"
Html_Append "<img src='[WscopeSite]/GenoretGenes/SignalIntensityImages/$Queue'>"
}
return [Html_Get]
}
proc FileMoiRetinalGene {{Qui ""} {Quoi ""} {Comment ""}} {
#rR Attention Qui Quoi et non pas Quoi Qui"
if {[set Nom [lindex [RetinalGene GscopeIdsOf $Qui] 0]]==""} {
return [Html_DuTexteTelQuel "Sorry, I found nothing about $Qui"]
}
return [FileMoi $Quoi $Nom $Comment]
}
proc FileMoiAlias {{Qui ""} {Quoi ""} {Comment ""}} {
#rR Attention Qui Quoi et non pas Quoi Qui"
if {[set Nom [NomDuAlias $Qui]]==""} {
return [Html_DuTexteTelQuel "Sorry, I found nothing about $Qui"]
}
return [FileMoi $Quoi $Nom $Comment]
}
proc FileMoiSearchList {{Qui ""} {Comment ""}} {
return [FileMoi "SearchList" $Qui $Comment]
}
proc FileMoi {{Quoi ""} {Qui ""} {Comment ""}} {
if {[regexp " " $Quoi] && $Qui==""} {
set Qui [split $Quoi " "]
set Quoi "SearchList"
}
PourWscope 1
set AboutRetinalGene 0
set LesRefText {}
if {$Quoi=="InterrogeCopainsDesCompulsory"} {
set TexteHtml [InterrogeCopainsDesCompulsory $Qui]
if {$TexteHtml!=""} { return $TexteHtml }
}
if {($Quoi=="" && $Qui=="") || $Quoi=="BaList" || $Quoi=="SearchList" || $Quoi=="GscopeIdsList" || $Quoi=="RetinalGeneList"} {
if {$Quoi=="BaList"} {
set Liste [BaList $Qui]
set Quoi ""
set Qui ""
} elseif {$Quoi=="GscopeIdsList"} {
set Liste [split $Qui " "]
set Quoi ""
set Qui ""
} elseif {$Quoi=="SearchList"} {
set Liste [RepereBox $Qui "AllPlease"]
set Quoi ""
set Qui ""
} elseif {$Quoi=="RetinalGeneList"} {
set Liste [RetinalGene "ListAll" "GscopeIds"]
set AboutRetinalGene 1
set Quoi ""
set Qui ""
} else {
set Liste [ListeDesPABs]
}
if {[PourWscope]} {
foreach Nom $Liste {
if {[OnTraiteSpine]} {
set SurNom [SpineID $Nom]
} elseif {$AboutRetinalGene} {
set SurNom [RetinalGene "GeneNameOf" $Nom]
} else {
set SurNom [Alias $Nom]
if {$SurNom==""} { set SurNom [ExtraitInfo $Nom "ValiGN"] }
}
set Info "$Nom\t$SurNom\t[string range [DefinitionRapide $Nom] 0 80]"
if {[OnTraiteEVImm] || [OnTraiteGGmm] || [OnTraiteGGWmm] || [OnTraiteEVIhs] || [OnTraiteGGhs] || [OnTraiteGGWhs]} {
set RRC [RecapitulatifRetChipCourt $Nom]
if {$RRC!=""} {
regsub -all ";" $RRC " " RRC
}
lappend LesRefText "[WscopeScience]&GeneIdentityCard&$Nom" $Info
} else {
lappend LesRefText "[WscopeScience]&FileMoi&$Nom" $Info
}
}
if {$Comment=="TelQuel"} { return [join $LesRefText "\n"] }
return [Html_ListOfRefs $LesRefText "<h3 class='darkgreen margin25'>Please click on a [PreFixe]</h3>" "PleaseSplitText"]
}
foreach Nom $Liste {
set Info [format "%s %-8s %s" $Nom [Alias $Nom] [DefinitionRapide $Nom]]
lappend LesNoms $Nom
lappend LesInfos $Info
}
set Qui [ChoixParmiJoli $LesNoms {} $LesInfos]
if {$Qui==""} { return "" }
return [FileMoi $Qui]
}
if {[EstUnPAB $Quoi]} {
set W $Qui
set Qui $Quoi
set Quoi $W
}
set PosMacsim 0
if {$Quoi==""} {
if {[PourWscope]} {
DerniereVisite $Qui
set MacsimHtml 0
set LesRefText {}
LConcat LesRefText [WscopeLinks "FileMoi" $Qui]
set PosMacsim [llength $LesRefText]
foreach Rep [lsort [LesRepertoiresPossiblesPour $Qui "HtmlAussi" "Vite"]] {
if {$Rep=="macsimHtml"} { set MacsimHtml 1 }
set DescDuRepertoire [DescDuRepertoire $Rep]
lappend LesRefText "[WscopeScience]&FileMoi&$Rep&$Qui" "$Rep\t$DescDuRepertoire"
if {$Rep=="macsimXml" } {
set Rep "macsimHtml"
set DescDuRepertoire [DescDuRepertoire $Rep]
set R "[WscopeScience]&FileMoi&$Rep&$Qui"
set T "$Rep\t$DescDuRepertoire"
lappend LesRefText $R $T
set LesRefText [linsert $LesRefText $PosMacsim $R $T]
set RepJal "macsimJalview"
set DescDuRepertoire [DescDuRepertoire $RepJal]
set R "[WscopeScience]&JalviewHtml&$Qui"
set T "$RepJal\t$DescDuRepertoire"
lappend LesRefText $R $T
set LesRefText [linsert $LesRefText $PosMacsim $R $T]
}
if {[regexp "phylo" $Rep] } {
set Rep "AtvOf$Rep"
set DescDuRepertoire [DescDuRepertoire $Rep]
lappend LesRefText "[WscopeScience]&ATV&$Qui" "$Rep\t$DescDuRepertoire"
}
if {$Rep=="msf" } {
set Rep "msfToHtml"
set DescDuRepertoire [DescDuRepertoire $Rep]
lappend LesRefText "[WscopeScience]&FileMoi&$Rep&$Qui" "$Rep\t$DescDuRepertoire"
continue
}
if {[regexp "msf" $Rep] } {
set RepOri $Rep
set Rep "msfToHtml"
set DescDuRepertoire [DescDuRepertoire $Rep]
lappend LesRefText "[WscopeScience]&FileMoi&$Rep&$RepOri/$Qui" "${RepOri}ToHtml\t$DescDuRepertoire"
}
}
if {$LesRefText=={}} {
return "I didn't found any file about $Qui"
}
return [Html_ListOfRefs $LesRefText \
"<h3 class='darkgreen margin25'>$Qui [Alias $Qui] [DefinitionRapide $Qui]<br/><small>please click</small></h3>" "PleaseSplitText"]
}
set Quoi [ChoixParmi [LesRepertoiresPossiblesPour $Qui]]
if {$Quoi==""} { return "" }
}
if {$Quoi!="" && $Qui==""} { return "Sorry Target not available" }
if {$Comment==""} { set Comment "EnHTML" }
set Titre "[file tail [RepertoireDuGenome]]/$Quoi/$Qui"
set EstUnJpg 0
set EstDejaEnHtml 0
set Probable "[RepertoireDuGenome]/$Quoi/$Qui"
while 1 {
if {[regexp {^[0-9][0-9][0-9]$} $Quoi] && [string equal [string range [Date] 6 8] $Quoi] } {
if {[file exists $Qui]} { set Probable $Qui }
}
if {[file exists $Probable]} {
set EstDejaEnHtml [regexp -nocase {\.html?$} $Probable]
break
}
if {[file exists "$Probable.html"]} {
append Probable ".html"
set EstDejaEnHtml 1
break
}
if {$Quoi=="^AtvOf"} {
set TexteHtml [ATV $Qui]
if {$TexteHtml!=""} { return $TexteHtml }
}
if {$Quoi=="msfToHtml"} {
set TexteHtml [HtmlFromMsf $Qui]
if {$TexteHtml!=""} { return $TexteHtml }
}
if {$Quoi=="macsimHtml"} {
set TexteHtml [HtmlFromXmlMacsim $Qui]
if {$TexteHtml!=""} { return $TexteHtml }
}
if {[regexp "jpg_of_" $Quoi] } {
set Type [StringApres "jpg_of" dans $Quoi]
set ProPro "$Probable$Type.jpg"
if {[FileExists $ProPro]} {
append Probable "$Type.jpg"
set EstUnJpg 1
break
}
}
if {[regexp -nocase ".jpg$" $Probable] } {
set EstUnJpg 1
break
}
return "Sorry $Quoi/$Qui does not exist or cannot be created"
}
if { [regexp -nocase "TelQuel" $Comment] || $EstDejaEnHtml } {
set R [ContenuDuFichier $Probable]
if { ! $EstDejaEnHtml & [regexp -nocase "AvecPre" $Comment] } { return "<pre>$R</pre>" }
return $R
}
if {$EstUnJpg} { return [Html_DuFichierJpg $Probable] }
if {[EstUnPAB $Qui]} { return [SeeAby $Quoi $Qui] }
return [Html_DuTexteTelQuel [ContenuDuFichierAvecReferences $Probable] $Titre]
return [Html_DuTexteTelQuel [ContenuDuFichier $Probable] $Titre]
}
proc Html_ListOfRefs {LesRefText {Titre ""} {PleaseSplitText ""}} {
if {$PleaseSplitText=="PleaseSplitText"} { set PleaseSplitText 1 } else { set PleaseSplitText 0 }
Html_ZeroToBody
Html_Banner Wscope
# Html_Append "<div style='padding:0; margin-left:50%; transform:translate(-50%,0);'>"
# Html_Append "<div>"
Html_Append $Titre
lassign $LesRefText Ref0 Text0
set NbColonnes 1
if {$PleaseSplitText} { set NbColonnes [llength [split $Text0 "\t"]] }
lappend Liste $NbColonnes
lappend Liste "border='1' font-size='75%' cellpadding='3' cellspacing='1' class='wscope_table' style='margin:0 auto'"
lappend Liste ""
foreach I [NombresEntre 1 $NbColonnes] {
set Couleur [CouleurDuNuancier $I $NbColonnes 0.3 0.1 "hexa" 0.7]
lappend Liste "bgcolor='$Couleur' nowrap='nowrap'"
}
foreach {Ref Text} $LesRefText {
if {$PleaseSplitText} {
set PremiereFois 1
foreach Champ [split $Text "\t"] {
if {$PremiereFois} {
lappend Liste [H_Href $Champ $Ref]
set PremiereFois 0
continue
}
lappend Liste $Champ
}
} else {
lappend Liste [H_Href $Text $Ref]
}
}
Html_TableFromList $Liste
# Html_Append "</div>"
Html_BodyToEnd
return [Html_Get]
}
proc LogExpe Texte {
set FiLogExpe "[HomeRipp]/loghtml/logexpe.log"
AppendAuFichier $FiLogExpe $Texte
}
proc Expe Texte {
# LogExpe $Texte
# puts $Texte
return $Texte
return
}
proc HtmlAuthorize NomDeProc {
if { ! [regexp -nocase {^[a-z_\:]+[\:a-z_0-9]*$} $NomDeProc]} { return 0 }
return 1
}
proc ScienceEtCommandeDeQueryString QS {
#rR ATTENTION il y a le meme en Base64Encode !!!!!!!!!!!! voir plus bas
set i [string first "&" $QS]
if {$i<0} {
set Science $QS
set NewQS ""
} else {
set Science [string range $QS 0 [expr $i-1]]
set NewQS [string range $QS [expr $i+1] end]
}
if { ! [regexp -nocase {[a-z]} $NewQS]} { set NewQS "GuideMoi" }
return [list $Science $NewQS]
}
proc HtmlServer {{Methode "Get"} {Valeur ""} {RequestUri ""}} {
#rR ATTENTION il y a le meme en Base64Encode !!!!!!!!!!!! voir plus bas
global env
if {$Methode=="Get"} {
set ValeurQS [set env(QUERY_STRING)]
}
if {$Methode=="QueryFollows"} {
set ValeurQS $Valeur
}
set f [open "[HomeRipp]/log/toto.log" "w"]
puts $f "Valeur dans HtmlServer: $Valeur"
flush $f
close $f
set ScienceEtCommande [ScienceEtCommandeDeQueryString $ValeurQS]
set Science [lindex $ScienceEtCommande 0]
set Commande [lindex $ScienceEtCommande 1]
set LesValeurs {}
set LesNomValeur {}
set GardeLesNoms 0
foreach NomValeur [split $Commande "&"] {
set Valeur ""
if {[regexp "=" $NomValeur]} {
ScanLaListe [split $NomValeur "="] Nom Valeur
} else {
set Nom ""
set Valeur $NomValeur
}
set Valeur [TexteAscii $Valeur]
if {$GardeLesNoms} { lappend LesValeurs $Nom }
lappend LesValeurs $Valeur
#rR Traitement de faveur pour WscopeWebForm
if {$Valeur=="WscopeWebForm"} { set GardeLesNoms 1 }
lappend LesNomValeur $Nom $Valeur
}
set Query "$Science : [join $LesValeurs "&"]"
set Pro [lindex $LesValeurs 0]
if { ! [HtmlAuthorize $Pro]} { Expe "Error from Gscope : $Pro isn't authorized" ; return "" }
#rR on encadre l'exécution pour savoir d'où vient la commande
RequestUriFromWscope $RequestUri
set Retour ""
if {[catch {set Retour [eval $LesValeurs]} Message]} {
set Retour "Error from Gscope : I got following message and response \nMessage :\n$Message\nResponse :\n$Retour"
}
RequestUriFromWscope unset
# if {[regexp {^SetVariableDeRetour_([^=]+)=(.*)} $Retour Match Var Val]} {
# set Retour $Val
# global VariableDeRetour
# set VariableDeRetour($Var) $Val
# LogWscope "execution de set VariableDeRetour($Var) $Val"
# #after idle return ""
# }
# set f [open "[HomeRipp]/log/toto.log" "w"]
# puts $f "Retour dans HtmlServer: $Retour"
# flush $f
# close $f
return $Retour
}
proc HtmlServer64 {{Methode "Get"} {Texte_K_V64 ""} {RequestUri ""}} {
#rR voir ci-dessus l'ancienne version sur Base64
global env
if {$Methode=="Get"} {
set Liste_K_V64 {}
set ValeurQS [set env(QUERY_STRING)]
foreach KV [split $ValeurQS "&"] {
if {[regexp "=" $KV]} {
lassign [split $KV "="] K V
} else {
set K ""
set V $KV
}
set V64 [Base64Encode $K]
lappend Liste_K_V64 "$K=$V64"
}
set Texte_K_V64 [join Liste_K_V64 "&"]
}
if {$Methode=="QueryFollows"} {
# set ValeurQS $Texte_K_V64
}
#rR La on devrait être bon avec tout dans Texte_K_V64
set KScience64 [lindex [split $Texte_K_V64 "&"] 0]
if {[regexp "=" $KScience64]} {
lassign [split $KScience64 "="] K Science64
} else {
set K "science"
set Science64 $KScience64
}
set Science [Base64Decode $Science64]
set Commande64 [join [lrange [split $Texte_K_V64 "&"] 1 end] "&"]
if {$Commande64==""} { set Commande64 "commande=[Base64Encode GuideMoi]" }
set LesMotsDeLaCommande {}
set GardeLesK 0
foreach KV64 [split $Commande64 "&"] {
if {[regexp "=" $KV64]} {
lassign [split $KV64 "="] K V64
} else {
set K ""
set V64 $KV64
}
set Mot [Base64Decode $V64]
if {$GardeLesK} { lappend LesMotsDeLaCommande $K }
lappend LesMotsDeLaCommande $Mot
#rR Traitement de faveur pour WscopeWebForm
if {$Mot=="WscopeWebForm"} { set GardeLesK 1 }
}
set Pro [lindex $LesMotsDeLaCommande 0]
if { ! [HtmlAuthorize $Pro]} { Expe "Error from Gscope : $Pro isn't authorized" ; return "" }
set Retour ""
#rR on encadre l'exécution pour savoir d'où vient la commande
RequestUriFromWscope $RequestUri
if {[catch {set Retour [eval $LesMotsDeLaCommande]} Message]} {
set Retour "Error from Gscope : I got following message and response \nMessage :\n$Message\nResponse :\n$Retour"
}
RequestUriFromWscope unset
return $Retour
}
proc TestFormatQuery {} {
set Query [::http::formatQuery A B "Donnees" "Bonjour Madame il fait beau et 2+2=4"]
Espionne $Query
Espionne [TexteAscii $Query]
exit
}
proc HttpGetUrl {{Url ""} {Query ""}} {
if {$Url==""} { set Url "http://www.lbgi.fr/" }
if {$Query==""} {
set token [::http::geturl $Url -timeout 1000000 ]
} else {
# Quand on met -query il fait un POST sinon GET
set token [::http::geturl $Url -query $Query -timeout 1000000 ]
}
return [::http::data $token]
}
proc Html_ZeroToBody {{Titre ""} {Header ""} {RefDocType ""}} {
lappend Local [Html_Zero]
lappend Local [Html_Doctype $RefDocType]
lappend Local [Html_BeginHtml]
lappend Local [Html_Header $Titre $Header]
lappend Local [Html_BeginBody]
return [join $Local "\n"]
}
proc Html_BodyToEnd {} {
lappend Local [Html_EndBody]
lappend Local [Html_EndHtml]
return [join $Local "\n"]
}
proc Html_Encapsule {TexteHtml {Titre ""} {Header ""} {RefDocType ""}} {
lappend Local [Html_ZeroToBody $Header $RefDocType]
lappend Local [Html_Append $TexteHtml]
lappend Local [Html_BodyToEnd]
return [join $Local "\n"]
}
proc Html_Zero {} {
global H
set H {}
return {}
}
proc Html_BR {} {
return [Html_Append "<br/>"]
}
proc H_Balise {Texte Balise} {
set B "<$Balise>\n$Texte\n</$Balise>"
}
proc H_BalAtt {Texte Balise {LesAttVal {}}} {
set BalAtt "<$Balise"
foreach {Attribut Valeur} $LesAttVal {
if {$Attribut eq "ValueOnly"} {
append BalAtt " $Valeur"
} else {
append BalAtt " $Attribut=\"$Valeur\""
}
}
append BalAtt ">"
append BalAtt $Texte
append BalAtt "</$Balise>"
return $BalAtt
}
proc H_Font {Texte {Fonte ""}} {
if {$Fonte==""} { set Fonte "Courier New,Courier" }
set Font [H_BalAtt $Texte "font" [list "face" "$Fonte"]]
return $Font
}
proc H_Face {Texte {Fonte ""}} {
return [H_Font $Texte $Fonte]
}
proc H_Color {Texte {Couleur ""}} {
if {$Couleur==""} { set Couleur "red" }
set Hexa [ColorHexa $Couleur]
set Color [H_BalAtt $Texte "font" [list "color" "$Hexa"]]
return $Color
}
proc H_Bold Texte {
return [H_Balise $Texte "b"]
}
proc H_Italic Texte {
return [H_Balise $Texte "i"]
}
proc H_Center Texte {
return [H_Balise $Texte "center"]
}
proc H_Balises {Texte LesBalises} {
if {$LesBalises=={}} { return $Texte }
set Bal [lindex $LesBalises 0]
return "<$Bal>\n[H_Balises $Texte [lrange $LesBalises 1 end]]\n</$Bal>"
}
proc Html_Append Texte {
global H
lappend H $Texte
return $Texte
}
proc Html_Insert {Ici Texte} {
global H
set H [linsert $H $Ici $Texte]
return $Texte
}
proc Html_lGet {{ZeroIt ""}} {
global H
if {$ZeroIt!="ZeroIt"} { return $H }
set Tmp $H
set H {}
return $Tmp
}
proc Html_Get {{ZeroIt ""}} {
return [join [Html_lGet $ZeroIt] "\n"]
}
proc Html_GetPosition {} {
global H
return [llength $H]
}
proc Html_DuTexteTelQuel {TexteOuNomDuFichier {Titre ""} {Header ""} {RefDocType ""}} {
if {[regexp " " $TexteOuNomDuFichier] || ! [file exists $TexteOuNomDuFichier]} {
set NomDuFichier "Raw text"
set Texte $TexteOuNomDuFichier
} else {
set NomDuFichier $TexteOuNomDuFichier
set Texte [ContenuDuFichier $NomDuFichier]
}
if {$Titre==""} { set Titre $NomDuFichier }
if {[regexp {^ *<\?xml} $Texte]} { return $Texte }
lappend Local [Html_Zero]
lappend Local [Html_Doctype $RefDocType]
lappend Local [Html_BeginHtml]
lappend Local [Html_Header $Titre $Header]
lappend Local [Html_BeginBody]
lappend Local [Html_Teletype $Texte]
lappend Local [Html_EndBody]
lappend Local [Html_EndHtml]
Html_Zero
return [join $Local "\n"]
}
proc Html_DuScript {ScriptOuFichier} {
if {$ScriptOuFichier==""} { return "" }
if {[regexp " " $ScriptOuFichier]} {
set Script $ScriptOuFichier
} else {
set Script [ContenuDuFichier $ScriptOuFichier]
}
lappend ToutScript "<script>"
lappend ToutScript $Script
lappend ToutScript "</script>"
set ToutScript [join $Script "\n"]
return [Html_Append $ToutScript]
}
proc Html_Doctype {{Reference ""}} {
# if {$Reference==""} { set Reference "\"http://www.w3.org/TR/html4/strict.dtd\"" }
# set Doctype "<!DOCTYPE HTML public \"-//w3c//dtd HTML 4.01 Transitional//EN\" $Reference >"
# set Doctype "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">"
set Doctype "<!DOCTYPE HTML>"
return [Html_Append $Doctype]
}
proc Html_Title {{Titre ""}} {
if {$Titre==""} { set Titre "[Science] Wscope" }
lappend Local [Html_Append "<title>"]
lappend Local [Html_Append " $Titre"]
lappend Local [Html_Append "</title>"]
return [join $Local "\n"]
}
proc Html_BeginBody {} {
global WithLogoBing
set BeginBody "<body style='width:100%'>"
if {[info exists WithLogoBing] && $WithLogoBing=="WithLogoBing"} {
append BeginBody "\n[H_LogoBInG]"
}
return [Html_Append $BeginBody]
}
proc Html_EndBody {} {
return [Html_Append "</body>"]
}
proc Html_BeginHtml {} {
return [Html_Append "<html>"]
}
proc Html_EndHtml {} {
return [Html_Append "</html>"]
}
proc Html_UTF8 {} {
return [Html_Append "<meta http-equiv=\"content-type\" content=\"text/html;charset=utf-8\" />"]
}
proc Html_Header {{Titre ""} {Header ""}} {
lappend Local [Html_Append "<head>"]
lappend Local [Html_Append "<link rel='icon' type='image/ico' href='/logos/faviconGscope.ico'>"]
lappend Local [Html_Title "$Titre"]
lappend Local [Html_UTF8]
if {$Header!=""} {
lappend Local [Html_Append $Header]
}
if {[PourWscope]} { lappend Local [Html_Append [CssWscope]] }
lappend Local [Html_Append "</head>"]
return [join $Local "\n"]
}
proc Html_TheEnd {} {
set TheEnd "</body>\n</html>"
return [Html_Append $TheEnd]
}
proc Html_Teletype {Texte {WithoutPre ""}} {
set BonTexte $Texte
set Remettre 0
set LesD {}
set LesX {}
while {[set D [string first "<<<KeepChevrons" $BonTexte]]>=0} {
set Remettre 1
set F [string first "KeepChevrons>>>" $BonTexte]
incr F [string length "KeepChevrons>>>"]
set X [string range $BonTexte $D $F]
regsub "<<<KeepChevrons" $X "" X
regsub "KeepChevrons>>>" $X "" X
set BonTexte [string replace $BonTexte $D $F "ChevronsARemettreIciMerci"]
lappend LesX $X
}
regsub -all "&" $BonTexte {\&} BonTexte
regsub -all "<" $BonTexte {\<} BonTexte
regsub -all ">" $BonTexte {\>} BonTexte
if {$Remettre} {
foreach X $LesX {
set D [string first "ChevronsARemettreIciMerci" $BonTexte]
set F [expr $D + [string length "ChevronsARemettreIciMerci"] - 1]
set BonTexte [string replace $BonTexte $D $F $X]
}
}
if {[string equal -nocase $WithoutPre "WithoutPre"]} { return $BonTexte }
set Teletype "<pre>\n$BonTexte\n</pre>"
return [Html_Append $Teletype]
}
proc H_Href {Texte Url {AutresAttributs ""}} {
if {[string trim $Texte]==""} { return " "; }
if {$Url==""} { set HrefUrl "href=\"#\"" } else { set HrefUrl "href=\"$Url\"" }
set Href "<a $HrefUrl $AutresAttributs>$Texte</a>"
return $Href
}
proc Html_Href {Texte Url {AutresAttributs ""}} {
return [Html_Append [H_Href $Texte $Url $AutresAttributs]]
}
proc H_LogoBInG {} {
return [H_Center [H_Href "<img src=\"../../gag/logoBInG_50.gif\" Border=2>" \
"[LbgiUrl]/~ripp/logoBInG.html"]]
}
proc Html_BaliseOpen {Balise {Attributs ""}} {
if {$Attributs==""} {
set Local "<$Balise>"
} else {
regsub -all {\\'} $Attributs "SiMpLeQuOtE" Attributs
regsub -all {\'} $Attributs "\"" Attributs
regsub -all "SiMpLeQuOtE" $Attributs "'" Attributs
set Local "<$Balise $Attributs>"
}
return [Html_Append $Local]
}
proc Html_BaliseClose {Balise} {
return [Html_Append "</$Balise>"]
}
proc Html_Balise {Texte Balise {Attributs ""}} {
set Local {}
lappend Local [Html_BaliseOpen $Balise $Attributs]
lappend Local [Html_Append $Texte]
lappend Local [Html_BaliseClose $Balise]
return [join $Local "\n"]
}
proc Html_NewLine {{Texte ""}} {
return [Html_Append "<br/>\n$Texte"]
}
proc ColorHexa name {
if {[string index $name 0] != "#"} {
set list [winfo rgb . $name]
set red [lindex $list 0]
set green [lindex $list 1]
set blue [lindex $list 2]
set shift 8
} else {
case [string length $name] {
4 {set format "#%1x%1x%1x" ; set shift -4}
7 {set format "#%2x%2x%2x" ; set shift 0}
10 {set format "#%3x%3x%3x" ; set shift 4}
13 {set format "#%4x%4x%4x" ; set shift 8}
default {error "syntax error in color name \"$name\""}
}
if {[scan $name $format red green blue] != 3} {
error "syntax error in color name \"$name\""
}
}
if {$shift>=0} {
set red [expr $red >> $shift]
set green [expr $green >> $shift]
set blue [expr $blue >> $shift]
} else {
set red [expr ($red << -$shift) + $red]
set green [expr ($green << -$shift) + $green]
set blue [expr ($blue << -$shift) + $blue]
}
set color [format "#%02x%02x%02x" $red $green $blue]
return $color
}
proc HttpCopyRR {url {aliste ""} {Query ""}} {
#rR 20190201 j'ai rajouté pour le https
#rR et si ya redirection il faut tester Location: et remmettre https://machin devant la nouvelel location
if {[regexp https $url]} {
package require tls
http::register https 443 [list ::tls::socket -tls1 1] ;# "-tls1 1" is required since [POODLE]
}
#rR existe dans ordali/ordali_web.tcl et gscope/gscope_html.tcl
#rR si aliste est vide on return la liste sinon
#rR on return 1 et la liste dans liste
#rR moumou traite aussi les redirections (jusqu'a 5 imbriquees)
#rR Si jamais ca ne marche pas voir s'il n'y a pas un autre
#rR HttpCopy dans un gscopublic ...
#lm
#lm change tous les retours pour inclure
#lm ::http::cleanup qui libere la memoire
#lm voir wiki
if {$aliste eq ""} {set NothingFound 0} {set NothingFound ""}
if {$aliste ne ""} {upvar $aliste liste}
if {$Query ne ""} {
set token [::http::geturl $url -query $Query]
} else {
set token [::http::geturl $url]
}
upvar #0 $token state
Espionne $state(meta)
set liste [split $state(body) "\n"]
set iLocation -1
if {$iLocation<0} { set iLocation [lsearch -exact $state(meta) "Location"] }
if {$iLocation<0} { set iLocation [lsearch -exact $state(meta) "location"] }
set SansLocation [expr {$iLocation < 0}]
if { $SansLocation} {
#rR Cas general
::http::cleanup $token
if {$aliste ne ""} {
return 1
} else {
if {[info exists ::TryHttpCopyNTimes]} {
unset ::TryHttpCopyNTimes
}
return [join $liste "\n"]
}
}
#rR the following is to handle URL redirects
set Location [lindex $state(meta) [incr iLocation]]
if { ! [regexp {^http} $Location]} {
if {[regexp {^(https?://[^/]+)/} $url Match DebutUrl]} { set Location "$DebutUrl$Location" }
}
#Espionne $Location
incr ::TryHttpCopyNTimes
if {$::TryHttpCopyNTimes > 5} {
::http::cleanup $token
unset ::TryHttpCopyNTimes
return $NothingFound
}
::http::cleanup $token
set RetourRecursif [HttpCopyRR [string trim $Location] $aliste]
if {[info exists ::TryHttpCopyNTimes]} { unset ::TryHttpCopyNTimes }
return $RetourRecursif
}
proc HttpGetTextFromUrlRR Url {
set token [::http::geturl $Url -timeout 1000000]
upvar #0 $token State
unset token
return $State(body)
}
proc HttpProgressRR {args} {
puts -nonewline stderr . ; flush stderr
return
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.