HK1063229B - Method for providing contextually sensitive tools and help content in computer-generated documents - Google Patents

Description

Method for providing context-sensing tools and help content in computer-generated documents

Technical Field

The invention relates to providing context-sensing tools and help content in computer-generated documents.

Background

Computer software applications allow users to create a wide variety of documents to assist them in work, education, and leisure. For example, popular word processing applications allow users to create letters, articles, books, memos, and the like documents. Spreadsheet programs allow users to store, process, print, and display a wide variety of alphanumeric data. Such applications have well-known advantages, including rich editing, formatting, and computing tools.

However, documents created by such software applications do not provide the user with context sensing tools, help content, or support. That is, when a user is entering text or data into such software applications, these applications do not provide the user with a help tool or assistance depending on the context of the text or data the user is entering. Internet-based applications attempt to address some business issues by creating and deploying web-based templates that allow users to enter information that registers users for some service types that can be transmitted back to a backend web server. Such web-based applications may typically include links that a user may navigate to a separate website to obtain help information or help from the web-based application or document that the user is currently using. However, such web-based applications are disadvantageous compared to the above-mentioned software application documents, and modern web-based applications rarely provide rich editing, formatting, printing, and computing.

For example, in a typical setting, a user may decide to prepare a resume with a word processing application installed on her computer. While the user is preparing for a track, she may want to fill out such paragraphs as "personal information," education, "" experiences, "and" other course activities. After the user completes each paragraph, she may require help, including information about the order in which the paragraphs are arranged, preferred numbers to be put into the past work of "going through" the paragraph, and so on. To receive such assistance, the user may have to read a history-related book or surf to an internet-based history help site to find information.

Instead, the user may enter an internet-based resume site to complete a resume using a web-based resume template. The user is allowed to enter specified information in specified data fields and is provided with a link to an internet website in order to navigate to a site where she can obtain help from different paragraphs of the document. When the user has completed the preparation of the web-based resume, the user work service or the user can print the template. However, the rich editing and formatting of a user's word processing application functionality, such as resume, is likely to be unavailable to users with the limitations of web-based applications relative to the user's computer-based word processing software.

It is with respect to these considerations and others that the present invention has been made.

Disclosure of Invention

The present invention provides a method and system for creating, implementing and using computer-generated documents that provide contextual sensing tools, controls and help content to users. Generally, an outline attached to a document defines permissible data content, data types, and data structures for the document. Structured documents associate documents with schemas and solutions with document structures. A set of software components is assembled to provide a solution for the document, enabling the document to invoke the set of software components to provide the solution for the document according to the edit location in the document.

After the document is created, the software application for opening the document may be directed to initiate opening of the document. A determination is made as to whether the document references a solution. A determination is made as to whether the set of software components providing the solution is in a software component library. If so, the set of software components is invoked to provide a solution for the document.

Once the document is opened for use, the document edits are focused at a location on the document, such as by placing a cursor at a location on the document, causing the generation of a list of extensible markup language (XML) elements that encompass the location of the edit focus. A determination is made as to whether the list of XML elements has an available solution associated therewith. If there are any available solutions associated with the list of XML elements, the document invokes each associated solution for the user and obtains it. Preferably, the solution includes help content and document tools associated with the context of the document editing location. A graphical user interface is run for the document to display for each solution obtained by the user.

These and other features, advantages, and aspects of the present invention will be more clearly understood and appreciated from a review of the following detailed description of the disclosed embodiments and by reference to the drawings and claims.

Drawings

FIG. 1 is a computer screen displaying a software application graphical user interface through which a document and associated context-sensing tools and help content are displayed in accordance with embodiments of the present invention.

FIG. 2 is a block diagram illustrating a client software architecture used in conjunction with an embodiment of the present invention.

FIG. 3 is a block diagram of a computer and associated external and networked devices that provide a typical operating environment for the present invention.

FIG. 4 is a flow diagram illustrating a method of creating a document that provides context-sensing tools and help content in accordance with an embodiment of the present invention.

FIG. 5 is a flow diagram illustrating a method of opening a document created according to an embodiment of the present invention.

FIG. 6 illustrates a computer-generated dialog box for providing multiple document solutions to a user.

FIG. 7 illustrates a computer-generated dialog box for assisting a user in downloading components of an application created in accordance with the present invention.

FIG. 8 is a flow chart illustrating a method of determining what content to display on a document tool panel in accordance with an embodiment of the present invention.

Detailed Description

The present invention is directed to creating, implementing and using computer-generated "smart" documents with the addition of functionality that provides context-sensing tools, help content and controls to users of such documents. According to one embodiment of the invention, portions of a document are structured such that when a user enters the portions (e.g., places a computer cursor in the portions), document pointing may provide the user with a solution to contextual sensing tools and/or help content. For example, if a user is preparing a resume for a job, the user may place her computer cursor on the "education" section of the resume. Placing a computer cursor into an "educational" paragraph can provide context-sensitive information to a user in accordance with the present invention. The document may point to a comprehensive solution such as a resume document structure, or individual paragraphs of the document may point to contextual subsets of the solution such as an "experience" paragraph solution of a resume document structure. A document tool panel adjacent to the document being edited may be opened on the user's computer screen and a narrative may be provided regarding the suggested method of completing the "education" passage. If the user moves the cursor to another portion of the document, such as to the "target" paragraph of the resume, the user may obtain information associated with that context, such as an appropriate professional target statement.

It should be understood that the context-sensing tools and help content provided to a user in accordance with an embodiment of the present invention may be provided by a wide variety of software applications, including word processors, spreadsheets, web browsers, text editors, and the like. Furthermore, the types and content of help information and tools provided to a user in accordance with embodiments of the present invention may include a wide variety of tools and actions and help information as desired by the author of the software application used by the user.

