Process enaction and tool integration via a task oriented paradigm

Abstract

A task manager for providing personal organization, project management, and process automation capabilities. The task manager maintains a hierarchical list of tasks for an individual. For each task, notes can be kept, priorities set, and progress tracked. Also, subsets of the task hierarchy can be shared. Every task in the task manager belongs to a class, and each class includes pre-defined automatic actions and manual actions. The pre-defined automatic actions are automatically executed by the task manager when the task is being worked on. The manual actions aid in task execution because the relevant operations (that is, the manual actions) are available when the task is being worked on. The task manager communicates with agents, tools, and process engines via a message system. The agents, tools, and process engine may receive task information from the task manager and may also remotely control the task manager.

Claims

What is claimed is:

1. A computer system for managing task, comprising:

a task database for storing and organizing said tasks, each task having a hierarchy of subtasks for modeling a human process wherein said tasks have task information;

means for defining and creating instances of task classes, wherein each of said tasks belongs to one of said task classes, and wherein each of said task class have associated pre-defined automatic actions and optional manual actions;

a task manager, coupled to said task database, the maintains a hierachical list of said tasks for an individual, wherein said task manager comprises

a user interface for interfacing with said tasks,

means for enabling a user via said user interface to manually select one of said tasks to process;

means for enabling a computer to automatically selected one of said tasks to process;

means for performing said automatic actions corresponding to said manually or automatically selected task via the computer, wherein said automatic actions are invoked automatically by said task manager at specific times,

means for enabling said user to select one of said optional manual actions corresponding to said manually or automatically selected task, wherein said user can select one of said optional manual actions at any time while said task manager processes said manually or automatically selected task,

means for performing said optional manual action selected by said user via the computer,

means for enabling user interaction with said manually or automatically selected task via the computer, and

means for automatically updating said task information based on said processing of said task via the computer; and

means for sharing said tasks and said subtasks with external entities and/or other task managers via the computer, wherein said sharing means comprises means for transferring structured electronic mail messages to users and non-users of said task manager via the computer.

2. The system of claim 1, further comprising a message coupled to said task manager.

3. The system of claim 2, wherein said message system comprises:

network means, coupled to external entries and said task manager, for allowing communication between said external entities and said task manager; and

message interface means for allowing said external entities to remote control said task manager.

4. The system of claim 3, wherein said message interface means comprises means for exporting said task information to said external entities.

5. The system of claim 3, wherein said message interface comprise means for enabling said external entities to create, delete, modify and share said tasks.

6. The system of claim 2, further comprising a process engine coupled to said message system and said task manager.

7. The system of claim 1, wherein said updating means comprises:

an estimated completion time attribute;

a scheduled time attribute;

a task deadline attribute;

an actual time attribute;

a status attribute; and

a time of last status update attribute.

8. The system of claim 7, wherein said updating means comprises:

means for automatically accuring a user's effort as measured in time of said selected task via the computer; and

means for automatically storing said user's effort as measured in time in said actual time attribute via the computer.

9. The system of claim 7, further comprising means for automatically archiving said tasks based on said status attribute and said time of last status update attribute via the computer.

10. The system of claim 1, wherein said user interface comprises:

a task list region for displaying a list of said tasks;

a status and operations region for displaying a first set of functions to be used by a user to access a specific task; and

a menu bar region for displaying a second set of functions used by said user of processing said specific task.

11. The system of claim 1, wherein said user interface comprises:

means for enabling said user to create said tasks;

means for enabling said user to delete said tasks;

means for enabling said user to modify said task information;

means for displaying said tasks to said user according to said task information; and

means for providing task completion and scheduling advice to said user.

12. The system of claim 1, further comprising means for facilitating access to one or more of said optional manual actions.

13. The system of claim 1, wherein said task information comprises pre-defined and user-defined attributes.

14. The system of claim 1, wherein said task database is distributed such that other task managers have a copy of said task database.

15. The system of claim 1, wherein said tasks have associated notes and priorities.

16. The system of claim 1, further comprising means for sharing said tasks and said subtasks between individuals, whereby changes made to said tasks and said subtasks can by synchronized between said individuals via the computer.

17. The system of claim 1, further comprising a library of task templates that aid said user in creating new tasks, wherein said task templates include pre-defined task information.

18. The system of claim 1, further comprising means for recording pre-defined and user-defined attributes, corresponding to activities of user, involved in the completion of said selected task.

Description

