Task-sensitive methods and systems for displaying command sets

Information

  • Patent Grant
  • 9507610
  • Patent Number
    9,507,610
  • Date Filed
    Thursday, March 11, 2010
    14 years ago
  • Date Issued
    Tuesday, November 29, 2016
    8 years ago
Abstract
Methods and systems present commands to a user within a software application program by determining the user's context within the application program and automatically presenting in a user interface commands that pertain to the user's current context. When the user's context changes, the context-sensitive commands are automatically removed from the user interface. In one implementation context blocks and context panes are employed to present the commands.
Description
TECHNICAL FIELD

This invention relates generally to methods and systems that expose commands in software application programs.


BACKGROUND

Typically, application programs contain command sets that include individual commands that can be used by a user when working in a particular application program. These commands are specific to the purpose of the application program. For example, a word processing application program will typically include a command set that can be used to manipulate the text and/or format of a document. These command sets, however, are not always as easy to use as one would like. This situation can be complicated when a user is not familiar with the command set of an application program that they are currently using.


Current problems with application program command sets include that they can be difficult to use or browse because of the large number of commands that can be included in a command set, and that they often times can temporarily obscure a document when a user attempts to use them. In addition, command sets are typically presented in a manner that is not related to the tasks in which the user might be engaged.


With respect to the browsing difficulty of command sets, consider the following. Command sets can typically contain many different commands that are available for use. Since, in a typical user display, there is only a limited amount of space to present information without undesirably obscuring a work area, it logically follows that not all commands can be displayed at all times for the user. To address this problem, solutions have included providing a static tool bar that can expose some commands and contain a menu structure that can be browsed by the user. Consider, for example, FIG. 1 which shows an exemplary user display 10 that includes a tool bar 12 that includes a menu structure 14 and a collection of commands 16. The menu structure 14 includes individual entries, e.g. “File”, “Edit”, “View”, “Insert”, etc. Each of these entries is associated with a drop down menu that contains a collection of individual commands that are logically related to their entry. For example, for the “File” entry, individual drop down menu-accessible commands include “new”, “open”, “close”, “print”, “print preview” and additional commands that are accessible via an “options” selection that further extends the drop down menu to display the additional commands. Each of the top line menu entries in the menu structure 14 can be associated with a drop down menu. Also, some of the commands are gathered into broad groups (such as the Font Formatting dialog) and the user needs to know what Font Formatting is, in order to find the commands in this group. Needless to say, the number of available commands can often times be quite numerous so that browsing through them is not an easy task. In addition, an inherent inefficiency with this approach is that many if not most of the displayed commands will have little or nothing to do with what the user is currently looking for. Often, in fact, many of the commands are grayed out and disabled because they are not relevant to the current task. Regardless, they are exposed to the full subset of commands.


Consider how this problem is exacerbated when a user is only moderately familiar or not familiar at all with an application program. Having to figure out and navigate through an extensive set of commands that are not explained (except for perhaps a “Help” dialog) can make the user's experience difficult and time consuming. In addition, many application programs are physically or logically tapped out as far as including additional commands. Specifically, in many application programs there are simply so many commands in the command set that including more commands would require the menu structure to include more “options” buttons that, in turn, would present more and more commands, thus requiring a user to physically navigate through more commands.


Additionally, many application programs display their command sets in a manner that can obscure the work area for the user. For example, consider FIG. 2 which shows a “Font” dialog box 18 that is presented in the middle of the user's work area. To get to this dialog box, the user had to click on the “Format” menu entry in menu structure 14, and then select the “Font” command within the drop down menu that was presented. As a result the illustrated dialog box 18 is displayed. Although this is helpful for enabling a user to see an extensive list of commands, it is not optimal for a couple of different reasons. First, the user's document is partially obscured by the dialog box 18. This is undesirable because the user may wish to keep the work area in view. In addition, in order to work within the dialog box, the user has to quit working within their document. Thus, the dialog box is referred to as having “mode” or being “modal”, meaning that a user must enter into a particular mode that renders them unable to work within their document in order to work within the dialog box. Second, and perhaps more important, the user's command selection is not implemented immediately, and, even if it were, the document is obscured by the dialog box. Specifically, in order to have a command implemented, e.g. a “strikethrough” command, the user must select text in the document that they are working on and pull up the dialog box. Only after they click on the “strikethrough” box and on the “OK” box is the command implemented (this is somewhat related to the mode aspect mentioned above). In addition, if a user desires to implement a command on multiple different portions of text, they must separately select each text portion and apply the command for each selected portion of text. That is, for each portion of text, they must separately and individually pull up the appropriate dialog box to apply the command. This is not optimal.


Consider also the collection of commands 16. Many application programs provide such a feature where frequently used commands are displayed in a manner in which they can be quickly clicked on by a user and applied within the context of the application program. These commands are often presented as so-called “modeless” commands (as contrasted with “modal” commands) because they can be used while still working within a document. That is, in the illustrated example, individual commands from the collection include “bold”, “italics”, and “underline” commands. Yet, even though the goal of displaying these frequently-used commands is directed to improving user efficiency, this attempt falls short of the mark for the following reason. Even though the commands that are displayed might be considered as those that are most frequently used, their use occurrence may constitute only a very small portion of a user session, if at all. To this extent, having the commands displayed when they are not being used is wasteful in that valuable display real estate is consumed. This is a direct manifestation of the fact that the displayed commands have nothing to do with the specific context of the user. Yes—the user might in the course of their computing session have the need to use a particular command, but until that command is specifically needed by the user, its display bears no logical relation to the user's computing context.


Accordingly, this invention arose out of concerns associated with providing improved methods and systems for presenting command sets to users. Specifically, the invention arose out of concerns associated with providing methods and systems of presenting commands in a task-sensitive manner, which assist in using physical screen space in a more efficient manner.


SUMMARY

Methods and systems present commands to a user within a software application program by determining the user's context within the application program and automatically presenting in a user interface context-sensitive commands that pertain to the user's current context. When the user's context changes, the context-sensitive commands are automatically added to the user interface or removed from the user interface so that space can be freed up for additional, more relevant commands.


In one implementation context blocks and context panes are employed to present the commands. The context blocks and panes are displayed in a context UI container that is located adjacent a document area in a user interface. When displayed, the context blocks and context panes do not obscure a user's document.


The context blocks and panes each comprise a title bar area that labels the block or pane, and a controls area that presents commands to the user. The commands within the controls area can be logically grouped. The context blocks contain primary commands that pertain to a user's present context. More than one context block can be displayed in the context UI container. Context panes are associated with a context block and are not automatically displayed. Rather, a user can select one or more context panes from a particular context block, keyboard shortcut, or from other tool bars. The context panes contain additional commands that are logically associated with the commands of their associated context block. When displayed, the context panes replace the context blocks in the context UI container and must be closed by the user.


In one embodiment, a user's context is determined by monitoring the user's action within a particular application program. A series of expressions are provided and describe conditions that are associated with aspects of a user's interaction with the application program. Each expression is associated with a context block. As the user's context changes, at least portions of the expressions are evaluated to determine whether its associated context block should be displayed. In one optimization, each expression is represented as a tree structure with a root node and multiple nodes associated with the root node. Each of the nodes has a value associated with it that can change as a user's context changes. When a user's context changes, individual node values are evaluated for a change. If a node value changes, then its parent node is notified with the change. The parent node then evaluates its value to ascertain whether it has changed responsive to its child's value change. This process continues whenever a node value changes. If the root node value changes, then the context block with which it is associated is either automatically displayed or removed.


In one particular advantageous implementation, a single application program is provided with a single navigable window. The application program comprises multiple different functionalities to which the single navigable window can be navigated. The different functionalities enable a user to accomplish different tasks. For example, in one implementation, a user might read electronic mail, compose an electronic mail message, or navigate to sites on the web. As the user navigates between functionalities and as their context changes within particular functionalities, context blocks are automatically presented and/or removed so that they can have useful commands at hand to use. The functionalities of the single application program are desirably extensible, e.g. by incorporating third party functionalities that can be delivered over the web, so that the application can incorporate many different types of functionalities. Each of the incorporated functionalities can come with its own collection of automatically displayable context blocks.





BRIEF DESCRIPTION OF THE DRAWINGS


FIG. 1 is an illustration of an exemplary user display in accordance with the prior art.



FIG. 2 is an illustration of an exemplary user display that includes a dialog box in accordance with the prior art.



FIG. 3 is a high level block diagram of an exemplary computer system that can be utilized to implement various inventive embodiments.



FIG. 4 is a flow diagram that describes steps in a method in accordance with one described embodiment.



FIG. 5 is a diagram of an exemplary user interface in accordance with one described embodiment.



FIG. 6 is a diagram of an exemplary context block in accordance with one described embodiment.



FIG. 7 is a diagram of an exemplary context pane in accordance with one described embodiment.



FIG. 8 is a flow diagram that describes steps in a method in accordance with one described embodiment.



FIG. 9 is a diagram of a table in accordance with one described embodiment.



FIG. 10 is a diagram of a tree structure in accordance with one described embodiment.



FIG. 11 is a flow diagram that describes steps in a method in accordance with one described embodiment.



FIG. 12 is a diagram of a user interface in accordance with one described embodiment.



FIG. 13 is a diagram of a user interface in accordance with one described embodiment that illustrates an exemplary functionality.



FIG. 14 is a diagram of a user interface in accordance with one described embodiment that illustrates an exemplary functionality.



FIG. 15 is a flow diagram that describes steps in a method in accordance with one described embodiment.





DETAILED DESCRIPTION
Overview

The methods and systems described below present commands to a user within a software application program by determining the user's context within the application program and automatically presenting, in a user interface, context-sensitive commands that pertain to the user's current context. When the user's context changes, the context-sensitive commands can be automatically removed from the user interface.


Exemplary Computer System



FIG. 3 shows an exemplary computer system that can be utilized to implement the embodiment described herein. Computer 130 includes one or more processors or processing units 132, a system memory 134, and a bus 136 that couples various system components including the system memory 134 to processors 132. The bus 136 represents one or more of any of several types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, and a processor or local bus using any of a variety of bus architectures. The system memory 134 includes read only memory (ROM) 138 and random access memory (RAM) 140. A basic input/output system (BIOS) 142, containing the basic routines that help to transfer information between elements within computer 130, such as during start-up, is stored in ROM 138.


Computer 130 further includes a hard disk drive 144 for reading from and writing to a hard disk (not shown), a magnetic disk drive 146 for reading from and writing to a removable magnetic disk 148, and an optical disk drive 150 for reading from or writing to a removable optical disk 152 such as a CD ROM or other optical media. The hard disk drive 144, magnetic disk drive 146, and optical disk drive 150 are connected to the bus 136 by an SCSI interface 154 or some other appropriate interface. The drives and their associated computer-readable media provide nonvolatile storage of computer-readable instructions, data structures, program modules and other data for computer 130. Although the exemplary environment described herein employs a hard disk, a removable magnetic disk 148 and a removable optical disk 152, it should be appreciated by those skilled in the art that other types of computer-readable media which can store data that is accessible by a computer, such as magnetic cassettes, flash memory cards, digital video disks, random access memories (RAMs), read only memories (ROMs), and the like, may also be used in the exemplary operating environment.


A number of program modules may be stored on the hard disk 144, magnetic disk 148, optical disk 152, ROM 138, or RAM 140, including an operating system 158, one or more application programs 160, other program modules 162, and program data 164. A user may enter commands and information into computer 130 through input devices such as a keyboard 166 and a pointing device 168. Other input devices (not shown) may include a microphone, joystick, game pad, satellite dish, scanner, or the like. These and other input devices are connected to the processing unit 132 through an interface 170 that is coupled to the bus 136. A monitor 172 or other type of display device is also connected to the bus 136 via an interface, such as a video adapter 174. In addition to the monitor, personal computers typically include other peripheral output devices (not shown) such as speakers and printers.


Computer 130 commonly operates in a networked environment using logical connections to one or more remote computers, such as a remote computer 176. The remote computer 176 may be another personal computer, a server, a router, a network PC, a peer device or other common network node, and typically includes many or all of the elements described above relative to computer 130, although only a memory storage device 178 has been illustrated in FIG. 3. The logical connections depicted in FIG. 3 include a local area network (LAN) 180 and a wide area network (WAN) 182. Such networking environments are commonplace in offices, enterprise-wide computer networks, intranets, and the Internet.


When used in a LAN networking environment, computer 130 is connected to the local network 180 through a network interface or adapter 184. When used in a WAN networking environment, computer 130 typically includes a modem 186 or other means for establishing communications over the wide area network 182, such as the Internet. The modem 186, which may be internal or external, is connected to the bus 136 via a serial port interface 156. In a networked environment, program modules depicted relative to the personal computer 130, or portions thereof, may be stored in the remote memory storage device. It will be appreciated that the network connections shown are exemplary and other means of establishing a communications link between the computers may be used.


Generally, the data processors of computer 130 are programmed by means of instructions stored at different times in the various computer-readable storage media of the computer. Programs and operating systems are typically distributed, for example, on floppy disks or CD-ROMs. From there, they are installed or loaded into the secondary memory of a computer. At execution, they are loaded at least partially into the computer's primary electronic memory. The invention described herein includes these and other various types of computer-readable storage media when such media contain instructions or programs for implementing the steps described below in conjunction with a microprocessor or other data processor. The invention also includes the computer itself when programmed according to the methods and techniques described below.


For purposes of illustration, programs and other executable program components such as the operating system are illustrated herein as discrete blocks, although it is recognized that such programs and components reside at various times in different storage components of the computer, and are executed by the data processor(s) of the computer.


Context Sensitive Commands


In the described embodiment, command sets that include one or more individual commands are automatically presented to a user depending on the user's context. Specifically, depending on the type of action the user has taken, commands that are specific to that action will appear automatically thus obviating the need for the user to hunt through a menu structure to find commands of interest. This improves upon past approaches, which always presented top level commands, even when they were not needed by the user. This is also advantageous from the standpoint of assisting users who are unfamiliar with a particular software application. In the past, these users would have to hunt through an unfamiliar menu structure to find commands that may or may not be pertinent to an action that the user desired to take. Users also had to know the names of the functionality in order to find the tools (e.g. the user needed to know what a “table” was to know that there are tools for tables in an appropriate menu). In the present case, contextually-appropriate commands are automatically presented and removed in an interface so that a user need not worry about finding appropriate commands. That is, the described embodiment maintains an invariant that contextually applicable commands are visible and other non-applicable commands are hidden from the user.