Referring to FIG. 1, a computer screen is illustrated showing an exemplary software application 100 and illustrates a document and associated document tools panel providing document tools and help content using the program. The document 110 illustrated in fig. 1 displays a staff member annual performance review template with which a staff member can complete her annual performance review or with which a staff member can complete her annual performance review. The application 100 illustrated in FIG. 1 is a word processing application for displaying and editing a document 110, but those skilled in the art will appreciate that the application 100 may include other software applications including spreadsheet applications, text editing applications, and the like. Further, the document 110 illustrated in FIG. 1 depicts a yearly performance review document, but the document 110 may include other various documents and templates edited by the user, including biographical templates, will templates, desktop printed documents, letters, financial spreadsheets, and the like.

Referring to the exemplary document shown in FIG. 1, word processing application 100 provides functionality typically associated with word processing programs available through drop-down menus such as File, Edit, View, Insert, Format, and the like. The document 110 is displayed in the workspace of the application 100 and a document tool pane 135 is shown to the right of the document. It should be understood that the display shown in FIG. 1 is by way of example only and that the components shown in FIG. 1 may be organized in a variety of different ways that are satisfactory to a user. That is, the document tool pane may be positioned at the bottom of the screen display, to the left of the document 110, or in other orientations as permitted by the application 100.

The following is a detailed discussion of the creation and implementation of the "smart" document 110 shown in FIG. 1, but generally describes, in accordance with an embodiment of the present invention, that once a user places her computer cursor on a section of the document 110, such as the "objects" section 125 shown in FIG. 1, the user is provided with tools and help content in the document tools panel. For example, if the user places her computer cursor on the "objects" paragraph 125, the user is provided with an "Objective Writing Tips" 155 shown in the document tool panel 135. As shown in FIG. 1, selecting "Objective Writing Tips" 155 causes the display of an "Objective Writing Tips" body 160, which provides the user with help information such as how to complete the "objects" section of the performance review document 110. If the user moves the cursor to a different paragraph of the document, such as the personal information paragraph 120, the information provided in the document tool pane 135 will provide the user with assistance in completing the personal information paragraph 120.

In addition to help information to help the user, various tools and actions 145 are provided. For example, a "SubmitReview" action may allow a user to submit a completed document 110 to her supervisor or her staff member after completing the document. The "Open Last Review" action may allow the user to Open the Last performance Review so that she can determine whether she completed her goal in the Last Review. If the document used by the user is some other type of document, such as a resume document, the help information in the document tool pane may include information regarding the preparation of an "education" paragraph, a "story" paragraph, and/or a "personal information" paragraph. A testimonial document 110 may be associated with help information regarding legal provisions for preparing the testimonial, provisions regarding property beneficiaries, and the like.

In addition to the document actions and help content shown in panel 135, a wide variety of document controls may be provided, including radio buttons, text boxes, checkboxes, ActiveX controls, XML tree controls, and the like. For example, a text box may be provided to allow the user to select from a list of pre-written text items. Alternatively, the user may be allowed to enter text in a list box provided in the panel 135, which will then be inserted into the document or used by the application in some other function with respect to the application. Radio buttons or checkboxes are provided to allow the user to select from different options for document actions or help content. For example, if the document is a will, a checkbox may be provided to allow the user to select "married," "singles," etc. to obtain help information based on the user's personal intent and property profile.

Referring to FIG. 2, a general system architecture for creating and using a "smart" document 110 in accordance with the present invention is illustrated. As with one of the software applications 100 described above, a document 110 is opened and created or edited on a user's computer 20 in accordance with the present invention. A schema library 105 is provided to contain all executable files for providing context sensing functionality to the document 110. For example, the outline library may include various components, including various modular software routines that have been compiled and dynamically linked, ready to be used by the application program 100 to provide context sensing functionality to the document 110.

Such components may include a number of dynamic link libraries (dlls) that include executable files or routines stored separately from software application 110. Software application 100 loads the dll only if the dll is required to provide functionality for document 110. Further, as described in detail below, the schema library 105 may include a number of extensible markup language (XML) files to provide context sensing functionality with respect to XML structures that have been applied to the document 110.

The document 110 includes a solution attribute 115 that is used to point the document to a solution contained in the schema repository 105. The solution 118 provides information to the document 110 and application 100 such as to the location of solution attributes in the schema repository or to a remote location provided by a network-based server through a distributed computing environment such as through the internet.

In accordance with the present invention and as described in detail below, when a user focuses on a portion of a document 110, such as the "objects" section of the performance review 110 shown in FIG. 1, a solution property 115 points the document to the "objects" section to help display a solution in the document tool pane 115. Solution location 118 provides document 110 and application 100 with the location of the components, dlls, or XML files needed to implement that solution. It should be appreciated that typical components may include a component to draw the document tool pane 135, a component to display information associated with a context, such as the "objects" paragraph in this example, and a component to perform a document action, such as the "Submit Review" action 145.

FIG. 3 and the following discussion are intended to provide a brief general description of a suitable computing environment in which the invention may be implemented. While the invention will be described in the general context of application programs that run in an operating system in conjunction with a personal computer, those skilled in the art will recognize that the invention may also be implemented in combination with other program modules. Generally, program modules include routines, programs, components, data structures, etc. that perform particular tasks or implement particular abstract data types. Moreover, those skilled in the art will appreciate that the invention may be practiced with other computer system configurations, including hand-held devices, multiprocessor systems, microprocessor-based or programmable consumer electronics, cell phones, minicomputers, mainframe computers, and the like. The invention may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote memory storage devices.

With reference to fig. 3, an exemplary system for implementing the invention includes a conventional personal computer 20 including a processor unit 21, a system memory 22, and a system bus 23 that couples the system memory to the processor unit 21. The system memory 22 includes Read Only Memory (ROM)24 and Random Access Memory (RAM) 25. A basic input/output system 26(BIOS), containing the basic routines that help to transfer information between elements within the personal computer 20, such as during start-up, is stored in ROM 24. The personal computer 20 further includes a hard disk drive 27, a magnetic disk drive 28, such as for reading from and writing to a removable magnetic disk 29, an optical disk drive, such as for reading from a CD-ROM disk 31, or for reading from or writing to other optical media. The hard disk drive 27, magnetic disk drive 28, and optical disk drive 30 are connected to the system bus 23 by a hard disk drive interface 32, a magnetic disk drive interface 33, and an optical drive interface 34, respectively. The drives and their associated computer-readable media provide nonvolatile storage for the personal computer 20. Although the above description of computer-readable media refers to a hard disk, a removable magnetic disk and a CD-ROM disk, it should be appreciated by those skilled in the art that other types of media which are readable by a computer, such as magnetic cassettes, flash memory cards, digital video disks, Bernoulli cartridges, and the like, can also be used in the exemplary operating environment.

