Abstract:
A processor (CPU) in the computer system executes an application program made up of a number of components, each associated with a set of commands. While the program is executing, a current operating mode of the program is selected. The processor automatically constructs a dynamic menu for the selected operating mode by determining which of the program&#39;s components are active in the current operating mode, merging the commands sets of these active components to form an active set of command for the current operating mode, and organizing the commands of the active set into a menu structure. The constructed, displayed menu items can be selected with an input device. Menu items contained in a displayed application menu bar are revised when one of a number of subwindows displayed by the application is selected. Displayed menu items pertaining to a particular subwindow are included in the menu bar when the subwindow is selected. Add-on software components provides additional menu items to those provided by the application program and their implementations without itself having to modify the application&#39;s menu bar to add those menu items or intercept and process user input for selecting these menu items.

Description:
TECHNICAL FIELD 
     The invention relates to computer system user interfaces and more particularly to user interfaces having menus, such as graphical user interfaces. 
     BACKGROUND OF THE INVENTION 
     Graphical user interface (GUI) technology has offered computer users the promise of easy, intuitive access to complex computer software. Unfortunately, the reality often falls short of the promise. In particular, the familiar point-and-click menuing interfaces provided by many GUIs become unwieldy and difficult to use when the software that they control is especially complex. The sheer number of menu choices can be bewildering even to the most experienced user. 
     GUI designers have adopted various approaches in the prior art in their attempts to streamline and simplify menu interfaces. One approach is to provide &#34;accelerator keys&#34; that replace certain menu commands with keyboard inputs and &#34;tool bars&#34; that provide shortcut icons (also known as glyphs) for accessing commonly used functions at the touch of a button. Another approach is to provide hierarchies of menus and submenus. In menu hierarchies, any menu item can be a submenu. Selecting a menu item that is a submenu causes a list of items in the submenu to be displayed. These items (which can include sub-submenus, etc.) can then be selected. In general, the graph of the overall hierarchy &amp;menu bar, menus, and any submenus is a directed acyclic graph. 
     A third approach to streamlining menu interfaces is to display different menus according to context. The user sees only the menu choices relevant to the particular program context in which the user is currently operating, and so is not faced with a large number of irrelevant choices. An example of such a system in the prior art is found in the interface for the Microsoft Mail for Windows 3.2 electronic mail application program for personal computers, made by Microsoft Corp. (Redmond, Wash.). Microsoft Mail supports various kinds of interface windows, including an &#34;Inbox&#34; window that displays incoming electronic mail messages and a &#34;Send Note&#34; window that allows a user to compose an electronic mail message. Each of these kinds of windows has a &#34;View&#34; menu, but the contents of the &#34;View&#34; menu differs as between the two kinds of windows. 
     The &#34;Inbox&#34; window is shown in the example of FIG. 1A. The display contains a window 100 that is the master window for the Microsoft Mail program and an &#34;Inbox&#34; window 110. Also shown are a menu bar 120 that includes several menus such as menus 122 (&#34;File&#34;), 123 (&#34;Edit&#34;), and 124 (&#34;Mail,&#34; &#34;Window,&#34; &#34;Help&#34;), and in particular includes menu 130 (&#34;View&#34;), which is selected and displayed so that its contents 131 can be seen. &#34;View&#34; menu 130 includes items such as items 132 (&#34;Sort by Sender&#34;), 133 (&#34;Open Inbox&#34;), 134 (&#34;Split&#34;), 135 (&#34;Tool Bar&#34;), and 136 (&#34;Status Bar&#34;). Each item can be selected by the user to cause a command to issue to the Microsoft Mail program. Accordingly, menu items are also referred to as menu selections or menu commands. Menu items are grouped into display groups 140, 141 that are visually separated by separator bars 150. Each display group contains one or more related items. Additionally, the display includes a tool bar 160 that has icons (also called glyphs), such as icons 161 (&#34;Compose&#34;), 162 (&#34;Move&#34;), 163 (&#34;Delete&#34;), and 164 (&#34;Previous,&#34; &#34;Next&#34;). Each tool bar icon can be selected by the user to cause a command to issue to the program. 
     In particular, selecting the &#34;Compose&#34; icon 161 causes a &#34;Send Note&#34; window to appear in the display. This window is shown in the example of FIG. 1B. As in FIG. 1A, the display contains master window 100 and &#34;Inbox&#34; window 110, which is partially hidden behind &#34;Send Note&#34; window 115. &#34;Send Note&#34; window is the active window, that is, the window through which the user is currently interacting with the Microsoft Mail program. Menu bar 120 contains the same items as in FIG. 1A, including &#34;View&#34; menu 130, which is once again shown selected and displayed so that its contents can be seen. However, the contents 131&#39; of &#34;View&#34; menu 130 in FIG. 1B differ from the contents 131 of &#34;View&#34; menu 130 in FIG. 1A, because a different type of window is active. Thus, although display group 141 containing items 135 (&#34;Tool Bar&#34;) and 136 (&#34;Status Bar&#34;) remains in place, the other display groups 140 of FIG. 1A are replaced by new display groups 140&#39; that contain new menu items such as item 138 (&#34;Next&#34;) and item 139 (&#34;Previous&#34;). Also in FIG. 1B, certain menu items of &#34;View&#34; menu 130, such as items 138 and 139, are displayed in a lighter color or different typeface as compared with other items such as items 135 and 136. These differently displayed items are said to be &#34;grayed out,&#34; because in a black-and-white display they can appear to be gray instead of black. (Tool bar icons, too, can be grayed out; for example, icon 163 is shown in black in FIG. 1A but grayed out in FIG. 1B, and icons 164 are shown grayed out in both FIG. 1A and FIG. 1B.) 
     Menus that change automatically according to the active window type are easier to use than fixed menus are. Unfortunately, as computer programs have become increasingly complicated, providing such menus has become increasingly cumbersome. Known menuing systems and methods determine the menu contents to be displayed by selecting the appropriate contents from among several possibilities that are determined ahead of time by the program designer and are stored accessibly to the program. For example, the &#34;View&#34; menu 130 of FIGS. 1A and 1B can have two possibilities stored, one corresponding to the contents 131 displayed in FIG. 1A and another corresponding to the contents 131&#39; displayed in FIG. 1B. As window types and menus proliferate, the number of possibilities that must be designed and stored increases, so that this approach of known systems and methods becomes increasingly unworkable. 
     Moreover, the approach of known systems and methods is inflexible, in that all possible menu contents must be determined ahead of time. There is no convenient way to incorporate unanticipated new functionality into an existing set of menus. For example, suppose that an application program is originally designed and developed by certain program developers, and that at a later date, certain other program developers (possibly from a different software company) want to develop add-on software components that can be used with the application program to give it new features and enhanced functionality. Of course, the new developers would like their add-on software to include a user interface so that users can access their new features. The new developers quickly find themselves at an impasse, however, because the entire set of possible menus (and perhaps a very limited list of permissible extensions) has already been determined and coded into the application program by the original designers. The new developers cannot add items to existing menus without modifying the original program, and as a practical matter they cannot modify the original program because it is already in the hands of thousands or millions of users. Often, the best that the add-on developers can do is to graft a new menu or menus onto the menu bar (if the computer&#39;s operating system or the application program supports this). The resulting interface is aesthetically unpleasing and awkward to use, and so does not deliver on the promise of GUIs. 
     SUMMARY OF THE INVENTION 
     The present invention provides a method and system by which a computer can automatically and dynamically construct user interface menus &#34;on the fly&#34; during execution of a program. For example, the computer can reconfigure displayed menus responsively to a change in the operating mode of the program or selection of a new active window type. Furthermore, the invention provides seamless integration of new menu items into an existing set of menus when new software components are added to an existing program. Thus the invention facilitates the development of add-on software for application programs. 
     In one aspect, the invention provides a method for dynamic menu construction in a graphical user interface (GUI). A processor (CPU) in a computer system executes an application program made up of a number of components. Each component is associated with a set of commands. While the program is executing, a current operating mode of the program is selected. The processor automatically constructs a menu for the selected operating mode by determining which of the program&#39;s components are active in the current operating mode, merging the command sets of these active components to form an active set of commands for the current operating mode, and organizing the commands of the active set into a menu structure. The constructed menu can be displayed using a visual display, and commands from the menu can be selected with an input device. 
     The invention will be better understood with reference to the drawings and detailed description below. In the drawings, like reference numerals indicate like components. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIGS. 1A-1B are examples of menus in the prior art; 
     FIG. 2 illustrates the components of a computer system suited to an embodiment of the invention; 
     FIG. 3A schematically depicts an example of the structure of an application program suited to an embodiment of the invention; 
     FIG. 3B is an example of package object and related objects; 
     FIG. 4 is a flowchart of the steps for package registration; 
     FIG. 5 is a high-level flowchart of the steps for dynamically constructing menus; 
     FIG. 6 is a more detailed flowchart of the steps for determining menu contents; and 
     FIG. 7 is a more detailed flowchart of the steps for organizing menu contents. 
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     Overview 
     In a specific embodiment to be described, the invention provides automatic run-time menu construction in an application program having a graphical user interface (GUI) that supports multiple active windows of various types. Menu items (commands) from two or more different software components can be integrated into a single menu and can be assigned to a particular display group within the menu. The specific embodiment is implemented in Microsoft Visual C++ 2.0, an application program that provides a development environment for the well-known C++ programming language. Visual C++ runs in the context of an operating system that has GUI and windowing capabilities, such as Microsoft® Windows™ NT or, in the specific embodiment, Microsoft® Windows™95. 
     Visual C++ provides various types of windows. A user developing a C++ software program in Visual C++ can have several windows of different types open simultaneously. For example, the user can have open a source code editor window, various types of debugging windows, and various types of resource editor windows, which are used, for example, to control the appearance of the user interface of the software program being developed. At any given time, one of the open windows is selected as the active window through which Visual C++ interacts with the user. The displayed menus change according to what type of window (source code, debugger, resource editor, etc.) is active. Thus as windows are opened, closed, or selected, Visual C++ dynamically recreates the menu bar and the menus according to the invention so as to provide access to a set of commands appropriate for the current active window. 
     Visual C++ is structured as a shell into which one or more software components called dynamically linked library components, or DLLs, can be incorporated to provide different aspects of the program&#39;s functionality. (Technically speaking, the shell itself is also a DLL.) To incorporate a DLL into Visual C++, the DLL is loaded into memory with the program and thereafter is executed as part of the program. New DLLs can be developed as add-ons to Visual C++ and can be loaded into the shell without any need to modify the underlying Visual C++ program. 
     According to the invention, the menus displayed by Visual C++ are automatically configured at run time so as to provide the user with access to the commands for the particular DLLs that have been loaded. This makes the program readily extensible. For example, suppose a DLL is written to enable source code programming in a programming language other than C++, such as FORTRAN or Pascal, using the resource editor and debugging facilities of the underlying Visual C++ program. The new DLL can be linked into the Visual C++ environment, and Visual C++ will automatically incorporate the commands for the newly linked DLL into the displayed menus. There is no need to modify the Visual C++ shell or the DLLs provided as standard components with Visual C++ in order to add a new DLL. Quite simply, from the user&#39;s standpoint, the new code just plugs in and runs and the menus automatically take care of themselves. 
     System Components 
     FIG. 2 illustrates a computer system 200 in which the specific embodiment of the invention can be implemented. The hardware of system 200 includes a processor (CPU) 205, a memory 206, a persistent storage 208, and hardware for a graphical user interface (GUI) 220, coupled by a local bus or interface 210. System 200 can further include additional hardware components (not shown). 
     System 200 can be, for example, a personal computer or workstation. Processor 205 can be, for example, a microprocessor, such as the 80386, 80486 or Pentium™ microprocessor, made by Intel Corp. (Santa Clara, Calif.). Memory 206 can include, for example, random-access memory (RAM), read-only memory (ROM), virtual memory, or any other working storage medium or media accessible by processor 205. Persistent storage 208 can include a hard disk, a floppy disk, an optical or magneto-optical disk, or any other persistent storage medium. 
     GUI 220 facilitates communications between a user and system 200. Its hardware includes a visual display 221 and a selector device 222. Through visual display 221, system 200 can deliver graphical and textual output to the user and, in particular, can display windows, menu bars, and menus. From selector device 222, system 200 can receive inputs indicating the user&#39;s selection of particular windows, menus, and menu items. Visual display 221 can include, for example, a cathode-ray tube (CRT) or flat-panel display screen, or a head-mounted display such as a virtual reality display. Selector device 222 can be, for example, a two-dimensional pointing device such as a mouse, a trackball, a trackpad, a stylus, a joystick, or the like. Alternatively or additionally, selector device 222 can include a keyboard, such as an alphanumeric keyboard with function and cursor-control keys. 
     The software of system 200 includes an operating system 250 and an application program 260, and can further include one or more add-on software components (DLLs) 271, 272 designed to operate in conjunction with application program 260. The software of system 200 can further include additional application programs (not shown). Operating system 150 can be, for example, the Microsoft® Windows™95 operating system for IBM PC and compatible computers having or emulating Intel 80386, 80486, or Pentium™ processors. Application program 160 is Visual C++ 2.0 in this embodiment. Persons of skill in the art will appreciate that a wide range of hardware and software configurations can support the system and method of the present invention in various specific embodiments. 
     The invention facilitates automated menu construction by appropriate support structures, as shown in FIGS. 3A-3B. FIG. 3A schematically depicts the structure of an example application program 260 and shows its relationship to add-on software components including add-on component 271. Application program 260 is organized as a modular system, in which shell 300 governs one or more modules, such as modules 311 and 312 and additional modules (not shown), that provide different aspects of the program&#39;s functionality. Each module has associated commands that can be made available to the user through menus whenever a window associated with the module&#39;s functionality is active. In particular, module 311 has associated commands 312 and module 321 has associated commands 322. Optionally, each module can have one or more associated subsystems each of which can have its own associated commands specific to its use. In particular, module 311 has subsystems 313, 315 which have associated commands 314, 316 respectively, and module 321 has subsystems 323, 325, 327 which have associated commands 324, 326, 328, respectively. Additionally, shell 300 can include its own set of commands (not shown). 
     In the specific embodiment, the combination of a module and its associated commands, subsystems, and subsystem commands is called a package. A package is a particular kind of DLL that has the structure of modules, commands, subsystems, and subsystem commands that have been described, and that adheres to certain protocols according to the method of the invention that will be more fully described below with reference to FIG. 4. The subsystems affiliated with a package are called packets. In FIG. 3A, module 311 and its affiliated commands, subsystems, and subsystem commands make up package 310, and module 321 and its affiliated commands, subsystems, and subsystem commands make up package 320. Shell 300 is also considered to be a package. Subsystems 313 and 315 are the packets of package 310, and subsystems 323, 325, and 327 are the packets of package 320. 
     Besides shell 300 and packages 310 and 320, which come with application program 260 as standard components, application program 260 can support optional add-on components. Add-on components can be developed either by the designers of application program 260 or by third-party developers. Application program 260 is referred to as a host program or host application with respect to its add-on components. Like standard components, add-on components are packages. They support the same kinds of internal structures and conform to the same protocols as their standard counterparts. In FIG. 3A, component 271 is an add-on component that &#34;plugs into&#34; application program 260. Component 271 is a package that is made up of module 331, module commands 332, subsystem (packet) 333, and packet commands 334. 
     FIG. 3B shows the relationships among objects used to represent various software components in application program 260. Objects, in the sense of &#34;object-oriented programming,&#34; encapsulate related information and functionality within a program as is well-known in the art. Each package in application program 260 is represented by a package object. Each subsystem (packet) is represented by a packet object. Shell 300 maintains pointers to all package and packet objects in application program 260 and in any add-on components such as components 271, 272. 
     Commands for a package or for its packets are represented by command tables. Command tables are data structures, such as arrays, that contain information about individual commands. Each entry in a command table can contain, for example, the name of a command; information used for displaying the command name and related text; information that tells whether the command is bound to a menu, tool bar, accelerator key, or other user interface mechanism; a tool bar icon, if the command is bound to a tool bar button; and a unique identifier, for example an integer that uniquely specifies the command. Further, according to the invention, each entry in a command table also contains a group identifier, such as an integer, which indicates the display group to which the command should be assigned when a menu containing the command is constructed. Any two or more menu items that are to be included in the same display group within a menu will share a common group identifier. Group identifiers are used in sorting commands into functional or logically related groups for display, and thus promotes the construction of easy-to-use menus. The set of available group identifiers can be assigned by program designers or, in some embodiments, determined automatically by the computer, for example by shell 300 at run time, so that display groups unanticipated by the original developers of application program 260 can readily be added by later developers of add-on components. 
     In FIG. 3B, package object 350 corresponds to package 310 of FIG. 3A. Package object 350 maintains a pointer to command table 351 which corresponds to module commands 310, a pointer to packet object 360 which corresponds to subsystem 313, and a pointer to packet object 362 which corresponds to subsystem 315. Packet object 360 (&#34;packet object 1&#34;) maintains a pointer to command table 361 which corresponds to commands 314, and packet object 362 (&#34;packet object 2&#34;) maintains a pointer to command table 363 which corresponds to commands 316. Although each of packet objects 360 and 362 points to its own command table, it is also possible for two or more packet objects to point to the same command table so that their respective packets share commands, or for a packet not to point to any command table, so that its corresponding packet adds no commands to the package in which it resides. 
     Package object 350 also points to template objects 370 (&#34;template object A&#34;), 380 (&#34;template object B&#34;), and 390 (&#34;template object C&#34;). Each template object corresponds to a particular type of window. For example, windows 371 and 372 are of the type (&#34;A&#34;) associated with template object 370, window 381 is of the type (&#34;B&#34;) associated with template object 380, and window 391 is of the type (&#34;C&#34;) associated with template object 390. Windows 371, 372, 381, and 391 are windows that can be displayed in visual display 221. 
     The relationship between packages, packets, command tables, template objects, and windows can be explained more concretely in terms of the behavior of application program 260 in the specific embodiment. In Visual C++ 2.0, the standard packages (apart from the shell) include a package that provides the source code editing and debugging capabilities of the program, a package for resource editing, and a package for project management. The source editor-debugger package supports a source editor packet and several debugger packets including packets for stack analysis, memory display, register display, disassembly, etc. The resource editor package includes packets for editing dialog boxes, keyboard accelerators, display strings, icon bit maps, cursor bit maps, etc. The project management system has no packets. 
     Each of the three standard packages in Visual C++ 2.0 supports one or more types of user interface windows. Each of the window types has an associated template object. The commands that appear in the menus for an active window of a given type can include package commands provided by the packer&#39;s module, and packet commands provided by individual packets of the package. For example, in FIGS. 3A-3B, window 371 is associated with template object 370, which points to packet object 362, which corresponds to subsystem (packet) 315. Thus the commands that can be displayed when window 371 is active include the commands 312 provided by module 311 of package 310, which are stored in command table 351, and the commands 316 of subsystem 315, which are stored in command table 363. Similarly, window 391 is associated with template object 390, which points to packet object 360, which corresponds to subsystem (packet) 313. The commands that can be displayed when window 391 is active include the commands 312 provided by module 311 of package 310, which are stored in command table 351, and the commands 314 of subsystem (packet) 313, which are stored in command table 361. 
     A practical benefit of providing separate objects and command tables for packages and packets is that the package commands can be used flexibly with windows of several types, or even when no windows are open, and packet commands can provide more specialized commands appropriate to particular types of window. In FIG. 3B, the package commands stored in command table 351 can be made available, for example, in all of window types &#34;A,&#34; &#34;B,&#34; and &#34;C&#34; (corresponding to template objects 370, 380, and 390, respectively) and also when no window is open, whereas packet commands from command table 361 can be made available specifically in type &#34;C&#34; windows, and packet commands from command table 362 can be made available specifically in type &#34;A&#34; or type &#34;B&#34; windows. 
     Method Steps 
     As indicated above, a package, whether standard or add-on, adheres to certain protocols according to the method of the invention. In particular, a package notifies shell 300 of its existence and informs shell 300 of its command tables and its packets, if any, and their respective command tables, if any. This process of notification is called registering with the shell, or registration. Registration can take place, for example, as part of an initialization sequence that is performed automatically when application program 260 begins executing. 
     The steps of registration are illustrated in the flowchart of FIG. 4. Each package loaded with application program 260 is considered in turn (step A). The package currently being considered calls a package registration function to register itself with shell 300 (step B), and also calls a packet registration function for each of its packets, if any, to register them as well (step C). Additionally, the package calls a template registration function for each of its template objects (step D). By registering the template objects, the package informs shell 300 about the types of windows with which the package can work, and about the packets that are to be used in constructing the menus for these particular types of windows. In other words, registering the template objects creates a link between window types and packets, and thus between windows and packet command tables. Shell 300 provides the package, packet, and template registration functions. 
     The high-level steps for constructing the menus according to the method of the invention in the specific embodiment are illustrated in the flowchart of FIG. 5. At the start of FIG. 5, it is assumed that application program 260 is executing and that all packages have been registered with shell 300, so that shell 300 has current information about all packages and packets and their respective command tables and can readily obtain the group identifier and unique identifier for each command. 
     Whenever a new window is selected, opened, or otherwise becomes the active window (step AA), application program 260 determines whether the newly selected window is of the same type as any previously selected window (step AB). If so, application program 260 continues to use the same menus as for the previously selected window (step AC). However, if the new window is of a different type, or if no window was previously open, the menu bar and all menus to be displayed are rebuilt from scratch. Preferably this takes place quite rapidly so that the user perceives no delay in presentation of the new menus. 
     To rebuild the menu bar and menus (steps AD, AE, and AF), application program 260 determines what packages and packets are active and gathers the commands from the command tables of these packages and packets (step AD). It then constructs a complete menu hierarchy including a menu bar, menus, and submenus, if any, in which the commands from the various command tables are organized according to their display groups (step AE). The resulting menu bar is displayed in visual display 221, and the menus and submenus therein become available for selection by the user with selector device 222 (step AF). 
     Upon the user&#39;s selection of a displayed menu item from the newly constructed menu, shell 300 executes the corresponding command. For example, shell 300 can send a message to the package object that supplied the command requesting that the package object carry out a member function or other procedure that implements the command. 
     The step of determining the contents of the menu bar and menus (step AD) is shown in greater detail in the flowchart of FIG. 6. For each registered package (step BA), shell 300 considers in turn each of the commands in the package&#39;s command table (step BB), and assigns each of these package commands to a display group according to the command&#39;s group identifier (step BC). Shell 300 then checks to determine whether any windows are active (step BD). If there is an active window, shell 300 checks to determine the active packet for the active window, that is, the packet pointed to by the template object for the active window (step BE). Shell 300 considers in turn each of the commands in the active packet&#39;s command table (step BF), and assigns each of these packet commands to a display group according to the command&#39;s group identifier (step BG). 
     The step of organizing the contents of the menu bar and menus (step AE) is shown in greater detail in the flowchart of FIG. 7. In the specific embodiment, shell 300 uses an organizational plan that is predetermined and built into the design of application program 260. The organizational plan provides a guideline as to which menus are to be included in the menu bar and in what order, and which groups are to be included in particular menus and in what order. It is readily extensible to new groups and menus introduced by add-on software components. For example, the add-on components can specify where a new group or menu is to appear in relation to an existing group or menu. 
     Shell 300 uses the plan to create a data structure that represents the menu hierarchy to be displayed and that can be provided as input to the menu display routines of step AF. To build the data structure, shell 300 considers in turn each possible menu in the menu bar (step CA). Within the menu currently under consideration, shell 300 considers in turn each group identifier that could possibly appear in the menu (step CB). If, according to the menu contents as previously determined in step AD, no commands are assigned to a display group for this group identifier (step CC), then the group is suppressed from the menu (step CD). Otherwise, the group is included in the menu as a display group that contains the previously determined commands (step CE). Processing continues until all possible groups of the menu have been considered. If the resulting menu is empty because all of its groups were suppressed (step CF), then the entire menu is suppressed (step CG). Otherwise the menu is included in the menu bar (step CH). Processing continues until all possible menus have been considered. 
     In a variation on the foregoing method steps, a package can provide a group of placeholder commands. A placeholder command is one that is not necessarily bound to executable code, but which can optionally be bound according to the particular active window type and its corresponding packet. If the commands of the group are indeed bound, then they are included in the menu in step CE as previously described. However, if the commands are not bound, they are still included in the menu, rather than being suppressed in step CD. Shell 300 indicates that the placeholder commands are unavailable by causing them to appear &#34;grayed out&#34; in the display. An advantage of this variation is that very common commands, such as certain basic editing commands like cut, copy, paste, and undo, can be made always to appear in the menus by including them as placeholders in the shell package. For such basic commands, it is often less confusing for users if they are always displayed even if unavailable, rather than appearing and disappearing as the more specialized packet commands do. 
     The foregoing specific embodiments represent just some of the ways of practicing the present invention. Many other embodiments are possible within the spirit of the invention. Accordingly, the scope of the invention is not limited to the foregoing specification, but instead is given by the appended claims along with their full range of equivalents.