Method and system for processing fields in a document processor

Abstract

A method and system for providing calculated fields in a document processing environment. A calculated field comprises a beginning field character, a field code, and an ending field character. The field code specifies a behavior of the calculated field. A user may insert a calculated field into a document. After insertion, the result of the calculated field can be determined based on the behavior specified by the field code. The result of the calculated field is then stored within the document and preferably within the calculated field. The document can be displayed in either field code or results mode. In field code mode, when the document is displayed, the calculated field is displayed (i.e., beginning field character, field code, and ending field character). In results mode, when the document is displayed, the result is displayed, rather than the calculated field.

Claims

We claim:

1. An improved method of processing fields in a document processor, comprising the steps of:

inputting a plurality of characters organized as a string of text into the document processor;

inserting a field in said string of text, said field comprising a beginning field character, a field code, and an ending field character, said field code specifying a behavior of the field;

placing said string of text in a document;

determining a result of said field based on said behavior specified by the field code; and

storing said result in said field within said document that contains the placed string of text having inserted field.

2. An improved method of processing fields in a document processor, comprising the steps of:

inputting a plurality of characters organized as a string of text into the document processor;

inserting a field in said string of text, said field comprising a beginning field character, a field code, and an ending field character, said field code specifying a behavior of the field;

placing said string of text in a document; and

determining a result of said field based on said behavior specified by the field code by further performing the steps of:

detecting said beginning field character and calculating a character position of said beginning field character;

looking up said calculated character position in an array of character positions of field characters;

using an index of said calculated character position in said array as the index in an array of field descriptors;

using a field type stored in said field descriptor as an index into an array of field functions;

executing said field function indicated by said index into said array of field functions to effect the behavior of the field code; and

storing said result in said field within said document.

3. A method in a computer system of adding a result to a field in a document, the field having a field code, the method comprising the steps of:

retrieving the field code from the field;

determining a result of the field code; and

storing the determined result into the document that contains the field having the field code.

4. The method of claim 3 including the step of adding a separator field character to the document to separate the field code from the toted result.

5. The method of claim 4 wherein the field has a beginning field character before the field code and an ending field character after the result.

6. A method in a computer system of adding a result to a field in a document, the field having a plurality of field codes, the method comprising the steps of:

retrieving the plurality of field codes from the field, the field codes containing a system switch indicating non-default behavior for the field;

determining a result of the field codes including effecting the non-default behavior in accordance with the system switch; and

storing the determined result in the document.

7. A method in a computer system of adding a result to a field in a document, the field having a plurality of field codes, the method comprising the steps of:

retrieving the plurality of field codes from the field, the field codes containing a keyword and a keyword-specific switch, the keyword-specific switch indicating a non-default behavior for the field;

determining a result of the field codes including effecting the non-default behavior in accordance with the keyword-specific switch; and

storing the determined result in the document.

8. A method in a computer system for storing a field within a document, the document comprising a stream of data, the field having a field code and a result, the method comprising the steps of:

storing the field code within the stream of data;

determining the result of the field based on the stored field code; and

storing the determined result within the same document that contains the stream of data having the field code.

9. A method in a computer system of nesting a second field within a first field within a document, each field having a plurality of field codes, the method comprising the steps of:

adding the first field to the document;

inserting the second field as a field code of the first field wherein a result of the second field specifies a field code of the first field;

determining a result of the first field; and

storing the result of the first field in the document that contains the first field.

10. A method in a computer system of nesting fields within a document, the method comprising the steps of:

adding a first field to the document, the first field having a plurality of field codes, the field codes indicating a function to perform to generate a result;

performing the function indicated by the field codes of the first field to generate the result, wherein the generated result contains a second field; and

storing the generated result within the same document that contains the first field.

11. A method in a computer system of generating a result of a field, the field being stored in a document, the field having a plurality of field codes, one field code being a keyword, one field code being a nested field, the keyword specifying a function to perform, the keyword having an associated computer routine to perform the specified function, wherein the computer routine generates a result, the method comprising the steps of:

determining a result of the nested field;

invoking the computer routine associated with the keyword to generate a result based on the determined result of the nested field, the generated result containing a result field;

determining a result of the result field;

