2. Using the OO-Browser

2.1 Invoking the OO-Browser

The OO-Browser supports the following languages: C++, C, CLOS (Lisp), Eiffel, Java, Info (the online manual format), Objective-C, Python and Smalltalk. Use {C-c C-o} or, if that key has not been setup, use `M-x oo-browser RET' to browse source written in any of the above languages. This command will prompt for the name of an existing or new Environment to browse, and then will either create, build or load the Environment, depending on the state of the Environment specification. After the Environment is built, the browser will display the entire set of classes defined or referenced within the Environment. (Choose C++ as the language if you are browsing plain C code.)

Alternatively, you can invoke the browser on a specific language Environment, e.g. to bring back the last Environment browsed under that language. The language-specific browser invocation commands are: `M-x c++-browse RET', `M-x clos-browse RET', `M-x eif-browse RET', `M-x info-browse RET', `M-x java-browse RET', `M-x objc-browse RET', `M-x python-browse RET', and `M-x smt-browse RET'. A prefix argument given to any of these commands will cause it to prompt for an Environment file to use, rather than automatically reusing the last Environment of the same language.

On startup, if the named Environment exists and is built, it will be loaded; otherwise, you will be asked to specify the Environment. The specification will be saved under the previously given file name.

If the browser loads an Environment file and finds only a specification, it will prompt you in the minibuffer window with a request to build the Environment. It will continue to prompt you until a full Environment is built or loaded. It then will start interactive operation, displaying its multi-windowed interface. To abort from these prompts and to cancel the browser invocation request at any time, use {C-g} (keyboard-quit), the standard way to abort an unfinished command within Emacs and InfoDock.

The first time you start the OO-Browser during each editor session, it will display a version and credits screen within the viewer window. When you press any key, the screen will be replaced by the keyboard command help screen of the OO-Browser and the command associated with the key you pressed will be executed. If you'd like to read the rest of the credits, you may redisplay the version screen at any time from within a browser listing window by using {C-c #} (br-version). The {SPC} and {DEL} keys will then scroll the credits forward and backward, respectively, a windowful at a time.

Once an Environment has been loaded, entering and quitting the browser are rapid actions, so that you may smoothly transition between editing and browsing as needed. If you leave the browser using {q} and wish to browse the same Environment again, use {C-u C-c C-o}, which will immediately redisplay the browser just as you left it.

2.2 Displaying Top-Level Classes

The OO-Browser starts by displaying all classes in the Environment. The following commands filter the set of classes so that only top-level classes, those that do not inherit from any others, are shown. The browser can show all top-level classes or System or Library classes only. Once in the browser, use:

{s}

to show only top-level System classes;

{l}

to show only top-level Library classes;

{t} or {T}

to show all top-level classes in the Environment.

The use of any of these commands does not affect the ancestry or descendancy trees for any given class. Each simply limits which trees are easily accessible for browsing. For example, selection of Library top-level classes only, followed by the browser show children command, {c} (br-children), would display the name of a System class if the System class directly inherits from the Library class.

To see an ordered listing of all of the classes in a particular part of an Environment, use a prefix argument with the commands given above:

{C-u s}

shows all System classes;

{C-u l}

shows all Library classes;

{C-u t}

shows all Environment classes. {A} is a shortcut that does the same thing.

2.3 Moving to Entries

Many browser commands operate on the current entry of the selected listing window. {C-n} (br-next-entry) moves point to the next entry in a listing buffer. {C-p} (br-prev-entry) moves to the previous entry. Both take prefix arguments and use them as the number of entries by which to move.

2.4 Writing a Listing to a File

Many standard editing keys are rebound within listing buffers to issue browser-specific commands. Occasionally, you need to be able to store and to edit listing buffers. The {C-c C-w} (br-write-buffer) command provides this capability. The command prompts for a file name under which to save the current buffer. You may then quit the browser, read in the file and edit it as a plain text file.

2.5 Browsing Children and Parents