As an example, consider the following: A user is working in a word processing application and is in the process of preparing a document. The user selects, with their cursor, a portion of the text that they believe to be spelled incorrectly. Instead of having to go to a tool bar menu at the top of the document and pull down one or more other menus to find the spell checking feature, a spell checking context block automatically appears in an interface adjacent the document. The user can then correct the incorrectly spelled word using the spell checking context block. Once the word is corrected and the user's context is not longer associated with an incorrectly spelled word, the spell checking context block automatically disappears. As the user's context changes within their document, so too do the sets of automatically presented and removed commands. Consider further that the user has included a table in their document and that they wish to manipulate the table or its contents with table specific commands. In the past, the user would typically have to pull down a table menu entry and then select from one or more commands, some of which might present a dialog box that would obscure the user's document. In the present example, a user would simply select the table by placing the cursor inside of the table to have table-specific commands that are contextually accurate and appropriate automatically displayed in a dedicated space. Thus, a user need not hunt through a large menu structure to find commands that are appropriate for use. Here, contextually proper commands are automatically presented for the user. As the user's context changes, so too do the displayed command sets.



FIG. 4 is a flow diagram that describes steps in a method in accordance with the described embodiment. The illustrated method can be implemented in any suitable hardware, software, firmware, or combination thereof. In the present example, the method is implement in software that is executing on a user's computer.


At step 400 the method starts and step 402 then determines whether the user's current context has changed. The user's current context relates to various tasks that the user is attempting to accomplish. Context can be determined from almost any detectable state in a program. In the above example, two exemplary tasks included correcting an incorrectly-spelled word and manipulating the contents of a table. The context associated with each of these tasks can be determined from such things as the type of document a user is working in (i.e. which of the multiple different functionalities the user is accessing), the state that the document is currently in, for example, whether the document is in read-only (or browse) mode or is editable, the cursor's current location within a document (i.e. is the cursor located within a table, spreadsheet, etc. within a document), or a particular selection that might be made within the document (i.e. selection of text, a table, etc.). Other examples of things from which context can be determined include, without limitation, whether or not a certain extension has been installed, today's date is after the due date of a particular document, the document contains comments that need to be addressed, the subject line of an email message is missing, the document contains misspelled words, and the like. Any suitable way can be used to ascertain whether a user's context has changed.


If step 402 ascertains that a user's current context has changed, step 404 makes a command set change as a function of the user's context. Specifically, command sets can be added and/or removed automatically based upon the user's context.


Context Container, Context Blocks, Context Panes



FIG. 5 shows an exemplary user interface (UI) display 500 that constitutes but one implementation of a system that automatically presents context-sensitive commands to a user. Other implementations can, of course, be used without departing from the claimed subject matter.


In the illustrated example, display 500 includes a context UI container 502 and a document area 504 adjacent the context UT container. The context UI container is a narrow, vertically aligned user interface space that can be used to expose commands in a software application. The context UI container 502 is designed, in a particular implementation, to work with applications whose functionalities are primarily oriented around interacting with documents. The context UI container 502 does not preclude other UT constructs in the application, and indeed this design assumes some additional UI such as a toolbar with commands on it such as would be displayed in global toolbar area 506. Such commands can include, without limitation, an address well for a web browser, a “Create New” button for creating a new document type, or a button that brings up “search” or “help”.


The context UI container 502 is designed, in this example, to lay to the left of the document area 504 in the application. It could, however, be situated in any suitable location. The context UI container 502 contains two types of objects that are utilized to display context-sensitive commands to a user. A first type of object is a context block, exemplary ones of which are shown at 508a-c. Context blocks are essentially context-based palettes with command “shortcuts”, giving the user top-level tools for the current user contexts. In the present example, there are context blocks for editing commands (block 508a), text commands (block 508b), and table commands (block 508c). The assumption in this example is that a user has a table selected, and thus all three of these blocks are relevant. A second type of object is a context pane. Context panes provide access to secondary tools for a context and are used to complete a specific task. The secondary tools are generally more specific or more advanced functionalities relating to the context block with which the pane is associated.


In the described embodiment, context blocks automatically appear and disappear based on the user's context and have two primary forms when visible: expanded and collapsed. Context blocks are expanded by default and collapse only by manual action from the user. Context panes take up the entire context UI container 502 and focus the user on completing a task before they can continue with other commands in the application.


Context UI Container


The context UI container 502 is a collapsible vertical area that contains context blocks and context panes. The context UI container 502 can toggle between expanded and collapsed states as indicated above. When collapsed, the container is not visible at all. When expanded, the context UI container 502 is typically of a fixed size, e.g. 184 pixels wide, though it can grow wider to accommodate wider context blocks or context panes.


Changing the Context UI Container Expansion State


In the described embodiment, the user can manually change the expansion state of the context UI container by clicking on a “Tools” button on a global toolbar in an application. This button can toggle container's expansion state. When the container is expanded, the button is visualized as toggled “on”. When the container is collapsed, the button is visualized as toggled “off”.


In addition, the context UI container 502 can be expanded programmatically. For example, if the user clicks on a command elsewhere in the application that requires that the container to be open, then the context UI container automatically opens. When the context UI container opens, the left border of the document being viewed by the application shifts over and the document's total width is decreased by the size of the context UI container 502.


Population of the Context UI Container


The context UI container 502 can be populated with both context blocks or context panes. In addition, the context UI container can be populated with a help pane. The help pane looks like a context pane, but appears next to either a context pane or the context blocks; it is approximately the same size and shape as a context pane, is launched programmatically, and is associated with a context block or context pane. Context blocks appear in the context UI container by default. Exemplary context blocks 508a-c are shown in FIG. 5. Context block 508a contains commands that are associated with editing a document; context block 508b contains commands that are associated with manipulating text within a document; and context block 508c contains commands blocks that are associated with operating on a table. As is evident, more than one context block can be displayed at one time.


Context panes, on the other hand, are configured in this example so that they can only be viewed one at a time. And, while context blocks are displayed automatically depending on the user's context, context panes are displayed, in this example, when they are selected by a user. Context panes are task oriented and are dismissed by a user when the task is completed. Although the user dismisses them, context panes are modeless in that the user can continue acting on the document while the pane is open. Context panes can also be used to communicate an alert to a user. For example, if the user is trying to publish a document, but cannot do so because of a merge conflict, a merge conflict user interface may be provided through a context pane.


To determine which context blocks to automatically display, one implementation uses an expression-based system that ascertains the user's context and then sees to it that the proper context blocks are displayed. An exemplary expression-based system is described in more detail below in a section entitled “Expression Evaluation”.


Sizing and Overflow Issues


The context UI container 502 is of fixed size vertically, but the number and size of context blocks is not limited. Therefore, there may be situations in which an application does not have enough room to display all of the current context blocks. This is referred to as an “overflow case”. The overflow case occurs when there is not enough vertical room in the context UI container 502 to display all of the context blocks. One solution of the overflow case, in this particular example, is as follows: When an overflow occurs, the application can display a small scroll button at the bottom of the context block container. This button serves as an indicator that there are one or more context blocks scrolled out of the container. Clicking on the button once scrolls down by a predetermined number of pixels, e.g. 44 pixels, or to the end of the last context block, whichever is less. This, in turn, causes part or all of some context block to scroll off of the top of the context UI container 502. Accordingly, the context UI container 502 will also show a scroll button at its top when this occurs. Clicking on this top button will scroll up by a predetermined number of pixels, e.g. 44 pixels, or to the top of the first context block, whichever is less.


If there are no more context blocks or parts of context blocks scrolled out of the container in a certain direction (either up or down), then the corresponding respective scroll button will disappear. Since the scroll buttons take up space in the container 502, the calculation for when the scroll buttons should disappear takes into account the additional room that would appear if the button were not there.


Application Window Resizing Issues and the Context UI Container


The context UI container 502 is defined in the illustrated example to have a standard size horizontally and is sized to fit the application window vertically. The context UI container 502 responds to window/resolution resizing issues as follows: Vertically, the container resizes to fit into the space left over in the application frame from any other UI areas at its top or bottom. If the vertical space is not enough to hold all context blocks, then the overflow mechanism described above is invoked. Horizontally, the context UI container does not resize except to accommodate larger context blocks or context panes. Other than this case, the container only expands or collapses completely. The container does not resize horizontally due to the application window resizing. If the user resizes the window horizontally so that the window is narrower than the context UI container, the container will be clipped.


Context Blocks


In the illustrated example, context blocks are rectangular control containers that expose top-level commands for a given context. A context is anything that can be described by an “expression” in the application. Examples of expressions are given below. Typical contexts include: the type of document being currently viewed, the state that the document is currently in, for example, whether the document is in read-only (or browse) mode or is editable, and any objects that are currently selected in the document. Other contexts were listed above. Context blocks appear and disappear based on whether an expression that describes their context is true or false, respectively. This is discussed in more detail in the “Expression Evaluation” section below.



FIG. 6 shows exemplary context block 508b apart from the context UI container 502 of FIG. 5. Context block 508b displays text formatting commands. Each block comprises a title bar area 600 and a controls area 602.


The title bar area 600 provides a location to label the entire context block, provides expand/collapse functionality, and also contains a button 604 that opens up the context block menu. The user can click anywhere on the title bar outside of the menu button to toggle the expansion state of the context block. On the right-hand side of the title bar area 600, button 604 can be clicked to bring up a menu that can contain links to context panes, as well as commands that execute immediately without invoking a context pane. The menu then closes after the user invokes a command from it.


The controls area 602 is the main area of the context block and exposes commands to the user. In the illustrated example, the contras area allows any arbitrary HTML code to be filled into it, so commands can be exposed in any way that HTML supports. Of course, other manners of defining commands other than HTML can be used. Context blocks are advantageously “modeless” meaning that any action taken by the user is immediately applied to the user's selection in the document. This is advantageous over past methods because a user can experiment with different selections that are available through the context block and see their choices immediately effectuated in their document. In some cases, this eliminates the need for a costly (in terms of both space and time) “preview pane.” This does not, however, mean that the context blocks must always be modeless. For example, a context block for inserting a table could be provided where the user sets the number of rows and columns before pressing an “insert” button.


One feature of context blocks that prevents them from being inadvertently displayed is that a selection that is made by the user in a particular document (e.g. with their cursor) must contain only content that is pertinent to a particular set of displayable commands. If the user's selection includes an object but also additional content around the object, then the context block for that object will not be displayed. So for example, in order to have a table formatting context block visible, the user's selection would need to contain only the table, or the user's insertion point (i.e. cursor) would have to be in the table.


Context Panes


In the described embodiment, context panes, like context blocks, are also rectangular controls containers. One primary difference in this implementation is that context panes are typically larger than context blocks and only one context pane can be viewed at one time. It will be appreciated, however, that this is simply a choice for this particular implementation.


Context panes are used to expose secondary commands as well as task-based UIs, such as stepping through document publishing merge conflicts, in the application. Context panes can also be used to display various error messages related to the current document, such as when there are versioning problems when publishing a document and the user needs to make a decision about which version to keep. To maintain consistency, commands that are contained in context blocks are also repeated in their associated context panes.


Context panes can be accessed from the menus of their associated context blocks, through keyboard shortcuts, or from other UIs in the application, such as from a global toolbar. In the described embodiment, when a context pane: is invoked, the entire content of the context UI container 502 (FIG. 5) is replaced with the context pane. Advantageously, context panes are typically modeless with respect to the document. This means that the user can continue to interact with their document while a context pane is open. For example, if a user wishes to use a strikethrough command repeatedly in a portion of text, the user can do this time after time by simply selecting the appropriate text and clicking on a strikethrough box in the context pane. In the past, a user would have had to traverse a menu structure for each separate invocation of the strikethrough command.



FIG. 7 shows an exemplary context pane 700 that includes secondary format font commands. Context pane 700 includes a title bar 702 and a controls area 704 that contains individual commands. A context pane looks similar to a context block that fills up the entire context UI container. There are, however, a few differences in the described example. Here, context panes are not collapsible. That is, they are displayed in their entirety for a user during the course of a user's interaction with them. In addition, context panes have a standard way to be closed, e.g. a “Close” button or the equivalent at the bottom of the panel can be clicked on by the user.


In addition, whereas a user does not have to request a context block in order for it to appear, a user does, in most cases, request a context pane for it to appear. That is, context panes are not automatically displayed as a result of an expression evaluation. Rather, they are displayed based on some event or function call. There can be, however, some context panes that are expression based and are not end-user initiated (e.g. an error context pane that informs a user of an error condition). In addition, in this example, the user must also physically dismiss a context pane when it is no longer needed. That is, the context pane will not automatically disappear. Thus, the user is free to move their selection around the document while interacting with a context pane. If the context pane's functionality is context sensitive (for instance if it contains tools that only apply to a table within the document), then the controls in the context pane become disabled if they are out of context. The context pane typically does not disappear or collapse, in many instances, when it goes out of context.


User Assistance in Context Panes


Context panes are used to provide access to the full range of commands in an application. In this way, context panes complement context blocks. There may be instances where a user may not be familiar with all of the commands that are displayed in the context pane. Accordingly, in the described embodiment, the context panes provide context-sensitive access to help for their commands via a pop-out help pane. This help pane appears to the right of the context pane and causes the context UI container to grow horizontally. This pushes the user's document somewhat to the right. The help pane provides quick, contextual help on how to use the controls on the pane or context block. In the FIG. 7 example, the help pane is accessed by a help icon 706 (“?”) on the right side of the context pane's title bar 702.


This is much different from current help features in most current application programs. Presently in many applications, a user will have to either search through a help menu to find particular topics of interest, or they may have to enter a search query through a dialog box that typically pulls up multiple topics that relate to their search. They must then navigate through the different multiple topics to find the one in which they are interested. “Help” in these instances, is typically delivered as a separate application, overlaying, obscuring, or displaying outside of the user's application window. There is no awareness of the context of the user's work. Here, however, the described approach is somewhat different. First, the help function is contextually related to the current context pane. Thus, the user only receives help information that is pertinent to their current context. Additionally, because the help information is specifically tailored to the user's current context, and because there is a dedicated space for the context blocks and context panes, more thorough help information can be displayed in the container UI than would normally be possible in present systems. In addition, the help feature is rendered in a “modeless” fashion so that the user can continue working in their document while the help menu is displayed. Further, it is worth noting that the contextual help provided by the present example is tailored not only to the user's context, but to the tasks and troubleshooting steps that are most likely to be needed by the user in that context. For instance, if the user is correcting a misspelled word in the document by using a context pane designed for that purpose, the help pane associated with that context pane may contain information about how to correct the misspelled word with one of the provided choices, how to add the word in question to the system dictionary, and how to replace the word in question with a different word altogether. Accordingly, the user is provided with assistance in a much more efficient and informative way.


