	  #!/bin/bash
	  # lancement de l'interpréteur wish\
	  exec wish "$0" "${1+"$@"}"
	  
	  
	  #_______________________________________________________________________________
	  #									 Tikeditor3_gavarnie10/fevrier/2005 - daniel MACOUIN
	  # _______________________________________________________________________________
	  
	  # TIKEDITOR est un éditeur de code TCL-Tk écrit en TCL-TK
	  # auteur : daniel MACOUIN
	  
	  # Cet éditeur est basé sur le code de TkEdit de David Cobac,
	  # lui même développement d'un éditeur de texte de JL DEVINEZ
	  
	  # ORIGINE >>>> TkEdit-1.2gamma.tcl <<<<
	  #  Copyright (C) 2002-2003 David COBAC - dcobac@larochelle-innovation.com
	  
	  # Script initial : editeur.tcl de J.L. Devinez
	  # Date : novembre 2002 - janvier 2003
	  # Cadre : Atelier programmation
	  
	  # TKV(isionneuse) de Jan NIJTMANS  - j.nijtmans@chello.nl
	
	# aide Html sur le langage Tcl/Tk : Michel Salvagniac & David Zolli 
	  
	  #------------------------------------------------------------------------------------------
	  
	  # Ce programme est un logiciel libre :
	  # vous pouvez le redistribuer et/ou le modifier conformément aux dispositions
	  # de la Licence Publique Générale GNU,
	  # telle que publiée par la Free Software Foundation ; version 2 de la licence,
	  
	  # Ce programme est distribué dans l'espoir qu'il sera utile,
	  # mais SANS AUCUNE GARANTIE ;
	  # sans même la garantie implicite de COMMERCIALISATION ou
	  # D'ADAPTATION A UN OBJET PARTICULIER.
	  # Pour plus de détail, voir la Licence
	  # Publique Générale GNU.
	  #TkEdit Version 1.2 gamma - 12/01/2003 - David COBAC
	  # Tikeditor version 1.0 - mai 2004 / novembre 2004 - daniel MACOUIN
	  
	  #-------------------------------------------------------------------------------------------
	  
		  
	  # la ligne suivante [package require Tk] sert à tester l'évaluation Tcl avec le widget Tk ;
	  #attention un ficher a été ajouté pour que ça marche
	  #... sinon cette commande ne fonctionne pas :
		package require Tk
	
	set Chemin(abs) [pwd]
	  set NomScript [info script]
	  set Chemin(rel) [file dirname $NomScript]
	
	#-------------------------------------------------------------------------------------------
	# lancement d'une fenêtre d'attente de chargement
	toplevel .initiation -background bisque -borderwidth 5 -relief raise 
	wm  geometry .initiation 270x350+400+250 
	wm overrideredirect .initiation 1
		raise .initiation
		
	text .initiation.t -foreground purple -font {courier 20} -wrap char -width 15 -height 15 -bg bisque
	pack .initiation.t  -expand true -fill both
	.initiation.t insert end "TIKEDITOR\npour \nTcl & Tk"
	bind .initiation <Enter> {destroy .initiation}
	
  	set tikimg [image create photo -file  $Chemin(rel)/images/logtik.gif  ] 
 	.initiation.t image create end -image $tikimg -align center
		
	#------------------------------------------------------------------------------------------
	
	
	  
	
	#<VariablesGlobales>
	#Chargement des fichiers annexes
		#pour le html : Simple HTML display library by Stephen Uhler (stephen.uhler@sun.com)
		source [file join $Chemin(rel) tikhtmllib.tcl]
		global Home
		global Url
		
		global Size
		set Size 0
		
		# pour les numero ligne et surlignage supplémentaire
		source [file join $Chemin(rel) ctext.tcl ]
				
		global numeroMarque
		set numeroMarque "0"
		
		global numeroMasque 
		set numeroMasque "0"
		
		global systeme
		set systeme $tcl_platform(platform)
		
		global marquesActuelles 
		set  marquesActuelles {"" maMarqueTest}
		
		set i 0
		while {$i <100} {
		global lignesChoisies$i 
		set  lignesChoisies$i [list 10 20 30 40 55]
		incr i
		}
		
		global widpage
		set widpage 0
		
		global mesMots
		set mesMots "" 
		
		global couleurMesMots
		set couleurMesMots SteelBlue 
		
			
	  set numeroPage 0
	  global widtexte
	  set widtexte .$numeroPage
	  global listeTextes
	  
	  namespace eval Tikeditor {
		
		#variables globales
		global choixMarque
		global numeroPage
		global listeTextes
			set listeTextes [list "page : $numeroPage"]
		global widtexte
			set widtexte initial
			global NomScript
			set NomScript [info script]
		global Chemin(rel)
		set Chemin(rel) [file dirname $NomScript]
		global flagNumero
		global indexProc1
		global indexProc2
		
		global police
		global taillePolice	
		
				
		variable lignesChoisies ""
				
		##########################################################
	#<version>
		variable version  "3_gavarnie"
		
		##########################################################
		
		variable application "Tikeditor"
		
		variable ausujetdeDC  { "David COBAC" "dcobac@larochelle-innovation.com"\
			  "http://dcobac.free.fr"\
			  "Novembre 2002 / Janvier 2003" }
			
		variable ausujetdeJLD { "Jean-Luc DEVINEZ" "devinez@amd.fr" \
			  "http://www.mygale.org/01/djl/" \
			  "Copyright (c) 1998" }
			
		variable ausujetdeDM { "Daniel MACOUIN" \
			 "daniel.macouin@libertysurf.fr" \
			  "http://www.danielmacouin.chez.tiscali.fr" \
			  "Mai 2004/février 2005" 	}
			
		variable ausujetdeMSDZ { "(AIDE sur le langageTCL/TK)>>" "Michel SALVAGNIAC" "DavidZOLLI" \
			 }
			
		variable ausujetdeJN { "(visionneuse TKV)>>" "Jan NITJMANS" "j.nijtmans@chello.nl" \
			 }
			
		variable ausujetdeSUCF {  "(routines html2)>>" "Stephen Uhler" "stephen.uhler@sun.com"  \
						"Clif Flynt" "clif@cflynt.com"\
			 }
			


		
		variable motRecherche
		variable fichier
		variable types {
		  {{Fichier Tcl/TK} {.tcl}} {{Fichier Texte} {.txt}} {{Tout fichier } {.*}}
		}
		
		variable cheminAcrobat 0
		variable cheminVisionneuse 0
		variable travailencours 0
		variable permute
		
		variable langage
		variable listLang
		variable motscles
		variable indexTampon 0
		
		
	
		
		set motscles(tcl) [ list after append argc argv argv0 array auto_execok auto_import \
			auto_index auto_load auto_oldpath auto_mkindex auto_mkindex_old auto_path	 \
			auto_qualify auto_reset bgerror binary break catch cd clock close concat	  \
			continue else elseif encoding env eof error errorCode errorInfo eval exec	 \
			exit expr fblocked fconfigure fcopy file fileevent filename flush for foreach \
			format gets glob global history if incr info interp join lappend lindex	   \
			linsert list llength load lrange lreplace lsearch lsort memory msgcat	package	 \
			pwd read regexp registry   \
			regsub rename require resource return scan seek set socket source split string subst  \
			switch tclDefaultLibrary tcl_findLibrary tcl_interactive tcl_libpath		  \
			tcl_library tcl_patchLevel tcl_pkgPath tcl_platform tcl_precision			 \
			tcl_rcFileName tcl_rcRsrcName tcl_traceCompile tcl_traceExec tcl_version tell \
			then time trace unknown unset update uplevel upvar variable vwait while ]
		
		
		
		set motscles(tk) [ list bell bind bindtags bitmap button canvas checkbutton chooseColor \
			chooseDirectory clipboard configure colors console cursors destroy dialog entry event focus \
			focusNext font frame getOpenFile grab grid image insert keysyms label labelframe listbox \
			loadTk lower menu menubar menubutton message messageBox option optionMenu options \
			pack-old pack palette panedwindow photo place popup radiobutton raise scale	   \
			scrollbar selection send spinbox text tk tkerror tkvars tkwait tk_bisque		  \
			tk_chooseColor tk_chooseDirectory	tk_getOpenFile tk_getSaveFile tk_library tk_messageBox		 \
			tk_popup tk_setPalette tk_strictMotif tk_version	toplevel winfo wm \
			]
		
		set motscles(opt) [ list -activebackground -activeforeground -activeborderwidth -all -anchor -aspect -autoseparators \
			-bitmap -command -count -cursor -width -forwards -height -icon -ipadx -ipady -initialcolor \
			-initialdir -insertofftime -insertbackground  -relief -expand -fill -background -borderwidth -font \
			-foreground  -highlightcolor -bg -bd -fg -accelerator -defaultextension -filetypes -side -before -after -wrap -underline \
			-column -row -rowspan -columnspan	-label -orient -padx -pady -selection -setgrid -state -sticky -tabs -tearoff -text -title \
			-type -undo -window -xscrollcommand -yscrollcommand ]
		
		set motscles(signes) [list \{ \} ]
		
		variable debut
		variable fin
		variable couleur
		
		# définition des couleurs au chargement et de la taille de la police.
		
		# couleur de "namespace"
		set couleur(0) red
		
		#  couleur de proc
		set couleur(1) red
		
		# couleur de variable
		set couleur(2) darkblue
		
		# couleur de tcl
		set couleur(3) blue
		
		# couleur de tk
		set couleur(4) chocolate
		
		#couleur de options Tk
		set couleur(5) hotPink4
		
		# couleur de commentaire
		set couleur(6) darkgreen
		
		# fond
		set couleur(fond) white
		
		# couleur de curseur
		set couleur(curseur) black
		
		# taille de la police
		set taillePolice 12
		
		#nom de la police
		set police helvetica
		
		variable ListeRecents {}
		variable ListeOccurences {}
		
		
	  }
	  
	  
	  
proc Tikeditor::AfficherOctets { etiquette } {
		variable fichier
		$etiquette configure -text "[ file size $fichier ] octets"
	  }
	  
	  
	  
proc Tikeditor::NouvellePage {choix} {
		global numeroPage
		global listeTextes
		global widtexte
		variable couleur
		global police
		global taillePolice
		
		# désaffichage de la fenetre précédente
		for {set i 0} {$i < $numeroPage} {incr i} {
		  pack forget .ftext.$i
		  pack forget .ftext.sy$i
		  pack forget .ftext.sx$i
		}
		
		#création d'une nouvelle page "-wrap none" par defaut
		ctext .ftext.$numeroPage -bg $couleur(fond)  -wrap none -tabs {1c}\
			-xscrollcommand ".ftext.sx$numeroPage set" -yscrollcommand ".ftext.sy$numeroPage set" -undo 1 -highlight 1
		scrollbar .ftext.sx$numeroPage -orient horizontal -command ".ftext.$numeroPage xview"
		scrollbar .ftext.sy$numeroPage -orient vertical -command ".ftext.$numeroPage yview"
		
		
		pack .ftext.sy$numeroPage -fill y -side right
		pack .ftext.$numeroPage 	-fill both	-expand true
		pack .ftext.sx$numeroPage -fill x -side top
				
		# on affecte la configuration police à la fenêtre
		 .ftext.$numeroPage configure -font  "[list $police]  $taillePolice"
		
		set listeTextes [lappend listeTextes "page : $choix" ]
		
		
		# on affecte la nouvelle valeur à "widtexte" pour désigner la fenetre en cours
		set widtexte ".ftext.$numeroPage"
		
		# puts ".ftext.$numeroPage\n"
		
		# on "bind" la page sur bouton3 pour afficher menu "editer"
		bind $widtexte <3> { tk_popup .menubar.mEditer %X %Y }
		
		# on met à jour le menu Pages
		.menubar.mPages	 add radio -label "page : $choix"  -command " Tikeditor::Affiche  $numeroPage $choix "
						
		# on incrémente le numéro de page pour la prochaine page à ouvrir
		incr numeroPage
		
		.fetat.fichier configure -text "$choix"
		
		Tikeditor::MenuMarques $widtexte
	  }
	  
	  
proc Tikeditor::Affiche { num nomFichier} {
		global numeroPage
		global widtexte
		variable fichier
		
		
		variable lignesChoisies$widtexte 1

		
		for {set i 0} {$i < $numeroPage} {incr i} {
		  pack forget .ftext.$i
		  pack forget .ftext.sy$i
		  pack forget .ftext.sx$i
		}
		
		pack .ftext.sy$num -fill y -side right
		pack .ftext.$num -expand true	-fill both
		pack .ftext.sx$num -fill x -side top
		
		set widtexte .ftext.$num
		set fichier 	$nomFichier
		.fetat.fichier configure -text "$nomFichier"
		
			bind $widtexte <3> { tk_popup .menubar.mEditer %X %Y }
		
		Tikeditor::MenuMarques $widtexte  
	  }
	  
	  
proc Tikeditor::Nouveau {} {
		global Chemin
		variable application
		variable fichier
		variable types
		global widtexte
		global numeroPage
		
		if {[string compare $widtexte .ftext.0 ]!=0} {
		  set dialogue [tk_dialog .top "nouveau..." "Vous devriez sauvegarder le fichier en cours.\nSauvegarder?" questhead 0 OUI NON Annuler]
		  
		  
		  switch $dialogue {
			0 { Tikeditor::Sauvegarder $widtexte 1}
			1 {}
			2 {return}
		  }
		}
		
		Tikeditor::NouvellePage "PageNouvelle.$numeroPage"
	  }
	  
proc Tikeditor::Ouvrir {} {
		global Chemin
		global numeroPage
		variable application
		variable fichier
		variable types
		global widtexte
		
		
		if { [string compare  [set choix [ tk_getOpenFile -title "$application : 0uvrir"\
			-initialdir $Chemin(rel) -filetypes $types] ] "" ]== 0} {
						tk_messageBox -message "vous n'avez pas ouvert de fichier"
						; return
		}
		
		# ouverture d'une nouvelle fenetre
		Tikeditor::NouvellePage $choix
		
		if [ string compare $choix "" ] {
		  set resultat [ Tikeditor::ChargerTexte $widtexte $choix ]
		  if { $resultat == 0 } {
			set fichier $choix
			Tikeditor::Recents $choix
			Tikeditor::MiseAJour $widtexte
		  }
		}
		.fetat.fichier configure -text $choix
	  }
	  
	  
proc Tikeditor::Fermer { widtexte } {
		
				
		#on récupère le numéro de la fenetre
		set splitWidtexte [split $widtexte .]
		set num [lindex $splitWidtexte 2]
		
		# on détruit la fenetre en cours
		if {$num != 0} {
		  destroy $widtexte
		  
		  # on ferme les scrollbars relatifs à cette fenetre texte
		  destroy .ftext.sy$num
		  destroy .ftext.sx$num
		  
		  # on met à jour le menu Pages
		  .menubar.mPages delete [expr $num+1]
		  
		  Tikeditor::Affiche 0 defaut
		  
		}
	  }
	  
proc Tikeditor::Sauvegarder { widtexte flag } {
		global Chemin
		variable application
		variable fichier
		variable types
		#flag :1 sauvegarder sous
		
		#on récupère le numéro de la fenetre
		set splitWidtexte [split $widtexte .]
		set pageIndex [lindex $splitWidtexte 2]
		
		
		
		if {$flag==1} {
		  set choix [ tk_getSaveFile \
		-title "$application : Sauvegarder sous" -defaultextension .tcl -filetypes $types] ;
		set fichier $choix
		} else {
		  if [catch {set choix $fichier}] {
			tk_messageBox -type ok -icon warning \
				-message "Aucun fichier n'a encore été défini, utilisez :\n\"Sauvegarder\
				sous\"."
			return
		  }
		}
		
		if {$choix==""} {
		  tk_messageBox -type ok -icon warning \
			  -message "Erreur d'écriture ... le fichier n'a pas été enregistré."
		} else {
			
			set dossier [regexp $Chemin(abs) $choix	]
		 	if {$dossier == 1} {
		
			tk_messageBox  -icon error -type ok  -message  "Vous ne pouvez pas enregistrer\
		 dans le dossier de $Chemin(abs)\
		C'est celui du programme en cours"
		
		return
		
		}
		
		  set idf [open $choix w]
		  set contenu [ $widtexte get 1.0 end ]
		  puts -nonewline $idf $contenu
		  close $idf
		  set fichier $choix
		  
		  Tikeditor::AfficherOctets .fetat.taille
		  
		  if {$flag==1} {
			Tikeditor::MiseAJour $widtexte
			.fetat.fichier configure -text $choix
			# on met à jour le menu Pages
			.menubar.mPages	 delete [expr $pageIndex+1 ]
			.menubar.mPages insert [expr $pageIndex+1 ] radiobutton -label "page : $choix"  -command " Tikeditor::Affiche  $pageIndex $choix "
			
			
		  }
		}
		
		
	  }
	  
	  
proc Tikeditor::MiseAJour { widtexte } {
		variable application
		variable version
		variable fichier
		variable langage
		
		set langage [ string range [file extension $fichier] 1 end]
		wm title . "$application version $version "
		Tikeditor::OuvrirFicLang
		#Tikeditor::Coloration $widtexte 1
		Tikeditor::AfficherOctets .fetat.taille
		Tikeditor::NbLignes $widtexte .fetat.nblignes
	  }
	  
proc Tikeditor::ChargerTexte { widtexte choix } {
		variable application
		variable motscles
		if [ catch { open $choix } FIC ] {
		  tk_messageBox -type ok -icon warning \
			  -message "Impossible d'ouvrir le fichier $choix"
		  return 1
		} else {
		  $widtexte delete 0.0 end
		  set contenu [ read -nonewline $FIC ]
		  regsub -all {\ {4}} $contenu "\t" contenu
		  $widtexte fastinsert 0.0 $contenu
		   		
		  close $FIC
		  return 0
		}
		
		.fetat.fichier configure -text $choix
	  }
	  
  
proc Tikeditor::Imprimer { widtexte} {
global systeme

tk_messageBox -message $systeme 

		
	# impression d'un bloc sélectionné
	# ou de tout le texte par défaut
	
	set ranges [ $widtexte tag ranges sel ]
	
	if { [llength $ranges] == 0 } { 
			set contenu [$widtexte get 1.0 end]
	}   else {		
	set i1 [ lindex $ranges 0 ]
	set i2 [ lindex $ranges 1 ]
	set contenu [ $widtexte get $i1 $i2 ]
	}
	
	# la commande unix lpr imprime un fichier
	# il fautdonc sauver temporairement le contenu du texte dans un fichier,
	# l'imprimer,
	# et le détruire après.
	# on utilise un artifice avec Windows en chargeant le script dans le notepad et en imprimant de puis celui-ci

	set tempo [open "[pwd]/temp.txt" w+ ]
	puts $tempo $contenu 
	close $tempo
	
	# commande en fonction des systèmes unix ou windows
	switch $systeme unix {
		exec lpr "[pwd]/temp.txt" }
	switch $systeme windows {
#£ 		 tk_messageBox -message "Imprimer ne fonctionne que sous Unix\n Désolé!" 
		exec notepad 	"[pwd]/temp.txt"}
		
 	file delete "[pwd]/temp.txt"
	
	}
		
	
proc Tikeditor::ToutSelectionner { widtexte } {
		$widtexte tag add sel 0.0 end
	  }
	  
proc Tikeditor::Defaire { widtexte } {
		catch {$widtexte edit undo}
	  }
	  
	  
proc Tikeditor::Refaire { widtexte } {
		catch {$widtexte edit redo}
	  }
	  
	  
proc Tikeditor::Copier { widtexte } {
		set ranges [ $widtexte tag ranges sel ]
		if { [llength $ranges] == 0 } { return }
		set i1 [ lindex $ranges 0 ]; set i2 [ lindex $ranges 1 ]
		set texte [ $widtexte get $i1 $i2 ]
		clipboard clear
		clipboard append $texte
		return [list $i1 $i2]
	  }
	  
proc Tikeditor::Coller { widtexte } {
		if [ catch { selection get -selection CLIPBOARD } texte ] { return }
		$widtexte insert insert $texte
		Tikeditor::Coloration $widtexte 2
	  }
	  
proc Tikeditor::Couper { widtexte } {
		set coupeZone [ $widtexte tag ranges sel ]
		if { [llength $coupeZone] == 0 } { return }
		set i1 [ lindex $coupeZone 0 ]; set i2 [ lindex $coupeZone 1 ]
		$widtexte delete $i1 $i2
	  }
	 
proc Tikeditor::MasquerSelection {widtexte} { 
		global Chemin
		global numeroMasque 

		# création du bouton de démasquage 
		set imgDemasquer [image create photo -file [file join $Chemin(rel) images masque.gif]]
	
		#masquage du texte sélectionné 		
		set ranges [ $widtexte tag ranges sel ]
		if { [llength $ranges] == 0 } { return
		 } else {
		set i1 [ lindex $ranges 0 ]
		set i2 [ lindex $ranges 1 ]

		$widtexte tag add masque$numeroMasque  $i1 $i2 
		$widtexte tag configure masque$numeroMasque -elide true 
		set numMasque $numeroMasque
		# création du bouton de démasquage 
		button $widtexte.boutonDemasquer$numMasque -image $imgDemasquer  -relief raise -command "Tikeditor::DemasquerSelection $widtexte $numMasque $i1 $i2" -background red	-bd 2 -activebackground green
		bind $widtexte.boutonDemasquer$numMasque   <Enter> "after 50 ; .fetat.message configure -text {>>Démasquer le texte caché} "
		bind $widtexte.boutonDemasquer$numMasque   <Leave> " ; .fetat.message configure -text {} "

		#insertion du bouton de démasquage 
		$widtexte window create $i1 -window $widtexte.boutonDemasquer$numeroMasque -padx 5
		incr numeroMasque
		
		}
		
		return [list $i1 $i2]
}	

proc Tikeditor::DemasquerSelection {widtexte numMasque i1 i2} { 

$widtexte tag remove masque$numMasque $i1 $i2
destroy  $widtexte.boutonDemasquer$numMasque   
.fetat.message configure -text {} 
}

proc Tikeditor::IndentationAuto { widtexte } {
		set position [expr {int([$widtexte index insert])-1}]
		set indice [$widtexte search -forwards -count long\
			-regexp (\\t)* ${position}.0 ${position}.end]
		if {[info exists long]==0} {return}
		set espace ""
		for {set i 1} {$i<=$long} {incr i} {
		  append espace "\t"
		}
		$widtexte insert  [$widtexte index insert] $espace
	  }
	  
proc Tikeditor::Indenter {widtexte} {
		set contenu [$widtexte get 1.0 end]
		regsub -all {\ {4}} $contenu "\t" contenu
		$widtexte delete 1.0 end
		$widtexte insert 1.0 $contenu
	  }
	  
proc Tikeditor::Quitter {} {
		#Tikeditor::EnregConfig
		Tikeditor::EnregListeRecents
		destroy .
		exit
	  }
	  
proc Tikeditor::Recents {fic} {
		variable ListeRecents
		global Chemin
		variable fichier
		variable types
		global widtexte
		
		if {[lsearch $ListeRecents $fic]!=-1} {return}
		
		set liste [list $fic]
		foreach el $ListeRecents {
		  lappend liste $el
		}
		set ListeRecents [lrange $liste 0 9]
		
		Tikeditor::MaJMenuRecents
	  }
	  
	  
proc Tikeditor::EnregListeRecents { } {
		global Chemin
		variable ListeRecents
		
		set fichier [open [file join $Chemin(rel) TikeditorRecents.rc] w]
		foreach fic $ListeRecents {
		  puts $fichier $fic
		}
		close $fichier
	  }
	  
	  
proc Tikeditor::LectureListeRecents { } {
		global Chemin
		variable ListeRecents
		
		if {![catch {set fichier [open [file join $Chemin(rel) TikeditorRecents.rc] r]}]} {
		  while {![eof $fichier]} {
			set capture [gets $fichier]
			if {$capture!=""} {
			  append ListeRecents " [list $capture]"
			}
		  }
		  close $fichier
		}
	  }
	  
	  
proc Tikeditor::MaJMenuRecents {} {
		variable ListeRecents
		global widtexte
		set Fichier .menubar.mFichier
		
		$Fichier.lRecents delete 0 end
		foreach el $ListeRecents {
		  $Fichier.lRecents  add command -label $el\
			  -command "Tikeditor::OuvrirRecents $el"
		}
		Tikeditor::EnregListeRecents
		
	  }
	  
proc Tikeditor::PurgerRecents {} {
		variable ListeRecents
		global widtexte
		set Fichier .menubar.mFichier
		
		$Fichier.lRecents delete 0 end
		set ListeRecents ""
		Tikeditor::EnregListeRecents
	  }
	  
	  
proc Tikeditor::OuvrirRecents {choix} {
		variable fichier
		global widtexte
		
		# ouverture d'une nouvelle fenetre
		Tikeditor::NouvellePage $choix
		
		set resultat [ Tikeditor::ChargerTexte $widtexte $choix ]
		if { $resultat == 0 } {
		  set fichier $choix
		  Tikeditor::MiseAJour $widtexte
		}
		.fetat.fichier configure -text $choix
	  }
	  
	  
	  
proc Tikeditor::OuvrirFicLang { } {
		global Chemin
		variable langage
		variable listLang
		
		if { $langage=="tcl" } {
		  set listLang {tcl tk opt}
		}
		
	  }
	  
	  ###############################################"
	  ### routines couleur
	  ###############################################
	  
	  #l'alternative qui permet de coloriser soit tout le texte, soit ligne par ligne à la saisie, soit un bloc.
	  
proc Tikeditor::ZoneColoration {widtexte flip} {
		variable debut
		variable fin
		variable tailleBloc
		
		if {$flip == 1} {
		  set debut 1.0
		  set fin end
		} else {
		  set indices [ $widtexte tag ranges sel ]
		  if { [llength $indices] == 0  } {
			set debut [$widtexte index "insert linestart"]
			set fin [$widtexte index "insert lineend"]
		  } else {
			set debut [$widtexte index  [lindex $indices 0]]
			set fin [$widtexte index  [lindex $indices 1]]
			set tailleBloc [expr $fin - $debut ]
			puts $tailleBloc
		  }
		  
		}
	  }
	  
	  
	  