The {c} (br-children) command displays the children of the class at point. The {p} (br-parents) command displays the parents of the class at point. {C-u c} displays the children of all of the classes from the present listing window; {C-u p} does the same for parents.

2.6 Browsing Descendants and Ancestors

The OO-Browser is very fast at computing ancestor and descendant hierarchies, accounting for multiple inheritance and cycles where permitted. Descendant and ancestor listings provide an immediate overview of some key relationships among class groupings.

With point on any class entry line in a listing buffer, {d} (br-descendants) shows descendants for the class and {a} (br-ancestors) shows ancestors. {C-u d} shows the descendant trees for all of the classes in the current listing; {C-u a} does the same for ancestors.

The ancestor tree for a given root class is normally shown branching out from the root class. This means that higher-level ancestors, those further away from the root class, are shown in descending trees below lower-level ancestors. The leaves of the tree represent the ancestors furthest from the root, as you might expect.

This, however, is the inverse of inheritance trees. Some people prefer to see ancestor trees like inheritance trees, with parents above children. This is an inverted ancestor tree. To obtain this view of ancestors, use {M- -1 a} for ancestors of the current class. For ancestors of all classes in the current buffer, use {M- -2 a}, or any negative prefix argument less than -1. Inverted ancestor trees may be set as the default by making the variable br-invert-ancestors true: `M-x set-variable RET br-invert-ancestors RET t RET'. This is a personal setting that affects all Environments used by the browser.

2.7 Viewing and Editing

One of the major uses of the OO-Browser is to view or to edit class source texts. The {v} (br-view-entry) command will view the source for the class or element name (attribute, method or instance) at point in a read-only mode within the viewer window; it will not select the viewer window. The {e} (br-edit-entry) command performs a similar function, except that it edits the element source in a read-write mode, if the user has write permission for the source file. It also selects the viewer window.

A prefix argument to either of these commands, as in {C-u v} or {C-u e}, causes them to prompt for the entry to display. Full class and element name completion is provided once an Environment has been loaded and built. See section 2.21 Completing Names.

The value of the variable br-edit-file-function is the function that the browser calls when it displays a source file for editing. The value of br-view-file-function is the function called to view a source file. See section Using an External Viewer or Editor, for information on using non-Emacs editors and viewers with the browser.

If you have no read access rights to a file, this will be apparent when the browser tries to display the file and fails. If you lack write permission to the class source file, the standard br-edit-file-function may display the file in a read-only mode (indicated by two percent signs, %%, at the front of the buffer modeline). This is a warning that you should not attempt to edit the file. In some cases, you may really need to edit such a file; then, you may toggle the buffer between read-only and read-write modes via the Emacs command, (vc-toggle-read-only), usually bound to {C-x C-q}.

Once an entry has been displayed for viewing, {SPC} will scroll its source text up (forward) a windowful; {DEL} will scroll it down (backward) a windowful. In fact, this is a general means for scrolling the OO-Browser viewer window whenever point, as shown by the Emacs block cursor, is in a listing window.

For finer control over scrolling when in a listing window, use the {.} and {,} keys to scroll the viewer window by one line forward and backward, respectively. {<} will scroll the viewer buffer to its beginning; {>} will scroll display the end of buffer.

When point is moved to the viewer window, you must use {C-v} to scroll up and {M-v} to scroll down, assuming the standard Emacs key bindings are in use.

Sometimes one needs to quickly switch back and forth between the viewer window and the current listing window. The normal Emacs window movement commands are often cumbersome in such instances. Instead use (br-to-from-viewer) bound to {C-c C-v}. This allows the desired back and forth movement. It acts as a toggle switch, alternately moving between the buffer in the viewer window and the prior listing buffer.

By default, the OO-Browser displays class definition files in their entirety. If there are multiple classes in a file, you will be able to scroll through all of them. If you prefer that only the selected class be visible, enable the br-narrow-view-to-class option flag. When set to `t', this flag narrows the source buffer so that only the class of interest and its preceding comments are visible. To examine other classes in the same file, you must execute a {C-x n w} (widen) command when in the narrowed buffer. (Use {C-x w} under Emacs 18.)