A number of program modules may be stored in the drives and RAM25, including an operating system 35, one or more application programs 100, a word processing program module 37 (or other type of program module), program data such as display data 38, and other program modules (not shown).

A user may enter commands and information into the personal computer through a keyboard 40 and a pointing device, such as a mouse 42. Other input devices (not shown) may include a microphone, joystick, game pad, satellite dish, scanner, or the like. These and other devices are often connected to the processor unit 21 through a serial port interface 46 that is coupled to the system bus, but may be connected by other interfaces, such as a game port or a Universal Serial Bus (USB). A monitor 47 or other type of display device is also connected to the system bus 47 via an interface, such as a video adapter 48. In addition to the monitor, personal computers typically include other external output devices (not shown), such as speakers and printers.

The personal computer 20 may operate in a networked environment using logical connections to one or more remote computers, such as a remote computer 49. The remote computer 49 may be a server, a router, a peer device or other common network node, and typically includes many or all of the elements described above relative to the personal computer 20, although only a single storage device 50 has been illustrated in FIG. 3. The logical connections depicted in FIG. 3 include a Local Area Network (LAN)51 and a Wide Area Network (WAN) 52. Such networking environments are commonplace in offices, enterprise-wide computer networks, intranets and the Internet.

When used in a LAN networking environment, the personal computer 20 is connected to the LAN51 through a network interface 53. When used in a WAN networking environment, the personal computer 20 typically includes a modem 54 or other means for establishing communications over the WAN52, such as the Internet. The modem 54, which may be internal or external, is connected to the system bus 23 via the serial port interface 46. In a networked environment, program modules depicted relative to the personal computer 20, or portions thereof, may be stored in the remote memory storage device. It will be appreciated that the network environments shown are exemplary and other means of establishing a communications link between the computers may be used.

FIG. 4 is a flow diagram illustrating a method of creating a "smart" document 110 in accordance with an embodiment of the present invention. The method 300 begins at step 305 and proceeds to step 310 where an XML schema is attached to the document. As understood by those skilled in the art, the schema establishes the syntax and rules of extensible markup language (XML) tags that are applied to the document 110 in order to provide XML structure to the document 110. The schema attached to the document 110 shown in FIG. 1 may set forth all grammatically allowed data types and data content rules for tags associated with the document 110. For example, a "personal information" paragraph 120, which includes a name, an email name, a job title, and a staff identification for a staff member, may have an outline that requires that the "name" block data must be entered in the format of "first name" followed by "midle name" followed by "last name".

As will be appreciated by those skilled in the art, the use of an extensible markup language, once a document 110 has that portion tagged with an XML structure by a corresponding "name" element, for example, the processing of that paragraph of data into the document can be accomplished by a software component, regardless of the actual content of the data, by simply entering the content in accordance with the schema specified for that portion of the document.

In step 315, the document 110 is annotated with XML structure relating to tools and help functions to provide the document with context sensing functionality as described above. A simplified XML structure for the staff review document 110 shown in FIG. 1 is labeled as follows:

XML structural paradigm

<Employee Review>

<Personal Information>

<Name>

<first_name>Joe</first_name>

<last_name>Smith</last_name>

</Name>

<email Name>

<email>JoeAddress.com</email>

<mail Name>

*

*

*

</Employee Review>

The schema appended to the document 110 specifies the data structure rules entered into the XML document structure. As should be appreciated, the XML structure shown above is simplified in nature and is provided for illustrative purposes only. An exemplary XML schema associated with the above exemplary XML structure is as follows: outline example

<xsd:sche xmlns:xsd＝“http://www.w3.org/2001/XMLSchema”

xmlns＝“urn:reviewForm”

targetNamespace＝“urn:reviewForm”

elementFormDefault＝“qualified”>

<xsd:annotation>

<xsd:documentation xml:lang＝“en”>

The schema for the August2001Microsoft employee review form.

</xsd:documentation>

</xsd:annotation>

<xsd:element name＝“Review”type＝“ReviewType”/>

<xsd:complexType name＝“EmployeeManagerResponsesType”>

<xsd:all>

<xsd:element name＝“EmployeeResponse”type＝“xsd:string”/>

<xsd:element name＝“ManagerResponse”type＝“xsd:string”/>

</xsd:all>

</xsd:complexType>

<xsd:simpleType name＝“RatingScore”>

<xsd:restriction base＝“xsd:demical”>

<xsd:enumeration value＝“2.5”/>

<xsd:enumeration value＝“3.0”/>

<xsd:enumeration value＝“3.5”/>

<xsd:enumeration value＝“4.0”/>

<xsd:enumeration value＝“4.5”/>

<xsd:enumeration value＝“5.0”/>

</xsd:restriction>

</xsd:simpleType>

<xsd:complexType name＝“IdentityType”>

<xsd:all>

<xsd:element name＝“Name”type＝“xsd:string”/>

<xsd:element name＝“Alias”type＝“xsd:string”/>

<xsd:element name＝“Title”type＝“xsd:string”/>

<xsd:element name＝“EmployeeID”type＝“xsd:positiveInteger”/>

<xsd:element name＝“Reviewer”type＝“xsd:string”/>

<xsd:element name＝“Department”type＝“xsd:string”/>

<xsd:element name＝“Date”type＝“xsd:date”/>

</xsd:all>

</xsd:complexType>

<xsd:complexType name＝“ReviewType”mixed＝“true”>

<xsd:all>