proc Tikeditor::Coloration {widtexte flag } {
		variable fichier 	; #chemin du fichier ouvert
		
		global Chemin
		
		variable travailencours  ;
		#  0 ou 1 sert à afficher un message dans la barre d'état
		#et à bloquer toute autre action avant la fin de la colorisation syntaxique
		
		variable debut ;
		#début de la zone à coloriser
		
		variable fin ;
		#fin de la zone à coloriser
		
		variable couleur ;
		#valeurs correspondant aux couleurs du panneau de couleurs syntaxiques
		
		variable motscles ;
		# il s'agit d'une liste de trois élements liste: vakeurs : mots-tcl , mots-tk  et mots-opt(ions tk)
		
		variable langage ;
		#actuellement  <mai 2004> ne prend en compte qu'une valeur :TCL.
		#Pourrait servir si Tikeditor servait pour d'autres langages de programmation.
		
		variable listLang ;
		# pour langage==TCL, listLang possède trois éléments (valeurs Tcl et Tk et option)
		
		
		if {$travailencours==1} {return}
		
		if  {[ info exists listLang]==0} { return }
		set travailencours 1
		set imgColoration [image create photo -file [file join $Chemin(rel) images greenball.gif]]
		set imgColoration2 [image create photo -file [file join $Chemin(rel) images redball.gif]]
		
		
		
		if {($flag==1) } {
		  .ficones.coloration configure -image $imgColoration2
		  .fetat.message configure -text "Travail de coloration en cours ...\
			  veuillez patienter"
		  $widtexte configure -cursor watch
		  . configure -cursor watch
		  update
		}
		
			
		set DifferentesParties {0 espacenom 1 Env 2 var }
		set nb [ llength $listLang ] ;
		#dans le cas du langage TCL listLang possède trois éléments.tcl tk optionsTk qui vont se rajouter à la liste différentes parties
		#  on pourrait simplifier tout cela car Tikeditor ne taite que TCLTk, mais comme le code prévoit la possibilité d'autres langagfes,
		#autant le garder pour un avenir d'éventuelle complexité
		
		for { set u 0 } { $u<$nb } { incr u } {
		  
		  set LeLangage [ lindex $listLang $u ]
		  
		  lappend DifferentesParties [ expr {$u+3} ] $LeLangage
		  
		  # dm construction des expressions régulières
		  # dm correspondant aux mots clés des langages (tcl et tk et opt).
		  set ExReg([ expr {$u+3} ]) "("
		  append ExReg([ expr {$u+3} ]) [ string map { " " | } $motscles($LeLangage) ]
		  append ExReg([ expr {$u+3} ]) ")"
		}
		
		
		lappend DifferentesParties [expr {$nb+3}] commentaire
		
		
		Tikeditor::ZoneColoration $widtexte $flag
		
		# attribution des noms de tags
		# et destruction des tags existants
		foreach {k espece} $DifferentesParties {
		  set nom($k) $espece
		  $widtexte tag remove $espece $debut $fin
		}
		
		set com(0) { -regexp {[a-zA-Z]+::[a-zA-Z]+} $debut $fin } ; # espace de nom (namespace)
		set com(1) { proc $debut $fin } ;										 # procédures
		set com(2) { -regexp {\s*\$(\w|\(|\)|\:|\{|\})+} $debut $fin } ; #variables
		set com(3) { -regexp "\\s*$ExReg(3)\\s" $debut $fin } ; 	# tcl
		set com(4) { -regexp "\\m$ExReg(4)\\s" $debut $fin } ; #Tk
		set com(5) { -regexp "\\s*$ExReg(5)\\s" $debut $fin}  ;  #options de Tk
		set com(6) { -regexp {\s*#.*$} $debut $fin }									; #commentaires
		
		
		
		for {set j 0} {$j<=6} {incr j} {
		  set com($j) "$widtexte search -forwards -count long($j) $com($j)"
		  set i($j) [eval $com($j)]
		}
		
		
		# boucle principale de la recherche des correspondances
		# pour la coloration
		while 1 {
		  
		  if {[join $i(0)$i(1)$i(2)$i(3)$i(4)$i(5)$i(6)]==""} { break }
		  set min [lindex [lsort -real "$i(0) $i(1) $i(2) $i(3) $i(4) $i(5) $i(6)"] 0]
		  
		  for {set u 0} {$u<=6} {incr u} {
			if {$i($u)==$min} {
			  set k $u
			  break
			}
		  }
		  
		  $widtexte tag add $nom($k) $i($k) "$i($k) + $long($k) char"
		  set debut "$i($k) + $long($k) char"
		  
		  # on ne recalcule que celui qu'on vient d'utiliser
		  set i($k) [eval $com($k)]
		  
		}
		
		for { set k 6 } { $k>=0 } { incr k -1} {
		  $widtexte tag configure $nom($k) -foreground $couleur($k)
		}
		
				
		set travailencours 0
		.fetat.message configure -text ""
		$widtexte configure -cursor arrow
		. configure -cursor arrow
		.ficones.coloration configure -image $imgColoration
		update
	  }
	  
	  
	  
	  ##########################
	  # Couleurs et préférences
	  ##########################
	  
	  
proc Tikeditor::Couleurs { } {
		variable couleur
		global widtexte
		
		destroy .fenCoul
		toplevel .fenCoul
		bind .fenCoul <3> {destroy .fenCoul}
		wm title .fenCoul "Choix des couleurs"
		wm resizable .fenCoul false false
		
		set Coul " Namespace 0	proc 1 Variable 2 Tcl 3 Tk 4 OptionsTk 5 Commentaire 6 Fond fond Curseur curseur"
		foreach {chose cle} $Coul {
		  pack [button .fenCoul.$cle -text $chose -width 25 -bg $couleur($cle)\
			  -command "Tikeditor::ModCouleur $cle" ]
		}
	
	label .fenCoul.separe -text " les changements fond et curseur\n s'appliquent immédiatement."
	pack  .fenCoul.separe -before .fenCoul.fond
		button .fenCoul.ok -text "Valider" -width 10 -command "Tikeditor::Coloration $widtexte 1" -background grey -foreground black
		button .fenCoul.fermer -text "Fermer" -width 10 -command "destroy .fenCoul" -background grey -foreground black
		
		button .fenCoul.defaut -text "Réinitialiser"\
			-width 10	-command "Tikeditor::ModCouleur defaut " -background grey -foreground black
		pack .fenCoul.ok .fenCoul.defaut   .fenCoul.fermer -side left -expand 1 -fill x
	  }
	  
proc Tikeditor::ModCouleur {cle} {
		variable couleur
		global widtexte
		
		if {$cle=="defaut"} {
		  # namespace
		  set nouvellecouleur red
		  set couleur(0) $nouvellecouleur
		  # proc
		  set nouvellecouleur red
		  set couleur(1) $nouvellecouleur
		  # variable
		  set nouvellecouleur darkblue
		  set couleur(2) $nouvellecouleur
		  # tcl
		  set nouvellecouleur blue
		  set couleur(3) $nouvellecouleur
		  # tk
		  set nouvellecouleur chocolate
		  set couleur(4) $nouvellecouleur
		  #options tk
		  set nouvellecouleur violet
		  set couleur(5] $nouvellecouleur
		  # commentaire
		  set nouvellecouleur darkgreen
		  set couleur(6) $nouvellecouleur
		  # fond
		  set nouvellecouleur white
		  set couleur(fond) $nouvellecouleur
		  $widtexte configure -bg $nouvellecouleur
		  # curseur
		  set nouvellecouleur black
		  set couleur(curseur) $nouvellecouleur
		  $widtexte configure -fg $nouvellecouleur -insertbackground $nouvellecouleur
		  
		  #fermeture de la boite et mise à jour de la colorisation du texte
		  destroy .fenCoul
		  Tikeditor::Coloration $widtexte 1
		  return
		  
		} else {
		  set nouvellecouleur [tk_chooseColor -initialcolor $couleur($cle) -parent .fenCoul\
			  -title "Choisir une couleur"]
		  
		  if {$nouvellecouleur==""} {destroy .fenCoul ; return }
		  set couleur($cle) $nouvellecouleur
		  
		  if {$cle=="fond"} {
			$widtexte configure -bg $nouvellecouleur
		  } elseif {$cle=="curseur"} {
			$widtexte configure -fg $nouvellecouleur -insertbackground $nouvellecouleur
		  } else {
			$widtexte tag configure $cle -foreground $nouvellecouleur
		  }
		}
		.fenCoul.$cle configure  -bg $nouvellecouleur
		
		#fin de la procédure modCouleur
	  }
	  
proc Tikeditor::BarreEtat {position } {
		global widtexte
		switch $position {
		  "haut" {pack .fetat  -before .ftext -fill both}
		  "bas" {pack .fetat  -after .ftext -fill both}
		} }
	  
proc Tikeditor::RetourLigne  {wrap } {
		global widtexte
		switch $wrap {
		  "none" {$widtexte configure -wrap none -background  white }
		  "word" {$widtexte configure -wrap word -background ivory}
		  "char" {$widtexte configure -wrap char -background #bcc0e0	   }
		} }
	  
proc Tikeditor::PolicePlus {widtexte} {
		
		set i "[lindex [$widtexte cget -font] 1 ]"
		set j "[ list [lindex [$widtexte cget -font] 0 ] ]"
		incr i
		$widtexte configure -font "$j $i"
		
	  }
	  
proc Tikeditor::PoliceMoins {widtexte} {
		
		set i "[lindex [$widtexte cget -font] 1]"
		set j "[ list [lindex [$widtexte cget -font] 0 ] ]"
		incr i -1
		if {$i <2} { set i 2}
		
		$widtexte configure -font "$j $i  "
		
	  }
	
proc Tikeditor::PolicePlusAide {widtexte} {
		global Size
		incr Size
		
HMset_state $widtexte -size $Size
	  }
	  
proc Tikeditor::PoliceMoinsAide {widtexte} {
		global Size		
		incr Size -1
 HMset_state $widtexte -size $Size
	  }
	  
	  
	  
proc Tikeditor::ChoixFonte {} {
		global police
		global taillePolice
		global widtexte
		
		destroy .fonte
		toplevel .fonte
		wm title .fonte "FONTE Tikeditor"
	
		wm resizable .fonte false false
		
		
		frame .fonte.f  -relief raised 
		frame .fonte.f.ico -bg SteelBlue
		
		pack .fonte.f  -expand false -fill y
		pack .fonte.f.ico -fill x
		
		button .fonte.f.ico.plus -text "+" -command { incr taillePolice ; .fonte.f.tp configure -font "[list $police]  $taillePolice " } -font {-size 12}
		button .fonte.f.ico.moins -text "-" -command { incr taillePolice  -1; .fonte.f.tp configure -font "[list $police]  $taillePolice "  } -font {-size 12}
		button .fonte.f.ico.okT  -text valider -command { $widtexte configure -font "[list $police]  $taillePolice " } -font {-size 12}
		
		spinbox .fonte.f.ico.nomFonte -text "nom de fonte" -relief raised -bd 3  -values [font families]\
			-textvariable police -command  {.fonte.f.tp configure -font "[list $police]  $taillePolice "}  -font {-size 12}
		button .fonte.f.ico.okP -text valider -command { $widtexte configure -font "[list $police]  $taillePolice " } -font {-size 12}
		
		label .fonte.f.ico.lP -text POLICE  -relief flat -bd 0 -bg SteelBlue -fg yellow -font {-size 12}
		
		spinbox .fonte.f.ico.sp -text police -relief raised -bd 3 -width 3  -from 6 -to 30 -incr 2 -textvariable taillePolice -command  {.fonte.f.tp configure -font "[list $police]  $taillePolice "}
		label .fonte.f.ico.l -text CorpsFonte  -relief flat -bd 0 -bg SteelBlue -fg yellow -font {-size 12}
		
		pack  .fonte.f.ico.l  .fonte.f.ico.plus  .fonte.f.ico.moins .fonte.f.ico.sp  .fonte.f.ico.okT	.fonte.f.ico.lP  .fonte.f.ico.nomFonte  .fonte.f.ico.okP  -side left -fill y
		
		text .fonte.f.tp -bg AntiqueWhite -font [list $police]  -relief sunken  -wrap char -height 5 -width 15 
		pack .fonte.f.tp -fill both -expand 1
		.fonte.f.tp insert end "Ceci est un texte pour essayer les fontes \nabcdefghijklmnopqrstuvwyz\nABCDEFGHIJKLMNOPQRSTUVWXYZ"
		
		.fonte.f.ico.nomFonte delete 0 end
		.fonte.f.ico.nomFonte insert end  "[ list [lindex [$widtexte cget -font] 0 ] ]"
		.fonte.f.ico.sp delete 0 end
		.fonte.f.ico.sp insert end "[lindex [$widtexte cget -font] 1]"
		
		bind .fonte <3> { destroy .fonte }
		
	  }
	  
	  
	  
	  ##########################
	  # aides programmeur Tcl/Tk
	  ##########################
	  
	  
proc Tikeditor::EvaluationTcl {widtexte} {
		set contenu [$widtexte get 1.0 end]
		set Espace [namespace current]
		
	proc ${Espace}::FenRes {widtexte} 	{
		  #global widtexte
		  destroy $widtexte.cadre
		  frame $widtexte.cadre
		  $widtexte window create "current linestart" -window $widtexte.cadre
		  text $widtexte.cadre.fenres -wrap word -bg pink -tabs {1c} -bd 12 -relief raised -yscrollcommand {$widtexte.cadre.yres set}
		  
		  scrollbar $widtexte.cadre.yres -orient vertical -command {$widtexte.cadre.fenres yview}
		  pack $widtexte.cadre.fenres $widtexte.cadre.yres -side left -fill y
		  $widtexte.cadre.fenres insert end "	FERMETURE: CLIC DROIT\n   *********************************\n"
		  $widtexte.cadre.fenres insert end 	 "Pensez à refermer l'évaluation de votre script\n\n" ;#"Résultat de l'évaluation par tclsh\n\n"
		  bind $widtexte.cadre.fenres <Button-3> {destroy $widtexte.cadre}
		}
		
		${Espace}::FenRes $widtexte
		if [interp exists slave] {interp delete slave}
		
		set slave [interp create slave]
		
		
		$slave hide proc
		#£		$slave hide puts
		$slave alias proc ${Espace}::slave_proc $slave
		$slave alias exit  ${Espace}::slave_exit  $slave $widtexte.cadre.fenres
		#£		$slave alias puts ${Espace}::slave_puts $slave $widtexte.cadre.fenres
		
		
	proc ${Espace}::slave_exit {slave widtexte args} {
		  $widtexte insert end "\n"
		  $widtexte insert end "Interprétation terminée"
		  $widtexte tag add interpretation "insert linestart" "insert lineend"
		  $widtexte tag configure interpretation -underline 1
		  interp delete $slave
		}
		
	proc ${Espace}::slave_proc {slave name args body} {
		  $slave invokehidden proc $name $args $body
		}
		
	proc ${Espace}::slave_puts {slave widtexte args} {
		  $widtexte insert end "Interprétation\ du\ fichier"
		  $widtexte tag add interpretation "insert linestart" "insert lineend"
		  $widtexte tag configure interpretation -underline 1
		  $widtexte insert end "\n$args"
		}
		
		if [catch {$slave eval $contenu} erreur] {$widtexte.cadre.fenres insert end "ERREUR\ :\n$erreur"}
	  }
	  
		  
proc Tikeditor::LanceConsole {widtexte } {
global NomScript
	# set NomScript [info script]
	  set chemin  [file dirname $NomScript]
	#pour l'évaluation : console
		exec  tclsh [file join $chemin console.tcl ] 
		
	  }
	  
	
	  
proc Tikeditor::AcrobatTcl {} {
		global Chemin
		variable cheminAcrobat
		if {$cheminAcrobat ==0} {
		  set cheminAcrobat [tk_getOpenFile ]
		  exec $cheminAcrobat  [file join $Chemin(rel) ReferenceTcl.pdf ] &
		} else {
		  exec $cheminAcrobat  [file join $Chemin(rel) ReferenceTcl.pdf ]  & ; # l'esperluette permet d'éxécuter AcrobatReader en arrrière plan
		}
	  }
	  
	  
proc Tikeditor::Visionneuse {} {
		global Chemin
		set vision [file join $Chemin(rel) visionneuse Tkvisionneuse.tcl ]
		exec wish	$vision  & ; # & l'esperluette permet d'éxécuter Visionneuse en arrrière plan
	  }
	  
proc Tikeditor::ExpressionReguliere {} {
		variable couleur
		global Chemin
		destroy .topRG
		# création d'une fenêtre pour les expressions régulières
		toplevel .topRG
		set largeurEcran [ winfo screenwidth . ]
		wm geometry .topRG +[expr ${largeurEcran}/2]+60
		text .topRG.fenRG -wrap none  -bg skyblue  -fg $couleur(curseur)\
			-tabs {1c} -font "Helvetica 10"	-yscrollcommand ".topRG.sy set" -xscrollcommand ".topRG.sx set" -relief groove  -cursor "hand1"
		scrollbar .topRG.sy -orient vertical -command ".topRG.fenRG yview" -cursor hand2
		scrollbar .topRG.sx  -orient horizontal -command ".topRG.fenRG xview" -cursor hand2
		
		pack .topRG.sx -fill x  -side top
		pack .topRG.sy -fill y -side left
		pack .topRG.fenRG -expand false -fill both -side left
		
		
		set Aexpreg [file join $Chemin(rel) aideRG.txt ]
		set FIC [open $Aexpreg RDWR]
		
		.topRG.fenRG delete 0.0 end
		set contenu [ read -nonewline $FIC ]
		regsub -all {\ {4}} $contenu "\t" contenu
		.topRG.fenRG insert 0.0 $contenu
		close $FIC
		.topRG.fenRG configure -state disabled
		bind .topRG <3> {destroy .topRG}
		
	  }
	  
	  ################################################################################
	  #<BALISES TIK>
	  ################################################################################
	  
	  
	  
proc Tikeditor::RechercheBalises { widtexte } {
		variable ListeBalises
		set debut 1.0
		set  ListeBalises ""
		
		while 1 {
		  set indice [$widtexte search -forwards -regexp {#<[a-zA-Z_*]+>}  $debut end ] ; # $indice est un numéro de ligne+numéro du caractère dans la ligne, un indice quoi!
		  if {$indice==""} { 	break}
		  
		  set indice [$widtexte search -forwards -count longueur		-regexp {#<[a-zA-Z_*]+>}  "$indice " end]
		  set debut "$indice + $longueur char"
		  append ListeBalises  " [$widtexte get $indice "$indice + $longueur char" ] $indice "
		}
		
		return $ListeBalises
		
	  }
	  
proc Tikeditor::AfficheListeBalises {widtexte} {
		variable ListeBalises
		variable couleur
		global indexBalise1
		global indexBalise2
		
		destroy .topBalises ; #supprime la fenetre éventuellement ouverte précédemment
		
		# création d'une fenêtre pour les procédures
		toplevel .topBalises
		set largeurEcran [ winfo screenwidth . ]
		wm geometry .topBalises +[expr ${largeurEcran}-350]+60
		text .topBalises.fenbalises -wrap word -bg LightBlue   -fg $couleur(curseur)\
			-tabs {1c} -font "Helvetica 12"	-yscrollcommand ".topBalises.sy set"  -relief groove  -cursor "hand1"
		scrollbar .topBalises.sy -orient vertical -command ".topBalises.fenbalises yview" -cursor hand2
		
		# appel de la procedure RechercherBalises
		Tikeditor::RechercheBalises $widtexte
		
		set max 0
		set compteur 0
		
		# écriture dans la fenêtre des procédure
		#ligne d'entête
		.topBalises.fenbalises insert end "Un clic sur une balise\n y positionne la fenêtre principale\n\n\n"
		
		set deb "début du script\n"
		.topBalises.fenbalises insert end $deb
		.topBalises.fenbalises tag add debZero 5.0 "5.0 lineend"
		.topBalises.fenbalises tag configure debZero  -underline 1
		
		# 1 clic et on voit le début du script dans la fenetre principale
		.topBalises.fenbalises tag bind debZero <1> "$widtexte see 1.0"
		
		# boucle 		pour afficher la liste des balises
		foreach {el i} $ListeBalises {
		  incr compteur
		  set l [string length $el]
		  if {$l>$max} {set max $l}
		  .topBalises.fenbalises insert end $el
		  .topBalises.fenbalises tag add $el "current linestart" "current lineend"
		  .topBalises.fenbalises tag configure $el -foreground black   -underline 1
		  
		  .topBalises.fenbalises tag bind $el <1> "$widtexte see $i	"	 ; # 1 clic et on voit la procédure dans la fenetre principale
		  .topBalises.fenbalises insert end \n ; # saut de ligne avant affichage des balises
		} ; #fin de la boucle d'affichage
		
		.topBalises.fenbalises insert 1.0	"Liste des $compteur balises \n\n"
		
		.topBalises.fenbalises configure -width [expr {$max+2} ]
		
		pack .topBalises.fenbalises 	-fill both -side right -expand true
		pack 	.topBalises.sy -fill y -side right
		
		bind .topBalises.fenbalises <3> "destroy .topBalises	"
	  }
	  
	  ################################################################################
	  # RECHERCHE ET AFFICHAGE  DES PROCEDURES
	  ################################################################################
	  
proc Tikeditor::RechercheProcs { widtexte } {
		variable ListeProcs
		variable ListeProcsAlpha
		set debut 1.0
		set ListeProcs ""
		set ListeProcsAlpha ""
		
		if { [string match  "*proc *" [$widtexte get 1.0 end] ] !=1 } {tk_messageBox -message " Il n'y a pas de procédures dans votre script."  ; return}
		
		# partie propre à chrono
		while 1 {
		  set indice [$widtexte search -forwards -regexp {^\s*proc} $debut end] ; # $indice est un numéro de ligne+numéro du caractère dans la ligne, un indice quoi!
		  if {$indice==""} { break }
		  set indice [$widtexte search -forwards -count longueur\
			  -regexp {\s*[a-zA-Z$\{]+[_a-zA-Z0-9\}]*(::)*[$\{\}a-zA-Z0-9_]+\s} "$indice + 4 char" end]
		  set debut "$indice + $longueur char"
		  append ListeProcs " [$widtexte get $indice "$indice + $longueur char" ] $indice "
		}
		
		# partie propre à ALpha :
		set debut "1.0"
		
		while 1 {
		  set indice  [$widtexte  search -forwards -regexp {^\s*proc} $debut end] ; # $indice est un numéro de ligne+numéro du caractère dans la ligne, un indice quoi!
		  if {$indice==""} { break }
		  set indice [$widtexte  search -forwards -count longueur\
			  -regexp {\s*[a-zA-Z$\{]+[_a-zA-Z0-9\}]*(::)*[$\{\}a-zA-Z0-9_]+\s} "$indice + 4 char" end]
		  set debut "$indice + $longueur char"
		  
		  set elementListeProcsAlpha  " [$widtexte get $indice "$indice + $longueur char" ] $indice "
		  regsub -all {[\{\}]}	$elementListeProcsAlpha  "µ" elementListeProcsAlpha  ;# # traitement de la chaine pour que [trim \{\}] fonctionne (voir plus loin)
		  lappend ListeProcsAlpha $elementListeProcsAlpha
		  
		  set ListeProcsAlpha [lsort -dictionary $ListeProcsAlpha]
		  set ListeIntermediaire ""
		  
		  foreach element $ListeProcsAlpha {
			set elmt [split $element \}]
			set elmt [string trim $elmt \{\}]
			set ListeIntermediaire [concat $ListeIntermediaire $elmt]
		  }
		  
		}
		
		set ListeProcsAlpha $ListeIntermediaire
		
		
	  }
	  
	  
proc Tikeditor::AfficheListeProcs { widtexte } {
		variable ListeProcs
		variable couleur
		global indexProc1
		global indexProc2
		
		
		
		destroy .topProcs ; #supprime la fenetre éventuellement ouverte précédemment
		
		# création d'une fenêtre pour les procédures
		toplevel .topProcs
		set largeurEcran [ winfo screenwidth . ]
		wm geometry .topProcs +[expr ${largeurEcran}-350]+60
		text .topProcs.fenprocs -wrap word -bg SpringGreen  -fg $couleur(curseur)\
			-tabs {1c} -font "Helvetica 12"	-yscrollcommand ".topProcs.sy set"  -relief groove  -cursor "hand1"
		scrollbar .topProcs.sy -orient vertical -command ".topProcs.fenprocs yview" -cursor hand2
		
		# appel de la procedure RechercherProcs
		Tikeditor::RechercheProcs $widtexte
		set max 0
		set compteur 0
		
		# écriture dans la fenêtre des procédure
		#ligne d'entête
		.topProcs.fenprocs insert end "Un clic sur une procédure\n y positionne \
			la fenêtre principale \n un double-clic ouvre une fenêtre \n avec n° de ligne.\n\n"
		set deb "début du script\n"
		.topProcs.fenprocs insert end $deb
		.topProcs.fenprocs tag add debZero 6.0 "6.0 lineend"
		.topProcs.fenprocs tag configure debZero -foreground red -underline 1
		# 1 clic et on voit le début du script dans la fenetre principale
		# double clic et le script s'affiche dans une nouvelle fenêtre avec n° de lignes
		.topProcs.fenprocs tag bind debZero <1> "$widtexte see 1.0"
		.topProcs.fenprocs tag bind debZero <Double-Button-1> " set indexProc1 1.0  ; set indexProc2 end ; Tikeditor::BodyProcsDebut $widtexte "
		
		foreach {el i} $ListeProcs {
		  incr compteur
		  set l [string length $el]
		  if {$l>$max} {set max $l}
		  .topProcs.fenprocs insert end $el
		  .topProcs.fenprocs tag add $el "current linestart" "current lineend"
		  .topProcs.fenprocs tag configure $el -foreground blue -underline 1
		  .topProcs.fenprocs tag bind $el <1> "$widtexte see $i	"
		  # 1 clic et on voit la procédure dans la fenetre principale
		  # double clic et le corps de la procédure s'affiche dans une nouvelle fenêtre avec n° de lignes
		  .topProcs.fenprocs tag bind $el <Double-Button-1> " set indexProc1 $i ; set indexProc2 end ; Tikeditor::BodyProcs $widtexte "
		  
		  .topProcs.fenprocs insert end \n
		}
		
		.topProcs.fenprocs insert 1.0	"Liste des $compteur procédures \n\n"
		
		.topProcs.fenprocs configure -width [expr {$max+2} ]
		
		
		pack .topProcs.fenprocs 	-fill both -side right -expand true
		pack 	.topProcs.sy -fill y -side right
		
		
		bind .topProcs.fenprocs <3> "destroy .topProcs	"
	  }
	  
	  
	  
proc Tikeditor::AfficheListeProcsAlpha { widtexte } {
		variable ListeProcsAlpha
		variable couleur
		
		destroy .topProcsAlpha
		# création d'une fenêtre pour les procédures alpha
		toplevel .topProcsAlpha
		set largeurEcran [ winfo screenwidth . ]
		wm geometry .topProcsAlpha +[expr ${largeurEcran}-350]+60
		text .topProcsAlpha.fenprocs -wrap word -bg orange  -fg $couleur(curseur)\
			-tabs {1c} -font "Helvetica 12"	-yscrollcommand ".topProcsAlpha.sy set" -relief groove  -cursor "hand1"
		scrollbar .topProcsAlpha.sy -orient vertical -command ".topProcsAlpha.fenprocs yview" -cursor hand2
		Tikeditor::RechercheProcs $widtexte
		set max 0
		set compteur 0
		
		
		# écriture dans la fenêtre des procédure
		#ligne d'entête
		.topProcsAlpha.fenprocs insert end "Un clic sur une procédure\n y positionne \
			la fenêtre principale \n un double-clic ouvre une fenêtre \n avec n° de ligne.\n\n"
		set deb "début du script\n"
		.topProcsAlpha.fenprocs insert end $deb
		.topProcsAlpha.fenprocs tag add debZero 6.0 "6.0 lineend"
		.topProcsAlpha.fenprocs tag configure debZero -foreground red -underline 1
		# 1 clic et on voit le début du script dans la fenetre principale
		# double clic et le script s'affiche dans une nouvelle fenêtre avec n° de lignes
		.topProcsAlpha.fenprocs tag bind debZero <1> "$widtexte see 1.0"
		.topProcsAlpha.fenprocs tag bind debZero <Double-Button-1> " set indexProc1 1.0  ; set indexProc2 end ; Tikeditor::BodyProcsDebut $widtexte "
		
		
		foreach {el i} $ListeProcsAlpha {
		  incr compteur
		  set l [string length $el]
		  if {$l>$max} {set max $l}
		  .topProcsAlpha.fenprocs insert end $el
		  .topProcsAlpha.fenprocs tag add $el "current linestart" "current lineend"
		  .topProcsAlpha.fenprocs tag configure $el -foreground blue -underline 1
		  .topProcsAlpha.fenprocs tag bind $el <1> "$widtexte see $i	"
		  # 1 clic et on voit la procédure dans la fenetre principale
		  # double clic et le corps de la procédure s'affiche dans une nouvelle fenêtre avec n° de lignes
		  .topProcsAlpha.fenprocs tag bind $el <Double-Button-1> " set indexProc1 $i ; set indexProc2 end ; Tikeditor::BodyProcs $widtexte "
		  .topProcsAlpha.fenprocs insert end \n
		}
		
		.topProcsAlpha.fenprocs insert 1.0	"Liste des $compteur procédures \n\n"
		
		.topProcsAlpha.fenprocs configure -width [expr {$max+2} ]
		
		pack .topProcsAlpha.fenprocs 	-fill both -side right -expand true
		pack  	.topProcsAlpha.sy -fill y -side right -expand true
		
		bind .topProcsAlpha.fenprocs <3> "destroy .topProcsAlpha	"
	  }
	  
	  #____________________________________________________________________________________
	  
	  
proc Tikeditor::BodyProcs {widtexte } {
		variable couleur
		global indexProc1
		global indexProc2
		
		destroy .topBodyProcs
		# création d'une fenêtre pour les procédures
		toplevel .topBodyProcs
		set largeurEcran [ winfo screenwidth . ]
		wm geometry .topBodyProcs +[expr ${largeurEcran} - 400]+100
		text .topBodyProcs.fenprocs -wrap none -bg beige  -fg $couleur(curseur)\
			-tabs {1c} -font "Helvetica 12"	-yscrollcommand ".topBodyProcs.sy set" -xscrollcommand ".topBodyProcs.sx set" -relief groove  -cursor "hand1"
		scrollbar .topBodyProcs.sy -orient vertical -command ".topBodyProcs.fenprocs yview" -cursor hand2
		scrollbar .topBodyProcs.sx -orient horizontal -command ".topBodyProcs.fenprocs xview" -cursor hand2
		
		set corpProc [$widtexte get $indexProc1 $indexProc2]
		.topBodyProcs.fenprocs tag configure tagProc -foreground red -background white
		#.topBodyProcs.fenprocs insert 1.0  "proc " tagProc
		.topBodyProcs.fenprocs insert 1.5 $corpProc
		
		.topBodyProcs.fenprocs tag  add  tagProc 1.0 "1.0 lineend"
		
		pack .topBodyProcs.sx -fill x
		
		pack .topBodyProcs.sy -fill y -side left
		pack .topBodyProcs.fenprocs -fill both -side left -expand 1
		
		
		bind .topBodyProcs.fenprocs <3> "destroy .topBodyProcs	"
		
		Tikeditor::NumeroterLignes
		
	  }
	  
proc Tikeditor::BodyProcsDebut {widtexte } {
		variable couleur
		global indexProc1
		global indexProc2
		
		destroy .topBodyProcs
		# création d'une fenêtre pour les procédures
		toplevel .topBodyProcs
		set largeurEcran [ winfo screenwidth . ]
		wm geometry .topBodyProcs +[expr ${largeurEcran} - 400]+100
		text .topBodyProcs.fenprocs -wrap none -bg beige  -fg $couleur(curseur)\
			-tabs {1c} -font "Helvetica 12"	-yscrollcommand ".topBodyProcs.sy set" -xscrollcommand ".topBodyProcs.sx set" -relief groove  -cursor "man"
		scrollbar .topBodyProcs.sy -orient vertical -command ".topBodyProcs.fenprocs yview" -cursor hand2
		scrollbar .topBodyProcs.sx -orient horizontal -command ".topBodyProcs.fenprocs xview" -cursor hand2
		
		set corpProc [$widtexte get $indexProc1 $indexProc2]
		.topBodyProcs.fenprocs insert 1.5 $corpProc
		
		.topBodyProcs.fenprocs tag configure tagProc -foreground red -background white
		.topBodyProcs.fenprocs insert 1.0 "DEBUT DU SCRIPT\n" tagProc
		.topBodyProcs.fenprocs insert end "\nFIN DU SCRIPT" tagProc
		
		pack .topBodyProcs.sx -fill x
		pack .topBodyProcs.sy -fill y -side left
		pack .topBodyProcs.fenprocs -fill both -side left
		
		
		bind .topBodyProcs.fenprocs <3> "destroy .topBodyProcs	"
		
		Tikeditor::NumeroterLignes
		
	  }
	  
proc Tikeditor::NumeroterLignes {} {
		set i 1 ;# lignes logiques
		set j 1 ;# lignes texte
		
		.topBodyProcs.fenprocs tag configure numéro -foreground red -background green
		
		set fenetre .topBodyProcs.fenprocs
		set nb [expr int([ $fenetre index end])-1]
		
		while {$j<$nb} {
		  set contenuLigne  [$fenetre get $j.0 "$j.0 lineend"]
		  set finDeLigne [string index $contenuLigne end ]
		  # le if/else suivant teste si une ligne d'instruction a été coupée par une oblique pour la lisibilité du code
		  if { [string compare $finDeLigne \\ ] == 0} {
			incr j
		  } else {
			$fenetre insert "[expr $j + 1].0" "$i  " numéro
			incr i
			incr j
		  }
		  
		}
		.topBodyProcs.fenprocs configure -state disabled
	  }
	  
	  
	
	  ################################################################################
	  #	# entrée pour choisir le mot pour recherche d'occurences
	  ################################################################################
#<Occurences>

proc Tikeditor::ChoisirMot {} {
		destroy .topMot 	; #ferme la fenêtre précédemment ouverte
		toplevel .topMot		; #ouvre la fenêtre de recherche
		label .topMot.label1 -text "rechercher : " -width 25 -font {-size 12}  -bg beige -justify left
		entry .topMot.entreMot  -textvariable motRecherche -font {-size 12} -bg ivory -justify left
		checkbutton .topMot.ch1 -text "Différencier Maj/Min" -variable majmin -onvalue 1 -offvalue 0 -font {-size 12} -bg beige -justify left
		checkbutton .topMot.ch2 -text "Expression Régulière" -variable expressRegul -onvalue 1 -offvalue 0 -font {-size 12} -bg beige -justify left
		checkbutton .topMot.ch3 -text "Dans texte caché	" -variable texteCache  -onvalue 1 -offvalue 0 -font {-size 12} -bg beige -justify left
		
		radiobutton .topMot.ch4 -text "Après curseur	" -variable wards  -value forwards -font {-size 12} -bg beige -justify left
		radiobutton .topMot.ch5 -text "Avant curseur	" -variable wards  -value backwards  -font {-size 12} -bg beige -justify left
		radiobutton .topMot.ch6 -text "Tout le texte	" -variable wards  -value 0  -font {-size 12} -bg beige -justify left
		radiobutton .topMot.ch7 -text "Texte sélectionné" -variable wards  -value selection  -font {-size 12} -bg beige -justify left
		
		button .topMot.ok -text "lancer la recherche" -bg beige -fg blue -font {-size 12} -bd 5 -relief raise \
			 -command { Tikeditor::AfficheListeOccurences $widtexte $motRecherche $wards $texteCache $majmin $expressRegul} -justify left
		grid .topMot.label1   -column 1 -row 1 -padx  3 -sticky ew
		grid .topMot.entreMot -column 1 -row 2 -padx 3 -sticky ew
		grid .topMot.ch1 -column 1 -row 3 -padx 3 -sticky ew
		grid .topMot.ch2 -column 1 -row 4 -padx 3 -sticky ew
		grid .topMot.ch3 -column 1 -row 5 -padx 3  -sticky ew
		grid .topMot.ch4 -column 1 -row 6 -padx 3  -sticky ew
		grid .topMot.ch5 -column 1 -row 7 -padx 3  -sticky ew
		grid .topMot.ch6 -column 1 -row 8 -padx 3  -sticky ew
		grid .topMot.ch7 -column 1 -row 9 -padx 3  -sticky ew
		grid .topMot.ok  -column 1 -row 10 -padx 3 -sticky ew
		
		bind .topMot <3> {destroy .topMot }
		
	  }
	  

proc Tikeditor::RechercherElement { widtexte element wards texteCache minMaj expressRegul } { 
 
		
		variable ListeOccurences
		
		 set indices [ $widtexte tag ranges sel ]
		  if { [llength $indices] == 0  } {
		  set debut 1.0
		  set fin end
		} else {
		  	set indices [ $widtexte tag ranges sel ]
		 	set debut [$widtexte index  [lindex $indices 0]]
			set fin [$widtexte index  [lindex $indices 1]]
			  }
		  
		
		$widtexte tag remove  surligner 1.0 end
		
	
		#différenciation des majuscules et des minuscules
		if {$minMaj == 1} {
		set  casse ""
		} else {
		 set casse "-nocase"
		}
		# recherche avec ou sans expression régulière
		set ListeOccurences ""
		if {$expressRegul==1} {
		  set com "-regexp $casse $element"
		} else {		  
		  set com $element
		}
		
		#recherche avec ou sans texte caché
		if {$texteCache == 1} {
			set masque "-elide"
		} else {
			set masque ""
		}
		
		#sens de la recherche
				
		switch $wards forwards {set debut [$widtexte index insert] ; set fin end  }
		switch $wards backwards {set fin [$widtexte index insert] ;set debut 1.0 }
		switch $wards 0 {set fin end  }
		switch $wards "" {set debut 1.0 ; set fin end  }
		switch $wards "selection" {set debut $debut ; set fin $fin  }
		
		# boucle de recherche enregistrant les indices d'occurences dans une liste "ListeOccurences"
		while 1 {
		  set lacom "$widtexte search $casse $masque -count longueur $com  \"$debut\" \"$fin\" "
		  set indice [eval $lacom]
		  if {$indice==""} { break }
		  lappend ListeOccurences $indice
		  set debut "$indice + $longueur char"
		}
		
	
	}
	
	
proc Tikeditor::AfficheListeOccurences { widtexte element wards texteCache majmin expressRegul} {
		variable ListeOccurences
		
		
		
		destroy .topMot.fenoccs
		destroy .topMot.occssy
		scrollbar .topMot.occssy -orient vertical -command ".topMot.fenoccs yview" -cursor "hand2"
		text  .topMot.fenoccs -wrap word -bd 6 -relief raised -bg lavender -fg black \
			-tabs {1c} -font "Helvetica 12"	-height 10 -yscrollcommand ".topMot.occssy set" -width 40 -cursor "hand1"
		
		
		
		Tikeditor::RechercherElement $widtexte $element $wards $texteCache $majmin $expressRegul
		
		grid .topMot.fenoccs  -row 1 -column 2 -rowspan 5
		grid .topMot.occssy -row 1 -column 3 -rowspan 5 -sticky ns
		
		# lancement de la boucle d'affichage dans la fenêtre crée à la ligne ci-dessus
		set compteur 0
		if {[llength $ListeOccurences]!=0} {
		  foreach el $ListeOccurences {
			
			set ligneOccurence "... ligne N° $el ème caractère..." ;# $el est un indice text (ex : 10.5 ) N°ligne.N°caractère
			
			$widtexte tag add surligner $el
			$widtexte tag configure surligner -background yellow
			
			.topMot.fenoccs insert end "Occurence $compteur : $ligneOccurence"
			.topMot.fenoccs tag add $compteur "current linestart" "current lineend"
			.topMot.fenoccs tag configure $compteur -foreground blue -underline 1
			.topMot.fenoccs tag bind $compteur <1> "$widtexte see $el ;destroy .topBulleOccurence "
			
			.topMot.fenoccs tag bind $compteur <Enter> ".topMot.fenoccs tag configure $compteur -background AntiqueWhite  -foreground blue -underline 1 ;Tikeditor::BulleOccurence $widtexte $el"
			.topMot.fenoccs tag bind $compteur <Leave> " .topMot.fenoccs tag configure $compteur -background  lavender  ; destroy .topBulleOccurence "
			
			.topMot.fenoccs insert end \n
			incr compteur
			
			
		  }
		}
		.topMot.fenoccs insert 1.0 "$compteur occurence(s) de \"$element\"\n\n"
		
		bind .topMot.fenoccs <3> {	destroy .topBulleOccurence  ;	destroy .topMot	; $widtexte tag remove "surligner" 1.0 end }
	  }
	  
proc Tikeditor::BulleOccurence { widtexte indice} {
		toplevel .topBulleOccurence
		text .topBulleOccurence.texte  -height 1 -bg White -fg tomato -relief raised -borderwidth 2
		
		wm overrideredirect .topBulleOccurence  1 ; # supprime la barre de titre
		set x [ winfo pointerx . ]
		set y [ winfo pointery . ]
		wm geometry .topBulleOccurence  +[expr $x + 10]+[expr $y - 10]
		
		set contenuLigneOccurence [ string trimleft [$widtexte get "$indice linestart" "$indice  lineend" ] " \t"]
		set contenuLigneOccurence [ string trimright $contenuLigneOccurence " " ]
		.topBulleOccurence.texte insert end $contenuLigneOccurence
		pack .topBulleOccurence.texte
		.topBulleOccurence.texte configure -width [string length $contenuLigneOccurence ]
		
	  }
	  
	  ###############################
	  #<remplacement>
	  
proc Tikeditor::Remplacer {widtexte } {
		destroy .topRemplace 	; #ferme la fenêtre précédemment ouverte
		toplevel .topRemplace		; #ouvre la fenêtre de recherche
		
		label .topRemplace.label1 -text "remplacer : "
		entry .topRemplace.entreMot  -textvariable motRecherche
		label .topRemplace.label2 -text "par : "
		entry .topRemplace.entreRemplacement  -textvariable aLaPlace
		button .topRemplace.ok -text "lancer la recherche-remplacement"  -command { Tikeditor::RemplacerMaintenant $widtexte $motRecherche $aLaPlace $majmin }
		checkbutton .topRemplace.ch1 -text "Différencier Maj/Min" -variable majmin -onvalue 1 -offvalue 0
		button .topRemplace.b2 -text "Remplacer tout" -command { Tikeditor::RemplacerTout $widtexte $motRecherche $aLaPlace $majmin }
		
		grid .topRemplace.label1   -column 1 -row 1 -padx  8
		grid .topRemplace.entreMot -column 1 -row 2 -padx 8
		grid .topRemplace.label2   -column 1 -row 3 -padx  8
		grid .topRemplace.entreRemplacement -column 1 -row 4 -padx 8
		grid .topRemplace.ok  -column 1 -row 5 -padx 8
		grid .topRemplace.ch1 -column 2 -row 1 -padx 8
		grid .topRemplace.b2 -column 2 -row 5 -padx 8
		
		bind .topRemplace <3> {destroy .topRemplace}
	  }
	  
proc Tikeditor::RemplacerMaintenant { widtexte motif remplacement mM } {
		if {$mM == 0} {
		  regexp  -indices -nocase -- $motif [$widtexte get 1.0 end ]  indicesRemplacement
		} else {
		  regexp  -indices -- $motif [$widtexte get 1.0 end ]  indicesRemplacement
		}
		
		if { [catch {
			$widtexte delete "1.0 + [expr [lindex  $indicesRemplacement 0] ] chars" \
			"1.0 + [expr [lindex $indicesRemplacement  1 ] +1] chars "
			$widtexte insert  "1.0 +  [lindex  $indicesRemplacement 0] chars"  $remplacement
			} ]  !=0
			}  { tk_messageBox -message "Pas d'autres occurences à remplacer par \"$remplacement\" " }
		
	  }
	  
proc Tikeditor::RemplacerTout { widtexte motif remplacement mM} {
		set i 0
		set tmM [ regexp  -indices -nocase -all -- $motif [$widtexte get 1.0 end ] ]
		set t [ regexp  -indices -all -- $motif [$widtexte get 1.0 end ] ]
		
		if {$mM == 0} {
		  while {$i <  $tmM } {
			regexp  -indices -nocase -- $motif [$widtexte get 1.0 end ]  indicesRemplacement
			$widtexte delete "1.0 + [expr [lindex  $indicesRemplacement 0] ] chars" \
				"1.0 + [expr [lindex $indicesRemplacement  1 ] +1] chars "
			$widtexte insert  "1.0 +  [lindex  $indicesRemplacement 0] chars"  $remplacement
			
			incr i
		  }
		} else {
		  while {$i < $t} {
			regexp  -indices  -- $motif [$widtexte get 1.0 end ]  indicesRemplacement
			$widtexte delete "1.0 + [expr [lindex  $indicesRemplacement 0] ] chars" "1.0 + [expr [lindex $indicesRemplacement  1 ] +1] chars "
			$widtexte insert  "1.0 +  [lindex  $indicesRemplacement 0] chars"  $remplacement
			
			incr i
		  }
		}
	  }
	  
proc Tikeditor::ChoixMarque {widtexte} { 
		global numeroMarque
		incr numeroMarque
		
		global marquesActuelles
		set  marquesActuelles {"" maMarqueTest}
		

		foreach i  [$widtexte dump -mark 1.0 end] {
		switch -glob --  $i anchor {set nomMarque "" ;lappend  marquesActuelles $nomMarque}
		switch -glob --  $i insert {set nomMarque "" ;lappend  marquesActuelles $nomMarque}
		switch -glob --  $i MK_* {set nomMarque [string trim $i  "MK_" ] ; lappend  marquesActuelles $nomMarque;}
		switch  -glob -- $i  *.* {	set nomMarque ""  ; lappend  marquesActuelles $nomMarque} 
		
		}
		
		set marquesActuelles [lsort -unique $marquesActuelles ] 
	

		# ouverture d'une boite d'entrée
		destroy .entreeMarque 
		toplevel .entreeMarque 
		frame .entreeMarque.f
		pack .entreeMarque.f
		label .entreeMarque.f.etiquette -text "Entrez un nom pour la nouvelle marque ($numeroMarque ème) : "
		spinbox .entreeMarque.f.nomMarque -textvariable nouvelleMarque -values $marquesActuelles
		label .entreeMarque.f.etiquetteGravitation -text gravity
		radiobutton 	.entreeMarque.f.gravitationG -text gauche -variable gravitation -value left
		radiobutton 	.entreeMarque.f.gravitationD -text droite -variable gravitation -value right
		button .entreeMarque.f.ok -text "Valider" -command {	if { $nouvelleMarque == ""} { set nouvelleMarque "marque$numeroMarque" }
												set nomMarque MK_$nouvelleMarque ; 
												Tikeditor::Marquer $widtexte $nomMarque $gravitation;
												set nouvelleMarque "" }
		pack .entreeMarque.f.etiquette .entreeMarque.f.nomMarque  -side top
		pack .entreeMarque.f.etiquetteGravitation  .entreeMarque.f.gravitationG \
			 .entreeMarque.f.gravitationD  .entreeMarque.f.ok -side top -expand  true -fill x

		bind .entreeMarque.f <3> { destroy .entreeMarque }
		bind .entreeMarque.f.etiquette <3> { destroy .entreeMarque }
		bind .entreeMarque.f.nomMarque <3> { destroy .entreeMarque }
		bind .entreeMarque.f.ok <3> { destroy .entreeMarque }
		}
		
proc Tikeditor::Marquer {widtexte nouvelleMarque gravitation} {
	
		$widtexte mark set $nouvelleMarque insert 
		$widtexte mark gravity  $nouvelleMarque  $gravitation
		
		Tikeditor::MenuMarques $widtexte 
	}
		
proc Tikeditor::MenuMarques {widtexte } {		
	global marquesActuelles
	set marquesActuelles {"" maMarqueTest}

		set nomMarque ""
	# on met à jour le menu des marques
		.menubar.mMarques add radiobutton -label n2				
		.menubar.mMarques delete 4 end
							
		foreach i  [$widtexte dump -mark 1.0 end] {
		switch -glob --  $i anchor {set nomMarque "" }
		switch -glob --  $i insert {set nomMarque "" }
		switch -glob --  $i MK_* {set nomMarque $i  }
		switch  -glob -- $i  *.* {	 if { [lindex $nomMarque] >0 } {
						.menubar.mMarques add radiobutton -label "$nomMarque $i"\
						-command "Tikeditor::InfoMarques $widtexte $i"
						set nomMarque ""
						}

					}
		}
		destroy .entreeMarque 
	}
	
	
proc Tikeditor::SupprimerMarque {widtexte } {		
	
		global marquesActuelles
		set  marquesActuelles {"" maMarqueTest}
		

		foreach i  [$widtexte dump -mark 1.0 end] {
		switch -glob --  $i anchor {set nomMarque "" ;lappend  marquesActuelles $nomMarque}
		switch -glob --  $i insert {set nomMarque "" ;lappend  marquesActuelles $nomMarque}
		switch -glob --  $i MK_* {set nomMarque [string trim $i  "MK_" ] ; lappend  marquesActuelles $nomMarque;}
		switch  -glob -- $i  *.* {	set nomMarque ""  ; lappend  marquesActuelles $nomMarque} 
		
		}
		
		set marquesActuelles [lsort -unique $marquesActuelles ] 
	

		# ouverture d'une boite d'entrée
		destroy .supprimeMarque 
		toplevel .supprimeMarque
		frame .supprimeMarque.f
		pack .supprimeMarque.f
		label .supprimeMarque.f.etiquette -text "Supprimer la marque : "
		spinbox .supprimeMarque.f.nomMarque -textvariable texteMarque -values $marquesActuelles
			
		button .supprimeMarque.f.ok -text "Valider" -command {		set nomMarque MK_$texteMarque ; 
												$widtexte mark unset  $nomMarque
												Tikeditor::MenuMarques $widtexte 
												destroy .supprimeMarque 
												}
		pack .supprimeMarque.f.etiquette .supprimeMarque.f.nomMarque .supprimeMarque.f.ok -side left
		
		bind .supprimeMarque.f <3> { destroy .supprimeMarque  }
		bind .supprimeMarque.f.etiquette <3> { destroy .supprimeMarque }
		bind .supprimeMarque.f.nomMarque <3> { destroy .supprimeMarque }
		bind .supprimeMarque.f.ok <3> { destroy .supprimeMarque }
	

}
		  
		  
proc Tikeditor::InfoMarques {widtexte numMarque} {
		global choixMarque
		if { $choixMarque == ""} { 
			tk_messageBox -message "Vous allez avoir un message d'erreur\ncar il faut faire d'abord un choix dans les options de recherche de marques\n" 
			} 
		destroy .marques
		toplevel .marques
		text .marques.fenMarques -bg "sea green" -fg yellow
		pack .marques.fenMarques
		.marques.fenMarques insert end  [$widtexte dump $choixMarque $numMarque end] 
		bind .marques.fenMarques <3> {destroy .marques}
	  }
	  
	  ####################
	  #<commentarisation>
	  
proc Tikeditor::PermuteCommentaireSpecial {widtexte } {
		variable permute
		set indices [ $widtexte tag ranges sel ]
		if { [llength $indices] == 0 } {tk_messageBox -type ok -message "Il n'y a pas de bloc sélectionné" -title "Commentage ..." -icon error ; return }
		set bloc [$widtexte get [lindex $indices 0] [lindex $indices 1]]
		puts "indices  : $indices \n"
		# $indices est une liste d'indices de texte de la forme entier/point/entier;
		#donc [lindex $indices 0] est une chaine entier/point/entier que l'on peut disjoindre selon le "point"
		#en supprimant  elements sauf le premier, on obtient un entier
		set splitDebutBloc [split [lindex $indices 0] .]
		set ligneDebutBloc [lindex $splitDebutBloc 0]
		puts "ligne debut : $ligneDebutBloc \n"
		set splitFinBloc [split [lindex $indices 1] .]
		set ligneFinBloc [lindex $splitFinBloc 0]
		puts "ligne fin bloc : $ligneFinBloc \n"
		set rg [regexp {^#£} $bloc]
		if {$rg==0 } {
		  set permute 0
		} else {set permute 1
		}
		Tikeditor::CommenterSelectionSpeciale $widtexte $permute $ligneDebutBloc $ligneFinBloc
	  }
	  
proc Tikeditor::CommenterSelection {widtexte bit } {
		
		set indices [ $widtexte tag ranges sel ]
		if { [llength $indices] == 0 } {tk_messageBox -type ok -message "Il n'y a pas de bloc sélectionné" -title "Commentage ..." -icon error ; return }
		set bloc [$widtexte get [lindex $indices 0] [lindex $indices 1]]
		puts "indices  : $indices \n"
		# $indices est une liste d'indices de texte de la forme entier/point/entier;
		#donc [lindex $indices 0] est une chaine entier/point/entier que l'on peut disjoindre selon le "point"
		#en supprimant  elements sauf le premier, on obtient un entier
		set splitDebutBloc [split [lindex $indices 0] .]
		set ligneDebutBloc [lindex $splitDebutBloc 0]
		puts "ligne debut : $ligneDebutBloc \n"
		set splitFinBloc [split [lindex $indices 1] .]
		set ligneFinBloc [lindex $splitFinBloc 0]
		puts "ligne fin bloc : $ligneFinBloc \n"
		
		
		set i $ligneDebutBloc
		
		if {$bit != 0} {
		  while {$i <= $ligneFinBloc} {
			$widtexte insert $i.0 "#"
			incr i
		  }
		} else {
		  while {$i <= $ligneFinBloc} {
			set texteLigne [$widtexte get $i.0 "$i.0 lineend"]
			set trimTexteLigne [string trimleft $texteLigne ] ;		# on supprime les espaces superflus en début de ligne pour tester la présence du dièse
			set rg [regexp {^#} $trimTexteLigne ]
			if  {$rg != 0} {
			  $widtexte delete $i.0 "$i.0 lineend"
			  $widtexte insert $i.0 $trimTexteLigne
			  $widtexte delete $i.0
			}
			incr i
		  }
		}
		
	  }
	  
	  
proc Tikeditor::CommenterSelectionSpeciale {widtexte bit ligneDebut ligneFin} {
		set i $ligneDebut
		
		# si le bloc n'est pas dièsé on insère un commentaire spécial "#£" en début de chaque ligne
		if {$bit == 0} {
		  while {$i <= $ligneFin} {
			$widtexte insert $i.0 "#£ " ;# une espace est insérée après le dièse et le sterling
			incr i
		  }
		} else {
		  set texteLigne [$widtexte get $ligneDebut.0 "$ligneDebut.0 lineend"]
		  set rg [regexp {^\#£} $texteLigne ]
		  if  {$rg != 0} {
			while {$i <= $ligneFin} {
			  # set ligneSpeciale [string trimright [$widtexte get $i.0 "$i.0 lineend" ] "\{"]
			  set ligneSpeciale [$widtexte get $i.0 $i.2 ]
			  if {[string compare $ligneSpeciale  \#£ ] != 0} {
				tk_messageBox -message "Une ligne ne fait pas partie du bloc spécial" -icon warning \
					-type ok -title "BLOC SPECIAL"
				return
			  } else {
				$widtexte delete $i.0 $i.3 ;# supprime #£ plus l'espace insérée après
				incr i
			  }
			}
		  }
		}
		
	  }
	  
	  ####################################################
	  
proc Tikeditor::NbLignes { widtexte widetiquette } {
		set nb [expr int([$widtexte index end])-1]
		set mot lignes
		if {$nb==1} {set mot seule\ ligne}
		set cc "curseur : "
		set coords $cc[$widtexte index insert]
		
		$widetiquette configure -text "$coords\t$nb $mot" -fg blue
	  }
	  
proc Tikeditor::ChoisirLigne {widtexte} {
	global widpage	
	set widpage [ lindex [ split $widtexte .] 2]

	
	set nomGlob "lignesChoisies$widpage"
	global $nomGlob

	
		destroy .topLigne$widpage
		toplevel .topLigne$widpage
		bind .topLigne$widpage <3> {destroy .topLigne$widpage}
		label .topLigne$widpage.etiquetteNumeroLigne -text "entrez un numerode ligne et valider" -font {size 12}
		pack .topLigne$widpage.etiquetteNumeroLigne
		spinbox .topLigne$widpage.memoireNumeroLigne -textvariable numeroLigne -values [set lignesChoisies$widpage] -font {size 12}
		pack .topLigne$widpage.memoireNumeroLigne -side left
		focus .topLigne$widpage.memoireNumeroLigne
		button .topLigne$widpage.valider -text "Envoi" -command  {;lappend  lignesChoisies$widpage  $numeroLigne ;  lsort -unique  lignesChoisies$widpage ; destroy  .topLigne$widpage ;Tikeditor::AllerLigne $widtexte  $numeroLigne ;} -font  {size 12}
		pack .topLigne$widpage.valider
		
		
	  }
	  
		  
proc  Tikeditor::AllerLigne {widtexte ligne} {
variable lignesChoisies


		set nb [expr int([$widtexte index end])-1]
		if {$ligne > $nb} {
		  tk_messageBox -message "NOMBRE TROP ELEVE : \n vérifiez le nombre de ligne de votre texte \n dans la barre d'état à droite" \
			  -icon warning -type ok
		} else {
		  $widtexte see $ligne.0
		  $widtexte tag remove "tagLigne" 1.0 end
		  $widtexte tag configure "tagLigne" -background GreenYellow
		  $widtexte tag add "tagLigne" $ligne.0  "$ligne.0 lineend"
		}
		$widtexte tag bind "tagLigne" <KeyPress> {$widtexte tag remove "tagLigne" 1.0 end}

	  }
	  
	
proc Tikeditor::Tampon {widtexte} {
		variable indexTampon
		set selection [$widtexte tag ranges sel]
		if {[llength $selection ]==0} {return}
		set index1 [lindex $selection 0]
		set index2 [lindex $selection 1]
		set mot [$widtexte get $index1 $index2]
		
		.menubar.mTampon add radio	-label $mot	 -variable motTampon -value $mot 	-activebackground yellow -activeforeground black\
			-command {$widtexte insert insert "$motTampon "}
		incr indexTampon
		
	  }
	
proc Tikeditor::ChoixSurlignage {widtexte}  {
		global mesMots
		global couleurMesMots 
		
		destroy .classCtext  
		toplevel .classCtext 
		wm title .classCtext  "Mes mots colorisés"
		frame .classCtext.f
		pack .classCtext.f
		

	# entrer des mots
		label .classCtext.f.labelMots -text "Entrer les mots à surcolorier"
		spinbox .classCtext.f.spinMots -textvariable mesMotsSurlignage -values $mesMots -background white 
		button .classCtext.f.boutonColor -text "Choix Couleur" -background $couleurMesMots -activebackground ivory\
						-command { $widtexte configure -cursor watch
								 set couleurMesMots [ tk_chooseColor ] ;
								 .classCtext.f.boutonColor configure  -background $couleurMesMots
								ctext::addHighlightClass $widtexte MaClasseMots $couleurMesMots   $mesMots ;
								$widtexte highlight 1.0 end 
								$widtexte configure -cursor arrow
								} 
		button .classCtext.f.boutonMots -text "Valider chaque mot nouveau" -activebackground ivory\
			-command {
					set mesMots [lsort -unique [ lappend mesMots $mesMotsSurlignage ] ]
					ctext::addHighlightClass $widtexte MaClasseMots $couleurMesMots   $mesMots ;
					.classCtext.f.spinMots configure -values $mesMots
					 }
					
		button .classCtext.f.boutonOK -text "Surcolorier le texte" -activebackground ivory\
		 -command {
				$widtexte configure -cursor watch
				ctext::addHighlightClass $widtexte MaClasseMots $couleurMesMots   $mesMots ;
				$widtexte highlight 1.0 end 
				$widtexte configure -cursor arrow
				destroy .classCtext
				}
				
	# supprimer des mots
		button .classCtext.f.boutonMotsSupprim -text "Valider pour supprimer le mot affiché" -activebackground ivory\
		 -command {	
				$widtexte tag delete MaClasseMots
				ctext::deleteHighlightClass $widtexte MaClasseMots 
			 	regsub $mesMotsSurlignage $mesMots "" mesMots; 
				set mesMots [lsort -unique $mesMots ] ;
				ctext::addHighlightClass $widtexte MaClasseMots $couleurMesMots   $mesMots ;
				.classCtext.f.spinMots configure -values $mesMots
				 }
				
		
		pack  .classCtext.f.boutonColor .classCtext.f.labelMots  .classCtext.f.spinMots .classCtext.f.boutonMots \
			  .classCtext.f.boutonMotsSupprim  .classCtext.f.boutonOK -side top -expand true -fill both
		
		bind .classCtext.f <3> {destroy .classCtext } 
		bind .classCtext.f.boutonColor <3> {destroy .classCtext } 
		bind  .classCtext.f.labelMots <3> {destroy .classCtext } 
		bind .classCtext.f.spinMots <3> {destroy .classCtext } 
		bind .classCtext.f.boutonMots <3> {destroy .classCtext } 
		bind  .classCtext.f.boutonMotsSupprim <3> {destroy .classCtext } 
		bind  .classCtext.f.boutonOK <3> {destroy .classCtext } 
			

}
	
	
	
proc Tikeditor::EscapePermute {widtexte} {

	set dernier [$widtexte get "insert -1 char"]
	$widtexte delete [$widtexte index "insert -1 char"]
	$widtexte insert [$widtexte index "insert -1 char"] $dernier

}

proc Tikeditor::CompteAccollades {widtexte} {

$widtexte tag remove accolladeDepart 0.1 end
$widtexte tag remove accolladeArrivee 0.1 end
	$widtexte tag configure accolladeDepart -background green
	$widtexte tag configure accolladeArrivee -background orange
	
	$widtexte tag add accolladeDepart "insert -1 char"
	set indiceDepart [$widtexte index "insert -1 char"]
	set signeDepart [$widtexte get "insert -1 char"]
	
	switch $signeDepart {
		
		\{ { 
			# accollade ouvrante 
			set signeIntermediaire  a
			set indiceArrivee [$widtexte search -forward \}  insert]
			set i insert
			
			while { $signeIntermediaire != ""  }  { 
				# recherche d'une autre accolade ouvrante entre 
				if  { $indiceArrivee == "" } { break }
				 set signeIntermediaire  [$widtexte search \{ $i "$indiceArrivee "] 
				if { $signeIntermediaire  != "" } {
					# on recherche une autre accolade fermante plus loin
					set i "$signeIntermediaire  +1 char"
					set j "$indiceArrivee +1 char "
					 set indiceArrivee [$widtexte search -forward \}  $j end] 
					}
			} 
				
			if  { $indiceArrivee == "" } {
			tk_messageBox -message "Il manque une accollade fermante à votre script" 
			} else {		
			 $widtexte tag add accolladeArrivee $indiceArrivee 
			$widtexte see $indiceArrivee
				}
		  }
		
		
		\[ { # crochet ouvrant 
			set signeIntermediaire  a
			set indiceArrivee [$widtexte search -forward \]  insert]
			set i insert
			
			while { $signeIntermediaire != ""  }  { 
				# recherche d'une autre accolade ouvrante entre 
				if  { $indiceArrivee == "" } { break }
				 set signeIntermediaire  [$widtexte search \[ $i "$indiceArrivee "] 
				if { $signeIntermediaire  != "" } {
					# on recherche une autre accolade fermante plus loin
					set i "$signeIntermediaire  +1 char"
					set j "$indiceArrivee +1 char "
					 set indiceArrivee [$widtexte search -forward \]  $j end] 
					}
			} 
				
			if  { $indiceArrivee == "" } {
			tk_messageBox -message "Il manque un crochet  fermant à votre script" 
			} else {		
			 $widtexte tag add accolladeArrivee $indiceArrivee 
			$widtexte see $indiceArrivee
				}
			}
			
		\( { # parenthèse ouvrante 
			set signeIntermediaire  a
			set indiceArrivee [$widtexte search -forward \)  insert]
			set i insert
			
			while { $signeIntermediaire != ""  }  { 
				# recherche d'une autre parenthèse ouvrante entre 
				if  { $indiceArrivee == "" } { break }
				 set signeIntermediaire  [$widtexte search \( $i "$indiceArrivee "] 
				if { $signeIntermediaire  != "" } {
					# on recherche une autre parenthèse fermante plus loin
					set i "$signeIntermediaire  +1 char"
					set j "$indiceArrivee +1 char "
					 set indiceArrivee [$widtexte search -forward \)  $j end] 
					}
			} 
				
			if  { $indiceArrivee == "" } {
			tk_messageBox -message "Il manque une parenthèse fermante à votre script" 
			} else {		
			 $widtexte tag add accolladeArrivee $indiceArrivee 
			$widtexte see $indiceArrivee
				}
			}
		
		
		\} { # accollade fermante 
			 set signeIntermediaire  a
			set indiceArrivee [$widtexte search -backward \{   "insert " ]
			set i "insert -1 char" 
			
			while { $signeIntermediaire != ""  }  { 
				# recherche d'une autre accolade fermante entre 
				if  { $indiceArrivee == "" } { break }
				 set signeIntermediaire  [$widtexte search -backward \} $i  "$indiceArrivee "  ] 
				if { $signeIntermediaire  != "" } {
					# on recherche une autre accolade fermante plus haut 
					set i "$signeIntermediaire "
					set j "$indiceArrivee "
					set indiceArrivee [$widtexte search -backward  \{  $j  1.0] 
				}
			} 
			
			if  { $indiceArrivee == "" } {
			tk_messageBox -message "Il manque une accollade ouvrante à votre script" 
			} else {		
			 $widtexte tag add accolladeArrivee $indiceArrivee 
			$widtexte see $indiceArrivee
				}
			}
			
		
		
		\] { #crochet fermant
			 set signeIntermediaire  a
			set indiceArrivee [$widtexte search -backward \[   "insert " ]
			set i "insert -1 char" 
			
			while { $signeIntermediaire != ""  }  { 
				# recherche d'une autre accolade fermante entre 
				if  { $indiceArrivee == "" } { break }
				 set signeIntermediaire  [$widtexte search -backward \] $i  "$indiceArrivee "  ] 
				if { $signeIntermediaire  != "" } {
					# on recherche une autre accolade fermante plus haut 
					set i "$signeIntermediaire "
					set j "$indiceArrivee  "
					set indiceArrivee [$widtexte search -backward  \[  $j  1.0] 
						
					}
			} 
				
			if  { $indiceArrivee == "" } {
			tk_messageBox -message "Il manque un crochet fermant à votre script" 
			} else {		
			 $widtexte tag add accolladeArrivee $indiceArrivee 
			$widtexte see $indiceArrivee
				}
			}
			
		\) { #parenthèse fermante
			 set signeIntermediaire  a
			set indiceArrivee [$widtexte search -backward \(  "insert " ]
			set i "insert -1 char" 
			
			while { $signeIntermediaire != ""  }  { 
				# recherche d'une autre accolade fermante entre 
				if  { $indiceArrivee == "" } { break }
				 set signeIntermediaire  [$widtexte search -backward \) $i  "$indiceArrivee "  ] 
				if { $signeIntermediaire  != "" } {
					# on recherche une autre accolade fermante plus haut 
					set i "$signeIntermediaire "
					set j "$indiceArrivee  "
					set indiceArrivee [$widtexte search -backward  \(  $j  1.0] 
						
					}
			} 
				
			if  { $indiceArrivee == "" } {
			tk_messageBox -message "Il manque une parenthèse fermante à votre script" 
			} else {		
			 $widtexte tag add accolladeArrivee $indiceArrivee 
			$widtexte see $indiceArrivee
				}
			}
	}

}
  
  

proc Tikeditor::EnregConfig { } {
		global Chemin
		variable couleur
		global police 
		global taillePolice
		
				
		set fichier [open [file join $Chemin(rel) Tikeditor.rc] w]
		puts $fichier "# fichier de configuration de Tikeditor"
		puts $fichier "#################################################"
		foreach cle [array names couleur] {
		  puts $fichier "# Couleur $cle\nset couleur($cle) $couleur($cle)"
		}
		puts $fichier "# Taille police \nset taillePolice $taillePolice"
		puts $fichier "#  police \nset police [list $police]"
		close $fichier
	  }
	  
	  
proc Tikeditor::LectureConfig { } {
		global Chemin
		variable couleur
 		global police
 		global taillePolice
		
		set fichier [open [file join $Chemin(rel) Tikeditor.rc] r]
		while {![eof $fichier]} {
		  eval [gets $fichier]
		}
		close $fichier
	  }
	  
	  
	  #<INTERFACE>
	  
proc Tikeditor::Gui {} {
		global tcl_version tcl_platform
		global Chemin
		variable ausujetdeDC
		variable ausujetdeJLD
		variable ausujetdeDM
		variable ausujetdeMSDZ 
		variable ausujetdeJN  
		variable ausujetdeSUCF
		variable application
		variable version
		variable fichier
		variable couleur
		variable ListeRecents
		variable MotRecherche
		global choixMarque
		global numeroPage
		global widtexte
		global police
		global taillePolice
		
		wm title . "$application version : $version"
		
		
		# zone texte
		
		frame .ftext
		pack   .ftext -padx 2 -pady 2   -expand true -fill both
		
		#création d'une page neutre
		text  .ftext.0   -background gray   -foreground LightBlue   
		
		# incrementation de la variable globale "numeroPage" pour fixer sa valeur à 1
		incr numeroPage
		
		if {$tcl_version>=8.4} {
		  .ftext.0 configure -undo 1 -autoseparators 1
		}
		scrollbar .ftext.sx0 -orient horizontal -command {.ftext.0 xview}
		scrollbar .ftext.sy0 -orient vertical -command {.ftext.0 yview }
		
		pack .ftext.sy0 -fill y -side right
		pack  .ftext.0 	-fill both	-expand true
		pack .ftext.sx0 -fill x -side top
		
	#<page_defaut>	
		.ftext.0 configure -state disable 
		set widtexte .ftext.0
		
	
		#<BARRE_MENUS_gavarnie>
		menu .menubar -activebackground LemonChiffon 
		. config -menu .menubar 
		
		option add *Menu.activeBackground LemonChiffon 
		
		
  		foreach m { Fichier Editer Outils Prefs Aide *** TCL TK  Color Tampon  Marques Pages } {
			set $m [ menu .menubar.m$m -tearoff 1]
			  .menubar add cascade -label $m -menu .menubar.m$m
		}
		
		################################################################################
		# # barre des icones
		################################################################################
		
		
		
		frame .ficones -relief groove -bd 3 
		option add *Button.activeBackground LemonChiffon ; # couleur par défaut des boutons survolés : LemonChiffon 
		pack .ficones -fill both  -before .ftext 
		
	#<iconesStandards>
	
		#icone nouveau
		set imgNouveau [image create photo -file [file join $Chemin(rel) images nouveau.gif]]
		button .ficones.nouveau -image $imgNouveau -relief flat -command {Tikeditor::Nouveau} 
		pack .ficones.nouveau -side left
		bind .ficones.nouveau <Enter> {after 50  ; .fetat.message configure -text ">> Ouvrir un nouveau fichier ..."}
		bind .ficones.nouveau <Leave> {  .fetat.message configure -text ""}
		
		#icone ouvrir
		set imgOuvrir [image create photo -file [file join $Chemin(rel) images open.gif]]
		button .ficones.ouvrir -image $imgOuvrir -relief flat -command {Tikeditor::Ouvrir }
		pack .ficones.ouvrir -side left
		bind .ficones.ouvrir <Enter> {after 50 ; ; .fetat.message configure -text ">> Ouvrir un fichier ..."}
		bind .ficones.ouvrir <Leave> {  .fetat.message configure -text ""}
		
		#icone sauver
		set imgSauver [image create photo -file [file join $Chemin(rel) images save.gif]]
		button .ficones.sauver -image $imgSauver -relief flat -command {Tikeditor::Sauvegarder $widtexte 0}
		pack .ficones.sauver -side left
		bind .ficones.sauver <Enter> {after 50  ; .fetat.message configure -text ">> Sauvegarder le fichier en cours ..."}
		bind .ficones.sauver <Leave> { .fetat.message configure -text ""}
		
		#icone sauverSous
		set imgSauverSous [image create photo -file [file join $Chemin(rel) images toSave.gif]]
		button .ficones.sauverSous -image $imgSauverSous -relief flat -command {Tikeditor::Sauvegarder $widtexte 1}
		pack .ficones.sauverSous -side left
		bind .ficones.sauverSous <Enter> {after 50 ; .fetat.message configure -text ">> Sauvegarder le fichier sous un nouveau nom ..."}
		bind .ficones.sauverSous <Leave> {  .fetat.message configure -text ""}
		
		#icone Fermer
		set imgFermer [image create photo -file [file join $Chemin(rel) images remove.gif]]
		button .ficones.fermer -image $imgFermer -relief flat -command {Tikeditor::Fermer $widtexte}
		pack .ficones.fermer -side left
		bind .ficones.fermer <Enter> {after 50 ; .fetat.message configure -text ">> Ferme le fichier en cours..."}
		bind .ficones.fermer <Leave> { .fetat.message configure -text ""}
		
		#icone Imprimer
		set imgImprimer [image create photo -file [file join $Chemin(rel) images print.gif]]
		button .ficones.imprimer -image $imgImprimer -relief flat -command {Tikeditor::Imprimer $widtexte}
		pack .ficones.imprimer -side left
		bind .ficones.imprimer <Enter> {after 50; .fetat.message configure -text ">> Imprime le texte en cours..."}
		bind .ficones.imprimer <Leave> { .fetat.message configure -text ""}
		
		#icone Separateur
		label .ficones.separateur1 -relief groove -bd 2
		pack .ficones.separateur1 -side left
		
		#icone defaire
		set imgDefaire [image create photo -file [file join $Chemin(rel) images undo.gif]]
		button .ficones.defaire -image $imgDefaire -relief flat -command {Tikeditor::Defaire $widtexte}
		pack .ficones.defaire -side left
		bind .ficones.defaire <Enter> {after 50  ; .fetat.message configure -text ">> Annule la dernière action (undo)"}
		bind .ficones.defaire <Leave> { .fetat.message configure -text ""}
		
		#icone refaire
		set imgRefaire [image create photo -file [file join $Chemin(rel) images redo.gif]]
		button .ficones.refaire -image $imgRefaire -relief flat -command {Tikeditor::Refaire $widtexte}
		pack .ficones.refaire -side left
		bind .ficones.refaire <Enter> {after 50  ; .fetat.message configure -text ">> Refait la dernière action annulée(redo)"}
		bind .ficones.refaire <Leave> { .fetat.message configure -text ""}
		
		#icone Separateur
		label .ficones.separateur2 -relief groove -bd 2
		pack .ficones.separateur2 -side left
		
		#icone commenter
		set imgCommenter [image create photo -file [file join $Chemin(rel) images commenter.gif]]
		button .ficones.commenter -image $imgCommenter -relief flat -command {Tikeditor::CommenterSelection $widtexte 1}
		pack .ficones.commenter -side left
		bind .ficones.commenter <Enter> {after 50 ; .fetat.message configure -text ">> \"Commenter\" la sélection" }
		bind .ficones.commenter <Leave> { .fetat.message configure -text "" }
		
		#icone décommenter
		set imgDecommenter [image create photo -file [file join $Chemin(rel) images decommenter.gif]]
		button .ficones.decommenter -image $imgDecommenter -relief flat -command {Tikeditor::CommenterSelection $widtexte 0}
		pack .ficones.decommenter -side left
		bind .ficones.decommenter <Enter> {after 50  ; .fetat.message configure -text ">> \"Décommenter\" la sélection" }
		bind .ficones.decommenter <Leave> {  .fetat.message configure -text "" }
		
		#icone Separateur
		label .ficones.separateur2b -relief groove -bd 2
		pack .ficones.separateur2b -side left
		
		#icone rechercher
		set imgRechercher [image create photo -file [file join $Chemin(rel) images find.gif]]
		button .ficones.rechercher -image $imgRechercher -relief flat -command {Tikeditor::ChoisirMot}
		pack .ficones.rechercher -side left
		bind .ficones.rechercher <Enter> {after 50; .fetat.message configure -text ">> Cherche une chaine verbale choisie ..."}
		bind .ficones.rechercher <Leave> { .fetat.message configure -text ""}
		
		#icone remplacer
		set imgRemplacer [image create photo -file [file join $Chemin(rel) images replace.gif]]
		button .ficones.remplacer -image $imgRemplacer -relief flat -command {Tikeditor::Remplacer $widtexte}
		pack .ficones.remplacer -side left
		bind .ficones.remplacer <Enter> {after 50  ; .fetat.message configure -text ">> Remplace une chaine verbale par une autre ..."}
		bind .ficones.remplacer <Leave> { .fetat.message configure -text ""}
		
		#icone allerLigne
		set imgNumeroterSelection [image create photo -file [file join $Chemin(rel) images icon_label.gif]]
		button .ficones.numeroterSelection  -image $imgNumeroterSelection	 -relief flat -command {Tikeditor::ChoisirLigne $widtexte} 		-bd 1
		pack .ficones.numeroterSelection -side left
		bind .ficones.numeroterSelection <Enter> {after 50 ; .fetat.message configure -text ">>Curseur positionné à la  ligne sélectionnée "}
		bind .ficones.numeroterSelection <Leave> { .fetat.message configure -text ""}
		
		#icone Separateur
		label .ficones.separateur3 -relief groove -bd 2
		pack .ficones.separateur3 -side left
		
		#icone tout selectionner
		set imgToutSelectionner [image create photo -file [file join $Chemin(rel) images anchor.gif]]
		button .ficones.toutSelectionner  -image $imgToutSelectionner  -relief flat -command {Tikeditor::ToutSelectionner $widtexte}
		pack .ficones.toutSelectionner -side left
		bind .ficones.toutSelectionner <Enter> {after 50  ; .fetat.message configure -text ">> Selectionne tout le texte <Ctrl+a>"}
		bind .ficones.toutSelectionner <Leave> { .fetat.message configure -text ""}
		
		#icone couper
		set imgCouper [image create photo -file [file join $Chemin(rel) images cut.gif]]
		button .ficones.couper  -image $imgCouper  -relief flat -command {Tikeditor::Couper $widtexte}
		pack .ficones.couper -side left
		bind .ficones.couper <Enter> {after 50 ; .fetat.message configure -text ">> Supprime le texte sélectionné et le mémorise dans le presse papier <Ctrl+x>"}
		bind .ficones.couper <Leave> {  .fetat.message configure -text ""}
		
		#icone copier
		set imgCopier [image create photo -file [file join $Chemin(rel) images copy.gif]]
		button .ficones.copier  -image $imgCopier  -relief flat -command {Tikeditor::Copier $widtexte}
		pack .ficones.copier -side left
		bind .ficones.copier <Enter> {after 50  ; .fetat.message configure -text ">> Copie le texte sélectionné dans le presse papier <Ctrl+c>"}
		bind .ficones.copier <Leave> { .fetat.message configure -text ""}
		
		#icone coller
		set imgColler [image create photo -file [file join $Chemin(rel) images paste.gif]]
		button .ficones.coller  -image $imgColler -relief flat -command {Tikeditor::Coller $widtexte}
		pack .ficones.coller -side left
		bind .ficones.coller <Enter> {after 50  ; .fetat.message configure -text ">> Insère le contenu du presse papier à la position du curseur <Ctrl+v>"}
		bind .ficones.coller <Leave> { .fetat.message configure -text ""}
		
		#<icone_cacher>
		set imgCacher [image create photo -file [file join $Chemin(rel) images masque.gif]]
		button .ficones.cacher  -image $imgCacher -relief flat -command {Tikeditor::MasquerSelection $widtexte}
		pack .ficones.cacher -side left
		bind .ficones.cacher <Enter> {after 50  ; .fetat.message configure -text ">> Masque le texte sélectionné"}
		bind .ficones.cacher <Leave> { .fetat.message configure -text ""}
		
		#icone Separateur
		label .ficones.separateur4 -relief groove -bd 2
		pack .ficones.separateur4 -side left
		
		#icone PolicePlus
		set imgPolicePlus [image create photo -file [file join $Chemin(rel) images incfont.gif]]
		button .ficones.policePlus  -image $imgPolicePlus -relief flat -command {Tikeditor::PolicePlus $widtexte}
		pack .ficones.policePlus  -side left
		bind .ficones.policePlus  <Enter> {after 50  ; .fetat.message configure -text ">> Augmente la taille des lettres"}
		bind .ficones.policePlus  <Leave> {  .fetat.message configure -text ""}
		
		#icone PoliceMoins
		set imgPoliceMoins  [image create photo -file [file join $Chemin(rel) images decrfont.gif]]
		button .ficones.policeMoins  -image $imgPoliceMoins  -relief flat -command {Tikeditor::PoliceMoins $widtexte}
		pack .ficones.policeMoins   -side left
		bind .ficones.policeMoins   <Enter> {after 50  ; .fetat.message configure -text ">> Diminue la taille des lettres"}
		bind .ficones.policeMoins   <Leave> {  .fetat.message configure -text ""}
		
		
		# icone Separateur
		label .ficones.separateur5 -relief groove -bd 2
		pack .ficones.separateur5 -side left
		
		
		#<iconesTikeditor>  icones particulières à Tikeditor
		
		#icone tester
		set imgTester [image create photo -file [file join $Chemin(rel) images tclplume.gif]]
		button .ficones.tester  -image $imgTester -relief flat -command {Tikeditor::EvaluationTcl $widtexte } -background red
		pack .ficones.tester -side right
		bind .ficones.tester <Enter> {after 50  ; .fetat.message configure -text ">>Lance le script avec l'interpréteur choisi <Ctrl+t>"}
		bind .ficones.tester <Leave> { .fetat.message configure -text ""}
		
		#icone procs
		set imgProcs [image create photo -file [file join $Chemin(rel) images procs.gif]]
		button .ficones.procs  -image $imgProcs -relief flat -command {Tikeditor::AfficheListeProcs $widtexte} 
		pack .ficones.procs -side right
		bind .ficones.procs <Enter> {after 50  ; .fetat.message configure -text ">>Affiche les procédures du script (ordre chrono) "}
		bind .ficones.procs <Leave> { .fetat.message configure -text ""}
		
		#icone procsAlpha
		set imgProcAlpha [image create photo -file [file join $Chemin(rel) images alpha.gif]]
		button .ficones.procsAlpha  -image $imgProcAlpha  -relief flat -command {Tikeditor::AfficheListeProcsAlpha $widtexte} 
		pack .ficones.procsAlpha  -side right
		bind .ficones.procsAlpha  <Enter> {after 50; .fetat.message configure -text ">>Affiche les procédures du script (ordre alpha) "}
		bind .ficones.procsAlpha  <Leave> { .fetat.message configure -text ""}
		
		#icone Balises
		set imgBalises [image create photo -file [file join $Chemin(rel) images balises.gif]]
		button .ficones.balises  -image $imgBalises -relief flat -command {Tikeditor::AfficheListeBalises $widtexte}  
		pack .ficones.balises  -side right
		bind .ficones.balises  <Enter> {after 50  ; .fetat.message configure -text ">>Affiche les balises du script (ordre chrono) "}
		bind .ficones.balises  <Leave> {  .fetat.message configure -text ""}
		
		#icone commentaires
		set imgCommentaire [image create photo -file [file join $Chemin(rel) images toglcom.gif]]
		button .ficones.commentaire  -image $imgCommentaire -relief flat -command {Tikeditor::PermuteCommentaireSpecial $widtexte} 
		pack .ficones.commentaire -side right
		bind .ficones.commentaire <Enter> {after 50  ; .fetat.message configure -text ">>(dé)Commente les lignes sélectionnées <Ctrl+k>"}
		bind .ficones.commentaire <Leave> {   .fetat.message configure -text ""}
		
		#icone marquer
		set imgMarquer [image create photo -file [file join $Chemin(rel) images srchbak.gif]]
		button .ficones.marquer -image $imgMarquer -relief flat -command {Tikeditor::ChoixMarque $widtexte} 
		pack .ficones.marquer -side right
		bind .ficones.marquer <Enter> {after 50 ; .fetat.message configure -text ">> Insérer une marque..."}
		bind .ficones.marquer <Leave> { .fetat.message configure -text ""}
		
		#icone coloration
		set imgColoration [image create photo -file [file join $Chemin(rel) images greenball.gif]]
		set imgColoration2 [image create photo -file [file join $Chemin(rel) images redball.gif]]
		button .ficones.coloration  -image $imgColoration	 -relief flat -command {
			# coloration des accolades et crochets 
			ctext::addHighlightClassForSpecialChars $widtexte signesRegexp DeepPink  { [ ] { }}
			$widtexte highlight 1.0 end;
			#coloration des mots clefs;
			Tikeditor::Coloration $widtexte 1} 	-bd 4
		pack .ficones.coloration -side right
		bind .ficones.coloration <Enter> {after 50 ; .fetat.message configure -text ">>Lance la coloration de la syntaxe "}
		bind .ficones.coloration <Leave> { ; .fetat.message configure -text ""}
		
		#icone surcoloration
		set imgSurColoration [image create photo -file [file join $Chemin(rel) images surcolorier.gif]]
		
		button .ficones.surcoloration  -image $imgSurColoration	 -relief flat -command {Tikeditor::ChoixSurlignage $widtexte } 	-bd 4
		pack .ficones.surcoloration -side right
		bind .ficones.surcoloration <Enter> {after 50 ; .fetat.message configure -text ">>Permet de surcolorier des mots choisis"}
		bind .ficones.surcoloration <Leave> { ; .fetat.message configure -text ""}
		
		
		#icone visionneuse
		set imgVisionneuse [image create photo -file [file join $Chemin(rel) images visionneuse.gif]]
		button .ficones.visionneuse  -image $imgVisionneuse  -relief flat -command {Tikeditor::Visionneuse  } 		-bd 2
		pack .ficones.visionneuse -side right
		bind .ficones.visionneuse <Enter> {after 50  ; .fetat.message configure -text ">>Voir des images... "}
		bind .ficones.visionneuse <Leave> { .fetat.message configure -text ""}
		
		#icone tampon
		set imgTampon [image create photo -file [file join $Chemin(rel) images tampon.gif]]
		button .ficones.tampon  -image $imgTampon  -relief flat -command {Tikeditor::Tampon $widtexte} 		-bd 2
		pack .ficones.tampon -side right
		bind .ficones.tampon <Enter> {after 50  ; .fetat.message configure -text ">>Inserer la sélection dans le menu tampon"}
		bind .ficones.tampon <Leave> { .fetat.message configure -text ""}
		
		#<icone_accollades>
		set imgAccollades [image create photo -file [file join $Chemin(rel) images accollades.gif]]
		button .ficones.accolade -image $imgAccollades  -relief flat -command {Tikeditor::CompteAccollades $widtexte} 		-bd 2
		pack .ficones.accolade  -side right
		bind .ficones.accolade  <Enter> {after 50 ; .fetat.message configure -text ">>Affiche l'accollade ou le crochet correspondant"}
		bind .ficones.accolade  <Leave> { .fetat.message configure -text ""}
		
		#icone Separateur
		label .ficones.separateur6 -relief groove -bd 2
		pack .ficones.separateur6 -side right
		
		#<icone_console>
		set imgConsole [image create photo -file [file join $Chemin(rel) images tconsole.gif]]
		button .ficones.console -image $imgConsole  -relief flat -command {Tikeditor::LanceConsole $widtexte} 		-bd 2
		pack .ficones.console  -side right
		bind .ficones.console  <Enter> {after 50; .fetat.message configure -text ">>Inserer une console"}
		bind .ficones.console  <Leave> { .fetat.message configure -text ""}
		
		
				
		######################################################
		#<MENUS>
		######################################################
		
		#<MENUScLASSIQUE>  D'EDITION
		
		#MENU FICHIER
		$Fichier add command -label "Nouveau script" -accelerator Ctrl+n \
			-command 	 {Tikeditor::Nouveau }
		$Fichier add command -label "Ouvrir" -accelerator Ctrl+O \
			-command { Tikeditor::Ouvrir }
		
		$Fichier add cascade -label "Récents" -menu $Fichier.lRecents
		menu $Fichier.lRecents -tearoff 1
		Tikeditor::MaJMenuRecents
		
		$Fichier add command -label "Sauvegarder" -accelerator Ctrl+S \
			-command { Tikeditor::Sauvegarder $widtexte 0 }
		$Fichier add command -label "Sauvegarder sous..." -accelerator Ctrl+Shift+S \
			-command { Tikeditor::Sauvegarder $widtexte 1 }
		$Fichier add command -label "Fermer" -accelerator Ctrl+Shift+F \
			-command { Tikeditor::Fermer $widtexte }
		$Fichier add separator
		$Fichier add command -label "Quitter" -accelerator Ctrl+Q \
			-command Tikeditor::Quitter
		
		#MENU EDITER
		$Editer add command -label "Rechercher" \
			-command "Tikeditor::ChoisirMot "
		$Editer add command -label "Remplacer"\
			-command {Tikeditor::Remplacer $widtexte}
		$Editer add separator
		
		if {$tcl_version>=8.4} {
		  $Editer add command -label "Défaire" -accelerator Ctrl+Z\
			  -command { Tikeditor::Defaire $widtexte }
		  $Editer add command -label "Refaire" -accelerator Ctrl+E\
			  -command { Tikeditor::Refaire $widtexte }
		  $Editer add separator
		}
		
		$Editer  add command -label "Couper" -accelerator Ctrl+X\
			-command { Tikeditor::Couper $widtexte}
		$Editer  add command -label "Copier" -accelerator Ctrl+C\
			-command { Tikeditor::Copier $widtexte }
		$Editer  add command -label "Coller" -accelerator Ctrl+V\
			-command { Tikeditor::Coller $widtexte }
		$Editer add separator
		$Editer add command -label "Sélectionner tout" -accelerator Ctrl+A \
			-command { Tikeditor::ToutSelectionner $widtexte }
		
		#MENU OUTILS
		$Outils add command -label "Colorier la syntaxe" \
			-command { Tikeditor::Coloration $widtexte 1}
	#<MENU_cacher>
		$Outils add command -label "Masquer Sélection" -command {Tikeditor::MasquerSelection $widtexte} 	
		$Outils add command -label "Surcolorier" -command {Tikeditor::ChoixSurlignage $widtexte} 
		$Outils add command -label "Évaluation Tcl" -accelerator Ctrl+T\
			-command {Tikeditor::EvaluationTcl $widtexte }
		$Outils add command -label "Liste Procédures Chrono" \
			-command {  Tikeditor::AfficheListeProcs $widtexte }
		$Outils add command -label "Liste Procédures Alpha" \
			-command {  Tikeditor::AfficheListeProcsAlpha $widtexte }
		$Outils add command -label "Liste Balises" \
			-command {  Tikeditor::AfficheBalises $widtexte }
		$Outils add command -label "Visionneuse " \
			-command {Tikeditor::Visionneuse}
		$Outils add separator
		$Outils add command -label "Commenter sélection"\
			-command { Tikeditor::CommenterSelection $widtexte 1 }
		$Outils add command -label "Décommenter sélection"\
			-command { Tikeditor::CommenterSelection $widtexte 0 }
		$Outils add separator
		
		
		
		#MENU PAGES
		# on met à jour le menu Pages	 avec la page par défaut
		set choix  "défault"
		$Pages	add radio -label "page : 0" -command " Tikeditor::Affiche 0 $choix "
		
		
		#<MENU_PREFS>
		$Prefs add command -label "Purger \"menu récent\" " \
	  -command { Tikeditor::PurgerRecents  }
	  
	  $Prefs add separator
	  
		$Prefs add  cascade -label "Retour ligne" -menu $Prefs.menuRetourLigne
	 $Prefs add cascade -label "Barre d'état" -menu $Prefs.menuEtat
	$Prefs add cascade -label "Numéros lignes" -menu $Prefs.menuNumLignes
	  
	 $Prefs add separator
	
		$Prefs add command -label "Choix couleurs" \
	  -command {Tikeditor::Couleurs}
	  
		$Prefs add separator
		$Prefs add command -label "Choix Fonte" \
			-command {Tikeditor::ChoixFonte }		
		$Prefs add command -label "augmenter Fonte" \
			-command {Tikeditor::PolicePlus $widtexte}
		$Prefs add command -label "diminuer Fonte" \
			-command {Tikeditor::PoliceMoins $widtexte}
		
		
		menu $Prefs.menuRetourLigne
		$Prefs.menuRetourLigne  	add radio -label "aucun" -variable wrap -value "none" -command {Tikeditor::RetourLigne none}
		$Prefs.menuRetourLigne  	add radio -label "char" -variable wrap -value "word" -command {Tikeditor::RetourLigne  char}
		$Prefs.menuRetourLigne  	add radio -label "mot" -variable wrap -value "char" -command {Tikeditor::RetourLigne  word}
		
		menu $Prefs.menuEtat
		$Prefs.menuEtat 	add radio -label "haut" -variable position -value "haut" -command {Tikeditor::BarreEtat haut}
		$Prefs.menuEtat 	add radio -label "bas" -variable position -value "bas" -command {Tikeditor::BarreEtat bas}
		
		menu $Prefs.menuNumLignes
		$Prefs.menuNumLignes  	add radio -label "oui" -variable position -value "haut" -command {$widtexte configure -linemap 1}
		$Prefs.menuNumLignes  	add radio -label "non" -variable position -value "bas" -command {$widtexte configure -linemap 0}
		
		 $Prefs add separator
		
		$Prefs add command -label "Sauver Config" \
			-command {Tikeditor::EnregConfig }
		
		
		#<MENU_AIDE>
		$Aide	add command -label "Au sujet de..."\
			-command " Tikeditor::AuSujetDe \[list \"Tikeditor version\"  $version $ausujetdeDM \"d'après TkEdit 1.0-gamma \" $ausujetdeDC  $ausujetdeJLD  $ausujetdeMSDZ  $ausujetdeJN  $ausujetdeSUCF \] "
		$Aide	add command -label "AIDE Tikeditor"\
			-command  " Tikeditor::Aide \[list \"Tikeditor version $version\" \] "
		$Aide	add command -label "AIDE Tcl/Tk"\
			-command  " Tikeditor::AideTcl \[list \"Tikeditor version $version\" \] "
		$Aide add separator
		$Aide add command -label "expression régulière" -command {Tikeditor::ExpressionReguliere}
		
		
		# MENUS PARTICULIERS DE TIKEDITOR
		#oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
		# interface "gavarnie"
	# MENUS PARTICULIERS DE TIKEDITOR
		
	#<MENU_TCL>
	
	# les commandes sont classées par grandes fonctions selon un plan proche de celui de Paul RAINES 
	# dans TCL/TK précis et concis (o'reilly Paris 2000 -traduction James Guérin)
	# les menus sont créés par des boucles foreach selon une liste "commandesTcl" redéfinie à chaque fois.
	# La boucle crée des radiobuttons ayant tous la même variable comTcl 
	# dont la valeur est définie pour chaque mot clé lors de la création des menus par les boucles foreach.
	# les entrées de menus ont le fond jaune si le mot est insérable dans le texte, 
	# le fond est standard si l'entrée ouvre une cascade.
	# une condition "if" permet de gérer l'option columnBreak en fonction du nombre d'entrées d'un menu,
	# grace au compteur "i" qui n'est pas remis à zéro entre deux boucles "foreach" pour le même menu.
		
		
	#<TCL_variables_et_commandes>
		# list des commandes tcl de variables .
		# Un sous menu au menu TCL est créé, avec l'entrée : "Variables & Commandes" 
		
		set commandesTcl [ list  global incr set unset uplevel upvar variable vwait]
		
		 $TCL add cascade -label "Variables & commandes" -menu $TCL.variables
		menu $TCL.variables 
		
		set i 0
		$TCL.variables add command -label " variables >>" -background green  -activebackground green
		incr i
		
		foreach élément $commandesTcl {
		  if { ($i==15) || ($i==51)} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $i]
		  $TCL.variables add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "$comTcl "} -columnbreak $optionColumnBreak
		  incr i
		}
		
		$TCL.variables add command -label " évènements >>" -background green -activebackground green
		incr i
		
		set j 0
		set commandesTcl [ list update variable vdelete vinfo vwait ]
		foreach élément $commandesTcl {
		  if { ($i==15) || ($i==51)} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $j]
		  $TCL.variables add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "$comTcl "} -columnbreak $optionColumnBreak
		  incr i
		incr j
		}
		$TCL.variables add command -label "" -background yellow
		
		 if { ($i==15) || ($i==51)} {set optionColumnBreak 1 }
		$TCL.variables add command -label "commandes >>" -background green -activebackground green -columnbreak $optionColumnBreak
		incr i
		
		$TCL.variables add radiobutton 		-label after	 -background yellow -variable comTcl -value after \
			  -command {$widtexte insert insert "$comTcl "} 
		incr i
			
		set j 0
		set commandesTcl [ list cancel idle info ]
		foreach élément $commandesTcl {
		  if { ($i==15) || ($i==51)} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $j]
		  $TCL.variables add radiobutton 		-label "after $mot"	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "after $comTcl " } -columnbreak $optionColumnBreak
		  incr i
		incr j
		}
		
		set j 0
		set commandesTcl [ list eval error expr proc rename unknown]
		foreach élément $commandesTcl {
		  if { ($i==15) || ($i==51)} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $j]
		  $TCL.variables add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "$comTcl "} -columnbreak $optionColumnBreak
		  incr i
		incr j
		}
		
		
		$TCL.variables add command -label "scripts >>" -background green -activebackground green
		incr i
		
		set j 0
		set commandesTcl [ list bgerror catch load source time ]
		foreach élément $commandesTcl {
		  if { ($i==15) || ($i==51)} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $j]
		  $TCL.variables add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "$comTcl "} -columnbreak $optionColumnBreak
		  incr i
		incr j
		}
		
		
		
			
		
	#<TCL_controles>
		# list des commandes tcl de controle .
		# Un sous menu au menu TCL est créé, avec l'entrée : "controle" 
		
		set commandesTcl [ list  break case continue exit for foreach if then elseif switch while return]
		
		 $TCL add cascade -label Controle -menu $TCL.controle
		menu $TCL.controle 
		
		set i 0
		foreach élément $commandesTcl {
		  if { ($i==25) || ($i==51) || ($i==77) || ($i==103) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $i]
		  $TCL.controle add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "$comTcl "} -columnbreak $optionColumnBreak
		  incr i
		}
		
		# autre commande TCL de controle, mais avec options : "return" .
		 $TCL.controle add cascade 		-label "options return" -menu  $TCL.controle.return
		menu $TCL.controle.return
			#options pour "return"
			set commandesTcl [list -code -errorinfo -errorcode ]
			set i 0
			foreach élément $commandesTcl {
				 set mot [lindex $commandesTcl $i]
				$TCL.controle.return add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			 	 -command {$widtexte insert insert "$comTcl "} -columnbreak $optionColumnBreak
			incr i
			}
	
	#<TCL_fichiers>
		# list des commandes tcl de gestion de fichiers .
		# Un sous menu au menu TCL est créé, avec l'entrée : "fichier  (file)"  
		#
		set commandesTcl [list atime attributes copy delete dirname executable exists extension isdirectory \
					isfile join lstat mkdir mtime nativename owned pathtype readable readlink rename \
					rootname size split stat tail type volume writable ]	
		
		 $TCL add cascade -label "Fichier" -menu $TCL.fichier
		menu $TCL.fichier
		set i 0
		foreach élément $commandesTcl {
		  if { ($i==17) || ($i==35) || ($i==31) || ($i==103) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $i]
		  $TCL.fichier add radiobutton 		-label "file $mot"	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "file $comTcl "} -columnbreak $optionColumnBreak
		  incr i
		}
		
		set j 0
		# liste des commandes tcl-fichier demandant des options .
		set commandesTcl [list attributes copy delete pathtype rename stat  type ]	
		foreach élément $commandesTcl {
			 if { ($i==17) || ($i==35) } {set optionColumnBreak 1
		  	} else {set optionColumnBreak 0 }
		 	set mot [lindex $commandesTcl $j]
			$TCL.fichier add cascade	-label "option $mot"	-menu $TCL.fichier.$mot -columnbreak $optionColumnBreak
		menu $TCL.fichier.$mot
		incr j
		incr i
		}
		
		#option des commandes fichiers 
			# options de "file attributes" variables selon les systèmes d'exploitaton. 
		$TCL.fichier.attributes add command -label UNIX>>  -background green -activebackground green
		$TCL.fichier.attributes add command -label -group -background yellow -command {$widtexte insert insert "-group "}
		$TCL.fichier.attributes add command -label -owner -background yellow -command {$widtexte insert insert "-owner "}
		$TCL.fichier.attributes add command -label -permissions -background yellow -command {$widtexte insert insert "-permissions "}
		$TCL.fichier.attributes add command -label WINDOWS>>	-background green -activebackground green
		$TCL.fichier.attributes add command -label -archive -background yellow -command {$widtexte insert insert "-archive "}
		$TCL.fichier.attributes add command -label -hidden -background yellow -command {$widtexte insert insert "-hidden "}
		$TCL.fichier.attributes add command -label -longname -background yellow -command {$widtexte insert insert "-longname "}
		$TCL.fichier.attributes add command -label -readonly -background yellow -command {$widtexte insert insert "-readonly "}
		$TCL.fichier.attributes add command -label -shortname -background yellow -command {$widtexte insert insert "-shortname "}
		$TCL.fichier.attributes add command -label -system -background yellow -command {$widtexte insert insert "-system "}
		$TCL.fichier.attributes add command -label MacOS>> -background green -activebackground green
		$TCL.fichier.attributes add command -label -creator -background yellow -command {$widtexte insert insert "-creator "}
		$TCL.fichier.attributes add command -label -hidden -background yellow -command {$widtexte insert insert "-hidden "}
		$TCL.fichier.attributes add command -label -readonly -background yellow -command {$widtexte insert insert "-readonly "}
		$TCL.fichier.attributes add command -label -type -background yellow -command {$widtexte insert insert "-type "}

		
		$TCL.fichier.copy  add command 		-label -force	 -background yellow -command {$widtexte insert insert "-force "} 
		
		$TCL.fichier.delete  add command		-label -force	 -background yellow  -command {$widtexte insert insert "-force "} 
		
		$TCL.fichier.pathtype add command		-label -absolute	 -background yellow  -command {$widtexte insert insert "-absolute "}
		$TCL.fichier.pathtype add command		-label -relative	 -background yellow  -command {$widtexte insert insert "-relative "}
		$TCL.fichier.pathtype add command		-label -volumerelative	 -background yellow  -command {$widtexte insert insert "-volumerelative "}
		
		$TCL.fichier.rename add command 		-label -force	 -background yellow -command {$widtexte insert insert "-force "}
		
			# boucle pour cascade des options de "file stat". 
		set commandesTcl [list -atime -ctime -dev -gid -ino -mode -mtime -nlink -size -type -uid ]
		set i 0
			foreach élément $commandesTcl {
				 set mot [lindex $commandesTcl $i]
				$TCL.fichier.stat add radiobutton 		-label "$mot"	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "$comTcl "}		
				incr i
			}
		
		 
		# boucle pour cascade des options de "file type".
		
		set commandesTcl [list -file -directory -characterSpecial -blockSpecial -fifo -link -socket ]
		set i 0
			foreach élément $commandesTcl {
				 set mot [lindex $commandesTcl $i]
				$TCL.fichier.type add radiobutton 		-label "$mot"	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "$comTcl "}	
			incr i
			}
		
	#<TCL_info>
		# list des commandes tcl de gestion des informations .
		# Un sous menu au menu TCL est créé, avec l'entrée : "infos"  
		#
		set commandesTcl [list args body cmdcount commands complete default exists globals hostname level library \
				loaded locals nameofexecutable patchlevel procs script sharelibextension tclversion vars]	
		
		 $TCL add cascade -label "Infos" -menu $TCL.infos
		menu $TCL.infos
		set i 0
		foreach élément $commandesTcl {
		  if { ($i==25) || ($i==35) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $i]
		  $TCL.infos add radiobutton 		-label "info $mot"	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "info $comTcl "} -columnbreak $optionColumnBreak
		  incr i
		}
		
	#<TCL_listes>
		# list des commandes tcl de liste .
		# Un sous menu au menu TCL est créé, avec l'entrée : "listes" 
		
		set commandesTcl [ list  concat join lappend lindex linsert list llength lrange lreplace lsearch \
				lsort split]
		
		 $TCL add cascade -label Listes -menu $TCL.listes
		menu $TCL.listes 
		
		set i 0
		foreach élément $commandesTcl {
		  if { ($i==25) || ($i==51) || ($i==77) || ($i==103) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $i]
		  $TCL.listes add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "$comTcl "} -columnbreak $optionColumnBreak
		  incr i
		}
		
		#  commande TCL de listes, mais avec options : "lsort" .
		 $TCL.listes add cascade 		-label "options lsort" -menu  $TCL.listes.lsort
		menu $TCL.listes.lsort
			#options pour "lsort"
			set commandesTcl [list -ascii -dictionnary -index -integer -real -increasing -decreasing -command]
			set i 0
			foreach élément $commandesTcl {
				 set mot [lindex $commandesTcl $i]
				$TCL.listes.lsort add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			 	 -command {$widtexte insert insert "$comTcl "} 
			incr i
			}
		
	#<TCL_tableaux>
		# list des commandes tcl de gestion de tableaux .
		# Un sous menu au menu TCL est créé, avec l'entrée : "Tableaux"  
		
		set commandesTcl [list anymore donesearch exists get names nextelement set size startsearch  ]	
		
		 $TCL add cascade -label "Tableaux" -menu $TCL.tableaux
		menu $TCL.tableaux
		set i 0
		foreach élément $commandesTcl {
		  if { ($i==17) || ($i==35) || ($i==31) || ($i==103) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $i]
		  $TCL.tableaux add radiobutton 		-label "array $mot"	 -background yellow -variable comTcl -value $mot \
				  -command {$widtexte insert insert "array $comTcl "} -columnbreak $optionColumnBreak
		  incr i
		}
		
		  $TCL.tableaux add radiobutton 		-label "parray"	 -background yellow -variable comTcl -value $mot \
				  -command {$widtexte insert insert "parray "} 

		
	#<TCL_chaines>
		# list des commandes tcl de gestion de fichiers .
		# Un sous menu au menu TCL est créé, avec l'entrée : "chaines & binaires"  
		#
		set commandesTcl [list append format regexp regsub scan subst]	
		
		 $TCL add cascade -label "Chaines & binaires" -menu $TCL.chaine
		menu $TCL.chaine
		set i 0
		foreach élément $commandesTcl {
		  if { ($i==12) || ($i==23) || ($i==31) || ($i==103) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $i]
		  $TCL.chaine add radiobutton 		-label "$mot"	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "$comTcl "} -columnbreak $optionColumnBreak
		  incr i
		}
		
		 $TCL.chaine add separator
		
		set j 0
		set commandesTcl [list format scan ]			
		foreach élément $commandesTcl {
		  if { ($i==12) || ($i==23) || ($i==31) || ($i==103) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $j]
		  $TCL.chaine add radiobutton 		-label "binary $mot"	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "binary $comTcl "} -columnbreak $optionColumnBreak
		  incr i
		incr j
		}
		
		$TCL.chaine add separator
		
		set j 0
		set commandesTcl [list compare first index last length match range tolower toupper \
				trim trimleft trimright wordend wordstart]			
		foreach élément $commandesTcl {
		  if { ($i==12) || ($i==23) || ($i==31) || ($i==103) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $j]
		  $TCL.chaine add radiobutton 		-label "string $mot"	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "string $comTcl "} -columnbreak $optionColumnBreak
		  incr i
		incr j
		}
		
		set j 0
		# liste des commandes tcl-string demandant des options .
		set commandesTcl [list regexp regsub subst]	
		foreach élément $commandesTcl {
			 if { ($i==10) || ($i==35) } {set optionColumnBreak 1
		  	} else {set optionColumnBreak 0 }
		 	set mot [lindex $commandesTcl $j]
			$TCL.chaine add cascade	-label "option $mot"	-menu $TCL.chaine.$mot -columnbreak $optionColumnBreak
		menu $TCL.chaine.$mot
		incr j
		incr i
		}
		
		#options pour "regexp"
			set commandesTcl [list -nocase -indices ]
			set i 0
			foreach élément $commandesTcl {
				 set mot [lindex $commandesTcl $i]
				$TCL.chaine.regexp add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			 	 -command {$widtexte insert insert "$comTcl "} 
			incr i
			}
			
		#options pour "regsub"
			set commandesTcl [list -nocase -all ]
			set i 0
			foreach élément $commandesTcl {
				 set mot [lindex $commandesTcl $i]
				$TCL.chaine.regsub add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			 	 -command {$widtexte insert insert "$comTcl "} 
			incr i
			}
			
		#options pour "subst"
			set commandesTcl [list -nobackslashes -nocommands -novariables ]
			set i 0
			foreach élément $commandesTcl {
				 set mot [lindex $commandesTcl $i]
				$TCL.chaine.subst add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			 	 -command {$widtexte insert insert "$comTcl "} 
			incr i
			}
		
	#<TCL_systeme>
		# list des commandes tcl de gestion de fichiers .
		# Un sous menu au menu TCL est créé, avec l'entrée : "Système"  
		#
		set commandesTcl [list auto_execok auto_load auto_mkindex auto_reset cd exec glob load pid pwd source ]	
		
		 $TCL add cascade -label "Système" -menu $TCL.système
		menu $TCL.système
		set i 0
		foreach élément $commandesTcl {
		  if { ($i==20) || ($i==40) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $i]
		  $TCL.système add radiobutton 		-label "$mot"	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "$comTcl "} -columnbreak $optionColumnBreak
		  incr i
		}
		
		 $TCL.système add separator
		
		set commandesTcl [list clicks format scan seconds ]			
		set j 0
		foreach élément $commandesTcl {
		  if { ($i==20) || ($i==40) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $j]
		  $TCL.système add radiobutton 		-label "clock $mot"	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "clock $comTcl "} -columnbreak $optionColumnBreak
		  incr i
		incr j
		}
		
		set j 0
		# liste des commandes tcl-fichier demandant des options .
		set commandesTcl [list  (clock)format (clock)scan exec glob ]	
		foreach élément $commandesTcl {
			 if { ($i==22) || ($i==40) } {set optionColumnBreak 1
		  	} else {set optionColumnBreak 0 }
		 	set mot [lindex $commandesTcl $j]
			$TCL.système add cascade	-label "option $mot"	-menu $TCL.système.$mot -columnbreak $optionColumnBreak
		menu $TCL.système.$mot
		incr j
		incr i
		}
		
		#options pour "clock format"
			set commandesTcl [list -format -gmt ]
			set i 0
			foreach élément $commandesTcl {
				 set mot [lindex $commandesTcl $i]
				$TCL.système.(clock)format add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			 	 -command {$widtexte insert insert "$comTcl "} 
			incr i
			}
		
		#options pour "clock scan"
			set commandesTcl [list -base -gmt ]
			set i 0
			foreach élément $commandesTcl {
				 set mot [lindex $commandesTcl $i]
				$TCL.système.(clock)scan add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			 	 -command {$widtexte insert insert "$comTcl "} 
			incr i
			}
			
		#options pour "exec"
		$TCL.système.exec add radiobutton 		-label -keepnew	 -background yellow -variable comTcl -value $mot \
			 	 -command {$widtexte insert insert "-keepnew "} 
			
		#options pour "glob"
		$TCL.système.glob add radiobutton 		-label -nocomplain	 -background yellow -variable comTcl -value $mot \
			 	 -command {$widtexte insert insert "-nocomplain "} 
		
		
	#<TCL_entreeSorties>
		# list des commandes tcl de gestion d'entrée/sortie .
		# Un sous menu au menu TCL est créé, avec l'entrée : "Entrées & sorties"  
		#
		set commandesTcl [list close eof fblocked fconfigure fcopy fileevent  flush  gets open putsreadseek socket tell ]	
		
		 $TCL add cascade -label "Entrées & sorties" -menu $TCL.entréeSortie
		menu $TCL.entréeSortie
		set i 0
		foreach élément $commandesTcl {
		  if { ($i==20) || ($i==35) || ($i==51) || ($i==103) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $i]
		  $TCL.entréeSortie add radiobutton 		-label "$mot"	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "$comTcl "} -columnbreak $optionColumnBreak
		  incr i
		}
			
		set j 0
		# liste des commandes tcl-entrée/sortie demandant des options .
		set commandesTcl [list  fconfigure fcopy fileevent open puts read socket ]	
		foreach élément $commandesTcl {
			 if { ($i==20) || ($i==35) } {set optionColumnBreak 1
		  	} else {set optionColumnBreak 0 }
		 	set mot [lindex $commandesTcl $j]
			$TCL.entréeSortie add cascade	-label "option $mot"	-menu $TCL.entréeSortie.$mot -columnbreak $optionColumnBreak
		menu $TCL.entréeSortie.$mot
		incr j
		incr i
		}
		
		#options pour "fconfigure"
		
		$TCL.entréeSortie.fconfigure add radiobutton 		-label -blocking	 -background yellow -variable comTcl -value -blocking \
			 	 -command {$widtexte insert insert "$comTcl "}
			
		$TCL.entréeSortie.fconfigure add cascade	 -label "-buffering valeurs" -menu $TCL.entréeSortie.fconfigure.bufferingValeurs
		menu $TCL.entréeSortie.fconfigure.bufferingValeurs
			# valeurs de -buffering 
			set commandesTcl [list full line none  ]
			set j 0
			foreach élément $commandesTcl {
				 set mot [lindex $commandesTcl $j]
				$TCL.entréeSortie.fconfigure.bufferingValeurs add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			 	 -command {$widtexte insert insert "-buffering $comTcl "} 
			incr j
			}
			
		$TCL.entréeSortie.fconfigure add radiobutton 		-label -buffersize	 -background yellow -variable comTcl -value -buffersize \
			 	 -command {$widtexte insert insert "$comTcl "}
		$TCL.entréeSortie.fconfigure add radiobutton 		-label -eofchar	 -background yellow -variable comTcl -value -eofchar \
			 	 -command {$widtexte insert insert "$comTcl "}
			
		$TCL.entréeSortie.fconfigure add cascade	 -label "-translation" -menu $TCL.entréeSortie.fconfigure.translation
		menu $TCL.entréeSortie.fconfigure.translation
			# valeurs de -buffering 
			set commandesTcl [list auto binary cr crlf  lf ]
			set j 0
			foreach élément $commandesTcl {
				 set mot [lindex $commandesTcl $j]
				$TCL.entréeSortie.fconfigure.translation add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			 	 -command {$widtexte insert insert "-translation $comTcl "} 
			incr j
			}
		
		# autres options de "configure"	
		set commandesTcl [list -sockname -peername -mode]
		set j 0
		foreach élément $commandesTcl {
			set mot [lindex $commandesTcl $j]
			$TCL.entréeSortie.fconfigure add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			 	 -command {$widtexte insert insert "$comTcl "} 
		incr j
		incr i
		}
			
		#options pour "fcopy"
		set commandesTcl [list -size -command]
		set i 0
		foreach élément $commandesTcl {
			set mot [lindex $commandesTcl $i]
			$TCL.entréeSortie.fcopy add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			 	 -command {$widtexte insert insert "$comTcl "} 
		incr i
		}
		
		#options pour "fileevent"
		set commandesTcl [list readable writable]
		set i 0
		foreach élément $commandesTcl {
			set mot [lindex $commandesTcl $i]
			$TCL.entréeSortie.fileevent add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			 	 -command {$widtexte insert insert "$comTcl "} 
		incr i
		}
		
		#options pour "open"
		set commandesTcl [list r r+ w w+ a a+]
		set i 0
		foreach élément $commandesTcl {
			set mot [lindex $commandesTcl $i]
			$TCL.entréeSortie.open add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			 	 -command {$widtexte insert insert "$comTcl "} 
		incr i
		}
		
		#options pour "puts"
		$TCL.entréeSortie.puts add radiobutton 		-label -nonewline	 -background yellow -variable comTcl -value -nonewline \
				 -command {$widtexte insert insert "$comTcl "} 
		
		#options pour "read"
		$TCL.entréeSortie.read add radiobutton 		-label -nonewline	 -background yellow -variable comTcl -value -nonewline \
				 -command {$widtexte insert insert "$comTcl "} 
		
		#options pour "socket"
		set commandesTcl [list -myadress -myport -async -server]
		set i 0
		foreach élément $commandesTcl {
			set mot [lindex $commandesTcl $i]
			$TCL.entréeSortie.socket add radiobutton 		-label $mot	 -background yellow -variable comTcl -value $mot \
			 	 -command {$widtexte insert insert "$comTcl "} 
		incr i
		}
		
	#<TCL_interpréteurs>
		# list des commandes tcl de gestion des interpréteurs alias .
		# Un sous menu au menu TCL est créé, avec l'entrée : "Interprêteurs"  
		#
		set commandesTcl [list alias aliases create delete eval exists expose \
			hide hidden invokehidden issafe marktrusted share slaves target transfer]	
		
		 $TCL add cascade -label "Interprêteurs" -menu $TCL.interp
		menu $TCL.interp
		set i 0
		foreach élément $commandesTcl {
		  if { ($i==20) || ($i==23) || ($i==31) || ($i==103) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $i]
		  $TCL.interp add radiobutton 		-label "interp $mot"	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "interp $comTcl "} -columnbreak $optionColumnBreak
		  incr i
		}
		
		#options pour "interp invokehidden"
		set commandesTcl [list {invokehidden option}]
		set i 0
		foreach élément $commandesTcl {
			set mot [lindex $commandesTcl $i]
			$TCL.interp add cascade 		-label $mot	 -menu  $TCL.interp.invokehiddenOption
			menu $TCL.interp.invokehiddenOption
		incr i
		}
		
		$TCL.interp.invokehiddenOption 	add radiobutton 		-label "-global"	 -background yellow -variable comTcl -value -global \
			  -command {$widtexte insert insert "$comTcl "}
			
	#<TCL_paquetages>
		# list des commandes tcl de gestion des paquetages .
		# Un sous menu au menu TCL est créé, avec l'entrée : "Paquetages"  
		#
		set commandesTcl [list forget ifneed names provide require unknown vcompare versions vsatisfies]	
		
		 $TCL add cascade -label "Paquetages" -menu $TCL.paquetage
		menu $TCL.paquetage
		set i 0
		foreach élément $commandesTcl {
		  if { ($i==20) || ($i==40)  } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $i]
		  $TCL.paquetage add radiobutton 		-label "package $mot"	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "package $comTcl "} -columnbreak $optionColumnBreak
		  incr i
		}		
		
		# option pour require
		$TCL.paquetage add cascade -label "option require" -menu $TCL.paquetage.requireOption
		menu $TCL.paquetage.requireOption
		$TCL.paquetage.requireOption add radiobutton 		-label "-exact"	 -background yellow -variable comTcl -value "-exact" \
			  -command {$widtexte insert insert "$comTcl "} 
	
	#<TCL_history>
		# list des commandes tcl de gestion des historiques .
		# Un sous menu au menu TCL est créé, avec l'entrée : "Historique"  
		#
		set commandesTcl [list add change clear event info keep nextid redo ]	
		
		 $TCL add cascade -label "Historique" -menu $TCL.historique
		menu $TCL.historique
		set i 0
		foreach élément $commandesTcl {
		  if { ($i==20) || ($i==40)  } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $i]
		  $TCL.historique add radiobutton 		-label "history $mot"	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "history $comTcl "} -columnbreak $optionColumnBreak
		  incr i
		}		
			
	#<TCL_espaceNom>
		# list des commandes tcl de gestion des espaces de noms .
		# Un sous menu au menu TCL est créé, avec l'entrée : "Espaces de nom"  
		#
		set commandesTcl [list children code current delete eval export forget import inscope origin qualifiers tail which ]	
		
		 $TCL add cascade -label "Espaces de nom" -menu $TCL.espaceNom
		menu $TCL.espaceNom
		set i 0
		foreach élément $commandesTcl {
		  if { ($i==20) || ($i==40)  } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $i]
		  $TCL.espaceNom add radiobutton 		-label "namespace $mot"	 -background yellow -variable comTcl -value $mot \
			  -command {$widtexte insert insert "namespace $comTcl "} -columnbreak $optionColumnBreak
		  incr i
		}
		
		# entrées options pour espaceNom		
		set commandesTcl [list export import which  ]	
		set j 0
		foreach élément $commandesTcl {
		  if { ($i==20) || ($i==40)  } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $commandesTcl $j]
		  $TCL.espaceNom add cascade 		-label "options $mot"	 -menu $TCL.espaceNom.option$mot
		menu $TCL.espaceNom.option$mot
		  incr i
		incr j
		}
		
		# options 	pour export import 
		$TCL.espaceNom.optionexport add radiobutton 		-label "-clear"	 -background yellow -variable comTcl -value -clear \
			  -command {$widtexte insert insert "$comTcl "}
		$TCL.espaceNom.optionimport add radiobutton 		-label "-force"	 -background yellow -variable comTcl -value -force \
			  -command {$widtexte insert insert "$comTcl "}
			
		# options 	pour  which
		$TCL.espaceNom.optionwhich add radiobutton 		-label "-command"	 -background yellow -variable comTcl -value -command \
			  -command {$widtexte insert insert "$comTcl "}
		$TCL.espaceNom.optionwhich add radiobutton 		-label "-variable"	 -background yellow -variable comTcl -value -variable \
			  -command {$widtexte insert insert "$comTcl "}
		
			
		