It may be helpful to use the full frame to view or edit a buffer of source code if the browser is run while using a small screen. If point is in a listing buffer, press {1}, the number one, to expand the viewer window to the dimensions of the full frame. When the browser is re-invoked, it will look just as it did before. If point is in the viewer window, {C-x 1} (delete-other-windows), will do practically the same thing, except that when the browser is re-invoked it will not look precisely as it did before.

With point in a listing window, the buffer displayed in the viewer window may be killed with the {C-c C-k} (br-kill) command. (A killed buffer is removed from the current Emacs session.) With point in the viewer window, use the standard Emacs command {C-x k} (kill-buffer) instead.

2.8 Browsing Elements

Most OO-Browser languages support feature browsing, as documented in 6. Language-Specific Notes. Instance browsing is supported in very limited form for class instances which exist within the code itself. For example, under Common Lisp and CLOS, a default class called [function] is defined whose instances are all named functions defined within the source code. A default class is a class automatically created by the OO-Browser to categorize standard elements of particular language Environments. The instances of default classes are constructs statically defined within Environment source code. Default classes themselves are not defined within the source code since they exist only to provide convenient categorization of constructs within the OO-Browser.

Use {f} (br-features) to display a listing of the features or elements of the class at point, including inherited features. For most languages, this includes all defined features but in some languages only routines are included. {C-u f} displays the features or elements of all classes in the present listing window.

Use {r} (br-routines) to display just the routines of the class at point. {C-u r} shows the routines in all listed classes. The {=} (br-attributes) command shows just the attributes of the class at point; each attribute entry is preceded by an = or an & character to distinguish them from other entry types. {C-u =}, as expected, applies to all listed classes.

By default, all inherited features, routines or attributes are shown by these commands, grouped together by the ancestral classes in which they are defined. (The OO-Browser does not yet distinguish between private and public attributes, so all attributes of ancestor classes will be shown, even if some are private.) Give any of these commands a zero prefix argument, e.g. {M-0 f}, and they toggle the display of inherited features on and off for future listings. In fact, you may use the simpler key sequence, {0 f}, since the zero key is specially bound to serve as a prefix argument when in listing windows. If inherited features are off and there are no feature definitions for the class, the class definition is displayed so that you may browse its feature declarations.

Use {v} (br-view-entry) with point on an element name to view its source definition. Use {e} (br-edit-entry) instead to edit its source. Use {F} (br-feature-signature) to see the full signature tag of an element, which includes its argument names and types, if any. {C-u F} lists the signatures of all elements in the current listing. This is handy when several elements from the same class have the same name but differ in signature.

In languages that require method declarations separate from their definitions, some other keys are handy when browsing. (Presently these keys work only for C++ Environments.) Use {j} (br-feature-view-declaration) with point on a feature name to view its declaration; use {J} to edit its declaration within the viewer window.

See section 2.14 Using the Mouse, for how the context-sensitive Action and Assist Mouse Keys may be used for browsing elements.

2.9 Browsing Categories

The definition of a category is language-specific. Some languages such as Smalltalk use categories to group related classes together. The OO-Browser does not yet support this kind of category. It does support Objective-C categories, which segment each class into multiple groupings of related features. Objective-C class categories appear within parentheses when defined, so the OO-Browser displays category names with parentheses around them to distinguish them from classes. The aggregation of all of the categories defined by a class and its ancestors represents the complete class definition.

Use the {C} key (br-categories) with point on a class listing entry to obtain a list of the categories defined for the class within the Environment source code (this excludes inherited categories). Use {C-u C} to list the categories for all classes within the current listing. Thus, to see the full set of categories for a class, use {a} to list the ancestors of the current class and then {C-u C} to show all direct and inherited categories of the class.

Use {v} to view or {e} to edit the class category definition for the category entry at point. See section 2.11 Browsing Implementors, for an explanation of how to browse the classes that directly implement a category.