Stackability


Although only one context pane can be viewed at a time, it is possible for multiple panes to be stored in a stack. In this case, closing one context pane reveals the next context pane in the stack. There are a number of cases where context panes can get stacked on top of each other. The following constitute some exemplary cases:

    • A context pane is open and then an error context pane is displayed
    • A context pane is open and the user then opens up another context pane from a button on the global toolbar.
    • A context pane has a button that opens another context pane.
    • A context pane is open and the user hits an accelerator key that opens up another context pane


In each case above, the latter context pane opened goes to the top of the stack, while the previous context pane goes underneath it on the stack.


In addition, each document can have its own stack of context panes. If the user navigates away from a document and back to it, the document's stack of context panes persists and is redisplayed (though it is possible for members of a stack to be aged out).


Expression Evaluation


As described above, context blocks are automatically presented to the user depending on the user's current context. In the described embodiment, an expression-based method is used to ascertain which contexts blocks to present and when to present them.


One way of implementing an expression-based method is as follows. Each context block is associated with an expression that can evaluate to a predetermined value. Each expression is essentially a defined condition that describes some aspect of a user's interaction with a document. As a user interacts with a document, the expressions, or at least portions of the expressions, are evaluated to ascertain whether they evaluate to the predetermined value. When one or more of the expressions evaluates to the predetermined value, the context block that is associated with that expression is displayed for the user.



FIG. 8 is a flow diagram that describes steps in a method in accordance with the described embodiment. The described method can be implemented in any suitable hardware, software, firmware or combination thereof. In the illustrated example, the method is implemented in software.


Step 800 associates a context-sensitive UI with a visibility expression. An exemplary context-sensitive UI is a context block as described above. In the described example, a table is used for the association and includes two columns, one of which is associated with a particular context block, the other of which is associated with the context-block's visibility expression. FIG. 9 shows an exemplary table 900 with columns 902 and 904. Column 902 contains entries associated with each context block, while column 904 contains so-called visibility expressions that are associated with each of the context blocks. In the illustrated example, two exemplary context blocks are shown in column 902 with their corresponding visibility expressions in column 904. For example, for the “Font Format” context block the visibility expression is “em & ts”. The visibility expression is a Boolean expression that describes a condition in which the application is in “edit mode” (i.e. “em”) with a portion of text having been selected (i.e. “ts”). For the “Table Commands” context block, the visibility expression is “em & ip=t+tbs” which translates to a condition in which the application is in edit mode and an insertion point lies within a table (i.e. “ip=t”), or a table has been selected (i.e. “tbs”).


Step 802 determines whether a visibility expression has changed in value because of a user's action. A user's action can typically change their context. A user's context could be based upon any type of variable such as user selection, insertion point, time of day, user's name, to name just a few. If the value of a visibility expression has changed, then step 804 removes visible UIs (i.e. context blocks) that are not applicable to the current context. Step 806 displays UIs that previously were not visible but are applicable to the user's current context.


The visibility expressions can be evaluated in any suitable fashion. For example, each time the user takes an action within a document, all of the expressions in table 900 can be evaluated. A more desirable approach is as follows:


Each of the expressions is represented in a data structure known as a “tree”. FIG. 10 shows exemplary tree structures for the two illustrated visibility expressions of FIG. 9. Here, the top node of each tree comprises an operation. In the present case, the operation happens to be an “AND” operation for each expression. Each top node has one or more children nodes that can either be operands or operations. In the case of the font format context block expression, each of the children nodes 1002, 1004 is an operand (i.e. “edit mode” and “text selected” respectively). For the table commands context block expression, child node 1008 is an operand (i.e. “edit mode”) and child node 1010 is an operation (i.e. an “OR” operation). In turn, node 1010 has two operand nodes 1012, 1014 (i.e. “insertion point=table”, and “table selected” respectively).


Each tree structure can evaluate to either “TRUE” or “FALSE”. If the tree structure evaluates to “TRUE”, then its corresponding context block is displayed. If the tree structure evaluates to “FALSE”, or remains in a false state after some of the nodes have been evaluated, the context block is not displayed. The expression value of a tree, however, cannot change unless the value of its operands changes. For example, consider the font format tree structure. Assume that its current value is “FALSE” (indicated by the “F” adjacent node 1000). Assume also that its edit mode operand 1002 has a value of “TRUE” and its text selected operand 1004 has a value of “FALSE”. In this case, the user is currently in edit mode but has not selected any text. In order for this tree structure to change in value, the value of its text selected operand 1004 must change from “FALSE” to “TRUE”. This will only happen when a user has selected some text with their cursor. In accordance with the described embodiment, when the value of a child node changes, it generates a notification to its parent node that its value has changed. The parent node expression is then re-evaluated to ascertain whether its value has changed. If its value has changed, then if it has a parent node, it generates a notification that is sent to its parent node. This continues until either a parent node's expression does not change in value, or the top parent node's expression changes in value. If the latter is the case, a corresponding context block is either displayed or removed. If the former is the case, then a current state is maintained (i.e. if the context block was previously displayed, then it is still displayed; and if the context block was not previously displayed, then it is not displayed). Thus, in many cases, only a portion of the visibility expression will need to be evaluated.


As another example, consider the visibility expression for the table commands context block. Assume that the current state of the expression is as indicated in the table below:
















Node
Value









AND
FALSE



Em
TRUE



OR
FALSE



ip=t
FALSE



tab sel
FALSE










In this example, the table commands context block is not being displayed because the top node 1006 has evaluated to “FALSE”. The user is in edit mode and neither the insertion point is in a table nor has a table been selected. Assume now that the user selects a table with their cursor. In this case, the value associated with node 1014 is changed to “TRUE”. Because this node changed in value, it generates a notification and sends the notification to its parent node 1010. Node 1010 is an OR expression whose value now re-evaluates to “TRUE”. Because this node has changed in value, it generates a notification and sends the notification to its parent node 1006. Node 1006 is an AND expression that now evaluates to “TRUE”. Since this is the top node and it now evaluates to “TRUE”, the context block with which it is associated is now displayed for the user. This logically follows from the user's actions. That is, in order to change the value of node 1014, the user had to select a table. When the user selects the table, the table commands context block should automatically be displayed for the user. If and when the user “unselects” the table, the value associated with node 1014 will change and this change will be propagated up the tree in the form of notifications until the top node 1006 is re-evaluated to “FALSE” and the context block is removed.



FIG. 11 is a flow diagram that describes steps in an exemplary expression-evaluation method in accordance with the above-described embodiment. The described method can be implemented in any suitable hardware, software, firmware, or combination thereof. In the illustrated example, the method is implemented in software.


Step 1100 represents each expression as a tree structure having multiple nodes. Exemplary expressions and tree structures are shown and described in connection with FIGS. 9 and 10. Step 1102 gets the first tree or tree structure and step 1104 gets the first leaf node on the tree. In the FIG. 10 example, exemplary leaf nodes are shown at 1002, 1004 for the font format tree, and 1008, 1012, and 1014 for the table commands tree. Step 1106 evaluates the node. Step 1108 determines whether the node value has changed. If the node value has not changed, then step 1110 determines whether there are more nodes on the tree, and if so, step 1112 gets the next node and returns to step 1106. If there are no more nodes on the tree, step 1114 determines whether there are more trees. If there are additional trees, step 1116 gets the next tree and returns to step 1104 to evaluate the nodes of the tree. If there are no additional trees, then step 1114 returns to step 1102. Note, that the return of step 1114 can take place automatically to repeat the above process, or the return can be effected by a user's context change.


If, at step 1108, the node value has changed, step 1118 determines whether this node is the root node of the tree. If the node is the root node, then the method branches to step 1126 to ascertain whether the value of the node is “TRUE” or “FALSE”. If the value is “FALSE, then step 1128 hides the context block that is associated with that particular visibility expression. If, on the other hand, the value is “TRUE”, then step 1130 displays the context block that is associated with that particular visibility expression. If, at step 1118, the node is not the root node, step 1120 gets the parent node of that particular node and step 1122 evaluates the parent node. If the node value changes (step 1124), then the method branches back to step 1118. If, on the other hand, the node value does not change, then the method branches to step 1110.


The above-described process is advantageous in that many times the complete expressions that are associated with the context blocks need not be evaluated. Many times, only portions of the expressions need to be evaluated. If a particular portion of the expression has changed in value, then additional portions of the expression can be evaluated. If particular portions of the expression have not changed in value, then it is possible to terminate the expression-evaluation process thereby saving processing overhead.


Note that a small delay function can be built into the system so that the expression evaluation process is not initiated immediately when a user takes a particular action. For example, the system might be programmed so that the expression evaluation process is not initiated until a user has left their cursor in a particular location for a definable amount of time. Such delay mechanisms will be understood by those of skill in the art and are not discussed in detail any further.


Single Navigable Window Application


In accordance with one implementation, the context-sensitive context blocks and context panes can be employed in connection with a single application program having multiple different functionalities to which a user can navigate and accomplish multiple different tasks. As the user navigates to the different functionalities, their context inevitably changes. As their context changes, so too do the context blocks and context panes that are displayed for the user. An exemplary single application program with multiple different functionalities is described in the U.S. patent application entitled “Single Window Navigation Methods and Systems”, incorporated by reference above.


In the exemplary single application program that is subject of the reference incorporated above, software provides a user interface (UI) that presents a user with a single navigable window that can be navigated from functionality to functionality by a user. The individual functionalities are desirably provided by a single application program the result of which is a highly integrated software product.


A user, through the use of various navigation instrumentalities can navigate between the functionalities and when doing so, the single window ensures that only one functionality is presented to a user at a time. In this described embodiment, one navigation instrumentality is provided in the form of a web browser-like navigation tool. The choice of a web browser-like navigation tool follows from concerns that navigation instrumentalities be of a type that is readily understood by most individuals familiar with computing environments. Thus, when a user first encounters the inventive navigable single window concept for the first time, they do not have to learn an unfamiliar navigation concept. Another navigation instrumentality includes links to each of the multiple different functionalities. These links can be clicked on by a user and the single navigable window is automatically navigated to the selected functionality.



FIG. 12 shows but one exemplary user interface (UI) 1200 in accordance with one described embodiment. It will be appreciated that other UIs could be used to implement the inventive concepts described herein and that the illustrated UI constitutes but one way of doing so. In the illustrated example, UI 1200 includes a navigation bar 1202, one or more command areas 1204, and a display or document area 1206 that constitutes the single navigable window.


Navigation bar 1202 is located adjacent the top of display area 1206 and contains browser-like navigation buttons 1208 in the form of a “back” button, a “forward” button, a “stop” button and the like. The navigation bar can be located anywhere on the UI. Its illustrated placement, however, is similar in appearance to the placement of traditional web browsing navigation features. In addition to the navigation buttons 1208, the navigation bar 1202 also includes links 1210 to the different functionalities that can be accessed by the user. In the illustrated example, links to three exemplary functionalities (i.e. functionality 1, functionality 2, and functionality 3) are shown. These functionalities are typically different functionalities that can enable a user to complete different respective tasks. Examples of different tasks are given below in more detail. These functionalities are all provided within the context of a single application. To access a particular functionality, a user simply clicks on one of the links and a window that pertains to the selected functionality is immediately presented in the display area 1206.


Command areas 1204 are located adjacent the top and left side of the display area 1206. The command area(s) can, however, be located in any suitable location. The command areas provide commands that are both global in nature and specific to the particular context the user has selected. For example, some commands such as “search” and “help” might be considered as global in nature since they can find use in many contexts. Other commands, such as “text bold” or “reply to all” are more specific to the particular context that the user has selected. For the “text bold” command, the user's context may likely be a word processing context, while the “reply to all” command may likely be employed in an email context.


EXAMPLE

As an example of the single navigable window provided by a single application consider FIGS. 13 and 14.


In this example, the multiple functionalities 1210 that can be navigated by a user include a browser functionality (indicated by the home icon), a mail functionality (indicated by the letter icon), a planner functionality (indicated by the clock icon), a contacts functionality (indicated by the people icon), a documents functionality (indicated by the folder icon), and a links functionality (indicated by the world icon). These functionalities are so-called “document-centric” functionalities because they all relate in some way to a document that a user interacts with, e.g. a Web page document, an email document, a calendar document, etc.



FIG. 13 shows an example of a display that is rendered in the display area 1206 when a user clicks on the link to the browser functionality. By clicking on the link (i.e. the home icon) to the browser functionality, single application program software executing on the user's computer executes to implement a browser functionality. In this example, the browser functionality displays the user's home page in display area 1206. Notice also that navigation buttons 1208 are provided for navigation between the different selectable functionalities. The command areas 1204 contain context blocks designated as “Favorites” and “Browsing” that include command sets with commands that are specific to the context that the user has selected. In this example, the user's context is a browsing context. Accordingly, the leftmost command area contains commands that are specific to the browsing functionality. Such commands include ones that a user would normally expect to find in a web browser. Notice also that the command area 1204 adjacent the top of display area 1206 also contains commands that are specific to the browsing context, i.e. “Add to Favorites” and an address well in which the user can type a URL of a particular destination web site. Thus, context blocks that are displayable in the leftmost command area are automatically presented to the user as the user's context changes.



FIG. 14 shows an example of a display that is rendered in the display area 1206 when the user clicks on the link to the mail functionality (i.e. the folder icon). By clicking on this link, single application program software executing on the user's computer executes to implement the mail functionality. In this example, the mail functionality displays a user's inbox with messages that have been received by the user. Notice that the leftmost command area has been minimized by the user and that command area 1204 adjacent the top of the display area 1206 contains commands that are specific to the user's current context, e.g. “New” for generating a new email message, “Reply” for replying to an email message, “Reply to All” for replying to all recipients of an email message and the like. When the user's context within this functionality changes in a way that requires one or more context blocks to be displayed, the context blocks will be automatically displayed in the leftmost command area. For example, a user may author an email message and desire to italicize a portion of text. Upon selecting a portion of text, a text formatting context block will automatically appear for the user to use. As another example, assume that a user incorporates a table into their email message, if they then move the cursor inside of the table, the table formatting context block will automatically appear in the leftmost command area.


Although not specifically illustrated, the user could have displays for the planner, contacts, documents, and links functionalities presented in the display area 1206 by simply clicking on the links to these specific functionalities. When so displayed, context blocks that are associated with the user's context in these particular functionalities will be automatically displayed in accordance with the user's particular context. The navigation bar 1208 provides the user with the ability to navigate through these different functionalities in a browser-like manner.


