#! /usr/bin/env tclsh

# This is a support program for filerunner. It produces a list of
# scripts that, when executed by SaveConfig, builds the config file

# We are using a complex way to generate the configure file so that we can set the
# order of generation independently of the order below. The "data" command just collects
# the input in a somewhat organized way. We then break the command (info body data)
# into a list of statements (buildCmds above). we then pick and choose the statements
# in the order dictated by glob(edit_configuration_configlist). If we don't have an
# entry there, the command in "data" will not be executed. The rules for selection:
# 1. a nil selection gets entries from the head of the list
# 2. entries are selected until a "Header" is found or a config body with a comment.
#    A header is " putsTrim $fid {#**************** HOTLISTS `{fill *}`} (we trigger on
#    at least 10 stars.

#    config bodies are commands with "AddConf $fid config(??) ??  {comment}"

# Information on putsTrim and AddConf (including embedded scriplets)
# may be found with their sources.

# The config file generation, and thus the produced list, is controlled
# by a list "glob(edit_configuration_configlist)" which is a loosly
# encoded copy of the left hand panel of the "edit configuration" window.
# glob(edit_configuration_configlist) is defined here as are the various
# scripts that are used by SaveConfig. In short the content of the
# "edit configuration" window is defined here.
#
# The glob(edit_configuration_configlist) rules:
# 1) glob(edit_configuration_configlist) contains two types of entries:
#    a) header entries which contain a title and a search string
#       ( the search string is what the "edit configuration" browser uses
#         when the user selects a header in the left hand window.)
# 2) subscripts for the configuration element to be displayed with
#   its comments. These entries will be of length 1.
# 3) entries may contain expressions that result in one of the above.
#    At this time the only variable this expression may use is ::MSW
#    which is true if we are building for Microsoft Windows.
#
# Import options from the command line... they should look like:
# var=val which will define the global var to have value val. 
# the output file name may be define with out=filename
set out stdout
foreach ent $argv {
  lassign [split $ent =] var value
  set $var $value
}

proc buildList {} {
  buildCmds data
  set lenConfigCmds [llength $::configcmds]
  set ::used {}
  set ::result {}
  set noCmds 0
  set ent -1
  foreach cmd [list {} {*}$::glob(edit_configuration_configlist)] {
    if {$cmd == {}} {
      set ind 0
    } else {
      lassign $cmd lab head flag
      if {$head != {}} {
	# a header.
	set search  *\*\*\*\*\*\**$head*
	set ind [lsearch -glob -nocase $::configcmds ${search}]	
      } else {
	set search "config($lab)"
	set ind -1
	set found 0
	foreach ent $::configcmds {
	  incr ind
	  if {[string range $ent 0 7] != "AddConf "} {continue}
	  set matchPart [lindex $ent 2]
	  lassign $matchPart con pat
	  set npat {}
	  append npat $con "(" $pat ")"
	  if {$matchPart == $search ||\
		  [string match $npat $search]} {
	    incr found
	    break
	  }
	}
	if {!$found} {
	  puts "Oops! could not find \"$search\" in configcommands"
	  puts "working with $cmd"
	  continue
	}
      }
    }
    set line [lindex $::configcmds $ind]
    set limit 0
    while {[incr limit] < 100} {
      if {$limit > 98} {
	puts "can not find end of $cmd, configcmds entry $ind"
	return
      }
      lappend ::result $line
      if {$ind in $::used} {
	puts "configcmds entry $ind used at $noCmds for $cmd used before $limit"
      }
      lappend ::used $ind
      incr noCmds
      incr ind
      set line [lindex $::configcmds $ind]
      #if {$ind < 10} {puts "$ind $cmd"}
      if {[string match {*\*\*\*\*\*\**} $line] ||\
	      [string match "AddConf *config*" $line] ||\
	      $ind > $lenConfigCmds} {
	# puts "stop on $ind of $lenConfigCmds $line"
	break
      }
    }
  }
  puts "$noCmds executed of [llength $::configcmds]"
  set unused {}
  set ind -1
  while {[incr ind] < [llength $::configcmds]} {
    if {$ind in $::used} {continue}
    lappend unused $ind
  }
  puts "unused commands $unused"
  
  # unset -nocomplain ::configcmds
}
# Here we build a list of commands in data using "info body" as
# source.

proc buildCmds {fun} {
  set cmds [info body $fun]
  set start 0
  set end 1
  set ::configcmds {}
  while {$end < [string length $cmds] && [incr lim] < 10000} {
    set end [string  first \n $cmds $end]
    if {$end == -1} {
      set end [string length $cmds]
    }
    if {[info complete [set nc [string range $cmds $start $end-1]]] &&\
	    [set rs [string trim $nc]] != {}} {
      lappend ::configcmds $rs
      set start $end
    }
    incr end
  }
  puts "found [llength $::configcmds] commands"
}

# Here are the key data elements (glob(edit_configuration_configlist)
# and proc data)
 # {{  bind} {Each entry binds}}
 #  {{  menu} {Mail To}}
 #  {{  exception} no_selection}

set glob(edit_configuration_configlist) {
  {Hotlists {HOTLISTS}}
  hotlist
  runlist
  {{Mouse Bindings & menus} {MOUSE & KEY BINDINGS & MENUS}}
  bind,
  global-bind,
  menu,
  no_selection
  [expr {$::MSW ? "X-behave" : ""}]
  paste
  [expr {$::MSW ? "CB-paste" : ""}]
  {Commands {COMMAND CONFIGURATION}}
  editor
  cmd,diff
  cmd,open
  cmd,print
  cmd,term
  open,extensions
  view,extensions
  {Archiver/Packer {ARCHIVER/PACKER}}
  cmd,archive
  cmd,pack
  cmd,unarc,extensions
  cmd,unpack,extensions
  {{passwordlocker} {PASSWORD LOCKER}}
  passwordLocker
  {VFS {Type I VFS CONFIGURATION}}
  vfs,cache,maxentries
  vfs,helptable
  ftp,cd_pwd
  ftp,fastlink
  ftp,timeout
  ftp,password
  ftp,proxy
  ftp,useproxy
  ftp,login
  {{VFS TYPE II} {Type II VFS CONFIGURATION}}
  vfsII,config
  {RSYNC/SFTP {RSYNC/SFTP CONFIGURATION}}
  rsync,table
  {{USER BUTTONS} {USER BUTTON CONFIGURATION}}
  userButton,
  {HTTP {HTTP CONFIGURATION}}
  http,proxy
  {{APPEARANCE/colors } {APPEARANCE - COLORS}}
  gray
  gui,color_bg
  gui,color_fg
  gui,color_cmd
  gui,color_select_bg
  gui,color_select_fg
  gui,color_highlight_bg
  gui,color_highlight_fg
  gui,color_handle
  gui,color_scheme
  gui,color_cursor
  gui,color_flash
  gui,color_balloonHelp_fg
  gui,color_balloonHelp_bg
  {{APPEARANCE/fonts} {APPEARANCE - FONTS}}   
  gui,ListBoxFont
  gui,GuiFont
  gui,BalloonHelpFont
  overstrike,
  {{APPEARANCE/directory} {APPEARANCE - DIRECTORY - OTHER}}   
  ListBoxColumns,right
  ListBoxColumns,left
  ListBoxScripts
  {{APPEARANCE/SIZE/LOCATION} {APPEARANCE - SIZE - LOCATION}}
  dateformat
  dateformatTop
  DisplayName
  DisplayNameShare
  geometry,textviewer
  geometry,qedit
  geometry,max
  geometry,min
  geometry,location
  {{APPEARANCE/windows} {APPEARANCE - WINDOWS}}   
  columnScroll
  columnScrollSize
  fast_checkboxes
  middle_button_list
  {Shell {SHELL CONFIGURATION}}
  shell,aliases
  shell,buffer
  shell,height,left
  shell,height,right
  {FileOps {FILE & DIRECTORY HANDELING OPTIONS}}
  ask,dir_delete
  ask,file_delete
  ask,save_modified_file
  cd_pwd
  check_ownership
  create_relative_links
  fileshow,all
  fileshow,dirs
  fileshow,sort
  keyb_support
  positiondirs
  sortoption
  {update {INTERNAL PANE UPDATE OPTIONS}}
  autoupdate
  inotify_flags
  inotify_nlflags
  inotify_rate_limit
  {mouse {MOUSE MANAGEMENT}}
  focusFollowsMouse
  mwheel,delta
  mwheel,neg
  mwheel,pos
  {start/shutdown {START & SHUTDOWN OPTIONS}}
  [expr {$::MSW ? "cifs,shares" : ""}]  
  geometry,main
  geometry,mainops
  startpwd,left
  startpwd,right
  save_conf_at_exit
  {miscellaneous {MISC CONFIGURATION}}
  balloonhelp
  hoverTime
  logsize
  search,limit
  search,CmdConfStrings
  search,ViewEditStrings
  spellingFilter
  spellcheck,expect
  [expr {$::MSW ? "" : "monitors"}]
  [expr {$::MSW ? "" : "manualMonitors"}]
  {{wildcard options} {COMMND WINDOW WILDCARD OPTIONS}}
   expandWildCards
   globstar
  {{Dangerous stuff} {DANGEROUS}}
  [expr {$::MSW ? "" : "cmd,chmod"}]
  [expr {$::MSW ? "" : "cmd,chown"}]
  cmd,cp
  cmd,dircp
  cmd,du
  cmd,find
  cmd,hardlink
  cmd,rm
  cmd,sh
  cmd,touch
  cmd,ucmd
  [expr {$::MSW ? "useDIR" : ""}]
}
proc translate {} {
  global glob
  # now do the substutions for windows vs unix
  puts "translate left using MSW=$::MSW"
  set glob(edit_configuration_configlist) \
    [subst  $glob(edit_configuration_configlist)]
  #puts "translate done"
  # At some point we might want to translate the right side as well
  # That would involve finding the references to ::MSW and resolving them
}