Use {f} with point on the default [category] class to list all categories defined in the Environment.

2.10 Browsing Protocols

The definition of a protocol is language-specific. It generally refers to an interface specification to which a class must conform. A class conforms to a protocol by implementing the set of features defined in the protocol interface. Protocols consist only of interfaces, without any method bodies, since conforming classes implement the necessary bodies. They generally differ from abstract classes, such as those found in Java and Eiffel, in that they define only the interface for a single facet of a class. The distinction is subtle, however, and abstract classes may be used as a substitute for protocols in languages that do not support protocols.

Presently, the OO-Browser supports protocols as a distinct construct under Objective-C and Java (where they are called interfaces). Objective-C protocols are sometimes called formal protocols. Protocol interfaces are specified in a manner similar to classes. A single protocol may inherit from any number of other protocols; therefore, any conforming class must conform to all of its ancestor protocols.

Objective-C class definitions reference within angled brackets the protocols to which they directly conform. Therefore, the OO-Browser displays protocol names within <angled brackets> to distinguish them from classes.

Commands that work on class listing entries generally also work on protocol entries, notably display of parents, children, ancestors or descendants. See section 2.11 Browsing Implementors, for an explanation of how to browse the classes that conform to a protocol.

By default, all protocols and classes referenced within an Environment are listed when the Environment is first loaded. Protocols are also included when the {t} command is used to show top-level classes only. If you prefer to omit protocols from such listings, use the toggle menu item Options/List-Protocols-with-Classes or the key sequence {M-0 P}; then issue the {T} or {A} commands to list top-level or all classes, respectively. The toggle menu item sets the value of the variable, br-protocols-with-classes-flag to `t' or `nil'.

If you have chosen to not list protocols with classes, you can still get a listing of protocols referenced within the Environment by moving point to the default class [protocol] or [interface] included in the top-level class listing of appropriate language Environments and then issuing the {f} command.

Use the {P} key (br-protocols) with point on a class listing entry to obtain a list of the protocols to which the class conforms (including inherited protocols). Use {C-u P} to list the protocols for all classes in the current listing. Use {v} or {e} when on a protocol entry to view or edit its definition. See section 2.11 Browsing Implementors, for a description of how to list the classes that physically define a protocol's methods (which is different than the set of classes that conforms to a protocol).

2.11 Browsing Implementors

Sometimes it is important to see the set of things that implement a feature, category or protocol. These are called implementors. With point on an element, category or protocol listing entry, {I} (br-implementors) will compute and display its list of implementors, which then may be browsed like any other listing entry. {C-u I} will do the same for entries in the present listing.

Move point to an implementor class name and then use {v} or {e} to view or edit the element associated with the class. If an element name is defined with different signatures in a single class, the class is listed as an implementor multiple times. Each class entry displays a different element. {C-u F} displays the element signatures for all of the class entries in the present listing buffer.

2.12 Exiting a Listing

When done with a browser listing buffer, exit from it with {x} (br-exit-level). This command erases the current listing window and returns to the previous listing level, if any. You may exit a single level at a time or all the way back to the top-level listing buffer by sending a prefix argument value to the command, {C-u x}.

There is no need to exit from listing buffers to quit from the browser. You may quit, perform other actions, and then re-invoke the browser at the same point from which you left. See the next manual section.

2.13 Quitting and Refreshing the OO-Browser

Use {q} (br-quit) to quit from the browser temporarily. The same command with a prefix argument quits from the browser permanently and kills all non-modified browser buffers. It will not kill any of the remaining class source buffers.