It is important to note that the above example constitutes but one exemplary way in which multiple different functionalities and context blocks can be presented to a user within the construct of a navigable structure. It should be understood that the specifically illustrated functionalities (i.e. browser, mail, planner etc.) constitute specific examples of different functionalities that are capable of being incorporated into the single application program that provides the navigable window. Accordingly, other different functionalities can be employed. This aspect is discussed in more detail in the section entitled “Extensible Functionalities” below. It should also be noted that various context panes are associated with the individual context blocks that form the basis of this example. The context panes have not specifically been described in this example because they were explained above.



FIG. 15 is a flow diagram that describes steps in a method in accordance with the described embodiment. The illustrated method can be implemented in any suitable hardware, software, firmware, or combination thereof. In the illustrated example, the method is implemented in software.


Step 1500 provides a single application program with multiple different functionalities. The functionalities, as pointed out above, are advantageously different so as to enable a user to accomplish different tasks. One specific non-limiting example of different functionalities was given above in the context of document-centric functionalities that enable a user to make use of browser, mail, planner, contacts, documents, and links functionalities. Step 1500 can be implemented by configuring a computing device, such as a user's computer, with the single application program having the multiple different functionalities. This step can also be implemented by providing a software platform in the form of a generic single application shell that is extensible and adaptable to receive different extensions or software modules that embody various different functionalities, as described in various patent applications incorporated by reference above. These different extensions are then presented to the user in the context of the single application having the multiple different functionalities.


These extensions can be delivered to the platform in any suitable way and through any suitable delivery mechanism. For example, one way of delivering the various extensions or functionalities is to deliver them via a network such as an Intranet or the Internet. Regardless of the manner in which the single application is provided, step 1502 presents a user interface (UI) with a single window and links to the multiple different functionalities. The UI can also advantageously include navigation instrumentalities that enable a user to navigate between the different functionalities in a browser-like manner. FIGS. 13-14 give specific examples of an exemplary UI that can be used in accordance with the described embodiment. Step 1504 ascertains whether a user has selected a particular link to a functionality or whether the user has used one of the navigation instrumentalities to navigate to a particular functionality. If a user has not done either, the method branches back to step 1502. If, on the other hand, a user has selected a particular link or used a navigation tool to navigate to a particular functionality, step 1506 presents a functionality-specific display within the single window. That is, the single navigable window is navigated by the software to the selected functionality. Specific examples of this were given above in connection with FIGS. 13 and 14 in which browsing and mail functionalities were respectively displayed within display area 1206. In connection with presenting the functionality-specific display in step 1506, step 1508 can present functionality-specific commands in a command area of the UI. This is advantageously done automatically as a user navigates from functionality to functionality. That is, as a user changes functionalities, command sets that are specific to the user's current context or functionality are automatically displayed in the command area. In connection with this step, context blocks can be automatically displayed as described above. It will also be appreciated that step 1508 includes the step of presenting various context panes in response to the user selecting them as described above. Step 1508 then branches back to step 1504 to ascertain whether the user has navigated to another functionality.


Context Block and Context Pane Persistence


In the multi-functionality application scenario, context blocks or context panes can be provided that are not specifically associated with a specific document. Rather, these context blocks and context panes remain open regardless of the document, until the user explicitly closes them. Such context blocks and panes are referred to herein as “Application-level context blocks” and “Application-level context panes”.


Application-Level Context Blocks and Application-Level Context Panes


Application-level context blocks are context blocks that are not removed from the UI, even when the user navigates to another document. So, instead of being associated with a particular document, they are associated with a state of the application as a whole. Application-level context panes are similar: they are context panes that stay open even when the user navigates to another document.


As an example, consider a user that desires to use a “search” function. If the user opens the search function, a context pane corresponding to the search function will populate the context UI container. The search context pane is specific to the user's particular functionality. Thus, if the user has navigated to their email inbox, the search context pane will enable them to search their inbox. If the user has navigated to a particular document, the search context pane will enable them to search that document. As long as the search context pane is not closed by the user it will navigate with them from functionality to functionality and enable them to specifically conduct searches with the individual functionalities.


Application-Level Context Panes and Stacking


Application-level context panes are implemented with special behavioral characteristics with regards to the stacking of context panes. In this example, there are two types of context panes: those with affinity to a particular document, and those with no affinity to any document. A stack of context panes that have been opened is maintained. The stack is ordered so that the most recent pane is on the top of the stack. This stack does not contain any panes that have been explicitly closed by the user. The first pane in the stack that meets one of the following two criteria is displayed: (1) the pane has affinity to the current document, and (2) the pane has no affinity to any document. If no pane in the stack meets these criteria, then the context blocks are displayed. Note that this has the effect of hiding any pane that does not have affinity to the current document. This means that when navigation occurs, panes with affinity to the previous document are suppressed. Panes with affinity to the new document and those with no affinity to any document become candidates for display. They are considered as candidates because only the pane closest to the top of the stack is actually displayed.


CONCLUSION

The embodiments described above provide methods and systems that automatically present a user with commands that are specific to a task in which the user happens to be engaged. Advantageously, as the user's context changes within an application, the commands that are presented automatically change as well. In various implementations, the user can be given the opportunity to select additional context-sensitive commands for display. Overall, the methods and systems advantageously enable a user to take advantage of many different commands without requiring the user to know much about the application that they are using. In one particular implementation, a single application comprises multiple functionalities that enable a user to accomplish different tasks. These multiple functionalities are presented in the context of a single window that is navigable by a user between the different functionalities. Advantageously, navigation instrumentalities are provided that are, in some instances, browser-like in appearance and allow the user to navigate between the application-provided functionalities in a browser-like manner. Functionality-specific commands can be automatically presented to the user when they navigate to a particular functionality. The functionality-specific commands are presented, in the illustrated example, in the form of context blocks and content panes as described above. One aspect of the single navigable window application is that the application can serve as a basis for an extensible platform that can be configured with different functionalities. Software modules incorporating the different functionalities, as well as appropriate command sets that are displayable in the context blocks and panes, can be desirably included in the software modules. When the modules are plugged into the platform, a set of extensible functions is provided. Each of the extensible functions can have their own set of unique context blocks and panes that can be automatically displayed in a manner that is defined by the software developer of the module.


Although the invention has been described in language specific to structural features and/or methodological steps, it is to be understood that the invention defined in the appended claims is not necessarily limited to the specific features or steps described. Rather, the specific features and steps are disclosed as preferred forms of implementing the claimed invention.

Claims
  • 1. A computing system comprising: one or more processing units; andone or more computer-readable media that provide nonvolatile storage of computer-readable instructions that, when executed by the one or more processing units, cause the computing system to:display a user interface within a single navigable window, the user interface comprising: a navigation area including buttons to provide browsing functionality for navigation of the single navigable window;a document area displaying a document; anda container area proximate the document area, the container area not obscuring the document area; andin response to selection of a given object within the document area: determine whether a first context block is relevant to a task for the given object within the document by evaluating a first visibility expression associated with the first context block, the first context block comprising a first plurality of user-selectable commands;in response to determining that the first context block is relevant to the task for the given object and is not displayed in the container area, without receiving further input from the user, display the first context block within the container area; anddetermine whether a second context block is relevant to the task for the given object within the document by evaluating a second visibility expression associated with the second context block, wherein the second visibility expression is different than the first visibility expression, the second context block comprising a second plurality of user-selectable commands, the first plurality of user-selectable commands in the first context block being different than the second plurality of user-selectable commands in the second context block;in response to determining that a second context block is not displayed in the container area and that the second context block is relevant to the task for the given object, without receiving further input from the user, display the second context block within the container area;in response to determining that a second context block is displayed in the container area and that the second context block is not relevant to the task for the given object, without receiving further input from the user, hide the second context block; andwherein if the selection includes additional content in the document in addition to the given object, the first context block is displayed only when each user-selectable command in the first plurality of user-selectable commands is pertinent to the given object and the additional content.
  • 2. The computing system of claim 1, wherein the first context block is not displayed within the container area immediately prior to the selection of the given object.
  • 3. The computing system of claim 1, wherein the second context block, when displayed, comprises a title and a second plurality of user-selectable commands, the second plurality of user-selectable commands being different than the first plurality of user-selectable commands; andwherein the first context block, when displayed, comprises a title and the first plurality of user-selectable commands, the title of the first context block being different than the title of the second context block.
  • 4. The computing system of claim 1, wherein in response to deselection of the given object, the computer-readable instructions, when executed by the one or more processing units, cause the computer system to hide the first context block.
  • 5. The computing system of claim 1, wherein in response to the selection of the given object, the computer-readable instructions, when executed by the one or more processing units, cause the computer system to determine whether the second context block is relevant to the task.
  • 6. The computing system of claim 1, wherein the given object is one of the following: a portion of text, a table, and a spreadsheet.
  • 7. The computing system of claim 1, wherein the user selects the given object by placing a cursor inside the given object.
  • 8. The computing system of claim 1, wherein the first context block is modeless.
  • 9. The computing system of claim 1, wherein HTML is used to define the plurality of user-selectable commands in the first context block.
  • 10. The computing system of claim 1, wherein the software application program is a web browser and the document is a web page.
  • 11. The computing system of claim 1, wherein the computer-readable instructions, when executed by the one or more processing units, cause the computer system to collapse the first context block when the user selects the title of the first context block.
  • 12. The computing system of claim 1, wherein the container area is located to the left of the document area.
  • 13. A computing system comprising: one or more processing units; andone or more computer-readable media that provide nonvolatile storage of computer-readable instructions that, when executed by the one or more processing units, cause the computing system to:display a user interface within a single navigable window, wherein the single navigable window includes buttons for navigation of the single navigable window, the user interface comprising:a navigation area including buttons to provide browsing functionality for navigation of the single navigable window;a document area displaying a document;a container area, the container area not obscuring the document area;in response to selection of a given object within the document area:determine whether a first context block is relevant to a task for the given object within the document by evaluating a first visibility expression associated with the first context block, the first context block comprising a plurality of user-selectable commands;determine whether a second context block is relevant to the task by evaluating a second visibility expression associated with the second context block, wherein the second visibility expression is different than the first visibility expression, the second context block comprising a second plurality of user-selectable commands, the first plurality of user-selectable commands in the first context block being different than the second plurality of user-selectable commands in the second context block;display the first context block within the container area, without receiving further input from the user, when the first context block is not displayed in the container area prior to the selection of the given object and the first context block is relevant to the task; anddisplay the second context block within the container area, without receiving further input from the user, when the second context block is not displayed in the container area prior to the selection of the given object and the second context block is relevant to the task;hide the second context block within the container area, without receiving further input from the user, when the second context block is displayed in the container area and the second context block is not relevant to the task; andwherein if the selection includes additional content in the document in addition to the given object, the first context block is displayed only when each user-selectable command in the first plurality of user-selectable commands is pertinent to the given object and the additional content.
  • 14. The computing system of claim 13, wherein in response to selection of another object in the document, the computer-readable instructions, when executed by the one or more processing units, cause the computing system to: determine whether the first context block is relevant to another task, the user attempting to perform the other task with regard to the other object; anddisplay the first context block within the container area when the first context block is not displayed in the container area immediately prior to the selection of the other object and the first context block is relevant to the other task.
  • 15. The computing system of claim 13, wherein HTML is used to define the plurality of user-selectable commands in the first context block.
  • 16. The computing system of claim 13, wherein the software application program is a web browser and the document is a web page.
  • 17. A method comprising: generating a user interface displayed within a single navigable window, the user interface comprising:a navigation area including buttons to provide browsing functionality for navigation of the single navigable window, wherein the buttons include a back button, a forward button, and a stop button;a document area displaying a document;a container area proximate the document area, the container area not obscuring the document area;in response to a user selecting a portion of text within the document area, performing the following actions: determining whether a first context block is relevant to a task that the user is able to perform on the portion of text by evaluating a first visibility expression associated with the first context block, the first context block comprising one or more user-selectable commands to perform the task on the portion of text;in response to determining the first context block is relevant to the task on the portion of text, making the first context block visible within the container area without receiving further input from the user;determining whether a second context block is relevant to the task for the given object within the document by evaluating a second visibility expression associated with the second context block, wherein the second visibility expression is different than the first visibility expression, the second context block comprising a second plurality of user-selectable commands, the first plurality of user-selectable commands in the first context block being different than the second plurality of user-selectable commands in the second context block;in response to determining that a second context block is relevant to the task for the given object, without receiving further input from the user, display the second context block within the container area;in response to determining that a second context block is not relevant to the task for the given object, without receiving further input from the user, hiding the second context block; andwherein if the selection includes additional content in the document in addition to the given object, the first context block is displayed only when each user-selectable command in the first plurality of user-selectable commands is pertinent to the given object and the additional content.
  • 18. The method of claim 17, wherein the one or more user-selectable commands includes a spell checking feature to perform on the portion of text.
  • 19. The method of claim 18, wherein the one or more user-selectable commands includes a spell checking feature when the portion of text includes an incorrectly spelled word.
  • 20. The method of claim 17, wherein the container area is located to the left of the document area.
RELATED APPLICATIONS

This application is a continuation of U.S. patent application Ser. No. 10/897,647, entitled “Task-Sensitive Methods and Systems for Displaying Command Sets”, filed on Jul. 23, 2004, now U.S. Pat. No. 7,712,048, which is a divisional application of U.S. patent application Ser. No. 09/599,086, entitled “Task-Sensitive Methods and Systems for Displaying Command Sets”, filed on Jun. 21, 2000, Now U.S. Pat. No. 7,624,356. In addition, the following patent applications are related to the present application, are assigned to the assignee of this patent application, and are expressly incorporated by reference herein: U.S. patent application Ser. No. 09/599,298, entitled “Single Window Navigation Methods and Systems”, filed on Jun. 21, 2000, now U.S. Pat. No. 7,346,848;U.S. patent application Ser. No. 09/599,806, entitled “Methods and Systems of Providing Information to Computer Users”, filed on Jun. 21, 2000, now U.S. Pat. No. 6,948,135;U.S. patent application Ser. No. 09/599,299, entitled “Methods, Systems, Architectures and Data Structures For Delivering Software via a Network”, filed on Jun. 21, 2000, now U.S. Pat. No. 6,883,168;U.S. patent application Ser. No. 09/599,048, entitled “Network-based Software Extensions”, filed on Jun. 21, 2000, now U.S. Pat. No. 7,000,230;U.S. patent application Ser. No. 09/599,813; entitled “Authoring Arbitrary XML Documents Using DHTML and XSLT”, filed on Jun. 21, 2000, now U.S. Pat. No. 7,191,394;U.S. patent application Ser. No. 09/599,812, entitled “Architectures For And Methods Of Providing Network-based Software Extensions”, filed on Jun. 21, 2000, now U.S. Pat. No. 6,874,143.

