########################################################################
# html-mode.tcl - mode for editing html code
# 
# Modifié :
# 
#  20/07/95 (Maurice DIAMANTINI : diam@ensta.fr)
#  26/08/99 : correction patterne de colorisation pour "<A   HREF...>" 
#  17/11/99 : modif des alias a, aa, href et href2 et ajout des
#            synonymes a, aa, ah et aah
#  13/04/00 : création des proc pour menu et électricAlias
#             (pour meilleure encapsulation)
#             et rajout d'lias pour listes (ul, ol, ...)
#  15/12/00 : ajout d'alias et menu pour Bold, em, ...
#  25/01/01 : modif alias et menu pour code, tt et pre 
#                 (création prec pour p^re + class, ...
#  23/07/01 : rajout alias li, br, p et - (petit mais fréquent :-)
###########################################################################

## mode_html_init -- 
# 
# 
proc mode_html_init {  } {
    
    global stead
    global xtext
    upvar 0 stead(text) w
    
    global EDITPREFS
    
    # Les commandes à exécuter si on quitte ce mode
    set stead(mode,cleanupCmds) [list]



    # cette variable contient une liste de fichier à éditer dans ce mode
    global MODE_FAST_EDIT
    set MODE_FAST_EDIT {
        /insert/here/you/favorite/list/of
        /HTML/modeles
        see_file__html-mode.tcl__in_stead_library
    }


    # On redéfinit la liste des parentheses pour y inclure "<" et ">"

    # On ajoute à la spécification de parentheses les crochets
    # BUG : il faudrait remettre à l'état initial si on quitte le mode html
    # 
    # liste de triplets de la forme {rightSym leftChar rightChar}
    # 
    # diam : commenté le 05/12/01 pour voir si c'est la cause de l'inefficacité
    # 

    # On veut balancer des termes comme table ou TABLE par :
    # 
    #    lappend xtext(balance_list) [list table <table </table>] 
    #    lappend xtext(balance_list) [list TABLE <TABLE </TABLE>] 
    # 
    # Attention :
    #   - on peut avoir <a> ... </a>  ou  <a popo-"value"> ... </a>
    #   - <a> ne doit pas etre confondu avec <applet> 
    #     Rien à faire tant que le type regexp n'est pas implémenté
    #     car toute bidouille induit des tas de bug !
    #     Par exemple <b> ... </body> serait accepté
    # 
    set balanceKeys {  
        a  
        q strong tt emph ul ol dl h1 h2 h3 h4 h5 h6 
        html head body table td tr th  tbody
        div span font code kbd 
        form select
        center
        script  title
    }
    # addum pour xml (fichir build.xml de ant)
    lappend balanceKeys \
            project description target java javac javadoc zip junit \
            classpath 
            
    foreach key $balanceKeys  {
        lappend xtext(balance_list) [list $key "<$key"  "</$key>"]
        # set key [string toupper $key]
        # lappend xtext(balance_list) [list $key "<$key"  </$key>]
    }
    # Cette parenthèse monocaractère perturbe les parenthèses multi-caractères 
    # précédentes = ligne commentée par diam le 04/07/02 
    # brouillon : 
    #       puts [join $xtext(balance_list) \n]
    #       set xtext(balance_list) [list]
    lappend xtext(balance_list) [list greater < >] 


    # défini le préfixe pour le mode HTML (utilisé pour mettre en commentaires)
    set EDITPREFS(prefix) "// "
    
    # Utilisé pour mémoriser la commande UNIX de compilation :
    set stead(unixCommand) {netscape  &}
    

    # chaine de recherche (utilisé pour le générer le menu de navigation) :
    # On cherche lesheader de la forme <H4> Fournisseur, sociétés, ... </H4>
    # 
    global TE_MODE_SEARCH_STRING TE_MODE_NAVIG_SHOW_TEXT  
    # Modif diam le 21/01/04 pour ajouter les <target...> de ant (en xml)
    # # set    t1 {<[hH][0-9]>}
    # # append t1 "(\[^\n\]*)\n"
    set    t1 {(?i)<h[0-9][ >]}
    append t1 {([^\n]*)\n}
    append t1 {|(?:<target\s+name\s*=\s*")([\w\d_-]+)"}
    set TE_MODE_SEARCH_STRING $t1
    
    set TE_MODE_NAVIG_SHOW_TEXT "plan" ;# nom de menu de navigation
}


## mode_html_defineStyles -
# 
# 
proc mode_html_defineStyles {} {
    
    global stead
    upvar 0 stead(text) w
    
    # # # # On commence par supprimer tout style précédent de la feuille "tcl"
    # # # xtext_style $w delete html
    
    lappend stead(mode,cleanupCmds) \
                        [list xtext_style $w delete $stead(mode)]

    # style "elements" pour les mots clé HTML 
    # 
    # MODIF diam le 21/01/04 pour aléger les fichiers xml
    # 
    # # xtext_style $w define html elements {
    # #     -type regexpPair
    # #     -config {-foreground blue}
    # #     -prePat {<(/)?\s*.}
    # #     -postPat {>}
    # # }
    # On colorie les chaine du genre :
    #   <target
    #   </target
    #   
    xtext_style $w define html elements {
        -type regexp
        -config {-foreground blue}
        -pat {<(/)?([\w\d_-]+(/>|>)?)|/?>}
    }
    
    # style "specChars" pour les caracteres spéciaux html  : &eacute;
    # 
    xtext_style $w define html specChars {
        -type regexpLight
        -config {-foreground #0C0}
        -pat {&\w+;}
    }

    # les chaines de caractère entre double quote
    xtext_style $w define html doubleQuote {
        -type regexp
        -config {-foreground DarkViolet}
        -pat {"[^"]*"}
    }

    # 
    # style "header" pour les titres <h2>...</h2>
    # 
    # 27/11/02 (diam) je ne colorie plus un titre entier,  car les en-tetes
    # multi-lignes surchargent la coloration !
    # 
    # xtext_style $w define html header {
    #     -type regexpPair
    #     -config {-foreground red}
    #     -prePat {(?i)<h[1-9]( [^>]*)*}
    #     -postPat {(?i)</h[1-9]>}
    # }
    # Le mode regexpPair et plus lourd, (perturbation temporaire des couleur)
    # et pas forcément nécessaire dans ce cas. => je passe en mode regexpLine
    xtext_style $w define html header {
        -type regexpLight
        -config {-foreground red}
        -pat {(?i)<(h[1-9][^>]*|/h[1-9])>}
    }
    # xtext_style $w define html antTarget {
    #     -type regexp
    #     -config {-foreground red}
    #     -pat {(?i)<(target\s+name\s*=\s*".*")}
    # }
    xtext_style $w define html antTarget {
        -type regexp
        -config {-foreground red}
        -pat {(?i)<target\s+name\s*=\s*"(.*)"|</target>}
    }

    # 
    # style "href" pour les hyper-ref  <a href= xxxx>...</a>
    # 
    # # xtext_style $w define html href {
    # #     -type regexp
    # #     -config {-foreground Maroon}
    # #     -pat {(?i)\y(:?href|src|action)\s*=\s*".*?"}
    # # }
    # # CE QUI SUIT FONCTIONNE
    # # xtext_style $w define html href {
    # #     -type regexp
    # #     -config {-foreground Maroon}
    # #     -pat {(?i)\y(?:(href|src|action)\s*=\s*)".*?"}
    # # }
    xtext_style $w define html href {
        -type regexpLine
        -config {-foreground Maroon}
        -pat {(?i)\y(?:href|src|action)(?:\s*=\s*)(".*?")}
    }

    # 
    # style pour les erreur potencielles  a < b ou  i>=3
    # Inconvénient : on interdit les balises avec un espace en trop
    #       < b >
    #       
    # autorisation de 
    #     <biuiuui...
    #     <HGFGFG...
    #     </xxx
    #     />
    #     
    # interdiction de :
    #     < b...  ( donc de < b > pourtant correct)
    #     <1...
    #     
    #     (xxx<yyy) 
    #     
    #     (xxx>yyy) 
    #     xxx ) > 
    #     
    #     >=
    #     
    #     
    # xtext_style $w define html error {
    #     -type regexpLight
    #     -config {-background red}
    #     -pat {(<[^/A-z!]|\([^\)]*<[^>\(]*\)|\([^<\)]*>[^\(]*\)|>=|\)\s*>)}
    # }
    xtext_style $w define html error {
        -type regexpLight
        -config {-background #F88}
        -pat {(<[^/A-z!\?]|\([^\)]*<[^>\(]*\)|\([^<\)]*>[^\(]*\)|>=|\)\s*>)}
    }

    # style "comment" pour les commentaires html  <!-- xxx -->
    # 
    xtext_style $w define html comment {
        -type regexpPair
        -config {-foreground #080}
        -prePat {<!--}
        -postPat {-->}
    }

    xtext_style $w enable html
}


## mode_html_getHelp - retourne une chaine d'info spécifique au mode tcl
# 
proc mode_html_getHelp {} {

  set help {\

    Aide du mode Html : 
    
    Le menu "Plan" permet d'accéder rapidement à une procédure du fichier.


    Abbréviation statiques : 
    ------------------------
    Taper l'abrév. suivis de <Meta-Espace>, 
    

    alias          résultat
    ^^^^^          ^^^^^^^^
    
    html           Crée un prototype de fichier html
    htm            Crée un prototype de fichier html (minimaliste)
    
    header1 (h1)   En-tete de niveau 1 "<h1> xxx ... </h1> "
    ...
    header6 (h6)   En-tete de niveau 1 "<h6> xxx ... </h6> "
    
    a              ancre simple : "<a href=xxx> xxx </a>"
    aa             ancre multiligne : "<a href=xxx>\n xxx \n</a>"
    
    ah ou href     ancre avec demande d'une url
    aah ou href2   ancre multiligne avec demande d'une url 
    
    ul             bloc de listes non numérotée
    ol             bloc de listes numérotée
    dl             bloc de listes de description
    
    -----------------------------------------------------------------
    
    Astuce pour faciliter la creation de liste d'URL
    
        Options de recherche : Regexp et By line
        Rechercher :     (.+)
        remplacer par :  <li> <A HREF="\0">\n      (\0)</A>\n


    A l'intérieur de ces structures <Control-j> permet de sauter d'une
    marque à l'autre. 

    
    Raccourcis claviers : (à compléter)
    ---------------------
    <meta-1>       insertion d'une ligne séparatrice "<!--...-->"
    <Contol-Meta-b> => bold
    <Contol-Meta-i> => italic
    <Contol-Meta-t> => bloc tt
    ...
    <Contol-Meta-y> => bloc interactif court (demande le tag)

  }
  return $help
}



## separator {{NbLines 1}}
# 
# Insère "Nblines" lignes (défaut : 1) correspondant au separateur 
# souhaité  (soit "<!--...--> en HTML);
# Cette procédure est automatiquement liée à <Meta-1>
# 
# Modif 21/05/02 
#   remplacement de  <!------------> 
#   par <!--==========-->
# Car la chaine "--" est refusée à l'intérieur d'un commentaire xml 
# (build.xml pour le constructeur ant)
# 
proc separator {{NbLines 1}} {

    global stead
    set w $stead(text)
    
    global EDITPREFS
    
    # On définit une ligne de séparation de la forme <!-------->
    # d'une longueur fonction de la pref utilisateur "fillcolumn"
    # auquel on rajoute des espace pour revenir a la meme colonne.
    
    # Ncolonne contiendra le nbre de caracteres depuis le début de ligne
    set Ncolonne [lindex [split [$w index insert]  .] 1]
  
    # Nombre de caracteres de remplissage de facon a ne pas depasser 
    # la longueur maxi d'une ligne :
    set N [expr $EDITPREFS(fillcolumn) - 7 -$Ncolonne]
    
    set LineSep {<!--}
    for {set i 1} {$i<=$N} {incr i} {append LineSep "="}
    append LineSep "-->\n"
    
    # On rajoute le nombre d'espace correspondant à l'indentation
    for {set i 1} {$i<$Ncolonne} {incr i} {append LineSep " "}
    
    
    # Sauvegarde du con texte (en vue undo éventuel) :
    xtext_pushState
    xtext_markDirty $w
  
    for {set i 1} {$i <= $NbLines} {incr i} {
        $w insert insert $LineSep
    }
    xtext_updateInsertPos $w
 

} ;# endproc separator

## mode_html_defineSabbrev -- 
# 
# 
# 
proc mode_html_defineSabbrev {} {
        
    # Pour simplifier l'écriture des electricAlias : on déclare
    # les variables M, B, E et V au niveau local pour 
    # 
    #      M :  Marque temporaire
    #      B :  début de postcommande 
    #      E :  fin de postcommande
    #      V :  Inclusion d'une variable TCL
    # 
    electricAlias-use8bitsCars

    ###########################################################################
    # Alias pour le mode HTML
    
    electricAlias-def ${M}html ${M}html ${M}html
    
    ####################################################################
    # alias divers :
    
    
    # une nouvelle page html   (minimaliste)
    set a    {<html><head>}
    append a {<title>[setStop]</title></head>\n\n}
    append a {<body>\n[setStop]\n</body>\n</html>\n}
    electricAlias-def html htm $a
    
    # une nouvelle page html 
    set a    {<html>\n<head>\n[i]}
    append a {<title>[setStop]</title>\n</head>\n\n}
    append a {<body>\n[setStop]\n</body>\n</html>\n}
    electricAlias-def html html $a
    
    
    
    # styles
    set a    {<style type="text/css">\n[i][setStop]}
    append a {\n</style>\n}
    electricAlias-def html style $a
    electricAlias-def html css $a
    
    # styles : fichier eXterne 
    set a    {<link rel="stylesheet" type="text/css" href="[setStop]"> />\n}
    append a {[i][setStop]}
    electricAlias-def html stylex $a
    electricAlias-def html cssx $a
    
    # styles : fichier eXterne version "@import" semble ne pas marcher
    # set a    {<style type="text/css">\n}
    # append a {[i]@import url([setStop])}
    # append a {\n</style>\n}
    # electricAlias-def html stylex2 $a
    # electricAlias-def html cssx2 $a
    
    # javascript
    set a    {<script type='text/javascript'>\n[i][setStop]}
    append a {\n</script>\n}
    electricAlias-def html javascript $a
    electricAlias-def html script $a
    electricAlias-def html js $a
    
    
    # espace insécable
    electricAlias-def html nb "&nbsp;"
    electricAlias-def html nb2 "&nbsp;&nbsp;"
    electricAlias-def html nb3 "&nbsp;&nbsp;&nbsp;"
    electricAlias-def html nb4 "&nbsp;&nbsp;&nbsp;&nbsp;"
    
    ###########################################################################
    # Les différents type de lien :
    
    # Une ancre simple "a"  :  <a href=xxx> </a> 
    set a    "<a href=\"$M\">$M</a>$M"
    electricAlias-def html a $a
    
    # Une ancre multiligne "aa"  :  <a href=xxx>\n </a> 
    set a    "<a href=\"$M\">\n$M\n</a>\n$M"
    electricAlias-def html aa $a
    
    # une ancre avec demande de l'URL "ah" ou "href"
    set a    "${B}askalias {URL name} URL${E}"
    append a "<a href=\"$V{URL}\">$V{URL}</a>$M"
    electricAlias-def html ah $a
    electricAlias-def html href $a
    
    # une ancre multiligne avec double ecriture de l'URL "aah" ou "href2"
    set a    "${B}askalias {URL name} URL${E}"
    append a "<a href=\"$V{URL}\">\n$V{URL}\n</a>\n$M"
    electricAlias-def html aah $a
    electricAlias-def html href2 $a
    
    # Formulaire (exemple complet)
    # 
    set a    {<form action="http://www.ensta.fr/[setStop]" method=post>\n\n}
    append a {[i]Nom :    <input name="name"      size=46>\n}
    append a {[i]<br/>\n}
    append a {[i]Prénom : <input name="firstname" size=46>\n}
    append a {[i]<br/>\n}
    append a {[i]<br/>\n}
    append a {[i]Sexe : &nbsp;&nbsp;\n}
    append a {[i][i]<input name="sexe" type=radio value="Masculin">\n}
    append a {[i][i][i]Masculin\n}
    append a {[i][i]<input name="sexe" type=radio value="Féminin">\n}
    append a {[i][i][i]Féminin\n}
    append a {[i][i]<input name="sexe" type=radio value="Neutre">\n}
    append a {[i][i][i]Neutre (:-)\n}
    append a {[i]<br/>\n}
    append a {[i]Sexe : &nbsp;\n}
    append a {[i][i]<select name="sexe2">\n}
    append a {[i][i][i]<option value="masculin">Masculin          <option>\n}
    append a {[i][i][i]<option value="feminin" selected>Féminin  <option>\n}
    append a {[i][i][i]<option value="neutre">Neutre (:-)        <option>\n}
    append a {[i][i]</select>\n}
    append a {[i]<br/>\n}
    append a {[i]<br/>\n}
    append a {[i]Aime : &nbsp;&nbsp;\n}
    append a {[i][i]<input name="aime" type=checkbox value="hommes">\n}
    append a {[i][i][i]Les hommes &nbsp;&nbsp;\n}
    append a {[i][i]<input name="aime" type=checkbox value="femmes">\n}
    append a {[i][i][i]Les femmes &nbsp;&nbsp;\n}
    append a {[i]<br/>\n}
    append a {[i]Sexe : &nbsp;\n}
    append a {[i][i]<select name="aime2">\n}
    append a {[i][i][i]<option value="hommes">Hommes          <option>\n}
    append a {[i][i][i]<option  value="femmes" selected>Femmes <option>\n}
    append a {[i][i]</select>\n}
    append a {[i]<br/>\n}
    append a {[i]<br/>\n}
    append a {[i]<input type=reset value="Raz">\n}
    append a {[i]<input type=submit value="Envoyer!">\n}
    append a {[i]<br/>\n}
    append a {[i]<br/>\n}

    append a {</form>\n}
    electricAlias-def html Form $a
    
    
    # # Quelques macros simples et fréquentes :
    electricAlias-def html -     {<br/>&nbsp;-&nbsp;\n}
    electricAlias-def html li    {<li>\n    }
    electricAlias-def html p     {<p>\n}
    electricAlias-def html pp    {<p>\n[i][setStop]\n</p>}
    electricAlias-def html br    {<br\>\n}
    
    # pour définir un label
    # electricAlias-def html name    "<a name=\"$M\"></a>\n$M"
    electricAlias-def html name    {<a name=\"[setStop]\"></a>\n[setStop]}

    
    # Quelques caracteres spéciaux :
    electricAlias-def html >    "&gt;"
    electricAlias-def html <    "&lt;"
    electricAlias-def html &    "&amp;"
    
    electricAlias-def html >>    "&raquo;"
    electricAlias-def html <<    "&laquo;"
    
    
    ####################################################################
    # Les headers :
    
    electricAlias-def ${M}html h1    "<h1>$M</h1>\n$M"
    electricAlias-def ${M}html h2    "<h2>$M</h2>\n$M"
    electricAlias-def ${M}html h3    "<h3>$M</h3>\n$M"
    electricAlias-def ${M}html h4    "<h4>$M</h4>\n$M"
    electricAlias-def ${M}html h5    "<h5>$M</h5>\n$M"
    electricAlias-def ${M}html h6    "<h6>$M</h6>\n$M"
    
    electricAlias-def ${M}html center  "<center>\n$M\n</center>\n$M"
    
    # Quelques alias de liste
    electricAlias-def ${M}html ul  "<ul>\n<li> $M\n<li> $M\n<li> $M\n</ul>\n$M"
    electricAlias-def ${M}html ol  "<ol>\n<li> $M\n<li> $M\n<li> $M\n</ol>\n$M"
    set tmp "<dl>\n\n"
    append tmp "<!----- DL item  --->\n"
    append tmp "<dt> $M </dt>\n<dd>\n[i]$M\n</dd>\n\n"
    append tmp "<!----- DL item  --->\n"
    append tmp "<dt> $M </dt>\n<dd>\n[i]$M\n</dd>\n\n"
    append tmp "$M\n</dl>\n$M"
    electricAlias-def ${M}html dl2  $tmp
    
    set tmp "<dl>\n"
    append tmp "<dt>[setStop]</dt>\n<dd>\n[i][setStop]\n</dd>\n"
    append tmp "<dt>[setStop]</dt>\n<dd>\n[i][setStop]\n</dd>\n"
    append tmp "[setStop]</dl>\n[setStop]"
    electricAlias-def ${M}html dl  $tmp
    
    set tmp ""
    append tmp "<dt>[setStop]</dt>\n<dd>\n[i][setStop]\n</dd>\n"
    electricAlias-def ${M}html dtl  $tmp
    set tmp ""
    append tmp "<dt>[setStop]</dt>\n"
    electricAlias-def ${M}html dt  $tmp
    set tmp ""
    append tmp "<dd>\n[i][setStop]\n</dd>\n"
    electricAlias-def ${M}html dd  $tmp
    
    # une "anti-list" : pratique pour fermer une liste, écrire un sous-titre
    # et réouvrir la list
    electricAlias-def ${M}html lu  "</ul>\n$M\n<ul>\n"
    electricAlias-def ${M}html lo  "</ol>\n$M\n<ol>\n"
    
    
    electricAlias-def html div  "<div class=$M> $M </div>\n$M"
    electricAlias-def ${M}html divi "<div class=$M>\n[i]$M\n</div>\n$M"
    
    electricAlias-def html spa  "<span class=$M> $M </span>\n$M"
    electricAlias-def html span "<span class=$M>\n[i]$M\n</span>\n$M"
    
    electricAlias-def html fon  "<font size=+1$M>$M</font>$M"
    electricAlias-def html font  "<font size=+1$M>\n[i]$M\n</font>\n$M"
    
    
    electricAlias-def html e     {<em>[setStop]</em>[setStop]}
    electricAlias-def html em    {<em>[setStop]</em>[setStop]}
    
    electricAlias-def html i     {<i>[setStop]</i>[setStop]}
    
    electricAlias-def html b     {<b>[setStop]</b>[setStop]}
    
    electricAlias-def html t     {<tt>[setStop]</tt>[setStop]}
    electricAlias-def html tt    {<tt>[setStop]</tt>[setStop]}
    
    electricAlias-def html code  {<code>[setStop]</code>[setStop]}
    electricAlias-def html c     {<code>[setStop]</code>[setStop]}
    
    electricAlias-def html u     {<u>[setStop]</u>[setStop]}
    
    electricAlias-def html g     {<big>[setStop]</big>[setStop]}
    electricAlias-def html big   {<big>[setStop]</big>[setStop]}
    
    electricAlias-def html s     {<small>[setStop]</small>[setStop]}
    electricAlias-def html small {<small>[setStop]</small>[setStop]}
    
    
    electricAlias-def html sub   {<sub>[setStop]</sub>[setStop]}
    electricAlias-def html sup   {<sup>[setStop]</sup>[setStop]}
    
    electricAlias-def ${M}html pre \
        {<pre>[setStop]</pre>[setStop]}
    electricAlias-def ${M}html pre2 \
        {<pre>\n[i][setStop]\n</pre>[setStop]}
    
    electricAlias-def ${M}html prec \
        {<pre class=[setStop]>\n[i][setStop]\n</pre>[setStop]}
    
    # # electricAlias-def ${M}html pre "<pre class=$M>\n[i]$M\n</pre>\n$M"
    
    electricAlias-def html col \
            {<font color="[setStop]">[setStop]</font>[setStop]}
    electricAlias-def ${M}html colo \
            {<font color="[setStop]">\n[i][setStop]\n</font>[setStop]}
    electricAlias-def ${M}html color \
            {<font color="[setStop]">\n[i][setStop]\n</font>[setStop]}
    
    
    # Exemple d'appel de parametre dans un electricalias :
    # electricAlias-def ${M}html begin  "begin\n${B}i${E}$M\nend;\n$M"
    
    electricAlias-def ${M}html y    "${B}askalias {HTML tag} URL${E}$V{URL}"
    electricAlias-def ${M}html Y    "${B}te:cmd:askHtmlEnvTag${E}"
}

## mode_html_defineMenu_html -
# 
# 
proc mode_html_defineMenu_html {} {

    global stead 
    global MODE_FAST_EDIT

    set menubutton  .menu.$stead(mode)
    set m           .menu.$stead(mode).m
    
    if {[winfo exists $menubutton]} {
        destroy $menubutton
    }
    # Création d'un bouton de menu (ce qu'on voit)
    menubutton $menubutton \
            -text [string totitle $stead(mode)] \
            -menu .menu.$stead(mode).m
            
    lappend stead(mode,cleanupCmds) [list destroy  $menubutton]

    # On positionne ce bouton
    pack append .menu $menubutton left
  
    # Création d'un menu (ce qui ce déroule quand on clique sur le menubutton)
    set m [menu $m]
    # 
    ####################################################################


    # # # te:mode:make_menu $stead(mode)
    # # # 
    # # # set m .menu.$stead(mode).m
    
    $m add command -label {Refresh Colors} \
       -command {refresh_colors} \
       -accelerator {<Control-c>}
    $m add command -label {Cancel Colors} \
       -command {cancel_colors}
    $m add separator
    $m add command -label "Aide du mode HTML"  \
       -command [list stead -r 1  -text [mode_html_getHelp] ]  
    $m add cascade -label {Files sample}  \
       -menu "$m.files"
       
    menu $m.files
    foreach {file} $MODE_FAST_EDIT {
       $m.files add command -label $file \
          -command "exec $stead(exe) $file &"
    } ;# endforeach
    
    
}


## mode_html_defineMenu_templates - défini le menu Templates de tcl
# 
# 
proc mode_html_defineMenu_templates {} {
    global stead
    set w $stead(text)

    
    ###########################################################################
    # On crée le menu template s'il n'existe pas
    # 
    set menubutton  .menu.template
    set m           .menu.template.m
    
    if {[winfo exists $menubutton]} {
        destroy $menubutton
    }
    # Création d'un bouton de menu (ce qu'on voit)
    menubutton $menubutton  \
            -text Templates \
            -menu $m
            
    lappend stead(mode,cleanupCmds) [list destroy  $menubutton]

    # On positionne ce bouton
    pack append .menu $menubutton left
  
    # Création d'un menu (ce qui ce déroule quand on clique sur le menubutton)
    set m [menu $m]
    
    # 
    ##################################################################


    # # ###################################################
    # # # On crée le menu template s'il n'existe pas
    # # # 
    # # te:mode:make_menu templates
    
    
    ###########################################################################
    # Remplissage de menu template
    # 
    $m add command -label "Insérer un separateur   " \
                          -command {separator 1}  \
                          -accelerator {<Meta-Key-1>}
    
    $m add command -label {Insérer un tag...} \
                          -command {te:cmd:askHtmlTag} \
                          -accelerator {<Control-Meta-y>}
    bind $w <Control-Meta-y> {te:cmd:askHtmlTag ; break}
    
    $m add command -label {Insérer un tag indenté...} \
                          -command {te:cmd:askHtmlEnvTag} \
                          -accelerator {<Control-Shift-Y>}
    bind $w <Control-Shift-Y> {te:cmd:askHtmlEnvTag ; break}
    
    $m add command -label {pre (en ligne)} \
                          -command {te:cmd:askHtmlEnvTag pre} \
                          -accelerator {<Control-Meta-p>}
    bind $w <Control-Meta-p> {electricAlias-wrap pre ; break}
    
    $m add command -label {pre2 (env)} \
                          -command {te:cmd:askHtmlEnvTag pre2} \
                          -accelerator {<Control-Shift-P>}
    bind $w <Control-Shift-P> {te:cmd:askHtmlEnvTag pre ; break}
    
    $m add separator
    
    $m add command -label {EMphasis} \
                          -command {electricAlias-wrap e} \
                          -accelerator {<Control-Meta-e>}
    bind $w <Control-Meta-e> {electricAlias-wrap e ; break}
    
    $m add command -label {Italic} \
                          -command {electricAlias-wrap i} \
                          -accelerator {<Control-Meta-i>}
    bind $w <Control-Meta-i> {electricAlias-wrap i ; break}
    
    $m add command -label {Bold} \
                          -command {electricAlias-wrap b} \
                          -accelerator {<Control-Meta-b>}
    bind $w <Control-Meta-b> {electricAlias-wrap b ; break}
    
    $m add command -label {Type Writer (tt)} \
                          -command {electricAlias-wrap t} \
                          -accelerator {<Control-Meta-t>}
    bind $w <Control-Meta-t> {electricAlias-wrap t ; break}
    
    $m add command -label {Type Writer (code)} \
                          -command {electricAlias-wrap code} \
                          -accelerator {<Control-Meta-c>}
    bind  <Control-Meta-c> {electricAlias-wrap code ; break}
    

    $m add command -label {Underline} \
                          -command {electricAlias-wrap u} \
                          -accelerator {<Control-Meta-u>}
    bind $w <Control-Meta-u> {electricAlias-wrap u ; break}
    
    $m add separator
    $m add command -label {Big} \
                          -command {electricAlias-wrap big} \
                          -accelerator {<Control-Meta-g>}
    bind $w <Control-Meta-g> {electricAlias-wrap big ; break}
    

    $m add command -label {Small} \
                          -command {electricAlias-wrap small} \
                          -accelerator {<Control-Meta-s>}
    bind $w <Control-Meta-s> {electricAlias-wrap small ; break}
    

    $m add separator
    $m add command -label {HREF avec affichage de l'URL...} \
                                    -command {electricAlias-wrap url2}
                                    
    $m add command -label {HREF avec affichage de texte} \
                                    -command {electricAlias-wrap url}
                                    
    
    $m add cascade -label Alias -menu $m.alias
    menu $m.alias
    foreach alias [electricAlias-softNames] {
       $m.alias add command -label $alias \
       -command "electricAlias-insert $stead(text) [te:no_interp $alias]"
    }
    
} 

## te:cmd:askHtmlTag - demande et applique un tag html à la sélection
# 
proc te:cmd:askHtmlTag { {cmd ""} } {

    global stead
    if {![info exists stead(html,cmdDefault)]} {
        set stead(html,cmdDefault) strong
    }
    if {"x$cmd" == "x"} {
        
        set cmd [te:prompt \
                -text "Html tag to applay"\
                -default $stead(html,cmdDefault) \
                -title "Html tag" \
                -cancelvalue "HAS_BEEN_CANCELLED"]
                
        if {"x$cmd" == "x" || "x$cmd" == "xHAS_BEEN_CANCELLED"} {
            return
        }
    }

    set prefix "<$cmd>"
    set suffix "</$cmd>"
    set stead(html,cmdDefault) $cmd
    # te:cmd:wrapSel $prefix $suffix
    xtext_wrapSel $stead(text) $prefix $suffix
}        

## te:cmd:askHtmlEnvTag - demande et applique un environnement html à sélection
# 
# modif diam 30/11/99 : mémorisation de la chaine demandée 
# 
proc te:cmd:askHtmlEnvTag { {env ""} } {
    global stead
    if {![info exists stead(html,envDefault)]} {
        set stead(html,envDefault) center
    }
    
    if {"x$env" == "x"} {
        
        set env [te:prompt \
                -text "html environment to applay"\
                -default $stead(html,envDefault) \
                -title "html environment*" \
                -cancelvalue "HAS_BEEN_CANCELLED"]
                
        if {"x$env" == "x" || "x$env" == "xHAS_BEEN_CANCELLED"} {
            return
        }
    }
    
    set stead(html,envDefault) $env
    set indent [stead:getIndentToInsert]
    set prefix "<$env>\n$indent[i]"
    set suffix "\n$indent</$env>\n"
    
    # te:cmd:wrapSel $prefix $suffix
    xtext_wrapSel $stead(text) $prefix $suffix
}        

# # ## stead:modeStart_html - lancement du mode html
# # # 
# # # 
# # proc stead:modeStart_html {} {
# #     mode_html_init
# #     mode_html_defineSabbrev
# #     # mode_html_defineMenu_html
# #     # mode_html_defineMenu_templates
# #     mode_html_defineMenu
# #     mode_html_defineStyles
# # }
# # 
# # ## stead:modeCleanup -
# # # 
# # proc stead:modeCleanup {} {
# #     global stead
# #     global xtext
# #     upvar 0 stead(text) w
# #     te:mode:destroy_menu $stead(mode)
# #     te:mode:destroy_menu templates
# #     xtext_style $w delete $stead(mode)
# #     
# #     # Suppression de la parenthese "html"
# #     set elem [list greater < >]
# #     set idx [lsearch $xtext(balance_list) $elem]
# #     if {$idx != -1} {
# #         set xtext(balance_list) [lreplace $xtext(balance_list) $idx $idx]
# #     }
# # } 

## stead:modeStart_tcl - lancement du mode tcl
# 
# 
proc stead:modeStart_html {} {
    global stead
    global xtext
    upvar 0 stead(text) w

    # Suppression de la parenthese "html"
    set elem [list greater < >]
    set idx [lsearch $xtext(balance_list) $elem]
    if {$idx != -1} {
        set xtext(balance_list) [lreplace $xtext(balance_list) $idx $idx]
    }

    mode_html_init
    mode_html_defineSabbrev
    mode_html_defineMenu_html
    mode_html_defineMenu_templates
    mode_html_defineStyles

}        
## stead:modeQuit_gvt - Nettoyage quand on quitte ce mode
# 
proc stead:modeQuit_html {} {
    catch {eval [join $::stead(mode,cleanupCmds) ";"]}
}

## Cette procédure est appelé automatiquement (sera refondu)
proc stead:modeCleanup {} {
    stead:modeQuit_html
}

# Ceci sera géré automatiquement par stead (via auto_load)
stead:modeStart_html
#./