A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent disclosure, as it appears in the Patent and Trademark Office patent files or records, but otherwise reserves all copyright rights whatsoever.

BACKGROUND OF THE INVENTION

1. Field Of The Invention

The present invention relates generally to task management, and more particularly to a computer-based system and method for achieving task management.

2. Related Art

Computer-based tools having limited task management capabilities exist today. These existing tools essentially fall into three categories.

The first category is typified by "Lotus Agenda" and provides for management of task-related data. Tools which fall into this first category are limited in that they do not define hooks to the actual work performed or to project management tools. For example, they cannot automatically track time spent executing tasks. Additionally, tools which fall into this first category are limited because they do not include triggers for automatically initiating actions in the computing environment based on the task which is currently being performed.

The second category is typified by any number of project management tools which are on the market today, such as "XPM" and "Viewpoint." Tools which fall into this second category provide for project tracking, project estimation, and "what if?" analysis. However, these second category tools are limited because they do not include triggers for automatically initiating actions in the computing environment based on the task which is currently being performed. Also, they usually do not provide automatic tracking of time spent executing tasks. Additionally, data entered into these second category tools can only be used by the tools themselves. Such data cannot be easily exported and used by other tools. In general, these systems provide assistance to the project manager but not the task implementer.

The third category is typified by a Columbia University MARVEL project. The Columbia University MARVEL project is described in "Experience with Process Modeling in the Marvel Software Development Environment Kernel" by Gail Kaiser, Naser S. Barghouti, and Michael H. Sokolsky (23rd Annual Hawaii International Conference on System Sciences, January 1990, pages 131-140). In this third approach, a relatively elaborate process engine is used with a process description language for describing software processes including constraints and enactable components. However, systems which fall into this third category are flawed because they use ad hoc mechanisms (or none at all) for communicating with users. In fact, many such third category systems operate entirely without terminals and thus have no mechanism for providing interactive communication with users. Thus, they poorly handle enaction of processes involving manual steps.

SUMMARY OF THE INVENTION

The task manager of the present invention is a computer-based system and method for managing tasks. The task manager is helpful for organizing and coordinating a user's work. The task manager takes project definitions (in the form of task lists) for multiple projects and provides facilities which aid groups of individuals in actually performing the defined tasks.

The task manager provides personal organization, project management, and process automation capabilities. The task manager is very useful when used by a single individual. The task manager is even more; useful when used by teams of people who need to communicate information and responsibility in the progress of their work.

The task manager maintains a hierarchical list of tasks for an individual. For each task, notes can be kept, priorities set, and progress tracked. Also, subsets of the task hierarchy can be shared for constructing project wide views to allow effective project management. To support group work, tasks can be shared between individuals, while keeping changes synchronized between them.

Every task in the task manager belongs to a class, and each class includes pre-defined automatic actions, manual actions, and data relevant to the task. The pre-defined automatic actions associated with a task are automatically executed by the task manager when the task is being worked on. The manual actions aid in task execution because the relevant operations (that is, the manual actions) are available when the task is being worked on. Users can define their own classes with their own actions to model the types of tasks they encounter in their work situations.

The task manager communicates with agents, tools, and a process engine via a message system. The agents, tools, and process engine may receive task information from the task manager and may also remotely control the task manager. Thus, by allowing two-way communication with the entities that are used for performing work (that is, the agents, tools, and process engine), the task manager may be used to perform complex activities.

FEATURES AND ADVANTAGES OF THE INVENTION

The task manager of the present invention includes the following features and advantages.

The present invention provides for direct interaction between users and their tasks. Thus, the present invention may support user's tools and processes to provide traceability between tasks and their artifacts.

The present invention provides for communication of tasks among individuals performing the tasks without losing semantic information.

The present invention provides for task classes.

The present invention associates automatic actions with tasks, wherein the automated actions accomplish or contribute to the accomplishment of the tasks.

The present invention provides for task scheduling and sequencing advice.

The present invention supports task templates wherein generalizations of kinds of tasks and task hierarchies are predefined in text files. Users may create tasks and subtasks from scratch or by using the task templates.

The present invention provides for action inheritance over a task hierarchy.

The present invention accrues actual time spent on tasks and estimates completion time for tasks.

The present invention interacts with external tools (such as project management tools, report generators, and electronic appointment books) such that these tools may generate reports and perform other functions using the task information stored by the task manager of the present invention.

The present invention provides for a message interface wherein the functions of the present invention may be remotely invoked.