<xsd:element name＝“ReviewPeriod”type＝“xsd:string”/>

<xsd:element name＝“Identity”type＝“IdentityType”/>

<xsd:elementname＝“CurrentObjectives”type＝

“EmployeeManagerResponsesType”/>

<xsd:elementname＝“FutureObjectives”type＝

“EmployeeManagerResponsesType”/>

<xsd:elementname＝“StrengthsAndWeaknesses”type＝

“EmployeeManagerResponsesType”/>

<xsd:element name＝“Ratings”type＝“RatingType”/>

</xsd:all>

</xsd:complexType>

</xsd:schema>

In step 320, the document 110 is saved with the associated document schema and XML structure.

In step 325, software program code needs to be written for displaying and processing tools, controls and actions in the document tool pane 135 according to the position of the user's cursor in the document 110. The code written in step 325 includes all required XML files, including extensible stylesheet language (XSL) files, including XSL transformations and XSL format objects. As understood by those skilled in the art, XSL transformations include files that contain specified rules by which one XML document is transformed to another XML document. As will be appreciated by those skilled in the art, all XML files, including XML documents and XML transformation documents, are written for the purpose of processing the document 110 into an XML structured document.

According to one embodiment, writing an XML schema may be to define a list of document actions, controls, and help content that are associated with a solution or a subset of the solution's context that is correspondingly associated with an XML structure (element) in the document. The XML schema may be written using any editing tool or XML schema editing tool to create an instance of the schema. An XML schema may be written to include all of the attributes of the schema and a list of document actions, controls, and help content to be displayed directly in the XML schema. An exemplary XML schema is listed above.

Other code written for document 110 in step 325 includes all components such as application 100 and the dynamic link library (dll) required by document 110 to provide context sensing functionality for document 110, as previously described with reference to FIG. 1. For example, a dll in the form of an Application Programming Interface (API) may be written to access a certain solution contained in the outline library 105 when the user positions the computer cursor in a certain context of the document 110. That is, when a computer cursor is placed in a certain paragraph or section of the document 110, such as the "name" section, an application programming interface is included to discover the solution properties 115 associated with the "name" section of the document 110 and access the solution to provide document tools, actions, and help content related to the "name" section of the document.

Other typical components written at step 325 include components that draw the document tool panel 135 and components that display textual information associated with the XML element in the document 110 where the computer cursor is currently located. Other components may include displaying an action such as a "submit review" button, modular software routines that allow the user to submit the review to a third party such as the user's staff member or the user's supervisor. And other components that render and provide functionality to controls, such as radio buttons, text boxes, and checkboxes, as previously described with reference to fig. 1. Any component object model plug-ins that may be needed to provide functionality in accordance with the present invention are also written in step 325. In addition to the software components required to provide the documentation tools and help functions described herein, the actual text of the help content displayed in the panel 135 is assembled for use when accessing the corresponding help topic.

Controls such as radio buttons, text boxes, and check boxes may be provided in the panel 135 when the associated outline is not attached to the document. By declaring a control to be associated with a certain XML element, that control can be provided on top of the panel 135 over other actions, controls, and help topics specified by the schema. Likewise, a control may be provided in the panel 135 directly over all other items including those described above by declaring that control to be associated with the entire schema of the document rather than the individual XML elements specified by the schema.

All of the above-described files, components, component plug-ins, dlls, outline files, and XML files are assembled and stored for use by the application 100 in providing the context sensing functionality of the document 110. Schema library 105 may contain pointers to the stored components in the form of a database, which may be stored in memory at various locations on computer 20, including a registry of computers.

According to embodiments of the present invention, an Application Programming Interface (API) is provided to implement the functionality of the present invention, providing a "smart" document structure for document 110. This API includes properties and methods or instructions that are invoked when an action is initiated, such as opening document 110 to point to a solution in turn, as described above. Listed below is an example of computer program code that implements the "Smart" document API. The code examples set forth below are not intended to limit the changes that can be made in computer program code written to implement this API in accordance with the present invention.

Smart document API paradigm

Implements ISmartDocument

Private Sub ISmart Document_SmartDocInitialize(ByVal document As Object，ByVal bstrSolutionPath As String)

Private Property Get ISmartDocument_SmartDocXMLTypeCount()As Long

Private Property Get ISmartDocument_SmartDocXMLTypeName(ByValsmartDocIDAs Long)As String

Private Property Get ISmartDocument_SmartDocXMLTypeCaption(ByVal smartDocIDAs Long，ByVal LocaleID As Long)As String

Private Property Get ISmart Document_ControlCount(ByVal SmartDocXMLTypeNameAs String)As Long

Private Property Get ISmart Document_ControlID(ByVal SmartDocXMLTypeName AsString，ByVal ControlIndexAs Long)As Long

Private Property Get ISmart Document_ControlType From ID(ByVal ControlID As Long，ByVal Application Name As String，ByVal Locale IDAs Long) AsC_TYPE

Private Property Get ISmartDocument_Control Name FromID(ByVal ControlID As Long)As String

Private Property Get ISmart Document_Is Control Dynamic(ByVal ControlID As Long，ByVal ApplicationName As String，ByVal LocaleID As Long)As Boolean

Private Property Get ISmartDocument_Control CaptionFromID(ByVal ControlID AsLong，ByVal ApplicationName As String，ByVal LocaleID As Long，ByVal bstrText AsString，ByVal bstrXML As String，ByVal Target AsObject)As String

Private Sub ISmart Document_PopulateRadioGroup(ByVal ControlID As Long，ByValApplicationNameAs String，ByVal LocaleID As Long，ByValbstrText As String，ByValbstrXML As String，ByVal Target AsObject，List()As String，count As Long，InitialSelected As Long)

Private Sub ISmart Document_OnRadioGroupSelectChange(ByVal ControlID As Long，ByVal Target AsObject，ByVal Selected As Long，ByValValue As String)

Private Sub ISmart Document_PopulateImage(ByVal ControlID As Long，ByValApplicationName As String，ByVal LocaleID As Long，ByVal bstr Text As String，ByValbstrXML As String，ByVal Target As Object，Image Src As String)