If you are familiar with Emacs windowing, you may quickly alter the window configuration of the browser frame, either intentionally or more likely unintentionally. If you execute non-browser Emacs commands while in the browser, you may find other buffers have taken the place of your browser buffers. In either case, you may refresh the browser display and restore it to the way it was when you originally invoked it, by using `M-x br-refresh RET' or with {C-c C-r} when in a browser listing buffer.

2.14 Using the Mouse

Once configured, mouse control within the OO-Browser is helpful and easy to use. Under InfoDock, XEmacs and Emacs 19 or higher, the right mouse button, called the Menu Key, pops up a menu of OO-Browser commands when clicked within an OO-Browser listing buffer. Under XEmacs and Emacs 19 or higher, the same menu is added to the menubar used in listing buffers. Under InfoDock with mode-specific menus turned on, the entire menubar is devoted to OO-Browser commands, with each submenu from the popup menu broken into a separate menubar entry. See section B. Menus, for a detailed summary of the available menu commands.

Even if the above features are not available to you, if you have mouse support in your version of emacs, the following features are available. A single mouse button, called the Action Key, is used for most purposes such as displaying classes and features, as well as following references within code. Within listing buffers, the Action Key is bound to the middle mouse button on systems which typically have three mouse buttons and to the left mouse button on two-button systems. Use the OO-Browser 3-Button-Mouse option to inform the browser that your system has three buttons, if it does and you are running under a Microsoft operating system (where systems typically have only two buttons).

Outside of listing buffers, the Action Key location depends on both the type of editor that you are using and the number of mouse buttons available. The Action Key is bound to the shift-middle mouse button under XEmacs or Emacs, to the middle mouse button under InfoDock, or to the shift-left button on a two-button mouse under any of these editors.

A second mouse button, called the Assist Key, is used for help and other ancillary functions. The Assist Key is bound to the shift-right button. Both of these keys perform context-sensitive actions based on where they are clicked. See section 2.15 Getting Help, for details on displaying a summary that describes their behavior in each context, any time you are using the browser. Below we discuss these behaviors.

Within an empty listing buffer, a click of the Action Key displays a buffer that summarizes the browser's key bindings (pressing {h} within any listing window displays this same help buffer). We call this the OO-Browser command menu because an Action Key click within one of the curly brace delimited key sequences invokes the command bound to that key.

A click of the Assist Key within an empty listing buffer displays a menu of the existing source code buffers for the current OO-Browser Environment language, such as Java. Within this menu, the Action Key selects a buffer for display; the Assist Key marks the buffer for deletion. To perform the deletes, click the Action Key after the last line of the menu. If the Assist Key is clicked after the last line, the deletes are undone and a list of all current editor buffers is shown. This permits you to select buffers other than those containing classes.

The mouse buttons may be used to scroll the viewer window. An Action Key click at the end of a line scrolls that line to the top of the viewer window; the Assist Key puts the line clicked upon at the bottom of the window. This is called proportional scrolling since the amount of the scroll is relative to the position of the selected line.

When in an OO-Browser listing buffer, the Action Key acts as follows. If the key is pressed:

• on a blank line following all entries or in a blank listing buffer, the browser command help menu is displayed in the viewer window;
• on a default class name, the statically defined instances of the default class are listed;
• at the beginning of a (non-single character) class name, the class' ancestors are listed;
• at the end of an entry line, the listing is scrolled up proportionally so that the current line is at the top of the window;
• on the `...', following a class name, point is moved to the class descendency expansion;
• before an element entry, the element's implementors are listed;
• anywhere else on an entry line (i.e. on the entry), the entry's source is displayed for editing.

The Assist Key acts as follows when in a listing buffer. If it is pressed:

• in a blank buffer, a selection list of buffer files is displayed;
• on a default class name, the statically defined instances of the default class are listed;
• at the beginning of a (non-single character) class, the class' descendants are listed;
• at the end of an entry line, the listing is scrolled down proportionally so that the current line is at the bottom of the window;
• on the `...', following a class name, point is moved to the class expansion;
• anywhere else on a class line, the class' elements are listed;
• anywhere else on an element line, the element's implementors are listed;
• on a blank line following all entries, the current listing buffer is exited.

2.15 Getting Help

The OO-Browser is very intuitive to operate (much more so than it is to describe textually). However, help is always just a key or button press away when needed. Besides the online and printed versions of this manual, the command menu built-in to the browser and bound to {h} (br-help) serves as an online quick reference for key bindings and commands. The {H} (br-help-ms) command displays the `br-help-ms' file, a table that summarizes mouse operations within each OO-Browser context. For more extensive documentation on each browser key, use the Emacs command {C-h k <key-sequence>}.