The present invention provides for different filtering options for displaying task lists.

Further features and advantages of the present invention, as well as the structure and operation of various embodiments of the present invention, are described in detail below with reference to the accompanying drawings. In the drawings, like reference numbers indicate identical or functionally similar elements.

BRIEF DESCRIPTION OF THE DRAWINGS

The present invention will be described with reference to the accompanying drawings, wherein:

FIG. 1 illustrates a computer system in which a task manager of the present invention operates.

FIG. 2A illustrates an overall architecture of the task manager of the present invention.

FIG. 2B illustrates a first connectivity architecture of the present invention.

FIG. 3 illustrates a user interface according to a preferred embodiment of the present invention.

FIG. 4 illustrates five menu categories and their respective functions according to a preferred embodiment of the present invention.

FIG. 5 illustrates a second connectivity architecture of the present invention.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

1. Overview

In a preferred embodiment, the task manager of the present invention is a computer program 122. FIG. 1 illustrates a computer system 102 in which the task manager 122 operates.

The computer system 102 includes a computer platform 104 having various hardware components 108. The hardware components 108 include a random access memory (RAM) 110, a central processing unit (CPU) 112, and an input/output interface 114. Various peripherals may be connected to the computer platform 104, such as an "X window system" terminal 116, data storage device 118, and a printer 120. Also, data entry devices may be connected to the computer platform 104. In the preferred embodiment of the present invention, such data entry devices would be a keyboard and a mouse.

The computer platform 104 also includes an operating system 106.

In the preferred embodiment of the present invention, the computer platform 104 is an "Hewlett Packard (HP) 9000/Series 400 Workstation." The operating system 106 is an "HP-UX" operating system. The task manager 122 is written in the C++ computer programming language. The present invention uses the "HP SoftBench" platform for the messaging system.

Various computer programs operate on the computer platform 104. These computer programs include the task manager 122 of the present invention. These computer programs also include tools 124, agents 126, and a process engine 128.

The tools 124 are user-interactive programs such as editors, compilers, and debuggers.

The agents 126 are similar to tools 124, except agents 126 operate autonomously. An intelligent mail program is an example of an agent 126. A user may instruct the mail program to monitor, sort, and prioritize all incoming electronic mail. The mail program would then operate autonomously to process the user's electronic mail.

The process engine 128 includes a process administration support tool which allows specification of a process. The process engine 128 can be viewed as a collection of agents. The process engine 128 interprets a process modeling language to enact the process.

FIG. 2A illustrates an overall architecture of the task manager 122 of the present invention. As shown in FIG. 2A, the task manager 122 may communicate with a human operator 201, a process engine 128, the tools 124, and the agents 126. When communicating with the process engine 128, tools 124, and agents 126, such communication is over a message system 202. Communication with the user 201 is via a user interface 302 (discussed below). Both the task manager 122 and the process engine 128 may have direct access to a persistent task database 204.

The message system 202 may be implemented using any communication system which allows data and commands to be transferred between the task manager 122, tools 124, agents 126, and process engine 128. The message system must allow tools (such as the task manager 122), agents, and the process engine to send requests to each other for specific operations, and must allow tools to notify one another of completion of operations. The message functionality should mimic most functionality available through the user interface.

The message system 202 may be implemented, for example, as a broadcast message server (BMS). The BMS is described in a commonly assigned and pending patent application entitled "Method And Apparatus For Communicating Between Tools In A Computer Aided Software Engineering System" (Ser. No.: 07/359,309; Filing Date: May 31, 1989), which is herein incorporated by reference in its entirety.

As shown in FIG. 2A, the task manager 122 interacts with a persistent task database 204. The persistent task database 204 is a backing store for tasks.

According to the present invention, the task manager 122 is the users' primary interface to tasks. Users operate the task manager 122 to create, execute, and delete tasks. An extensible library of task templates exist for aiding users in creating new tasks.

According to the present invention, users may create tasks having specific actions. The task manager 122 aids users in executing the tasks by automatically performing the actions associated with the tasks. For example, if a user selects a "Write Daily Report" task, the task manager 22 may automatically invoke the user's text editor on the appropriate file. If the user selects a "Compile Program" task, the task manager 122 may automatically invoke the user's compiler.

These, and other, aspects of the present invention are described in greater detail below.

2. Task Structure

A task represents a piece of work which needs to be done. A task is defined by pre-defined and user-defined attributes. The pre-defined and user-defined attributes collectively model the work which the task represents.