Private Sub ISmartDocument_ImageClick(ByVal ControlID AsLong，ByValApplication Name As String，ByVal TargetAs Object，ByVal Text As String，ByValXmlAs String，ByVal LocaleID As Long，ByValX Coordinate As Long，ByValY CoordinateAs Long)

Private Sub ISmart Document_PopulateDocumentFragment(ByVal ControlID As Long，ByVal Application Name As String，ByVal LocaleID As Long，ByVal bstr Text AsString，ByValbstrXML As String，ByVal Target As Object，Document Fragment As String)

Private Sub ISmartDocument_Populate ActiveXProps(ByVal ControlID As Long，ByValApplicationName As String，ByVal LocaleID As Long，ByValbstr Text As String，ByValbstrXML As String，ByVal Target As Object，Prop Bag AsSmartTagLib.IActiveXProperties)

Private Sub ISmartDocument_PopulateCheckbox(ByVal ControlID As Long，ByValApplicationName As String，ByVal LocaleID As Long，ByValbstr Text As String，ByValbstrXML As String，ByVal Target As Object，ByVal Checked As Boolean)

Private Sub ISmartDocument_OnCheckboxChange(ByVal Cal ControlID As Long,ByValTarget As Object，ByVal Checked As Boolean)

Private Sub ISmart Document_PopulateListOr Combo Content(ByVal ControlID As Long，ByVal ApplicationName As String，ByVal LocaleID As Long，ByValbstr Text As String，ByVal bstrXML As String，ByVal Target As Object，List()As String，count As Long，InitialSelected As Long，Is Editable As Boolean，ControlOn SameLine As Boolean)Private Sub ISmart Document_OnListOr ComboSelect Change(ByVal ControlID As Long，ByVal Target As Object，ByVal Selected As Long，ByVal Value As String)

Private Sub ISmart Document_Populate Textbox Content(ByVal ControlID AsLong，ByVal Application Name As String，ByVal LocaleID As Long，ByValbstrText As String， ByVal bstrXML As String，ByVal Target As Object，Value As String，ControlOnSameLine As Boolean)

Private Sub ISmartDocument_OnTextboxContentChange(ByVal ControlID As Long，ByVal Target As Object，ByValValue As String)

Private Sub ISmart Document_PopulateHelpContent(ByValControlID As Long，ByValApplicationName As String，ByValLocaleID As Long，ByVal bstr Text As String，ByValbstrXML As String，ByVal Target As Object，Content As String)

Private Sub ISmartDocument_Invoke Control(ByVal ControlID As Long，ByValApplicationName As String，ByValTarget As Object，ByVal Text As String，ByValXmlAs String，ByVal LocaleID As Long)

Many attributes and methods are included in the above listed APIs. The SmartDocInitialize method includes routines and instructions that are executed when an API is called to provide "Smart" document functionality for the document 110. The SmartDocXMLTypeCount attribute includes the number of XML element types associated with the solution. The SmartDocXMLName attribute includes a unique identifier of the XML element type associated with the "smart" document structure.

The smartdocxmltypecap attribute includes a title associated with an XML element that a menu or panel, such as the help panel 135, may include.

The ControlCount attribute includes the number of controls associated with the "smart" document structure that correspond to a certain XML element type. The ControlID attribute includes a unique identifier of the control. The ControlTypeFromID attribute includes the types of controls available for association with the solution, such as radio buttons, text boxes, and checkboxes. The ControlNameFromID attribute returns a name associated with each control used internally by a given application 100.

The PopulateRadioGroup method includes routines and instructions executed to populate a menu or panel, such as help panel 135, with radio control buttons. The OnRadioGroupSelect Change method includes routines and instructions that are executed when a radio group (radio button) is selected or deselected.

The PopulaeImage method includes routines and instructions executed to populate an image associated with a solution, such as populating an image in the help panel 135. The ImageClick method includes routines and instructions that are executed when a user selects an image.

The popup documentfragment method includes routines and instructions that are executed to fill in text or data into a user interface. The PopulateActiveXProps method includes routines and instructions to obtain ActiveX functionality associated with a document structure.

The postatebox method includes routines and instructions executed by providing a checkbox control in a user interface, such as the help panel 135. The OnCheckBoxChange method includes routines and instructions that are executed when a user selects or deselects a checkbox control.

The postatelistorcontent method includes routines and instructions that are executed to fill a list box control in a user interface, such as panel 135. The OnListOrComboSelectChange method includes routines and instructions that are executed when one of the options is selected in a listbox control.

The PopulateTextBoxContent method includes routines and instructions to fill a text box in a user interface, such as panel 135. The OnTextboxContentChange method includes routines and instructions executed to process an event associated with a change in the contents of a text box control in a user interface, such as panel 135.

The postlatehelmontent method includes routines and instructions executed to fill in a help content field in panel 135 with the required text or data. The InvokeControl method includes routines and instructions that are executed when a control, such as a radio button, text box, or checkbox, is selected or deselected.

Referring still to FIG. 4, in step 330, a determination is made as to whether the document 110 is operable in a client-server mode of operation. That is, the components that provide the context sensing functionality to the application 110, or updates or changes to these components, may be stored in a remote server location separate from the computer 20. If the document is to be enabled to obtain the application and components needed for the document to run from a remote server location, the method proceeds to step 335 and writes server code responsive to client actions performed by a user at computer 20. That is, a corresponding application program interface is written between the computer 20 and the remote server 49 to obtain the required server-side data and application program components for providing the context sensing functionality of the present invention. If it is desired that the application point to a remote server for data and application components, a solution location identifier, such as a solution URL, is added to cause the application to point to a location on the remote server to obtain the desired data and application components.

In step 340, a manifest of all the above-described programming components is created to identify a list of components, dlls, outline files, and XML files that will be used to provide various solutions and functions to the document 110. A pointer is added to document 110 that points the document to the component manifest to obtain the functionality provided by the various components. In step 350, all files, code, and changes to document 110 are saved, and the document creation method ends in step 390. Thus, the document 110 is now in a state that can be opened and used by the user.