determining the result of the field based on the determined result of the result field; and

storing the determined result of the field in the document in which the field is stored.

12. A method for using fields in a document processor, a field comprising a beginning field character, a field code, a separator field character, a result, and an ending field character, the field code specifying a behavior to perform to generate the result, the method comprising the steps of:

storing a beginning field character, a field code, and an ending field character in a document;

generating the result of the stored field code;

storing a separator field character in the document in which the field is stored; and

storing the determined result of the field in the same document in which the field is stored wherein the stored separator field character separates the stored field code from the stored determined result.

13. A method in a computer system for displaying a field, the computer system having a field codes mode and a result mode, the method comprising the computer-implemented steps of:

loading a document into memory of the computer system, the document containing a field, the field having both a field code and a result within the [same]document;

displaying the field code of the field when the computer system is in field codes mode; and

displaying the result of the field when the computer system is in the result mode.

14. The method of claim wherein the computer program is a document processor.

15. A method in a computer system for processing fields within a document, the method comprising the steps of:

receiving a plurality of characters;

storing the received plurality of characters within the document;

receiving a field code that specifies a behavior to be performed by the computer system to generate a result;

storing the field code within the document;

performing the behavior of the field code to generate the result; and

storing the result within the document;

when the document is displayed in a field codes mode, displaying an indication of the stored field code; and

when the document is displayed in a result mode, displaying an indication of the stored result of the field code.

16. The method of claim 15 wherein when displaying the indication of the stored field code, displaying a beginning field character and an ending field character and displaying the indication of the stored field code in between the displayed beginning field character and ending field character.

17. The method of claim 15 wherein when displaying the indication of the stored field code, displaying a beginning field character and an ending field character and displaying the indication of the stored field code, a separator character, and an indication of the stored result in between the displayed beginning field character and ending field character.

18. A method in a computer system for calculating results of fields stored in a document, each field having one of a plurality of field codes that specify a behavior to perform to generate a result of the field, the method comprising the computer-implemented steps of:

loading a mapping from each of the plurality of field codes to an associated function that performs the specified behavior to generate a result of a field that has the field code; and

for each field in the document,

retrieving the field code of the field;

identifying from the loaded mapping the function associated with the retrieved field code;

invoking the identified function; and

under control of the invoked function,

performing the specified behavior of the retrieved field to generate a result of the field; and

storing the generated result in the document.

19. The method of claim 18 including the steps of:

for each field in the document.

retrieving the stored result of the field; and

displaying the retrieved result a display device.

20. The method of claim 18 including the steps of:

for each field in the document,

retrieving the field code of the field; and

displaying the retrieved field code on the display device.

21. The method of claim 18 wherein the step of storing the generated result in the document stores the generated result within the field in the document.

22. The method of claim 18 wherein a field includes an argument indicating a variation in the specified behavior of the field code and wherein the step of performing the specified behavior does so base indicated variation.

23. The method of claim 18 including the step of after storing the generated result in the document, deleting any previous result of the field.

24. A method in a computer system for processing a plurality of fields within text of a word processing document, the method comprising the steps of:

displaying the text of the word processing document on a display device; and

for each of the plurality of fields,

receiving an indication of a position within the text of the word processing document;

receiving an indication of the field to be inserted at the indicated position within the text of the word processing document, the field having a field code specifying a behavior to perform to generate a result of the field;

inserting the indicated field at the indicated position within the text of the word processing document;

performing the specified behavior of the field code of the inserted field to generate a result of the field and storing the generated result with the field within the word processing document; and

displaying, within the displayed text of the word processing document, the generated result of the field at a position corresponding to the indicated position.

25. The method of claim 24 including the steps of:

after displaying the generated result of each field,

receiving an indication to re-perform the specified behavior of the fields inserted into the text of the word processing document; and

in response to receiving the indication to re-perform,

for each field code within the text of the word processing document,

performing the specified behavior of the field code of the field to re-generate a result of the field; and

storing the re-generated result within the text of the word processing document.

26. The method of claim 25 including the step of deleting the generated result that is stored with the text word processing document.

27. The method of claim 24 wherein each field code has an associated function for performing the specified behavior and the step of performing includes identifying the function associated with the field code and executing the function to perform the specified behavior.