2.16 Locating Entries

The {w} (br-where) command locates the source file associated with a listing entry and displays it together with the entry name within the viewer window. A prefix argument as in, {C-u w}, causes the command to prompt for the class or element name to locate. Full completion is provided. See section 2.21 Completing Names.

The {m} (br-match) command offers a quick mechanism for locating any classes in the Environment whose names match to an expression in part or in whole. The browser prompts for the expression to use. All matching names are displayed in ascending order. By default, the expression is treated as a regular expression, i.e. a pattern match. A prefix argument sent to the command tells it to treat the expression as a string.

After each search, the command reports the number of matching classes found and displays them in the current listing window. It then prompts for another expression used to narrow the search further. This cycle continues until the {RET} key is pressed without entering an expression. This process allows for easy location of desired classes.

When the command is invoked (first time through the cycle), if the {RET} key is pressed without giving a match expression, the search will match to all classes referenced in the Environment.

If you want a regular expression to match to whole class names exclusively, begin it with a `^' and end it with a `$' character. These match to beginning of name and end of name, respectively. Thus, "^....$" matches to class names with exactly four characters. A string match always matches to any class name that contains the matching string.

2.17 Filtering Entries

The {M} (br-match-entries) command works much like the (br-match) command described in, 2.16 Locating Entries, except that it matches only to entries in the current listing buffer. It thus allows you to filter a listing to just those entries that you care to browse. It prompts you for a regular expression of entries to match and then deletes entries that don't match. A prefix argument sent to the command tells it to treat the match expression as a string.

After each search, the command reports the number of matching entries found and displays them in the current listing window. It then prompts for another expression to match. The selected set is then filtered once again. This cycle continues until the {RET} is pressed without giving an expression. This process allows for easy incremental filtering of listings.

When the command is invoked (first time through the loop), if the {RET} key is pressed without giving a match expression, the search matches to all entries in the listing, so no filtering is done.

If you want a regular expression to match to whole entries exclusively, begin it with a `^' and end it with a `$' character. These match to beginning of line and end of line, respectively. Thus, "^....$" matches to entry lines with exactly four characters. A string match always matches to any entry that contains the matching string.

2.18 Ordering Entries

Once you have a desired set of names in a browser listing window, you may want to re-order them. For a simple ascending ordering by name, use {o} (br-order). To sort the lines in the current listing window accounting for leading whitespace, use a positive prefix argument. To sort the lines in descending order accounting for leading whitespace, use a negative prefix argument. You should note that all of the top-level class display commands automatically sort their output lists into ascending order. See section Displaying Top-Level Classes.

To sort in descending order, first sort into ascending order with {o} to strip any leading whitespace and then use a negative prefix argument to sort the names into descending order.

2.19 Summarizing Environments and Classes