This section describes the pre-defined attributes. Every task includes at least the pre-defined attributes. The user-defined attributes are described in the following section.

2.1. Title

The task manager 122 automatically assigns a title to a task when the task in created. Users can change the task's title at any time. The title is displayed in a task list 308 (see FIG. 3) and is generally used in all human-readable reports generated from the task manager 122. However, the title is not otherwise interpreted by the task manager 122 (the user is free to use any appropriately descriptive title).

2.2. Unique name

The task manager 122 automatically generates a unique name for a task when the task is created. The unique names are unique identifiers used internally by the task manager 122 to identify tasks. The unique names are globally unique. Thus, the unique names never need be changed, even when tasks are shared with different machines. Messages from the tools 124, agents 126, and process engine 128 refer to tasks using their unique names. Also, whenever a task needs to refer to other tasks (such as parents and children in the hierarchy), the unique names are used.

2.3. Class

This attribute identifies a class of a task. A task's class is selected by the user when the user creates the task or by a template when tasks are created according to the template. According to the present invention, a task class may have multiple actions (also called methods). Tasks having the same task class have the same actions (that is, those defined for the task class). A task class is a generic class if the task class has no actions. Task classes are described further below.

2.4. Type

This attribute is a name for a particular series of process steps. The type attribute is a logical mechanism for defining the work that a person performs. For example, an attribute value "bench.sub.-- review" may be assigned for work involving code review which is done at an engineer's desk/lab bench. The class attribute, discussed above, is an implementation mechanism for assigning actions with tasks having certain types. Thus, the distinction between a type and a class is that a class is an implementation mechanism for associating actions with types of tasks.

2.5. Task Parent(s)

If a task is a subtask (that is, a task whose completion is part of completing a parent task), then this attribute refers to the parent task.

2.6. Children

This attribute comprises a list of subtasks into which this task has been decomposed.

2.7. Task Creator

This attribute identifies the creator of the task. In the preferred embodiment of the present invention, this attribute is the user's name or agent 126 who created the task.

2.8. Time Estimate

This attribute is a time estimate for the completion of the task.

2.9. Actual Time

This attribute is the actual time spent working on the task. The task manager 122 automatically updates this attribute. This attribute is the sum of the Per User Actual Times and the Non-tracked Actual Time, discussed below.

2.10. Non-tracked Actual Time

This is the time, entered by the user, which indicates the amount of time spent on the task which was not tracked by the task manager 122. This attribute may represent time spent working on the task before the task was entered into the task manager 122.

2.11. Per User Actual Time

This attribute is the actual time which has been spent working on the task (and which has been tracked automatically by the task manager 122). An entry is maintained for each user who has worked on the task. The actual time spent by each user is added together and stored in the user's entry.

The task manager 122 also maintains a tasktimelog file for each user. The tasktimelog file contains a series of entries each having the Unique name of a task, and the start and end time of an execution of that task. The tasktimelog file, however, is not stored with the tasks.

2.12. Task Deadline

This is a deadline for completing the task. The deadline is in a time/date format. The task manager 122 may generate an alarm when a task deadline is approaching. Alternatively, a tool 124 such as an appointment calendar program may request and receive this information. Also, this attribute is available for an Advise Next Task function, discussed below.

2.13. Scheduled Time

This attribute applies for tasks which are scheduled to occur during a specific time range, such as a meeting. A tool 124, such as an appointment calendar program, may request and receive this information from the task manager 122.

2.14. Creation Time

This attribute lists the time that this task was initially created. This information may be requested and received by a tool 124, such as a report generator, in order to perform query/report functions. It is not used directly by the task manager 122.

2.15. Time of last Status update

This attribute lists the time that this task's status was last changed. This attribute is used for automatic archival of tasks. This attribute is also used for determining when a task was completed. Thus, tools 124, such as a report generator, may request and receive this information in order to create a monthly summary report.

2.16. Note Pages

This attribute is a list of named note pages. The note pages may contain any text and/or graphics and may be viewed via a Task:Notes . . . menu item, described below.

2.17. Priority

A numeric priority is attached to each task. The priorities may be displayed in the task list window 308, and are typically used by the Advise Next Task function (described below). Tools 124, such as a report generators, may also request and receive this information.

2.18. Status

