#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 "&nbsp;" }
	if {$D==""} { set D "&nbsp;" }
	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/>&nbsp;&nbsp;&nbsp;&nbsp;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 " &nbsp;&nbsp;&nbsp;&nbsp;"
    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 " &nbsp;&nbsp;&nbsp;&nbsp;"
    Html_Append " <label for='SynonymString'>GeneName Synonym : </label>"
    Html_Append " <input type='text' name='SynonymString' id='SynonymString' value=''>"
    Html_Append " &nbsp;&nbsp;&nbsp;&nbsp;"
    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 {\&nbsp;} 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 {\&lt;} $Page "<" Page
    regsub -all {\&gt;} $Page ">" Page
    regsub -all {\&quot;} $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 {\&lt;} $Page "<" Page
    regsub -all {\&gt;} $Page ">" Page
    regsub -all {\&quot;} $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]&amp;FicheMoi&amp;$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 " &bull; "]
	lappend BackTo [Html_Href " Genoret"      [GenoretUrl]      "title='GenoretDatabase home page'"]
	lappend BackTo [Html_Append " &bull; "]
	lappend BackTo [Html_Href " GenoretGenes" [GenoretGenesUrl] "title='GenoretGenes home page'"]
    }
    if {1} {
	lappend BackTo [Html_Append " &bull; "]
	lappend BackTo [Html_Href " ICube"           "http://icube.unistra.fr" \
			    "title='ICube - home page'"]
	
	lappend BackTo [Html_Append " &bull; "]
	lappend BackTo [Html_Href " CSTB"            "http://icube-cstb.unistra.fr" \
			    "title='Complex Systems and Translational Bioinformatics - home page'"]

	lappend BackTo [Html_Append " &bull; "]
	lappend BackTo [Html_Href " LBGI"            [LbgiUrl] \
			    "title='LBGI BioInformatique et Génomique Intégratives - home page'"]

	lappend BackTo [Html_Append " &bull; "]
	lappend BackTo [Html_Href "WelcomeToWscope"        "[WscopeScience]&amp;WelcomeToWscope" \
			    "title='Lists all Gscope Projects'"]

	lappend BackTo [Html_Append " &bull; "]
	lappend BackTo [Html_Href "[Science]"        "[WscopeScience]" \
			    "title='[Science] general information entry point'"]

	lappend BackTo [Html_Append " &bull; "]
	lappend BackTo [Html_Href "List" "[WscopeScience]&amp;FileMoi" \
			    "title='all entry points for [Science]'"]
	
	if {$Nom!=""} {
	lappend BackTo [Html_Append " &bull; "]
	lappend BackTo [Html_Href "$Nom" "[WscopeScience]&amp;FileMoi&$Nom" \
			    "title='See all available data about $Nom'"]
	}

	lappend BackTo [Html_Append " &bull; "]
	lappend BackTo [Html_Href "Search" "[WscopeScience]&amp;RechercheMoi" \
			    "title='search any word in (the infos files of) [Science]'"]
    }
    if {[OnTraiteBalibase]} {
	lappend BackTo [Html_Append " &bull; "]
	lappend BackTo [Html_Href "BAliBASE home page" \
			    "/balibase/index.html"]
    }
    if {[OnTraite "KoAnno"]} {
	lappend BackTo [Html_Append " &bull; "]
	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&nbsp;&nbsp;&nbsp;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/>&nbsp;&nbsp;&nbsp;&nbsp;<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 " &nbsp;&nbsp;&nbsp;&nbsp;"
    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 " &nbsp;&nbsp;&nbsp;&nbsp;"
    Html_Append " <label for='SynonymString'>GeneName Synonym : </label>"
    Html_Append " <input type='text' name='SynonymString' id='SynonymString' value=''>"
    Html_Append " &nbsp;&nbsp;&nbsp;&nbsp;"
    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 "\&amp;" 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]&amp;OuSontLesMutations" "OuSontLesMutations ?"
    }
    lappend LesRefText "[LbgiUrl]/wikili/index.php/Gscope"      "Get help from Wiki"
    lappend LesRefText "[WscopeScience]&amp;RechercheMoi"       "Search for a gene, a description, etc..."
    lappend LesRefText "[WscopeScience]&amp;FileMoi"            "List all $N sequences [PreFixe]"
    lappend LesRefText "[WscopeScience]&amp;FicheMoi"           "List information files"
    lappend LesRefText "[WscopeScience]&amp;SynonymsPourTous&amp;&amp;GetHtml&amp;GscopeSyn"     "List all $N sequences Synonyms"
    lappend LesRefText "[WscopeScience]&amp;SynonymsPourTous&amp;&amp;GetHtml&amp;SynGscope"     "List all Synonyms GscopeIds"
    lappend LesRefText "[WscopeScience]&amp;Environ"                                             "Show environment"
    lappend LesRefText "[WscopeScience]&amp;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&amp;GenomiqueComparativeParBlast&amp;$Bank" "Genomique Comparative par <b>$Bank</b>"
	}
    }
    if {[Science]=="RetGene"} {
	lappend LesRefText ""  ""
	lappend LesRefText "[WscopeScience]&amp;RetGeneMutationOnWeb" "Summary of all mutations"
    }
    if {[OnTraiteUCSCGenomes]} {
	lappend LesRefText ""  ""
	lappend LesRefText "[WscopeScience]&amp;CytoBandUcsc&amp;ListOf&amp;Organisms" "List of available organisms for CytoBandUcsc"
	lappend LesRefText "[WscopeScience]&amp;CytoBandUcsc&Human&List&amp;Of&amp;CytoBands" "Human CytoBands"
	lappend LesRefText "[WscopeScience]&amp;CytoBandUcsc&Mouse&amp;List&amp;Of&amp;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]&amp;FicheMoi&amp;$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]&amp;GeneIdentityCard&amp;$Nom" $Info
		} else {
		    lappend LesRefText "[WscopeScience]&amp;FileMoi&amp;$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]&amp;FileMoi&amp;$Rep&amp;$Qui" "$Rep\t$DescDuRepertoire"
		if {$Rep=="macsimXml" } {
		    set Rep "macsimHtml"
		    set DescDuRepertoire [DescDuRepertoire $Rep]
		    set R "[WscopeScience]&amp;FileMoi&amp;$Rep&amp;$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]&amp;JalviewHtml&amp;$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]&amp;ATV&amp;$Qui" "$Rep\t$DescDuRepertoire"
		}
		if {$Rep=="msf" } {
		    set Rep "msfToHtml"
		    set DescDuRepertoire [DescDuRepertoire $Rep]
		    lappend LesRefText "[WscopeScience]&amp;FileMoi&amp;$Rep&amp;$Qui" "$Rep\t$DescDuRepertoire"
		    continue
		}
		if {[regexp "msf" $Rep] } {
		    set RepOri $Rep
		    set Rep "msfToHtml"
		    set DescDuRepertoire [DescDuRepertoire $Rep]
		    lappend LesRefText "[WscopeScience]&amp;FileMoi&$Rep&amp;$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 {\&amp;} BonTexte
    regsub -all "<" $BonTexte {\&lt;}  BonTexte
    regsub -all ">" $BonTexte {\&gt;}  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 "&nbsp;";  } 
    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
}