# Glossary

Important: We often refer to outline nodes by the directives they contain. For example, an @root node is a node containing an @root directive, etc. Exception: An @file node is a node whose headline starts with `@file`.

`@file node`
  An `@file` node is a node whose headline starts with `@file`. Important: Headlines that start with `@file-asis`, `@file-noref`, `@file-nosent` (and their abbreviations `@asis`, `@noref`, `@nosent`) are collectively called `@file` nodes.

`@file tree, @others tree, @root tree, etc.`
  An @file tree is a tree whose root is an @file node, etc.
`@asis, @auto, @file, @noref, @nosent, @thin`

  Headlines that start with one of these create (correspond to) derived files. The following synonyms exist:

      @asis, @file-asis
      @noref, @file-noref
      @nosent, @file-nosent

  For more information, see the documentation for @asis, @auto, @file, @noref, @nosent and @thin in Leo's programming reference chapter.

  @auto trees allow you to edit derived files that contain no sentinels. Leo will import the @auto files when reading .leo files. Be careful when first creating the @auto node. Before saving the .leo file containing the new @auto node, use the read-at-auto-nodes command to do the initial import.

`@all`
  A directive that copies the body text of all nodes in an @thin tree to the corresponding derived file. For more information, see directives for programming in Leo's tutorial.

`@others`
  A directive that copies the body text of all nodes except section definition nodes in an @thin tree to the corresponding derived file. For more information, see directives for programming in Leo's tutorial.

`@unit`
  A directive that expands the scope of definitions in @root trees. For more information, see the @unit documentation in Leo's programming reference.

`Body pane`
  The pane containing the body text of the currently selected headline in the outline pane.

`Body text`
  The text in the body pane. Body text is always associated with a particular node.

`Body text box`
  A small blue box in the icon box indicating that the node contains body text.

`Child`
  A node directly contained by a node.

`Chunk`
  A section (noweb terminology).

`Clone`
  A copy of a tree that changes whenever the original changes. The original and all clones are treated equally: no special status is given to the "original" node.

`Clone Arrow`
  A small red arrow in the icon box indicating that the node is a clone.

`Code part`
  A part of a section definition that contains code. Code parts start with `@c` or `@code` directives and continue until the next doc part

`Contract`:
  To hide all descendants of a node.

`CWEB`
  A literate programming language invented by Donald Knuth and Silvio Levy. The CWEB language produces derived files for the C language.

`Demote`
  To move all siblings that follow a node so that they become children of the node.

`Derived file`
  The file created as the result of tangling a node containing an `@root` directive. The file consists of the expansion of the text following the `@root` directive. For more information, see the derived files section of Leo's tutorial.

`Descendant`
  An offspring of a node. That is, a child, grandchild, etc. of a node.

`Directive`
  A keyword, preceded by an '@' sign, in body text that controls Leo's operation. The keyword is empty for the `@` directive. For more information, set the Leo directives section of Leo's tutorial.

`Doc part, @doc part, document part, etc.`
  A part of a section definition that contains comments. Doc parts start with `@` and continue until the `@c` directive or the end of the body text. In @root trees, doc parts are associated with the immediately following code part, if any.

`Escape convention`
  A convention for representing sequences of characters that would otherwise have special meaning. Leo has only one such convention: in @root trees, `@@` in the leftmost column of a code part stands for a single `@` character. Important: Leo does not support noweb's `@<<` and `@>>` escape conventions. Any line containing matched `<<` and `>>` is a section reference, regardless of context. To use `<<` and `>>` as ordinary characters, place them on separate lines.

`expand`
  To make the children of a node visible.

`Grandchild`
  The child of a child of a node.

`Headline`
  The headline text of a node. The part of the node visible in the outline pane

`Hoist & dehoist`
  Hoisting a node redraws the screen that node and its descendants becomes the only visible part of the outline. Leo prevents the you from moving nodes outside the hoisted outline. Dehoisting a node restores the outline. Multiple hoists may be in effect: each dehoist undoes the effect of the immediately preceding hoist.

`LaTex`
  A markup language often used in literate programming environments. See: http://www.latex-project.org/
`Icon box`
  An icon just to the left of headline text of a node indicating whether the node is cloned, marked or dirty, and indicating whether the node contains body text.

`Leo1 and Leo2`

  Leo1 denotes all versions of Leo that write version 1 .leo files, that is, all Windows version of Leo prior to version 2.0. The last version of Leo1, version 1.15, understands enough about Leo2 to issue a warning when opening version 2 files.

  Leo2 denotes all versions of Leo that write version 2 .leo files, that is, all versions of leo.py and all Windows versions with version number 2.0 and above. Only Leo2 can generate derived files from @file trees.

`Literate programming`
  A style of programming that aims at producing the highest quality program listings. Literate programming languages apply two fundamental operations to text: weaving and tangling. Leo supports two literate programming languages, CWEB and noweb. For more links see the literate programming web page.