Fig. 5 relates to steps associated with opening and using document 110. For purposes of example only, the employee performance review document 110 is described with reference to the step of opening a "smart" document that is created and implemented in accordance with embodiments of the present invention. Method 400 begins at step 405 and proceeds to step 410 where the user launches application 100. As will be appreciated by those skilled in the art, the application 100 may be initiated by selecting an application or selecting a document 110 created by the application 100.

In step 415, the user selects a manner to open the document 110 consistent with the application program 100. In step 420, a determination is made as to whether document 110 references a solution. That is, a determination is made as to whether the document 110 has been annotated with pointers to one or more solutions for providing context-sensing tools and help information to the document, as described above. As part of the check to determine whether document 110 points to one or more solutions, a determination is also made as to whether an outline has been attached to the document as described above. If the document references a solution, such as a solution that provides assistance to the user in preparing the user's staff to review the document 110, the method proceeds to step 425 where the application 100 invokes the schema 105 to determine if the solution referenced by the document 110 is stored in the schema repository 105. In the outline library, the judging comprises judging the components required in the outline library; that is, what components are associated with the i.d. of the solution. For example, the document 110 may have an additional schema that defines rules governing the XML structure of the document 110, but that is created without reference to a solution.

In step 430, a determination is made as to whether the solution is stored in the schema repository. As should be appreciated, document 110 may have multiple solutions attached. For example, a first solution may include help information and actions to provide context-sensing information about a user completing the document 110. A second solution for providing information to the supervisor of the user may be attached to document 110 such that the context-sensing information provided to the supervisor gives the supervisor information such as how to evaluate each paragraph of the employee's review document.

If the document 110 references multiple solutions, a prompt may be provided to the user, such as dialog box 500 shown in FIG. 6, informing the user that multiple solutions are available for the document. The user may then select a solution from the solution list after the document is opened that provides the user with the desired functionality.

In step 435, a determination is made as to whether the user does want to provide a solution to the user after the document 110 is opened. As should be appreciated, a dialog box similar to dialog box 500 may be displayed to the user to ask the user if the user desires the functionality of help content and tools, for example. In many instances the user may have completed the document 110 without the need for additional help or action functionality. If desired, the user may decide to always accept the solution when opening the document 110. Similarly, the user may decide to check the document 110 and update the solution by the application 100 each time the document 110 is opened.

If the user rejects the solution, the method proceeds to step 455, where the document does not have a "smart" document structure and is opened according to the normal steps required and implemented by the application 100. If the user requires the functionality of the solution referenced by the document 110, the method proceeds to step 440, where the solution is loaded for use by the application 100 and the document 110. As will be appreciated by those skilled in the art, loading a solution includes the document 110 invoking, via the application 100, all of the necessary files, dlls, plug-in components, and XML files associated with the solution and stored in the schema library 105.

When called by document 110, application 100 registers each called file through the computer operating system and establishes a path between each called file and application 100 and document 110 to provide the functionality associated with each file. For example, if a dll for rendering the document tool panel 135 must assign a registration key to properly communicate with the application 100 and the document 110, the registration process is completed when the solution is loaded in step 440. In step 445, the "smart" document 110 is opened and displayed on the user's computer screen, as shown in FIG. 1.

Referring back to step 420, if the document does not reference a solution, the method proceeds to step 450 where a determination is made as to whether the document has an outline attached. If the document has an outline attached thereto, but does not reference a solution, the method proceeds to step 430 where a "check" is made of the outline repository to determine if there is a solution that may be associated with the outline attached to the document 110. That is, even when document 110 does not reference a solution, the outline repository may have a solution that the user obtained after the user created document 110 that may be used for document 110, even though document 110 did not reference a solution when it started to be created.

If no solution exists in the outline repository that is appropriate for the document 110, the method proceeds to step 435, where the following steps are performed as previously described. If the document 110 has not been outline-attached, the method proceeds to step 455 by not opening the document using the "clever" document structure.

Referring back to step 430, if no solutions associated with the solution referenced by document 110 or associated with additional schemas are found in the schema library, the method proceeds to step 460 where a determination is made as to whether the user would like to download a solution. In step 460, application 110 may "prompt" the user and tell the user that document 110 will work more efficiently or more usefully if the user downloads certain help and action functions to the user's document 110. The "prompts" may be provided to the user in the form of a dialog box, such as dialog box 600 shown in FIG. 7. Various queries may be made to the user to see if the user wants to download the component containing the desired solution in a variety of ways. If the user declines to download solution functions and components, the method returns to step 455, where the document is opened without using the "smart" document structure as previously described.

If it is desired to download the solution provided to the user, the method proceeds to 465. In step 465, the components that provide the document 110 with the desired solution are downloaded to the user's computer 20 from some remote source, such as a remote web-based server. To locate the remote source, the application 100 uses the solution location pointer 118 in the document 110 to locate and obtain the necessary solution components. In step 470, the downloaded solution is loaded into the schema library 105 of the client and the solution is loaded as described above such that the document 110 will include the functionality of the solution.

FIG. 8 is a flow chart illustrating the determination of what is displayed in the document tools pane 135 after opening the document 110 using the "smart" document structure. To describe the steps shown with reference to FIG. 8, a "smart" document structure has been loaded and run when the document 110 is opened. As an example, consider that the user has placed a computer cursor at a location on document 110, such as "objects" paragraph 125.

The method 700 begins at step 705 and proceeds to step 710 where a column of XML elements surrounding a cursor is generated. The position of the cursor in the XML hierarchy is located and the X-path expression that takes the cursor location is determined. For example, with reference to the simplified XML code set listed above, the cursor might be positioned in the "e-mail" tab and in the larger XML tree "employee review" tab.