Each task will have a status assigned by the user. Status values include Complete, Ongoing, New, and Abandoned. A user's flexibility in setting this attribute is limited by constraints such as "no task may be marked Complete unless all its children are Complete." Status is used in filtering the task list display 308. Status may be requested, received, and used by tools 124 such as report generators to generate monthly reports. Status is used with the Time of last Status update attribute for automatic archiving. For example, a task may be automatically archived to permanent storage when the task's Status is Complete, and the task's Status has not been updated (as indicated by Time of last Status update) for a predefined amount of time.

2.19. Viewed By

This attribute identifies users who have access to view the task. This attribute also indicates whether the users have read-only or read-write access to the task. This attribute also lists Locales (described below). In the preferred embodiment of the present invention, the format of this attribute is as follows: user name, machine (such as an electronic mail address), access flag, and Locale name.

2.20. Owner

This attribute identifies the user who has primary responsibility for the task. This is generally used as a filter upon the tasks so that users may view only their own tasks and generate reports based on them.

2.21. Accepted

This attribute is a flag for indicating whether a task whose ownership was changed has been accepted by the new owner.

2.22. Urgent

This is a flag for indicating whether the task is urgent. It is viewable in the task list 308 as an indicator, and is used by the Advise Next Task function (described below). It is also used for external report generation (such as generating a "to do" list).

2.23. Version

This is a sequence number which is used to determine which version of a task is the most recent. This is used in a synchronization protocol to ensure that an old version of a task does not overwrite a new version of the task when tasks are shared (described below).

2.24. Repository Version

When a task is created, the version number of the task manager 122 is stored in this attribute.

3. User-defined Attributes

The user may add additional attributes to tasks as well. These are described below.

User-defined attributes are in the following form: Name=Value.

Any number of user-defined attributes may be attached to a task.

Pre-defined and user-defined attributes may be set and retrieved in the same way by tools 124 and agents 126. Thus, tools 124 and agents 126 may store and access information about the task by setting and retrieving the task's attributes.

The user-defined attributes may be shared by all users viewing the task, or may be private to a single user. Attributes are private by default, and must be exported to be shared by all users viewing a task.

User-defined attributes may be used to affect display and report generation. For instance, a task may have an attribute "Objectives=Summarize" to indicate that the task should be summarized in an objectives report. A tool 124, such as a report generator, could request that the task manager 122 send it all tasks having the attribute "Objectives=Summarize."

Likewise, attributes may be applied for grouping purposes in order to allow operations on all tasks with a given attribute value (such as a request in the Advise Next Task command to suggest the next task to be started among those tasks having an user-defined attribute "Category=System-Administration").

4. Task Database

The tasks are stored and organized in a task database. The task database may be implemented as either a full database application (such as "ONTOS", "Objectivity", or "PCTE") or a primitive filesystem database (such as a directory per task list and a file per task). The task database may be implemented as either an object-oriented, relational, or entity-relationship database. Such full database applications and primitive filesystem database approaches are well known to those skilled in the art.

The task database may be located in a central database or may be distributed such that each task manager 122 (either operating on the same or different computer platforms) has a copy of the task database.

In the preferred embodiment of the present invention, the task database is distributed such that each task manager 122 has a subset of the task database. The present invention includes a mechanism for transferring synchronized portions of the task database among the task managers 122. This mechanism is necessary for sharing tasks between the task managers 122 and is described further in Section 9.

A task's attributes (both pre-defined and user-defined) are either shared or private. Shared attribute values will be the same for all users who have access to the task (access is granted via the Viewed By attribute). Private attribute values may be different for each viewer of the task. Therefore, copies of the shared attributes must be stored in the task databases associated with all users who have access to the task. Each viewer's private attributes only needs to be stored in his/her own task database. Shared attribute values are synchronized between all viewers' databases, while private attribute values appear only in the databases to whom they belong.

5. Task Classes

Users may define task classes according to the class structure described in this section. Each task class may be associated with multiple actions. When creating a new task, it is created as one of the predefined task classes. The new task then has the actions associated with the predefined task class.

A class definition is a C++ specialization of the C++ generic "Task" class, with appropriate class constructor functions as well as virtual functions defined for any of the hook functions (which are described below).

The task classing mechanism is implemented using C++ objects. Class; definitions are stored in C++ source and compiled using a C++ compiler. The object files may be dynamically loaded into a running Task Manager 122. Alternatively, the object files are linked into a full executable Task Manager 122. Not all users wishing to customize a process will require adding new task classes, as task templates (discussed below) with existing classes may be sufficient.