US Referenced Citations (705)
Number Name Date Kind
2804878 Fishwood et al. Sep 1957 A
3091077 Erickson et al. May 1963 A
3104520 Cazier et al. Sep 1963 A
3195805 Cholvin et al. Jul 1965 A
3196606 Cholvin et al. Jul 1965 A
3812942 Espenschied et al. May 1974 A
3874828 Herschler et al. Apr 1975 A
3961748 McNabney Jun 1976 A
4005578 McInerney Feb 1977 A
4005579 Lloyd Feb 1977 A
4060340 Yanik et al. Nov 1977 A
4089623 Hofmann, Jr. May 1978 A
4201978 Nally May 1980 A
4256019 Braddick Mar 1981 A
4362475 Seitz Dec 1982 A
4391184 Yamane et al. Jul 1983 A
4396345 Hutchinson Aug 1983 A
4498147 Agnew Feb 1985 A
4514800 Gruner Apr 1985 A
4514985 Cadeddu May 1985 A
4564752 Lepic Jan 1986 A
4641274 Swank Feb 1987 A
4674040 Barker Jun 1987 A
4723211 Barker Feb 1988 A
4739477 Barker Apr 1988 A
4815029 Barker Mar 1989 A
4847749 Collins Jul 1989 A
4910663 Bailey Mar 1990 A
4933880 Borgendale Jun 1990 A
4962475 Hernandez Oct 1990 A
5025484 Yamanari Jun 1991 A
5072412 Henderson, Jr. Dec 1991 A
5179703 Evans Jan 1993 A
5182709 Makus Jan 1993 A
5187786 Densmore Feb 1993 A
5191645 Carlucci Mar 1993 A
5195183 Miller Mar 1993 A
5202828 Vertelney et al. Apr 1993 A
5204947 Bernstein Apr 1993 A
5206951 Khoyi Apr 1993 A
5218672 Morgan Jun 1993 A
5222160 Sakai Jun 1993 A
5228100 Takeda Jul 1993 A
5237680 Adams Aug 1993 A
5249275 Srivastava Sep 1993 A
5257646 Meyer Nov 1993 A
5274803 Dubin Dec 1993 A
5287448 Nicol et al. Feb 1994 A
5297249 Bernstein Mar 1994 A
5297283 Kelly, Jr. Mar 1994 A
5313631 Kao May 1994 A
5313646 Hendricks May 1994 A
5317686 Salas May 1994 A
5325481 Hunt Jun 1994 A
5333317 Dann Jul 1994 A
5339423 Beitel Aug 1994 A
5339424 Fushimi Aug 1994 A
5341478 Travis, Jr. Aug 1994 A
5369766 Nakano Nov 1994 A
5369778 San Soucie Nov 1994 A
5371675 Greif Dec 1994 A
5377323 Vasudevan Dec 1994 A
5379419 Heffeman Jan 1995 A
5381547 Flug Jan 1995 A
5388967 Firnhaber et al. Feb 1995 A
5388968 Wood et al. Feb 1995 A
5390325 Miller Feb 1995 A
5396623 McCall Mar 1995 A
5408665 Fitzgerald Apr 1995 A
5410646 Tondevold Apr 1995 A
5410688 Williams Apr 1995 A
5412772 Monson May 1995 A
5434965 Matheny et al. Jul 1995 A
5434975 Allen Jul 1995 A
5436637 Gayraud Jul 1995 A
5438659 Notess Aug 1995 A
5440744 Jacobsen Aug 1995 A
5446842 Schaeffer Aug 1995 A
5455875 Chevion Oct 1995 A
5456582 Firnhaber et al. Oct 1995 A
5459865 Heninger Oct 1995 A
5481722 Skinner Jan 1996 A
5497489 Menne Mar 1996 A
5504898 Klein Apr 1996 A
5517655 Collins May 1996 A
5535389 Elder Jul 1996 A
5540558 Harden et al. Jul 1996 A
5542070 LeBlanc Jul 1996 A
5548745 Egan et al. Aug 1996 A
5550976 Henderson Aug 1996 A
5551035 Arnold Aug 1996 A
5555325 Burger Sep 1996 A
5556271 Zuercher et al. Sep 1996 A
5566330 Sheffield Oct 1996 A
5572643 Judson Nov 1996 A
5572648 Bibayan Nov 1996 A
5577252 Nelson Nov 1996 A
5581686 Koppolu Dec 1996 A
5581760 Atkinson Dec 1996 A
5600789 Parker Feb 1997 A
5602996 Powers, III Feb 1997 A
5608720 Biegel Mar 1997 A
5613837 Konishi et al. Mar 1997 A
5625783 Ezekiel et al. Apr 1997 A
5627979 Chang May 1997 A
5630126 Redpath May 1997 A
5630706 Yang May 1997 A
5634121 Tracz May 1997 A
5634124 Khoyi May 1997 A
5640544 Onodera Jun 1997 A
5644738 Goldman Jul 1997 A
5644739 Moursund Jul 1997 A
5649099 Theimer Jul 1997 A
5655887 Chou Aug 1997 A
5659729 Nielsen Aug 1997 A
5664178 Sinofsky Sep 1997 A
5664938 Yang Sep 1997 A
5668966 Ono Sep 1997 A
5669005 Curbow Sep 1997 A
5681151 Wood Oct 1997 A
5682536 Atkinson Oct 1997 A
5689667 Kurtenbach Nov 1997 A
5689703 Atkinson Nov 1997 A
5692540 Huang Dec 1997 A
5704029 Wright, Jr. Dec 1997 A
5706501 Horikiri Jan 1998 A
5717939 Bricklin Feb 1998 A
5721824 Taylor Feb 1998 A
5740439 Atkinson Apr 1998 A
5740455 Pavley et al. Apr 1998 A
5742504 Meyer Apr 1998 A
5745683 Lee Apr 1998 A
5745712 Turpin et al. Apr 1998 A
5748807 Lopresti May 1998 A
5758184 Lucovsky May 1998 A
5758358 Ebbo May 1998 A
5761408 Kolawa Jun 1998 A
5761683 Logan Jun 1998 A
5764984 Loucks Jun 1998 A
5764985 Smale Jun 1998 A
5778372 Cordell Jul 1998 A
5778402 Gipson Jul 1998 A
5784555 Stone Jul 1998 A
5785081 Krawczyk et al. Jul 1998 A
5790796 Sadowsky Aug 1998 A
5798757 Smith Aug 1998 A
5801701 Koppolu Sep 1998 A
5802304 Stone Sep 1998 A
5802530 Van Hoff Sep 1998 A
5803715 Kitchener Sep 1998 A
5806079 Rivette Sep 1998 A
5815830 Anthony Sep 1998 A
5826265 Van Huben Oct 1998 A
5835777 Staelin Nov 1998 A
5838906 Doyle Nov 1998 A
5842018 Atkinson Nov 1998 A
5845077 Fawcett Dec 1998 A
5845090 Collins, III Dec 1998 A
5845299 Arora et al. Dec 1998 A
5854630 Nielsen Dec 1998 A
5859973 Carpenter Jan 1999 A
5862372 Morris Jan 1999 A
5862379 Rubin Jan 1999 A
5864819 De Armas Jan 1999 A
5875815 Ungerecht et al. Mar 1999 A
5898434 Small et al. Apr 1999 A
5907704 Gudmundson May 1999 A
5910895 Proskauer Jun 1999 A
5911776 Guck Jun 1999 A
5915112 Boutcher Jun 1999 A
5922072 Hutchinson Jul 1999 A
5928363 Ruvolo Jul 1999 A
5929858 Shibata Jul 1999 A
RE36281 Zuercher et al. Aug 1999 E
5940075 Mutschler, III Aug 1999 A
5947711 Myers et al. Sep 1999 A
5950010 Hesse Sep 1999 A
5956481 Walsh Sep 1999 A
5960199 Brodsky Sep 1999 A
5963964 Nielsen Oct 1999 A
5973696 Agranat Oct 1999 A
5974454 Apfel Oct 1999 A
5982370 Kamper Nov 1999 A
5983348 Ji Nov 1999 A
5986657 Berteig et al. Nov 1999 A
5987480 Donohue Nov 1999 A
5991710 Papineni Nov 1999 A
5991731 Colon Nov 1999 A
5991877 Luckenbaugh Nov 1999 A
5995103 Ashe Nov 1999 A
5999740 Rowley Dec 1999 A
6005570 Gayraud Dec 1999 A
6014135 Fernandes Jan 2000 A
6016520 Facq Jan 2000 A
6018743 Xu Jan 2000 A
6026379 Haller Feb 2000 A
6026416 Kanerva Feb 2000 A
6031989 Cordell Feb 2000 A
6035297 Van Huben Mar 2000 A
6035309 Dauerer Mar 2000 A
6044205 Reed Mar 2000 A
6052531 Waldin Apr 2000 A
6052710 Saliba Apr 2000 A
6054987 Richardson Apr 2000 A
6072870 Nguyen Jun 2000 A
6078326 Kilmer Jun 2000 A
6078327 Liman Jun 2000 A
6078924 Ainsbury Jun 2000 A
6081610 Dwork Jun 2000 A
6084585 Kraft Jul 2000 A
6088708 Burch Jul 2000 A
6091417 Lefkowitz Jul 2000 A
6094657 Hailpern Jul 2000 A
6097382 Rosen Aug 2000 A
6098081 Heidorn Aug 2000 A
6108637 Blumenau Aug 2000 A
6108783 Krawczyk Aug 2000 A
6115646 Fiszman Sep 2000 A
6121965 Kenney et al. Sep 2000 A
6122647 Horowitz Sep 2000 A
6144969 Inokuchi Nov 2000 A
6151624 Teare Nov 2000 A
6154128 Wookey Nov 2000 A
6163772 Kramer Dec 2000 A
6167521 Smith Dec 2000 A
6167523 Strong Dec 2000 A
6182094 Humpleman Jan 2001 B1
6182095 Leymaster Jan 2001 B1
6188401 Peyer Feb 2001 B1
6191797 Politis Feb 2001 B1
6192367 Hawley Feb 2001 B1
6195661 Filepp Feb 2001 B1
6199204 Donohue Mar 2001 B1
6209128 Gerard Mar 2001 B1
6216152 Wong Apr 2001 B1
6219698 Iannucci Apr 2001 B1
6225996 Gibb May 2001 B1
6235027 Herzon May 2001 B1
6253366 Mutschler, III Jun 2001 B1
6253374 Dresevic Jun 2001 B1
6263313 Milsted Jul 2001 B1
6266810 Tanaka Jul 2001 B1
6268852 Lindhorst Jul 2001 B1
6272506 Bell Aug 2001 B1
6275227 DeStefano Aug 2001 B1
6275575 Wu Aug 2001 B1
6275599 Adler Aug 2001 B1
6279042 Ouchi Aug 2001 B1
6281896 Alimpich Aug 2001 B1
6282711 Halpern Aug 2001 B1
6286033 Kishinsky Sep 2001 B1
6292897 Gennaro Sep 2001 B1
6297819 Furst Oct 2001 B1
6300948 Geller Oct 2001 B1
6307955 Zank Oct 2001 B1
6308179 Petersen Oct 2001 B1
6308273 Goertzel Oct 2001 B1
6311271 Gennaro Oct 2001 B1
6314415 Mukherjee Nov 2001 B1
6321259 Ouellette Nov 2001 B1
6321334 Jerger Nov 2001 B1
6327628 Anuff Dec 2001 B1
6331864 Coco Dec 2001 B1
6336797 Kazakis et al. Jan 2002 B1
6342907 Petty Jan 2002 B1
6343149 Motoiwa Jan 2002 B1
6343302 Graham Jan 2002 B1
6345256 Milsted Feb 2002 B1
6345278 Hitchcock Feb 2002 B1
6345361 Jerger Feb 2002 B1
6347323 Garber Feb 2002 B1
6349408 Smith Feb 2002 B1
6351574 Yair Feb 2002 B1
6353851 Anupam Mar 2002 B1
6353926 Parthesarathy Mar 2002 B1
6356906 Lippert Mar 2002 B1
6357038 Scouten Mar 2002 B1
6366907 Fanning Apr 2002 B1
6366912 Wallent Apr 2002 B1
6367013 Bisbee Apr 2002 B1
6369840 Barnett Apr 2002 B1
6369841 Salomon Apr 2002 B1
6374402 Schmeidler Apr 2002 B1
6381742 Forbes Apr 2002 B2
6381743 Mutschler, III Apr 2002 B1
6389434 Rivette May 2002 B1
6393456 Ambler May 2002 B1
6396488 Simmons May 2002 B1
6405221 Levine Jun 2002 B1
6408311 Baisley Jun 2002 B1
6414700 Kurtenbach Jul 2002 B1
6421070 Ramos Jul 2002 B1
6421656 Cheng Jul 2002 B1
6425125 Fries Jul 2002 B1
6429885 Saib Aug 2002 B1
6434563 Pasquali Aug 2002 B1
6434564 Ebert Aug 2002 B2
6442563 Bacon Aug 2002 B1
6442583 Eilert et al. Aug 2002 B1
6442755 Lemmons Aug 2002 B1
6446110 Lection Sep 2002 B1
6449617 Quinn Sep 2002 B1
6457009 Bollay Sep 2002 B1
6460058 Koppolu Oct 2002 B2
6463419 Kluss Oct 2002 B1
6470349 Heninger Oct 2002 B1
6473800 Jerger Oct 2002 B1
6476828 Burkett Nov 2002 B1
6476833 Moshfeghi Nov 2002 B1
6477544 Bolosky Nov 2002 B1
6480860 Monday Nov 2002 B1
6487566 Sundaresan Nov 2002 B1
6490601 Markus Dec 2002 B1
6493006 Gourdol et al. Dec 2002 B1
6493702 Adar Dec 2002 B1
6496203 Beaumont et al. Dec 2002 B1
6501864 Eguchi Dec 2002 B1
6502101 Verprauskus Dec 2002 B1
6502103 Frey Dec 2002 B1
6505230 Mohan Jan 2003 B1
6505300 Chan Jan 2003 B2
6507856 Chen Jan 2003 B1
6516322 Meredith Feb 2003 B1
6519617 Wanderski Feb 2003 B1
RE38070 Spies Apr 2003 E
6546546 Van Doorn Apr 2003 B1
6549221 Brown Apr 2003 B1
6549878 Lowry Apr 2003 B1
6549922 Srivastava Apr 2003 B1
6553402 Makarios Apr 2003 B1
6560616 Garber May 2003 B1
6560620 Ching May 2003 B1
6560640 Smethers May 2003 B2
6563514 Samar May 2003 B1
6571253 Thompson May 2003 B1
6578144 Gennaro Jun 2003 B1
6581061 Graham Jun 2003 B2
6584469 Chiang Jun 2003 B1
6584548 Bourne Jun 2003 B1
6585778 Hind Jul 2003 B1
6589290 Maxwell Jul 2003 B1
6594686 Edwards Jul 2003 B1
6598219 Lau Jul 2003 B1
6603489 Edlund Aug 2003 B1
6604099 Chung Aug 2003 B1
6606606 Starr Aug 2003 B2
6609200 Anderson Aug 2003 B2
6611822 Beams Aug 2003 B1
6611840 Baer Aug 2003 B1
6611843 Jacobs Aug 2003 B1
6613098 Sorge Sep 2003 B1
6615276 Mastrianni Sep 2003 B1
6621505 Beauchamp Sep 2003 B1
6629109 Koshisaka Sep 2003 B1
6631357 Perkowski Oct 2003 B1
6631379 Cox Oct 2003 B2
6631497 Jamshidi Oct 2003 B1
6631519 Nicholson Oct 2003 B1
6632251 Rutten Oct 2003 B1
6635089 Burkett Oct 2003 B1
6636845 Chau Oct 2003 B2
6643633 Chau Nov 2003 B2
6643652 Helgeson Nov 2003 B2
6643684 Malkin Nov 2003 B1
6651217 Kennedy Nov 2003 B1
6654737 Nunez Nov 2003 B1
6654932 Bahrs Nov 2003 B1
6658417 Stakutis Dec 2003 B1
6658622 Aiken Dec 2003 B1
6661920 Skinner Dec 2003 B1
6668369 Krebs Dec 2003 B1
6671805 Brown Dec 2003 B1
6675202 Perttunen Jan 2004 B1
6678717 Schneider Jan 2004 B1
6681370 Gounares Jan 2004 B2
6691230 Bardon Feb 2004 B1
6691281 Sorge Feb 2004 B1
6697944 Jones Feb 2004 B1
6701434 Rohatgi Mar 2004 B1
6701486 Weber Mar 2004 B1
6704906 Yankovich Mar 2004 B1
6711679 Guski Mar 2004 B1
6720985 Silverbrook Apr 2004 B1
6725426 Pavlov Apr 2004 B1
6728755 de Ment Apr 2004 B1
6735721 Morrow May 2004 B1
6745367 Bates Jun 2004 B1
6748385 Rodkin Jun 2004 B1
6751777 Bates Jun 2004 B2
6754874 Richman Jun 2004 B1
6757826 Paltenghe Jun 2004 B1
6757868 Glaser Jun 2004 B1
6760723 Oshinsky Jul 2004 B2
6763343 Brooke Jul 2004 B1
6772139 Smith, III Aug 2004 B1
6772165 O'Carroll Aug 2004 B2
6774926 Ellis Aug 2004 B1
6779154 Nussbaum Aug 2004 B1
6781609 Barker Aug 2004 B1
6782144 Bellavita Aug 2004 B2
6799299 Li Sep 2004 B1
6801929 Donoho et al. Oct 2004 B1
6816849 Halt, Jr. Nov 2004 B1
6842175 Schmalstieg et al. Jan 2005 B1
6845380 Su Jan 2005 B2
6845499 Srivastava Jan 2005 B2
6847387 Roth Jan 2005 B2
6848078 Birsan Jan 2005 B1
6871220 Rajan Mar 2005 B1
6874130 Baweja Mar 2005 B1
6874143 Murray et al. Mar 2005 B1
6876996 Czajkowski Apr 2005 B2
6883168 James et al. Apr 2005 B1
6889359 Conner May 2005 B1
6901403 Bata May 2005 B1
6915454 Moore Jul 2005 B1
6931532 Davis Aug 2005 B1
6941129 Loghmani Sep 2005 B2
6941510 Ozzie Sep 2005 B1
6941511 Hind Sep 2005 B1
6941521 Lin Sep 2005 B2
6948133 Haley Sep 2005 B2
6948135 Ruthfield Sep 2005 B1
6950980 Malcolm Sep 2005 B1
6961897 Peel, Jr. Nov 2005 B1
6963875 Moore Nov 2005 B2
6968503 Chang Nov 2005 B1
6968505 Stoll Nov 2005 B2
6993714 Kaler Jan 2006 B2
6996776 Makely Feb 2006 B1
6996781 Myers Feb 2006 B1
7000179 Yankovich Feb 2006 B2
7000230 Murray et al. Feb 2006 B1
7002560 Graham Feb 2006 B2
7003722 Rothchiller Feb 2006 B2
7010580 Fu Mar 2006 B1
7020869 Abriari Mar 2006 B2
7024417 Russakovsky Apr 2006 B1
7032170 Poulose Apr 2006 B2
7036072 Sulistio Apr 2006 B1
7039875 Khalfay May 2006 B2
7051273 Holt May 2006 B1
7058663 Johnston Jun 2006 B2
7062764 Cohen Jun 2006 B2
7065493 Homsi Jun 2006 B1
7080083 Kim Jul 2006 B2
7080325 Treibach-Heck Jul 2006 B2
7086009 Resnick Aug 2006 B2
7086042 Abe Aug 2006 B2
7088374 David Aug 2006 B2
7100147 Miller Aug 2006 B2
7103611 Murthy Sep 2006 B2
7106888 Silverbrook Sep 2006 B1
7107282 Yalamanchi Sep 2006 B1
7107521 Santos Sep 2006 B2
7146564 Kim Dec 2006 B2
7152205 Day Dec 2006 B2
7168035 Bell Jan 2007 B1
7178166 Taylor Feb 2007 B1
7190376 Tonisson Mar 2007 B1
7191394 Ardeleanu Mar 2007 B1
7213200 Abe May 2007 B2
7236982 Zlatanov Jun 2007 B2
7272789 O'Brien Sep 2007 B2
7281018 Begun Oct 2007 B1
7296017 Larcheveque Nov 2007 B2
7313758 Kozlov Dec 2007 B2
7316003 Dulepet Jan 2008 B1
7318237 Moriconi Jan 2008 B2
7334178 Aulagnier Feb 2008 B1
7346848 Ruthfield et al. Mar 2008 B1
7512896 Rockey et al. Mar 2009 B2
7610562 Rockey et al. Oct 2009 B2
7624356 Rockey et al. Nov 2009 B1
7712048 Rockey et al. May 2010 B2
20010007109 Lange Jul 2001 A1
20010022592 Alimpich Sep 2001 A1
20010024195 Hayakawa Sep 2001 A1
20010037345 Kiernan Nov 2001 A1
20010054004 Powers Dec 2001 A1
20010056429 Moore Dec 2001 A1
20010056460 Sahota Dec 2001 A1
20020010700 Wotring Jan 2002 A1
20020010743 Ryan Jan 2002 A1
20020010746 Jilk Jan 2002 A1
20020013788 Pennell Jan 2002 A1
20020019941 Chan Feb 2002 A1
20020023113 Hsing Feb 2002 A1
20020026356 Bergh et al. Feb 2002 A1
20020026441 Kutay Feb 2002 A1
20020026461 Kutay Feb 2002 A1
20020032590 Anand Mar 2002 A1
20020032692 Suzuki Mar 2002 A1
20020032706 Perla Mar 2002 A1
20020032768 Voskuil Mar 2002 A1
20020035579 Wang Mar 2002 A1
20020035581 Reynar Mar 2002 A1
20020040469 Pramberger Apr 2002 A1
20020049790 Ricker Apr 2002 A1
20020054126 Gamon May 2002 A1
20020054128 Lau May 2002 A1
20020057297 Grimes May 2002 A1
20020065798 Bostleman May 2002 A1
20020065847 Furukawa May 2002 A1
20020070973 Croley Jun 2002 A1
20020078074 Cho Jun 2002 A1
20020078103 Gorman Jun 2002 A1
20020083318 Larose Jun 2002 A1
20020099952 Lambert Jul 2002 A1
20020100027 Binding Jul 2002 A1
20020112224 Cox Aug 2002 A1
20020129056 Conant Sep 2002 A1
20020133484 Chau Sep 2002 A1
20020152222 Holbrook Oct 2002 A1
20020152244 Dean Oct 2002 A1
20020156772 Chau Oct 2002 A1
20020156846 Rawat Oct 2002 A1
20020156929 Hekmatpour Oct 2002 A1
20020169752 Kusama Nov 2002 A1
20020169789 Kutay Nov 2002 A1
20020174147 Wang Nov 2002 A1
20020174417 Sijacic Nov 2002 A1
20020178380 Wolf Nov 2002 A1
20020184219 Preisig Dec 2002 A1
20020188597 Kern Dec 2002 A1
20020188613 Chakraborty Dec 2002 A1
20020194219 Bradley Dec 2002 A1
20020196281 Audleman Dec 2002 A1
20020196288 Emrani Dec 2002 A1
20020198891 Li Dec 2002 A1
20020198935 Crandall, Sr. Dec 2002 A1
20030004951 Chokshi Jan 2003 A1
20030007000 Carlson Jan 2003 A1
20030014397 Chau Jan 2003 A1
20030018668 Britton Jan 2003 A1
20030020746 Chen Jan 2003 A1
20030023641 Gorman Jan 2003 A1
20030025732 Prichard Feb 2003 A1
20030026507 Zlotnick Feb 2003 A1
20030028550 Lee Feb 2003 A1
20030033037 Yuen Feb 2003 A1
20030037303 Bodlaender Feb 2003 A1
20030043986 Creamer Mar 2003 A1
20030046665 Ilin Mar 2003 A1
20030048301 Menninger Mar 2003 A1
20030051243 Lemmons Mar 2003 A1
20030055811 Stork Mar 2003 A1
20030055828 Koch Mar 2003 A1
20030056198 Al-Azzawe Mar 2003 A1
20030061386 Brown Mar 2003 A1
20030061567 Brown Mar 2003 A1
20030074279 Viswanath Apr 2003 A1
20030084424 Reddy May 2003 A1
20030085918 Beaumont et al. May 2003 A1
20030093755 O'Carroll May 2003 A1
20030110443 Yankovich Jun 2003 A1
20030120578 Newman Jun 2003 A1
20030120651 Bernstein Jun 2003 A1
20030120659 Sridhar Jun 2003 A1
20030120671 Kim Jun 2003 A1
20030120686 Kim Jun 2003 A1
20030126555 Aggarwal Jul 2003 A1
20030128196 Lapstun Jul 2003 A1
20030135825 Gertner Jul 2003 A1
20030140132 Champagne Jul 2003 A1
20030158897 Ben-Natan Aug 2003 A1
20030163285 Nakamura Aug 2003 A1
20030167277 Hejlsberg Sep 2003 A1
20030182268 Lal Sep 2003 A1
20030182327 Ramanujam Sep 2003 A1
20030187756 Klivington Oct 2003 A1
20030187930 Ghaffar Oct 2003 A1
20030188260 Jensen Oct 2003 A1
20030189593 Yarvin Oct 2003 A1
20030192008 Lee Oct 2003 A1
20030200506 Abe Oct 2003 A1
20030204511 Brundage Oct 2003 A1
20030204814 Elo Oct 2003 A1
20030205615 Marappan Nov 2003 A1
20030212664 Breining Nov 2003 A1
20030212902 van der Made Nov 2003 A1
20030217053 Bachman Nov 2003 A1
20030220930 Milleker Nov 2003 A1
20030225469 DeRemer Dec 2003 A1
20030225768 Chaudhuri Dec 2003 A1
20030225829 Pena Dec 2003 A1
20030226111 Wirts Dec 2003 A1
20030226132 Tondreau Dec 2003 A1
20030233374 Spinola Dec 2003 A1
20030233644 Cohen Dec 2003 A1
20030236859 Vaschillo Dec 2003 A1
20030236903 Piotrowski Dec 2003 A1
20030237046 Parker Dec 2003 A1
20030237047 Borson Dec 2003 A1
20040002939 Arora Jan 2004 A1
20040003031 Brown Jan 2004 A1
20040003353 Rivera Jan 2004 A1
20040003389 Reynar Jan 2004 A1
20040010752 Chan Jan 2004 A1
20040024842 Witt Feb 2004 A1
20040030991 Hepworth Feb 2004 A1
20040039990 Bakar Feb 2004 A1
20040039993 Kougiouris Feb 2004 A1
20040044961 Pesenson Mar 2004 A1
20040044965 Toyama Mar 2004 A1
20040054966 Busch Mar 2004 A1
20040059754 Barghout Mar 2004 A1
20040073565 Kaufman Apr 2004 A1
20040073868 Easter Apr 2004 A1
20040078756 Napper Apr 2004 A1
20040083426 Sahu Apr 2004 A1
20040088647 Miller May 2004 A1
20040088652 Abe May 2004 A1
20040093596 Koyano May 2004 A1
20040107367 Kisters Jun 2004 A1
20040117769 Lauzon Jun 2004 A1
20040123277 Schrader Jun 2004 A1
20040146199 Berkner Jul 2004 A1
20040163041 Engel Aug 2004 A1
20040172442 Ripley Sep 2004 A1
20040181711 Johnson Sep 2004 A1
20040186762 Beaven Sep 2004 A1
20040189716 Paoli Sep 2004 A1
20040194035 Chakraborty Sep 2004 A1
20040205473 Fisher Oct 2004 A1
20040205525 Murren Oct 2004 A1
20040205534 Koelle Oct 2004 A1
20040205571 Adler Oct 2004 A1
20040205592 Huang Oct 2004 A1
20040205605 Adler Oct 2004 A1
20040205653 Hadfield Oct 2004 A1
20040205671 Sukehiro Oct 2004 A1
20040210599 Friedman Oct 2004 A1
20040221238 Cifra Nov 2004 A1
20040221245 Chickles Nov 2004 A1
20040237030 Malkin Nov 2004 A1
20040261019 Imamura Dec 2004 A1
20040268229 Paoli Dec 2004 A1
20040268259 Rockey Dec 2004 A1
20040268260 Rockey Dec 2004 A1
20050004893 Sangroniz Jan 2005 A1
20050005248 Rockey Jan 2005 A1
20050015279 Rucker Jan 2005 A1
20050015732 Vedula Jan 2005 A1
20050022115 Baumgartner Jan 2005 A1
20050027757 Kiessig Feb 2005 A1
20050033728 James Feb 2005 A1
20050038711 Marlelo Feb 2005 A1
20050055627 Lloyd Mar 2005 A1
20050060324 Johnson Mar 2005 A1
20050060721 Choudhary Mar 2005 A1
20050065933 Goering Mar 2005 A1
20050065936 Goering Mar 2005 A1
20050066287 Tattrie Mar 2005 A1
20050071752 Marlatt Mar 2005 A1
20050076049 Qubti Apr 2005 A1
20050091285 Krishnan Apr 2005 A1
20050091305 Lange Apr 2005 A1
20050102370 Lin May 2005 A1
20050102612 Allan May 2005 A1
20050108104 Woo May 2005 A1
20050108624 Carrier May 2005 A1
20050114757 Sahota May 2005 A1
20050132196 Dietl Jun 2005 A1
20050138086 Pecht-Seibert Jun 2005 A1
20050138539 Bravery Jun 2005 A1
20050171746 Thalhammer-Reyero Aug 2005 A1
20050198086 Moore Sep 2005 A1
20050198125 Beck Sep 2005 A1
20050198247 Perry Sep 2005 A1
20050223063 Chang Oct 2005 A1
20050223320 Brintzenhofe Oct 2005 A1
20050240876 Myers Oct 2005 A1
20050246304 Knight Nov 2005 A1
20050268222 Cheng Dec 2005 A1
20060020586 Prompt Jan 2006 A1
20060026534 Ruthfield Feb 2006 A1
20060031757 Vincent, III Feb 2006 A9
20060036995 Chickles Feb 2006 A1
20060041838 Khan Feb 2006 A1
20060059434 Boss Mar 2006 A1
20060069605 Hatoun Mar 2006 A1
20060069985 Friedman Mar 2006 A1
20060080657 Goodman Apr 2006 A1
20060085409 Rys Apr 2006 A1
20060101037 Brill May 2006 A1
20060101051 Carr May 2006 A1
20060129978 Abriani Jun 2006 A1
20060143220 Spencer, Jr. Jun 2006 A1
20060161559 Bordawekar Jul 2006 A1
20060200754 Kablesh Sep 2006 A1
20070036433 Teutsch Feb 2007 A1
20070050719 Lui Mar 2007 A1
20070061467 Essey Mar 2007 A1
20070061706 Cupala Mar 2007 A1
20070074106 Ardeleanu Mar 2007 A1
20070094589 Paoli Apr 2007 A1
20070100877 Paoli May 2007 A1
20070101280 Paoli May 2007 A1
20070118803 Walker May 2007 A1
20070130504 Betancourt Jun 2007 A1
20070186157 Walker Aug 2007 A1
20070208606 MacKay Sep 2007 A1
20070208769 Boehm Sep 2007 A1
20080028340 Davis Jan 2008 A1
Foreign Referenced Citations (32)
Number Date Country
0 841 615 May 1998 EP
0 961 197 Dec 1999 EP
1 076 290 Feb 2001 EP
1 221 661 Jul 2002 EP
63085960 Apr 1988 JP
401173140 Jul 1989 JP
3191429 Aug 1991 JP
4225466 Aug 1992 JP
5314152 Nov 1993 JP
406014105 Jan 1994 JP
6139241 May 1994 JP
6180697 May 1994 JP
6180698 Jun 1994 JP
08-263246 Oct 1996 JP
08-263247 Oct 1996 JP
09-016801 Jan 1997 JP
09-134273 May 1997 JP
09-190327 Jul 1997 JP
09-251370 Sep 1997 JP
09-292967 Nov 1997 JP
10-011255 Jan 1998 JP
10-097559 Apr 1998 JP
10-232754 Sep 1998 JP
10-240434 Sep 1998 JP
10-260765 Sep 1998 JP
2000132436 May 2000 JP
2002183652 Jun 2002 JP
2003173288 Jun 2003 JP
WO 9924945 May 1999 WO
WO 9956207 Nov 1999 WO
WO 0144934 Jun 2001 WO
WO 0157720 Aug 2001 WO
Non-Patent Literature Citations (157)
Entry
Author: Dieter Schmalstieg, L. Miguel Encarna, and Zsolt Szalav Title: Using Transparent Props for Interaction With the Virtual Table Date: 1999 pp. 147-153, 232.
Author: Jos Kingston Title: CorelDRAW 7: Getting Started with CorelDraw Date: Aug. 1999 Publisher: Sheffield Hallam University Pertinent pp. 3, 21.
Author: Jason Ellis, Chi Tran, Jake Ryoo, Ben Shneiderman Title: Buttons vs. menus: An exploratory study of pull-down menu selection as compared to button bars Date: Jun. 1995 Publisher: Department of Computer Science, University of Maryland, College Park, Pertinent pp. 3, 17.
“Architecture for a Dynamic Information Area Control,” IBM Technical Disclosure Bulletin, IBM Corp. New York, US, vol. 37, No. 10, Oct. 1994, pp. 245-246.
“Enter Key,” retrieved from the Internet on Dec. 20, 2006 at http://systems.webopedia.com/TERM/E/Enter—key.html, Sep. 1, 1996, 1 page.
“Microsoft Visual Basic 5.0 Programmer's Guide 1997,” pp. 578-579, Redmond, WA 98052-6399.
“Microsoft Visual Basic 5.0 Programmer's Guide,” Microsoft Press, (1997), pp. 42-43, 54-58.
“Microsoft Word 2000 Screenshots,” (2000), pp. 11-17.
“Microsoft Word 2000 Screenshots,” Word, (2000), pp. 1-17.
“Microsoft Word 2000,” Screenshots, (1999), pp. 1-5.
“Netscape Window,” Netscape Screenshot, Oct. 2, 2002.
“Store and Organize Related Project Files in a Binder,” Getting Results with Microsoft Office, 1990, pp. 109-112.
“Webopedia Computer Dictionary” retrieved on May 9, 2006, at http://www.pewebopedia.com/TERM/O/OLE.html, Jupitermedia Corporation, 2006, pp. 1-7.
“Whitehill Composer,” Whitehill Technologies Inc., 2 pages.
“XForm 1.0,” W3C (Jul. 16, 2001).
Adams, Susie , “BizTalk Unleashed,” Sams Publishing, 2002, first printing Mar. 2001, pp. 1-2, 31-138.
Alschuler, Liora, “A tour of XMetal,” O'Reilly xml.com, ′Online! Jul. 14, 1999, XP002230081, retrieved from the Internet: <URL:http://www.xml.com/pub/a/SeyboldReport/ip031102.html>, retrieved on Feb. 5, 2003.
Altova , “User and Reference Manual Version 4.4,” www.xmlspy.com, (May 24, 2007), pp. 1-565.
Altova , “XML Spy, XML Integrated Development Environments,” Altova Inc., 2002, pp. 1-18.
Altova, “Altova Tools for XPath 1.0/2.0,” Altova, pp. 1-12.
Altova, Inc., “XML Spy 4.0 Manual,” Altova Inc. & Altova GmbH, copyright 1998-2001, Chapters 1, 2 and 6, pp. 1-17, 18-90 and 343-362.
Anat, Eyal , “Integrating and Customizing Heterogeneous E-Commerce Applications,” The VLDB Journal—The International Journal on Very Large Data Bases, vol. 10, Issue 1, (Aug. 2001), pp. 16-38.
Atova, “User Reference manual Version 4.4, XML Spy suite 4.4,” Atova Ges.m.b.H and Altova, Inc., May 24, 2002, pp. cover, copyright page, 1-565.
Au, Irene , “Netscape Communicator's Collapsible Toolbars,” CHI '98, Human Factors in Computing Systems, Conference Proceedings, Los Angeles, CA, Apr. 18-23, 1998, pp. 81-86.
Barker , “Creating In-Line Objects Within an Integrated Editing Environment,” IBM Technical Disclosure Bulletin, vol. 27, No. 5, Oct. 1984, p. 2962.
Battle, Steven A. , “Flexible Information Presentation with XML,” 1998, The Institution of Electrical Engineers, 6 pages.
Beauchemin, Dave, “Using InfoPath to Create Smart Forms,” Retrieved from the Internet on Jan. 21, 2007 at http://www.microsoft.com/office/infopath/prodinfo/using.mspx, Microsoft Corporation, 2007, pp. 1-6.
Begun, Andrew , “Support and Troubleshooting for XML Schemas in InfoPath 2003,” Microsoft Office InfoPath 2003 Technical Articles, Retrieved from the Internet on Jan. 21, 2007 at http://msdn2.microsoft.com/en-us/library/aa168241(office.11,d=printer).aspx, Microsoft Corporation, 2007, pp. 1-18.
Berg, A., “Naming and Binding: Monikers,” Inside Ole, 1995, Chapter 9, pp. 431-490.
Borland, Russo, “Running Microsoft Word 97,” pp. 314-315, 338, 361-362, 390, and 714-719.
Brabrand , “Power Forms Declarative Client-side Form Field Validation,” (2002), pp. 1-20.
Bradley, Neil, “The XML Companion, Third Edition,” published by Addison Wesley Professional, http://proquest.safaribooksonline.com0201770598, (Dec. 12, 2001), pp. 1-18.
Brogden, William, “Arbortext Adept 8 Editor Review,” O'Reilly xml.com, ′Online! Sep. 22, 1999 XP002230080, retrieved from the Internet: <URL:http://www.xml.com/pub/a/1999/09/adept/AdeptRvw.htm>, retrieved on Feb. 5, 2003.
Bruce Halberg , “Using Microsoft Excel 97,” Published 1997, Bestseller Edition, pp. 1-9, 18-25, 85-89, 98-101, 106-113, 124-127, 144-147, 190-201, 209-210, 218-227, 581-590, 632-633, 650-655, 712-714.
Chen, Ya Bing , “Designing Valid XML Views,” ER 2002, LNCS 2503, 2002, Springer-Verlag Berlin Heidelberg 2002, pp. 463-477.
Chen, Yi , “XKvalidator: A Constraint Validator for XML,” CIKM '02, Nov. 4-9, 2002, Copyright 2002, ACM 1-58113-492-4/02/0011, pp. 446-452.
Chien, Shu-Yao , “Efficient Management of Multiversion Documents by Object Referencing,” Proceedings of the 27th VLDB Conference, 2001, pp. 291-300.
Chien, Shu-Yao , “Efficient schemes for managing multiversion XML documents,” VLDB Journal (2002), pp. 332-353.
Chien, Shu-Yao , “Storing and Querying Multiversion XML Documents using Durable Node Numbers,” IEEE 2002, pp. 232-241.
Chien, Shu-Yao , “XML Document Versioning,” SIGMOD Record, vol. 30, No. 3, Sep. 2001, pp. 46-53.
Chuang, Tyng-Ruey., “Generic Validation of Structural Content with Parametric Modules,” ICFP '01, Sep. 3-5, 2001, Copyright 2001, ACM 1-58113-415-0/01/0009, pp. 98-109.
Ciancarini, Paolo , “Managing Complex Documents Over the WWW: A Case Study for XML,” IEEE Transactions on Knowledge and Data Engineering, vol. 11, No. 4, Jul./Aug. 1999, pp. 629-638.
Clapp, D., “The NeXT Application Kit Part I: Non-Responsive Classes,” The NeXT Bible, 1990, Chapter 16, pp. 275-293.
Clarke, P., “From small beginnings,” Knowledge Management, Nov. 2001, pp. 28-30.
Cover, XML Forms Architecture, retrieved at http://xml.coverpages.org/xfa.html on Aug. 17, 2006, Coverpages, Jun. 16, 1999.
Cybook, Inc., “Copying the Search Form to Services-based Web Sites,” Internet Article (online) Jul. 26, 2004.
Davidow, Ari, “XML Editors: Allegations of Functionality in search of reality,” Internet, ′Online! 1999, XP002230082, retrieved from the Internet: <URL:http://www.ivritype.com/xml/>.
Dayton, Linnea and Jack Davis, Photo Shop 5/5.5 WOW! Book, 2000, Peachpit Press, pp. 8-17.
Description of Whitehill Composer software product produced by Whitehill Technologies Inc. available at <http://www.xml.com/pub/p/221> accessed on Apr. 8, 2004, 2 pages.
DiLascia, “Sweeper,” Microsoft Interactive Developer, vol. 1, No. 1, 1996, 27 pages.
Dodds, “Toward an XPath API,” xml.com, (May 7, 2001), pp. 1-3.
Dubinko, Micah, “Xforms and Microsoft InfoPath,” Retrieved from the Internet on Jan. 21, 2007 at http://www.xml.com/1pt/a/1311, O'Reilly Media, 1998-2006, pp. 1-6.
Dyck, Timothy., “XML Spy Tops as XML Editor,” http://www.eweek.com/article2/0, 3959, 724041,00.asp, Nov. 25, 2002, 4 pages.
Excel Developer Tip (hereinafter “Excel”), “Determining the Data Type of a Cell,” May 13, 1998, 1 page (available at http://jwalk.com/ss/excel/tips/tip62.htm).
Grosso, “XML Fragment Interchange,” W3C (Feb. 2001), pp. 1-28.
Halberg, Bruce , “Using Microsoft Excel 97,”(1997), pp. 191-201, 213-219.
Hall, Richard Scott, “Agent-based Software Configuration and Deployment,” Thesis of the University of Colorado, Online, Dec. 31, 1999, retrieved from the Internet on Nov. 7, 2003: <http://www.cs.colorado.edu/users/rickhall/documents/ThesisFinal.pdf>, 169 pages.
Han, “WebSplitter: A Unified XML Framework for Multi-Device Collaborative Web Browsing,” 2000, ACM Conference on Computer Supported Cooperative Work, 10 pages.
Hardy, Mathew R.B. , “Mapping and Displaying Structural Transformations between XML and PDF,” DocEng 02, Nov. 8-9, 2002, Copyright 2002, ACM 1-58113-594-7/02/0011, pp. 95-102.
Haukeland, Jan-Henrick, “Tsbiff—tildeslash biff—version 1.2.1” Internet Document, [Online] Jun. 1999, URL:http://web.archive.org/web/19990912001527/http://www.tildeslash.com/tsbiff/.
Herzner, “CDAM—Compound Document Access and Management. An Object-Oriented Approach,” Multimedia Systems Interaction and Applications, 1992, Chapter 3, pp. 17-36.
Hoffman, “Architecture of Microsoft Office InfoPath 2003,” Microsoft Office InfoPath 2003 Technical Articles, retrieved from the Internet on Jan. 21, 2007 at http://msdn2.microsoft.com/en-us-/library/aa219024(office.11,d=printer).aspx, Microsoft Corporation, 2007, pp. 1-18.
Hu, “A Programmable Editor for Developing Structured Documents based on Bidirectional Transformations,” ACM, (Aug. 2004), pp. 178-189.
Hwang, Kai , “Micro-Firewalls for Dynamic Network Security with Distributed Intrusion Detection,” IEEE Int'l Symposium on Network Computing and Applications, 2001, pp. 68-79.
IBM: Stack Algorithm for Extractin Subtree from Serialized Tree, Mar. 1, 1994, TDB-ACC-NONN94033, 3 pages.
Ixia Soft, “Streamlining content creation, retrieval, and publishing on the Web using TEXTML Server and SML Spy 4 Suite in an integrated, Web publishing environment,” (Partner&apos;s Whitepaper, published on the Web as of Jun. 6, 2002, download pp. 1-16.
James Clark, Editor, “XSL Transformation (XSLT) Version 1.0,” Nov. 16, 1999, W3C (MIT, INRIA, Keio), pp. 1-156.
James Clark and Steve Derose, “XML Path Language (XPath) Version 1.0,” Nov. 16, 1999, W3C (MIT,. INRIA, Keio), pp. 1-49.
Kaiya, Haruhiko , “Specifying Runtime Environments and Functionalities of Downloadable Components under the Sandbox Model,” Int'l. Symposium on Principles of Software Evolution, 2000, pp. 138-142.
Kanemoto, Hirotaka , “An Efficiently Updatable Index Scheme for Structured Documents,” 1998 IEEE, pp. 991-996.
Kim, Sang-Kyun , “Immediate and Partial Validation Mechanism for the Conflict Resolution of Update Operations in XML Databases,” WAIM 2002, LNCS 2419, 2002, pp. 387-396, Springer-Verlag Berlin Heidelberg 2002.
Klarlund, Nils , “DSD: A Schema Language for XML,” ACM, FSMP Portland, Oregon, (2000), pp. 101-111.
Kobayashi , “An Update on BTRON-specification OS Development,” IEEE 1991, pp. 132-140.
Komatsu, N. , “A Proposal on Digital Watermark in Document Image Communication and Its Application to Realizing a Signature,” Electronics and Communications in Japan, Part I: Communications, vol. 73, No. 5, May 1990, pp. 22-33.
Laura Acklen & Read Gilgen, “Using Corel Wordperfect 9,” pp. 251-284, 424-434, 583-586 (1998).
LeBlond , “PC Magazine Guide to Quattro Pro for Windows,” pp. 9-11, 42-61, Ziff-Davis Press, Copyright 1993 by LeBlond Group.
Lehtonen, Miro , “A Dynamic User Interface for Document Assembly,” Department of Computer Science, University of Helsinki, pp. 134-141 (Nov. 2002).
Macromedia, Inc., “Dreamweaver Technote, Changes in copying and pasting in Dreamweaver 4,” Internet Article (online).
Mansfield, “Excel 97 for Busy People,” Published by Osborne/Mcgraw-Hill, 1997, pp. 48-50.
McCright, J.S., “New Tool Kit to Link Groove with Microsoft SharePoint,” eWeek, Enterprise News & Reviews, Ziff Davis Media Inc., Jul. 29, 2002, 1 page.
Microsoft Corporation, “Microsoft Computer Dictionary,” Microsoft Press, 5th Edition, p. 149.
Microsoft Word 2000 (see Screen Shot “About Microsoft Word”) Published 1983-1999 and Microsoft Excel 2000 (see Screen Shot “About Microsoft Excel”) published 1988-1999, 3 pages.
Musgrave, S., “Networking technology—impact and opportunities,” Survey and Statistical Computing 1996, Proceedings of the Second ASC International Conference, Sep. 1986, pp. 369-378, London, UK.
Nelson, Joe, “Client-side Form Validation Using JavaScript,” Developer Advisory (Sep. 21, 2001).
Nelson, Mark, “Validation with MSXML and XML Schema,” Windows Developer Magazine, Jan. 2002, pp. 35-38.
Netscape Communication Corporation: “Netscape Communicator 4.61 for OS/2 Warp,” Software, 1999, The whole software release & “Netscape—Version 4.61 [en]—010615” Netscape Screenshot, Oct. 2, 2002.
Netscape Communications Corp., “SmartUpate Developer's Guide,” Online, Mar. 11, 1999, retrieved from the Internet on Dec. 8, 2000: <http://developer.netscape.com:80/docs/manuals/communicator/jarman/index.htm>, 83 pages.
Noore, A., “A Secure Conditional Access System using Digital Signature and Encryption,” 2003 Digest of Technical Papers, International Conference on Consumer Electronics, Jun. 2003, pp. 220-221.
OMG XML Metadata Interchange (XMI) Specification Version 1.2 Jan. 2002.
Pacheco, X.avier , “Delphi 5 Developer's Guide,” Sams Publishing, 1999, Chapter 31, Section: Data Streaming, 6 pages.
Peterson, B., “Unix Variants,” Unix Review, vol. 10, No. 4, Apr. 1992, pp. 29-31.
Pike , “Plan 9 from Bell Labs,” UKUUG, Summer 1990, 10 pages.
Pike , “The Use of Name Spaces in Plan 9,” Operating Systems Review, vol. 27, No. 2, Apr. 1993, pp. 72-76.
Prevelakis, Vassilis , “Sandboxing Applications,” FREENIX Track: 2001 USENIX Annual Technical Conference, pp. 119-126.
U.S. Appl. No. 60/191,662, filed Mar. 23, 2000.
U.S. Appl. No. 60/203,081, filed May 9, 2000.
U.S. Appl. No. 60/209,713, filed Jun. 5, 2000.
Rado, Dave, “How to create a template that makes it easy for users to “fill in the blanks”, without doing any programming” Microsoft Word MVP FAQ Site (online) Apr. 30, 2004.
Raggett, “HTML Tables,” retrieved on Aug. 6, 2006 at http://www.is-edu.homuns.edu/vn/WebLib/books/Web/Tel/html3-tables.html, W3C Internet Draft, Jul. 7, 1995, pp. 1-12.
Raman, T.V. , “XForms 1.0,” (Dec. 2001), Section 1-12.2.3 & Appendices A-G.
Rapaport, L., “Get more from SharePoint,” Transform Magazine, vol. 11, No. 3, Mar. 2002, pp. 13-15.
Rees, Michael J., “Evolving the Browser Towards a Standard User Interface Architecture,” Third Australasian User Interfaces Conference, 2001, Australian Computer Society Inc., IEEE Computer Society, pp. 1-7.
Rogge, Boris , “Validating MPEG-21 Encapsulated Functional Metadata,” IEEE 2002, pp. 209-212.
Schmid, M. , “Protecting Data from Malicious Software,” 18th Annual Security Applications Conference, 2002, pp. 199-208.
Singh, Darshan, “Microsoft Infopath 2003 by Example,” retrieved from the Internet on Jan. 21, 2007 at http://www.perfectxml.com/InfoPath.asp, PerfectXML.com, 2004, pp. 1-19.
Staneck, W., “Internal and External Media,” Electronic Publishing Unleashed, 1995, Chapter 22, pp. 510-542.
STYLUSSTUDIO, “StylusStudio: XPath Tools,” 2004-2007, StylusStudio, pp. 1-14.
Sun, Q. , “A Robust and Secure Media Signature Scheme for JPEG Images,” Proceedings of 2002 IEEE Workshop on Multimedia Signal Processing, Dec. 2002, pp. 296-299.
Sutanthavibul, Supoj , “XFIG Version 3.2 Patchlevel 2 (Jul. 2, 1998) Users Manual (Edition 1.0),” Internet Document, [Online], XP002229137 Retrieved from the Internet: <URL:http://www.ice.mtu.edu/online—docs/xfig332/> [retrieved on Jan. 28, 2003].
Tomimori, Hiroyuki , “An Efficient and Flexible Access Control Framework for Java Programs in Mobile Terminals,” Proceedings of 22nd Int'l Conference on Distributed Computing Systems Workshops, 2002, pp. 777-782.
Trupin, J., “The Visual Programmer,” Microsoft Systems Journal, Apr. 1996, pp. 103-105.
U.S. Office Action mailed Oct. 28, 2003 cited in U.S. Appl. No. 09/599,086.
U.S. Final Office Action mailed May 25, 2004 cited in U.S. Appl. No. 09/599,086.
U.S. Office Action mailed Mar. 3, 2005 cited in U.S. Appl. No. 09/599,086.
U.S. Final Office Action mailed Aug. 8, 2005 cited in U.S. Appl. No. 09/599,086.
U.S. Office Action mailed Jan. 30, 2006 cited in U.S. Appl. No. 09/599,086.
U.S. Final Office Action mailed Jul. 5, 2006 cited in U.S. Appl. No. 09/599,086.
U.S. Office Action mailed Nov. 13, 2006 cited in U.S. Appl. No. 09/599,086.
U.S. Final Office Action mailed May 10, 2007 cited in U.S. Appl. No. 09/599,086.
U.S. Office Action mailed Oct. 31, 2007 cited in U.S. Appl. No. 09/599,086.
U.S. Final Office Action mailed Mar. 6, 2008 cited in U.S. Appl. No. 09/599,086.
U.S. Office Action mailed Sep. 6, 2007 cited in U.S. Appl. No. 10/897,647.
U.S. Final Office Action mailed Mar. 6, 2008 cited in U.S. Appl. No. 10/897,647.
U.S. Office Action mailed Jul. 18, 2007 cited in U.S. Appl. No. 10/898,657.
U.S. Final Office Action mailed Jan. 3, 2008 cited in U.S. Appl. No. 10/898,657.
U.S. Office Action mailed Sep. 8, 2008 cited in U.S. Appl. No. 10/898,657.
U.S. Office Action mailed Jul. 13, 2007 cited in U.S. Appl. No. 10/898,656.
U.S. Final Office Action mailed Nov. 15, 2007 cited in U.S. Appl. No. 10/898,656.
U.S. Office Action mailed Apr. 18, 2008 cited in U.S. Appl. No. 10/898,656.
U.S. Office Action mailed Nov. 14, 2008 cited in U.S. Appl. No. 09/599,086.
U.S. Office Action mailed Nov. 14, 2008 cited in U.S. Appl. No. 10/897,647.
U.S. Office Action mailed Jul. 14, 2009 in U.S. Appl. No. 10/897,647.
U.S. Appl. No. 09/599,086, filed Jun. 21, 2000, Confirmation No. 6625.
Udell, Jon, “InfoPath and XForms,” retrieved from the Internet at http://weblog.infoworld.com/udell/2003/02/26.html (Feb. 26, 2003).
Usdin, Tommie, “XML: Not a Silver Bullet, But a Great Pipe Wrench,” Standardview, vol. 6, No. 3, Sep. 1998, pp. 125-132.
Van Hoff, Arthur, “The Open Software Description Format,” Online, Aug. 13, 1997, retrieved from the Internet on Nov. 7, 2003: <http://www.w3.org/TR/NOTE-OSD>, 11 pages.
Varlamis, Iraklis, “Bridging XML-Schema and relational databases. A system for generating and manipulating relational databases using valid XML documents,” DocEng '01, Nov. 9-10, 2001, Copyright 2001, ACM 158113-432-0/01/0011, pp. 105-114.
Vasters, Clemens F., “BizTalk Server 2000 A Beginner's Guide,” Osborne/McGraw-Hill (2001), pp. 1-2, 359-402.
Villard, “An Incremental XSLT Transformation Processor for XML Document Manipulation,” http://www2002.org/CDROM/refereed/321, printed on May 18, 2007 (May 2002) 25 pages.
Watt, Andrew, “Microsoft Office Infopath 2003 Kick Start,” (published by Sams) Print ISBN-10:0-672-32623-X, (Mar. 24, 2004), pp. 1-57.
Williams, Sara and Charlie Kindel, “The Component Object Model: A Technical Overview,” Oct. 1994, Microsoft Corp., pp. 1-14.
Wong, Raymond K. , “Managing and Querying Multi-Version XML Data with Update Logging,” DocEng '02, Nov. 8-9, 2002, Copyright 2002, ACM 1-58113-594-7/02/0011, pp. 74-81.
XMLSPY, “XmlSpy 2004 Enterprise Edition Manual,” Altova, (May 17, 2004), pp. 1-25, 220-225.
Zdonik, S., “Object Management System Concepts,” ACM, 1984, pp. 13-19.
Extended European Search Report in EP Appln. No. 10012887.5-2211, Jul. 4, 2011, 12 pages.
Dubinko et al., “XForms 1.0,” W3C, 2001, pp. 1-125.
European Search Report mailed Mar. 21, 2003 and issued in Application No. EP 97 30 7138, filed Sep. 15, 1997; Patent No. EP 0 841 615 A3, date of publication May 14, 2003.
European Search Report mailed Jul. 16,2003 and issued in Application No. 00306806.1, filed Aug. 9, 2000; Patent No. EP 1 076 290 A3, date of publication Feb. 14, 2001.
International Search Report mailed Apr. 9, 1999 and issued in Application No. PCT/IB98/01392, filed Sep. 8, 1999; Patent No. WO 99/24945, date of publication, May 20, 1999.
International Search Report mailed Sep. 22, 1999 and issued in Application No. PCT/US99/09620, filed Apr. 30, 1999; Patent No. WO 99/56207, date of publication, Nov. 4, 1999.
International Search Report mailed Nov. 28, 2000 and issued in Application No. PCT/IB99/02003, filed Dec. 15, 1999; Patent No. WO 01/44934 A1, date of publication Jun. 21, 2001.
Japanese Office Action Issued in Patent Application 2002-504581, Mailed Date: Dec. 17, 2010, 24 Pages.
Japanese Office Action Issued in Patent Application 2002-504581, Mailed Date: May 27, 2011, 6 Pages.
Japanese Notice of Allowance Issued in Patent Application 2002-504581, Mailed Date: Sep. 16, 2011, 6 Pages.
European Office Action Issued in Patent Application 01939034.3, Mailed Date: Nov. 6, 2007, 3 Pages.
Office Action Issued in European Patent Application No. 01939034.3, Mailed Date: Aug. 31, 2015, 5 Pages.
European Office Action Issued in Patent Application No. 01939034.3, Mailed Date: Jun. 29, 2016, 4 pages.
Related Publications (1)
Number Date Country
20100229110 A1 Sep 2010 US
Divisions (1)
Number Date Country
Parent 09599086 Jun 2000 US
Child 10897647 US
Continuations (1)
Number Date Country
Parent 10897647 Jul 2004 US
Child 12722414 US