In step 715, a determination is made as to what tools and help content should appear in the document tools pane 135. To make this determination, the application 110 enters a look-up table stored at the client computer 20 that contains information about which XML elements have which particular tools, help content, controls, etc. associated with those XML elements. For example, if the cursor is positioned over the "e-mail name" element in the "personal information" paragraph 130, the application 100 will enter a lookup table to determine the particular tools or help content associated with the e-mail name element.

Each document action, help item, and control associated with each element is populated with a unique Identifier (ID) that applies to the XML element with which it is associated, so that the application 100 can easily locate the action, help item, or tool associated with the XML element. In step 720, a determination is made as to whether any actions, help items or controls are dynamic. One control may appear differently based on context or context information corresponding to the context. This paragraph may be associated with the Submit Review button after the completion of reviewing the "objects" paragraph of document 110. On the other hand, if this paragraph is not complete, the Submit Review button will not appear in panel 135 because the document should not be submitted when the objects paragraph is not complete. Thus, the button "Submit Review" is determined to be dynamic in this case in step 720, and the method then proceeds to step 725. In step 725, document 110 calls a component representing the "SubmitReview" button through application 100 and provides the component in the context of the cursor position, e.g., the "objects" element is complete or not.

In step 730, after a determination is made that the action, help content, or control is static or dynamic, the contents of the document tool pane 135 are drawn adjacent to the document 110 in the user's computer screen, as shown in FIG. 1. In step 735, a determination is made as to whether the cursor has moved to a new context. For example, after the user has completed entering the "objects" paragraph, the user may move the cursor to the "personal information" paragraph 120 to complete that paragraph. If the cursor has not moved, the method proceeds to end at step 790. That is, as long as the cursor remains in the current context, no other changes are made to the contents of the document tool pane 135. If the cursor is moved into a new context in the document, the method returns to step 710 where a new XML element column containing the cursor is generated, and the method proceeds as described above to provide new content associated with the new cursor location and context in the document tool pane 135.

Referring back to FIG. 1, the following is a description of the tools and help content drawn in the document tools pane 135. The particular text and controls shown in FIG. 1 are by way of example only and may vary with the context of the cursor position as described above. The name 140 is the name of the document XML element associated with the action and tool displayed in the document tools panel 135. This name may relate to an outline attached to the document, such as a staff member performance review form, or the name 140 may relate to the XML element where the cursor is currently located. For example, if the cursor is located on the "objects" paragraph, the name 140 may be redisplayed as an "objects section". A display document action 145 depending on the context of the cursor and depending on whether the action is static or dynamic. As described above, the "SubmitReview" action, for example, may be a dynamic action that is not displayed in the document action panel 135 if all required paragraphs of the document 110 have not been completed. The "Last Yeast objects" help topic 133 is displayed in a collapsed display. Selecting "+" expands the help topic to display other sub-topics included. The "Objective Writing Tips" help topic is displayed in an expanded manner, showing the entire content 160 available under this help topic. If an XML element in the document 110 does not have a "smart" document action or tool associated with it, the XML element is not displayed or identified in the document tools pane 135.

The help topics and tools may be nested, meaning that sub-help topics and sub-actions may be included in the help topics and documents tools. If the cursor is nested in multiple elements, then the number of paragraphs in the document tool pane 135 can be greater than two. In this case, the nested elements are displayed in a nested order, i.e., the outermost element is at the top of the document tool pane 135 and the innermost element is at the bottom of the document tool pane 135. If the elements, actions, tools, and help content are not placed within a page, a scroll bar may be provided as shown in FIG. 1, which will extend the entire document tools panel 135. The actions and help content are listed in the order in which the dlls or components that provided them to the document 110 returned their names in response to invocation of the application 100. According to one embodiment, XML elements that are not related to actions, controls, or help topics are not displayed to the user. If displayed, however, all XML elements may be displayed in the panel 135 to let the user know the complete XML structure of the document 110.

Thus, after the document 110 is opened, the "smart" document structure is loaded and implemented as described above, and the user of the document 110 can now enter and complete the document with the help of the "smart" document functionality provided in the document tools pane 135. The user may be provided with help information and tools associated with the portion of the document when the user moves the computer cursor through different paragraphs of the document marked by the XML structure.

It will be apparent to those skilled in the art that various modifications and variations can be made in the present invention without departing from the scope or spirit of the invention. Other embodiments of the invention will be apparent to those skilled in the art from consideration of the specification and practice of the invention disclosed herein.

Claims (40)

1. A method for providing context sensing functionality for a computer-generated document through element association, comprising the steps of:

attaching an outline defining allowable data content, data types and data structures for the document to the document, wherein the outline includes definitions of allowable data content, data types and data structures for a particular portion of the document;

structuring the document to associate the document with the outline;

associating a solution with the document structure;

assembling a set of software components to provide a solution for the document; and

enabling the document to invoke the set of software components to provide a solution for the document based on the edit location in the document,

wherein the document includes a solution property for pointing the document to a particular solution location contained in the outline repository, the solution location providing the document with components or files required to implement the solution, and the document further includes a solution location pointer that can be used to locate a remote source from which the components or files required to implement the solution can be downloaded.

2. The method of claim 1, wherein the step of attaching an outline to the document comprises attaching an extensible markup language (XML) outline to the document.

3. The method of claim 1, wherein the step of structuring the document includes structuring a particular portion of the document to associate the particular portion of the document with permissible data content, data types, and data structures for the particular portion of the document as defined by the schema.

4. The method of claim 3, wherein the step of structuring the particular portion of the document comprises annotating the particular portion of the document with an XML structure.

5. The method of claim 4, wherein the step of annotating the document with an XML structure further comprises defining XML elements associated with particular portions of the document.

6. The method of claim 5, wherein the step of defining an XML element further comprises defining an XML element associated with a set of literal strings in a document.

7. The method of claim 5, wherein the step of defining an XML element further comprises defining an XML element associated with a set of data elements in the document.

8. The method of claim 4, wherein the step of associating a solution with a document structure further comprises associating help content and document tools with an XML structure.

9. The method of claim 8, wherein help content and documentation tools are associated with XML elements that comprise XML structures.