Description

FIELD OF THE INVENTION

This invention relates to the field of document processors, and more particularly, to a method and system for allocating and displaying fields in a document processor.

BACKGROUND OF THE INVENTION

Document processors are a class of computer application programs which provide the ability to manipulate, display, and print text and graphics in a variety of formats. One example of a popular document processor program is the Microsoft Word document processor available from Microsoft Corporation. Typically, in most document processors, text may be produced in a variety of fonts, sizes, styles, and paragraph formats. While a number of computer programs provide similar capabilities, document processors provide flexibility and capabilities not found in other programs.

For example, in computer spreadsheet application programs, text information or numerical data is identified with a particular cell which is positioned according to x-y coordinates in the spreadsheet. In this type of system, specific formatting information is associated with individual cells. Thus, the data or text within the cells is easily associated with formatting information based on its relative position in the spreadsheet application. In contrast, in a document processor, text or graphic information may be placed in a document in a position which is dependent primarily on its position within a text string wherein its actual position within a document changes as text or graphic objects are added or deleted from the text string.

Since character positions are variable within a document processed by a document processor, it is extremely difficult to provide fields within such a document. Fields are similar to the formula in cells provided in a spreadsheet application program wherein the contents of a field may be dependent on the mathematical relationship between a plurality of other values.

SUMMARY AND OBJECTS OF THE INVENTION

In summary, the present invention contemplates a method and system for providing fields in a document processing environment wherein fields may be included within a stream of text. Fields are processed by a single generic field handling mechanism which invokes field-specific functions. Fields are delineated with unique beginning and ending field characters, which enclose a field keyword as well as field arguments. The keyword of a field determines the type of the field. When a field is encountered in a document, the keyword and arguments are parsed and field-specific functions are invoked through a look-up table that is indexed by the keyword. Field results are generated based on field arguments. The present invention provides a means whereby fields may be displayed in a result mode or field code mode. In addition, arguments of one field may be generated from the result of another field.

Accordingly, it is an object of the present invention to provide an improved method and system for processing documents providing a single mechanism for handling all types of fields.

It is another object of the present invention to provide an improved method and system for generating field results and inserting field results in fields.

It is another object of the present invention to provide a document processor system wherein a variety of field types may be added to the system or the functioning of existing field modified without altering the basic mechanism for handling fields.

It is still another object of the present invention to provide a method and system for implementing nested fields in a document processing environment.

It is still another object of the present invention for applying general switches to the result of a field in a document processor system.

It is yet another object of the present invention to provide a method and system for determining the portion of field to be displayed and for adjusting a page layout in a document processor accordingly.

BRIEF DESCRIPTION OF THE DRAWINGS

These and other objects will be apparent from the description below and the accompanying drawings in which:

FIGS. 1A and 1B are diagrams of displays showing documents having fields of the type processed by the present invention.

FIG. 2 is a flow diagram of the FCalcFields routine used to update a field whenever invoked manually by the user or automatically by the system.

FIG. 3 is a flow diagram of the FCalcFieldIfld routine used to generate the result of a field.

FIG. 4 is a flow diagram of the CallCalcFunc routine called by the routine of FIG. 3.

FIG. 5 is a diagram showing the organization of the data structures used to implement the present invention.

FIG. 6 is a flow diagram of the DcpApplySysSwitches routine called by the routine of FIG. 4.

FIG. 7 is a flow diagram of the ChFetchSwitch routine.

FIG. 8 is a flow diagram of the DcpApplyFormatSw routine called by the routine of FIG. 6.

FIG. 9 is a flow diagram of the DcpApplyPictureSw routine called by the routine of FIG. 6.

FIG. 10 is a flow diagram of the FormatLine routine used to update display devices while using the present invention.

FIG. 11 is a flow diagram of the FfcFormatFieldPdcp routine called by the routine of FIG. 10.

FIG. 12 is a flow diagram of the FShowResultPflcdFvc routine called by the routine of FIG. 11.

FIG. 13 is a flow diagram of the DcpSkipFieldChPflcd routine called by the routine of FIG. 11.

FIG. 14 is a flow diagram of the FltParseDocCp routine used to fetch keyword text and return the field-specific function for the keyword.