The class structure contains member functions for several different types of actions: start, receive, create, send, delete, resume, deadline reached, schedule date reached, and status change. These actions are called pre-defined automatic actions because they exist in every class structure.

The class structure also includes manual actions. The manual actions are in the form of label/action pairs and are placed in a registry table. The manual actions also include a flag for indicating whether the manual actions are inherited over the task hierarchy (that is, by descendants). Those manual actions in the registry table are added to and accessible from an actions menu 318 (described below).

Actions (both pre-defined automatic actions and manual actions) are specified as functions or method calls in C++. Appropriate accessor functions are available for accessing the data objects (which are required by the actions) in the current task. In addition, system() and send.sub.-- message() functions are provided. System () is a "Unix" command. Send.sub.-- message() is used to send a message (request/notification) to another tool using the message system.

The pre-defined automatic and manual actions are created consistent with the functionality and purpose of their respective task classes. Thus, for some task classes, some (or even all) of the pre-defined automatic actions may not perform any operations. Also, some tasks may not include any manual actions.

The pre-defined automatic actions are described in the following paragraphs.

A CreateAction(Boolean interactive) pre-defined automatic action is automatically invoked by the task manager 122 when a task is created. The Boolean interactive flag indicates whether the task was created via the user interface 302 (described below) or the message interface.

The CreateAction pre-defined automatic action may create subtasks which are always part of executing tasks of that class. Thus, CreateAction may create a class hierarchy. For example, for an "attend conference" task which always includes two subtasks (such as "actual attendance" and "writing trip report"), CreateAction might create the subtasks (that is, "actual attendance" and "writing trip report") automatically whenever the parent task (that is, "attend conference") is created.

An EditAction() pre-defined automatic action is automatically invoked by the task manager 122 when the user wants to edit class data. EditAction() may cause a dialog box to appear to allow the user to edit any class-specific attributes which are accessible via the Task/Edit . . . menu function (described below).

A DeleteAction() pre-defined automatic action is automatically invoked by the task manager 122 upon the deletion of a task. DeleteAction() may include a function to send a message to a tool 124, such as an appointment calendar program, to inform the tool 124 that the task has been deleted. Upon receiving the message, the appointment calendar program would remove a corresponding alarm if one had ever been created for the task (such as for a meeting or deadline).

A ReceiveAction() pre-defined automatic action is automatically invoked by the task manager 122 when a task is received via the message system 202. In a "Compile Program" task, for example, ReceiveAction() may include a function to automatically compile a program.

A SendAction() pre-defined automatic action is automatically invoked by the task manager 122 when the task is sent to the message system 202. Some tasks may want to log all send actions to a file in order to allow the sender to know which tasks of that type he is sending. This might be related to certain checkpoint approval type tasks where traceability is critical. For these tasks, SendAction() would perform such logging functions.

A StartAction() pre-defined automatic action is automatically invoked by the task manager 122 when the task is started (that is, the task was in the New state and is executed). StartAction() may invoke an editor or may send messages to a tool 124, such as a report generator, when its corresponding task is executed.

A ResumeAction() pre-defined automatic action is automatically invoked by the task manager 122 when the task is resumed (that is, the task was not in the New state and is executed). ResumeAction() generally has the same functionality as StartAction(). However, some activities may only make sense to perform the first time a task is run (such as resolving a defect). Such activities would be executed by StartAction() but not ResumeAction().

A DeadlineAction() pre-defined automatic action is automatically invoked by the task manager 122 when a task deadline is reached. The task deadline is stored in the Task Deadline attribute. DeadlineAction() may generate an alarm or to create a new task to process the deadline.

A ScheduleAction() pre-defined automatic action is automatically invoked by the task manager 122 when a scheduled start time is reached. Scheduled start times are stored in the Scheduled Time attribute. ScheduleAction() may generate an alarm.

A StatusChangeAction() pre-defined automatic action is automatically invoked by the task manager 122 when the task's status is changed. The task's status is stored in the Status attribute. StatusChangeAction() may start another task when the status of the current task changes to Complete.

As noted above, these pre-defined automatic actions are automatically executed by the task manager 122 at particular times. For example, consider a task to examine a defect in the process of fixing the defect. StartAction() and ResumeAction() may operate to display a defect report for that particular defect.

The present invention also defines two additional pre-defined automatic actions:

WriteClassData(ostream&,const StrArray * const)const

Boolean ReadClassData(istream&,const Str *const, Boolean assignment.sub.-- flag=TRUE)