10. The method of claim 4, wherein the step of associating a solution with a document structure further comprises associating a control with an XML structure.

11. The method of claim 10, wherein associating a control with an XML structure comprises associating a radio button, a check box, or a text box with an XML structure.

12. The method of claim 1, further comprising the steps of:

listing the software component in a software component manifest; and

pointers to the list are stored in a software component library.

13. The method of claim 12, wherein the software component library is a schema library.

14. The method of claim 5 wherein the step of enabling the document to invoke the set of software components further comprises the step of attaching a solution attribute to the document, the associating of the set of software components with the document providing the document with the solution.

15. The method of claim 14, further comprising associating solution attributes with XML structures.

16. The method of claim 15, wherein the step of attaching a solution attribute to the document further comprises attaching a set of solution attributes to the document associating a plurality of context-sensing sets of the solution with particular portions of the document.

17. The method of claim 16, further comprising associating each of the solution's context-sensing sets with a corresponding set of XML elements.

18. The method of claim 17, wherein each of the contextually-sensed groups of solutions includes help content or documentation tools associated with each of a set of XML elements.

19. The method of claim 5, wherein upon initiating editing of the document in an XML element associated with the solution, further comprising enabling the document to receive the solution by receiving a call to the solution by the document.

20. The method of claim 1, further comprising the steps of:

a software application that directs opening of a document;

initializing an open document;

determining whether the document references a solution;

determining whether a software component group providing a solution exists in a software component library; and

the software component group is invoked to provide a solution for the document.

21. The method of claim 20, wherein the solution is provided to the document in response to invoking the software component group.

22. The method of claim 20, further comprising determining whether a document references more than one solution.

23. The method of claim 20, further comprising determining whether the document contains a solution attribute that points to a solution.

24. The method of claim 23, further comprising determining whether the document contains a pointer to a solution.

25. The method of claim 24, further comprising determining whether the document contains a context-sensed pointer to a solution.

26. The method of claim 20, further comprising the step of completing the opening of a document having software component set providing functionality available for use by the document.

27. The method of claim 20, further comprising the step of:

document editing focuses on a particular portion of the document;

generating a list of XML elements surrounding an edit focus position;

determining whether there are any available solutions associated with the list of XML elements; and

after determining whether there are any available solutions associated with the list of XML elements, each associated solution is invoked and obtained for use of the document.

28. The method of claim 27, wherein the step of document editing focusing on a particular portion of the document comprises placing a computer cursor in the particular portion of the document.

29. The method of claim 23, wherein the step of determining if there are any available solutions associated with the XML element column further comprises the step of parsing a lookup table of solutions to determine if there are any available solutions associated with any XML element in the XML element column.

30. The method of claim 29, further comprising the step of determining whether any solutions available are dynamic by calling each of a set of software components that contain any solutions.

31. The method of claim 29, further comprising the step of determining a function type associated with each available solution to be displayed to a document user by invoking a set of software components containing available solutions.

32. The method of claim 31, wherein the help content displayed to the user is specified in response to the step of determining a type of functionality associated with the available solutions to be displayed to the user.

33. The method of claim 32, wherein the document tool displayed to the user is specified in response to the step of determining a function type associated with the available solutions to be displayed to the user.

34. The method of claim 31, wherein the controls displayed to the user are specified in response to the step of determining the type of functionality associated with the available solutions to be displayed to the user.

35. The method of claim 34, wherein the controls designated for display to the user include radio buttons, check boxes, and text boxes.

36. The method of claim 27, further comprising the step of:

an XML schema is created that defines a list of document actions, controls, or help content associated with available solutions associated with the XML element list.

37. The method of claim 31, further comprising running a graphical user interface for displaying each solution obtained for use of the document.

38. The method of claim 37, wherein the step of displaying each solution obtained for use of the document includes drawing help content and document tools on a help panel displayable to a user of the document.

39. The method of claim 37, wherein the step of displaying each solution obtained for use of the document comprises drawing a radio button, a checkbox, or a text box on a help panel displayable to a user of the document.

40. The method of claim 11, further comprising a method of implementing an Application Programming Interface (API) that provides solutions for documents, comprising the steps of:

providing a SmartDocXMLTypeCount attribute containing the number of XML element types associated with the solution;

providing a SmartDocXMLTypeName attribute containing a unique identifier of an XML element type associated with the solution;

providing a SmartDocXMLTypeApp attribute containing a title of the XML element displayable to the user;

providing a ControlCount attribute containing a number of controls associated with the solution;

providing a ControlID attribute containing a unique identifier of the control;

providing a ControlTypeFromID attribute containing a control type usable by the solution;

providing a ControlNameFromID attribute, returning a name associated with each control used within the application providing the document;

providing a PoputateRadiogroup method comprising routines and instructions executed to fill in radio control buttons that may be displayed to a user;

providing an OnRadioGroupSelectChange method comprising routines and instructions executed upon selection of a radio control;

providing a PopulateImage method comprising routines and instructions executed to provide an image associated with a solution;

providing an ImageClick method comprising routines and instructions to be executed when an image is selected;

providing a popup documentfragment method comprising routines and instructions executed for displaying data;

providing a PopulateActiveXProps method comprising routines and instructions executed to obtain ActiveX functionality associated with a solution;

providing a PoputateConskBox method, which comprises the steps of providing a routine and an instruction executed by a check box control;

providing an OnCheckbxChange method comprising routines and instructions executed when a checkbox control is selected;

providing a PopulateListOrCombocontent method comprising filling in routines and instructions executed by a listbox control;

providing a OnListOrCombo SelectChange method comprising routines and instructions executed upon selection of an item of a listbox control;

providing a PopulateTextboxContent method comprising filling in a routine and an instruction executed by a textbox;

providing an OnTextContentChange method comprising routines and instructions executed to process events associated with a content change of a textbox control;

providing a postlatehelmontent method comprising filling in routines and instructions executed by a help content field with data; and

an InvokeControl method is provided that includes routines and instructions that are executed when a control is selected.