DETAILED DESCRIPTION OF THE INVENTION

The present invention provides a method and system for use with a document processor application program which allows a user to insert "calculated text" or "fields" virtually anywhere in a document. The present invention provides a single mechanism for handling all fields, wherein the specific behavior of a field is defined by a field specific algorithm that is invoked by the generic field mechanism. This allows the generic field mechanism of the present invention to be incorporated in an application program without regard to the specific behavior of individual fields.

In the context of the present invention, a "field" is defined as a placeholder object that is evaluated to produce a result. A "field" is used to implement generated objects such as page numbers, dates, or cross references. A field comprises a beginning field character, field codes, a separator field character, a field result, and an ending field character specified according to the following syntax:

{field codes.vertline.result}

The field codes in the above expression are typically entered in a text stream as ordinary text and may be edited or modified as any other character in the text stream. The beginning field character ("{"), the ending field character ("}"), the separator character (".vertline."), and the result are generated by the application. Fields are used in two modes: field code mode and result mode. In the field code mode, the beginning field character, the field codes, and the ending field character are displayed. In the result mode, only the result of the field codes is displayed. Field codes consist of a keyword that identifies the field type, field arguments of the field type, switches specific to the field type, and general switches, called "system switches." A switch consists of a backslash character (".backslash."), a single character switch identifier (e.g., "*"), and optionally a switch argument.

The keyword of a field identifies the type of the field. If the keyword is not known, then the field is considered to be a bookmark reference and the keyword is the bookmark name.

A keyword may optionally be preceded by a backslash character (".backslash."). If a keyword is not known and is preceded by a backslash, it will not be treated as a bookmark reference. Rather, the field will have no result.

Arguments, both field and switch, are words separated by one or more spaces. However, a space between a switch identifier and the switch argument is optional. A multi-word argument is obtained by surrounding it with quotes ("). A quote can be placed within an argument by preceding it with a backslash character (.backslash.") as shown below.