`Mark`
  A red vertical line in the icon box of a node.

`Node`
  The organizational unit of an outline. The combination of headline text and body text. Sometimes used as a synonym for tree.

`noweb`
  A literate programming language invented by Norman Ramsey. The noweb language can produce derived files for any text-based programming language.

`Offspring`
  The children, grandchildren, etc. of a node.

`Organizing node`, `organizer node`
  A node containing no body text. Organizing nodes may appear anywhere in an @file tree; they do not affect the derived file in any way. In particular, organizing nodes do not affect indentation in derived files.

`Orphan node`

  A node that would not be copied to a derived file. Orphan nodes can arise because an @thin tree has no `@others` or `@all` directives. Sections that are defined but not used also create orphan nodes.

  Leo issues a warning when attempting to write an @thin tree containing orphan nodes, and does not save the derived file. No information is lost; Leo saves the information in the @thin tree in the .leo file. Leo will load the @thin tree from the .leo file the next time Leo opens the .leo file.

`Outline`
  - A node and its descendants.
  - A tree
  - All the nodes of a .leo file.

`Outline Order`
  The order that nodes appear on the screen when all nodes are expanded.

`Outline pane`
  The pane containing a visual representation of the entire outline, or a part of the outline if the outline is hoisted.

`Parent`
  The node that directly contains a node.

`Part`
  A synonym for section. See also code part and doc part.

`pdf file`
  A file that can be read by Adobe Acrobat.

`Plugin`
  - A Python file in Leo's `plugins` folder.
  - A way to modify and extend Leo without changing Leo's core code. `leoPlugins.leo` contains all of Leo's official plugins.

  See Writing plugins and hooks.

`Promote`
  To move all children of a node in an outline so that they become siblings of the node.

`reStructuredText (rST)`
  A simple, yet powerful markup language for creating .html, or LaTeX output files. See the rST primer.

`Root`
  - The first node of a .leo file.
  - The first node of an @root tree or @file tree.

`rST plugin`
  A plugin that supports reStructuredText. Unlike previous rst plugins, the rst3 plugin supports per-node options.

`Scope`
  The portion of the outline in which a section definition is known.

`Section`
  A fragment of text that can be incorporated into derived files. See the Quick start for programmers in Leo's tutorial for more details.

`Section definition`:
  The body text of a section definition node. See the Quick start for programmers in Leo's tutorial for more details.

`Section definition node`
  A node whose headline starts with a section name and whose body text defines a section. See the Quick start for programmers in Leo's tutorial for more details.

`Section name`
  A name enclosed in `<<` and `>>`. Section names may contain any characters except newlines and ">>". See the Quick start for programmers in Leo's tutorial for more details.

`Section reference`
  A section name appearing in a code part. Tangling replaces all references by their definitions. See the Quick start for programmers in Leo's tutorial for more details.

`Sentinels, sentinel lines`
  Comment lines in files derived from @file nodes. Such lines start with an `@` following the opening comment delimiter. Sentinels embed outline structure into derived files. Do not alter sentinel lines. Doing so can corrupt the outline structure. For more information see Sentinel lines in Leo's tutorial.

`Setting`:
  Plugins and other parts of Leo can get options from `@settings` trees, outlines whose headline is `@settings`. When opening a .leo file, Leo looks for `@settings` trees in the outline being opened and also in various `leoSettings.leo files`. `@settings` trees allow plugins to get options without any further support from Leo's core code. For a full discussion of @settings trees, see Chapter 8: Customizing Leo.

`Sibling`
  Two nodes are siblings if they have the same parent. Siblings of the root have no parent.

`Tangling`
  The process of creating derived files from @root trees or @file trees. Leo tangles @file trees automatically when writing a .leo file. You must explicitly tangle @root trees using the `Tangle` command. Tangling expands all section references in an @root node or @file node. For more information, see Tangling @root trees in Leo's programming reference.

`Target language`
  The language used to syntax color text. This determines the default comment delimiters used during tangling and untangling.

`Tree`
  An outline. A node and its descendants.

`Untangling`
  Updating an outline based on changes to derived files. Untangling allows changes to be propagated from derived files back to the outline. Especially useful when fixing syntax errors outside Leo. For more information, see Untangling @root trees in Leo's programming reference.

`View node`
  A node that represents a view of an outline. View nodes are typically ordinary, non-cloned nodes that contain cloned descendant nodes. The cloned descendant nodes comprise most of the data of the view. Other non-cloned nodes may add additional information to the view. See clones & views in the Leo's tutorial for more information.
`Weaving`
  The process of creating typeset documentation from a noweb or CWEB source file. Weaving creates documentation. Tangling creates derived files. Leo does not support weaving directly. To weave a file you can create noweb or CWEB files using Leo's `Export` commands, then use the noweb or CWEB systems to weave those files.