prev leo next

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
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.

prev leo next