Examples of arguments:

    ______________________________________
    Field Codes          Arguments
    ______________________________________
    foo bar              foo
                         bar
    "foo bar"            foo bar
    "foo .backslash." bar"
                         foo " bar
    .backslash."Joe.backslash."
                         "Joe"
    "John .backslash."Johnny.backslash.""
                         John "Johnny"
    .backslash..backslash. .backslash."
                         .backslash.
                         "
    abc"def"ghi          abc
                         def
                         ghi
    foo "" bar           foo
                         (empty string)
                         bar
    ______________________________________

    ______________________________________
            {
             if appname = "Opus"
              "This is the true text."
              "This is the false text."
            }
    ______________________________________

                                      TABLE 2
    __________________________________________________________________________
    /*CP is a long describing a character position in the document*/
    /*BOOL is a boolean flag*/
    /* A plc is a structure containing an array of cp's and an array of
    objects (in this case fld's) in
    which the index to the array serves as the link between the two pieces of
    Information. A handle to
    the plcfld is stored In the document descriptor. The plcfld itself is
    stored in the file format.*/
    /* Information stored in plcfld for each field character*/
    struct FLD
     {/* FIELD Descriptor*/
     struct
      {
      int ch : 7; /*chFieldBegin, chFieldSeparate or chFieldEnd*/
      int fDirty : 1; /*field must be reparsed*/
      };
      union
      {
      char flt; /*chFieldBegin:FIELD Type*/
      char bData; /*chFieldSeparate: field-specific
      cached data*/
      struct
       { /*chFieldEnd*/
       int fDiffer : 1; /*this field in ! show
      results mode*/
       int : 1;
       int fLocked : 1; /*this field is locked
       from recalc*/
       int fNested : 1; /*field is nested within
       another field*/
       int : 4; /*spare*/
       };
      char grpf; /*chFieldEnd: GRouP of bit Flags*/
      };
     };
    /*Used to cache information about a field.
    Constructed from the info in the two or three fld's corresponding to the
    field.*/
    struct FLCD
     {/* FIELD Composite Descriptor*/
     CP cpFirst; /*cp where field begins*/
     CP dcplnst; /*Includes both {} and all field codes*/
     CP dcpResult; /*Includes .vertline. and all result text*/
     BOOL fDirty; /*field is dirty and must be reparsed*/
     int flt; /*field's type*/
     int bData; /*flt specific cached data*/
     int ifldChBegin;
     int ifldChSeparate;
     int ifldChEnd;
     union
      {
      struct
      {
       intfDiffer : 1; /*this field in ! show results mode*/
       int : 1;
       int fLocked : 1; /*this field is locked from recalc*/
       int fNested : 1; /*field is nested within another field*/
       int : 4; /*spare*/
       };
      int grpf : 8;
      };
     };
    /*This structure provides general information about a specific field
    type*/
    struct EFLT
     { /*Element of dnflt, an array of the info below for each field type.
    flt is the index into
    this array*/
     int fResult : 1; /*this field may have a result*/
     int : 4; /*spare*/
     int : 1; /*spare*/
     int frm : 8; /*refresh time mask*/
     PFN pfnCalcFunc; /*pointer to recalc function*/
     };
    /*this is used to map ich's to cp's*/
    struct CR
     { /*CP Run*/
     CP cp;
     int ccp;
     };
    /*holds information about switches found during a fetch*/
    struct FSF
     { /*Field Switch Fetched*/
     int c; /*how many were fetched*/
     CHAR rgch [cSwitchMax]; /*the switches themselves*/
     CP rgcpSw [cSwitchMax]; /*cp of the switches*/
     CP rgcp [cSwitchMax]; /*cpNil or the cp of the switch's arg*/
     };
    /*this is used by FetchFromField and functions that call it*/
    struct FFB
     { /*Field Fetch Block*/
     union
      {
      /*this is used also by FetchVisibleRgch*/
      struct FVB
      { /*Fetch Visible Block*/
       int doc; /*document fetching from*/
       CP cpFirst; /*first cp to fetch in next fetch (modified)*/
       CP cLim; /*limit of fetches*/
       int cch; /*number of ch's read if rgch. under if !rgch*/
       int ccr; /*number of cr's corresponding to ch's read*/
       union
        {
        struct FBB
         { /*Fetch Block Buffers*/
         int cchMax; /*max number of ch to place in rgch*/
         CHAR *rgch; /*buffer in which to place chars*/
         int ccrMax; /*max number of cr's to place in rgcr*/
         struct CR *rgcr;/*buffer in which to place cp runs*/
         };
        struct FBB fbb;
        };
       BOOL fOverflow; /*fetch overflowed cchMax or ccrMax, fetch again*/
       };
      struct FVB fvb;
      };
     union
      {
      struct FSFB
       { /*Field Specific Fetch Block*/
       CP cpField; /*cpFirst of the field being fetched from*/
       /*inputs*/
       int flt; /*what flt is the field being fetched*/
       int foc; /*how to treat fetch options*/
       /*outputs*/
       BOOL fGrouped; /*indicates returned argument was grouped*/
       BOOL fNested; /*fetched data contained fields*/
       BOOL fNoArg; /*there was no argument fetched*/
       /*state (be very careful modifying)*/
       int cchFieldBegin; /*count of chfieldBegin's to be matched*/
       BOOL fGroupPending; /*indicates inside chGroupExternal pair*/
       struct FSF fsfFlt; /*flt specific switches found*/
       struct FSF fsfSys; /*system switches found*/
       };
      struct FSFB fsfb;
      };
     ;
    /*stores information about all defined field switches*/
    struct FSI
     { /*Field Switch Information*/
     int ch : 7; /*the switch character, note: packed to 7 bits*/
     int fArg : 1; /*switch expects an argument*/
     int flt : 8; /*what flt does this switch apply to*/
     };
    __________________________________________________________________________

• Inventors
  Jackson, Peter C.; Gates, III, William H.; Loofbourrow, Bryan;
• Assignee
  Microsoft Corporation (Redmond, WA)
• Published
  Sep-3-1996
• Current US Classes:
  715/531
• Application #
  205141
• International Classes
  G06F 017/22
• Field of Search
  364/419.19 364/419.14 364/419.17 364/419.1 395/146 395/600 395/147 395/148 395/145
• Examiner
  Weinhardt; Robert A.
• Agent
  Seed and Berry LLP
• US Patent References:
  4965763
  5025396
  5148366