General Help for The Dotfile Generator
How to use this help page
In the Dotfile Generators help page you will find information
about the Dotfile Generator, and it's behavior. Furthermore the modules may
insert text, which will describe complicated features, which is difficult
to describe on a single configuration page.
Help page layout
In the following list you'll see the different parts of the help page.
- Index list
- In the index list you can see all the section headers in the help text.
- Help text
- The help text is of course the box showing the actual help text.
- Left and Right arrows
- These two buttons let you travel back and forth in your history
list. This is just like you know them from you favorite web browser.
- Search String
- In the entry at the bottom of the page you can can search for a
string in the help text. The search is case insensitive and it will
search from the current position in the help text.
- Up and Down arrows
- These two arrows will bring you to the previous/next match in your
search.
Note: This help file is also available via WWW
Introduction
The Dotfile Generator is a configuration tool, which let you configure
those awful dotfiles almost every unix program has. For the Dotfile
Generator to configure a given program, it needs a module. To see which
modules are installed on your system, type dotfile without any
arguments in your shell.
To configure a program you will start the Dotfile Generator with the
given module name as argument (as you already did).
This will most likely bring up a load page, where
you can select a predefined setup to load. When you've selected one, The Dotfile Generator
will show a menu structure, which resembles a directory browser. This menu
structure represent several configuration
pages. The pages contains the actual configuration options, and when
you've configured all to your hearts content, you will generate, which will result in a configuration
file for the given program.
The most important thing to know about The Dotfile Generator is that help
is available all the time, just press the right mouse button over the
element you wish to know more about, and help will
be shown either in the help region at the button of the configuration page or in the help browser you are
looking at.
In this section a description can be found on the different elements/pages
of The Dotfile Generator. If you read this continually, please bear in mind
that the help description is written so it is self contained and can be
referenced to from the different pages and menus in The Dotfile Generator.
The load page, is the one which is shown, when you start The Dotfile
Generator, or when you select Reload in the File menu.
This page lets you (re)load a given setup, either one you have created
yourself, one that came with The Dotfile Generator, or sometimes even the
one which is located in your original dotfile.
You may chose to load only some of the configuration
pages or all the pages in the module. To select only some of the pages,
click the Details button.
If you came to this page, from the Reload menu, you may also choose
to reset some of the pages, which means that all configuration on the given
page(s) will be deleted. This is equivalent to pressing the Cancel
button at startup.
On the Detail page, you can select which configuration pages to load, reload or reset. For export files you may choose either to merge
the existing page with the one shown in the item, or you may
overwrite the exiting page, with the one in the item.
Merge means that elements of ExtEntries, will be
merged, ie. the elements will be added to the elements of the ExtEntry.
Overwrite means that the existing page will be totally overwritten.
Both menu items and configuration pages are shown, and when selecting a
menu item, you will (de)select all the items below this menu item.
The configuration pages are the places where you configure your program. Only
one page is visible at a time, though this page may have several Window widgets.
Layout
In the title bar of the window you can see which page you are configuring,
this is very useful when you travel all the pages of the module.
At the bottom of the page you can see which pages will be generated. See
the setup menu for the different possibilities.
Above this, you will see some text. This is the help region. All help for
the configuration page is located there. When you enter the page, general
information about the page is located there. Later when you press the right
mouse button on one of the elements of the page, you will see the help
associated with this element in the help region.
The rest of the page is configuration options. These are built from
entries, check buttons, pull down menus, combo boxes and list boxes. For
further information on these elements, please refer to the user manual.
There are a few extra elements, however, which are specific for The Dotfile
Generator, and they will be described below.
The ExtEntry is an element, which repeats other elements several times. It
is used for configurations, which the user may have zero, one or many
of. Your search path in the shell is a good example of this sort of
information. You may have a number of directories, in which the shell may
search for executables.
To add a new tuple to an extentry, you have to press the button, which look
like this: 
This will also locate
the new element in the view of the ExtEntry.
The tuples in the ExtEntry may be treated just like they were basic
elements. Under the icon which look like this: 
is located a pull down menu with the
following items:
- Cut
- This will copy the tuple to the clipboard, and remove it from the
ExtEntry.
- Copy
- This will copy the tuple to the clipboard, and leave it in the ExtEntry.
- Paste
- This will copy the tuple from the clipboard into the ExtEntry, just
before the one in which the scissors was invoked.
- Insert Blank
- This will insert an empty tuple, just before the one in which
the scissors was invoked.
An ExtEntry may be arbitraryly big, by that reason some of them have an index
element. This index element is used to travel to an other tuple in the
ExtEntry, without having to scroll all the way to it.
If an ExtEntry has an index element, a button which look like this: 
is located next to it. If you press
this button a listbox will show up, and in it you can select the index
element associated with the tuple you want to go to. When you've selected
one, The Dotfile Generator will scroll the ExtEntry to this tuple.
FillOut
The FillOut widget is used to type some text, which is built from
tokens and ordinary text. An example of this is the prompt in your shell.
It is composed by a listbox and an entry. In the entry you can type
ordinary text and insert tokens from the listbox within this text. The
elements of the listbox may either be a basic token, or may be a
configurable one. The configuration is, of course, done with basic Dotfile
Generator widgets.
The configurations on one configuration page, may be located in several
windows. This is especially useful, inside ExtEntries.
A window widget is just a button, which brings up the window when it's
pressed.
In addition to The Dotfile Generator's standard widget, there may be added
some additional widgets, which all bring up a configuration page. At this
moment the following widgets exists:
- Color Widget
- This widget will let you select a color, either by name or by
dragging three scales representing the three basic colors: red,
green and blue.
- Font Widget
- Here you select a font, either by name or by it's basic attributes
(font name, font size etc.)
- File/Directory Browser
- This is an ordinary browser, which you surely know from other
applications.
Menus
At the top of the main window, there is located three pull down menus. These
contain links to different actions, configuration pages and help pages. The
menus may be torn off, which is done by selecting the dashes at the top of
the pull down menu.
This is the most important function in The Dotfile Generator. This is the
one which converts your configurations to the code of the program you are
configuring. The code will be shown in a window and written to
file(s). This can however be configured in the setup
menu. To see how to use the output, please refer to the section below
To generate a large module may take awhile. This delay will be
annoying, if you play around with the different options on a page. To
avoid this, you can regenerate the single page you are working on, and let
the other part of the configuration file be. To do this you have to
generate the whole module first!
This will save your configuration in a file, which lets you continue your
configuration in a later Dotfile Generator session.
You can (re)load the save files from the load menu
This format is version dependent (both The Dotfile Generator version and
module version). It is however very fast compared to the export format.
This will save your configuration to the file you
specify.
This will export your configuration to an export format. This format is
version independent. However it is very slow to import from. So this format
should only be used, if you want to upgrade your Dotfile Generator, or give
your configuration to someone who uses The Dotfile Generator. (ver 2.0 or
later.)
The export format is also used if the module has a filter, which can
convert from the original dotfile to configuration in The Dotfile Generator.
This will let you reload/reset one or more configuration pages.
This will quit The Dotfile Generator. If you have any unsaved changes, you
will be offered to save these.
In the options menu you can configure how The Dotfile Generator behaves. It
contains the following options:
- Name of the file(s) to generate to.
- At the top of the setup window you can specify which file(s) to
generate to, and the comment character for the given file.
- What to generate.
- Next you can select where you want the generated code to go:
Either in file(s), in window(s) on the screen, or both.
- How much to generate.
- You can specify how many pages you which to generate:
- One page.
- The Dotfile Generator will only generate the current visible
configuration page. This is useful, if you experiment with
The Dotfile Generator, to see what it generates for the
different widgets.
- Selected pages.
- The Dotfile Generator will only generated the pages, which
you select. The selection is done at the bottom of the configuration page.
- All pages.
- All the configuration pages are generated.
- Generate Defaults?
- Some of the programs configured by The Dotfile Generator has default
values, which is set when the option is not specified at all in the
configuration file. If you append the output from The Dotfile
Generator to the original configuration file, then this is useful
to ensure that the settings in The Dotfile Generator will overwrite
the original, which may be located in your configuration file.
- Save when Generating.
- When you generate your module, you'll often want to save too. Here you can tell The Dotfile
Generator to do this for you automatically.
- Place windows.
- If your window manager asks you to place the windows, you may tell
The Dotfile Generator that it shall place them for you. This may be
useful...
This will let you configure the header and description on the save- and
export files.
You can mail either a suggestion/comment, a bug report, or a postcard from
The Dotfile Generator.
The postcard is only for encouraging the programmers to make their job even
better, after all... if no one is using our product, we may not want to
spend so much time on it.
This will bring up a window with version information about The Dotfile
Generator and the current module.
This will bring up this help page.
This is a link into the help page, which the module
programmer has written. It should tell you how to use the output from the
current module.
The Dotfile Generator has a home page, which you may
wish to check out. A manual on how
to write modules for The Dotfile Generator is also available on the
net.
A mailing list exists for The Dotfile Generator. You may subscribe by
sending a mail to dotfile-request@imada.sdu.dk with the subject
subscribe. To unsubscribe, let the subject be unsubscribe.
The Fvwm2 Module
Changes Since the Fvwm1 Module
The Fvwm2 module differs from the Fvwm1 module in the same way as the two
programs differ. This means for example that a lot of the global options from
Fvwm1 has been moved into the "Styles of Windows" page, and is configurable on
a per-window basis.
Notes about the state of Fvwm2
Please remember that Fvwm2 is in beta state, which means that this module may
change at times. New pages may appear, and old ones may disappear as the
syntax and/or semantics of the Fvwm2 dotfile changes.
InitFunction and RestartFunction
If you want Fvwm2 to do special things at startup (e.g. start programs and
modules) you have to create the special functions InitFunction and
RestartFunction.
InitFunction is called when Fvwm2 is started (typically when you log in),
and RestartFunction is called whenever Fvwm2 is restarted. This means that
if you want to start som programs this is only necessary to do in
InitFunction, but if you start modules they must be started in
RestartFunction too since modules are killed when Fvwm2 restarts.
Although I have tried to make the Fvwm2 module as complete as possible there
may be some things you cannot configure through the graphical interface
(typically fvwm modules not supported in the dotfile module). Therefore you
will typically "not" generate to the ~/.fvwm2rc file, but to the proposed
~/dot.fvwm2rc. This can be read in your ~/.fvwm2rc file using the Read
command:
--- start of ~/.fvwm2rc ---
Read dot.fvwm2rc
* additional configuration lines *
--- end of ~/.fvwm2rc ---
Bash module
This module will help you configure Bash versions ranging from 1.14.4 to
2.0. The module consists of 17 configuration pages, where you can setup
options as shell prompt, command aliases, completion, error handling and
much more.
Before generating your configuration options, please make sure you have
choosen the right version of Bash (default
1.14.4 to 2.0).
Configuration pages
Below you will find a list of configuration pages in this module. You
can use it to get an overview of the module, and if needed a small
description of each page is included. For further information on each
configuration option on the individual pages, as well as the the
generated output, please read the reference guide.
User/Bash interface
In this section you can configure options concerning the interaction
between User and Bash (i.e. commandline, completion and prompting, etc.)
Prompting
A collection of pages, that will help you setup how Bash is to prompt you.
Command aliases
UNIX often have commands with very cryptic names, or numerous arguments
you have to remember/type each time you use the command/program. With
aliases you are saved from that kind of annoyances. If you are familiar
with C shells (like Tcsh), the major difference is you cannot use
arguments in alias expansions-the alias function in Bash can be compared
with search-and-replace. The use of arguments is provided by
functions, a sort of script-within-a-script, which you can use to
define some shell code by name and store it in the shell's memory, to be
invoked and run later. Due to the versatility of functions, you can not
define functions (-maybe in a later version), but are you interested in
writing shell functions, I can recommend the book Learning the bash
Shell.
Command history
This configuration page will help you setup the history function of
Bash. The history mechanism records your commands, and is very useful if
you make a mistake. Instead of retyping the entire commandline, you just
recall the command, fix the mistake and re-execute the command. Bash has
several ways to edit old commands; either by using incremental search
for a single commandline by using up and down cursor keys, or using the
builtin fc (fix command) command.
Commandline
This configuration page will help you setup options concerning the
commandline. In particular which editing mode is prefered, how to
respond to scripts, etc.
Completion
This page will help you setup options concerning completion and
globbing. You can complete a commandline typing TAB. Bash will complete
the line based on the text before point. Bash attempts completion
treating the text as a variable (if the text begins with $), username
(if the text begins with ~), hostname (if the text begins with @), or
command (including aliases and functions) in turn. If none of these
produces a match, filename completion is attempted.
Job control
Job control refers to the ability to selectively stop (suspend)
the execution of processes and continue (resume) their execution
at a later point. A user typically employs this facility via an
interactive interface supplied jointly by the system's terminal driver
and Bash. If the operating system on which Bash is running supports job
control, Bash allows you to use it. Typing the suspend character
(typically ^Z, CTRL-z) while a process is running causes that
process to be stopped and returns you to Bash. You may then manupulate
the state of this job, using the bg command to continue it in the
background, the fg command to continue it in the foreground, or
the kill command to kill it. A ^Z takes effect
immediately, and has the additional side effect of causing pending
output and typeahead to be discarded.
Keyboard bindings
Here you can setup keyboard macros. A macro is simply a sequeence of
keystrokes or a builtin (readline) command. Typing the key sequence
causes the keys in the macro to be entered as though you had typed
them. Some of the readline commands and their bindings you can see in
Bash module reference guide.
Mail check
You can make Bash check for incoming mail, if you should choose to. The
shell can't actually check for incoming mail, but it check your mail
file periodically and dertermine whether the file has been modified
since last check. Here you can setup how often, what file(s) to check.
TTY appearance
This configuration page covers topics as screen dimensions, bell style,
how to react on commandline exceeding screen width, etc.
System/Bash interface
Here you can configure options that have no affect on interactive
communication with user-not directly anyway. In this group options on
file creation, path search, etc. is found. Please remember, options in
this section is to be altered with much care, as much of this
information is essential for the shell to work properly.
Error handling
This configuration page will help you to setup options concerning
certain exceptions.
File and directory handling
This configuration page will help you to setup options concerning file
and directory handling, how to follow links, etc.
Paths
This configuration page will help you to setup paths. If a path is
already defined, the Bash module will attempt to read it and
auto-fillout the entries. You can then add, or delete in the list as you
please, just bear in mind not to compromise with system security.
System limits
This configuration page will help you to setup how system resources are
shared, e.g. how much disk space a user file may allocate, how much
memory and CPU-time a user process can allocate, etc.
Bash version
In contrast to the other configuration pages, this page will not create
any output, when generating. Here you can specify which version of Bash
you want to generate dot.files for.
This module generate options used by the following two files:
- .bashrc
- which is used for configuring Bash, and
- .inputrc
- holding Readline options (Readline is the builtin Bash commandline
editor).
How to use .bashrc options
You have to options:
- You may generate directly to your ~/.bashrc file. This is
recomented if you do NOT have a ~/.bashrc file
allready, and do NOT plan to add additional code to the
output (i.e. conditions).
- You may generate to an other file than ~/.bashrc
(e.g. ~/.bash-dotfile). this file may then be sourced in your
original ~/.bashrc file, with the command source. The
source line may look like this: source ~/.bash-dotfile
How to use .inputrc options
Where .bashrc allows you to link in other configuration files,
.inputrc does not allow such linking. Therefore you have the
following options:
- You may generate directly to your ~/.inputrc file. This is
recomented if you do NOT have a ~/.inputrc file
allready, and do NOT plan to add additional code to the
output.
- You may copy from the file generated by the Dotfile Generator
(~/.inputrc-dotfile) to your /~.inputrc. When
using simple cut-and-paste, please remember to add your auto-
generated information at the bottom--in this way other old
configurations are overwritten by your new choice.
Good luck!
Second edition, 1997 January 27
Per Zacho
TCSH version
This module is made for tcsh version 6.06.
Version 6.05 is compatible though, except for the variables listflags
and promptchars.
The Manual
The tcsh manual is available via world wide web. This page is the one
which comes with your tcsh installation, so you might have it 'at home'
You have to two possibilities:
- You may generate directly to your ~/.tcshrc file. This is
recomented if you do NOT have a ~/.tcshrc file
allready, and do NOT plan to add additional code to the
output (ie. conditions).
- You may generate to an other file than ~/.tcshrc
(i.e. ~/.tcsh-dotfile). this file may then be sourced in your
original ~/.tcshrc file, with the command source. The
source command should be before any key bindings (the command
binkey), since the page userdefined bindings, will write
either bindkey -e or bindkey -v, which resets all
key bindings. The source line may look like this: source
~/.tcsh-dotfile
RTIN version
This module is made for rtin version 1.2 PL2 [UNIX]
How to use the output
You have to two possibilities:
- You may want to start up rtin just once to make sure it generates the
~/.tin/tinrc file. Simply type rtin from the prompt.
- You then might generate directly to your ~/.tin/tinrc file.
This will just overwrite your old file with the newly added information
as well as the default options you haven't changed.
- You can also generate to an other file than ~/.tin/tinrc (default
is ~/.tin/dottinrc). Thereby you don't change anything that makes
rtin do funny things.