WriteClassData() and ReadClassData() are used for writing and reading class specific data. Thus, these actions are used for saving class specific state information for a task.

As noted above, the class structure also includes manual actions. The manual actions (which are in the registry table) are accessible from the actions menu 318. When executing a task, the actions menu 318 is only available when the task's task class includes manual actions. The action menu 318 displays a list of labels corresponding to C++ functions which correspond to the manual actions defined for the current task's task class. Users may execute a manual action by selecting the manual action in the action menu 318. Thus, the action menu 318 facilitates the processing of tasks by acting as a repository of functions (that is, the manual actions) which are often used by users while processing the tasks.

Note that the distinction between the manual actions and predefined automatic actions are that the manual actions are available any time while executing the task (from the action menu 318), and are never invoked automatically, whereas the pre-defined automatic actions are invoked automatically by the task manager 122 at specific times.

An example of a task class structure is shown below in Table 1. In the following, CreateAction(), StartAction(), EditAction(), ResumeAction(), WriteClassData(), and ReadClassData() are described above. RunAction() is an example of a manual action. ActionTable() is the registry table for the manual actions.

                  TABLE 1
    ______________________________________
    /***********************************************************
     * File:       ClassExecute.h
     * Description:
              Defines "Execute" class of tasks (for executing a
     *               random command via system).
     Language:
              C++
     **********************************************************/
    #ifndef
           CLASSEXECUTE.sub.-- H
    #define
           CLASSEXECUTE.sub.-- H
    #include <Str.h>
    class ClassExecute : public Task {
    Str .sub.-- exec.sub.-- sting;
                     // Sting to pass to system();
    public:
    ClassExecute();
    virtual void   CreateAction(Boolean);
    virtual void   StartAction();
    virtual void   EditAction();
    virtual void   ResumeAction();
    virtual const Actions& ActionTable() const;
    virtual Boolean WriteClassData(ostream&, const Str &,
            Boolean);
                     // invoked to write task to
                       stream
    virtual Boolean ReadClassData(istream&, char *attrib,
            int attrib.sub.-- size, Boolean assignment.sub.-- flag-
            TRUE);
                     // invoked to read task to
                       stream
    const Str exec.sub.-- string() const;
    void exec.sub.-- strin(const Str&);
    };
    inline const Str ClassExecute::exec.sub.-- string() const
    return.sub.-- exec.sub.-- string;
    }
    inline void ClassExecute::execstring(const Str& s)
    {
    .sub.-- exec.sub.-- string = s;
    }
    #endif
    /*******************************************************
     * File:       ClassExecute.C
     * Description:
              implements execute class (calls system on
     *               exec.sub.-- string)
     * Language:     C.sup.++
    *************************************************/
    #include <stdlib.h>
    #include <Xm/Xm.h>
    /* declares functions, such as TmPromptUser, which allows
    interaction with users via dialog boxes.*/
    #include "dialogs.h"
    * defines the task base class*/
    #include "Task.h"
    /* declares a repository of services, such as SaveTask, for
    managing tasks */
    #include "TaskRepository.h"
    #include "ClassExecute.h"
    //
    // Create an object of the Unknown class
    //
    Task *CreateExecuteClass()
    {
    return new ClassExecute;
    }
    //
    // Class constructor
    //
    ClassExecute::ClassExecute()
    {
    .sub.-- class.sub.-- name = "Run.sub.-- Action";
    }
    void system.sub.-- add(Widget, void *task, char *exec+str)
    {
    ClassExecute *t = (ClassExecute *) task;
    t.fwdarw.exec.sub.-- string(exec.sub.-- str);
    }
    void ClassExecute::CreateAction(Boolean interactive)
    {
     if (interactive)
            TmPromptUser(NULL, "Command String",
            "What is your execution
                 string: ", NULL
                 (XtCallbackProc) system.sub.-- add,
                 (caddr.sub.-- t) this);
    }
    void ClassExecute::StartAction()
    {
    system(.sub.-- exec.sub.-- string);
    }
    static void EditActionCB(Widget, ClassExecute *e, char *st)
    {
    if(str != NULL)
    {
            if(e.fwdarw.exec.sub.-- string() != str)
            {
                 e.fwdarw.exec.sub.-- string(str);
                 task.sub.-- base.fwdarw.SaveTask(*(Task *)e);
            }
    }
    }
    void ClassExecute::EditAction()
    {
    TmPromptUser(NULL,"Cmmand String", "Execution
    String: ",
    exec.sub.-- string(),
    (XtCallbackProc) EditActionCB, (caddr.sub.-- t)this);
    }
    void ClassExecute::ResumeAction()
    {
    system(.sub.-- exec.sub.-- string);
    }
    Boolean ClassExecute::WriteClassData(ostream& out, const
    Str &sa,
    Boolean /*for.sub.-- sharing*/)
    {
    if (sa == NULL .vertline. .vertline. sa == "Execute-string")
    {
            out <<"Execute-String: " << .sub.-- exec.sub.-- string
            <<' n';
            if(sa !=  NULL)return TRUE;
    }
    return FALSE;
    }
    Boolean ClassExecute::ReadClassData(istream& in, char *atttrib,
    int attrib.sub.-- size, Boolean /*assignment.sub.-- flag*/)
    {
    if(strcmp(attrib, "Execute-String") == 0)
    {
            in.get(attrib, attrib.sub.-- size);
            .sub.-- exec.sub.-- string = attrib;
            return TRUE;
    }
    return FALSE;
    }
    void RunAction(Task &t)
    {
    system(((ClassExecute &) t).exec.sub.-- string());
    }
    const Actions& ClassExecute::ActionTable() const
    {
    static actions execute.sub.-- action.sub.-- table[]= {{"Rerun
    Command",
            RunAction},{NULL, NULL}};
    static Actions ret = { FALSE, execute.sub.-- action.sub.-- table };
    return ret;
    }
    ______________________________________
    Copyright HewlettPackard Company, 1991, All Rights Reserved

                  TABLE 2
    ______________________________________
    # 1st field:
            numbered by section and subsection to show
            hierarchy
    # 2nd field:
            Task title
    # 3rd field:
            estimated time in days
    # 4th field:
            non-tracked actual time (not normally used)
    # text between titles: note associated with each task
    1 Inspection: DESCRIPTION
                           0      0
    1.1 inspection kickoff meeting
                         .0625    0
    1.2 inspection preparation
                         .375     0
    Read all code and supplemental materials. Use checklist to
    monitor for omissions and certain classes of defects. Record
    amount of preparation time (from task manager or elsewhere).
    1.3 inspection meeting
                         .375     0
    ______________________________________
    Copyright HewlettPackard Company, 1991, All Rights Reserved

                  TABLE 3
    ______________________________________
    Message-Id:<9004042019.AA122.03
               @hpfcjrd.sde,hp.com>
    To:task-manager@hpfcjrd.sde.hp.com
    Subject:task delegation
    Date:Wed, 04 Apr 90 14:19:11 MDT
    From:Tim <twt@hpfcjrd.sde.hp.com>
    FROM twt@hpfcjrd.sde.hp.clm
    DESTINATION john@hpfcjrd.sde.hp.com
    BEGIN-UPDATE
    BEGIN-TASK
    BEGIN-TASKDATA
    Class:Unknown
    Name:33779hpfcgt-gary
    Version:13
    Time-Estimate:3
    Initial-Actual-Time:0
    Per-User-Time-Total:gary 10800
    Per-User-Time-Total-jenings 0
    Parents:33716hpfcgt-gary
    Title:fix XeInitialize core dump in XmPutResource
           when using color object
    Owner:gary
    Creator:gary
    Creation-Time:1991-03-19 09:23:23 MST
    Accepted:True
    Status:Completed
    Last-Status-Change:1991-03-27 13:44:25 MST
    Priority:70
    Urgent:False
    Viewed-By:gary@hpfcgt.sde.hp.com True myLocale
    Viewed-By:diamant@hpfcjrd.sde.hp.com True
           myLocale
    Viewed-By:gerety@hpfccg.sde.hp.com True myLocale
    Viewed-By:twt@hpfcjrd.sde.hp.com True myLocale
    END-TASKDATA
    END-TASK
    END-UPDATE
    ______________________________________
    Copyright HewlettPackard Company, 1991, All Rights Reserved

• Inventors
  Diamant, John R.; Thunquest, Gary L.;
• Assignee
  Hewlett-Packard Company (Palo Alto, CA)
• Published
  Jun-25-1996
• Current US Classes:
  705/8
  705/9
  707/1
• Application #
  345874
• International Classes
  G06F 009/46
• Field of Search
  395/650 364/DIG.
• Examiner
  Heckler; Thomas M.
• US Patent References:
  4658351
  4807142
  4825354
  4901225
  4951190
  5423023