proc data {} {
  putsTrim $fid  {
    # Generated by `{B FileRunner}` `{subst "$::glob(displayVersion) on
    # [clock format [clock seconds]]"}`
   
    # This is the configuration file for `{B Filerunner}`. It is read every time
    # `{B Filerunner}` starts up. It is saved in a sub folder of  
    # your HOME folder. In your case it is in `{subst "$::glob(conf_dir)"}`
    # `{B Filerunner}` will recognize these possible locations for the
    # configuration file: `{next}` `{ifThis {$::MSW} { `{subst "$::env(APPDATA)/.fr"}`
    # `{next}` `{subst "$::env(LOCALAPPDATA)/.fr"}`
    # `{next}` `{subst "$::env(USERPROFILE)/.fr"}` }
    # { `{subst "[file norm ~/.config/.fr]"}`
    # `{next}` `{subst "[file norm ~/.fr]" }` } }`
    # 
    # The configuration file is named "config<date>" where <date> is the release
    # date of the `{B Filerunner}`.  New versions of `{B Filerunner}` will use old config
    # files to build a new one with the new date. This allows old `{B Filerunner}`
    # versions to continue to use their config files with out conflict with newer
    # versions.
    #
    # Make
    # sure to only edit values for variables that are listed. Do not add or
    # delete comments or other variables, since this file will be automatically
    # regenerated
    # when you do a "Edit Configuration->Save Configuration" in the menu and those
    # changes will be lost. 
    #
    # This config file is saved to disk and reread into `{B Filerunner}` when you
    # press the OK button in the config browser.

    # You can also edit this file
    # with a regular text editor and re-read it into `{B Filerunner}` with
    # "Configuration->Reread Configuration" or just restart `{B Filerunner}`.
    # (If you have the save on exit option set you should exit `{B Filerunner}` by
    # typing "%exit" in a command window to avoid the auto save messing with
    # your newly edited file.)

    # From time to time, as `{B Filerunner}` is enhanced, the 'as shipped' version
    # of a configuration entry may change. If you have an existing configuration
    # file, it will replace the 'as shipped' entry with what you have entered
    # or what was last shipped. To reset an entry to the current 'as shipped'
    # version all you need to do is to eliminate that entry from the configuration,
    # either with the configuration editor or another editor. That is all
    # that needs to be done. `{B Filerunner}` will replace the missing entry with the
    # current 'as shipped' version.
    
    #`{ifThis {$::MSW} {# `{B Filerunner}` handles file path names as
    # "/" separated components and not "\" separated as windows uses. In passed
    # versions of `{B Filerunner}` it was recommended that you use [file native] to
    # pass native MS windows file names. This version ALWAYS passes native
    # file names so that option is no longer needed and in fact will be
    # automaticly removed from the config file.} {}}`

    # `{B "Syntax note:"}` `{B Filerunner}` uses a special Exec Call Formatter (frECF) to
    # set up calls to external
    # (and some internal) programs and functions. To get details on how the
    # lines in this file are handled please read the "Configure
    # options for commands I" and II in the Tips file (see Help menu).

    # `{B Patterns:}` The rule based commands use rules set up in this configuration
    # code. Most of these rules use a 'tcl string match' pattern to match the
    # rule or option to some string (file name, message, etc.). Here is a
    # summary of the match rules. For more details google the tcl string
    # command, match subcommand.
    #
    # *        Matches  any sequence of characters in string,
    #          including a null string.`{in 1 9}``{next;in 0}`

    # ?        Matches any single character in string.`{next}`

    # [chars]  Matches any character in the set given by chars. If a
    #          sequence  of `{in 1 9}`the form x-y appears in chars, then any
    #          character`{next}` between x and  y, inclusive, will match.`{next;in 0}`

    # \x       Matches the single character x.`{next}`
    
    #
    #`{ifThis {$::MSW} {# Some useful things you may need here:
    
    # [namespace exists freewrap] is true only in the fr*.exe version of fr.`{next}`
    # If you are having trouble with spaces in file names try:`{next;in 1}`
    #   [file attr 'filename' -sh]`{next}`
    #   this replaces filename with the short name which will have
    # no spaces.`{next;in 0}`} {}}`
    # 
  }
  putsTrim $fid {
    #**************** `{B HOTLISTS}` `{fill *}`
  }

  AddConf $fid config(hotlist) 2 {
    # This list is what will show up in your HotList menu. (Like "bookmarks"
    # in a browser). Feel free to edit this list.
    # You can label your selections thusly: {label /home/usr/foobar} 
    # and you can build as many levels of cascade menus as you like
    # with each cascade starting with an entry preceeded by "-"
    # thusly:`{next;in 1}`
    # one level {-clabel { a b c }}`{next}`
    #         two level {first {a b {-second {c d e}}}}
    
    # or, more readably:`{next;in 0}`
    
    #         set config(hotlist) {`{next;in 1}`
    #             {-first {`{next;in 1;in 1}`
    #                a`{next}`
    #                b`{next}`
    #                {-second {`{next;in 1;in 1}`
    #                    c`{next}`
    #                    d`{next}`
    #                    e`{next}`
    #                   }`{next;in 0}`
    #                }`{next;in 0}`
    #              }`{next;in 0}`
    #            }`{next;in 0}`
    #          }`{next;in 0}`
    # where each 'a' 'b' 'c' 'd' 'e' is an entry which also may have a label as above.
    # For example here is an entry for the Windows volumes:`{next}`
    # {-volumes {{floppy a:/} {{system volume} c:/} { d:/ }}}`{next}`
    # The '{}' around an entry allow spaces which otherwise seperate the entries.
    # White space is preserved so what ever indention format you use is kept.
    # Try it...
  }

  AddConf $fid config(runlist) 2 {
    # This list is used by the Run ... commands (Utilities menu).  It contains
    # a list of programs that you can select and instructions on how to run them.
    # You may find it easier to add to this list by invoking the Run command
    # and selecting '<Add a new program>' where you can use command completion and
    # or browsing to find the program name.
    #
    # Each entry in the list contains 2 to 5 entries as follows:
    #
    # The first entry is the display name (or 'nice' name) and the run string. 
    # You may choose any thing you want for the display name.  The run string
    # should contain the program name (possibly a full path name) followed by any
    # flags you want to code.  The file(s) you are passing will replace the '%s'
    # in this string. If the program name contains spaces you should can either
    # enclose the full program name in curly braces ({}) or precede each space
    # with a back slash (\). `{ifThis {$::MSW} {Use '/' instead of '\'
    # in file names.}}`
    #
    # The second entry is the string you want to separate the files with 
    # (should you ever pass more than one file).  Usually this is a space, coded as
    # { }.
    #
    # The remaining two entries are 'async' 'fullname' and 'last+current'
    # coded in any order.
    # These are optional entries.

    # If 'async' is present the program is run
    # asynchronously.`{next}` If 'fullname' is coded only full filenames are passed.
    # `{next}` If 'last+current' is coded both the last & the currently selected
    # file names are passed.
    
    # Here is an example entry to run the 'thunderbird' mailer to compose a 
    # mail message with the selected files as attachments. It will display as
    # 'mail-to' when the 'Run' command is invoked.
    #
    #  {{mail-to {thunderbird -compose attachment='%r'}} , fullname async}
    #
    # Here is how to call emacs to diff two files:
    #
    #  {{Emacs-diff {emacsclient -e {(edif-files %s %s )} &}}}
    
    # If you need to use the quotes '"' use '%' to protect them e.g.'%"'.
    # (Note that in the mail-to case the parameter is 'attac....'. Any spaces (except
    # in file names, which are autmatically escaped) will make more than one parameter
    # and (likely) fail.
    #
    # The display of the run list (when the run command is given) may be setup
    # as a cascade (or hierarchical) menu. To do this the contents of each
    # sub menu must be contained in '{-title sub-menu-entries}' (note the "-").
    # For example
    # this would be the entry for two versions of running fr as root, one with
    # the home dir change to root's dir and one with the current home dir: `{next}`
    
    #  {{-root-fr-options} { `{next;in 1;in 1}`
    #              {{{using root's home} {sudo -H fr}} { }}`{next}`
    #              {{{using my     home} {sudo fr}} { }}`{next;in 0}`
    #             }`{next;in 0}`
    #  }
    # White space is preserved so what ever indention format you use is kept.
  }  
  

  putsTrim $fid {
    #****** `{B "MOUSE & KEY BINDINGS & MENUS"}` `{fill *}`

    # This is the binding list. There are three types of bindings, global, 
    # local to a directory list window and to the directory (dir) window.
    # Global bindings may be triggered anywhere in
    # `{B Filerunner}`'s main window, except that local bindings will suppress global
    # bindings in the dir and directory list windows.
    # So, for example mouse 3 can be locally 
    # bound to ViewOne and globally bound to a menu. In a directory window mouse-3
    # will do ViewOne, while outside of the directory it will bring up the menu. 
    # Global bindings look like:

    # config(global-bind,event) action

    # local bindings look like:

    # config(bind,event) action
    #  or
    # config(bind.event) action

    # Note the difference, a comma or a period between bind and event. This is
    # to allow the same binding to both the dir windows and the directory list
    # windows. In this case the 'action' defines which window is used in the
    # binding.

    # Each entry binds a key or mouse event to an action. 
    # Legal actions are all the possible (not just those you configured
    # to be present) commands in the center button list, including
    # user defined buttons, plus commands from other `{B Filerunner}` 
    # menus (listed below). Of these commands 'CmdRunCmd' takes
    # parameters. The parameter is 
    # the 'nice' name of a program that must appear
    # in the runlist (see above).  This parameter is
    # optional. For example, using the 'mail-to' example in the runlist, this:
    #
    # set config(bind,Button-2) {CmdRunCmd mail-to}
    #
    # will cause a mouse button 2 press to run thunderbird to bring up a mail 
    # compose window with the selected files 'attached' to the message.
    # 'Back' pops a dir from the dir stack and makes it the current dir 
    # (the same as the <- button).  'UpDirTree' is the same as the ^ button.
    # One of these commands might be bound to the Left key (left arrow).  You
    # then might want to bind the Right key (right arrow) to 'ViewOne'.
    # The 'Toggle' command takes as a parameter a config item and toggles it.
    # For example 'Toggle config(fileshow,all)' All the binary items in the 
    # Configuration menu may be toggled this way.  Binary config options not
    # in this menu will, most likely not work, especially if their changes require
    # rebuilding the window (e.g. the keyboard support binary).
    # Legal values for the 'bind' command may be found in the man page (do a
    # google search for 'tk bind').  In general, mouse buttons 1, 2 & 3 with
    # modifiers 'Double, Triple, Meta, Alt, Control etc. may be used. (Do
    # understand that 'Double' & 'Triple' will also invoke the actions leading
    # to the given action, that is a Triple will also invoke the single and double.
    # Also, the button 1 selection will happen even if button one is also
    # bound to a command (this is not recommended). Also note that all printing
    # chars are used by the position command. If you do bind a printing character
    # that binding as well as the position command will be executed.

    # The command 'PopupDir' is automatically redirected to the pane dir
    # window. To allow you to use the same 'event' (e.g. Alt-1) there and on
    # some action in the directory listing, one of the two should use a '.' after
    # the 'bind' and the other should use ','. I.e. the separator between
    # 'bind' and 'event' or 'action' may be either '.' or ',' to avoid
    # a naming conflict.
    #
    # In the list below, the first element in each entry is command name and the
    # second is a one line description of what it will do.
    # This is a list of the bindings `{B Filerunner}`
    # ships with.  These may be changed but not eliminated at your discretion
    # (since these are predefined they will not go away if you just eliminate them 
    # but you may set them to null "{}" to make them do nothing):

    #   set config(bind,`{DarMou Button-3}`) ViewOne`{next}`
    #   set config(bind,`{DarMou Control-3}`) ViewDirOpposite`{next}`
    #   set config(bind,Double-1) Edit`{next}`
    #   set config(bind,Control-1) {DoMenu,sample}`{next}`
    #   set config(global-bind,`{DarMou Shift-3}`) {DoMenu,two}`{next}`
    #   set config(bind.Alt-1) PopupDir`{next}`
    #   set config(bind,Alt-1) PopupListEntry`{next}`
    #   set config(bind,`{DarMou Alt-3}`) PopupListDetail

    # Here is the current list:
  }
  set inde 0
  foreach k $glob(buttoncmds) {
    if {[lindex $k 2] != {}} {
      set inde [expr {max ($inde , [string length [lindex $k 0]])}]
    }
  }
  frputs glob(buttoncmds)'
  foreach k $glob(buttoncmds) {
    putsTrim $fid "#    [list [lindex $k 0]]\
     [string repeat " " [expr {$inde - [string length [lindex $k 0]]}]]\
     [lindex $k 2]"
  }
  putsTrim $fid "\n"
  
  AddConf $fid {config bind*} "" { }
  
  AddConf $fid {config global-bind,*} "" {}
  
  AddConf $fid {config menu,*} "1" {
    # These are the menus.  Each menu is a list of commands & menu references.
    # a menu reference looks like 'DoMenu,name' where 'name' is the menu's 
    # name and should appear here in a config(menu,name) description.
    # You may define as many menus as you like, however, only menus that
    # are referred to by one of the bindings listed above (and cascade menus
    # of those) will be built. An empty entry (i.e. {}) will generate a
    # separator in the menu.  All of these menus may be 'torn off' by clicking
    # on the top entry (the '-----').  This promotes the menu to a window which
    # may be moved around on the screen.  Torn off menus no longer have access
    # to the list box entry that you were on when the menu was first popped up
    # but they do have access to the current selection(s). To continue our 
    # example of using the run command, here is a menu line that will give a
    # menu entry called 'Mail To' which will run 'thunderbird' (see the runlist 
    # above) to bring up a compose window with the selected files attached.
    #
    #    {{Mail To} {CmdRunCmd 0 mail-to}}
  }
  AddConf $fid config(no_selection) 1 {
    # Commands in this list will not update the selection when they are 
    # selected via a bind command.  All other commands will up date the selection
    # if, when they are called via a 'bind'ing, there is no current selection.
    # You should only add to this list if you really know what you are doing.
    # These commands need to know how to work without a selection.
    # Removing commands from this list will make the removed commands update the
    # selection the same as others do.
  }
  AddConf $fid config(X-behave) "" {
    # The X-behave option attempts to make `{B Filerunner}` behave more closely to
    # how the X11 system works on *nix systems with respect to cut and paste.
    # In MS Windows, there is a local "selection" and a "clipboard". In general
    # one makes a selection with mouse 1 (often by dragging) and then copies that
    # to the "clipboard" (usually with Control-C). One can then "paste" that
    # information into the same or another application. In `{B Filerunner}` and other
    # apps the "selection" can be "pasted" locally with out copying it to the
    # "clipboard". In `{B Filerunner}` the current selection is highlighted in color.
    # If a new selection is made the old highlighted selection is replaced by
    # the new one (including the change of highlighting). By default
    # <Button2-ButtonRelease> does a "paste" of the selection and
    # <Shift-Button2-ButtonRelease> and Control-v does a "paste" from the
    # "clibboard".
    # On *nix systems (Unix, Linux) a selection is always put in the "clipboard".
    # The Xbehave option, if 1, puts selections in the "clipboard" as soon as
    # they are made.
    #  
  }
  AddConf $fid config(paste) 1 {
    # The "paste" configuration item allow you to define additional mouse or
    # key selections that do a "paste". `{ifThis {$::MSW} {This paste will be
    # from the current selection (i.e. the local `{B Filerunner}` highlighted text)
    # <ButtonRelease-2> is defined to do this in the "as shipped"
    # `{B Filerunner}`.} {The standard paste characters
    # <Control-v> and <Control-y> are already defined.
    # In addition some systems 
    # define <ButtonRelease-2> and <Control-Shift-Insert>.}}`  This info is
    # required for paste operations in the directory line where the paste is
    # intercepted to make magic happen. At the same time, any sequence named 
    # here will result in a 'paste' being preformed (without the magic) in all
    # `{B Filerunner}` 'view' windows.  If your system has other sequences for 'paste'
    # but you don't used them to paste in the directory line you don't need to
    # enter them here.  `{B Filerunner}` is shipped with <ButtonRelease-2> set
    # as this is common in the Unix world. Syntax is the same as the Tc/Tk
    # bind command (see bind(n)).
  }
  AddConf $fid config(CB-paste) 1 {
    # This option allows you to define an optional mouse or key-board character
    # to "paste" from the "clipboard". The "as shipped" entry here is
    # <Shift-ButtonRelease-2>, Control-Key-v <Shift-Key-Insert>
    # and <Control-Lock-Key-V>

  }
  putsTrim $fid {
    #********** `{B "COMMAND CONFIGURATION"}` *`{fill *}`
  }
  AddConf $fid config(editor) "" {
    # This variable should be set to the name of your favorite text
    # editor. This editor will be invoked when you select files and press
    # the "Edit" button. It is also invoked when you double click on any
    # file name in a list box.  The text editor you choose should be an
    # window application, not a text-terminal application. You can start
    # text-terminal editors for example by launching them from inside an
    # xterm. E.g: "xterm -e vi %s". The editor you choose should be able to
    # load multiple files specified as arguments to the editor (e.g: 
    # "emacs /tmp/foo /home/joe/bar"). The editor will be launched in the
    # background.
    
    # Note: If you use a path name and any elements of it contain blanks
    # you will need to do something like:`{next}`
    # set config(editor) {`{next;in 1 5}`
    # {c:/Program Files/Windows NT/Accessories/wordpad.exe} %s}`{next;in 0}`
    # You could also just put the path in you PATH env var, either in your system
    # environment set up or in the config file in `{B Filerunner}`'s home
    # directory:`{next}`
    # `{ifThis {$::MSW} {
    # global env; set env(PATH) "$env(PATH);<path to wordpad program>".} {
    # global env; set env(PATH) "$env(PATH):<path to emacs program>"}}`
  }
  AddConf $fid config(cmd,diff) "" {
    # Your favorite diff command. Should be able to diff directories also.
    # Used in the "Diff" button command. `{B Filerunner}` will wait
    # until the program finishes unless you put a trailing '&' here.
    # You should do this if your diff program opens its own window e.g. meld or
    # emacs. Since you asked, this is what you need here to get emacs to 
    # diff two files:`{next}`
    #
    # set config(cmd,diff) {emacsclient -e {(ediff-files %s %s% )} &}
    #
    # If you use a non-gui program leave off the '&' and `{B Filerunner}` will
    # pop up
    # a window with the results.`{ifThis {$::MSW} { For windows
    # you might want to use "fc".} }`
  }
  AddConf $fid config(cmd,open) "" {
    # This rule is command for the 'Open' command (above). `{ifThis {$::MSW} {
    # This should be: `{next}`'{twapi::shell_execute -path {%s}}'}
    # {I am aware of 'gnome-open' 'kde-open' and 'xdg-open'
    # (one file limit) and 'gvfs-open'
    # (runs program for each file rather than send all files to the same program.)}}`
    # `{next}`Mac systems use 'open'. 
  }

  AddConf $fid config(cmd,print) "" {
    # The print command you want to use to print files.`{ifThis {$::MSW} {
    # This should be 'twapi::shell_execute -verb print -path %s'}}`
    # {Most likey you want 'lpr %s' here.}
  }

  AddConf $fid config(cmd,term) "" {
    # The name of your favorite terminal program.
    # This is the program that will be launched when you press the button
    # with the image of the terminal window (upper right of the file list
    # panels). It will be launched in the background.  If you include a %s
    # in this command it will be replaced with the current working dir 
    # e.g.:
    
    {konsole --workdir %s}
    
    # The command is also invoked in the current working dir.
  }

  AddConf $fid config(open,extensions) "1" {
    # This rule contains a list of commands and the file patterns that
    # are used when finding the right 'open' routine for various files. The
    # commands will receive a list of selected files. The first file in the
    # selected list are used when deciding which opener should be used. (Don't
    # try and open a couple of text files and images simultaneously by selecting
    # and pressing the open button). If you add the option "-viewtext"
    # last in the rule that means the command outputs a listing/view and it
    # should be viewed in the internal text viewer. The opening commands
    # will be executed in the background. Open is used to launch applications
    # based on the file extension, however, for some files it makes more
    # sense to launch the application in a 'peek' mode.  For this see the
    # view command.
  }
 
  AddConf $fid config(view,extensions) "1" {
    # This rule contains a list of commands and the file patterns that
    # are used when finding the right viewer for various files. The commands
    # will receive a list of selected files. The first file in the selected
    # list is used when deciding which viewer should be used. (Don't try
    # and view a couple of text files and images simultaneously by selecting
    # and pressing the view button). If you add the option "-viewtext"
    # last in the rule that means the command outputs a listing/view and it
    # should be viewed in the internal text viewer. The viewing commands
    # will be executed in the background. View may be used to launch applications
    # based on the file extension, however, for some files what makes more
    # sense to launch the application in a 'peek' mode.  For example you
    # may want to 'peek' inside a .zip file to see what it contains with:
    
    # { {unzip -lv %s} {*.zip} -viewtext }
    
    # where the '-lv' tells unzip to list the files in the package.
    # This is particularly true of files that are addressed by the UnArc and
    # the UnPack buttons where, for example we might want:
    
    #  { {unzip -oqq %s} {*.zip} }
    
    # to actually unzip the file.

    # If the rules program name is {try open} the
    # indicated files will be sent to the "open" rule. This is very useful in
    # cases where the system may have any of several programs to 'view' files of
    # a given type.  Here is an example that sends '*.pdf' files to the open rule:

    #  {{try open} {*.pdf}}
  }

  putsTrim $fid {
    #****** `{B "ARCHIVER/PACKER CONFIGURATION"}` `{fill *}`
  }
  AddConf $fid config(cmd,archive) "" {
    # This is the name of your archiver program. The archiver program is
    # passed the name of the directory selected and is executed in the
    # current directory. The archive created is supposed to contain the
    # contents of the directory. The default built in "tar+gz %s" creates
    # an archive named <directory>.tar.gz packed with tar and gzip. This
    # command is used in the "Arc" button command to pack/archive
    # directories. It can be run synchronously or in the background.
    # This command takes up to three parameters (%s)'s.  The first is the
    # selected file (or directory) the second is the other panels working
    # directory and the third is again the selected file.  Thus:
    
    # "tar -cz  %s -f %s/%s.tar.gz"

    # is the same as "tar+gz %s" except
    # that the result will be put in the 'other' directory.
  }

  AddConf $fid config(cmd,pack) "" {
    # The name of your favorite packer command. 
    # Used in the "Arc" button command to pack files. Run synchronously
    # or in the background.
  }
  AddConf $fid config(cmd,unarc,extensions) "1" {
    # Extensions and bindings for unarchive rules. This is a list of
    # commands and file name extensions. `{B Filerunner}` will use this variable
    # when deciding which command should be used to unarchive the file when
    # you press the UnArc button. See above comments on the 'view' command.
    # Its OK to put identical rules here and in the following 'unpack'
    # command to, for example, unzip a file even if you push the wrong
    # button.
  }

  AddConf $fid config(cmd,unpack,extensions) "1" {
    # Extensions and bindings for unpacking rules. This is a list of
    # commands and file name extensions. `{B Filerunner}` will use this variable
    # when deciding which command should be used to unpack the file when you
    # press the UnPack button.
  }



  putsTrim $fid {
    #****** `{B "PASSWORD LOCKER"}`  `{fill *}`
  }

  AddConf $fid config(passwordLocker) 1 {
    # All passwords that are kept by `{B Filerunner}` are kept here.
    # Each entry contains an ID and the encripted password and,
    # optionally a comment.
    #
    # URLs have the following parts:`{next}`
    # "protocol" the protocol e.g. ftp, rsync, sftp, cifs`{next}`
    # "user"     is the user name and`{next}`
    # "port"     the port" is optional if not the standard port)
    #            however it is part of the ID and if changed here the`{in 1 11}`
    #            VFS handler may not find the password.`{next;in 0}`
    #            Also, the ID most often will require the "user"`{next}`
    # "address"  The address to be accesed with this password.
    
    # The full URL format is: "protocol://user@address:port"`{next}`
    # For "cifs" this looks like "cifs://user@server"

    # The password code does not require a "protocol" or a "port". So for
    # user password on the current machine the Id would look like:

    # user

    # If the password code is given an Id of "foo" it will search this
    # table for "foo"

    # The best and easiest way to handle the password Locker is to
    # use the "Show/edit passwords" command in the "Utilities" menu.

    # The 'password info' has the following three parts:
    
    # A password (may be {} for sftp connections using ssh keys)`{next}`
    # The disk address of the ssh private key (may be a full address or 
    #    the file name if the key is in env(HOME)/.ssh)`{in 1 5;next;in 0}`
    # The pass phrase.`{next}`
    #
    # If any of these entries contain blanks, enclose the whole
    # entry in braces e.g.:`{next}` {Hello world}`{next}`
    # Note that `{B Filerunner}` will encrypt the 'password info'.
    # If you need to change
    # it you should delete the string:`{next}`
    #'>> list of numbers <<'`{next}`
    # and enter the new
    # info in plain text.  File runner will encrypt it automatically.
  }

  putsTrim $fid {
    #*********** `{B "Type I VFS CONFIGURATION"}` `{fill *}`

    The "Virtual File System" (VFS) grew out of the origional FTP work
    so some of these entries are still named for FTP while, in fact, are
    used in the VFS code.
  }
  AddConf $fid config(vfs,cache,maxentries) "" {
    # Maximum number of directory listings the cache should hold.
  }
  AddConf $fid config(ftp,cd_pwd) "" {
    # If true (non-zero): When doing a cd to a new directory, `{B Filerunner}`
    # will run pwd to check where it ended up (which makes a difference
    # if you cd to a link which points to a directory).
  }
  AddConf $fid config(ftp,fastlink) "" {
    # Set this to 1 if you feel your FTP connections are fast, to 0
    # otherwise. If you set it to 1, soft-links in FTP listings are
    # correctly identified either as links to directories or to files,
    # otherwise it will always think links are links to directories.
  }

  AddConf $fid config(ftp,timeout) "" {
    # Set timeout in seconds for VFS communication. 
  }

  AddConf $fid config(ftp,password) "" {
    # Set password for anonymous FTP sessions. This should be your 
    # email address.
  }


  AddConf $fid config(ftp,proxy) "" {
    # ******** `{B WARNNING}` ***************`{next}`
    # With no way to test ftp proxy I fear this feature will not work.`{next}`
    
    # If you have to go through a firewall via an FTP proxy, set this
    # variable to the hostname of your FTP proxy. Set it to "" if you don't
    # have an FTP proxy.
  }

  AddConf $fid config(ftp,useproxy) "" {
    # 1 -> Use defined ftp proxy`{next}`
    # 0 -> Don't use proxy (to access hosts inside the proxy/firewall)
  }
  AddConf $fid config(ftp,login) 1 {
    # Place holder till we get it all moved to vfs.
    # If config(ftp,login) is not empty a message will be generated 
    # each time `{B Filerunner}` is started suggesting that it be
    # either eliminated or converted to a VFS login and entered
    # in config(vfs,login) below. 
  }

  putsTrim $fid {
    #****** `{B "Type II VFS CONFIGURATION"}` `{fill *}`
  }
  AddConf $fid config(vfsII,config) "2" {
    # A TYPE II VFS (as defined by `{B Filerunner}`) is a Virtual File System (VFS)
    # that is constructed by setting up a set of files on the system such that
    # they are actually on the system drive (i.e. they are NOT really virtual).
    # This means you can do anything you want to with them, including passing
    # them to external programs. What is provided here is a rule based method
    # to make them appear and disappear on the system. For example, consider
    # a compressed "tar" archive. The `{B Filerunner}` 'mount' command will look in
    # this config variable for a set of rules (based on the file extension
    # in this case) to uncompressed and unpack the archive to a location 
    # (specified in the rules) and, if desired, provide an alias named path
    # to the unpacked files (see 'DisplayName' under 'Miscellaneous' below).
    # If the rule specifies that the files are
    # read only, the 'unmount' command will just delete the files. If
    # the files are not readonly, the 'unmount' script should rebuild the
    # archive and replace the original file prior to deleting the files.
    #
    # The set of rules consist of the following parts:
    # 
    # 1) Each rule is entered as a set of pairs with the name of the option
    #    `{in 1 3}`followed by its value (e.g. -mount <mount command>)
    #    "*" indicates optional. Option names may be abbreviated.
    
    #    The options are:`{next}`
    #    option    value                 comments`{next}`
    
    #    -mount    <mount command>     * if the command has spaces,
    #                                    enclose in braces `{in 1 32}`
    #                                    if external program lead with exec `{next;in 0}`
    #    -use      unarc or unpack     * Find the command in the given rule`{next}`
    #    -location <a directory>       * The path to the VFS directory`{next}`
    #    -display  <name>              * A name to display for the directory`{next}`
    #    -readonly 1 or 0              * 1 if a read only VFS`{next}`
    #    -umount   <rebuild script>    * A command/script to 
    #                                    rebuild the archive`{in 1 32}``{next;in 0}`
    #    -dirsonly 1 or 0              * If 1 only directory names 
    #                                    will match the rule. `{in 1 32}`If 0 or absent
    #                                    directories and files match`{next;in 0}`
    #    -okerror  {pattern}           * If the mount command generates an error that
    #                                    matches 'pattern' `{in 1 32}`
    #                                    (tcl string match pattern) the error
    #                                    is forgiven.`{next}`

    #`{in 0}`
    # The '-mount' may be omitted if '-use' is present. I.e. one or the other is required.
    # If the '-mount' or '-umount' command is an external program it must be proceeded by
    # 'exec'. This is done so internal `{B Filerunner}` commands may be used here.
    # The 'exec' is provided in the '-use' case.
    
    # Location options (each of these will be followed by a
    # dirname choosen by fr):`{next;in 1 3}`
    #   a) A fixed dir (such as /tmp or ~/tmp)`{next}`
    #   b) `{B Filerunner}`s tmp dir (enter as: "$frTmp")`{next}`
    #   c) A location relative dir (., .. etc.)`{next}`
    #   d) The opposite panels directory (enter as: "$opwd")`{next;in 0}`
    #
 
    # The dir name may be a pattern built from the above.

    # The 'DisplayName' will include this dir (and the path to it) i.e. the
    # 'DisplayName' will replace the path/dir in the `{B Filerunner}` panel.
    # To avoid collision, the displayed name should end with the dir name.

    # The following, hopefully usful variables are available for use:`{next}`
    #
    # $frTmp `{B Filerunner}`'s per user temp area (for -location above)`{next}`
    # $pwd   The current panes working directory`{next}`
    # $opwd  The other panes working directory`{next}`
    # $tail  The selected file name with no path`{next}`
    # $file  The selected file name with full path (same as $pwd/$tail)`{in 1 7}`
    #        This will always show a local path to the file as
    #        it is the location VFS files are moved to.`{next;in 0}`
    # $ext   The selected files extension`{next}`
    # $nil   An empty string (use with -location to prevent creation attempt)`{next}`
    
    # 2) A (glob) pattern to identify which files or directories use this rule.
    #    `{in 1 3}`This should look just like the view command pattern(s). More
    #     than one pattern may be used with a rule. If more than one they they
    #     should be separated spaces with the whole group enclosed with
    #     curly braces.`{next;in 0}`
    #
    # The as shipped version the the config file contains two example rules.
    # One to "mount" a tar archive. This rule will recreate the tar file on
    # "unmount". The other rule is to
    # read-only mount some of the many compressions that '7z' can unpack. (Make
    # sure '7z' is present and findable via the 'PATH' environment variable.)

    # `{ifThis {!$::MSW} {
    # Here is a normal mount request, to be executed with
    # the directory selected.`{next}`
    #`{next}`
    #  {{-mount {exec echo [pwLocker::getPw $::env(USER)] | sudo -H -S mount} `{next;in 6;in 6}`
    #    -location $nil`{next}`
    #    -dirsonly 1`{next}`
    #    -umount {exec echo [pwLocker::getPw $::env(USER)] | sudo -H -S umount -l} `{next;in 0}`
    #   } `{next}`
    #   {*} `{next;in 0}`
    #  } `{next}`
    #`{next}`
    #      As this will match any selection, it should be last. It depends on the
    # target being in /etc/fstab and will throw an error if it isn't.
    # }}`

  
  }
  putsTrim $fid {
    #****** `{B "RSYNC/SFTP CONFIGURATION"}` `{fill *}`
  }

  AddConf $fid config(rsync,table) "2" {
    # Rsync is a program that does a very good job of copying files, especially
    # from one system to another. `{B Filerunner}` is set up to dispatch "rsync"
    # in such a way that it does the copy directly with the target system
    # using one of the two ways it has of communication with the
    # remote (aka host) system (please see the rsync man page for details).`{next}`
    
    # The first way assumes that you have the remote system mounted in the
    # local systems file space and the copy command is the "Rsync" button.`{next}`

    # The second way is via VFS access to the remote system using VFSrsync.
    # For more on this, see below.`{next}`
    
    # In the fitst way the remote file system is mounted to the
    # current system such that `{B Filerunner}` can display it in one of the panes.
    # In order to do the rsync transfer `{B Filerunner}` needs to translate
    # directory names as
    # they appear in `{B Filerunner}` to the names as they appear to rsync. 
    # `{B Filerunner}` handles the following connections (with needs given):
    #
    # nfs     password  (translation of diretory name automatic)`{next}`
    # cifs    password  share address on the remote`{next}`
    # ftp     share address on the remote`{next}`
    # sftp    share address on the remote`{next}`
    #
    # The rsync table should contain an entry for each remote machine
    # "share". Each entry contains 5 parts {share path mode ops pwd}.
    #
    # share    is the cifs "share", nfs "host" or (s)ftp host 
    #          (for nfs and cifs this is the same as the fstab entry.
    #          `{in 1 9}`For (s)ftp
    #          this is the same as in the dir line when first opening a
    #          connection. 
    #          It might look like "ftp://sunsite.unc.edu" for example.`{next;in 0}`
    # path     is the host's path to the "share"
    #          (for nfs fr finds this in the mount info)`{in 1}`
    #          The path should not end in "/". I.e. if the file system root
    #          is the path, enter {}. Windows paths should be entered with
    #          "/", not "\".`{next;in 0}`
    # mode     the mode the rsync connection should use, 
    #          one of (shell daemon{=module} use=altnateCmd)`{in 1}`
    #          rsync daemon mode supports implies what rsync calls modules.
    #          The module name should appear as the last part of the share
    #          name (i.e. share/module). The key word "daemon" need not have
    #          the "=module" part.  The use= option allows you to use a program
    #          other than rsync.  scp is a possible alternative.`{next;in 0}`
    # ops      the option string to pass to rsync for this connection
    #          If spaces appear in this string the whole string should be`{in 1}`
    #          quoted with {} e.g. {-a -v}`{next;in 0}`

    
    # Passwords are kept in the "password locker" and are no longer in the
    # rsync table.
    #
    # Where to put the port number? Usually the remote shell is ssh. The port
    # should be in the "ops" like this (see man page):
    #
    # --rsh="ssh -p <port>"    where <port> is the port number. (Note quotes)
    #
    # If 'use=scp' the port would be '-P <port>' (Note upper case P)
    #                                          
    # The first entry should have a null share and path and sets the default
    # mode, ops and pwd.  These will be used when other entries don't supply
    # this info. It is not actually required to have other than the default
    # entry for nfs connections. If the shell or use=scp mode is used, the 
    # password may not be required (see man pages on setting up password 
    # free ssh/scp connections).

    # THE SECOND WAY TO SET UP AN RSYNC CONNECTION:
    #
    # The VFSrsync package in `{B Filerunner}` allows you to type an "rsync" URL in
    # the directory window at the head of one of the file panes. In this case
    # the remote system (which the URL addresses) must support the access either
    # with an rsync daemon or one of the rsync shell access modes. The rsync VFS
    # package uses the entry in the rsync table to determine the "mode" of the
    # access and if "use=<op>" appears, <op> is used to access the remote.
    #
    # Example:
    #
    # set config(rsync,table) {`{next;in 1 3}`
    #    { {} {} shell {-az} mypwd}`{next}`
    #    {//roadracer/c c:/users/me }       (uses default mode, ops)`{next}`
    #    {ftp://ftp.yonder.com /home/me/ shell {-az}}`{next}`
    #    {ftp://ftp.wild.com /home/me/ shell {-az --rsh="ssh -p 1022"}}`{next}`
    #    {sftp://tame.com:1022 /home/you use=scp {-BC -P 1022}}`{next}`
    #    }`{next;in 0}`
    # Note on the last entry the ':1022' port is not used but must be here
    # to match the sftp dir line. The actual port used is supplied by '-P 1022'
    #
    # 
  }
  AddConf $fid config(vfs,helptable) "2" {
    # From time to time additional help is needed by some of the VFS packages
    # to configure themselves. This may be global (i.e. all connections
    # for the given package) or local to specific connections. In this table
    # such options may be provided. In order for these to work the target
    # VFS package needs to access this table.
    
    # The VFS Helptable is a list of connection option entries. The connection
    # which is a URL which may be more or less specific (say "sftp://")
    # or more specific say ("sftp://host").
    # The code will find the best match
    # i.e. the one where all the parts of the connection (i.e. protocol,
    # address, user and port) either match or are absent and the most parts
    # match. Usually entries should be in the order of increasing specificity,
    # so, for example, and entry for "sftp://" would proceed one for
    # "sftp://some.com"
    # The URL parts are: "sftp" "host" "user" and "port" entered as:
    # "sftp://user@host::port".
    
    # At this time the VFSsftp package looks here for run time options and
    # also permission to use recursive access on reading or writing of
    # directories. The following options are supported:`{next}`
    
    # run=<runoptions> (default is {-oPort=$port -p})`{next}`
    # rcopyok=<?>      (default is {rcopyok=3} `{in 1 17;next}`
    #                  (1 means read recursive is supported,
    #                  2 write recursive, 3 both))`{next;in 0}`
    # rmdirempty=<bool> (default {rmdirempty=0}`{in 1 17;next}`
    # (0/1 can't/can delete a non-empty dir))`{next;in 0}`

    # VFSftp looks here to enable "active" mode which looks like:`{next}`

    #  mode=active`{next}`
    
    #
    # Each option should be surrounded by braces and may contain
    # "$port" to reference the port. The  "-p" indicates that sftp should
    # preserve modification times, access times, and modes.`{next}`
    # A examples are:
    #
    # set config(vfs,helptable) {`{next}`
    #                             {sftp://foo {run=-oPort=$port -p} rcopyok=0}`{in 1 17;next}`
    #                             {ftp://foo  mode=active}`{next}`
    #                           }`{next;in 0}`
  }
  putsTrim $fid {
    #****** `{B "FILE & DIRECTORY HANDELING OPTIONS"}` `{fill *}`

    # Options on when permission is to be requested, how & what files are displayed,
    # sorted and the list is scrolled.
  }
  putsTrim $fid {
    #****** `{B "INTERNAL PANE UPDATE OPTIONS"}` `{fill *}`

    # File list auto update time and automatically.
  }
  putsTrim $fid {
    #****** `{B "MOUSE MANAGEMENT"}` `{fill *}`

    # Focus and wheel options.
  }
  putsTrim $fid {
    #****** `{B "START & SHUTDOWN OPTIONS"}` `{fill *}`

    # Default directories to start with, save config on exit.
  }
  putsTrim $fid {
    #****** `{B "USER BUTTON CONFIGURATION"}` `{fill *}`

    
    # You may configure one or more generic buttons for the center button list.
    # Each button has a label (what you see on it) and a couple of options.
    # Here is the syntax:
    #
    # set config(userButton,name) {`{next;in 1}`
    #                              command     <command>`{next}`
    #                              label       <label> (default name)`{next}`
    #                              dirs        bool    (default 0)`{next}`
    #                              numparms    string  (default *)`{next}`
    #                              nomultiple  bool    (default 0)`{next}`
    #                              prior       bool    (default 0)`{next}`
    #                              viewout     bool    (default 0)`{next}`
    #                              exec        bool    (default 1)`{next;in 0}`
    #                             }`{next}`
    #
    # The `{in h}`name is what ever string of numbers and letters, excluding spaces
    # you would like. It is recommended that it be close to the string
    # used for the label.`{next;in 0}`
    # The `{in h}`<label> should be no more than 10 alphnumeric characters.
    # It should not include
    #  $[{"} ]. It must be enclosed in curly braces ({}) if
    # it includes spaces.`{next;in 0}`
    # The `{in h}`dirs bool indicates the command can handle directories
    # (1) or not (0).`{next;in 0}`
    # The `{in h}`numparms entry should be one of {*  n ==n <n  >n} where:`{next;in 1}`
    # "*"      means any number of parameters`{next}`
    # n or ==n means exactly "n" parameters`{next}`
    # <n       means less than "n" parameters`{next}`
    # >n       means greater than "n" parameters`{next;in e}`
    # The `{in h}`no multiple flag (deprecated) should be set to 1 if the 
    # command should be called with only one file.`{next;in 0}`
    # The `{in 1}`prior flag, if true, includes files from the prior selection.
    # This means you can select files from both panes.`{next;in 0}`
    # The `{in h}`exec bool, if false, indicates that the command is a Tcl script to
    # be executed locally (i.e. in fr).`{next;in 0}`

    # Note: `{in h}`The total number of selected files is checked against "numparms".
    # If the "prior" flag is true, the prior selection (same pane or opposite) is
    # included in the count, if false, they are not. In general you should set
    # the "prior" flag to 0 (false) unless you really need to include files from
    # both panes.`{next;in 0}`
    
    # The `{in h}`viewout flag indicates that the output of the command
    # should be put in a "View" window.`{next;in 0}`
    #
    # These `{in h}`dublets may appear in any order and the key words
    # (command label dirs nomultiple and viewout may be abbreviated.
    # Only command is required. You may also refer to the following $vars in
    # the 'command' entry:`{next}`
    
    # $pwd  is the directory of the selected file(s)`{next}`
    # $opwd is the directory of opposite pane`{next}`
    # $file is a tcl list of the referenced files.`{next;in e}`
    
    # Here `{in h}`is an example for an editor that can handle
    # directories and multiple files:`{next;in e}`
    #
    # set `{in h}`config(userButton,emacs) {`{next;in e;in 1 2}`
    # com {emacsclient --no-wait %s}`{next}` dir 1`{next;in e}`}
    #
    # And `{in h}`here is one to stream a file (or a directory full of files
    # audio or video) via "VLC" to a chromecast device (such as the google mini)
    # (note that the "command" line wraps, i.e.:`{next;in e}`
    #
    # set `{in h}`config(userButton,cast) {`{next;in e;in 1 2}`
    #                     com {`{next;in 1 2}`vlc `{in h}`%s --sout "#chromecast" --sout-chromecast-ip=10.235.7.80
    #--demux-filter=demux_chromecast &`{next;in 0}` }`{next}`
    #                    dir 1`{next}`
    #		         label google1`{next;in 0}`
    #                    `{next;in e}` }

    # Here `{in h}`is an example where we want to move a file to
    # 'BackUps~' a sub-directory and append a '~' to the name:`{next;in e}`
    #
    #  set `{in h}`config(userButton,ToBackUps) {`{next;in e;in 1 2}`
    #            dir 0`{next}`
    #            num 1`{next}`
    #            exec 0`{next}`
    #            com {`{next;in 1 2}`
    #               file `{in h}`%rename %s $pwd/BackUps~/[file tail {*}$file]~
    #         `{next;in 0}`    }`{next;in e}`
    #   }


  }
  AddConf $fid  {config userButton,*}  "" {
    # Currently defined user Buttons:
    
  }
  putsTrim $fid {
    #****** `{B "HTTP CONFIGURATION"}` `{fill *}`
  }

  AddConf $fid config(http,proxy) "" {
    # HTTP proxy. Format: host:port (for example: proxy.foo.com:80). 
    # Leave empty if you have a direct connection to the net.
  }

  putsTrim $fid {
    #****** `{B "APPEARANCE - COLORS"}` `{fill *}`
    
    # Except for the first two items (gray and middle button color) the colors
    # are more easily edited from the Configuration->Color Edit Menu.
  }

  AddConf $fid config(gray) "" {
    # The color gray is spelled grey in some places.  If you put your favorite
    # spelling here, we promise to use that spelling when offering up color
    # names that contain gray/grey.  Note that all named color values that have 
    # gray in their names are duplicates of those with grey in their names (and
    # vice versa) so we need contend with only one spelling.
  }
  AddConf $fid config(middle_button_colors) "" {
    # This configuration is deprecated in favor of the "middle_button_list".
    # This contains a list of background colors for the middle row command
    # buttons. The syntax is:`{next}`
    #  set config(middle_button_colors) {`{next}`
    #    { ButtonName [-]Color }`{next}`
    #    ...`{next}`
    #  }`{next}`
    # An example:`{next}`
    #  set config(middle_button_colors) {`{next}`
    #    { Copy #0000ff }`{next}`
    #    { Delete yellow }`{next}`
    #    { Delete -red }`{next}`
    #    { Move -red }`{next}`
    #  }`{next}`
    # The Copy button inactive color will be blue and the Delete button 
    # will be yellow. The Move and Delete buttons will turn red only when they
    # are active i.e. when the mouse moves over them. Buttons not mentioned
    # will get the default scheme color.
    #
    # Note: Since choosing an inactive color will automatic choose a lighter 
    #       'active' color, if you want to choose both an inactive and an active 
    #       color for the same button, you should arrange this list to put the
    #       'active' color for the same button after the inactive color for it.
  }
  
  AddConf $fid {config gui*,color_bg} "" {
    # `{ifThis {$::MSW} {For each entry starting with "config(gui" there are two
    # entries, the "config(gui,*)" entry and the "config(guiE,*)" entry. The values
    # for the "guiE" entries are used when `{B Filerunner}` is run in "elevated" mode and
    # the "gui" values are used in "normal" mode. This is to allow a distinctive
    # appearance in elevated mode.}}`
    
    # Background color of listboxes etc.
    # You can edit this easier from the configuration menu.
  }

  AddConf $fid {config gui*,color_fg} "" {
    # Foreground color of listboxes etc.
    # You can edit this easier from the configuration menu.
  }

  AddConf $fid {config gui*,color_cmd} "" {
    # Color for commands in the command window.
    # You can edit this easier from the configuration menu.
  }

  AddConf $fid {config gui*,color_select_bg} "" {
    # Selection background color.
    # You can edit this easier from the configuration menu.
  }

  AddConf $fid {config gui*,color_select_fg} "" {
    # Selection foreground color.
    # You can edit this easier from the configuration menu.
  }
  AddConf $fid {config gui*,color_highlight_bg} "" {
    # Highlight background color. This is the color of the last
    # selection and is the second argument for the diff command.
    # You can edit this easier from the configuration menu.
  }

  AddConf $fid {config gui*,color_highlight_fg} "" {
    # Highlight foreground color.This is the color of the last
    # selection and is the second argument for the diff command.
    # You can edit this easier from the configuration menu.
  }

  AddConf $fid {config gui*,color_handle} "" {
    # The 'handle' color is the color of the 'handles' that allow
    # you to change the size of the listbox columns.
    # You can edit this easier from the configuration menu.
  }

  AddConf $fid {config gui*,color_scheme} "" {
    # Scheme color.
    # Default Tk seems to be "grey85".
    # You can edit this easier from the configuration menu.
  }

  AddConf $fid {config gui*,color_cursor} "" {
    # Cursor color.
    # You can edit this easier from the configuration menu.
  }

  AddConf $fid {config gui*,color_flash} "" {
    # Flash color is used in command completion messages as 
    # well as in search messages in view windows and the 
    # command windows.

    # You can edit this easier from the configuration menu.
  }

  AddConf $fid {config gui*,color_balloonHelp_fg} "" {
    # Balloon Help foreground color.
    # You can edit this easier from the configuration menu.
  }
  AddConf $fid {config gui*,color_balloonHelp_bg} "" {
    # Balloon Help background color.
    # You can edit this easier from the configuration menu.
  }
  putsTrim $fid {
    #****** `{B "APPEARANCE - FONTS"}` `{fill *}`
  }
  AddConf $fid {config gui*,ListBoxFont} "" {
    # Font for listboxes etc. Must be fixed-width.
    # A good choice is "TkFixedFont"
    # You can edit this easier from the configuration menu.
  }

  AddConf $fid {config gui*,GuiFont} "" {
    # Font for default Tcl/Tk stuff (menus, buttons etc.)
    # Set this to "TkDefaultFont" in order to not change from what it already is.
    # You can edit this easier from the configuration menu.
  }

  AddConf $fid {config gui*,BalloonHelpFont} "" {
    # Font for Balloon Help text
    # Set this to "TkTooltipFont" in order to not change from what it already is.
    # You can edit this easier from the configuration menu.
  }
  AddConf $fid {config overstrike,*} "" {
    # Man pages generate bold and italic text which can be displayed if so desired
    # (see MAN_KEEP_FORMATTING in the man page manual). One of two formating methods
    # used is called overstrike (thus the name of this option). The other format
    # uses console escape codes to encode this information. Filerunner can decode
    # each of these
    # formats and display the page with the requested enhancements. The requests
    # for 'bold', 'italic' or both are converted using the information in these
    # configure three options. (Code other than 'man' output may use these format
    # codes, e.g. filerunner uses these codes in this configuration browser.)
    # You can select from the following options for each of the possible format
    # requests (bold, italic, bold+italic). You may code
    # as many of these as you like, each entry is two parts, the option and the
    # value:`{next}`
    #
    # size        (+ or - point size) `{next}`
    # weight      (normal or bold) `{next}`
    # slant       (roman  or italic) `{next}`
    # underline   (0  or 1) `{next}`
    # background  (a color) `{next}`
    # foreground  (a color) `{next}`
    # borderwidth (in pixals) `{next}`
    # relief      (flat, groove, raised, ridge, solid, or sunken) `{next}`
    #
    # 'size' is taken as a number to be added to the current font size to determine a
    # font size for the overstrike character. This means you don't really need to know
    # the current point size.`{next}`
    # Borderwidth and relief, in general must be used together. A borderwidth of 1 and
    # a relief of 'solid' would draw a box around the characters. `{next}`
    # Underline may appear twice resulting in a darker underline. `{next}`
    # In cases above with an or, the first entry is the default. `{next}`
    # Color may be any named color (the color editor enumerates all the names),
    # or a color number (see the number on the bottom of
    # color patch in the color editor). `{next}`
    # The font used is the 'listbox' font and its size is the default.
    # The as shipped default is 'bold'->"weight bold" 'italic'->"slant italic"
    # and boldItalic->"weight bold slant italic".
    #
    # example: `{next}` set config(overstrike,bold) {weight bold foreground red}
    #
    # config(overstrike,config) if true, uses overstrike encoding in the "config
    # browser" (what you are looking at) You might want to turn this off to
    # edit the config file with a normal editor.
  }
  # AddConf $fid {config overstrike,italic} "" {
  #   # This is the same as overstrike,bold except that the as shipped default is
  #   # "slant italic"
  # }
  # AddConf $fid {config overstrike,config} "" {
  #   # If this is true the config file (what you are looking at) will be enhanced with
  #   # 'overstrike' in some of the comment lines. You might want to turn this off to
  #   # edit the config file with a normal editor.
  # }
  putsTrim $fid {
    #****** `{B "APPEARANCE - DIRECTORY - OTHER"}` `{fill *}`
  }
  AddConf $fid config(ListBoxColumns,right) "2" {
    # This structure defines the listbox layout.  The three parts are:
    # The window name (never never NEVER change this),
    # the window width,
    # and the window label.
    # You may change the label and the width, but the width is easier to 
    # change by dragging the label separator in the window.
    #
    # Also, the order is the order the sub windows appear.  This you may change,
    # but, again, it is easier to drag the label in the window to do the same thing.
    #
    # Note: the '[_  text ]' below tells the localize routine to replace the
    # 'text' with a local version.  While this should be this way for the disto,
    # feel free to eliminate the [_' and the ']'.
    #
    # You can add and delete entries form the list, however, the first part
    # (the window name) must come from the 'config(ListBoxScripts)' (see below
    # two entries down), so if you add and new script, you can then refer to
    # it in this list.  Also, a given 'window name' may only be used once in
    # each of the list boxes. 
  }
  AddConf $fid config(ListBoxColumns,left) "2" {
    # This is the same as above but for the left listbox.  Usually they will be
    # the same, but that is not required.
  }
  AddConf $fid config(ListBoxScripts) "2" {
    # This is list of scripts that `{B Filerunner}` will use to format column entries
    # in the directory list boxes.  This is here to allow you to add new columns.
    # Each column window is filled with the info provided by the script.  The
    # following variables are available for this script:
    # $file   file name (without the directory part)`{next}`
    # $ffile  file name with the '@' and '/' tags attached`{next}`
    # $dir    directory name`{next}`
    # $type   file type (n normal, d directory, l normal link, ld directory link)
    #         FTP file types are the same as above with a leading 'f'`{in 1 8;next;in 0}`
    # $size   file size`{next}`
    # $mtime, $ctime, $atime The modify, create and access times for the file`{next}`
    # $mode   file mode in wrx format`{next}`
    # $usergroup  files owner ship`{next}`
    # $link   link name or blank`{next}`
    # `{ifThis {$::MSW} {# $nlink  The 
    # short file name if 'DIR' option on (see useDir below)`{next}`} {
    # $nlink  The number of links in the files dir entry`{next}`}}`
    # $inst   either 'left' or 'right', indicates the file list pane`{next}`

    # Please note that these entries are live.  If you mess them up it is possible
    # or even likely that `{B Filerunner}` will not run.  Do keep a back up config file
    # if you plan to tread here.   `{ifThis {$::MSW} {As shipped,
    # there are two entries that will do the 8X3 name, 'short' and 'shortDIR'.
    # For `{B Filerunner}` versions after 17.09.xx.xx 'shortDir' has been removed as the
    # '/x' feature of 'DIR' loses link information as a side effect.
    # The 'short' entry will always work. (See the note at the head of this
    # listing for information on how to restore an entry to the 'as shipped'
    # version.)}}`
  }

  putsTrim $fid {
    #****** `{B "APPEARANCE - SIZE - LOCATION"}`  `{fill *}`
    # These options control the size and location of "view" windows, including the "error"
    # window, and windows created for some commands (Diff, Find, etc.). (Some terminology:
    # "Screen" refers to the total display area which may be on more than one physical device.
    # "Monitor" refers to a physical device. "Monitor workarea" refers to the Monitor less
    # any docked windows (such as task bars or panels).)
    #
    # New windows will always be displayed on the monitor containing the mouse (or the one
    # the mouse is nearest to).
    #
  }

  AddConf $fid config(geometry,main) "" {
    # The X11 geometry string deciding where and how big the `{B Filerunner}`
    # main window should be at start up. This size will always be used,
    # however the location depends on the following (geometry,mainops).
  }

  AddConf $fid config(geometry,mainops) "" {
    # This option specifies how the "geometry,main" above is to be interpreted.
    # This is primarily for those who have more than one monitor.
    # (MCM means "Monitor Containing the Mouse").`{next}`
    
    # Value      What it means `{next}`
    # absolute   Use "geometry,main" exactly as it is.`{next}`
    # relative   Use "geometry,main" as the relative location in the MCM`{next}`
    # center     Center in the MCM`{next}`
    # random     The window will be put where ever Tk puts it.
    #
    # `{B Filerunner}` "as shipped" value is "absolute". Only the first letter is
    # checked on these options and "absolute" is the fall back.
  }
  
  AddConf $fid config(geometry,textviewer) "" {
    # The X11 geometry string deciding where and how big the `{B Filerunner}`
    # text viewer window should be.
  }

  AddConf $fid config(geometry,qedit) "" {
    # The X11 geometry string deciding where and how big the `{B Filerunner}`
    # quick-editor window should be.
  }
  AddConf $fid config(geometry,max) "" {
    # This sets the maximum width and height of the "view" windows.
    # Syntax is "width option" x "height option". The width and height option part
    # consist of a key <string><number> except "fixed" which may or may not have
    # a number. If "fixed" has no number the width/height is taken from
    # "config(geometry,textviewer)" Spaces are optional. If the height part
    # is missing or null, the width option is used by default. Only the first character
    # is checked in the key.
    # The three options are:`{next}`
    #
    # option                              key         number`{next}`
    # percent of "available workarea"  :  availablewa number`{next}`
    # percent of "main window"         :  mainw       number`{next}`
    # fixed                            :  fixed       number`{next}`
    #
    # Where "numbers" indicate the percentage except for fixed where it is
    # the number of pixels. Percentages and may range from 10 to 150, but all
    # windows will be constrained (at least on
    # creation) to fit in the "monitor workarea". For example:`{next}`
    
    # set config(geometry,max) a50`{next}`
    # set config(geometry,max) a50xmainw75`{next}`
    # set config(geometry,max) fixed`{next}`
    # set config(geometry,max) {mainw 50 x avail 50}`{next}`
    #
    # The braces are only needed if spaces are used.
    
    
  }
  AddConf $fid config(geometry,min) "" {
    # This sets the minimum width of the "view" windows. The syntax is the same as
    # the max option above, however, the option key words differ:`{next}`
    #
    #         option                      key         number`{next}`
   
    # percent of actual maximum line length: percent  number`{next}`
    # percent of actual number of lines    : percent  number`{next}`
    # actual maximun line length plus "n"  : addspace number`{next}`
    # actual number of lines plus "n"      : addlines number`{next}`
    # fixed                                : fixed    number`{next}`
    #
    # Again only the first letter of the option is checked. The difference
    # between adding spaces or lines depends on the option being before the "x"
    # (spaces) or after the "x" (lines).
    # If the minimum line length gives a window wider than the "max" width, the "max"
    # width is used.

    # For example:`{next}`

    # set config(geometry,min) a5       adds 5 spaces to width and 5 lines`{next}`
    # set config(geometry,min) a5xa2    adds 5 spaces to width and 2 lines`{next}`
    # set config(geometry,min) fixed    use widthxheight from geomerty,textvew`{next}`
    # set config(geometry,min) {percent 105 x addlines 2}`{next}`
    #
    # The braces are only needed if spaces are used.

  }
  AddConf $fid config(geometry,location) "" {
    # This sets the location of the new window. All windows are
    # constrained to be completely in the "available monitor area" containing the
    # mouse. There are five options on the Y location and
    # four options on the X location of a new window:

    # Y options`{next}`
    # centered on the main window           : cmw`{next}`      
    # centered in the "monitor workarea"    : cama`{next}`
    # on left/above  "monitor workarea"     : left`{next}`
    # on right/below  "monitor workarea"    : right`{next}`
    # tiled (starts at fixed Y)             : tiled`{next}`
    # random{fixed}                         : random`{next}`
    # fixed(by config(geometry,textviewer)) : fixed`{next}`
    #
    # X options`{next}`
    # same as Y options
    # 
    # These options are to be combined as X Y, for example:
    # set config(geometry,location) {right fixed} 

  }
  putsTrim $fid {
    #****** `{B "APPEARANCE - WINDOWS"}` `{fill *}`
  }
  AddConf $fid config(columnScroll) "" {
    # This controls the position of the column scroll bar.  Possible values are:
    # 0 No column scroll bar. 
    # 1 Top of the column
    # 3 Bottom of the column
    #  You can also pull the windows left & right with the mouse.
  }
  AddConf $fid config(columnScrollSize) "" {
    # This sets the thickness of the column scroll bar.  Recommended size is 8.
    # The other scroll bars are sized at 11.  This size affects the minimum 
    # column width (must be wide enough to contain the two end arrows).
  }


  AddConf $fid config(middle_button_list) "2" {
    # This is a list of the middle buttons in the order they will be
    # presented. Feel free to reorder these.
    # There are three sources for middle buttons:

    # 1. The built in code`{next}`
    # 2. User defined buttons`{next}`
    # 3. Buttons found in the cmds file in the .fr directory.`{next}`
    
    # The button build code scans four sources looking for buttons:
    # First this list (config(middle_button_list) and then the above three.
    # Any buttons that are found and not in the middle_button_list are
    # added to the end of the list. Each element in the list has
    # at least three and up to five elements.

    # The first is the button name.
    # The button name is used to manage the code behind the button.
    # If more than one button with the same name is found, the first found
    # (in the above order) wins. 

    # The second element is the display name. This is defaulted to the
    # button name but may be change here (except for user defined buttons
    # which have their own "label" entries) to create a new display name.

    # The third element is the enabled flag. This must be a tcl boolean
    # (1 on true 0 off false). Any button may be disable but it will remain
    # in the middle button list.

    # The optional fourth and fifth entries are button color entries. Two colors
    # are possible, the active and the inactive colors. An active button is one
    # that is under the mouse. Each state is defined by either a named color or
    # a hex number (e.g. #0000ff). In the middle button list the active color should
    # be indicated by putting a minus (-) sign in front of it. If you choose only
    # the inactive color, the code will define a lighter color for the active color.
  }

  AddConf $fid config(cifs,shares) "" {
    # This table containes information on how to handle mounting of "CIFS" shares.
    # A CIFS share with looks like: "cifs//:user@server/share". The "user" is
    # optional, but allows different users to have different options. If not
    # given the user from the password locker is used. A table
    # entry has the following fields:

    # The share URL e.g. "cifs//:user@server/share"`{next}`
    # -drive   'drive letter'`{next}`
    # -display 'display name'.`{next}`

    # A drive letter (to map the share to) is a letter or "*" followed by a
    # colon, e.g. "k:" or "*". The drive letter may be either case.

    # The "*" form tells the system to choose a letter. No drive letter tells
    # the system to not assign a drive letter but to use '//server/share' as
    # the root of the remote file system.

    # The 'display name' has the following possibilities:

    # None     Do not generate a "Display Name" (DN) `{next}`
    # VolOnly  Generate a "DN" for the "HotList" only`{next}`
    # Hot&Vol  Generate a "DN" for the "volume and the "HotList"`{next}`
    # Ignor    Do not ever set up the share.`{next}`
    #
    # The "DN" may be abbreviate (to one char) one of {N V H I} and may
    # have either case. If a "Display Name" is generated the
    # config(DisplayNameShare) entry governs its formatting. 

    # At start up (and after a configuration edit) `{B Filerunner}` reads this
    # table and attempts to connect any "share" named here (if not already
    # connected) using the given drive letter. If susessful it then sets up a
    # "Display Name" for the share as per the "-display" entry. Successful
    # set up depends on the "server" being up and accepting connections and
    # (usually) a user name and password (from the password locker).
    #
    # Example:

    # set config(cifs,shares) {`{next}`
    #     {cifs://Tom@tomscpu/usertom`{next}`
    #         -drive t:`{next}`
    #         -display Hot&Vol}`{next}`
    #     }`{next}`
    
    # If the '-drive' is not given no drive letter will be mapped. If the
    # '-display' is not given no display name will be generated.
    
  }
  putsTrim $fid {
    #******* `{B "SHELL CONFIGURATION"}` *`{fill *}`
  }

  AddConf $fid config(shell,height,left) "" {
    # Height in lines of text of the left shell text window.
  }

  AddConf $fid config(shell,height,right) "" {
    # Height in lines of text of the right shell text window.
  }

  AddConf $fid config(shell,buffer) "" {
    # Size of shell buffer, in lines of text.
  }

  AddConf $fid config(shell,aliases) "2" {
    # Shell aliases, in the form of a list of doublets:`{next}` " { alias, command } .. "
    # If there are arguments to the command line they are just tagged onto the
    # alias. (I.e, aliases can take arguments)
  }

  putsTrim $fid {
    #****** `{B "MISC CONFIGURATION"}` `{fill *}`
  }

  AddConf $fid config(startpwd,left) "" {
    # At start up, show this directory in the left panel.
    # If you set it to "", `{B Filerunner}` will show the working directory when
    # it was invoked. If you put "~/" it will show the home directory.
    # If this is a file `{B Filerunner}` will show its directory and
    # highlight that file.
  }

  AddConf $fid config(startpwd,right) "" {
    # At start up, show this directory in the right panel
    # If you set it to "", `{B Filerunner}` will show the  working directory when
    # it was invoked. If you put "~/" it will show the home directory.
  }

  AddConf $fid config(fileshow,all) "" {
    # 1 -> Will show hidden files.`{next}`
    # 0 -> Won't.
  }

  AddConf $fid config(fast_checkboxes) "3" {
    # You can configure check boxes to appear on the top menu bar. The following
    # are available.  You may sort these to get them to appear in your desired 
    # order.  Change the "d" to "Y" to get the box to appear.  The second item
    # in each entry is the value to use as a label for the check box.  Feel
    # free to edit the label or even eliminate it (by using {}).  (Balloon help
    # will still tell you what the box does.) The Help messages appears here to
    # help you understand what each one does. If you move an entry, be sure to
    # move the whole entry, including the Help message. Deleted entries will
    # automatically be added to the end of the list. You may delete all of them
    # to get a fresh list in the "shipped" order.
  }
  set width 0
  foreach ent $config(fast_checkboxes) {
    lassign $ent first second
    set width [expr max($width,[string length "$first $second"]) ]
  }
  foreach ent $config(fast_checkboxes) {
    set mes [lassign $ent first second flag]
    set sp [string repeat " " \
  		[expr {$width - [string length "$first $second"]} ]]
    puts $fid "    \{{$first} {$second} $sp $flag"
    set mes [regsub -all {\n} $mes { }]
    set mesr [regsub -all { +} $mes { }]
    set f 0
    set l "end"
    while {[string length [string range $mesr $f $l]] > $width} {
      set pt [string last " " [string range $mesr $f $l] $width]
      set mesr [string replace $mesr $pt+$f $pt+$f "\n       "]
      #puts "$f  $mesr"
      set f [expr {$f + $pt +7}]
    }
    puts $fid "      $mesr\}"
  }
  puts $fid "  \}\n"


  AddConf $fid config(balloonhelp) "" {
    # Balloonhelp (aka Tool Tip), if enabled, will popup a help window if you
    # hover on most widgets in Filerunner (i.e. put the mouse on pointer on or
    # in a widget). This help window will usually tell you what things you can
    # do in or with the widget. If one or file is selected in a directory pane,
    # balloon help for that pane is disabled.
    
    # 1 -> Will enable balloon help`{next}`
    # 0 -> disables balloon help.
  }
  
  AddConf $fid config(hoverTime) "" {
    # The time in centiseconds (100 centiseconds = 1 seconds) a mouse needs to
    # hover over a window or button before the 'balloon' help window is displayed.
    # The window will be withdrawn on mouse movement or leaving the widgit. The
    # balloon help will not be displayed on a pane if there is a current selection
    # in the pane.
  }
    
  AddConf $fid config(positiondirs) "" {
    # 1 -> Will 'show' directories when typing a character in to a selected 
    #      directory panel.`{in 1 5;next;in 0}`
    # 0 -> Will 'show' files when typing a character in to a selected 
    #      directory panel.`{in 1 5;next;in 0}`
    # By 'show' is meant that the panel is scrolled so that files (or directories)
    # that start with the typed character will visible. To get files when
    # this is 1, type Cntl-character. Likewise to show directories when this is
    # 0 type Cntl-character. If the sort option 'Dirs Mixed' is set this entry
    # is meaningless.
  }

  AddConf $fid config(focusFollowsMouse) "" {
    # The intent of this is to allow your to type in what ever window the mouse is in
    # regargless of the window being on top or not. This works well in *nix but in
    # MSW it will also raise the window as part of it getting focus. You will get
    # better behavior in MSW by adjusting the mouse in settings.
    
    # 1 -> Will enable focus following mouse`{next}`
    # 0 -> disables focus following mouse (requires restart of `{B Filerunner}`).
  }

  AddConf $fid config(fileshow,dirs) "" {
    # This variable determines how file listings are sorted. Possible values
    # are  "dirsfirst", "dirslast", "mixed"  This is most easily changed with the 
    # configuration menu.

  }

  AddConf $fid config(fileshow,sort) "" {
    # This variable determines what file listings are sorted on. Possible values
    # are:`{next;in 1 8}` "nameonly", "atime", "ratime", ctime", "rctime", mtime",
    #                 "rmtime", "size" and "extension"`{next;in 0}`
    # atime is access time, ctime is creation time, mtime is modify time
    # the r suffex means reverse.
    # This is most easily changed with the configuration menu.

  }

  AddConf $fid config(sortoption) "" {
    # This variable determines how file listings are sorted. Possible values
    # are "-ascii", "-nocase" and "-dictionary".  This is most easily changed 
    # with the configuration menu. Ascii and nocase should be clear.  Dictionary
    # extends "nocase" such that if two names contain embedded numbers the numbers
    # compare as integers, not characters.   For  example, in dictionary mode, 
    # bigBoy sorts between bigbang and bigboy, and x10y sorts between x9y and x11y.

  }
  
  AddConf $fid config(dateformat) "" {
    # Sets date format. Possible values:`{next}`
    # "yymmdd" and "ddmmyy". (yy=year mm=month dd=day)
    # You can also roll your own with:`{next}`
    %d 2 digit day          %T (same as %H:%M:%S)`{next}`
    %m 2 digit month        %D (same as %m/%d/%Y)`{next}`
    %y 2 digit year         %y 4 digit year`{next}`
    %H 2 digit hour         %R (2 digit hour:min:sec) `{next}`
    %M 2 digit minute`{next}`
    %S 2 digit second`{next}`
    # For example "%y%m%d %H:%M:%S" which is the same as "yymmdd" above.
    # The % values come from the tcl "clock" manpage.
  }
  AddConf $fid config(dateformatTop) "" {
    # Same as 'dateformat' but used at in the top of the main window.
  }

  AddConf $fid config(autoupdate) "" {
    # Sets how often `{B Filerunner}` checks to see if it needs to update its 
    # windows.
    # Set this to 0 to disable. Value is in seconds.
  }

  AddConf $fid config(inotify_rate_limit) "" {
    # Sets minimum amount of time between window updates when using inotify
    # (see below).  This allows a trade off of prompt updates vs system load.
    # Value is in seconds.
  }
  AddConf $fid config(inotify_flags) $inotFm {
    # These flags control what
    # events will cause `{B Filerunner}` to update its directory listing(s).  This 
    # update is nearly immediate, however, this requires 'some' overhead.  You
    # can remove some or all of these flags to reduce the overhead.
    # There are
    # two sets of flags, the local ones (inotify_flags) and the non-local ones
    # (inotify_nlflags).  Due to network overhead it is recommended that you
    # use a more restricted (even to nill, i.e. {}) for non-local file systems.
    # `{ifThis {!$::MSW} {
    # This is particularly true for the 'r', 'w', 'a' and 'o' flags.
    # The flags have the following meanings:`{next;in 1 5}`
    #     n  File was created.`{next}`
    #     r  File was read from.`{next}`
    #     w  File was written to.`{next}`
    #     a  File's meta-data (inode or xattr) was changed.`{next}`
    #     C  File was closed (and was open for writing).`{next}`
    #     c  File was closed (and was not open for writing).`{next}`
    #     o  File was opened.`{next}`
    #     m  File was moved away from watch.`{next}`
    #     M  File was moved to watch.`{next}`
    #     d  File was deleted.`{next;in 0}`
    # 'r','w','a','C','c' and 'o' cause just the files line in the window
    #  to be updated while the others require a full reread and display of 
    #  the directory.} {The flags consist of a list of doublets where the
    #  second entry is boolean (0 or 1) The first entries and their meanings are:
    # `{next;in 1 5}`
    #     -access     Changes to the last access time are watched`{next}`
    #     -attr       Attribute changes are monitored`{next}`
    #     -create     Changes to create time are monitored`{next}`
    #     -dirname    Directory name changes (including creation and deletion)`{next}`
    #     -filename   File name changes (including creation and deletion)`{next}`
    #     -size       Size changes are monitored`{next}`
    #     -write      Changes to write time are monitored`{next}`
    
    #  You should only change the boolean values.
    #  Changes that affect only the file size and times will cause only the
    #  files line in the window to be updated while other changes require
    #  a full reread and display of the directory.}}`
  }
  AddConf $fid config(inotify_nlflags)  $inotFm {
    # The inotify_nlflags are the same as above but are used on directories
    # that are not local (nfs or cifs).  Due to network overhead you will
    # usually not want to be as aggressive with the Non Local flags.
  }

  AddConf $fid config(logsize) "" { 
    # Size of log in bytes. Don't set this too high, or `{B Filerunner}` might 
    # slow down a little. When the log exceeds this size, it will be 
    # truncated.  
  }

  AddConf $fid config(check_ownership) "" {
    # If this is "1", `{B Filerunner}` will check as best as it can if you are
    # about to overwrite or delete a file you do not own and warn you about
    # it. This can be handy when working in groups with other people and you
    # want an extra check that you don't accidentally erase someone else's
    # files.  This will slow some operations down slightly.
  }

  AddConf $fid config(keyb_support) "" {
    # If this is 1, it extends the middle button short-cut to include simple ascii
    # characters for most of the middle buttons which will have their short-cut
    # character underlined. Note that Alt-key always does this short-cut.
    
    # Turning
    # this on eliminates the simple "jump to files that start with this char"
    # ability when focus is in a directory pane, but the ALT-key will continue
    # to work (See the "User's Guide" (Help->User's Guide) sections 3.3.5 & 3.3.5.3)
  }

  AddConf $fid config(ask,dir_delete) "" {
    # If 1, `{B Filerunner}` will ask you if you are sure when you delete 
    # directories. If 0, it will go ahead and delete without asking.
    # This flag is used by the 'Move', 'Copy' and 'Rename' commands.
  }

  AddConf $fid config(ask,file_delete) "" {
    # If 1, `{B Filerunner}` will ask you if you are sure when you delete 
    # files. If 0, it will go ahead and delete without asking.
    # This flag is used by the 'Move', 'Copy' and 'Rename' commands.
  }
  AddConf $fid config(ask,save_modified_file) "" {
    # If exiting a view window with no file association (for example after
    # viewing a programs output) that you have modified, this option,
    # if set to 1, will cause `{B Filerunner}` to ask if you wish to save the
    # modified data. `{B Filerunner}` will always ask if a modified view window
    # has an associated file.
  }
  AddConf $fid config(mwheel,delta) "" {
    # For "wheel"-mice (MS Intellimouse or Logitech MouseMan+), set
    # number of lines to scroll when turning mouse wheel.
  }

  AddConf $fid config(mwheel,neg) "" {
    # For "wheel"-mice (MS Intellimouse or Logitech MouseMan+), set
    # mouse button to use for negative scroll movement.
  }

  AddConf $fid config(mwheel,pos) "" {
    # For "wheel"-mice (MS Intellimouse or Logitech MouseMan+), set
    # mouse button to use for positive scroll movement.
  }

  AddConf $fid config(save_conf_at_exit) "" {
    # If true (non-zero): `{B Filerunner}` will automatically save configuration and
    # hotlist at exit.
  }

  AddConf $fid config(create_relative_links) "" {
    # If true (non-zero): `{B Filerunner}` will create relative links
    # instead of absolute links. (e.g ../../foo instead of
    # /a/b/c/foo)`{ifThis {$::MSW} {
    # Windows (NTFS) only allows 
    # absolute links, thus absolute is forced.}}`
  }

  AddConf $fid config(cd_pwd) "" {
    # If true (non-zero): When doing a cd to a new directory, `{B Filerunner}`
    # will run pwd to check where it ended up (which makes a difference
    # if you cd to a link which points to a directory).
  }

  AddConf $fid config(spellingFilter) "2" {
    # The spelling filter chooses what part of a line is spell checked when
    # you spell check in "View" and "Q-Edit" windows.  In the entries below the
    # filter name is first and is followed by the filter script.  You may add
    # your own filter to this list (see the "Users Guide" for help on this).
    # Several filters are provided and may be configured here.
   
    # Provided filters:
    #
    # {}        This is the default filter and causes the whole line to be checked.
    #           This is the {None {}} entry below.`{in 1 10;next;in 0}`
    #
    # qstrings  This filter can be configured to look for two types of strings:
    #           `{in 1}`Single lines (such as "# line" or "// line") as some
    #           languages use.
    #           And strings that have start and end quote marks which may be
    #           1 to N lines long.  E.g. "string" and "/* string */"
    #
    #           qstrings takes two parameters (as well as the string and line 
    #           number that the spell check code supplies):`{next}`
    #           First, the beginning and ending quote strings, e.g.`{next}`
    #                  {\" \"} or {/* */}`{in 1 5;next;in 0}`
    #           Second, the single line start quote string, e.g.`{next}`
    #                  {#} or {//}`{in 1;next;in 0;in 0}`
    #
    # thisstr   This filter takes, as a parameter, another filter and selects
    #           one of the the strings as the string to check.`{in 1}`
    #           This might be used
    #           if you want to spell check a translation list where the 
    #           original and the translation are two stings on the same line
    #           and you want to only check the first or second string.  
    #           For example {thisstr 1 {qstrings {\" \"} {}}} would check the
    #           second string (use 0 for the first string).
  }

  AddConf $fid config(spellcheck,expect) "" {
    # This Boolean, if 1 forces spell check to use "expect" to interact with
    # the spelling program.  Normally "expect" is required only on Windows 
    # platforms.
  }

  AddConf $fid config(search,limit) "" {
    # This value limits the number of search strings saved for use in the
    # search dropdown list. This is used in the search option in 'view',
    # 'Q-Edit', 'Configuration Browser' (this window) and the 'Command' windows.
    # The search code manages this list to keep it in order of recent use
    # and deletes duplicates.
  }
  AddConf $fid config(search,ViewEditStrings) 2 {
    # This is the list of saved search lines for 'View' and 'Q-Edit' windows.
    # This is here to save it from one run of `{B Filerunner}` to the next. You may
    # delete one or more (or all) entries. The first characters may encode
    # the "casefold" and "regular expression" options. `{B Filerunner}` recognizes the
    # following: ~CF~ ~RE~ and ~CFRE~ to turn on one or both options. Anything
    # else is treated as a normal string with neither "casefold" nor
    # "regular expression" active.
  }
  AddConf $fid config(search,CmdConfStrings) 2 {
    # These are the saved search strings for the 'Command' and 'Configuration
    # Browser' windows. See above for more info on managing these.
  }
  AddConf $fid config(manualMonitors) "" {
    # If this is true (i.e. 1) the "monitors" prob will only be done by command from the
    # "Utilities" menu. This will prevent the flashing the prob causes on systems
    # that don't support transparent windows. This need only be called when a
    # monitor is added or removed from the system or when a "panel" is added, removed
    # or changed in size or location."
  }
  AddConf $fid config(monitors) 2 {
    # The "monitors" list is a list, by display, of the "workarea" of each
    # monitor. This is compiled each time `{B Filerunner}` starts and is placed here
    # so that it is available at start time (to position the main window). FYI each
    # display has a sub list for each monitor containing {minx maxx miny maxy}.
    
  }
  AddConf $fid config(DisplayName) "doubles" {
    # The "Display Name" is a list of directories and the name to display
    # (mostly in the directory line at the top of each panel). Each entry is a
    # pair of values where the first is the directory and the second is the
    # name to display. This is mainly used to handle VFS directories, but
    # you may want to add your own. It is here so that it is saved and
    # restored when `{B Filerunner}` exits and is restarted. Display names must
    # be unique and the directories must be "absolute". The syntax is just
    # 'config(DisplayName) {dir1 name1 dir2 name2... }' As usual, any spaces
    # require you to put braces around the dir or name, as needed. The
    # "as shipped" entry here is for <volume> which is the nil ("") directory.
    # Display Names are automatically put in the HotList as well as displayed
    # in the dir list for the nil directory.
  }
  AddConf $fid config(DisplayNameShare) "" {
    # This config entry describes a "format" statement that is used to build
    # "Display Names" for mapped shares. A share looks like: `{next}`
    #
    # \\server\share
    #
    # Which is what is displayed for unmapped shares. Mapped shares are
    # shares that have
    # `{ifThis {$::MSW} {been mapped to a "drive letter:" such as "Z:".} {
    # a mount point (found in fstab, mtab, or autofs files).}}` 
    # As shipped this is set to map such shares as follows:`{next}`
    #
    # share(\\server)(`{ifThis {$::MSW} {drive} {mount-point}}`) `{next}`
    # using: format {%s(\\%s)(%s)} $share $server `{ifThis {$::MSW} {$drive} {$mp}}`
    #
    # `{ifThis {$::MSW} {where "drive" is the drive letter followed by a ":".}
    # {where "mp" is the mount point.}}`
    # You may set this configuration to "{}" (nil) which will cause `{B Filerunner}`
    # to use the as shipped format,
    # or you may define a format command.
    # The following variables are available:`{next}`
    #
    # $share   the shares name`{next}`
    # $server  the servers name`{next}`
    # `{ifThis {$::MSW} {$drive   the "drive letter:"} {$mp      the mount point}}``{next}`
    #
    # You should not use a single "/" in the name (but "//" is ok) (`{B Filerunner}` uses
    # the single "/" to find the end of Display Names). A format statement contains
    # the word "format" followed by a format string followed by the variables to
    # replace the "%s"s in the format string. Within the format string you may
    # use most any character (except the single "/") however "\" needs to be
    # escaped (i.e. "\\"). As and example I like:

    # set config(DisplayNameShare) {format "%s:%s [string toupper $server] $share}

    # Do remember that you are changeing an "as shipped" value
    # (see the configuration preamble above about  changing "as shipped" values.
  }
  putsTrim $fid {
    #****** `{B "COMMND WINDOW WILDCARD OPTIONS"}` `{fill *}`
    # Below are options for command expansion when using the bottom command
    # windows.
  }
  AddConf $fid config(expandWildCards) "" {
    `{ifThis {$::MSW} {This option, if true i.e. 1, tells `{B filerunner}` to
    expand wildcard symbols in any exec calls it builds. Mostly this is useful for
    commands entered in the commnd windows. This is useful in MSW as there is
    little to no wildcard expansion in 'powershell' and none at all in 'cmd'.} {
    Since most commands are run by the shell (usually sh -c) the wild card
    expansion is usually turned off here. You can, however, turn it on here.}}`
  }
  AddConf $fid config(globstar) "" {
    # globstar refers to a 'bash/sh' option by the same name. Basically, if the
    # first two characters of a wildcard are "**" it applies the following glob
    # pattern to all files in the current directory and all subdirectories
    # recursively. Thus the pattern "**/*.tcl" will return all files ending in
    # ".tcl" in the current directory and below. This option allows you to
    # user (1) or not (0) this feature. This option is not passed to the shell,
    # for that use the '.bashrc' file or such.
  }
  

  putsTrim $fid {
    #****** `{B "DANGEROUS CONFIGURATION"}` `{fill *}`
    # Below this point you can change some of the stuff that is used
    # internally by `{B Filerunner}`. This should almost never be necessary if the
    # platform is standard Unix or close to standard Unix. If you change any
    # of this below, make very very sure you get it right. You might want to
    # make a backup just to be safe.
  }
  putsTrim $fid "(This file is \"$::glob(configFile)\".)"
  putsTrim $fid {
    # A note on having the full path to the commands below, like using
    # "/bin/cp" and not just "cp": Lets say you have a dot "." in your path
    # and someone really mean has created a command called "cp" in his home
    # directory that does a "rm" instead. Then you cd to his home directory
    # and type cp <something>, you will invoke his evil manipulated version
    # of cp that removes whatever you intended to copy. The morale of this is
    # to always use full path to critical commands and hope your sysop is
    # not so mean he will rename "/bin/rm" to "/bin/mkdir"...
    # A few commands below do not have specified full path, that's because
    # they aren't very critical and seem to move around between different
    # versions of Unix.
  }

  AddConf $fid config(cmd,sh) "" {
    # This is the command prefix for commands entered in the command lines
    # at the bottom of the `{B Filerunner}` window.
    # `{ifThis {$::MSW} {
    # Set this to null (i.e. {}) (which is "as shipped") to use the 
    # `{B Filerunner}` command line handler. This command line handler will
    # run most anything
    # that 'cmd /C' can plus it handles *nix files that start with '#! <file>'
    # (shebang files) as the first line.
    # This depends on <file>s directory being in the %PATH%
    # (but it may be in any directory on the path, not just the one in <file>).
    # This command line handler will also expand wild card characters in the
    # command. The syntax for these is the tcl 'glob' syntax (ask google for
    # the "tcl glob man page"). And it will not popup a usless cmd
    # window.
    # If CYGWIN is installed you can use you can use '/bin/sh'.
    # If all else fails you can try 'cmd /C' (which will likely popup its own command
    # window).
    # } {	
    # The shell to run the command. This should almost always be /bin/sh.
    # If an option (such as '-c') is needed to execute a command in the
    # command line, it should be here (for example '/bin/sh -c'). If you want
    # to set an sh option (e.g. globstar) do '/bin/sh -O globstar -c'}}`
  }

  AddConf $fid config(cmd,cp) "" {
    # The cp (copy-files) command. You use the internal Tcl file copy routine 
    # by making this empty ({}). `{ifThis {! $::MSW} {
    # Otherwise this should almost always be /bin/cp
    # on Unix/Linux systems.
    # The 'pfr' switches should be here (i.e. 'cp -pfr')`{next;in 1 5}`
    # (p->preserve times/owner)`{next}`
    # (f-> force overwrite)`{next}`
    # (r-> if dir, copy recursively)`{next;in 0}`  
    # DON'T put the -i switch to cp here to get `{B Filerunner}` to display
    # a warning for overwriting a file when copying a file. It won't
    # work and will only make it behave unpredictably.} {
    # Otherwise 'xcopy' works fine.
    # Default is with switches:`{next}`
    #     /I /Q /H /C /K /Y`{next;in 1}`
    
    # (/Q -> Don't display file names)`{next}`
    # (/H -> Copies hidden files)`{next}`
    # (/C -> Continue copying if errors)`{next}`
    # (/K -> Copy attributes)`{next}`
    # (/Y -> Suppresses prompting to confirm...)} }`
    #
  }

  AddConf $fid config(cmd,dircp) "" {
    # This command is used by the 'copy' button when the source is a directory.
    # Again '{}' will use the Tcl file copy code and disallows back-grounding.
    # `{ifThis {! $::MSW} {
    # This can be the same as the 'cp' command above.} {
    # The 'xcopy' command will not copy a single file to
    # a point deeper in the tree if the /S or /E switches are on and we do
    # want one of those on in this command. If you use the '{}' option, when
    # you copy a directory to a new location you will get a new directory at
    # that location with the same name as the source unlike what
    # xcopy does(see below)).`{next}`
    # (/S -> copies directories and sub-directories except empty dirs)`{next}`
    # (/E -> copies directories and sub-directories INCLUDING empty dirs)`{next}`
    # (/I -> Assume destination is a directory)`{next}`
    #
    # Most of (all ?) MS windows copy routines treat the
    # source directory as if the user had added "\*" to it.  This means
    # that the directory pointed at is not copied, but its contents are.
    # Usually (at least from a *nix point of view) one wants the directory
    # replicated in the destination followed by its contents.  If this
    # is what you want, you can tell `{B Filerunner}` to negate the implied
    # "*" by adding "-*" to this configuration parameter as a second
    # entry in the list.  It would then look like:`{next;in 1}`
    #
    # set config(cmd,dircp) {{xcopy /E /I /Q /H /C /K /Y} -*}} }`
    #
  }

  AddConf $fid config(cmd,hardlink) "" {
    # This command is used by the 'HardLnk' button. For information on why you
    # might need this and need it to be recursive please read "File links 101"
    # in the Tips file.`{ifThis {! $::MSW} {
    # The best option is:`{next}`
    # '{{cp -pfrl}}'`{next}`
    # (for meaning of 'pfr' see comments on the 'cp' command above.)`{next}`} {
    # The best option is "{}".  This will then use the internal `{B Filerunner}`
    # hard link code which recursively call the tcl "file link" command. It is
    # also possible that the GNU version of cp will do the hard link recursively,
    # but this is untested. 'fsutil hardlink create' and 'mklink' will not
    # re-curse over directories.
    # Also, this command wants the parameters in the reverse order which is
    # indicated thusly: {fsutil hardlink create %2@s %1@s}}}`
  }
  AddConf $fid config(cmd,chmod) "" {
    # The change mode (chmod) command. This should almost always be /bin/chmod.
  }
  AddConf $fid config(cmd,chown) "" {
      # The change mode (chmod) command. This should almost always be /bin/chown.
  }
  AddConf $fid config(cmd,touch) "" {
    # The touch command. If you have the tcl package "fileutil" you can set this to
    # nill i.e. {}. If you do set it to nill and you don't have the package, fr will
    # tell you about it when you first try to use it.
  }

  AddConf $fid config(cmd,du) "" {
    # The "du" command. Should return size in kilobytes. On many
    # systems other than BSD (?) you need to add a -k argument
    # to this command to get it in kilobytes.
  }

  AddConf $fid config(cmd,find) "" {
    # The find command. If this is {} an internal find routine is used.
    # The internal version is a bit slower (especially for large file sets)
    # and has a bit fewer options but, especially where there is no find
    # command, it does the job.
  }
 AddConf $fid config(cmd,ucmd) "" {
   # This configure builds the 3ed entry in the "Utilities" menu. The first
   # of the two values is the label used in the menu, the second is the command
   # that is evaluated when that entry is selected. 
   # `{ifThis {!$::MSW} {As shipped this command
   # runs fr as root, on the current directories i.e.: `{next}`
   # {{Run fr as root} `{next}`
   # {exec echo [pwLocker::getPw $::env(USER)] |sudo -H -S fr $glob(left,pwd) $glob(right,pwd) &}} `{next}`
   
   # Note that if you don't included the "&" `{B Filerunner}` will wait for the
   # program to exit. You can put what
   # ever you like here if you think some other command is more useful.
   # Or you can enhance what is here by adding full paths and/or additional
   # parameters. (The -H in the default command causes sudo to NOT pass the
   # current HOME environment, but rather to use root's HOME. The -S tells
   # sudo to read STDIN for the password. If you have set up your sudo to
   # not need a password you may eliminate the "S" as well as the: `{next}`
   # "echo [pwLocker::getPw $::env(USER)] |". The command
   # "pwLocker::getPw $::env(USER)" gets root's
   # password from the `{B Filerunner}` password locker. If the password is
   # not found, "pwLocker::getPw" will prompt
   # you for it. You will also be given an opportunity to save the password at
   # that time. The word "$::env(USER)" is just an "ID" for the password that
   # contains the current users password and may be any
   # string (enclose in {} if it contains spaces).)}
   # {The
   # original reason for this command was to provide a way to launch an
   # "elevated" version of `{B Filerunner}` (and this is the "as shipped" value
   # for this entry). On the other hand, you may want to put something here
   # that is more useful to you.} }`

   #  Be careful!
  }
  
  AddConf $fid config(cmd,rm) "" {
    # File remove (or delete) command. If this is {} (i.e. nil) `{B Filerunner}` will
    # use the native
    # Tcl "file delete" command. `{ifThis {$::MSW} {"As shipped"
    # (twapi::recycle_file) this moves the file or directory to the  
    # "Recycle Bin". } {WARNNING: It has come to my attention that the
    # Tcl "file delete"
    # will fail to recursively delete on "CIFS" mounted file systems. Thus
    # the recommended command is "rm -fdr".
    
    # Various *nix systems have their own ways of managing
    # the "Trash". Check
    # if your system has one of these:`{next}`
    # trash-put`{next}`
    # gvfs-trash`{next}`
    # gio`{next}`
    # }}`
    # Several `{B Filerunner}` commands may delete files (Copy, Delete and Move).
    # All these deletes will use this command, thus, if a recycle command
    # is used here, all of these commands may add files to the
    # `{ifThis {$::MSW} {Recycle Bin.} {Trash.}}`
  }

  AddConf $fid config(useDIR) "" {
    # This tells `{B Filerunner}` to try different way of gathering dir info,
    # namely by calling the "cmd dir". If 0, the native tcl way is used.
  }
}
# We produce two sources, usually put in the platform part of fr
puts "start"
set db 0
if {$db} {
  puts "In debug mode"
}
if {!$db} {
  translate
  buildList
  if {$out == "stdout"} {
    puts "Don't really want this on stdout."
    exit 1
  }
  if {[set ext [file ext $out]] == {}} {
    set out1 "${out}l.tcl"
    set out2 "${out}c.tcl"
  } else {
    set out1 [file root $out]l.$ext
    set out2 [file root $out]c.$ext
  }

  set fi [open $out1 w]
  puts $fi "# Left side info for Configuration Browser"
  puts $fi "# Generated by $argv0 on [clock format [clock seconds]]"
  puts $fi ""
  puts $fi "namespace eval ::fr_config {"
  puts $fi "  variable leftSideConfig {"
  set leftMax 0
  foreach ent $glob(edit_configuration_configlist) {
    puts $fi "    [list $ent]"
    set leftMax [expr {max ($leftMax,[string length [lindex $ent 0]])}]
  }
  puts $fi "  }"
  puts $fi ""
  puts $fi "  proc getLeftSide {} {return \$::fr_config::leftSideConfig}"
  puts $fi "}"
  close $fi

  set fi [open $out2 w]
  puts $fi "# Right side info for Configuration Browser"
  puts $fi "# Generated by $argv0 on [clock format [clock seconds]]"
  puts $fi ""
  puts $fi "proc load_now_fr_config {} {}"
  puts $fi ""
  puts $fi "namespace eval ::fr_config {"
  puts $fi "  variable RightSideConfig {"
  foreach ent $result {
    puts $fi "    [list $ent]"
  }
  puts $fi "  }"
  puts $fi ""

  puts $fi "  variable leftMax $leftMax"
  puts $fi ""
  puts $fi "  proc getRightSide {} {return \$::fr_config::RightSideConfig}"
  puts $fi "}"
  close $fi

  exit 0
}
