* wesnoth-mode.el (wesnoth-guess-element-type): Rewritten to avoid recursion.

[wesnoth-mode.git] / wesnoth-mode.texi

\input texinfo
@c %**start of header
@setfilename wesnoth-mode.info
@settitle Wesnoth Mode Manual

@set VERSION 1.3.3
@set DATE October 2008

@dircategory Emacs
@direntry
* Wesnoth Mode: (wesnoth-mode).         Major-mode for editing WML
@end direntry

@c Contact information
@set MAINTAINERSITE @uref{http://www.wesnoth.org/forum/viewtopic.php?t=13798}
@set AUTHOR Chris Mann
@c %**end of header
@finalout

@copying
This manual is for Wesnoth Mode (version @value{VERSION}).

Copyright @copyright{} 2008 Chris Mann

@quotation
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.

This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
@end quotation
@end copying

@titlepage
@title Wesnoth Mode Manual
@subtitle Version @value{VERSION}
@author by Chris Mann

@page

@vskip 0pt plus 1fill
@insertcopying
@end titlepage

@contents
@ifnottex
@node Top, Introduction, (dir), (dir)
@top Wesnoth Mode Manual

@insertcopying
@end ifnottex

@menu
* Introduction::                Getting started
* Navigation::                  Moving around within WML
* Inserting Elements::          Insertion and completion of elements
* Checking WML::                Checking WML for common problems
* Customisation::               Available customisation options
* Key Index::                   Index of Key-Bindings

@detailmenu
 --- Detailed Node Listing ---

Introduction

* Summary::                     Introduction to Wesnoth Mode
* Getting Started::             How to start Wesnoth Mode

Navigation

* Navigation Introduction::     Common WML navigation
* Moving Across Elements::      Moving backward and forward across elements
* Matching Elements::           Moving to the matching element

Inserting Elements

* Standard Completion::         Completion commands and functionality
* Tab-Completion::              Element tab-completion
* Wrapping Elements::           Wrapping elements around sets of tags
* Missing Elements::            Finding and inserting missing elements

Checking WML

* Usage and Capabilities::      What to expect when checking WML

Customisation

* Indentation::                 Customising WML indentation
* Wesnoth Update::              Using and configuring Wesnoth Update
* Macro Definitions::           Making project-local macros known

@end detailmenu
@end menu

@node Introduction, Navigation, Top, Top
@chapter Introduction

@menu
* Summary::                     Introduction to Wesnoth Mode
* Getting Started::             How to start Wesnoth Mode
@end menu

@node Summary, Getting Started, Introduction, Introduction
@section Summary

Wesnoth Mode is a major mode for Emacs which assists in the editing of the
markup language extensively used in Wesnoth, a turn-based fantasy strategy
game.  From the Wesnoth Wiki: "The Wesnoth Markup Language (WML) is used to
code almost everything in Wesnoth, including scenarios, units, savefiles, and
the user interface layout." @footnote{@uref{http://www.wesnoth.org/wiki/ReferenceWML}}

Wesnoth Mode is supported under GNU Emacs 21 onwards and (with some
minor limitations) XEmacs 21.  Wesnoth Mode adds support for syntax
highlighting, automatic indentation, context-sensitive completion,
checking and much more when editing WML.

This documentation attempts to provide a comprehensive guide to
functionality available within Wesnoth Mode 1.3.3, and assumes you are
familiar with basic usage, terminology and customisation of Emacs.  For
more information, please refer to the Emacs
manual. @footnote{@uref{http://www.gnu.org/software/emacs/manual/html_node/emacs/}}

@node Getting Started, , Summary, Introduction
@section Getting Started

To use Wesnoth Mode, add the following to your @file{.emacs}:
@lisp
(add-to-list 'load-path "path/to/wesnoth-mode")
(autoload 'wesnoth-mode "wesnoth-mode" "Major mode for editing WML." t)
@end lisp
Optionally adding:
@lisp
(add-to-list 'auto-mode-alist '("\\.cfg\\'" . wesnoth-mode))
@end lisp
to automatically load Wesnoth Mode for all files with a `.cfg' extension.

If Wesnoth Mode is not the currently active major-mode for the current
buffer, it can be started via @kbd{M-x wesnoth-mode}.

The latest version of Wesnoth Mode along with release notes can be found at
@uref{http://www.wesnoth.org/forum/viewtopic.php?t=13798}.

@node Navigation, Inserting Elements, Introduction, Top
@chapter Navigation

@menu
* Navigation Introduction::     Common WML navigation
* Moving Across Elements::      Moving backward and forward across elements
* Matching Elements::           Moving to the matching element
@end menu

@node Navigation Introduction, Moving Across Elements, Navigation, Navigation
@section Navigation Introduction

Emacs provides many powerful built-in navigation commands which are
ideal for editing WML.  Common navigation commands, such as @kbd{C-n},
@kbd{C-s}, and (in recent Emacsen) @kbd{M-g g}, will behave as usual
within Wesnoth Mode.  However, some navigation commands have been
adjusted or added for increased productivity.  These will be explained
in the following sections.

@node Moving Across Elements, Matching Elements, Navigation Introduction, Navigation
@section Moving Across Elements
@kindex @kbd{C-M-a}
@kindex @kbd{C-M-e}

Next and previous opening elements can be navigated using @kbd{C-M-e}
and @kbd{C-M-a}, respectively.  In each case, point will be positioned
immediately before the element.  When there are no more elements are
available in that direction, point will not move.

@node Matching Elements,  , Moving Across Elements, Navigation
@section Matching Elements
@kindex @kbd{C-c C-o}

Moving to the matching element in a pair or locating the parent element
(depending on the position of point) can be performed via @kbd{C-c C-o}.
When point is on the same line as an opening element, such as an opening
tag or opening preprocessor statement it will be moved to the start of
the matching closing element.  Otherwise, the jump will position point
at the beginning of the corresponding opening element.

@node Inserting Elements, Checking WML, Navigation, Top
@chapter Inserting Elements

@menu
* Standard Completion::         Completion commands and functionality
* Tab-Completion::              Element tab-completion
* Wrapping Elements::           Wrapping elements around sets of tags
* Missing Elements::            Finding and inserting missing elements
@end menu

@node Standard Completion, Tab-Completion, Inserting Elements, Inserting Elements
@section Standard Completion
@kindex @kbd{C-c C-t}
@kindex @kbd{M-TAB}
@kindex @kbd{C-c C-a}
@kindex @kbd{C-c C-m}
@kindex @kbd{C-c C-p}

Tags can be inserted via @kbd{C-c C-t} and alternatively @kbd{M-TAB}
(when this is not shadowed by the Window Manager, etc.).  This will
prompt for the tag to add.  The tag entered into the mini-buffer prompt
and its matching closing tag will be inserted and point positioned
between.

Attributes can be inserted via @kbd{C-c C-a}.  The attribute entered at
the prompt will be inserted along with the `=', with point immediately
after.

Both tag and attribute completion is context-sensitive.  If an element
is available in WML and not listed for completion, you may want to add
it to your `addition file'.  See @ref{Wesnoth Update} for more
information.

Macro insertion can be performed via @kbd{C-c C-m}.  Any arguments known
to be required for the macro will be prompted and inserted in order.
Insertion will be aborted if no value for an argument is provided.  When
within a macro definition, macro arguments are also available to be
inserted.  Project-local macros will not be available until Wesnoth Mode
has scanned the buffer in which they are defined.  For information on
completing project-local macros, see @ref{Macro Definitions}.

Preprocessor statements are available for insertion via @kbd{C-c C-p}.
Closing elements for preprocessor statements will be automatically
inserted where possible, with point positioned between.  Otherwise,
point will be placed immediately after the inserted text.

@node Tab-Completion, Wrapping Elements, Standard Completion, Inserting Elements
@section Tab-Completion
@kindex @kbd{TAB}
Completion can also be performed immediately within the buffer via
@kbd{TAB} on a partial element.  For example:
@example
[scenario]
    vil-!-
@end example
Where @code{-!-} is the position of point.  Using @kbd{TAB} in the
example will complete to @code{vil} to @code{village_gold=}.  Tags,
macros and preprocessor statements can be completed similarly.  When the
current line does not contain a partially completed element, @kbd{TAB}
will perform indentation on the current line.

When there is more than one possible completion, a minibuffer prompt
will be provided, with the partial element entered.  @kbd{TAB} can be
used here to perform completion.  If multiple matches are available,
completion will be performed up to the smallest common substring with
further completion available via the minubuffer prompt.  When no matches
are found, completion will not be prompted.

When completing opening preprocessor statements and tags, Wesnoth Mode
will also attempt to insert a matching closing element if one is not
already available, acting in much the same way as if the element was
added via the minibuffer prompt.  However, if an matching closing
element is available, only the element at point will be completed.

A numeric argument can be provided when performing tab-completion of
opening elements to wrap around the following @i{n} blocks.  For
example, to wrap the completed opening and closing pair around the next
three blocks, @kbd{C-u 3 TAB} can be used.  See @ref{Wrapping Elements}
for more information.

@node Wrapping Elements, Missing Elements, Tab-Completion, Inserting Elements
@section Wrapping Elements
When inserting tags and some preprocessor statements, either via their
respective insertion command or via @kbd{TAB}, an optional numeric
argument can be provided to specify the number of `blocks' to wrap the
element around.  For example:

@example
[multiplayer]
 -!-[part]
        ...
    [/part]
    [part]
        ...
    [/part]
    [event]
        ...
@end example

Where point is at the position indicated by @code{-!-}.  A pair of
@code{story} tags can be inserted around both existing @code{part} tags using
@kbd{C-u 2 C-c C-t story}.  When the number of blocks specified to wrap
around exceeds the number of blocks available, Wesnoth Mode will only
wrap around the number of available so that the nesting of elements is
correct.

@node Missing Elements, , Wrapping Elements, Inserting Elements
@section Missing Elements
@kindex @kbd{C-c C-/}
Missing closing elements can be inserted using @kbd{C-c C-/}.  By
default, this will insert the first missing closing element found in the
current buffer at point.  If all elements appear to be matched or if
there is an excess of closing tags, an appropriate message will be
displayed in the echo area.

@node Checking WML,  Customisation, Inserting Elements, Top
@chapter Checking WML

@menu
* Usage and Capabilities::      What to expect when checking WML
@end menu

@node Usage and Capabilities, , Checking WML, Checking WML
@section Usage and Capabilities
@kindex @kbd{C-c C-c}
@kindex @kbd{C-x `}
@kindex @kbd{C-c C-f}
@kindex @kbd{C-c C-b}
Checking of the current buffer can be performed using @kbd{C-c C-c}.  A
summary of all warnings located will be provided in a separate buffer.
Point can be jumped to the next and previous warning using @kbd{C-c C-f}
(or @kbd{C-x `}) and @kbd{C-c C-b}, respectively.  For visibility,
warnings in the checked WML buffer will be underlined in red by default.
@i{Note: Warning underlines may not be available in XEmacs.}

The WML checking built-in to Wesnoth Mode is not intended to
be an alternative to tools such as `wmllint', but may often be a
convenient substitute while editing WML.

The following conditions can be detected by WML checking in Wesnoth Mode:
@itemize
@item Correct nesting of tags and preprocessor statements
@item Known macro definitions @footnote{see @ref{Macro Definitions}}
@item Availability of elements within the given context
@item Arguments are given to preprocessor statements when required
@item Attributes have a value assigned
@item Corresponding FOREACH..NEXT pairs
@end itemize

WML checking is specific to the version of WML known by Wesnoth Mode.
See @ref{Wesnoth Update} for more information.

@node Customisation, Key Index, Checking WML, Top
@chapter Customisation

@menu
* Indentation::                 Customising WML indentation
* Wesnoth Update::              Using and configuring Wesnoth Update
* Macro Definitions::           making project-local macros known
@end menu

@node Indentation, Wesnoth Update, Customisation, Customisation
@section Indentation

The style of indentation can be customised using
@code{wesnoth-indent-savefile}.  The default value is @code{non-nil},
which results in all children being indented a level deeper than their
parent.  When set to @code{nil}, children will be indented to the same
level as their parent element.  This option is provided only for
consistency when editing (very) old WML.  It is recommended that all new
code be written using the new convention.

By default, Wesnoth Mode will attempt indentation of the current line
and create a newline and when @kbd{RET} or @kbd{C-j} are used.
@code{wesnoth-auto-indent-flag} controls whether Wesnoth Mode will
attempt to indent the current line automatically.  Setting this to
@code{nil} will prevent automatic indentation.  Note that this does not
affect the behaviour of @kbd{C-j} performing indentation following the
newline; this only determines whether indentation will be automatically
performed on the current line.

@code{wesnoth-base-indent} controls the depth of indentation for each
level.  Its value should be an integer.  This is set to `4' by default,
which is the convention used when indenting WML.

@code{wesnoth-warning-face} is the face used to display the overlay for
warnings detected when checking WML (See @ref{Checking WML}).  By
default this is a red underline.  Use of this face may not be supported
under XEmacs.

@node Wesnoth Update, Macro Definitions, Indentation, Customisation
@section Wesnoth Update

Wesnoth Update controls the known WML data for Wesnoth Mode.  To update
this information, three variables need to be set appropriately:
@code{wesnoth-root-directory}, @code{wesnoth-update-output-directory}
and @code{wesnoth-addition-file}.

@code{wesnoth-root-directory} should be the path to the root directory
of a Wesnoth installation or Wesnoth source code.  Wesnoth Update will
search recursively in this directory for WML, using the information
found to provide context-sensitive completion and WML checking.

@code{wesnoth-update-output-directory} specifies the path to store the
WML data found.  This path should be within the @code{load-path}, and
preferably, in the same directory as Wesnoth Mode.

@code{wesnoth-addition-file} specifies the `addition file' to use.  An
addition file is an outline of a valid WML file which is processed for
additional element data.  This should be set as the path a suitable
addition file.  A sample addition file is included with Wesnoth Mode.

For example:
@example
(setq wesnoth-root-directory "/usr/local/share/wesnoth/"
      wesnoth-addition-file
      "~/.emacs.d/wesnoth-mode/wesnoth-wml-additions.cfg"
      wesnoth-update-output-directory "~/.emacs.d/wesnoth-mode/"
@end example

Once set, @kbd{M-x wesnoth-update} will generate and load a new cache of
WML data ready for use for the current and future sessions.  (Please
note, @code{wesnoth-update} may take some time to run.)

@node Macro Definitions, , Wesnoth Update, Customisation
@section Macro Definitions
@kindex @kbd{C-c C-u}

While built-in macros are always available, local macro definitions are
automatically scanned and made known to Wesnoth Mode for each WML file
which is loaded in the session. @kbd{C-c C-u} can be used to update the
known macro definitions for any buffer which has since been
modified. (Note that this is not required when the macro is defined in
the WML file currently being edited as such definitions will be
automatically updated when needed.)  @kbd{C-u C-c C-u} can be used to
clear known local macro definitions.

@node Key Index,  , Customisation, Top
@unnumbered Key Index
@printindex ky

@bye

@c Local Variables: 
@c mode: texinfo
@c TeX-master: t
@c End: