SGI Techpubs Library

IRIX 6.5  »  Man Pages
find in page

OVwRegIntro(5)

 NAME

     OVwRegIntro - introduction to HP OpenView Windows registration files

 DESCRIPTION

     OpenView Windows registration files are a mechanism for:

          +  Application Integration with the OpenView Windows GUI

          +  Symbol Registration for the OpenView Windows GUI.

          +  Field Registration for the OpenView Windows Object Database (see
             ovwdb(1M)).

     When ovw processes a set of registration files, it creates a list of all
     the files in a registration directory, sorts the list, then parses and
     processes the generated list of files.

     The command "ovw -verify" should be used before starting ovw to ensure
     the correctness of registration files after registration files have been
     modified.

     NOTE: On Windows NT, if you want to use backslashes, you must use double
     backslashes (\\), that is, you must escape the backslash with a
     backslash.  This is consistent with C programming style. You also should
     use forward slashes as path separators.

   APPLICATION INTEGRATION
     Application registration files are used to integrate external
     applications with OpenView Windows. Applications which are invoked from
     ovw and those which use the OVw API must register with ovw via the
     application registration files.

     Different degrees of integration can be achieved using the application
     registration files. The different types of possible application
     registration are as follows:

          +  Application Registration

          +  Application Menu Registration

          +  Application Action Registration

             Application Drop Action Registration

          +  Application Field Registration

     Application Registration provides the information used by ovw to invoke
     and manage the integrated applications.

     Application Menu Registration defines how new menu items and tool bar
     buttons, along with their associated behaviors, can be added to the OVW
     GUI. Once all the application registration files have been parsed,
     application menus are integrated into the menu bar, the tool bar, and the
     pop-up menus as appropriate. The OpenView Windows menu registration is
     processed first, followed by all other applications in application name
     order (i.e., application "Aardvark"'s menu items are registered before
     application "Zebra"'s).

     Application Action Registration defines certain "actions" that can be
     invoked from ovw. These "actions" may be linked to menu items (through
     the Application Menu Registration) or to executable symbols (via the OVw
     API or the OVW GUI.)

     Application DropAction Registration defines certain "actions" that can be
     invoked from ovw during a drag and drop operation. These "actions" must
     be linked to specific symbols and submaps through the OVw API,
     specifically through OVwModifySymbols, OVwModifySubmaps, and
     OVwAddDropCallback.

     Application Field Registration provides OVW dialog boxes with specific
     field information based on what object is being acted upon. Some
     applications manage semantics, or semantic planes, of OVW maps. These
     applications need to specify how certain dialog boxes look for various
     semantic operations. Within the registration file, the application
     enrolls fields for these dialog boxes based on rules about the objects
     the application will be managing. Details on how to use field enrollment
     in concert with the OVw API are available in The HP OpenView Windows
     Developer's Guide.

     Application registration files are located in the directory:
     $OV_REGISTRATION/$LANG.

     Application Registration

     The Application Registration Block contains all of the information about
     how an application is integrated with OVW. Only one Application
     Registration Block may be defined in each application registration file.

     A generic Application Registration Block is as follows:

          Application <application_name> {
              :
          }

     The application name uniquely identifies an application.

     For example, below are two application registration files:

        <in file sample_app1>
            Application "Sample App" {
              Command "checknode -test";
            }

     and

        <in file sample_app2>
          Application "Sample App" {
            Command "foo -x -y -z ${OVwSelections}";
          }

     Both attempt to register the same application, "Sample App". ovw will
     emit a warning when there are multiple registrations for an application
     name and will register only the first one that it encounters with that
     name, ignoring any duplicate registrations that it encounters.

     Command Statement

     The Command Statement contains process flags and the command string that
     is used to invoke the application.

     The generic format of the Command Statement is:

          Command <process flags> <command string>

     This declaration when made in the Application Registration Block is
     global, in that any actions defined later assume that the application
     process is started with this command. This command may be "overridden"
     within an action declaration. This global declaration can be omitted,
     provided there are command statements within action declarations.

     Process Flags

     The process flags listed in the command statement tell ovw how to manage
     the application process or processes. They are used to control the
     starting and stopping of user defined processes. By default none of these
     flags is enabled and the command string is executed only when the
     application action is triggered via a menu item or through an executable
     symbol.

     Valid process flags are:

     -Initial  This flag tells ovw to start the application when ovw starts.
               ovw invokes the application with the command specified in the
               <command string>.

     -Shared   This flag tells ovw that the application process started
               through this command instance is shared between actions. Once
               the application process is started (via a menu item, executable
               symbol, or because the "Initial" flag is set), it remains
               running. The application process is notified via the OVw API
               when actions are requested via menu items or executable
               symbols. An applications that does not use the OVw API can have
               the shared flag enabled. This means that only one instance of
               the application will run until ovw or the application exits.
               The 'shared' application would need to use the OVw API to
               intercept further action requests from menu items or executable
               symbols in order to be more useful.

     -Restart  This flag tells ovw that the application is a required
               application for normal ovw operation and should be restarted
               should it ever exit. This flag is intended for use by
               applications which manage semantics of OVW maps and need to be
               present for the duration of an ovw session.

     Command String

     For applications on UNIX platforms, ovw executes the command string by
     executing: '/bin/sh -c ''exec command'''. Thus, for the command
     invocation to succeed, the full path must be given to the executable file
     in the command string. The full syntax of sh(1) may be used in the
     command string, including references to environment variables inherited
     from ovw along with environment variables set by ovw.

     ovw sets the following environment variables which are passed to the
     command string:

     OVwSelections
               This is a list, separated by blanks, of the selection names of
               the objects in the selection list when the application is
               invoked.

     OVwNumSelections
               This is set to the number of selections which are in the
               selection list when the application is invoked.

     OVwSelectionn (n=1, 2,..., 10)
               Each of these environment variables contains the selection name
               of an object in the selection list when the application is
               invoked. OVwSelection1 is set to the selection name of the
               first object in the list, OVwSelection2 the second, etc., up to
               OVwSelection10 which is set to the selection name of the tenth
               object in the list. The order in which these variables are set
               to objects is the same as the order in which they were selected
               on the map.

     OVwActionID
               This is the name of the action defined within the registration
               file, by which the application was invoked.

     OVwMenuItem
                If the application action is invoked from a menu, this
               variable will be set to the label of the menu item which caused
               the action.

     OVwAppName
               This is the name of the application as defined within the
               registration file.

     OVwSessionID
               This is the ID of the GUI session from which the application
               was started.

     OVServer  This is the name of the system that stores the map database and
               runs the object database service.

     Remote Application Launching (UNIX platforms only)

     ovw allows an application to run on a system other than the one on which
     OVW is running. The command statement includes support for launching
     applications on remote systems.The On and StartedBy keywords are
     extensions to the Command statement syntax. They specify the host where
     the command should run and the application launcher to use to start the
     remote command.

     The argument to On defines the system on which the application will run.
     It may be either an explicit hostname or an environment variable such as
     $OVServer. If the value of the On argument matches the system on which
     the ovw GUI is running, ovw ignores the launch command specified with
     StartedBy.

     Use the StartedBy keyword to specify an alternative launcher. If
     StartedBy is not included, the default OVW launcher is used for
     distributed applications The default remote application launcher is:

        "ovexec -ovwlaunch -nodelist %1$s -cmd %2$s"

     As an example, here is an application that will start on the system named
     toner, using remsh as the launcher to start the command as the user
     ovuser:

          Application "Sample App" {
            Command "foo -session ${OVwSessionID} ${OVwSelections}"
                On "toner" StartedBy "remsh %1 -l ovuser %2";;
          }

     Note that applications which run on remote systems must explicitly
     support this feature. Such an application must support a mechanism to
     provide it the current GUI session ID and it must supply its registered
     application name to ovw in order to run correctly.

     Other Application Registration Block Statements

     Description, Copyright, and Version are used to provide the application
     specific information used in the Application Index dialog box, which
     displays all of the applications installed and registered with ovw. This
     dialog box can be accessed through Help:About OpenView and then selecting
     the [Applications] button.

     Description Block

     The description block contains a comma separated list of strings which
     describes the use of the application. When displayed in the Application
     Index dialog box, each string will appear on a separate line.

     An example of the description block follows:

          Application "Sample App" {
            Description {
              "Sample App",
              "This application does something cool!"
            }
          }

     Copyright

     The copyright block provides the copyright string for the application.
     This block also contains a comma separated list of strings which will
     appear on separate lines within the Application Index dialog box.

     An example of the copyright block follows:

          Application "Sample App" {
            Copyright {
              "(c)Copyright 1992 Hewlett-Packard Co.",
              "All Rights Reserved"
            }
          }

     Version

     The Version statement defines a string which provides the application
     version information. This version string appears on the Application Index
     dialog box, and it appears on the Help On Version dialog box which is
     available through the Help:On Version menu.

     An example of the version statement follows:

          Application "Sample App" {
            Version "BETA V1.0";
          }

     HelpDirectory statement

     The HelpDirectory statement specifies the name of the directory where the
     application's help files reside. These files are presented in response to
     help requests by the OpenView Windows help system, ovhelp. The directory
     name should be specified relative to $OV_HELP/$LANG.

     An example of the HelpDirectory statement follows:

          Application "Sample App" {
            HelpDirectory "sampledir";
          }

     NameField statement

     The NameField statements provide a mechanism for the application to
     quickly access the selected objects by a named field other than the
     selection name. The environment variable OVwSelections contains the
     selection names of all the objects in the selection list when the
     application is started by ovw. There may be cases when the selection name
     is different from the object names that the application is constructed to
     handle. For example, let's say the "telnet" command were specified as a
     menu item. Most of the time, the selection name for objects on the map
     will be the hostname. Some of the time though, the selection name given
     might not be the same as hostname since users can name objects however
     they wish. To make sure that a command gets only hostnames in its
     selection list, the application registration block can contain a
     NameField section which indicates that the object's selection name should
     be the object's hostname.

     For example:

          Application "Telnet" {
            Command "/usr/bin/X11/xterm -e /usr/bin/telnet ${OVwSelection1}";
            NameField "IP Hostname";
          }

     The string "IP Hostname" is referring to the object field "IP Hostname"
     defined in the field registration files. Any registered name field can be
     specified in a NameField section. Should an object appear in the
     selection list that doesn't have a "Hostname", the menu items by which
     the application is invoked will be grayed out.

     The NameField section accepts a list of field names. The first field
     which is defined for an object will be used in the selection list
     environment variable.

     For example:

          Application "Telnet" {
            Command "telnet ${OVwSelection1}";
            NameField "IP Hostname", "Selection Name";
              ...
        }

     If an object were selected that did not have an IP Hostname, its
     Selection Name would be used instead.

     DisplayString statement The DisplayString statement specifies a string
     that is used to display the name of an application. OVW GUI displays this
     string whenever the name of an application must be displayed from within
     OVW GUI (e.g., the Application Index dialog box). For example:
     Application "MySampleApp" { DisplayString "Sample Application";
     ...}If DisplayString is not specified, the application name is used
     instead.

     Application Menu Integration

     Applications may integrate with ovw through pull-down menus, pop-up
     menus, and tool bar buttons. Pull-down menu items may be placed globally
     or on the basis of submap context. Symbol pop-up menu items may be placed
     globally or on the basis of a combination of the symbol's submap context
     and the symbol type. The contents of symbol alert popup menus (available
     on UNIX platforms only) are not global in that they are limited to items
     with actions registered by the application which created the symbol
     alert. Tool bar buttons may be placed globally or on the basis of submap
     context.

     Pull-down Menus

     The MenuBar and Menu blocks provide a specification of how the
     application hooks into the OVW pull-down menu bar. Both block types are
     functionally equivalent with one exception. A MenuBar block declares the
     selections for the menu panes that are defined for the top level pull-
     down menus. A Menu block declares the selections of a cascaded menu block
     included in the toplevel menus (toplevel meaning the first cascade
     beneath a menu bar item) or in another lower level pull-down menu. Thus
     the scope of the MenuBar menuId is global (across applications) and also
     specifies the label on the item on the menu bar. The scope of the Menu
     menuId is limited to the application block and has no influence on the
     label of the button which brings up the pull-down menu cascade.

     The MenuBar and Menu blocks contain declarations of pull-down menu items
     for the application. Since the body of the Menu and MenuBar blocks are
     the same, discussion of the pull-down menu item declaration is deferred
     to the Menu section.

     Menu Bar Registration

     The MenuBar block provides registration of new menu bar selections and
     registration of menu items within the top-level menus.

     MenuBar Block: The <MenuName> for the MenuBar block serves to distinguish
     MenuBar declarations and to name top-level (menu bar) menus. This
     <MenuName> is global in scope. It corresponds to the label for the menu
     bar.

     The generic format of a MenuBar block is as follows:

          MenuBar <MenuName> {
            ...
          }

     The <MenuName> "Help" is reserved to be the rightmost menu bar item
     (attached to the right hand side of the menu bar).

     MenuBar Mnemonics: Along with the label for the menu bar item, an
     application can specify an optional mnemonic in the declaration of the
     menu.

     For example:

          MenuBar "Configure" _C {
            ...
          }

     This will add a new top-level menu on the menu bar called "Configure"
     with the mnemonic character "C" which can be used to quickly access the
     menu by the user.   The above example depicts the proper syntax for
     defining mnemonics in OVW. The <MenuName> "Configure" is now global in
     scope; other applications may register menus under this same top-level
     menu. If there are multiple declarations for a top-level MenuBar block
     that specify different mnemonics, ovw emits a warning and uses the first
     mnemonic registered for that MenuBar block.

     MenuBar Precedence: The precedence is an integer value which "weights"
     the importance of a menu bar cascade. MenuBar cascades are listed in the
     menu bar according to precedence. When two MenuBar blocks have the same
     precedence, ovw will place any of its registered MenuBars first followed
     by the remaining MenuBars ordered by the application names. ("0" is the
     lowest precedence and "100" is the highest.)

     For example, given the following three registrations:

          Application "Foo" {
            MenuBar <100> "Goof" _O {
              ...
            }
          }
          Application "Bar" {
              MenuBar <100> "Ball" _B {
                ...
              }
          }
          Application "Openview Windows" {
              MenuBar <100> "File" _F {
                ...
              }
          }

     The order of the MenuBar items would be File Ball Goof.

     Menu Blocks

     The Menu block provides a way for an application to specify a group of
     pull-down menu items to appear within a single menu cascade. For the
     declared menu to be useful, it must be associated with some pull-down
     menu item with the "f.menu" function (see below for a discussion of menu
     item functions).

     A generic Menu Block declaration follows:

        Menu <MenuID> {
            <Menu_Items>
        }

     MenuId: A MenuID provides a reference to the specified group of menu
     items. The sole purpose of the MenuID is to provide a way for the
     application to "hook" the group of menu items to a menu cascade button.
     The scope of this MenuID is limited to the application registration
     block. An application can declare a group of menu items using the same
     MenuID that another application uses for another group of menu items.

     What follows is a Menu block registration:

          Application "Mail Manager" {
            MenuBar "Monitor" {
              "Mail" f.menu "MailMenu";
            }
            Menu "MailMenu" {
              "Mail Log"      f.action "MailLog";
              "Mail Queue"    f.action "Mailq";
            }
              ...
          }

     Here, the application hooks into the menu bar item Monitor, adding a menu
     cascade named Mail which will contain at least two items, Mail Queue and
     Mail Log.

     Pull-down Menu Item Declarations

     Pull-down menu items are declared within the Menu and MenuBar sections. A
     pull-down menu item is composed of the following components:

        <Menu_Precedence> "Menu_Label" Menu_Mnemonic Menu_Accelerator
            Context_Expression Menu_Function;

     For example a Pull-down Menu Item could be:

        <75> "Mail Log" _L           Ctrl<Key>L          Context AllContexts
        f.action ScanMaillog
     Menu Precedence
               The precedence value is optional. It may range from "0" to
               "100" and it defaults to "50." This is an integer value which
               "weights" the importance of a menu item. ("0" is the lowest
               precedence and "100" is the highest.) Menu items are listed in
               OVW menus according to precedence. When menu items have the
               same precedence, ovw will place any of its registered menu
               items followed by the remaining menu items ordered by
               application name.

     Menu Label
               This is the label for the menu item as it should appear in a
               pull-down menu. It is a required field. Note that the label is
               not displayed if the menu item is a separator (i.e., function
               is f.separator).

     Menu Mnemonic
               A mnemonic is a character that allows keyboard traversal to the
               menu. The mnemonic declaration begins with an underscore
               followed by the mnemonic character used to make the menu
               selection. Note that the mnemonic is ignored if the menu item
               is a separator (i.e., function is f.separator).

               This is an optional field.

               If another mnemonic is already specified (by some other
               application) for the same menu item, ovw issues a warning and
               the previously defined mnemonic is used instead.

     Menu Accelerator
               The accelerator is a key sequence that invokes a menu selection
               without displaying the menu. Note that the accelerator is
               ignored if the menu item is a separator (i.e. function is
               f.separator).

               This is an optional field.

               If the menu item already has an accelerator associated with it
               (by some other application), ovw issues a warning and uses the
               previously defined accelerator.

     Context Expression
               This field is used to determine which submaps the menu item
               should appear on. The expression is a variation on a standard
               boolean expression (the not operator [!] is not permitted)
               whose terms are context identifiers or the reserved identifier,
               "AllContexts". A context identifier is evaluated by determining
               whether a submap has defined the term in its context. The
               "AllContexts" term evaluates as true if the submap has not
               included "NoGeneric" in its context. Before a menu item is
               placed on a submap, the context expression is evaluated. If it
               is true for the submap's context, then the menu item is placed
               in the submap's pull-down menus.

               This field is optional for all pull-down menu items. If it is
               not included, the menu item is assumed to be generic and it
               will be placed in all submaps that have not included
               "NoGeneric" or "NoDefault" in their context.

     Menu Function
               A function determines the behavior of each menu selection.
               Functions begin with the two characters "f." followed by a
               name. A special function named "!" provides easy integration of
               shell commands with OVW menus.
                            ! "commandline"
                            The "!" function allows quick integration of shell
                            commands into menu selections. Since it specifies
                            a shell command, an application would never be
                            notified when this item is selected, thus one need
                            not declare a separate action for it. Note,
                            however, that if attributes of the menu item
                            should be specified, such as the number of
                            selections or a selection rule, then you should
                            declare an action with this information and list
                            the desired shell command in the menu item
                            arguments.
                            f.action
                            The f.action function takes an ActionID which is
                            associated with some Action declaration elsewhere
                            in the file. It ties the action to the menu item
                            so that when the item is selected, the application
                            is, if necessary, invoked and notified of the
                            selected action.
                            f.menu
                            This function provides for the declaration of a
                            menu cascade within a menu. A previous menu
                            example shows f.menu declaring the Mail cascade.
                            f.built-in-function-name
                            Built-in functions are internal to ovw. They are
                            functions that implement internal ovw callbacks,
                            providing functionality for menu items such as
                            Help: On Version, File:New Map..., etc. These are
                            provided so that ovw can use the same file-based
                            menu registration as other applications. Each
                            function begins with the "f." followed by a unique
                            identifier describing the function. The OVW
                            registration file contains several examples of
                            internal functions.
                            A menu separator is defined using the built in
                            function f.separator.

     Pop-up Menus

     PopupItem registration and the PopupMenu block provide a specification of
     how an application hooks into OVW's symbol pop-up menus and symbol alert
     popup menus. The specific details for symbol alert popup menu
     registration are discussed below, following the discussion of symbol
     pop-up menus.

     A PopupItem specification defines a menu item in the first level pop-up
     menu. A PopupMenu block declares the selections of a cascaded menu
     included under the first level of the symbol pop-up menu. Thus the scope
     of the PopupItem menuId is global (across applications). The scope of the
     PopupMenu menuId is limited to the application block and has no influence
     on the label of the button which brings up the pop-up menu cascade.

     The PopupItem and PopupMenu sections contain declarations of pop-up menu
     items for the application. These are similar to the pull-down menu
     specifications.

     PopupItem Registration

     PopupItem specifications provide a way for an application to specify the
     menu items that appear in the first level of the symbol pop-up menu. A
     PopupItem entry has the same fields that are defined for the pop-up menu
     items in a PopupMenu block below.

     An example PopupItem registration:

          Application "Mail Manager"
          PopupItem <100> "Mail System" Context (AllContexts)
            TargetSymbolType "Computer":"Any" f.action "MailSys";
            ...
          }

     PopupMenu Block

     The PopupMenu block provides a way for an application to specify a group
     of pop-up menu items to appear within a single menu cascade. For the
     declared menu to be useful, it must be associated with some pop-up menu
     item with the f.menu function (see below for a discussion of menu item
     functions).

     An example PopupMenu registration:

          Application "Mail Manager" {
            PopupItem <100> "Mail Functions" Context (AllContexts)
              TargetSymbolType "Computer":"Any" f.menu "MailFns";
              PopupMenu "MailFns"
              {
                "Mail System" Context (AllContexts)
                TargetSymbolType "Computer":"Any" f.action "MailSys";
                "Check Queue" Context (AllContexts)
                TargetSymbolType "Computer":"Any" f.action "MailQ";
              }
          }

     PopupItem Statements

     Pop-up menu items are declared at the toplevel with a PopupItem section
     or within the PopupMenu section. A pop-up menu item is composed of the
     following components:

     Precedence
               The precedence value is optional. It may range from "0" to
               "100" and, by default is set to 50. This is an integer value
               which weights the importance of a pop-up menu item. ('0' is the
               lowest precedence and '100 is the highest.) Pop-up menu items
               are listed in OVW's pop-up menu according to precedence. When
               two Pop-up menu items have the same precedence ovw will place
               any of its registered Pop-up menu items first followed by the
               remaining Pop-up menu items ordered by the application names.

     Label     This is the label for the menu item as it should appear in a
               pop-up menu. It is a required field. Note that the label is not
               displayed if the menu item is a separator (i.e. function is
               f.separator).

     Context Expression
               This field is used to determine which submaps the menu item
               should appear on. The expression is a variation on a standard
               boolean expression (the not operator [!] is not permitted)
               whose terms are context identifiers or the reserved identifier,
               "AllContexts". A context identifier is evaluated by determining
               whether a submap has defined the term in its context. The
               "AllContexts" term evaluates as true if the submap has not
               included "NoGeneric" in its context. Before a menu item is
               placed, the context expression is evaluated. If it is true for
               the submap's context, then the menu item may be placed in
               symbol pop-up menus (if the target symbol type is also
               satisfied for a given symbol.)

               This field is required for all pop-up menu items.

     Target Symbol Type
               This field determines which symbol types that the given menu
               item should be placed on. The target symbol type is used in
               combination with the context expression to place the menu item
               in the pop-up menus of specific symbols (according to their
               type) in specific submaps (according to the submap's context).

               This field is required for all pop-up menu items.

     Function  A function determines the behavior of each menu selection.
               Functions begin with the two characters "f." followed by a
               name. A special function named "!" provides easy integration of
               shell commands with OVW menus.
                            !"commandline"
                            The "!" function allows quick integration of shell
                            commands into menu selections. Since it specifies
                            a shell command, an application would never be
                            notified when this item is selected, thus one need
                            not declare a separate action for it. Note,
                            however, that if attributes of the menu item
                            should be specified, such as the number of
                            selections or a selection rule, then you should
                            declare an action with this information and list
                            the desired shell command in the menu item
                            arguments.
                            f.action
                            The f.action function takes an ActionID which is
                            associated with some Action declaration elsewhere
                            in the file. It ties the action to the menu item
                            so that when the item is selected, the application
                            is, if necessary, invoked and notified of the
                            selected action.
                            f.menu
                            This function provides for the declaration of a
                            menu cascade within a menu. A previous menu
                            example shows f.menu declaring the Mail cascade.
                            f.built-in-function-name
                            Built-in functions are internal to ovw. They are
                            functions that implement internal ovw callbacks,
                            providing functionality for menu items such as
                            Help: On Version, File:New Map..., etc. These are
                            provided so that ovw can use the same file based
                            menu registration just as other applications do.
                            Each function begins with the "f." followed by a
                            unique identifier describing the function. The ovw
                            registration file contains several examples of
                            internal functions.
                            A menu separator is defined using the built in
                            function f.separator.

     Symbol Alert Pop-up Menus (UNIX platforms only)

     PopupItem registration and the PopupMenu block provide a specification
     for applications to hook into OVW's symbol alert popup menus. Following
     the same specification as that used for the symbol popup (explained
     above), the application registers a PopupItem with a TargetSymbolType
     which is a SymbolAlert (e.g. SymbolAlert:CriticalAlert) in order to
     define a menu item in the first level pop-up menu for any of its symbol
     alerts of that type. Thus, when the application creates a symbol alert of
     the target type, the application's PopupItems are included in the first
     level pop-up menu for the symbol alert. Unlike a symbol PopupItem which
     can be included in the menu of any symbol which matches in type and
     context, a symbol alert item is included only in the symbol alert pop-up
     menu for a symbol alert created by the application which registered the
     item. PopupMenu Blocks for symbol alert popup menus are identical in
     purpose and syntax to the symbol popup menu block registration already
     described. Menus, like items, are identified as symbol alert popup menus
     (rather than symbol popup menus) by the specification of the
     TargetSymbolType as a "SymbolAlert" type and are included only in the
     symbol alert pop-up menu of a symbol alert created by the application
     which registered the menus and menu items. A PopupItem for a symbol alert
     must be an action (f.action). Internal functions and shell commands are
     not suitable as symbol alert actions since they do not satisfy the
     requirement that symbol alert actions be actions which were registered by
     the application which created the symbol alert.

     Symbol Alert PopupMenu and PopupItem Registration.

     An example symbol alert popup item and menu registration with associated
     action registration:

        Application "Printer Manager" {
        < not a complete registration >
          PopupItem <100> "Paper Fault" Context (AllContexts)
            TargetSymbolType SymbolAlert:CriticalAlert f.menu "PaperFault";
            PopupMenu "PaperFault"
            {
            "Paper Out" Context (AllContexts)
            TargetSymbolType SymbolAlert:CriticalAlert f.action "PaperOut";
            "Paper Jam" Context (AllContexts)
            TargetSymbolType SymbolAlert:CriticalAlert f.action "PaperJam";
            }
          Action "PaperOut"
          {
          }
          Action "PaperJam"
          {
          }
        }

     ToolbarButton Block

     The ToolbarButton block provides a specification of how the application
     hooks into the OVW tool bar. A ToolbarButton section declares the buttons
     in the submap tool bar.

     Tool bar buttons are declared with a ToolbarButton line. It is composed
     of the following components:

     Precedence
               The precedence value is optional. It may range from "0" to
               "100" and, by default is set to "50". This is an integer value
               which weights the importance of a tool bar button. ("0" is the
               lowest precedence and "100" is the highest.) Buttons are listed
               in the OVW tool bar according to precedence. When two buttons
               have the same precedence, ovw will place any of its registered
               buttons first followed by the remaining buttons ordered by
               application name.

     Label     This is the label for the button. This is a required field. If
               the label starts with '@', it is interpreted as the name of an
               image file. HPUX and Solaris Only: If the label contains two
               image file names separated by a ':', the first image is
               displayed when the button is active and the second image is
               displayed when the button is inactive or "grayed". Windows NT
               Only: The image file must specify a 16x16 BMP image. ToolTip
               text can be specified by following the image file name with a
               comma, followed by the text of the ToolTip. See the ovw
               registration file for examples of toolbar buttons with
               ToolTips.

               Note that the label is not displayed if the button is a
               separator (i.e. function is f.separator).

     Context Expression
               This field is used to determine which submaps the button should
               appear on. The expression is a variation on a standard boolean
               expression (the not operator [!] is not permitted) whose terms
               are context identifiers or the reserved identifier,
               "AllContexts". A context identifier is evaluated by determining
               whether a submap has defined the term in its context. The
               "AllContexts" term evaluates as true if the submap has not
               included "NoGeneric" in its context. Before a button is placed
               on a submap, the context expression is evaluated. If it is true
               for the submap's context, then the button will be placed in the
               submap's tool bar.

               This field is required for all tool bar buttons.

     Function  A function determines the behavior of the button. Functions
               begin with the two characters "f." followed by a name. A
               special function named "!" provides easy integration of shell
               commands with OVW tool bar buttons.
                            ! "command line"
                            The "!" function allows quick integration of shell
                            commands into tool bar buttons. Since it specifies
                            a shell command, an application would never be
                            notified when this item is selected, thus one need
                            not declare a separate action for it.

                            f.action
                            The f.action function takes an ActionID which is
                            associated with some Action declaration elsewhere
                            in the file. It ties the action to the button so
                            that when the item is selected, the application
                            is, if necessary, invoked and notified of the
                            selected action. Note that tool bar actions don't
                            act on the selection list, so selection rules do
                            not apply.
                            f.built-in-function-name
                            Built in functions are internal to ovw. They are
                            functions that implement internal ovw callbacks,
                            providing functionality for buttons such as
                            "Root", etc. These are provided so that ovw can
                            use the same file based tool bar registration that
                            other applications do. Each function begins with
                            "f." followed by a unique identifier describing
                            the function. The OVW registration file contains
                            several examples of internal functions.
                            A tool bar separator is defined using the built in
                            function f.separator.

     Application Action Registration

     Action Block

     The Action block is used to define actions which an application can
     perform. Actions can then be hooked to menu items via the registration
     file, to symbol alerts via the OVw API (UNIX platforms only), or to
     executable symbols via the user interface.

     The generic form of an action block is:

          Action <Action_ID> {
            ...
          }

     An Application which specifies the "Initial" flag in the command
     statement need not define any actions if it is to simply run under OVW.
     All other applications need to define actions to allow application
     invocation via menu items, symbol alert default action, or executable
     symbols.

     The action definition contains information such as what kinds of objects
     are valid for the action and what command should be used to invoke the
     application or what arguments should be passed to the application if it
     is already running.

     Through the OVw API, an application is notified that an action has been
     requested by registering a callback for the action. This is accomplished
     using the OVwAddActionCallback(3) registration mechanism. The parameters
     to the callback procedure include the name of the action (i.e. - the
     ActionID described below), the current selection list, callback arguments
     specified for the action, and the map and submap where the action was
     requested. When an action is associated with a menu item on a popup menu
     for a symbol or a symbol alert the selection list is replaced by the
     object information for the symbol with the open popup menu.

     The action callback procedure is defined as:

          void (*OVwActionCallbackProc) (void *userData, char *actionId,
              char *menuItemID, OVwObjectIdList *selections, int argc,
              char **argv,         OVwMapInfo *map, OVwSubmapId submap);
     For symbol alert actions (both default action and menu item actions) the
     registration should be limited to an action name (ActionID). Symbol alert
     actions do not need or use a command, a selection rule, or minimums and
     maximums for selected items since the selection list is ignored. The
     application uses the OVwAddActionCallback(3) registration mechanism to
     associate the action with a callback procedure. It is that callback
     procedure and the application's own data on the appropriate target
     object(s) which is used to accomplish the action, not a command with
     target object(s) based on the selection list.

     The HP OpenView Windows Developer's Guide explains how to implement
     symbol alerts in your application.

     A typical symbol alert action specification is:

          Action <Action_ID> {
          }
     ActionID

     This is an identifier, or name, for the action which the application can
     use to receive notification when the action is requested. It is also used
     as an argument to the f.action function which is used to tie the action
     to a menu item or tool bar button. The scope of the name is limited to
     the application registration block; other applications may have defined
     actions using the same name.

     To continue an example started earlier, the Mail Manager registration
     referred to an action called "MailLog". Here is a definition for that
     action (for an application on a UNIX platform), using other elements of
     an action block which will be discussed below.

          Application "Mail Manager" {
            MenuBar "Monitor" {
              "Mail" f.menu "MailMenu";
            }
            Menu "MailMenu" {
              "Mail Queue"    f.action "Mailq";
              "Mail Log"      f.action "MailLog";
            }

              ...
            Action "MailLog"
            {
              SelectionRule isNode;
              MinSelected 1;
              MaxSelected 1;
              Command 'xterm -title "${OVwMenuItem} ($OVwSelection1)" \
                -e sh -c "/usr/bin/rexec ${OVwSelection1} \
                -l root tail -f /usr/spool/mqueue/syslog"';
            }
          }

     This action specifies that exactly one object can be selected for the
     action to take place (MinSelected 1 and MaxSelected 1). It also says that
     the object must have the isNode capability set to True. Finally, it lists
     the command which should be used to perform the action.

     Selection Rule

     The selection rule is a logical expression, using the and (&&), or (||)
     and not (!) operators, on capability fields. Capability fields are
     specially designated fields in the object database used for classifying
     an object. The field registration section below describes how to define a
     field as a capability. Pre-defined capabilities are specified in the
     directory $OV_FIELDS/$LANG.

     The Capability fields used in a Selection Rule are limited to Boolean and
     Enumerated types.

     The logical expression is classical in its definition. Refer to the
     grammar below for the detailed syntax of the SelectionRule expression.

     MinSelected

     The MinSelected declaration provides a method to specify the minimum
     number of objects which must be selected for the action to be enabled. If
     MinSelected is not specified and there is no Selection Rule then it
     defaults to zero, meaning that no objects must be selected for the action
     to be activated. If MinSelected is not specified, and the action contains
     a SelectionRule, it then defaults to 1, meaning that at least one object
     matching the selection rule must be selected for the action to be
     activated. If MinSelected is set to zero and the action includes a
     selection rule, then the action is valid when nothing is selected, but if
     there are any selections they must meet the selection rule criteria.

     MaxSelected

     MaxSelected provides an upper bounds for the number of selections on
     which an action can be applied. If MaxSelected is not specified, any
     number of objects may be selected for the action. If MaxSelected is set
     to zero, then the action is only valid when nothing is selected.

     Process Flags

     These process flags are the same as those used in an Application Command
     Statement. In the Action section, these flags override any global
     application settings.

     A command statement is uniquely identified by its command flags and its
     command string. In this example:

          Application "Silly App" {
            Command -Initial -Shared "/usr/bin/foo -x";
            ...
            Action "Bar"
            {
              Command "/usr/bin/foo -x";
            }
          }

     Each command statement is considered separately since the command process
     flags differ. The "foo" command is shared across actions and is started
     with ovw. The command associated with the "Bar" action will be invoked
     each time the "Bar" action is requested.

     Command

     The command statement in the action block provides the same functionality
     as the Command statement in the application block. It differs in that it
     specifies a specific command for an application that may override the
     application-level command statement. The command statement in the action
     section should specify application startup such that even if the
     application is not running the command executed can still service the
     action request. This is due to the fact that even if the Shared flag was
     enabled, the application might have exited.

     Name Field

     This provides the same object name capability as the NameField setting in
     the Application block, but on a per-action basis.

     CalbackArgs

     This is a string which is broken into an argument vector and passed to
     the application's action callback in the argc and argv parameters. It can
     be used as a more general means for passing parameters from the
     registration file to specific application action callbacks. The
     CallbackArgs are not available to applications which do not use the OVw
     API.

     Application DropAction Registration (UNIX Platforms)

     DropAction Block

     The DropAction block is used to define drop actions which an application
     can perform when the user drops a symbol on a submap or another symbol.
     After defining DropActions they can then be associated with drop targets
     (symbols and submaps) via the OVw API, specifically through
     OVwModifySymbols, OVwModifySubmaps, and OVwAddDropCallback.

     The generic form of a DropAction block is:

          DropAction <DropAction_ID> {
            ...
          }

     The DropAction definition contains the information needed during the
     "drag" of a drag and drop operation to inform the end user about drop
     target's requirements and potential behavior. They only define this for
     the drop target. The DropAction specification is:

     SelectionRule - The kinds of objects are valid for the drop target's
     DropAction.

     Operations - What operations are valid for a drop target...either OpCopy
     or OpMove.

     HelpString - Text that an application supplies describing the expected
     behavior of a drag Move or Copy onto a particular drop target.

     This is an example of a DropAction definition: Application "Mail Manager"
     {    ... DropAction "Backup Mailer"    { SelectionRule isNode; Operations
     OpMove OpCopy; HelpString "The host(s) being dragged will receive a
     message when backup is completed";    }

       }

     In more detail, these are the elements of the DropAction definition:

     DropActionID

     This is an identifier, or name, for the drop action. In the above
     example, the DropAction name is "Backup Mailer". The scope of the name is
     limited to the application registration block; other applications may
     have defined drop actions using the same name.

     An application can use this identifier for two purposes; to tie the
     DropAction to a specific symbol instance and the other is to tie a
     callback to the drop target. As hinted in the above the example,
     DropActions prequalify what is dragged onto the drop target. Only the
     operations specified will be allowed and only the objects that match the
     SelectionRule (if there is one) will be allowed to drop on the drop
     target. The callback, called a DropCallback, will be invoked when symbols
     are actually dropped onto the drop target.

     The routine, OVwAddDropCallback(3) is the API used to register for
     notification when the drop action is invoked. The routines,
     OVwModifySymbols(3) and OVwModifySubmaps(3) are used to tie the
     DropAction to a particular symbol instance. The flag
     ovwUpdateSymbolDropAction must be set and the structures, OVwSymboInfo
     and OVwSubmapInfo should have the fields drop_action and drop_app_name
     set to the name of the DropActionID and application name.

     SelectionRule

     The SelectionRule is a logical expression, using the and (&&), or (||)
     and not (!) operators, on capability fields. Capability fields are
     specially designated fields in the object database used for classifying
     an object. The field registration section below describes how to define a
     field as a capability. Pre-defined capabilities are specified in the
     directory $OV_FIELDS/$LANG.

     This DropAction specifies that the object must have the isNode capability
     set to True. If this is not true during the drag operation, an invalid
     cursor icon will be presented to the user when the user drags a symbol
     over the drop target associated with this DropAction.

     Operations

     Operation can be one of two choices, either OpMove or OpCopy. These
     choices designate which operations are permitted on the drop target.
     OpMove will allow symbols to be moved to the drop target and OpCopy will
     allow copy operations to the drop target. If both operations are omitted,
     no symbols may be dropped on the drop target. This will have the visual
     appearance of canceling the drag and drop operation.

     HelpString

     This is a string which is to be presented to the user upon request by the
     user pressing the <F1> key during the drag operation. Applications
     provide this help information to aid in understanding the consequences of
     dropping a symbol onto a drop target.

     Application Field Enrollment

     The field enrollment section is only needed by applications which will
     manage the semantics of OVW maps. It provides a means for the application
     to present fields from the object database within dialog boxes used by
     semantic applications.

     Field enrollment is rule based. A rule indicates interest in a particular
     type of object based on capability fields. The application can enroll
     various fields based on a rule describing the kind of object associated
     with a particular dialog box.

     The field enrollment section begins with the keyword "Enroll", followed
     by the dialog box for which fields are being enrolled.

     Dialog Boxes

     Applications may enroll fields for the following semantic dialog boxes:

     Add       The dialog box presented when adding an object to the map.
               See OVwVerifyAdd(3).

     Describe  The dialog box presented when describing an object on the map.
               See OVwVerifyDescribe(3).

     Connect   The dialog box presented when connecting two objects on the
               map. See OVwVerifyConnect(3).

     Configuration
               The dialog box presenting per map parameters for configuring
               the application. This dialog box is special in that it is not
               associated with a particular object. See OVwVerifyAppConfig(3).

     Rule

     Rule sections contain field enrollment based on certain capabilities of
     an object associated with the dialog box. The rule is a logical
     expression involving capability fields, like the SelectionRule for
     application actions. It specifies features of objects the application is
     interested in for the dialog box.

     A dialog box enrollment section may contain several Rule sections. When a
     dialog box is presented for a particular object, the object is tested
     against the specified rules. If a rule matches, the field enrollment
     within the corresponding rule section is used for the dialog box. The
     current plan is that the first rule that matches (the rules being scanned
     in the order specified in the registration) describes the dialog box; no
     other matching rules would be used in the dialog box.

     Rule Options

     The only rule option defined is the InitialVerify option. By default,
     this option is disabled, or Off. InitialVerify indicates that the
     application should be immediately contacted when the dialog box is
     displayed to provide default field values.

     NOTE: If an object exists, as it would for the Describe operation, the
     field values are initialized automatically to the values set for the
     object.

     Scale

     The scale setting provides a scale for parameters to Geometry in the
     field enrollment section. If no scale is provided, the scale is assumed
     to be 1.

     Field Enrollment

     Field enrollment sections specify which fields should appear in the
     dialog box given the encapsulating rule and how those fields should be
     presented.

     Options

     The following options may be set per field enrolled. If an option setting
     is absent, it is assumed to be "off".

     NoDisplay If on, it allows the application to be sent the field value
               even if it is not displayed in the dialog box.

     ImmediateVerify
               If on, initiate the process of sending all enrolled fields and
               their values to the application immediately after a value has
               been entered in this field.

     Label     This is the label for the field within the dialog box. If no
               label is specified, the name of the field is used for the
               label.

     Geometry  The Geometry of the field is specified with four integers. They
               are, in order specified: X Position, Y Position, Width, and
               Height. Only Width is supported in the current release; the X ,
               Y , and Height values are ignored but are required by the
               grammar.

     EditPolicy
               The edit policy describes when and whether the field is
               writable or read only. If the policy is "Edit", the field may
               be edited at any time. If it is "NoEdit", the field is only
               displayed.

               Note: Only the first application to enroll a field with the
               Edit edit policy will be permitted to enroll the field in other
               dialog boxes with a policy of Edit. Any other application that
               enrolls this field for a dialog box will automatically get an
               edit policy of NoEdit.

               "EditOnCreation" indicates that the field may be edited only at
               the time a new map is created. EditOnCreation can only be used
               for enrollment for the Configuration operation.

               If the field is a list field and the Edit Policy is "Edit", a
               text field is provided for editing the selected item in the
               list. The default edit policy is "Edit".

     List Selection Policy

     The List Selection Policy specifies the behavior of the selection list.
     Valid choices are:

     None      No specific items may be selected. This is the default.

     Single    Only one item in the selection list can be selected.

     Multiple  More than one item in the selection list can be selected.

     Integer Display Policy

     The integer display policy describes how Integer32 fields are displayed
     in the dialog box. Possible choices are:

     Integer   The integer is displayed in the usual decimal form. This is the
               default.

     Unsigned  The integer is displayed as an unsigned decimal value.

     Hex       The integer is displayed in hexadecimal.

     Octal     The integer is displayed in octal.

     IPAddr    The integer is displayed as an IP address in dot notation, that
               is. as the string returned from a call to inet_ntoa(3).

     Field Default Value

     This section lets you specify a default value for the field. This default
     value is only supported for application configuration fields.

   SYMBOL REGISTRATION
     The symbol class registration files are located in the directory
     $OV_SYMBOLS/$LANG.

     ICON SYMBOL CLASS BLOCK

     An icon symbol class block provides a way to define a new class of icon
     symbols. An icon's symbol class is represented graphically by the symbol
     class shape which is specified in the block.

     A symbol class's shape is defined using either the Arcs or Segments
     fields. The shapes defined using these fields are assumed to be closed
     polygons.

     An example of how an icon symbol class block would be defined follows:

        SymbolClass <class_name> {

          Variety Icon;
            :
        }

     The field <class_name> is the name given to the newly defined symbol
     class.

     The following fields are valid within an icon symbol class block:

     Scale

     The scale field specifies the scale of coordinates given in the Arc or
     Field descriptions.

     The format of a scale statement would be:

        Scale <size>;

     Where size is an integer which defines a square grid with origin (0,0)
     and max(x,y)= (<size>,<size>) and min(x,y) = (-<size>, -<size>).

     If no scale was specified the size defaults to 1 so coordinates are
     assumed to be given on a square grid with origin (0,0) and max (x,y) =
     (1,1) and min (x,y) = (-1, -1).

     Segment

     The segment field is followed by series of points which will be connected
     to form a polygon. The last specified point is automatically connected to
     the first point in the series.

     The general format of a segment statement would be:

        Segment (0,0) to (1,1) to (-1,1) to (1,-1) to (-1,-1);

     Arc

     The Arc statement is used to specify a filled arc shape. It provides a
     way to display circles, ellipses, and wedges for the class shape. An arc
     is defined within a conceptual rectangle of a particular width and
     height. A point is designated within the rectangle as the origin of the
     endpoint of a line which will be rotated to form the solid arc. A
     rotation is given with an optional starting angle and a number of degrees
     to rotate, meaning that the line whose endpoint is at the origin, will
     rotate from the starting angle for the specified number of degrees within
     the rectangle of the specified width and height.

     The general format of an arc statement would be:

        Arc Origin(0,0) Size(2,2) Rotation 0,360;

     Size

     This statement is used to specify the width and height of the conceptual
     rectangle in which the line will rotate. The center of the conceptual
     rectangle is assumed to have the coordinates (0,0).

     Origin

     This statement specifies the origin for the line which will be rotated
     within the conceptual rectangle to form the arc.

     Rotation

     This statement specifies the starting angle where the arc will begin and
     the total number of degrees that the line will rotate through. If no
     starting angle is specified, it defaults to 0, meaning that rotation will
     start from a three o' clock position within the rectangle. All rotation
     is clockwise.

     The HP OpenView Windows Developer's Guide provides more details on how to
     construct class shapes with the Segment and Arc statements.

     Default Layout

     This statement is used to specify what kind of submap layout should be
     used when creating a child submap from this class of symbol. The possible
     choices are Ring, Bus, Star, PointToPoint, RowColumn, and None. This
     default may be overridden within a symbol type definition.

     Capabilities

     The capability block is used to specify the default capabilities for
     objects represented by symbols within this symbol class. A capability
     block is composed of capability statements which specify a capability
     field name and its associated default value.

     An example of a capability block is:

        Capabilities {
          <capability statement>
            ...
        }

     Capability Statement

     For an icon symbol a capability statement is an assignment between a
     capability field name and a default value. Capability field values are
     limited to boolean and enumerated types. The values specified in a
     capability statement will be assigned when the symbol is placed on the
     map from the symbol palette. These capabilities may be extended or
     overridden within a symbol type definition.

     Default Status Source

     This statement is used to specify the source from which a symbol will get
     its status information. The three possible status source values are
     object (get the status from the underlying object), compound (get the
     status from the parent object of the child submap), and symbol (get the
     status from the symbol itself).

     The value specifying a default status source in the symbol class can be
     overridden by the default status source setting in the symbol type
     definition.

     DisplayString Statement

     The DisplayString statement specifies a string that is used to display
     the name of the symbol class. OVW GUI displays this string whenever the
     name of the symbol class must be displayed from within OVW GUI (e.g., the
     Symbol Palette dialog box). SymbolClass "SW_Utils"    { DisplayString "SW
     Utilities";        ...    }If DisplayString is not specified, the symbol
     class name is used instead.

     ICON SYMBOL TYPE BLOCK

     A symbol type specification provides a way to define a new symbol type
     within a class of icon symbols. A symbol type consists of a symbol class,
     defining its shape, and bitmaps to put within the class shape.

     The general format of symbol type specification is:

        SymbolType <symbol_class_name> : <symbol_type_name> {
            ...
        }

     Symbol Class Name

     The symbol class name designates the symbol class from which this symbol
     type is derived. The shape defined in the symbol class is used in drawing
     symbols of this type. All symbol types must be defined within existing
     symbol classes. If an undefined symbol class name is given, ovw emits an
     error and ignores the symbol class registration.

     Symbol Type Name

     This specifies the name given to this particular symbol type. A symbol
     type is then referred to by its symbol class name and its symbol type
     name, e.g. "Computer:Mainframe".

     Symbol Bitmaps

     The FileBase statement is used to specify the bitmap shape used in a
     symbol type which appears within the class shape. The bitmaps used for
     the internal symbol type shapes are located within the $OV_BITMAPS/$LANG
     directory. These bitmaps can either be in X Bitmap format or X Pixmap
     format. Files in this directory containing X Bitmaps are named
     filebase.size.p (the bitmap) and filebase.size.m (the bitmap mask). Files
     containing X Pixmaps are named filebase.size.pm (the pixmap and the
     mask). The base name of the bitmap files used for this symbol type are
     specified using the FileBase statement. ovw uses one of the bitmap files
     which begin with this base file name when displaying this symbol type.
     The size of the bitmap file which is chosen is based upon the scaled size
     of the symbol.

     CursorSize

     The CursorSize section tells ovw which bitmap should be used as the
     cursor when moving symbols on the map. A default cursor size is chosen
     automatically by ovw if one is not specified here. Cursors can be only in
     X Bitmap format. This requires a symbol bitmap in X Bitmap format with
     the same size as the CursorSize.

     Default Layout

     This statement is used to specify what kind of submap layout should be
     used when creating a child submap from this type of symbol. The possible
     choices are Ring, Bus, Star, PointToPoint, RowColumn, and None. This
     declaration would override the default layout if one was specified in the
     symbol class definition.

     Default Status Source

     This statement is used to specify the source from which a symbol will get
     its status information. The three possible status source values are
     object (get the status from the underlying object), compound (get the
     status from the parent object of the child submap), and symbol (get the
     status from the symbol itself).

     Specifying a default status source in the symbol type definition
     overrides the default status source setting in the symbol class
     definition.

     Capabilities

     The capability block is used to specify the default capabilities for
     objects represented by this symbol type. A capability block is composed
     of capability statements which specify a capability field name and its
     associated default value.

     Capability Statement

     For an icon symbol a capability statement is an assignment between a
     capability field name and a default value. Capability field default
     values are limited to boolean and enumerated types. The values specified
     in a capability statement will be assigned when the symbol is placed on
     the map from the symbol palette.

     Specification of capabilities in a symbol type declaration extends or
     overrides the specifications given within the symbol class definition.

     DisplayString Statement The DisplayString statement specifies a string
     that is used to display the name of the symbol type. OVW GUI displays
     this string whenever the name of the symbol type must be displayed from
     within OVW GUI (e.g., the Symbol Palette dialog box). SymbolType
     "SW_Utils" : "Applic."    { DisplayString "Application";        ...
     }If DisplayString is not specified, the symbol type name is used instead.

     CONNECTION SYMBOL CLASS

     A connection symbol class block provides a way to define a new class of
     connection symbols.

     For applications on Windows NT platforms, a connection symbol class is
     represented graphically by line style and line dash pattern. For
     applications on UNIX platforms, a connection symbol class is represented
     graphically by line style, line dash pattern, graphical overlays, and
     thickness.

     An example of how a connection symbol class block would be defined
     follows:

        SymbolClass <class_name> {
          Variety Connection;
            ...
        }

     The field <class_name> is the name given to the newly defined connection
     symbol class.

     The following fields are valid within a connection symbol class block:

     Line Style

     This statement specifies if the line will be Solid or Dash line.

     This specification can be overridden at the connection symbol type level.

     Line Dash Pattern

     This statement is used only if the line style is Dash. It is followed by
     a comma separated list of Dash Lengths which specify the length of a
     single dash or gap in the drawn line. The even elements in the list are
     the dash length and the odd elements are the gap lengths.

     This specification can be overridden at the connection symbol type level.

     Symbol Overlay Bitmaps (UNIX platforms only)
     The FileBase statement is used to specify the bitmap shape used which
     will be placed in the center of the connection symbol. The bitmaps used
     are located within the $OV_BITMAPS/$LANG directory. These bitmaps can
     only be X Pixmap format. Files in this directory containing X Pixmaps are
     named filebase.size.pm (the pixmap and mask). The base name of the pixmap
     files used for this symbol type are specified using the FileBase
     statement. ovw uses one of the pixmap files which begin with this base
     file name when displaying this symbol type. The size of the pixmap file
     which is chosen is based upon the scaled size of the symbol.

     This specification can be overridden at the connection symbol type level.

     Thickness (UNIX platforms only)

     This statement specifies the thickness of the connection symbol.

     This specification can be overridden at the connection symbol type level.

     Default Layout

     This statement is used to specify what kind of submap layout should be
     used when creating a child submap from this class of symbol. The possible
     choices are Ring, Bus, Star, PointToPoint, RowColumn, and None. This
     default may be overridden within a symbol type definition.

     Capabilities

     The capability block is used to specify the default capabilities for
     objects represented by symbols within this symbol class. A capability
     block is composed of capability statements which specify a capability
     field name and its associated default value.

     An example of a capability block is:

        Capabilities {
          <capability statement>
            ...
        }

     Capability Statement

     For a connection symbol, a capability statement is an assignment between
     a capability field name and a default value. Capability field values are
     limited to boolean and enumerated types. The values specified in a
     capability statement will be assigned when the symbol is placed on the
     map from the symbol palette. These capabilities may be extended or
     overridden within a symbol type definition.

     Default Status Source

     This statement is used to specify the source from which a symbol will get
     its status information. The three possible status source values are
     object (get the status from the underlying object), compound (get the
     status from the parent object of the child submap), and symbol (get the
     status from the symbol itself).

     The value specifying a default status source in the symbol class can be
     overridden by the default status source setting in the symbol type
     definition.

     DisplayString Statement The DisplayString statement specifies a string
     that is used to display the name of the connection symbol class. OVW GUI
     displays this string whenever the name of the connection symbol class
     must be displayed from within OVW GUI (e.g., the Symbol Palette dialog
     box). If DisplayString is not specified, the connection symbol class name
     is used intead.

     CONNECTION SYMBOL TYPE

     A connection symbol type specification provides a way to define a new
     connection symbol type within a class of connection symbols.

     The general format of a connection symbol type specification is:

        SymbolType <connection_class_name> : <connection_type_name> {
            ...
        }

     Connection Class Name

     The connection class name designates the connection class from which this
     connection type is derived.

     The shape defined in the symbol class is used in drawing symbols of this
     type.

     All connection types must be defined within existing connection classes.
     If an undefined connection class name is given, ovw emits an error and
     ignores the connection class registration.

     Connection Type Name

     This specifies the name given to this particular connection type. A
     connection type is then referred to by its connection class name and its
     connection type name, e.g. "Fiber:T1".

     The following fields are valid within a connection symbol type block:

     Line Style

     This statement specifies if the line will be a Solid or Dash line.

     If this statement is used it will override any value given in the
     connection symbol class specification.

     Line Dash Pattern

     This statement is used only if the line style is Dash. It is followed by
     a comma separated list of Dash Lengths which specify the length of a
     single dash or gap in the drawn line. The even elements in the list are
     the dash length and the odd elements are the gap lengths.

     If this statement is used it will override any value given in the
     connection symbol class specification.

     Graphical Overlay Bitmaps (UNIX platforms only)

     The FileBase statement is used to specify the bitmap shape which will be
     placed in the center of the connection symbol. The bitmaps used are
     located within the $OV_BITMAPS/$LANG directory. These bitmaps can only be
     X Pixmap format. Files in this directory containing X Pixmaps are named
     filebase.size.pm (the pixmap and mask). The base name of the pixmap files
     used for this symbol type are specified using the FileBase statement. ovw
     uses one of the pixmap files which begin with this base file name when
     displaying this symbol type. The size of the pixmap file which is chosen
     is based on the scaled size of the symbol.

     This specification can override and value given in the connection symbol
     class.

     Thickness

     This statement specifies the thickness of the connection symbol.

     If this statement is used it will override any value given in the
     connection symbol class specification.

     Default Layout

     This statement is used to specify what kind of submap layout should be
     used when creating a child submap from this type of symbol. The possible
     choices are Ring, Bus, Star, PointToPoint, RowColumn, and None. This
     declaration would override the default layout if one was specified in the
     symbol class definition.

     Thickness

     This statement is used to specify the thickness of the connection in
     pixels. The thickess of the connection cannot exceed the width of the
     connected symbols.

     Default Status Source

     Specifying a default status source in the symbol type definition
     overrides the default status source setting in the symbol class
     definition.

     Capabilities

     The capability block is used to specify the default capabilities for
     objects represented by this symbol type. A capability block is composed
     of capability statements which specify a capability field name and its
     associated default value.

     Capability Statement

     For a connection symbol a capability statement is an assignment between a
     capability field name and a default value. Capability field default
     values are limited to boolean and enumerated types. The values specified
     in a capability statement will be assigned when the symbol is placed on
     the map from the symbol palette.

     Specification of capabilities in a symbol type declaration extends or
     overrides the specifications given within the symbol class definition.

     DisplayString Statement The DisplayString statement specifies a string
     that is used to display the name of the connection symbol type. OVW GUI
     displays this string whenever the name of the connection symbol type must
     be displayed from within OVW GUI (e.g., the Symbol Palette dialog box).
     If DisplayString is not specified, the connection symbol type name is
     used instead.

     SYMBOL ALERT TYPE REGISTRATION (UNIX platforms only)

     Symbol alert registration provides a mechanism for defining symbol alert
     types which can be used for symbol alert creation via the OVw API.

      The symbol alert type registration files are located under the same
     directory as the symbol class and symbol type registration files,
     $OV_SYMBOLS/$LANG

     The general format of a symbol alert type specification is:

        SymbolAlert <symbol alert type name>{
            PixmapBaseName <filebase name of pixmap file>
            PixmapSize <size>
            TextRegion {
              RegionCenter (x,y);
              RegionHeight <height in pixels>;
              RegionWidth <width in pixels>;
            }

        }
     The symbol alert registration file begins with the unquoted keyword
     "SymbolAlert" followed by the type name. The specification includes the
     base part of the symbol alert type's pixmap file name and size, and a
     block which is the graphical specification of the text region within the
     pixmap.

     Symbol Alert Type

     The unique part of the name of this symbol alert type. A symbol alert
     type name is referred to as "SymbolAlert:<unique part>" e.g.,
     "SymbolAlert:CriticalAlert"

     PixmapBaseName

     The PixmapBaseName specifies the filebase name of the pixmap file used to
     display the symbol alert type. For symbol alerts only the X Pixmap format
     is supported. The pixmap files used for symbol alerts are located within
     the $OV_BITMAPS/$LANG/sym_alerts directory. Files in this directory are
     named filebase.size.pm, where filebase is the PixmapBaseName and size is
     the PixmapSize (see below). ovw uses the pixmap file named by this
     PixmapBaseName and PixmapSize when displaying this symbol alert type.
     (Symbol alerts are not scaled so only one pixmap file is needed for each
     symbol alert type.) For example, for one of the default symbol alert
     types which uses pixmap file critical_alert.85.pm the PixmapBaseName is
     critical_alert and the PixmapSize is 85.

     PixmapSize

     The size of the pixmap (in pixels). The pixmap must be square; its size
     is specified by the length, in pixels, of one of its sides. In the
     example above PixmapSize is 85.

     TextRegion

     A block which specifies the part of the pixmap in which text can be
     displayed, including that region's center relative to the upper right
     corner of the pixmap, and its height and width in pixels. When symbol
     alert text is positioned on the symbol alert the text region
     specification is used to determine where to display the text and around
     what point to center it or to make it left aligned.

     RegionCenter

     Part of the TextRegion block. It specifies the x and y coordinates of the
     center of the pixmap's text region relative to the upper left corner of
     the pixmap which is designated (0,0).

     RegionHeight

     Part of the TextRegion block. It specifies the height of the pixmap's
     text region in pixels.

     RegionWidth

     Part of the TextRegion block. It specifies the width of the pixmap's text
     region in pixels.

     For an example of a symbol alert type registration see the EXAMPLES
     section at the end of this document.

     FIELD REGISTRATION

     The field registration section provides a mechanism for the creation of
     fields in the object database. Field registration files can be provided
     by applications to ensure that fields used within an enrollment section
     exist in the object database.

     The field registration section begins with the keyword "Field" followed
     by a block which describes the field's name, type, and properties.

     Field Name

     The name of the field as it should be referred to in the object database.

     Field Type

     The following types are allowed for fields in the object database.

     Boolean   True or False value.

     String    Any character string.

     Enumeration
               An enumerated type. The specific enumeration constants can be
               declared in an enumeration section of the field registration.

     Integer32 A 32 bit integer.

     Field Flags

     The field flags indicate certain properties of the field. They are:

     List      This field is a List of the specified type. Currently, the only
               supported types for lists are strings and integers.

     Name      This is a name field. Name fields uniquely identify objects,
               i.e. there is only one object with a specific value for this
               field.

     Locate    A locate operation may be done on the Locate field. This field
               will appear in the Locate:By Attribute dialog box.

     General   This field will appear in the general attributes section of the
               Add and Describe boxes on an object.

     Capability
               This field is a capability and is used to classify an object.
               Only booleans and enumerated types are supported as capability
               fields.

     Field Enumeration

     This section specifies the constant symbolic names of the enumerated
     values for an enumerated type. The first name listed is the name for the
     value "0", the second is the name for the value "1", etc.

     DisplayString StatementThe DisplayString statement specifies a string
     that is used to display the name of the field. OVW GUI displays this
     string whenever the name of the field must be displayed from within OVW
     GUI (e.g., the Capabilities dialog box). For example: Field "isIP" {
     DisplayString "Object is IP";      ...}If DisplayString is not specified,
     the field name is used instead.

   GRAMMAR
     The following is a consolidated grammar for application, symbol, and
     field registration files. Elements of the grammar that are in quotes are
     tokens which are recognized case insensitively. This consolidated grammar
     list includes some elements that are available only for applications on
     UNIX platforms.

        Registration ::= Application | Symbols | SymbolAlerts | Fields | Empty
        EmptyBlock ::= "{" Empty "}"
        Empty ::=
        Application Registration
        Application ::= "Application" AppName AppParent AppBlock
        AppName ::= StringOrIdentifier
        StringOrIdentifier ::= String | Identifier
        String ::= "\"" zero or more ASCII letters "\"" | "'" zero or more
        ASCII letters "'"
        MultibyteString ::= "\"" zero or more ASCII letters "\"" | "\"" zero
        or more non-ASCII letters "\"" | "'" zero or more ASCII letters "'" |
        "'" zero or more non-ASCII letters "'"
        Identifier ::= one ASCII letter (a-z, A-Z) followed by zero or more
        ASCII letters, digits, or underscores
        AppParent ::= ":" AppName | Empty
        AppBlock ::= EmptyBlock | "{" AppStmts"}"
        AppStmts ::= AppStmt | AppStmts AppStmt
        AppStmt::=  Description | HelpDirectory | Naming | Command | Version |
        Copyright | MenuBar | Menu | PopupItem | PopupMenu | ToolbarButton |
        Action | Enrollment | ";"
        Description ::= "Description" DescriptionBlock
        DescriptionBlock ::= EmptyBlock | "{" DescriptionText "}"
        DescriptionText ::= MultibyteStrings
        DisplayString ::= MultibyteString ";"
        MultibyteStrings ::= MultibyteString | MultibyteString "," |
        MultibyteString "," MultibyteString
        Strings ::= String | String "," | String "," Strings
        Copyright ::= "Copyright" CopyrightBlock
        CopyrightBlock ::= EmptyBlock | "{" CopyrightText "}"
        CopyrightText ::= MultibyteStrings
        HelpDirectory ::= "HelpDirectory" Pathname ";"
        Pathname ::= MultibyteString
        Naming ::= "NameField" NameFields ";"
        NameFields ::= NameField | NameFields "," NameField
        NameField ::= StringOrIdentifier
        Command ::= "Command" ProcessFlags String RemoteSpec ";" | "Command"
        String RemoteSpec ";"
        ProcessFlags ::= ProcFlag | ProcessFlags ProcFlag
        ProcFlag ::= "-Initial" | "-Shared" | "-Restart"
        RemoteSpec ::= "On" HostSpec | "On" HostSpec "StartedBy" LaunchSpec |
        Empty
        HostSpec ::= StringOrIdentifier
        LaunchSpec ::= String
        Version ::= "Version" MultibyteString ";"
        MenuBar ::= "MenuBar" Precedence MenuID Mnemonic MenuBlock
        Mnemonic ::= An underscore followed by one or more non-whitespace
        ASCII characters
        Integer ::=  one or more decimal digits | "-" one or more decimal
        digits
        Menu ::= "Menu" MenuID MenuBlock
        MenuID ::= StringOrIdentifier
        MenuBlock ::= EmptyBlock | "{" MenuStmts "}"
        MenuStmts ::= MenuItem | MenuStmts MenuItem
        MenuItem::=  Precedence Label Mnemonic Accelerator ContextExpr
        Function ";" | ";" | Precedence Label Mnemonic Accelerator Function";"
        ContextExpr::= "Context" "(" CtxtExpr ")" | "Context" ContextIdName
        CtxtExpr::=  CtxtExpr "&&"  CtxtExpr | CtxtExpr "||" CtxtExpr | "("
        CtxtExpr ")" | ContextIdName
        ContextIdName::= StringOrIdentifer
        PopupItem::=  "PopupItem" Precedence Label ContextExpr
        TargetSymbolType Function ";"
        ToolbarButton::=  "ToolbarButton" Precedence Label ContextExpr
        Function ";"
        TargetSymbolType::= "TargetSymbolType" "Any" | "TargetSymbolType"
        SymbolClassName ":" "Any" | "TargetSymbolType" SymClassName ":"
        SymbolName
        PopupMenu::= "PopupMenu" MenuId PopupMenuBlock
        PopupMenuBlock::=  EmptyBlock | "{" PopupMenuStatements "}"
        PopupMenuStatements::= PopupMenuItem | PopupMenuStmts PopupMenuItem
        PopupMenuItem::= Precedence Label ContextExpr TargetSymbolType
        Function ";"
        Precedence ::= "<" Integer ">" | Empty
        Label ::= MultibyteString | Bitmap
        Bitmap ::= "@" Pathname
        Accelerator ::= ModifierList "<Key>" KeyName | Empty
        ModifierList ::= ModifierName |  ModifierList ModifierName
        ModifierName ::=  "Ctrl" | "Shift" | "Alt" | "Meta" | "Lock" | "Mod1"
        | "Mod2" | "Mod3" | "Mod4" | "Mod5" | "None" | "Any"
        KeyName ::=  An X11 keysym name. Keysym names can be in the
        keysymdef.h file (remove the XK_ prefix).
        Function ::= "!" ShellCommand | "f.action" FunctionArg | "f.menu"
        FunctionArg
        FunctionArg ::= StringOrIdentifier | Empty
        ShellCommand ::= String
        Action ::= "Action" ActionID ActionBlock
        ActionID ::= StringOrIdentifier
        ActionBlock ::= EmptyBlock | "{" ActionStmts "}"
        ActionStmts ::= ActionStmt | ActionStmts ActionStmt
        ActionStmt ::= SelectionRule | Naming | MinSelected | MaxSelected |
        CallbackArgs | Command | ";"
        SelectionRule ::= "SelectionRule" Expression ";"
        Expression ::= Expression "&&" Expression | Expression "||" Expression
        | "!" Expression | "(" Expression ")" | BooleanExpression
        BooleanExpression ::= Integer | CapabilityFieldName |
        CapabilityFieldName Operator String | CapabilityFieldName Operator
        Integer
        CapabilityFieldName ::= StringOrIdentifier
        Operator ::= "==" | "!="
        MinSelected ::= "MinSelected" Integer ";"
        MaxSelected ::= "MaxSelected" Integer ";"
        CallbackArgs ::= "CallbackArgs" String
        Enrollment ::= "Enroll" AddDescribe | "Enroll" Connect | "Enroll"
        Config
        AddDescribe ::= "Add" AddDescribeBlock | "Describe" AddDescribeBlock |
        "Add" "," "Describe" AddDescribeBlock | "Describe" "," "Add"
        AddDescribeBlock
        AddDescribeBlock ::= EmptyBlock | "{" EnrollAddRules "}"
        EnrollAddRules ::= Rule | EnrollAddRules Rule
        Connect ::= "Connect" ConnectBlock
        ConnectBlock ::= EmptyBlock | "{" EnrollConRules "}"
        EnrollConRules ::= ConnectRule | EnrollConRules ConnectRule
        Config ::= "Configuration" ConfigBlock
        ConfigBlock ::= EmptyBlock | "{" FieldEnrolls "}"
        Rule ::= "If" Expression FieldEnrollsBlock
        FieldEnrollsBlock ::= EmptyBlock | "{" FieldEnrolls "}"
        FieldEnrolls ::= FieldEnrollment | FieldEnrolls FieldEnrollment
        RuleGlobal ::= Scale | RuleOptions | EnrollHelp | ";"
        EnrollHelp ::= "HelpFile" Pathname ";" | "HelpIndex" Pathname ";"
        ConnectRule ::= "If" Expression "," Expression FieldEnrollsBlock
        RuleOptions ::= "InitialVerify" OnOff ";"
        OnOff ::= "On" | "Off"
        FieldEnrollment ::= RuleGlobal | "Field" FieldEnrollName
        FieldEnrollmentBlock
        FieldEnrollName ::= StringOrIdentifier
        FieldEnrollmentBlock ::= EmptyBlock | "{" FieldEnrollStmts "}"
        FieldEnrollStmts ::= FieldEnrollStmt | FieldEnrollStmts
        FieldEnrollStmt
        FieldEnrollStmt ::= FieldOptions | FieldLabel | FieldGeometry |
        FieldEditPolicy | FieldListSelectionPolicy | FieldIntegerDisplayPolicy
        | FieldDefaultValue | ";"
        FieldOptions ::= "NoDisplay" OnOff ";" | "ImmediateVerify" OnOff ";"
        FieldLabel ::= "Label" MultibyteString ";"
        FieldGeometry ::= "Geometry" Integer "," Integer ";" | "Geometry"
        Integer "," Integer "," Integer "," Integer ";"
        FieldEditPolicy ::= "EditPolicy" EditPolicy ";"
        EditPolicy ::= "Edit" | "NoEdit" | "EditOnCreation"
        FieldListSelectionPolicy ::= "ListSelectionPolicy" ListSelectionPolicy
        ";"
        ListSelectionPolicy ::= "None" | "Single" | "Multiple"
        FieldIntegerDisplayPolicy ::= "IntegerDisplayPolicy"
        IntegerDisplayPolicy ";"
        IntegerDisplayPolicy ::= "Hex" | "Octal" | "Integer" | "Unsigned" |
        "IPAddr"
        FieldDefaultValue ::= "DefaultValue" StringOrIdentifier ";"
        DropAction ::= "DropAction" StringOrIdentifier DropActionBlock";"
        DropActionBlock ::= EmptyBlock | "{" DropActStmts "}"
        DropActStmts ::= DropActStmts DropActStmt | DropActStmts
        DropActStmt ::= DropOperation | DropSelectionRule | DropHelp
        DropOperation ::= "Operation" "OpMove" | "OpCopy" | ";"
        DropSelectionRule ::= "SelectionRule" Expression ";"
        DropHelp ::= "HelpString" StringOrIdentifier ";"
        Symbol Registration
        Symbols ::= Symbol | Symbols Symbol
        Symbol ::= SymbolClass | SymbolType
        SymbolClass ::= "SymbolClass" SymClassName SymClassBlock
        SymClassName ::= StringOrIdentifier
        SymClassBlock ::= EmptyBlock | "{" SymClassStmts "}"
        SymClassStmts ::= SymClassStmt | SymClassStmts SymClassStmt
        SymClassStmt ::= Scale | Shape | VarietyStmt | Capabilities |
        DefaultStatusSource | DisplayString | Layout | FileBase | CursorSize |
        LineStmts | Thickness | ";"
        Scale ::= "Scale" Integer ";"
        Shape ::= Arc | Segment
        Arc ::= "Arc" Origin Size Rotation ";"
        Origin ::= "Origin" Point
        Point ::= "(" Integer "," Integer ")"
        Size ::= "Size" Point
        Rotation ::= "Rotation" Integer | "Rotation" Integer "," Integer
        Segment ::= "Segment" Segments ";"
        Segments ::= Point | Point "To" Segments | Empty
        VarietyStmt ::= "Variety" Variety ";"
        Variety ::= "Icon" | "Connection"
        DefaultStatusSource ::= "DefaultStatusSource" StatusSource ";"
        StatusSource ::= "Compound" | "Object" | "Symbol"
        SymbolType ::= "SymbolType" SymClassName ":" SymbolName SymBlock
        SymbolName ::= StringOrIdentifier
        SymBlock ::= EmptyBlock | "{" SymStmts "}"
        SymStmts ::= SymStmt | SymStmts SymStmt
        SymStmt ::= FileBase | CursorSize | Layout | Capabilities |
        DefaultStatusSource | LineStmts | Thickness | ";"
        FileBase ::= "FileBase" StringOrIdentifier ";"
        CursorSize ::= "CursorSize" Integer
        LineStmts ::= LineStyle | LineDashPattern
        LineStyle ::= "LineStyle" "Solid" ";" | "LineStyle" "Dash" ";"
        LineDashPattern ::= "LineDashPattern" DashLengths ";"
        Thickness ::= "Thickness" Integer ";"
        DashLengths ::= DashLength | DashLength "," DashLengths
        DashLength ::= Integer
        Layout ::= "DefaultLayout" LayoutName ";"
        LayoutName ::= "Ring" | "Bus" | "Star" | "PointToPoint" | "RowColumn"
        Capabilities ::= "Capabilities" CapabilityBlock
        CapabilityBlock ::= EmptyBlock | "{" CapabilityStmts "}"
        CapabilityStmts ::= CapabilityStmt | CapabilityStmts CapabilityStmt
        CapabilityStmt ::= CapabilityFieldName ";" | CapabilityFieldName "="
        StringOrIdentifier ";" | CapabilityFieldName "=" Integer ";"
        DisplayString ::= MultibyteString ";"
        Symbol Alert Registration
        SymbolAlerts ::= SymbolAlert | Symbol Alerts Symbol Alert
        Symbol Alert ::= "SymbolAlert" SymbolAlertTypeName SymbolAlertBlock
        SymbolAlertTypeName ::= StringOrIdentifier
        SymbolAlertBlock ::= "{" SymbolAlertStmts "}"
        SymbolAlertStmts ::= SymbolAlertStmt | SymbolAlertStmts
        SymbolAlertStmt
        SymbolAlertStmt ::= SymbolAlertBaseName | SymbolAlertPixmapSize |
        TextRegionSpecification
        SymbolAlertBaseName ::= "PixmapBaseName" StringOrIdentifier ";"
        SymbolAlertPixmapSize ::= "PixmapSize" Integer ";"
        TextRegionSpecification ::= "TextRegion" | TextRegionBlock
        TextRegionBlock ::= "{" TextRegionStmts "}"
        TextRegionStmts ::= TextRegionStmt | TextRegionStmts TextRegionStmt
        TextRegionStmt ::= TextRegionCenter | TextRegionHeight |
        TextRegionWidth
        TextRegionCenter ::= "RegionCenter" TextCenterPoint ";"
        TextCenterPoint ::= "(" Integer "," Integer ")" ";"
        TextRegionHeight ::= "RegionHeight" Integer ";"
        TextRegionWidth ::= "RegionWidth" Integer ";"
        Field Registration
        Fields ::= Field | Fields Field
        Field ::= "Field" FieldRegisterName FieldBlock
        FieldRegisterName ::= StringOrIdentifier
        FieldBlock ::= EmptyBlock | "{" FieldDefStmts "}"
        FieldDefStmts ::= FieldDefStmt | FieldDefStmts FieldDefStmt
        FieldDefStmt ::= FieldType | FieldFlags | FieldEnumeration |
        DisplayString | ";"
        FieldType ::= "Type" FieldTypeName ";"
        FieldTypeName ::= "Boolean" | "String" | "Enumeration" | "Integer32"
        FieldFlags ::= "Flags" FieldFlagStmts ";"
        FieldFlagStmts ::= FieldFlag | FieldFlag "," FieldFlagStmts | Empty
        FieldFlag ::= "List" | "Name" | "Locate" | "General" | "Capability"
        FieldEnumeration ::= "Enumeration" EnumDefs ";"
        EnumDefs ::= EnumDef | EnumDef "," EnumDefs
        EnumDef ::= EnumName
        EnumName ::= StringOrIdentifier
        DisplayString ::= MultibyteString ";"

   INTERNAL FUNCTIONS
     new_map   Brings up a dialog box for creating a new map.

     avail_maps
               Brings up a dialog box listing the available maps. The dialog
               box will also allow the user to select and open or delete a
               map.

     save_map  Brings up a dialog box for saving the current map.

     map_desc  Brings up a dialog box describing the current map and for
               modifying it.

     create_snap
               Brings up a dialog box for creating a map snapshot.

     avail_snap
               Brings up a dialog box listing the available map snapshots. The
               dialog box will also allow the user to select and open or
               delete a map snapshot.

     snap_desc Brings up a dialog box describing the current map snapshot.

     add_obj   Brings up the Add Object palette so the user can drag new
               objects onto a submap.

     add_conn  Brings up the Add Connection dialog box.

     sym_desc  Brings up a dialog box with symbol description information and
               allows the user to modify some fields. This associated with a
               pop-up menu item only.

     obj_desc  Brings up a dialog box with object description information and
               allows the user to modify the fields.

     new_submap
               Brings up a dialog box for creating a new submap.

     list_submaps
               Brings up a dialog box listing the available submaps. The
               dialog box will also allow the user to select and open or
               delete a submap.

     submap_desc
               Brings up a dialog box describing the current submap and for
               modifying it.

     sel_objs  Brings up a dialog box that lists the currently selected
               objects and allows the user to modify it.

     locate_name
               Brings up a dialog box for locating objects based on selection
               name.

     locate_type
               Brings up a dialog box for locating objects based on symbol
               type

     locate_comment
               Brings up a dialog box for locating objects based on comment
               string.

     locate_status
               Brings up a dialog box for locating objects based on symbol
               status.

     locate_attr
               Brings up a dialog box for locating objects based on object
               attribute.

     locate_label
               Brings up a dialog box for locating objects based on symbol
               label.

     disp_legend
               Brings up a help dialog box that shows the display legend which
               describes how ovw encodes information in the submap.

     about_ovw Brings up a dialog box that allows the user to look at OVW
               application information.

     redolayout
               Causes the submap to refresh the layout of its symbols.

     close_snapshot
               Closes the current snapshot.

     refresh_map
               Refreshes the current map. Only valid on read only maps.

     select_highlighted
               Causes ovw to add all highlighted objects to the selection
               list.

     clear_highlights
               Causes ovw to clear the highlighting on highlighted objects.

     manage_objects
               Manages the selected objects.

     unmanage_objects
               Unmanages the selected objects.

     exit      Exits ovw.

     delete_obj
               Deletes the selected objects from all submaps in ovw.

     delete_obj_smap
               Deletes the selected objects from the current submap.

     hide_obj  Hides the selected objects on all submaps that it appears.

     hide_obj_smap
               Hides the selected objects on the current submap.

     delete_smap
               Deletes the current submap.

     cut_obj_smap
               Cuts the selected objects from the current submap.

     cut_obj   Cuts the selected objects from all submaps in ovw.

     copy_obj_smap
               Copies the selected objects from the current submap.

     copy_obj  Copies the selected objects from all submaps in ovw.

     paste     Pastes the objects in the clipboard to the current submap.

     unhide    Causes all of the hidden symbols on the current submap to
               become visible again.

     unhide_all
               Causes all of the hidden symbols in ovw to become visible
               again.

     show_panner
               Brings up the Panner window for the current submap.

     goto_root Raises/displays the root submap window.

     goto_home Raises/displays the home submap window.

     goto_parent
               Raises/displays the current submap's parent submap window.

     close_smap
               Closes the current submap.

     task_index
               Brings up a help dialog box that contains information on OVW
               tasks.

     function_index
               Brings up a help dialog box that contains information on OVW
               tasks.

     help_browser
               Brings up a help dialog box on the help volume and location id
               passed in as a parameter.

     help_string
               Displays the specified helpString (a character string) in a
               simple help dialog box.

     man_page  Displays the specified manual page in a help dialog box.
               Specific sections of the manual may be requested using the
               format: ovhelp -manPage '1M mount'.

     quick_help
               Creates a quick help browser window containing the specified
               CDE Help volume.

     text_file Displays the specified (ascii) file in a help dialog box.

     on_help   Brings up a help dialog box on how to use the help system.

     open_symbol
               Opens the submap associated with an explodable symbol. This is
               associated with a pop-up menu item only.

     change_symbol
               Brings up a dialog box which allows the symbol's type to be
               changed. This is associated with a pop-up menu item only.

     delete_symbol
               Deletes the given symbol. This is associated with a pop-up menu
               item only.

     hide_symbol
               Hides the given symbol. This associated with a pop-up menu item
               only.

     star_center_symbol
               Sets the given symbol as the center symbol in a star layout.
               This is associated with a pop-up menu item only.

     set_home_submap
               Sets the current submap as the new home submap.

     persistify
               Makes the current submap persistent.

     terminate Exit ovw without prompting the user.

 EXAMPLES

     The following are simple, example registration files for each of the
     registrations described above. These examples include features such as
     symbol alerts which are available only for applications on UNIX
     platforms.

        Example Application Registration
        /*  OpenView Windows Terminal Connect */
        Application "OpenView Windows Terminal Connect" {
          Version "3.0";
          Description {
            "Enables you to create a terminal emulator window on a local ",
            "system that is connected to a remote system via a network ",
            "virtual terminal protocol. "
          }
          Copyright {
            "(c)Copyright 1992 Hewlett-Packard Co."
          }
           DisplayString "OpenView Windows Terminal Connect";
          // There is no application command statement.  Instead, each action
          // defines its own command.
          MenuBar <100> "Misc" _s {
          <100> "Terminal Connect"   _T   f.menu "Terminal Connect";
          }
          Menu "Terminal Connect" {
            <100> "Telnet (xterm)"  _x f.action "XTerm Telnet";
            <100> "Vt3k (hp3000)"   _V f.menu   "Vt3k Menu";
          }
          Menu "Vt3k Menu" {
            <100> "Block Mode ..." _B f.action "Block vt3k";
            <100> "Type Ahead ..." _T f.action "Typeahead vt3k";
          }
          Action "XTerm_Telnet" {
            MinSelected 1;
            MaxSelected 1;
            SelectionRule isNode;
            NameField "IP Hostname";
            Command "${xnmtelnet:-/usr/OV/bin/xnmtelnet} xterm";
            DisplayString "XTerm Telnet";
          }
          Action "Block_vt3k" {
            MinSelected 1;
            MaxSelected 1;
            SelectionRule isNode && (vendor=="Hewlett-Packard");
            NameField "IP Hostname";
            Command "${xnmvt3k:-/usr/OV/bin/xnmvt3k} block";
            DisplayString "Block vt3k";
          }
          Action "Typeahead_vt3k" {
            MinSelected 1;
            MaxSelected 1;
            SelectionRule isNode && (vendor=="Hewlett-Packard");
            NameField "IP Hostname";
            Command "${xnmvt3k:-/usr/OV/bin/xnmvt3k} typeahead";
            DisplayString "Typeahead vt3k";
          }
        }
        Example Symbol Class and Symbol Type Registration
        /* Network symbols */
        SymbolClass "Network"
        {
          Scale 7;
          Arc Origin (-2, -1) Size (17, 17) Rotation 0, 360;
          DefaultStatusSource Compound;
          DefaultLayout PointToPoint;
          Variety Icon;
          Capabilities {
            isNetwork = 1;
          }
        DisplayString "Network";
        }
        SymbolType "Network" : "Network"
        {
          Filebase "ip_net";
          CursorSize 38;
          DisplayString "Network";
        }
        SymbolType "Network" : "IP_Network"
        {
          Filebase "ip";
          CursorSize 38;
          Capabilities {
            isIP = 1;
          }
          DisplayString "IP Network";
        }
        SymbolType "Network" : "Bus"
        {
          Filebase "bus";
          CursorSize 38;
          Capabilities {
            isNetwork = 0;
            isSegment = 1;
            isBusSegment = 1;
          }
          DisplayString "Bus";
          DefaultLayout Bus;
        }
        SymbolType "Network" : "Token_Ring"
        {
          Filebase "ring";
          CursorSize 38;
          Capabilities {
            isNetwork = 0;
            isSegment = 1;
            isTokenRingSegment = 1;
          }
          DisplayString "Token Ring";
          DefaultLayout Ring;
        }
        Example Symbol Alert Type Registration
        /* OVW critical symbol alert*/
        SymbolAlert CriticalAlert{
          PixmapBaseName critical_alert;
          PixmapSize 85;
          TextRegion {
            RegionCenter (43,45);
            RegionHeight 46;
            RegionWidth 75;
          }
        }
        Example Field Registration
        /* OVW fields */
        Field "vendor" {
          Type    Enumeration;
          Flags   capability, general, locate;
          Enumeration "Unset", "Hewlett-Packard", "Other";
          DisplayString "Vendor";
        }
        Field "IP_Hostname" {
          Type    StringType;
          Flags   name, locate;
          DisplayString "IP Hostname";
        }
        Field "isLocation" {
          Type    Boolean;
          Flags   capability;
          DisplayString "Object is Location";
        }
        Field "isIP" {
          Type    Boolean;
          Flags   capability, locate;
          DisplayString "Object is IP";
        }

 FILES

     The environment variables below represent universal pathnames that are
     established according to your shell and platform requirements. See the
     ov.envvars(1) manpage for the universal pathnames for your platform and
     shell.

     $OV_FIELDS/$LANG

     $OV_REGISTRATION/$LANG

     $OV_SYMBOLS/$LANG

 SEE ALSO

     ovw(1), ovwdb(1M), OVwAddActionCallback(3), OVwVerifyAdd(3),
     OVwVerifyDescribe(3), OVwVerifyConnect(3), OVwVerifyAppConfig(3),
     inet_ntoa(3), exec(2).

     The HP OpenView Integration Series: OpenView Application Style Guide

     The HP OpenView Integration Series: OpenView Windows Developer's Guide

     The HP OpenView Integration Series: OpenView Windows Developer's
     Reference

 EXTERNAL INFLUENCES

   Environment Variables
     There are four optional environment variables specifying the paths to
     directories containing the registration files. If they are not set, then
     OVW uses the default directories. The environment variables are:

     OVwRegDir - application registration files

     OVwFieldDir - field registration files

     OVwSymDir - symbol registration files

     OVwBitmapDir - bitmap files

     Each environment variable may contain a colon separated list of absolute
     paths to be searched. For example:
     OVwRegDir=/usr/OV/registration/C:/users/sam/my_development

     Duplicate applications are detected by the "Application" name. Duplicate
     symbol classes and symbol types are detected by the "Symbol Class" and
     "Symbol Type" names. Multiple field registration files may contain
     information about the same field. However, an existing field may not be
     redefined to have a different type in another field registration file.
     Processing of a particular field registration file stops when a field
     type mismatch is detected. The rule for OVwBitmapDir is that it uses the
     first directory containing a file with the name specified by the
     "Filebase" in the symbol registration file. It does not search the
     remaining directories.

     LC_TYPE determines the interpretation of messages as single- and/or
     multi-byte characters.

     LANG determines the language in which language sensitive messages are
     displayed.

   International Code Set Support
     Single- and multi-byte character code sets are supported.




home/search | what's new | help