The {#} (br-count) command displays in the minibuffer the number of entries within the present listing buffer.

The {M-c} (br-class-stats) command displays in the minibuffer window the number of parents and children for the selected class; with a prefix argument, it prompts for the class name to use.

The {M-e} (br-env-stats) command displays the specification for the current Environment along with a few Environment statistics in the viewer window, namely: the OO-Browser version used to build the Environment, the start and end times of the most recent build of theis Environment, total classes, number of System and Library classes, and the number of duplicate and undefined classes. This command also displays version information on the editor and some of its tools.

With a prefix argument, {M-e} displays in the minibuffer window the basic statistics only, leaving the contents of the viewer window intact.

2.20 Deleting Classes

To delete a class from the Environment, display the class name in a listing window using the {m} (br-match) command, if necessary. See section 2.16 Locating Entries. Then move point to the desired class name and press {C-c C-d} (br-delete) to delete the class. This will remove the class name at point and will delete the class from the Environment.

2.21 Completing Names

Whenever the browser prompts for a name and an Environment has already been loaded or built, you can use the browser's name completion facilities to help you enter the name. These features let you type as much of the name as you know and then have the browser fill in what it can. The relevant keys are:

{TAB}

complete as much as possible of a class or element name;

{SPC}

complete up to one word of a class or element name;

{?}

show all possible completions for a class or element name.

You can also use the browser's completion facilities outside of the browser, for example, when editing code. See section Using Standalone OO-Browser Features, and the documentation produced from typing `C-h f br-complete-symbol RET'.

2.22 Browsing Graphically

The X interface to the OO-Browser is named, Xoobr, and is pronounced ex-owe-owe-browse-er. It provides a simple but effective means of navigating through hierarchy and element relations.

Windows-specific versions of the OO-Browser now include a native Windows graphical browser that works the same way as the Xoobr described in this section but is simply named oobr.exe. Use this section as a reference for either version of the graphical browser.

<CENTER> <DT><B>The X OO-Browser</B></DT><BR><BR> <IMG NAME="X OO-Browser" SRC="im/oobr-x.gif"><BR> </CENTER> See the end of this node for a link to a screenshot of the Xoobr.

Any number of Xoobr sessions may be established at the same time to yield different views over Environments. Each session may show relations from a different Environment (even a different language) than the others do. The textual OO-Browser is used to select the set of classes for display in an Xoobr session. For this reason, Xoobr is almost always invoked from within the textual OO-Browser. The following keybindings are all used within the textual browser to manage Xoobr views.

{M-d} (br-tree) selects the current class and displays its descendancy graph in tree-form by starting a new Xoobr session. With a prefix argument, {C-u M-d}, it displays descendancy trees for all classes within the current browser listing. They are all grouped under an imaginary root node so as to maintain the concept of one tree per Xoobr view.

Use {M-f} (br-tree-features-toggle) or the Options/Graphical-Descendant-Features menu item, to set whether or not the features of listing classes are shown as child nodes in any graphical descendency views created by the {M-d} command. (The setting applies across all OO-Browser languages. The default setting is not to add features to Xoobr views.)

{M-g} (br-tree-graph) displays the current listing buffer's entries in a graphical form. It ignores the add features setting so that you can capture the current listing without the need to alter that setting.

The {M-k} (br-tree-kill) command prompts to see if you want to terminate all Xoobr sessions started from within the current editor session. If you answer affirmatively, all such processes disappear, as your screen will quickly indicate.

(The rest of this section discusses the user interface of the Xoobr.) Xoobr views are meant to complement the textual browser interface. Therefore, the two most common actions used in the text browser are performed in a similar manner within an Xoobr view. A click on a node with the left mouse button displays the appropriate class text in the user-selected editor, ready for editing. See section Using an External Viewer or Editor. A click of the middle button performs similarly but displays the associated class for viewing only.

The right mouse button when depressed over an Xoobr node displays a short menu of commands that may be applied to the node. The only ones of real interest at this point are the collapse and expand entries which let you hide and then restore the display of a node's subtree. This yields precise control over the amount of detail you receive in various parts of the hierarchy.

The Help button in the Xoobr menubar displays a few pages of help text regarding the program itself.

If running under the X window system, Action Key click on the following filename to view a picture of the X OO-Browser: `im/oobr-x.gif'.

The Xoobr menubar may be useful in the future but should generally be ignored for now. The only menu entry of any import is found under the file menu, labeled Quit. Xoobr processes may also be terminated by issuing the kill command mentioned previously. A third means of killing such processes is by sending the permanent (br-quit) command, {C-u q}, to the textual browser. You will then be prompted as to whether to terminate all Xoobr sessions started from within the current editor session.

This document was generated by XEmacs shared group account on December, 19 2009 using texi2html 1.65.