#<fin_menu_TCL> ########################################################		
		
#<MENU_TK>

# variables internes de Tk
#<variablesTK> 
	$TK add cascade  -label "variables Tk" -menu $TK.variables			
 	menu $TK.variables 

set motTk [list  tk_library tk_patchlevel tkpriv tk_strictMotif tk_version]
		set i 0
		# boucle de création du menu
		foreach élément $motTk {
		  if { ($i==12) || ($i==25) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $motTk $i]
		$TK.variables	 add radiobutton 		-label " $mot"	 -background yellow -variable comTk -value $mot \
			  -command {$widtexte insert insert "$comTk "} -columnbreak $optionColumnBreak
		  incr i
		}
	
	


# on définit des cascades par grandes catégories de commandes
# et on affiche pour chaque catégorie les commandes avec en regard les éventuelles sous commandes et options
# quand les options ont des valeurs prédéfinies à choisir une cascade permet de les lister.
# les grands grpoupes de commandes seront les suivants : commandes, widgets, canvas, widget texte, winfo et wm

#<TK_predefinis> 
	$TK add cascade  -label "Tk_..." -menu $TK.tkk				
 	menu $TK.tkk 
	set motTk [list  tk_bisque tk_chooseColor tk_dialog tk_focusNext tk_focusFollowMouse tk_getOpenFile \
		 tk_getSaveFile tk_messageBox tk_optionMenu tk_popup tk_setPalette  ]
		set i 0
		# boucle de création du menu
		foreach élément $motTk {
		  if { ($i==12) || ($i==25) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $motTk $i]
		$TK.tkk	 add radiobutton 		-label " $mot"	 -background yellow -variable comTk -value $mot \
			  -command {$widtexte insert insert "$comTk "} -columnbreak $optionColumnBreak
		  incr i
		}
		
		 if { ($i==11) || ($i==10) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
	$TK.tkk	 add command -background green -activebackground green -label options -columnbreak $optionColumnBreak
	incr i
		
		#options 
		set motTk [list  _ tk_chooseColor _ _ _ tk_getOpenFile \
		 tk_getSaveFile tk_messageBox _ _ tk_setPalette  ]
		set j 0
		# boucle de création du menu
		foreach élément $motTk {
		  set mot [lindex $motTk $j]
		if { [string compare $mot "_"] !=0} {
		$TK.tkk  add cascad	-label $mot	 -menu $TK.tkk.$mot
		} else { 
		$TK.tkk  add command	-label "-"}
		  incr j
		  incr i
		}
		
		#<tk_chooseColor>
		 menu $TK.tkk.tk_chooseColor
			$TK.tkk.tk_chooseColor add command  -background  yellow -label -initialcolor -command {$widtexte insert insert "-initialcolor "}
			$TK.tkk.tk_chooseColor add command  -background  yellow -label -parent -command {$widtexte insert insert "-parent "}
			$TK.tkk.tk_chooseColor add command  -background  yellow -label -title -command {$widtexte insert insert "-title "}
		
		#<tk_getOpenFle>
		menu $TK.tkk.tk_getOpenFile
			$TK.tkk.tk_getOpenFile add command  -background  yellow -label -defaultextension -command {$widtexte insert insert "-defaultextension "}
			$TK.tkk.tk_getOpenFile add command  -background  yellow -label -filetypes -command {$widtexte insert insert "-filetypes "}
			$TK.tkk.tk_getOpenFile add command  -background  yellow -label -initialdir -command {$widtexte insert insert "-initialdir "}
			$TK.tkk.tk_getOpenFile add command  -background  yellow -label -initialfile -command {$widtexte insert insert "-initialfiles "}
			$TK.tkk.tk_getOpenFile add command  -background  yellow -label -parent -command {$widtexte insert insert "-parent "}
			$TK.tkk.tk_getOpenFile add command  -background  yellow -label -title -command {$widtexte insert insert "-title "}

		#<tk_getSaveFile>
		menu $TK.tkk.tk_getSaveFile
			$TK.tkk.tk_getSaveFile add command  -background  yellow -label -defaultextension -command {$widtexte insert insert "-defaultextension "}
			$TK.tkk.tk_getSaveFile add command  -background  yellow -label -filetypes -command {$widtexte insert insert "-filetypes "}
			$TK.tkk.tk_getSaveFile add command  -background  yellow -label -initialdir -command {$widtexte insert insert "-initialdir "}
			$TK.tkk.tk_getSaveFile add command  -background  yellow -label -initialfile -command {$widtexte insert insert "-initialfiles "}
			$TK.tkk.tk_getSaveFile add command  -background  yellow -label -parent -command {$widtexte insert insert "-parent "}
			$TK.tkk.tk_getSaveFile add command  -background  yellow -label -title -command {$widtexte insert insert "-title "}
		
		#<tk_messageBox>
		menu $TK.tkk.tk_messageBox
			#icon
			$TK.tkk.tk_messageBox add cascade -label -icon -menu $TK.tkk.tk_messageBox.icon
			menu $TK.tkk.tk_messageBox.icon
			$TK.tkk.tk_messageBox.icon add radiobutton -background yellow -variable opt_icon -label "error" -command {$widtexte insert insert "-icon error "}
			$TK.tkk.tk_messageBox.icon add radiobutton -background yellow -variable opt_icon -label info -command {$widtexte insert insert "-icon info "}
			$TK.tkk.tk_messageBox.icon add radiobutton -background yellow -variable opt_icon -label question -command {$widtexte insert insert "-icon question "}
			$TK.tkk.tk_messageBox.icon add radiobutton -background yellow -variable opt_icon -label warning -command {$widtexte insert insert "-icon warning "}
			
			#type
			$TK.tkk.tk_messageBox add cascade -label -type -menu $TK.tkk.tk_messageBox.type
			menu $TK.tkk.tk_messageBox.type
			$TK.tkk.tk_messageBox.type add radiobutton -background yellow -variable opt_icon -label abortretryignore -command {$widtexte insert insert "-type abortretryignore "}
			$TK.tkk.tk_messageBox.type add radiobutton -background yellow -variable opt_icon -label ok -command {$widtexte insert insert "-type ok "}
			$TK.tkk.tk_messageBox.type add radiobutton -background yellow -variable opt_icon -label okcancel -command {$widtexte insert insert "-type okcancel "}			
			$TK.tkk.tk_messageBox.type add radiobutton -background yellow -variable opt_icon -label retrycancel -command {$widtexte insert insert "-type retrycancel "}
			$TK.tkk.tk_messageBox.type add radiobutton -background yellow -variable opt_icon -label yesno -command {$widtexte insert insert "-type yesno "}
			$TK.tkk.tk_messageBox.type add radiobutton -background yellow -variable opt_icon -label yesnocancel -command {$widtexte insert insert "-type yesnocancel "}

			#default - message - parent -title -
			$TK.tkk.tk_messageBox add command  -background  yellow -label -default -command {$widtexte insert insert "-default "}
			$TK.tkk.tk_messageBox add command  -background  yellow -label -message -command {$widtexte insert insert "-message "}
			$TK.tkk.tk_messageBox add command  -background  yellow -label -parent -command {$widtexte insert insert "-parent "}
			$TK.tkk.tk_messageBox add command  -background  yellow -label -title -command {$widtexte insert insert "-title "}
		
		
		#<tk_setPalette>
		menu $TK.tkk.tk_setPalette
			$TK.tkk.tk_setPalette add command  -background  yellow -label -activeBackground  -command {$widtexte insert insert "-activeBackground "}
			$TK.tkk.tk_setPalette add command  -background  yellow -label -activeForeground  -command {$widtexte insert insert "-activeForeground "}
			$TK.tkk.tk_setPalette add command  -background  yellow -label -background  -command {$widtexte insert insert "-background "}
			$TK.tkk.tk_setPalette add command  -background  yellow -label -disabledForeground  -command {$widtexte insert insert "-disabledForeground "}
			$TK.tkk.tk_setPalette add command  -background  yellow -label -foreground  -command {$widtexte insert insert "-foreground "}
			$TK.tkk.tk_setPalette add command  -background  yellow -label -highlightBackground  -command {$widtexte insert insert "-highlightBackground "}
			$TK.tkk.tk_setPalette add command  -background  yellow -label -highlightColor  -command {$widtexte insert insert "-highlightColor "}
			$TK.tkk.tk_setPalette add command  -background  yellow -label -insertBackground -command {$widtexte insert insert "-insertBackground "}
			$TK.tkk.tk_setPalette add command  -background  yellow -label -selectColor -command {$widtexte insert insert "-selectColor "}
			$TK.tkk.tk_setPalette add command  -background  yellow -label -selectBackground  -command {$widtexte insert insert "-selectBackground "}
			$TK.tkk.tk_setPalette add command  -background  yellow -label -selectForeground  -command {$widtexte insert insert "-selectForeground "}
			$TK.tkk.tk_setPalette add command  -background  yellow -label -troughColor  -command {$widtexte insert insert "-troughColor "}
	
	
	
			
			
			
			
#<MENU_WIDGETS> 
	
	#les widgets sont listés dans un menu et grace au columnbreak
	# les sous commandes 
	# les options et 
	#sont disponibles au même niveau
	
		set OptionsW $TK.menuOptionsW ; # cette ligne sert à réutiliser le code de l'ancienne interface de tikeditor2.3 
		$TK add cascade  -label "Widgets"  -menu $OptionsW			
 		menu $OptionsW
				
		set widgetsTk [list  button canvas checkbutton entry frame image label listbox menu menubutton \
			message radiobutton scale spinbox scrollbar text toplevel ]
		set i 0
		# boucle de création du menu
		foreach élément $widgetsTk {
		
		  set mot [lindex $widgetsTk $i]
		  $OptionsW add radio	-label $mot	 -variable widTK -value $mot -background yellow\
			  -command {$widtexte insert insert "$widTK "} 
		  incr i
		}
		
	#<commandes_Widgets> ###################################################################################
	
		# sous rubrique du menu des widgets : "sous commandes"
		
		set CommandesW  $TK.menuOptionsW ; # cette ligne sert à réutiliser le code de l'ancienne interface de tikeditor2.3 
		
		 if { ($i==16) || ($i==17) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		 $OptionsW add command -label "sous commandes " -background green -activebackground green -columnbreak $optionColumnBreak
		incr i
		
		#commandes widget
		set widgetTk [list  button canvas checkbutton entry frame image label listbox menu menubutton \
			message radiobutton scale spinbox scrollbar text toplevel ]
		set j 0
		# boucle de création du menu
		foreach élément $widgetsTk {		
		  set mot [lindex $widgetsTk $j]
		  $OptionsW  add cascade	-label "cmd $mot"	-menu "$CommandesW.cmdmenu$mot"	 
		  
		incr j
		  incr i
		}
		
		
			
#<MENUcommandesW>

		# création des menus vides
		set widgetTk [list  frame  label listbox  menubutton message  toplevel ]
		set j 0
		# boucle de création du menu
		foreach élément $widgetTk {		
		  set mot [lindex $widgetTk $j]
		menu "$CommandesW.cmdmenu$mot"	 
		  
		incr j
		}

		
		#BUTTON
		menu $CommandesW.cmdmenubutton -bg yellow
		set commandesButton [list flash invoque ]
		set j 0
		# boucle de création de colonnes des menus cascade de "Widgets	"
		foreach élémentButton $commandesButton {
		  if {$j==26} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set commande [lindex $commandesButton $j]
		  $CommandesW.cmdmenubutton add radiobutton	-label $commande	-variable buttonComd -value $commande \
			  -command " \$widtexte insert insert {$commande } "  -columnbreak $optionColumnBreak
		  
		  incr j
		}
		
		#CANVAS
		menu $CommandesW.cmdmenucanvas -bg yellow
		set commandesCanvas [list addtag bbox bind canvasx canvasy coords create dchars delete dtag find focus gettags \
			icursor index insert itemcget itemconfigure lower move postscript raise scale scan {select adjust} {select clear} {select from} \
			{select item} {select to} type xview yview ]
		set j 0
		# boucle de création de colonnes des menus cascade de "Widgets	"
		foreach élémentCanvas $commandesCanvas {
		  if {$j==16} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set commande [lindex $commandesCanvas $j]
		  $CommandesW.cmdmenucanvas add radiobutton	-label $commande	-variable canvasComd -value $commande \
			  -command " \$widtexte insert insert {$commande } "  -columnbreak $optionColumnBreak
		  
		  incr j
		}
		
		#CHECKBUTTON
		menu $CommandesW.cmdmenucheckbutton -bg yellow
		set commandesCheckbutton [list deselect flash invoque select toggle]
		set j 0
		# boucle de création de colonnes des menus cascade de "Widgets	"
		foreach élémentCheckbutton $commandesCheckbutton {
		  if {$j==26} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set commande [lindex $commandesCheckbutton $j]
		  $CommandesW.cmdmenucheckbutton add radiobutton	-label $commande	-variable checkbuttonComd -value $commande \
			  -command " \$widtexte insert insert {$commande } "  -columnbreak $optionColumnBreak
		  
		  incr j
		}
		
		#ENTRY
		menu $CommandesW.cmdmenuentry -bg yellow
		set commandesEntry [list bbox delete get icursor index insert scan\
		 {selection adjust} {selection clear} {selection from} {selection present} {selection rage}  {selection to} ]
		set j 0
		# boucle de création de colonnes des menus cascade de "Widgets	"
		foreach élément $commandesEntry {
		  if {$j==26} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set commande [lindex $commandesEntry $j]
		  $CommandesW.cmdmenuentry add radiobutton	-label $commande	-variable entryComd -value $commande \
			  -command " \$widtexte insert insert {$commande } "  -columnbreak $optionColumnBreak
		  
		  incr j
		}
		
		
			
		#RADIOBUTTON
		menu $CommandesW.cmdmenuradiobutton -bg yellow
		set commandesRadiobutton [list deselect flash invoque select]
		set j 0
		# boucle de création de colonnes des menus cascade de "Widgets	"
		foreach élémentRadiobutton $commandesRadiobutton {
		  if {$j==26} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set commande [lindex $commandesRadiobutton $j]
		  $CommandesW.cmdmenuradiobutton add radiobutton	-label $commande	-variable radiobuttonComd -value $commande \
			  -command " \$widtexte insert insert {$commande } "  -columnbreak $optionColumnBreak
		  
		  incr j
		}
		
		#SCALE
		menu $CommandesW.cmdmenuscale -bg yellow
		set commandesScale [list coords get identify set ]
		set j 0
		# boucle de création de colonnes des menus cascade de "Widgets	"
		foreach élémentScale $commandesRadiobutton {
		  if {$j==26} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set commande [lindex $commandesScale $j]
		  $CommandesW.cmdmenuscale add radiobutton	-label $commande	-variable scaleComd -value $commande \
			  -command " \$widtexte insert insert {$commande } "  -columnbreak $optionColumnBreak
		  
		  incr j
		}
		
		#IMAGE
		menu $CommandesW.cmdmenuimage -bg yellow
		set commandesImage [list {create photo} {create bitmap} delete height names type types width]
		set j 0
		# boucle de création de colonnes des menus cascade de "Widgets	"
		foreach élémentImage $commandesImage {
		  if {$j==26} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set commande [lindex $commandesImage $j]
		  $CommandesW.cmdmenuimage add radiobutton	-label $commande	-variable imageComd -value $commande \
			  -command " \$widtexte insert insert {$commande } "  -columnbreak $optionColumnBreak
		  
		  incr j
		}
		
		
		#Menu
		menu $CommandesW.cmdmenumenu
		
		$CommandesW.cmdmenumenu add cascade -label "items de menu" -menu $CommandesW.cmdmenumenuItems
		menu $CommandesW.cmdmenumenuItems
		 
		set optionsMenu [list  cascade command radiobutton checkbutton separator]
		
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élément $optionsMenu {
		  set option [lindex $optionsMenu $j]
		$CommandesW.cmdmenumenuItems add radiobutton	-label $option	-variable menuOption -value $option \
			  -command " \$widtexte insert insert {-$option }" -background yellow
		  
		  incr j
		}
		
		set commandesMenu [list activate add clone delete entrycget entryconfigure index insert invoke post postcascade\
			type unpost yposition ]
		set j 0
		# boucle de création de colonnes des menus cascade de "Widgets	"
		foreach élémentMenu $commandesMenu {
		  if {$j==26} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set commande [lindex $commandesMenu $j]
		  $CommandesW.cmdmenumenu add radiobutton	-label $commande	-variable menuComd -value $commande \
			  -command " \$widtexte insert insert {$commande } "  -columnbreak $optionColumnBreak -background yellow
		  
		  incr j
		}
		
		#SCROLLBAR
		menu $CommandesW.cmdmenuscrollbar -bg yellow
		set commandesScrollbar [list activate delta fraction get identify set ]
		set j 0
		# boucle de création de colonnes des menus cascade de "Widgets	"
		foreach élémentScrollbar $commandesScrollbar {
		  if {$j==26} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set commande [lindex $commandesScrollbar $j]
		  $CommandesW.cmdmenuscrollbar add radiobutton	-label $commande	-variable srollbarComd -value $commande \
			  -command " \$widtexte insert insert {$commande } "  -columnbreak $optionColumnBreak
		  
		  incr j
		}
		
		
		
		#TEXT
		menu $CommandesW.cmdmenutext -bg yellow
		set commandesText [list bbox compare delete dlineinfo dump get image index insert {mark gravity}  {mark names}\
			{mark next} {mark previous} {mark set} {mark unset} scan search see {tag add} {tag bind} {tag cget} {tag configure}\
			{tag delete} {tag lower} {tag names} {tag nextrange} {tag prevrange} {tag raise} {tag range} {tag remove}\
			{window cget} {window configure} {window create} {window names} xview yview]
		set j 0
		# boucle de création de colonnes des menus cascade de "Widgets	"
		foreach élémentText $commandesText {
		  if {$j==18} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set commande [lindex $commandesText $j]
		  $CommandesW.cmdmenutext add radiobutton	-label $commande	-variable textComd -value $commande \
			  -command " \$widtexte insert insert  {$commande } "  -columnbreak $optionColumnBreak
		  
		  incr j
		}
	
		
		
 	# <OptionsWidget> ##############################################################################################
			
		# sous rubrique du menu des widgets  : "options"
		
		 if { ($i==33) || ($i==34) || ($i==35)} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		 $OptionsW add command -label "options " -background green -activebackground green		-columnbreak $optionColumnBreak
		incr i	
		set j 0
		# boucle de création du menu
		foreach élément $widgetsTk {
				  set mot [lindex $widgetsTk $j]
		  $OptionsW add cascade	-label "options $mot"	-menu $OptionsW.menu$mot 
		  
		incr j
		  incr i
		}
		
		# Création des menus cascade de Widgets
		# CANVAS
		menu $OptionsW.menucanvas -bg yellow
		set optionsCanvas [list background borderwidth cursor height highlightbackground highlightcolor highlightthickness insertbackground insertborderwith \
			insertofftime insertontime insertwidth relief selectbackground selectborderwidth selectforeground takefocus width xscrollcommand yscrollcommand \
			closeenough confine scrollregion xscrollincrement yscrollincrement  ]
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élémentCanvas $optionsCanvas {
		  if { ($j==12) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set option [lindex $optionsCanvas $j]
		  $OptionsW.menucanvas add radiobutton	-label -$option	-variable canvasOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  -columnbreak $optionColumnBreak
		  
		  incr j
		}
		
		# BUTTON
		menu $OptionsW.menubutton -bg yellow
		set optionsButton [list activebackground activeforeground background borderwidth command compound cursor defaut font foreground height highlightbackground \
			highlightcolor highlightthickness  insertborderwith insertofftime insertontime insertwidth justify overrelief padx pady relief \
			state takefocus text  textvariable underline width  wraplengh ]
		
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élémentButton $optionsButton {
		  set option [lindex $optionsButton $j]
		  $OptionsW.menubutton add radiobutton	-label -$option	-variable buttonOption -value $option \
			  -command " \$widtexte insert insert {-$option }"
		  
		  incr j
		}
		
		# CHECKBUTTON
		menu $OptionsW.menucheckbutton -bg yellow
		set optionsCheckButton [list activebackground activeforeground anchor background bitmap command borderwidth  cursor \
			defaut disabledforeground font foreground height highlightbackground \
			highlightcolor highlightthickness  image indicatoron insertborderwith insertofftime insertontime insertwidth \
			justify offvalue onvalue overrelief padx pady relief selectcolor selectimage state\
			takefocus text  textvariable underline width  wraplengh ]
		
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élémentCheckButton $optionsCheckButton {
		  set option [lindex $optionsCheckButton $j]
		  $OptionsW.menucheckbutton add radiobutton	-label -$option	-variable checkbuttonOption -value $option \
			  -command " \$widtexte insert insert {-$option }"
		  
		  incr j
		}
		
		# ENTRY
		menu $OptionsW.menuentry -bg yellow
		set optionsEntry [list  background borderwidth cursor disablebackground disableforeground exportselection font foreground height highlightbackground \
			highlightcolor highlightthickness  insertbackground insertborderwith insertofftime insertontime insertwidth invalidcommand justify  \
			readonlybackground relief 	selectbackground selecctborderwidth selectforeground show  state takefocus textvariable\
			 underline validate validatecommand width  xscrollcommand]
		
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élémentEntry $optionsEntry {
		  if { ($j==16) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set option [lindex $optionsEntry $j]
		  $OptionsW.menuentry add radiobutton	-label -$option	-variable buttonEntry -value $option \
			  -command " \$widtexte insert insert {-$option }"  -columnbreak $optionColumnBreak 
		  
		  incr j
		}
		
		# FRAME
		menu $OptionsW.menuframe -bg yellow
		set optionsFrame [list background borderwidth class colormap container cursor height highlightbackground \
			highlightcolor highlightthickness  relief \
			takefocus visual width  ]
		
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élémentFrame $optionsFrame {
		  set option [lindex $optionsFrame $j]
		  $OptionsW.menuframe add radiobutton	-label -$option	-variable frameOption -value $option \
			  -command " \$widtexte insert insert {-$option }"
		  
		  incr j
		}
		
		# IMAGE
		menu $OptionsW.menuimage
		set optionsImage [list photo bitmap ]
		
		set j 0
		
		#menu spéciaux cascade image photo/bitmap
		menu $OptionsW.menuimage.photo -bg yellow
		set optionsPhoto [list data format file height palette width  ]
		set k 0
		# boucle de création des menus cascade image/photo
		foreach élémentPhoto $optionsPhoto {
		  set option [lindex $optionsPhoto $k]
		  $OptionsW.menuimage.photo add radiobutton	-label -$option	 -command " \$widtexte insert insert {-$option }"
		  
		  incr k
		}
		
		#menu spéciaux cascade image photo/bitmap
		menu $OptionsW.menuimage.bitmap -bg yellow
		set optionsBitmap [list background data file foreground maskdata maskfile  ]
		set k 0
		# boucle de création des menus cascade image/bitmap
		foreach élémentBitmap $optionsBitmap {
		  set option [lindex $optionsBitmap $k]
		  $OptionsW.menuimage.bitmap add radiobutton	-label -$option	 -command " \$widtexte insert insert {-$option }"
		  
		  incr k
		}
		
		
		# boucle de création des menus cascade de "Image"
		foreach élémentImage $optionsImage {
		  set option [lindex $optionsImage $j]
		  $OptionsW.menuimage add cascade	-label $option	-menu  "$OptionsW.menuimage.$option"
		  
		  incr j
		}
		
		# LABEL
		menu $OptionsW.menulabel -bg yellow
		set optionsLabel [list anchor background bitmap borderwidth  cursor font foreground height highlightbackground \
			highlightcolor highlightthickness  image justify  padx pady relief \
			takefocus text textvariable underline width wraplengh ]
		
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élémentLabel $optionsLabel {
		  set option [lindex $optionsLabel $j]
		  $OptionsW.menulabel add radiobutton	-label -$option	-variable labelOption -value $option \
			  -command " \$widtexte insert insert {-$option }"
		  
		  incr j
		}
		
		# LISTBOX
		menu $OptionsW.menulistbox -bg yellow
		set optionsListbox [list background borderwidth cursor  font foreground height \
			highlightbackground highlightcolor highlightthickness  listvariable\
			relief  selectbackground selectborderwidth selectforeground  setgrid state takefocus \
			width xscrollcommand yscrollcommand ]
		
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élémentListbox $optionsListbox {
		  set option [lindex $optionsListbox $j]
		  $OptionsW.menulistbox add radiobutton	-label -$option	-variable listboxOption -value $option \
			  -command " \$widtexte insert insert {-$option }"
		  
		  incr j
		}
		#cascade spéciale pour listbox
		$OptionsW.menulistbox add cascade	-label selectmode	-menu $OptionsW.menulistbox.selectmode
		menu $OptionsW.menulistbox.selectmode -bg yellow -tearoff 0
		set optionsSelectMode [list single browse multiple extended ]
		set k 0
		# boucle de création des menus cascade listbox.selectmode
		foreach élémentBitmap $optionsSelectMode {
		  set option [lindex $optionsSelectMode $k]
		  $OptionsW.menulistbox.selectmode add radiobutton	-label -$option	 -command " \$widtexte insert insert {-selectmode $option } "
		  
		  incr k
		}
		
		# MENU
		menu $OptionsW.menumenu 
		
		$OptionsW.menumenu add cascade -label "items de menu" -menu $OptionsW.menumenuItems
		menu $OptionsW.menumenuItems
		 
		set optionsMenu [list  cascade command radiobutton checkbutton separator]
		
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élément $optionsMenu {
		  set option [lindex $optionsMenu $j]
		 $OptionsW.menumenuItems add radiobutton	-label -$option	-variable menuOption -value $option \
			  -command " \$widtexte insert insert {-$option }" -background yellow
		  
		  incr j
		}
		
		set optionsMenu [list  activebackground activeborderwidth active foreground background  \
			borderwidth  cursor disableforeground font foreground height highlightbackground \
			postcommand  relief selectcolor tearoff tearoffcommand title ]
		
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élément $optionsMenu {
		  set option [lindex $optionsMenu $j]
		  $OptionsW.menumenu add radiobutton	-label -$option	-variable menuOption -value $option \
			  -command " \$widtexte insert insert {-$option }" -background yellow
		  
		  incr j
		}
		
		#cascade spéciale pour menu/type
		$OptionsW.menumenu add cascade	-label type	-menu $OptionsW.menumenu.type
		menu $OptionsW.menumenu.type -bg yellow -tearoff 0
		set optionsMenuType [list menubar tearoff normal ]
		set k 0
		# boucle de création des menus cascade menu/type
		foreach élémentType $optionsMenuType {
		  set option [lindex $optionsMenuType $k]
		  $OptionsW.menumenu.type add radiobutton	-label -$option	 -command " \$widtexte insert insert {-type $option} "
		  
		  incr k
		}
		
		
		# MENUBUTTON
		menu $OptionsW.menumenubutton -bg yellow
		set optionsMenuButton [list  activebackground activeforeground anchor background  \
			borderwidth  bitmap cursor direction disableforeground font foreground height highlightbackground highlightcolor\
			highlightthickness image indicatoron justify menu padx pady  relief state takefocus text textvariable underline  ]
		
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élément $optionsMenuButton {
		  if { ($j==13) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set option [lindex $optionsMenuButton $j]
		  $OptionsW.menumenubutton add radiobutton	-label -$option	-variable menuButtonOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  -columnbreak $optionColumnBreak
		  
		  incr j
		}
		
		# MESSAGE
		menu $OptionsW.menumessage -bg yellow
		set optionsMessage [list  anchor aspect background  borderwidth cursor font foreground highlightbackground highlightcolor\
			highlightthickness justify padx pady  relief state takefocus text textvariable width ]
		
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élément $optionsMessage {
		  if { ($j==9) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set option [lindex $optionsMessage $j]
		  $OptionsW.menumessage add radiobutton	-label -$option	-variable messageOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  -columnbreak $optionColumnBreak
		  
		  incr j
		}
		
		# RADIOBUTTON
		menu $OptionsW.menuradiobutton -bg yellow
		set optionsRadiobutton [list  activebackground activeforeground anchor background bitmap borderwidth command \
			cursor disableforeground font foreground height highlightbackground highlightcolor\
			highlightthickness image indicatoron justify overrelief padx pady  relief selectcolor selectimage \
			state takefocus text textvariable underline value variable width wraplenght]
		
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élément $optionsRadiobutton {
		  if { ($j==15) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set option [lindex $optionsRadiobutton $j]
		  $OptionsW.menuradiobutton add radiobutton	-label -$option	-variable radiobuttonOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  -columnbreak $optionColumnBreak
		  
		  incr j
		}
		
		# SCALE
		menu $OptionsW.menuscale -bg yellow
		set optionsScale [list  activebackground background bigincrement borderwidth command \
			cursor digits font foreground from highlightbackground highlightcolor\
			highlightthickness label length orient relief repeatdelay repeatinterval resolution \
			state takefocus troughcolor showvalue sliderlength sliderrelief tickinterval to variable width	]
		
		
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élément $optionsScale {
		  if { ($j==15) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set option [lindex $optionsScale $j]
		  $OptionsW.menuscale add radiobutton	-label -$option	-variable scaleOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  -columnbreak $optionColumnBreak
		  
		  incr j
		}
		
		# SPINBOX
		menu $OptionsW.menuspinbox -bg yellow
		set optionsSpinbox [list  activebackground background  borderwidth buttonbackground buttoncursor buttondownrelief buttonuprelief command \
			cursor disablebackground disableforeground  exportselection font foreground  format  from highlightbackground highlightcolor\
			highlightthickness image increment insertbackground insertborderwith insertofftime insertontime invalidcommand justify padx pady insertwidth  readonlybackground \
			relief repeatdelay repeatinterval 	selectbackground selectborderwidth selectforeground state takefocus text textvariable to underline validate  \
			validatecommand values width wrap xscrollcommand 	]
		
		
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élément $optionsSpinbox {
		  if { ($j==24) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set option [lindex $optionsSpinbox $j]
		  $OptionsW.menuspinbox add radiobutton	-label -$option	-variable spinboxOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  -columnbreak $optionColumnBreak
		  
		  incr j
		}
		
		# SCROLLBAR
		menu $OptionsW.menuscrollbar -bg yellow
		set optionsScrollbar [list  activebackground activerelief background  borderwidth command \
			cursor elementborderwidth highlightbackground highlightcolor\
			highlightthickness jump orient relief repeatdelay repeatinterval \
			takefocus troughcolor width	]
		
		
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élément $optionsScrollbar {
		  set option [lindex $optionsScrollbar $j]
		  $OptionsW.menuscrollbar add radiobutton	-label -$option	-variable scrollbarOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  
		  
		  incr j
		}
		
		# TEXT
		menu $OptionsW.menutext -bg yellow
		set optionsText [list background  borderwidth cursor exportselection font foreground height \
			highlightbackground highlightcolor	highlightthickness \
			insertontime insertofftime insertwidth padx pady relief selectbackground selectborderwidth selectforeground \
			setgrid spacing1 spacing2 spacing3 state tabs takefocus  width	xscrollcommand yscrollcommand ]
		
		
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élément $optionsText {
		  set option [lindex $optionsText $j]
		  $OptionsW.menutext add radiobutton	-label -$option	-variable textOption -value $option \
			  -command " \$widtexte insert insert {-$option }" 
		  incr j
		}
		
		#cascade spéciale pour text/wrap
		$OptionsW.menutext add cascade	-label wrap	-menu $OptionsW.menutext.wrap
		menu $OptionsW.menutext.wrap -bg yellow -tearoff 0
		set optionsTextWrap [list none char word ]
		set k 0
		# boucle de création des menus cascade text/wrap
		foreach élément $optionsTextWrap {
		  set option [lindex $optionsTextWrap $k]
		  $OptionsW.menutext.wrap add radiobutton	-label -$option	 -command " \$widtexte insert insert {-wrap $option} "
		  
		  incr k
		}
		
		# TOPLEVEL
		menu $OptionsW.menutoplevel -bg yellow
		set optionsToplevel [list background  borderwidth cursor class colormap container height \
			highlightbackground highlightcolor	highlightthickness \
			menu relief screen takefocus use visual width	]
		
		
		set j 0
		# boucle de création des menus cascade de "Widgets	"
		foreach élément $optionsToplevel {
		  set option [lindex $optionsToplevel $j]
		  $OptionsW.menutoplevel add radiobutton	-label -$option	-variable toplevelOption -value $option \-columnbreak $optionColumnBreak
		  
		  incr j
		}
		
		

#<defilementW> 
	$TK add cascade  -label "cmd defilement " -menu $TK.defilement		
 	menu $TK.defilement 

 $TK.defilement add cascade -label "cmd communes" -menu  $TK.defilement.commun
menu  $TK.defilement.commun

set motTk [list  {scan mark} {scan dragto} xview {xview moveto} {xview scroll ... units} {xview scroll ... pages} \
	yview {yview moveto} {yview scroll ... units} {yview scroll ... pages} ]
		set i 0
		# boucle de création du menu
		foreach élément $motTk {
		  if { ($i==16) || ($i==32) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set mot [lindex $motTk $i]
		$TK.defilement.commun	 add radiobutton 		-label " $mot"	 -background yellow -variable comTk -value $mot \
			  -command {$widtexte insert insert "$comTk "} -columnbreak $optionColumnBreak
		  incr i
		}
		
	$TK.defilement add cascade -label "cmd texte" -menu  $TK.defilement.texte
menu  $TK.defilement.texte
	$TK.defilement.texte	 add radiobutton 		-label " yview \[indice\]"	 -background yellow -variable comTk -value "yview ?indice? " \
			  -command {$widtexte insert insert $comTk} -columnbreak $optionColumnBreak
			$TK.defilement.texte	 add command -label "option yview" -background green -activebackground green
	$TK.defilement.texte	 add radiobutton 		-label " -pickplace"	 -background yellow -variable comTk -value "-pickplace " \
			  -command {$widtexte insert insert $comTk} -columnbreak $optionColumnBreak

$TK.defilement add cascade -label "cmd entry/lisbox" -menu  $TK.defilement.el
menu  $TK.defilement.el
	$TK.defilement.el	 add radiobutton 		-label " yview \[indice\]"	 -background yellow -variable comTk -value "yview ?indice? " \
			  -command {$widtexte insert insert $comTk} -columnbreak $optionColumnBreak
			
#<Tk_dessin>
 # sous rubrique du menu des widgets : "dessin"
		
		$TK add cascade  -label "canvas" -menu $TK.dessin		
 	menu $TK.dessin
		
	#menu dessin
		$TK.dessin add command -label canvas -background yellow -command {$widtexte insert insert "canvas "} -activebackground LemonChiffon 
		
		set commandes [list sous-commandes options recherche créer-items postscript ]
		set j 0
		# boucle de création de colonnes des menus cascade de "dessin"
		foreach élément $commandes {
		  if {$j==26} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set commande [lindex $commandes $j]
		  $TK.dessin add cascade	-label $commande	-menu $TK.dessin$commande
		menu $TK.dessin$commande		
		  incr j
		}
		
		#sous-commandes canvas
		set commandesCanvas [list addtag bbox bind canvasx canvasy coords create dchars delete dtag find focus gettags \
			icursor index insert itemcget itemconfigure lower move postscript raise scale scan {select adjust} {select clear} {select from} \
			{select item} {select to} type xview yview ]
		set j 0
		# boucle de création de colonnes des menus cascade de "Widgets	"
		foreach élémentCanvas $commandesCanvas {
		  if {$j==16} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set commande [lindex $commandesCanvas $j]
		  $TK.dessinsous-commandes add radiobutton	-label $commande	-variable canvasComd -value $commande \
			  -command " \$widtexte insert insert {$commande } "  -columnbreak $optionColumnBreak  -background yellow
		  
		  incr j
		}
		
	# Création des menus cascade de dessin
		# options dessin
		
		set optionsCanvas [list background borderwidth cursor height highlightbackground highlightcolor highlightthickness insertbackground insertborderwith \
			insertofftime insertontime insertwidth relief selectbackground selectborderwidth selectforeground takefocus width xscrollcommand yscrollcommand \
			closeenough confine scrollregion xscrollincrement yscrollincrement  ]
		set j 0
		# boucle de création des menus cascade de "options dessin	"
		foreach élémentCanvas $optionsCanvas {
		  if { ($j==12) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set option [lindex $optionsCanvas $j]
		 $TK.dessinoptions add radiobutton	-label -$option	-variable canvasOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  -columnbreak $optionColumnBreak -background yellow
		  
		  incr j
		}
			
	# Création des menus cascade de dessin
		# recherche dessin
		
		set optionsCanvas [list above all below closest enclosed overlapping withtag]
		set j 0
		# boucle de création des menus cascade de "dessin recherche"
		foreach élémentCanvas $optionsCanvas {
		  if { ($j==12) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set option [lindex $optionsCanvas $j]
		 $TK.dessinrecherche add radiobutton	-label -$option	-variable canvasOption -value $option \
			  -command " \$widtexte insert insert {$option }"  -columnbreak $optionColumnBreak -background yellow
		  
		  incr j
		}
		
	# Création des menus cascade de dessin
		# postscript dessin
		
		 $TK.dessinpostscript add cascade	-label "-colormode" -menu  $TK.dessinpostscript.colormode
			menu  $TK.dessinpostscript.colormode
				 $TK.dessinpostscript.colormode add command -label color  -background yellow -command  {$widtexte insert insert "-colormode color" }
				$TK.dessinpostscript.colormode add command -label grey  -background yellow -command  {$widtexte insert insert "-colormode grey" }
				$TK.dessinpostscript.colormode add command -label mono  -background yellow -command  {$widtexte insert insert "-colormode mono" }

		set optionsCanvas [list colormap file fontmap height pageanchor pageheight \
			pagewidth pagex pagey rotate width x y]
		set j 0
		# boucle de création des menus cascade de "dessin	"
		foreach élémentCanvas $optionsCanvas {		 
		set option [lindex $optionsCanvas $j]
		 $TK.dessinpostscript add radiobutton	-label -$option	-variable canvasOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  -background yellow
		  
		  incr j
		}
	
	# Création des menus cascade de dessin
		# créer-items  dessin
			# commandes items
		set optionsCanvas [list arc bitmap image line oval polygon rectangle text window ]
		set i 0
		set j 0
		# boucle de création des menus cascade de "dessin créer items	"
		foreach élémentCanvas $optionsCanvas {		 
		set option [lindex $optionsCanvas $j]
		 $TK.dessincréer-items add radiobutton	-label "create $option"	-variable canvasOption -value $option \
			  -command " \$widtexte insert insert {create $option }"  -background yellow -columnbreak $optionColumnBreak
		  incr j
		incr i
		}
		
		#en tête de colonne menu 
		
		  if { ($i==8 ) ||  ($i==9) } {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		$TK.dessincréer-items add command -label "options items" -background green -activebackground green -columnbreak $optionColumnBreak
		incr i
		
			
			#options des items		
		set optionsCanvas [list arc bitmap image line oval polygon rectangle text window ]
		set j 0
		# boucle de création des menus cascade de "dessin créer items	" 
		foreach élémentCanvas $optionsCanvas {		 
		set option [lindex $optionsCanvas $j]
		 $TK.dessincréer-items  add cascade -label "options $option" -menu  $TK.dessincréer-items$option
		  menu  $TK.dessincréer-items$option
		  incr j
		incr i
		}
		
		#<menus_options_items>
			# arc
		set optionsCanvas [list extent fill outline  outlinestipple start stipple tags width]
		set j 0
		# boucle de création des menus cascade de "dessin créer items	" 
		foreach élémentCanvas $optionsCanvas {		 
		set option [lindex $optionsCanvas $j]
		 $TK.dessincréer-itemsarc  add radiobutton	-label -$option	-variable canvasOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  -background yellow
		  incr j
		
		}
		
		 $TK.dessincréer-itemsarc  add cascade -label -style -menu $TK.dessincréer-itemsarcStyle
		menu $TK.dessincréer-itemsarcStyle
		$TK.dessincréer-itemsarcStyle add radiobutton	-label pieslice	-variable canvasOption -value pieslice \
			  -command " \$widtexte insert insert {-style pieslice}"  -background yellow
		$TK.dessincréer-itemsarcStyle add radiobutton	-label chord	-variable canvasOption -value chord \
			  -command " \$widtexte insert insert {-style chord}"  -background yellow
		$TK.dessincréer-itemsarcStyle add radiobutton	-label arc	-variable canvasOption -value arc \
			  -command " \$widtexte insert insert {-style arc}"  -background yellow
		
			# bitmap
		set optionsCanvas [list anchor background bitmap foreground tags]
		set j 0
		# boucle de création des menus cascade de "dessin créer items	" 
		foreach élémentCanvas $optionsCanvas {		 
		set option [lindex $optionsCanvas $j]
		 $TK.dessincréer-itemsbitmap  add radiobutton	-label -$option	-variable canvasOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  -background yellow
		  incr j
		
		}
		
		# image
		set optionsCanvas [list anchor image tags]
		set j 0
		# boucle de création des menus cascade de "dessin créer items	" 
		foreach élémentCanvas $optionsCanvas {		 
		set option [lindex $optionsCanvas $j]
		 $TK.dessincréer-itemsimage  add radiobutton	-label -$option	-variable canvasOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  -background yellow
		  incr j
		
		}
		
		# line
		set optionsCanvas [list fill smooth stipple splinesteps tags width arrowshape]
		set j 0
		# boucle de création des menus cascade de "dessin créer items	" 
		foreach élémentCanvas $optionsCanvas {		 
		set option [lindex $optionsCanvas $j]
		 $TK.dessincréer-itemsline  add radiobutton	-label -$option	-variable canvasOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  -background yellow
		  incr j
		
		}
		
		$TK.dessincréer-itemsline  add cascade -label "-arrow" -menu $TK.dessincréer-itemslineArrow
		menu $TK.dessincréer-itemslineArrow
		$TK.dessincréer-itemslineArrow add radiobutton	-label none	-variable canvasOption -value none \
			  -command " \$widtexte insert insert {-arrow none }"  -background yellow
		$TK.dessincréer-itemslineArrow add radiobutton	-label first	-variable canvasOption -value first \
			  -command " \$widtexte insert insert {-arrow first }"  -background yellow
		$TK.dessincréer-itemslineArrow add radiobutton	-label last	-variable canvasOption -value last \
			  -command " \$widtexte insert insert {-arrow last }"  -background yellow
		$TK.dessincréer-itemslineArrow add radiobutton	-label both	-variable canvasOption -value both \
			  -command " \$widtexte insert insert {-arrow both }"  -background yellow
			
		$TK.dessincréer-itemsline  add cascade -label "-joinstyle" -menu $TK.dessincréer-itemslineJoinstyle
		menu $TK.dessincréer-itemslineJoinstyle
		 $TK.dessincréer-itemslineJoinstyle add radiobutton	-label bevel	-variable canvasOption -value bevel \
			  -command " \$widtexte insert insert {-joinstyle bevel }"  -background yellow
		 $TK.dessincréer-itemslineJoinstyle add radiobutton	-label miter	-variable canvasOption -value miter \
			  -command " \$widtexte insert insert {-joinstyle miter }"  -background yellow
		 $TK.dessincréer-itemslineJoinstyle add radiobutton	-label round	-variable canvasOption -value round \
			  -command " \$widtexte insert insert {-joinstyle round }"  -background yellow
			
		# oval
		set optionsCanvas [list fill outline smooth splinesteps stipple tags width ]
		set j 0
		# boucle de création des menus cascade de "dessin créer items	" 
		foreach élémentCanvas $optionsCanvas {		 
		set option [lindex $optionsCanvas $j]
		 $TK.dessincréer-itemsoval  add radiobutton	-label -$option	-variable canvasOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  -background yellow
		  incr j
		
		}
		
		# polygon
		set optionsCanvas [list fill outline smooth splinesteps stipple tags width ]
		set j 0
		# boucle de création des menus cascade de "dessin créer items	" 
		foreach élémentCanvas $optionsCanvas {		 
		set option [lindex $optionsCanvas $j]
		 $TK.dessincréer-itemspolygon  add radiobutton	-label -$option	-variable canvasOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  -background yellow
		  incr j
		
		}
		
		# rectangle
		set optionsCanvas [list fill outline  stipple tags width ]
		set j 0
		# boucle de création des menus cascade de "dessin créer items	" 
		foreach élémentCanvas $optionsCanvas {		 
		set option [lindex $optionsCanvas $j]
		 $TK.dessincréer-itemsrectangle  add radiobutton	-label -$option	-variable canvasOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  -background yellow
		  incr j
		
		}
		
		# text
		set optionsCanvas [list anchor fill font stipple tags width ]
		set j 0
		# boucle de création des menus cascade de "dessin créer items	" 
		foreach élémentCanvas $optionsCanvas {		 
		set option [lindex $optionsCanvas $j]
		 $TK.dessincréer-itemstext  add radiobutton	-label -$option	-variable canvasOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  -background yellow
		  incr j
		
		}
		
		$TK.dessincréer-itemstext  add cascade -label "-justify" -menu $TK.dessincréer-itemstextJustify
		menu $TK.dessincréer-itemstextJustify
		 $TK.dessincréer-itemstextJustify add radiobutton	-label "left" 	-variable canvasOption -value left \
			  -command " \$widtexte insert insert {-justify left }"  -background yellow
		 $TK.dessincréer-itemstextJustify add radiobutton	-label "right" 	-variable canvasOption -value right \
			  -command " \$widtexte insert insert {-justify right }"  -background yellow
		 $TK.dessincréer-itemstextJustify add radiobutton	-label "center" -variable canvasOption -value center \
			  -command " \$widtexte insert insert {-justify center }"  -background yellow

	# window
		set optionsCanvas [list anchor height tags width window]
		set j 0
		# boucle de création des menus cascade de "dessin créer items	" 
		foreach élémentCanvas $optionsCanvas {		 
		set option [lindex $optionsCanvas $j]
		 $TK.dessincréer-itemswindow  add radiobutton	-label -$option	-variable canvasOption -value $option \
			  -command " \$widtexte insert insert {-$option }"  -background yellow
		  incr j
		
		}

#<WINFO>
 # sous rubrique du menu des widgets : "winfo"
		
		$TK add cascade  -label "winfo" -menu $TK.winfo		
 	menu $TK.winfo
		
	#menu winfo
				
		set commandes [list allmapped atom atomname cells children class colormapfull containing depth \
		exists fpixels geometry height id interps ismapped manager name parent pathname \
		pointerx pointery pointerxy pixels reqheight reqwidth rgb rootx rooty server screen sreencells screendepth \
		screenheight sreenmmheight screenmmwidth screenvisual screenwidth toplevel visual visualavailable \
		vrootheight vrootwith vrootx vrooty width x y]
		set j 0
		# boucle de création de colonnes des menus cascade de "winfo"
		foreach élément $commandes {
		  if {$j==24} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set commande [lindex $commandes $j]
		  $TK.winfo add radiobutton	-label "winfo $commande"	-variable winfoCom -value $commande \
			  -command " \$widtexte insert insert {winfo $commande }"  -background yellow -columnbreak $optionColumnBreak
		  incr j
		}
		
		# seule option (-displayof) : commune  à plusieurs sous-commandes de winfo
		$TK.winfo add cascade -label "option -displayof" -menu $TK.winfo.displayof  -background pink
		menu $TK.winfo.displayof
		$TK.winfo.displayof add command	-label "-dispayof disponible pour :" -background green
		set commandes [list atom atomname containing interps pathname ]
		set j 0
		# boucle de création de colonnes des menus cascade de "winfo displayof"
		foreach élément $commandes {
		   set commande [lindex $commandes $j]
		  $TK.winfo.displayof add radiobutton	-label "winfo $commande"	-variable winfoCom -value $commande \
			  -command " \$widtexte insert insert {-displayof }"  -background pink 
		  incr j
		}
		
#<WM>
 # sous rubrique du menu des widgets : "wm"
		
		$TK add cascade  -label "wm" -menu $TK.wm		
 	menu $TK.wm	

#menu wm
				
		set commandes [list aspect  client colormapwindows command deiconify frame geometry grid group iconbitmap iconify \
		iconmask iconname iconposition iconwindow maxsize minsize overrideredirect protocol resizable state title transcient withdraw]
		set j 0
		set i 0
		# boucle de création de colonnes des menus cascade de "winfo"
		foreach élément $commandes {
		  if {$j==24} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set commande [lindex $commandes $j]
		  $TK.wm add radiobutton	-label "wm $commande"	-variable winfoCom -value $commande \
			  -command " \$widtexte insert insert {wm $commande }"  -background yellow -columnbreak $optionColumnBreak
		  incr j
		incr i
		}
		
		set commandes [list focusmode1 positionfrom sizefrom  ]
		set j 0
		# boucle de création de colonnes des menus cascade de "winfo"
		foreach élément $commandes {
		  if {$j==24} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set commande [lindex $commandes $j]
		  $TK.wm add cascade -label "wm $commande" -menu $TK.wm.$commande
		 menu $TK.wm.$commande
		  incr j
		}
		
		#options des sous commande de wm
		
		$TK.wm.focusmode1 add radiobutton	-label "active"	-variable winfoCom -value -active \
			  -command " \$widtexte insert insert {wm focusmode1 ?...? active }"  -background yellow
		$TK.wm.focusmode1 add radiobutton	-label "passive"	-variable winfoCom -value -active \
			  -command " \$widtexte insert insert {wm focusmode1 ?...? passive }"  -background yellow
			
		$TK.wm.positionfrom add radiobutton	-label "program"	-variable winfoCom -value -active \
			  -command " \$widtexte insert insert {wm positionfrom ?...? program }"  -background yellow	
		$TK.wm.positionfrom add radiobutton	-label "user"	-variable winfoCom -value -active \
			  -command " \$widtexte insert insert {wm positionfrom ?...? user }"  -background yellow	
			
		$TK.wm.sizefrom add radiobutton	-label "program"	-variable winfoCom -value -active \
			  -command " \$widtexte insert insert {wm sizefrom ?...? program}"  -background yellow	
		$TK.wm.sizefrom add radiobutton	-label "user"	-variable winfoCom -value -active \
			  -command " \$widtexte insert insert {wm sizefrom ?...? user}"  -background yellow	
			
		$TK.wm.sizefrom add radiobutton	-label "active"	-variable winfoCom -value -active \
			  -command " \$widtexte insert insert {wm sizefrom ?...? program}"  -background yellow	

#<interfaceTK> 


$TK add cascade  -label "interface Tk" -menu $TK.interface			
 	menu $TK.interface 
	set i 0
	
	$TK.interface	 add command 		-label " clipboard"	 -command " \$widtexte insert insert {clipboard}"  -background yellow	
		  incr i


set motTk [list  grab option selection tkwait]
		set j 0
		# boucle de création du menu
		foreach élément $motTk {
		set mot [lindex $motTk $j]
		$TK.interface	 add cascade 		-label " $mot"	 -menu $TK.interface.$mot
		menu $TK.interface.$mot
		incr j
		  incr i
		}
		
		# sous commandes de grab
		set optionTk [list  current release set  status]
		set k 0
		# boucle de création du menu
		foreach élément $optionTk {
		set mot [lindex $optionTk $k]
		$TK.interface.grab	 add radiobutton	-label "grab $mot"	-variable winfoCom -value grab$mot \
			  -command " \$widtexte insert insert {grab  $mot }"  -background yellow	
		  incr k
		}
		
		# sous commandes de Option
		set optionTk [list  add clear get readfile]
		set k 0
		# boucle de création du menu
		foreach élément $optionTk {
		set mot [lindex $optionTk $k]
		$TK.interface.option	 add radiobutton	-label "option $mot"	-variable winfoCom -value grab$mot \
			  -command " \$widtexte insert insert {option  $mot }"  -background yellow	
		  incr k
		}
		
		# sous commandes de selection
		set optionTk [list   clear get handle own]
		set k 0
		# boucle de création du menu
		foreach élément $optionTk {
		set mot [lindex $optionTk $k]
		$TK.interface.selection	 add radiobutton	-label "selection $mot"	-variable winfoCom -value selection$mot \
			  -command " \$widtexte insert insert {selection $mot }"  -background yellow	
		  incr k
		}
		
		# sous commandes de tkwait
		set optionTk [list   variable visibility window]
		set k 0
		# boucle de création du menu
		foreach élément $optionTk {
		set mot [lindex $optionTk $k]
		$TK.interface.tkwait add radiobutton	-label "tkwait $mot"	-variable winfoCom -value tkwait$mot \
			  -command " \$widtexte insert insert {tkwait $mot }"  -background yellow	
		  incr k
		}
		
		
	set j 0
	 set motTk [list  bell  destroy focus grid pack place send tkappname tkscaling ]
	# boucle de création du menu
		foreach élément $motTk {
		set mot [lindex $motTk $j]
		$TK.interface add radiobutton	-label "$mot"	-variable winfoCom -value $mot \
 			  -command " \$widtexte insert insert {$mot }"  -background yellow 
		 incr i
		incr j
		}
	
	 if { ($i==14) || ($i==15) || ($i==16)} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
	$TK.interface	 add command -background green -activebackground green -label options -columnbreak $optionColumnBreak
	incr i
	
		
		
	#<Options_interfaceTK>

  		menu $TK.options 
		
		set motTk [list  clipboard grab_set - selection - bell - focus grid pack place send - tkscaling ]
		set j 0
		# boucle de création du menu
		menu $TK.interface.vide
		foreach élément $motTk {		
		  set mot [lindex $motTk $j]
		if {[string compare $mot "-"] ==0 } {
		$TK.interface  add cascade -label $mot -menu $TK.interface.vide
		} else {	
		$TK.interface  add cascad	-label "options $mot"	 -menu $TK.options.$mot		 
		  menu $TK.options.$mot }
		  incr j
		  incr i
		}
		
		#<grab>
			$TK.options.grab_set add command  -background  yellow -label -global -command {$widtexte insert insert "-global "}
		
		#<selection>
		# options des sous commandes de selection
		set optionTk [list clear get handle own]
		set k 0
		# boucle de création du menu
		foreach élément $optionTk {
		set mot [lindex $optionTk $k]
		$TK.options.selection	 add cascade -label "options selection $mot" -menu $TK.options.selection.options$mot
		menu $TK.options.selection.options$mot
		  incr k
		}
		
					#options selection clear
			$TK.options.selection.optionsclear add command  -background  yellow -label -displayoff -command {$widtexte insert insert "-displayoff "}
			$TK.options.selection.optionsclear add command  -background  yellow -label -selection -command {$widtexte insert insert "-selection "}
		
		#options selection get
			$TK.options.selection.optionsget add command  -background  yellow -label -displayoff -command {$widtexte insert insert "-displayoff "}
			$TK.options.selection.optionsget add command  -background  yellow -label -selection -command {$widtexte insert insert "-selection "}
		
		#options selection handle
			$TK.options.selection.optionshandle add command  -background  yellow -label -selection -command {$widtexte insert insert "-selection "}
			$TK.options.selection.optionshandle add command  -background  yellow -label -type -command {$widtexte insert insert "-type "}
			$TK.options.selection.optionshandle add command  -background  yellow -label -format -command {$widtexte insert insert "-format "}

		#options selection own
			$TK.options.selection.optionsown add command  -background  yellow -label -displayoff -command {$widtexte insert insert "-displayoff "}
			$TK.options.selection.optionsown add command  -background  yellow -label -selection -command {$widtexte insert insert "-selection "}
			$TK.options.selection.optionsown add command  -background  yellow -label -command -command {$widtexte insert insert "-command "}

		#<bell>
			$TK.options.bell add command  -background  yellow -label displayoff -command {$widtexte insert insert "-displayoff "}
		#<clipboard>		
 			$TK.options.clipboard add command  -background  yellow -label -displayoff -command {$widtexte insert insert "-displayoff "}
 			$TK.options.clipboard add command  -background  yellow -label -format -command {$widtexte insert insert "-format "}
 			$TK.options.clipboard add command  -background  yellow -label -type -command {$widtexte insert insert "-type "}

		#<focus>
 			$TK.options.focus add command  -background  yellow -label -displayoff -command {$widtexte insert insert "-displayoff "}
 			$TK.options.focus add command  -background  yellow -label -force -command {$widtexte insert insert "-force "}
 			$TK.options.focus add command  -background  yellow -label -lastfor -command {$widtexte insert insert "-lastfor "}


		#<pack> 
			# side 
			$TK.options.pack add cascade -label -side -menu $TK.options.pack.side
			menu $TK.options.pack.side
			$TK.options.pack.side add radiobutton -background yellow -variable opt_side -label "top" -command {$widtexte insert insert "-side top "}
			$TK.options.pack.side add radiobutton -background yellow -variable opt_side -label "bottom" -command {$widtexte insert insert "-side bottom "}
			$TK.options.pack.side add radiobutton -background yellow -variable opt_side -label "left" -command {$widtexte insert insert "-side left "}
			$TK.options.pack.side add radiobutton -background yellow -variable opt_side -label "right" -command {$widtexte insert insert "-side right "}
			
			#expand 
			$TK.options.pack add cascade -label -expand -menu $TK.options.pack.expand
			menu $TK.options.pack.expand
			$TK.options.pack.expand add radiobutton -background yellow -variable opt_expand -label "true" -command {$widtexte insert insert "-expand true "}
			$TK.options.pack.expand add radiobutton -background yellow -variable opt_expand -label "false" -command {$widtexte insert insert "-expand false "}
			
			#fill 
			$TK.options.pack add cascade -label -fill -menu $TK.options.pack.fill
			menu $TK.options.pack.fill
			$TK.options.pack.fill add radiobutton -background yellow -variable opt_fill -label "both" -command {$widtexte insert insert "-fill both "}
			$TK.options.pack.fill add radiobutton -background yellow -variable opt_fill -label "x" -command {$widtexte insert insert "-fill x "}
			$TK.options.pack.fill add radiobutton -background yellow -variable opt_fill -label "y" -command {$widtexte insert insert "-fill y "}
			
			#anchor 
			$TK.options.pack add cascade -label -anchor -menu $TK.options.pack.anchor
			menu $TK.options.pack.anchor
			$TK.options.pack.anchor add radiobutton -background yellow -variable opt_anchor -label "center" -command {$widtexte insert insert "-anchor center "}
			$TK.options.pack.anchor add radiobutton -background yellow -variable opt_anchor -label "n" -command {$widtexte insert insert "-anchor n "}
			$TK.options.pack.anchor add radiobutton -background yellow -variable opt_anchor -label "ne" -command {$widtexte insert insert "-anchor ne "}
			$TK.options.pack.anchor add radiobutton -background yellow -variable opt_anchor -label "e" -command {$widtexte insert insert "-anchor e "}
			$TK.options.pack.anchor add radiobutton -background yellow -variable opt_anchor -label "se " -command {$widtexte insert insert "-anchor se "}
			$TK.options.pack.anchor add radiobutton -background yellow -variable opt_anchor -label "sw " -command {$widtexte insert insert "-anchor sw "}
			$TK.options.pack.anchor add radiobutton -background yellow -variable opt_anchor -label "w " -command {$widtexte insert insert "-anchor w "}
			$TK.options.pack.anchor add radiobutton -background yellow -variable opt_anchor -label "nw " -command {$widtexte insert insert "-anchor nw "}
			
			# padx & pady -- ipadx & ipady
			$TK.options.pack add command  -background  yellow -label -padx -command {$widtexte insert insert "-padx "}
			$TK.options.pack add command  -background  yellow -label -pady -command {$widtexte insert insert "-pady "}
			$TK.options.pack add command  -background  yellow -label -ipadx -command {$widtexte insert insert "-ipadx "}
			$TK.options.pack add command  -background  yellow -label -ipady -command {$widtexte insert insert "-ipady "}
			
			# after & before 
			$TK.options.pack add command  -background  yellow -label -after -command {$widtexte insert insert "-after "}
			$TK.options.pack add command  -background  yellow -label -before -command {$widtexte insert insert "-before "}
			
		#<grid>
			# sticky
			$TK.options.grid add cascade -label -sticky -menu $TK.options.grid.sticky
			menu $TK.options.grid.sticky
			$TK.options.grid.sticky add radiobutton -background yellow -variable opt_sticky -label "center {}" -command {$widtexte insert insert "-stiky {} "}
			$TK.options.grid.sticky add radiobutton -background yellow -variable opt_sticky -label "ns" -command {$widtexte insert insert "-stiky ns "}
			$TK.options.grid.sticky add radiobutton -background yellow -variable opt_sticky -label "ew" -command {$widtexte insert insert "-stiky ew "}
	
			# padx & pady -- ipadx & ipady
			$TK.options.grid add command  -background  yellow -label -padx -command {$widtexte insert insert "-padx "}
			$TK.options.grid add command  -background  yellow -label -pady -command {$widtexte insert insert "-pady "}
			$TK.options.grid add command  -background  yellow -label -ipadx -command {$widtexte insert insert "-ipadx "}
			$TK.options.grid add command  -background  yellow -label -ipady -command {$widtexte insert insert "-ipady "}
			
			#columnspan - rowspan - column - row - in - 
			$TK.options.grid add command  -background  yellow -label -columnspan -command {$widtexte insert insert "-columnspan "}
			$TK.options.grid add command  -background  yellow -label -rowspan -command {$widtexte insert insert "-rowspan "}
			$TK.options.grid add command  -background  yellow -label -column -command {$widtexte insert insert "-column "}
			$TK.options.grid add command  -background  yellow -label -row -command {$widtexte insert insert "-row "}
			$TK.options.grid add command  -background  yellow -label -in -command {$widtexte insert insert "-in "}
			
		#<place>
			#anchor
			$TK.options.place add cascade -label -anchor -menu $TK.options.place.anchor
			menu $TK.options.place.anchor
			$TK.options.place.anchor add radiobutton -background yellow -variable opt_anchor -label "center" -command {$widtexte insert insert "-anchor center "}
			$TK.options.place.anchor add radiobutton -background yellow -variable opt_anchor -label "n" -command {$widtexte insert insert "-anchor n "}
			$TK.options.place.anchor add radiobutton -background yellow -variable opt_anchor -label "ne" -command {$widtexte insert insert "-anchor ne "}
			$TK.options.place.anchor add radiobutton -background yellow -variable opt_anchor -label "e" -command {$widtexte insert insert "-anchor e "}
			$TK.options.place.anchor add radiobutton -background yellow -variable opt_anchor -label "se " -command {$widtexte insert insert "-anchor se "}
			$TK.options.place.anchor add radiobutton -background yellow -variable opt_anchor -label "sw " -command {$widtexte insert insert "-anchor sw "}
			$TK.options.place.anchor add radiobutton -background yellow -variable opt_anchor -label "w " -command {$widtexte insert insert "-anchor w "}
			$TK.options.place.anchor add radiobutton -background yellow -variable opt_anchor -label "nw " -command {$widtexte insert insert "-anchor nw "}
			
			#bordermode
			$TK.options.place add cascade -label -bordermode -menu $TK.options.place.bordermode
			menu $TK.options.place.bordermode
			$TK.options.place.bordermode add radiobutton -background yellow -variable opt_bordermode -label "inside" -command {$widtexte insert insert "-bordermode inside "}
			$TK.options.place.bordermode add radiobutton -background yellow -variable opt_bordermode -label "outside" -command {$widtexte insert insert "-bordermode outside "}
			$TK.options.place.bordermode add radiobutton -background yellow -variable opt_bordermode -label "ignore" -command {$widtexte insert insert "-bordermode ignore "}

			#x - y- height - width - relheight - relwidth - relx - rely - in 
			$TK.options.place add command  -background  yellow -label -x -command {$widtexte insert insert "-x "}
			$TK.options.place add command  -background  yellow -label -y -command {$widtexte insert insert "-y "}
			$TK.options.place add command  -background  yellow -label -height -command {$widtexte insert insert "-height "}
			$TK.options.place add command  -background  yellow -label -width -command {$widtexte insert insert "-width "}
			$TK.options.place add command  -background  yellow -label -relheight -command {$widtexte insert insert "-relheight "}
			$TK.options.place add command  -background  yellow -label -relwidth -command {$widtexte insert insert "-relwidth "}
			$TK.options.place add command  -background  yellow -label -relx -command {$widtexte insert insert "-relx "}
			$TK.options.place add command  -background  yellow -label -rely -command {$widtexte insert insert "-rely "}
			$TK.options.place add command  -background  yellow -label -in -command {$widtexte insert insert "-in "}
		
		#options selection send
			$TK.options.send add command  -background  yellow -label -displayoff -command {$widtexte insert insert "-displayoff "}
			$TK.options.send add command  -background  yellow -label -async -command {$widtexte insert insert "-async "}
			
		#options selection tkscaling
			$TK.options.tkscaling add command  -background  yellow -label -displayoff -command {$widtexte insert insert "-displayoff "}

		
			
#<bind_et_evenements> 
	$TK add cascade  -label "évènements" -menu $TK.evenement				
 	menu $TK.evenement 

		set motTk [list  bind bindtags  ]
		set i 0
		# boucle de création du menu
		foreach élément $motTk {
		  set mot [lindex $motTk $i]
		$TK.evenement	 add radiobutton 		-label " $mot"	 -background yellow -variable comTk -value $mot \
			  -command {$widtexte insert insert "$comTk "} 
		  incr i
		}
		
			$TK.evenement	 add cascade -label event -menu $TK.evenement.event
			menu $TK.evenement.event
			set motTk [list  add delete generate info ]
			set j 0
			# boucle de création du menu
			foreach élément $motTk {
			set mot [lindex $motTk $j]
			$TK.evenement.event	 add radiobutton 		-label "event $mot"	 -background yellow -variable comTk -value $mot \
			  -command {$widtexte insert insert "event $comTk "} 
			incr j
			}
		
			$TK.evenement.event	 add cascade -label "option generate -when"  -menu $TK.evenement.event.optionGenerate
				menu $TK.evenement.event.optionGenerate
			set motTk [list  now tail head mark ]
			set j 0
			# boucle de création du menu
			foreach élément $motTk {
		  	set mot [lindex $motTk $j]
			$TK.evenement.event.optionGenerate	 add radiobutton 		-label "$mot"	 -background yellow -variable comTk -value $mot \
			  -command {$widtexte insert insert "-when $comTk "} 
		  	incr j
			}
		
		$TK.evenement	 add cascade -label Modificateurs -menu $TK.evenement.modificateurs -background Green 
		menu $TK.evenement.modificateurs
		incr i
		
			set motTk [list  Any Control Shift Lock Double Triple Button1  Button2 Button3 Button4Button5 Meta Mod1 Mod2 Mod3 Mod 4 Mod5 ]
			set j 0
			# boucle de création du menu
			foreach élément $motTk {
			set mot [lindex $motTk $j]
			$TK.evenement.modificateurs	 add radiobutton 		-label "$mot"	 -background yellow -variable comTk -value $mot \
			  -command {$widtexte insert insert "$comTk "} 
		  	incr j
		}
		
		$TK.evenement	 add cascade -label Types -menu $TK.evenement.types -background Green 
		menu $TK.evenement.types
		incr i
		
			set motTk [list  Activate ButtonPress ButtonRelease Circulate Colormap Configure Deactivate Destroy\
			Enter Expose FocusIn FocusOut Gravity KeyPress KeyRelease Motion Leave Map \
			Property Reparent Unmap Visibility ]
			set j 0
			# boucle de création du menu
			foreach élément $motTk {
			set mot [lindex $motTk $j]
			$TK.evenement.types	 add radiobutton 		-label "$mot"	 -background yellow -variable comTk -value $mot \
			  -command {$widtexte insert insert "$comTk "} 
		  	incr j
		}
		
		# interface gavarnie : fin
		#oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
		
		#<MENUcolor>
		
		$Color add cascade	-label Nom	-menu "$Color.menuNom"
		
		menu $Color.menuNom -bg yellow
		set nomCouleur [list AliceBlue AntiqueWhite aquamarine azure beige bisque black BlueViolet brown chartreuse chocolate coral cyan DarkCyan\
			DarkGreen DarkGrey DarkRed DarkSalmon DeepPink DeepSkyBlue ForestGreen gray gray100 green GreenYellow\
			HotPink ivory  lavender LemonChiffon LightBlue LimeGreen maroon orange orchid pink plum purple RosyBrown salmon sienna\
			SteelBlue tan tomato turquoise violet white wheat yellow YellowGreen  ]
		set j 0
		# boucle de création de colonnes des menus cascade de "Widgets	"
		foreach élémentCouleur $nomCouleur {
		  if {$j==24} {set optionColumnBreak 1
		  } else {set optionColumnBreak 0 }
		  set commande [lindex $nomCouleur $j]
		  $Color.menuNom add radiobutton	-label $commande	-variable textComd -value $commande \
			  -command " \$widtexte insert insert {$commande } "  -columnbreak $optionColumnBreak
		  
		  incr j
		}
		
		$Color add command	-label Choix	 -command {$widtexte insert insert "[ tk_chooseColor ] " ;$widtexte insert insert " "}
		
		
	#<MENUtampon>
		$Tampon add command	-label "Vider tampon"	-command {.menubar.mTampon add separator ; .menubar.mTampon delete 2 end}  -foreground red
		
	#<MENU_MARQUES>
 		$Marques add command -label "Insérer une marque" -command {Tikeditor::ChoixMarque $widtexte}
		$Marques add command -label "Supprimer une marque" -command {Tikeditor::SupprimerMarque $widtexte}
		$Marques add cascade -menu $Marques.choix -label "Optionsde recherche"
		
		menu $Marques.choix
		$Marques.choix add radiobutton -label "toutes marques (all)" -variable choixMarque -value "-all"
		$Marques.choix add radiobutton -label "signets (tag)" -variable choixMarque -value "-tag"
		$Marques.choix add radiobutton -label "images image)" -variable choixMarque -value "-image"
		$Marques.choix add radiobutton -label "commandes (command)" -variable choixMarque -value "-command"
		$Marques.choix add radiobutton -label "marques (mark)" -variable choixMarque -value "-mark"
		$Marques.choix add radiobutton -label "textes (text)" -variable choixMarque -value "-text"
		$Marques.choix add radiobutton -label "fenêtres (window)" -variable choixMarque -value "-window"
		
	
		
	#<BARREetat> BARRE D'ETAT
		
		frame .fetat -bd 2 -relief flat
		pack .fetat -fill both -before .ftext
		
		
		
		label .fetat.fichier -anchor w -relief sunken -foreground red -bg aquamarine -width 17 -font {courrier 8} -text $choix 
		label .fetat.message -anchor w -relief sunken -foreground red -bg aquamarine  -width 28 -font {courrier 8}
		label .fetat.nblignes -width 22 -anchor e -relief sunken -bg aquamarine -font {courrier 8}
		label .fetat.taille  -width 12 -anchor e -relief sunken -bg aquamarine -font {courrier 8}
		
		pack .fetat.fichier -ipadx 8 -side left -fill x -expand true
		pack .fetat.message -ipadx 8 -side left -fill x -expand true
		pack .fetat.nblignes -ipadx 8 -side left
		pack .fetat.taille -ipadx 8 -side right
		
		if { ! [ string compare $tcl_platform(platform) "unix" ] } {
		  bind Text <Control-v> {}
		}
		
		bind . <Control-o> { Tikeditor::Ouvrir $widtexte}
		bind . <Control-s> { Tikeditor::Sauvegarder $widtexte 0 }
		bind . <Shift-Control-Key-S> { Tikeditor::Sauvegarder $widtexte 1 }
		bind . <Control-Key-f> { Tikeditor::Fermer $widtexte }
		bind . <Control-q> Tikeditor::Quitter
		
		bind . <Control-a> { Tikeditor::ToutSelectionner $widtexte}
		
		bind . <Control-t> { Tikeditor::EvaluationTcl $widtexte}
		#bind . <Control-2> {Tikeditor::CommenterSelection $widtexte1}
		
		
		bind . <Control-i> {Tikeditor::Indenter $widtexte }
		bind . <Control-C>	 Tikeditor::Couper
		bind $widtexte <3> { tk_popup .menubar.mEditer %X %Y } 
		bind . <KeyPress-Escape> {Tikeditor::EscapePermute $widtexte}
		
		bind . <KeyPress-space>  { Tikeditor::Coloration $widtexte 0 ; Tikeditor::NbLignes $widtexte .fetat.nblignes	}
		bind . <Control-Shift_L> { Tikeditor::Coloration $widtexte 0 ; Tikeditor::NbLignes $widtexte .fetat.nblignes	}
		bind . <Control-Shift_R> { Tikeditor::Coloration $widtexte 0 ; Tikeditor::NbLignes $widtexte .fetat.nblignes	}
		bind . <KeyPress-Return> { Tikeditor::IndentationAuto $widtexte ; Tikeditor::NbLignes $widtexte .fetat.nblignes}
		
		
	  }
	  
proc Tikeditor::AuSujetDe { var } {
		variable application
		variable ausujetdeDC
		variable ausujetdeJLD
		variable ausujetdeDM
		variable  ausujetdeMSDZ 
		variable ausujetdeJN
		variable ausujetdeSUCF
		
		if [winfo exists .aPropos] {destroy .aPropos}
		toplevel .aPropos
		wm title .aPropos "Au sujet de $application"
		wm resizable .aPropos false false
		frame .aPropos.f -relief groove -border 2 -bg bisque
		pack .aPropos.f -padx 4 -pady 4 -ipadx 4 -ipady 4
		
		set i 0
		foreach item $var {
		  label .aPropos.f.$i -text $item -bg bisque 
		  pack .aPropos.f.$i -anchor w
		  incr i
		}
		
		bind .aPropos  <Enter> { destroy .aPropos  }
		set x0 [ expr ( [winfo width .] - [winfo reqwidth .aPropos ] ) / 2 ]
		set y0 [ expr ( [winfo height .] - [winfo reqheight .aPropos ] ) / 2 ]
		wm geometry .aPropos  +[ expr [winfo x .] + $x0 ]+[ expr [winfo y .] + 30 ]
		
	  }
	  
	  # dévellopement de l'aide : affichage du fichier "aide_tikeditor.txt" dans un toplevel
	
proc Tikeditor::Aide { var } {
		variable application
		variable version
		global Chemin
		
		
		if [winfo exists .aide] {	destroy .aide}
		toplevel .aide
		bell -displayof .aide
		wm title .aide "Aide $application $version"
		wm resizable .aide true true


#<interface>

frame .aide.f
	pack .aide.f -side top
	label .aide.f.labelFonte -text " Taille des caractères "
	
	button .aide.f.plus -text " + " -command { Tikeditor::PolicePlusAide .aide.fenetreHtm}
	  button .aide.f.moins -text " _ " -command { Tikeditor::PoliceMoinsAide .aide.fenetreHtm}
	  pack .aide.f.labelFonte .aide.f.plus .aide.f.moins -side left


text .aide.sommaire -background lavender  -foreground BlueViolet -width 18 -height 15 -cursor arrow  -font  {helvetica 12}
text .aide.fenetreHtm -height 15 -font  {times 10}	-width 50 -yscrollcommand " .aide.y set"
scrollbar .aide.y -orient vertical -command {.aide.fenetreHtm yview} 
pack .aide.sommaire .aide.fenetreHtm   -expand true	-fill y  -side left 
pack .aide.y  -expand true  -fill y  -side left

wm resizable .aide false true
	
#<tags_sommaire>
foreach tag {t0 t1 t2 t3 t4 t5 t6 t7} {
	.aide.sommaire tag bind $tag <Any-Enter> ".aide.sommaire tag configure $tag -foreground white -background  RosyBrown " 
	.aide.sommaire tag bind $tag <Any-Leave> ".aide.sommaire tag configure $tag -foreground BlueViolet  -background  lavender"
}

#<insertion_sommaire>
.aide.sommaire insert end "Aide \n" t0
.aide.sommaire  insert end "Généralités \n" t1
.aide.sommaire  insert end "Menus \n" t2
.aide.sommaire  insert end "Menus classiques\n" t3
.aide.sommaire  insert end "Menus spéciaux\n" t4
.aide.sommaire  insert end "Icônes \n" t5
.aide.sommaire  insert end "Touches magiques\n" t6
.aide.sommaire  insert end "Marques\n" t7
.aide.sommaire  insert end "Masques\n" t8


#<liens_tags_fichiersHtml>

set fichierHtml [ open  [file join $Chemin(rel) aide accueil.htm ] ]
set aideAffiche [ read -nonewline $fichierHtml ]
close $fichierHtml

HMinit_win .aide.fenetreHtm ;	HMparse_html $aideAffiche "HMrender .aide.fenetreHtm "

.aide.sommaire  tag bind t0 <1> { set fichierHtml [ open  [file join $Chemin(rel) aide accueil.htm ] ]
set aideAffiche [ read -nonewline $fichierHtml ]
close $fichierHtml
HMreset_win .aide.fenetreHtm ;  HMinit_win .aide.fenetreHtm ;	HMparse_html $aideAffiche "HMrender .aide.fenetreHtm " }

.aide.sommaire  tag bind t1 <1> { set fichierHtml [ open  [file join $Chemin(rel) aide generalites.htm ] ]
set aideAffiche [ read -nonewline $fichierHtml ]
close $fichierHtml
 HMreset_win .aide.fenetreHtm  ;  HMinit_win .aide.fenetreHtm ;	HMparse_html $aideAffiche "HMrender .aide.fenetreHtm " }

.aide.sommaire  tag bind t2 <1> { set fichierHtml [ open  [file join $Chemin(rel) aide menus.htm ] ]
set aideAffiche [ read -nonewline $fichierHtml ]
close $fichierHtml
HMreset_win .aide.fenetreHtm  ;  HMinit_win .aide.fenetreHtm  ;	HMparse_html $aideAffiche "HMrender .aide.fenetreHtm "}

.aide.sommaire  tag bind t3 <1> {set fichierHtml [ open  [file join $Chemin(rel) aide menus_classiques.htm ] ]
set aideAffiche [ read -nonewline $fichierHtml ]
close $fichierHtml
 HMreset_win .aide.fenetreHtm  ;  HMinit_win .aide.fenetreHtm  ;	HMparse_html $aideAffiche "HMrender .aide.fenetreHtm "}

.aide.sommaire  tag bind t4 <1> { set fichierHtml [ open  [file join $Chemin(rel) aide menus_programmation.htm ] ]
set aideAffiche [ read -nonewline $fichierHtml ]
close $fichierHtml
HMreset_win .aide.fenetreHtm ;  HMinit_win .aide.fenetreHtm  ;	HMparse_html $aideAffiche "HMrender .aide.fenetreHtm "}


.aide.sommaire  tag bind t5 <1> {set fichierHtml [ open  [file join $Chemin(rel) aide icones.htm ] ]
set aideAffiche [ read -nonewline $fichierHtml ]
close $fichierHtml
 HMreset_win .aide.fenetreHtm  ;  HMinit_win .aide.fenetreHtm  ;	HMparse_html $aideAffiche "HMrender .aide.fenetreHtm " }

.aide.sommaire  tag bind t6 <1> {set fichierHtml [ open  [file join $Chemin(rel) aide touchesMagiques.htm ] ]
set aideAffiche [ read -nonewline $fichierHtml ]
close $fichierHtml
 HMreset_win .aide.fenetreHtm  ;  HMinit_win .aide.fenetreHtm  ;	HMparse_html $aideAffiche "HMrender .aide.fenetreHtm " }

.aide.sommaire  tag bind t7 <1> {set fichierHtml [ open  [file join $Chemin(rel) aide marques.htm ] ]
set aideAffiche [ read -nonewline $fichierHtml ]
close $fichierHtml
 HMreset_win .aide.fenetreHtm  ;  HMinit_win .aide.fenetreHtm  ;	HMparse_html $aideAffiche "HMrender .aide.fenetreHtm " }

.aide.sommaire  tag bind t8 <1> {set fichierHtml [ open  [file join $Chemin(rel) aide masque.htm ] ]
set aideAffiche [ read -nonewline $fichierHtml ]
close $fichierHtml
 HMreset_win .aide.fenetreHtm  ;  HMinit_win .aide.fenetreHtm  ;	HMparse_html $aideAffiche "HMrender .aide.fenetreHtm " }

bind .aide.sommaire  <3> { destroy .aide}
bind  .aide.fenetreHtm  <3> { destroy .aide}

		return 0
	  }
		
	
	
############################################################################	
#<Routines_html>
#
# ces procédures sont issues de l'exemple fourni par l'auteur des routines d'affichage Html.2
# les commentaires en anglais sont les originaux. 
#
############################################################################

# Go render a page.  We have to make sure we don't render one page while
# still rendering the previous one.  If we get here from a recursive 
# invocation of the event loop, cancel whatever we were rendering when
# we were called.
# If we have a fragment name, try to go there.

proc render {file} {
	global HM.aideTcl.texte Url
	global Running message

	set fragment ""
	regexp {([^#]*)#(.+)} $file dummy file fragment
	if {$file == "" && $fragment != ""} {
		HMgoto .aideTcl.texte  $fragment
		return
	}
	HMreset_win .aideTcl.texte
	set Running "EN COURS"
	set message "AFFICHAGE DE $file"
	update idletasks
	if {$fragment != ""} {
		HMgoto .aideTcl.texte $fragment
	}
	set Url $file
	HMparse_html [get_html $file] {HMrender .aideTcl.texte}
	set Running PRËT
	HMset_state .aideTcl.texte -stop 1	;# stop rendering previous page if buzy 
	set message ""
}

# given a file name, return its html, or invent some html if the file can't
# be opened.

proc get_html {file} {
	global Home
		
	if {[catch {set fd [open $file]} msg]} {
		return "
			<title>Bad file $file</title>
			<h1>Error reading $file</h1><p>
			$msg<hr>
			<a href=$Home>Go home</a>
		"
	}
	set result [read $fd]
	close $fd
	return $result
}

# Override the library link-callback routine for the sample app.
# It only handles the simple cases.

proc HMlink_callback {win href} {
	global Url
	
	if {[string match #* $href]} {
		render $href
		return
	}
	if {[string match /* $href]} {
		set Url $href
	} else {
		set Url [file dirname $Url]/$href
	}
	update
	render $Url
}


# downloading fonts can take a long time.  We'll override the default
# font-setting routine to permit better user feedback on fonts.  We'll
# keep our own list of installed fonts on the side, to guess when delays
# are likely

proc HMset_font {win tag font} {
	global message Fonts
	if {![info exists Fonts($font)]} {
		set Fonts($font) 1
	set message "downloading font $font"
		update
		
	}
	set message ""
	catch {$win tag configure $tag -font $font} message
	
}

# Supply an image callback function
# Read in an image if we don't already have one
# callback to library for display

proc HMset_image {win handle src} {
	global Url message
	if {[string match /* $src]} {
		set image $src
	} else {
		set image [file dirname $Url]/$src
	}
	set message "fetching image $image"
	update
	if {[string first " $image " " [image names] "] >= 0} {
		HMgot_image $handle $image
	} else {
		set type photo
		if {[file extension $image] == ".bmp"} {set type bitmap}
		catch {image create $type $image -file $image} image
		HMgot_image $handle $image
	}
}

# Handle base tags.  This breaks if more than 1 base tag is in the document

proc HMtag_base {win param text} {
	global Url
	upvar #0 HM$win var
	HMextract_param $param href Url
}

# Lets invent a new HTML tag, just for fun.
# Change the color of the text. Use html tags of the form:
# <color value=blue> ... </color>
# We can invent a new tag for the display stack.  If it starts with "T"
# it will automatically get mapped directly to a text widget tag.

proc HMtag_color {win param text} {
	upvar #0 HM$win var
	set value bad_color
	HMextract_param $param value
	$win tag configure $value -foreground $value
	HMstack $win "" "Tcolor $value"
}

proc HMtag_/color {win param text} {
	upvar #0 HM$win var
	HMstack $win / "Tcolor {}"
}

##########################################################################

	
proc Tikeditor::AideTcl { var } {
		variable application
		variable version
		global Chemin
		global Size
		
		
if [winfo exists .aideTcl] {	destroy .aideTcl}
		toplevel .aideTcl
		bell -displayof .aideTcl
		wm title .aideTcl "Aide TCL TK $application $version"
		
		wm geometry .aideTcl [expr ([winfo screenwidth . ]*9/10) ]x[expr ( [winfo screenheight . ] *9/10 ) ]+10+30
		wm resizable .aideTcl false false
		
		
	frame .aideTcl.f
	pack .aideTcl.f -side top
	label .aideTcl.f.msg -textvariable message -fg red
	
		
	label .aideTcl.f.labelFonte -text " Taille des caractères "	-relief raised 
	button .aideTcl.f.plus -text " + " -command { Tikeditor::PolicePlusAide .aideTcl.texte}
	button .aideTcl.f.moins -text " _ " -command { Tikeditor::PoliceMoinsAide .aideTcl.texte}
	pack	.aideTcl.f.labelFonte .aideTcl.f.plus .aideTcl.f.moins  -side left
	button .aideTcl.f.index -text INDEX -command { global Chemin ;set Home [file join $Chemin(rel) aidehtml index.html ]  ;
								render $Home }
												
	entry .aideTcl.f.entry  -textvariable Url -width 35	 		-bg white
	pack .aideTcl.f.entry  .aideTcl.f.msg -side left
	
	pack .aideTcl.f.index -side left  
	
	
		text .aideTcl.texte -bg LemonChiffon -relief groove -bd 6 -setgrid 1\
			-wrap word -yscrollcommand ".aideTcl.scrolly set" -xscrollcommand ".aideTcl.scrollx set" \
			-cursor hand2 -font {times 10} 
		scrollbar .aideTcl.scrolly -orient vertical -command ".aideTcl.texte yview" \
			-background #c0d9d9 -activebackground #c0d964 -troughcolor #c06664  
		scrollbar .aideTcl.scrollx -orient horizontal -command ".aideTcl.texte xview" \
			-background #c0d9d9 -activebackground #c0d964  -troughcolor #c06664  
		pack .aideTcl.scrollx -padx 0 -pady 0 -ipadx 0 -ipady 0  -fill x 
		pack  .aideTcl.texte -padx 0 -pady 0 -ipadx 0 -ipady 0 -side right -fill both -expand true
		
		pack .aideTcl.scrolly -padx 0 -pady 0 -ipadx 0 -ipady 0 -side right -fill y
		
		bind .aideTcl <ButtonPress-3> { destroy .aide}
		
		set x0 [ expr ( [winfo width .] - [winfo reqwidth .aideTcl] ) / 2 ]
		set y0 [ expr ( [winfo height .] - [winfo reqheight .aideTcl] ) / 2 ]
		
		bind .aideTcl <3> { destroy .aideTcl } 
	
	# set up some sample keyboard bindings for the text widget
	bind .aideTcl.f.entry <Return> {render $Url}
	
#<valeurs_initiales>

# set initial values
set Size 0				;# font size adjustment
set Indent 0.5			;# tab spacing (cm)
set Home [pwd]/aidehtml/index.html		;# home document
set Url $Home				;# current file
set Running busy			;# page status
set message ""				;# message line

HMinit_win .aideTcl.texte
HMset_state .aideTcl.texte -size $Size
HMset_indent .aideTcl.texte $Indent
 render $Home
HMoptimize 
		
		return 0
	  }
	  
	  
# LANCEMENT DE TIKEDITOR	  
	  
 	  catch {Tikeditor::LectureConfig}
	  catch {Tikeditor::LectureListeRecents}
	  Tikeditor::Gui
	
	

	after 10000 destroy .initiation 


#FIN de Tikeditor
	  
	  
