Revision: 0.1
*/
May 17, 1989: created (davidb)
Word has used this same file format since its first version. This means that Word 1.0 can read Word 5.0 files and vice-versa. This compatibility was accomplished by defining all structures to be larger than they needed to be and setting all reserved fields to zero for use in future versions. Reserved pointers in the document header have been used to add entirely new document sections (such as document retrieval information and bookmark tables).
Because of the important issue of compatibility with future versions, all fields in all structures which are not currently being used MUST be filled with zeros. When the fields is finally defined for a new feature, we will make zero either the default value for that fields or make zero represent an uninitialized state which will be ignored.
The most important sections of a Word document are the text section and the formatting sections. The text section is straight ASCII text with the IBM extended character set. Some of the low order characters have been reserved for the special use, such as forced line feeds and page breaks. No formatting "reveal" codes can be found in the text section. Instead, formatting is stored in the formatting sections and related to the text by sequential tables. This makes extracting the textual information from a Word document really simple: just read the ASCII text section and ignore the formatting section.
Autosave files can be identified by examining the fAsv bit in the document header (FIB). They are mentioned here since any program not aware of their existance would confuse them with a normal Word document. Loading such a document as if were a normal document could cause problems, so beware. The autosave format is beyond the scope of this document.
CPs are stored in the file least significant byte first, most significant byte last.
FCs are stored in the file least significant byte first, most significant byte last.
The word page is also used to describe the way a document is divided up to print on pieces of paper when it is printed or paginated.
Tables are usually used to stored data structures which, if they were added today, would be stored in a PLCF. In such usage, the item structure will be defined to begin with a CP. The last instance of the structure will exist only to provide a limiting CP for the previous entry; the other fields in the last item should be ignored. Example of tables which contain cps are fntb (footnote table), setb (section table) and bftb (buffer table).
| f | used to name a flag (a variable containing a boolean value). Usually the object referred to will contain either 1 (fTrue, TRUE) or 0 (fFalse, FALSE). (eg. fWidowControl, fBold) |
| l | used to name a 4 byte integer value (a long). (eg. lcb) |
| w | used to name a 2 byte integer value (a word). |
| cp | used to name a variable that contains a character position within the document. always a 4 byte quantity. |
| fc | used to name a variable that contains an offset from the beginning of a file. always a 4 byte quantity. |
| xa | used to name a variable that contains a width of an object imaged on screen or on hard copy that is measured in units of 1/1440 of an inch. This unit is one-twentieth of a point size (1/20 * 1/72") is called a twip in this documentation. (eg. xaPage is the width of a page). |
| ya | used to name a variable that contains a height of an object imaged on screen or on hard copy that is measured in twips. |
| dxa | used to name a variable that contains the horizontal distance of an object measured from some reference point expressed in twips. (eg. pap.dxaLeft is the distance of the left boundary of a paragraph measured from the left margin of the page) |
| dya | used to name a variable that contains the vertical distance of an object measured from some reference point expressed in twips. (eg. pap.dyaAbs is the vertical distance of the top of a paragraph from a frame declared in the pap). |
| dxp | used to name a variable that contains the horizontal distance of an object measured from some reference point expressed in printer specific units. |
| dyp | used to name a variable that contains the vertical distance of an object measured from some reference point expressed in printer specific units. |
| rg | prefix used to signify that the data structure begin defined is an array. (eg. rgb (an array of bytes), rgcp (an array of cps), rgfc (an array of fcs), rgfoo (an array of foos). |
| i | prefix used to signify that an integer value is used as an index into an array. (eg. itbd is an index info rgtdb.) |
| c | prefix used to signify that an integer value is a count of some number of objects. (eg. a cb is a count of bytes, a cl is a count of lines, ccol is a count of columns.) |
The two following modifiers are used occasionally in this documentation:
| First | means that variable marks the first of a range of object. For example, cpFirst would mark the first character position of a range of characters in a document. fcFirst would mark the file offset of the first byte of a range of bytes stored in a file. |
| Lim | means the variable marks the limit of a range of objects (ie. is the index of the lst object in a range plus 1). For example, cpLim would be the limit CP of a range of characters in a document. fcLim would be the limit file offset of a range of bytes stored in a file. |
| Mac | means variable marks the limit of an entire array of objects. Whereas cpLim could be used to specify the limit of a range of text within a document, cpMac would be used to denote the number of characters in the entire document. |
What follows is a brief overview of the composition of a Word document. A more in depth description of each part will follow.
The FIB structure comes first, and text immediately follows. All other information in the document is indexed by page numbers (PNs) stored in the FIB.
| Test for existance: | Always exists | |
| Location (PN) if present: | pn 1 |
| Test for existance: | Always exists | |
| Location (PN) if present: | (fib.fcMac + 127) / 128 |
| Test for existance: | Always exists | |
| Location (PN) if present: | fib.pnPara |
| Test for existance: | fib.pnFntb != fib.pnBkmk | |
| Location (PN) if present: | fib.pnFntb |
| Test for existance: | fib.pnBkmk != fib.pnMacBkmk && fib.pnMacBkmk != 0 | |
| Location (PN) if present: | fib.pnBkmk |
| Test for existance: | Section table exists | |
| Location (PN) if present: | Referenced by section table |
| Test for existance: | fib.pnPgtb != 0 && fib.pngtb < fib.pnSetb | |
| Location (PN) if present: | fib.pnPgtb |
| Test for existance: | fib.pnRhtb != 0 && fib.pnSetb > fib.pnRhtb | |
| Location (PN) if present: | fib.pnRhtb |
| Test for existance: | fib.pnSetb != fib.pnBftb | |
| Location (PN) if present: | fib.pnSetb |
| Test for existance: | fib.pnBftb != fib.pnMac | |
| Location (PN) if present: | fib.pnBftb |
For normal Word documents (non-glossaries), fib.pnBftb serves only to mark the end of the section table.
The summary sheet is only available for text documents. Do not look for summary information in glossaries or style sheets.
| Test for existance: | fib.pnSumd != fib.pnMac | |
| Location (PN) if present: | fib.pnSumd |
The rest of this document will describe each of these sections described above in detail.
The first thing Word uses the FIB for is to determine what type of file it is loading. The wIdent, dty, wTool and fAsv fields are used for this purpose.
All files written by PCWord will have fib.wIdent = 0x6031 and fib.wTool = 0xAB00. The dty field tells Word that the file is a document (0), glossary (1), stylesheet (2), or printer driver (3). If it is a document, Word looks at the fAsv field to determine whether the document has been incrementally saved.
In short, all full-saved Word documents begin with 0x6031, 0x000, 0xAB00 and the byte at offset 117 decimal will be zero. OEM programs dealing with Word documents can ignore all files not fitting this description.
The header contains the path\name of the attached stylesheet as a NULL terminated (ASCIIZ) string at offset 30, and an 8 character PRD (printer driver) name at offset 98. The PRD name is used to give a hint to other programs (such as Microsoft Write and Microsoft PageView) which printer driver Word was using when the document was last saved. The PRD name is NULL terminated only if it is less than 8 characters long.
The DOP (document properties, described in Appendix A) at offset 108 saves some of Word's options as they were when the document was aved. If they are different when it is reloaded, some caches will have to get invalidated. The DOP structure also contains revision marking options.
Some fields are used only for autosaved files. These fields (pnNextFib, pnChar, pnPlcpcd, pnPlcphe, fAsvFormatted, fAsv, pnFilename) should be set zero for normal word documents. Unassigned bits and wReserved should also be set to zero.
Most of the other fields in the header are PNs, or page numbers revealing the offsets of various sections of the file. Most of the sections so referenced are optional and may not be present. Unfortunately, there is no consistent rule for determining whether a section is present.
In this discussion, all ASCII values are given in decimal. The following ASCII definitions will apply:
| <LF> is a Line Feed | 10 decimal | |
| <FF> is a Form Feed | 12 decimal | |
| <CR> is a Carriage Return | 13 decimal |
Some ASCII characters have special meaning to Word. The rest of this section will elaborate on what those special meanings might be.
Also note that hard line, column and page breaks are only present if inserted by the user to preempt Word by causing a break sooner than it would otherwise occur. Word does not store any special codes represent natural breaks. Rather, it calculates how many words will fit on a line each time a line is displayed or printed. Word does not maintain a separate page table to store information about where pages break.
There is some confusion about the use of ASCII 196 to represent a non-breaking hyphen. Since Word began supporting the IBM linedraw set in version 4.0, this has been a natural conflict. People were not able to print the character 196 (horizontal line) from the linedraw set because it would be interpreted as a non-breaking hyphen and printed using ASCII 45. To avoid this problem, an exception was made for fixed-pitch fonts which could be used for cursor linedrawing. IF there are more than 2 ASCII 196's in a row or a ASCII 196 character is adjacent to another IBM linedraw character on either side, it will not be treated as a non-breaking hyphen. This makes virtually all cursor-linedrawings print correctly.
A second solution that works for all fonts has been introduced in Word 5.0. To get character 196, enter an em-hyphen. Word will unconditionally map this to character 196.
The following ASCII codes are treated as "special" characters when the have the character property fSpecial enabled (chp.fSpecial == 1):
The fundamental unit of text for which character formatting information is kept is the run of text, a contiguous sequence of characters stored on disk that all have the same character properties. Each run would have an entry recorded in a FCHP FKP. If a user never changed the character used in his document, the entire document stream would be one large run of text and one FCHP would suffice to describe the character properties of the entire document.
The fundamental unit of text for which paragraph properties are recored is the paragraph. Every paragraph has an entry recorded in a FPAP FKP.
An FKP (see table below) is a 128-byte data structure that is stored in one page of a Word file. At offset 127 is a 1-byte count named cRun, which is a count of runs of text FCHP FKPs and which is a count of paragraphs in FPAP FKPs. Beginning at offset 0 of the FKP is the FC for the first character covered by this disk page. This is followed by an array of RUN structures which provide the FC for the start of the next run (fcLim) and the byte offset of the actual stored properties (bProp). This offset is from byte 4 of the FKP (beginning of array of RUNs). If its value is -1, the properties are assumed to be default and are not stored.
As of Word 5.0, paragraph height are stored in the FPAP FKPs in addition to formatting information. This information is for Word's use only and should be ignored by other software. Programs writing out Microsoft Word 5.0 files should set fib.version to 3 (version5_0OEM) so that Word will not try to acces this information.
| byte offset | number of bytes | meaning |
|---|---|---|
| 0 | 4 |
|
| 4 | 6 * cRun |
|
| 4 + 6 * cRun | 6 * cRun |
|
| Character or Paragraph Properties (FPROPS) Go Here | ||
| 127 | 1 byte |
|
An FPROP is abbreviated set of properties. It consists of a single byte count of the characters (cch) followed by the first part of a CHP or PAP structure which is to be copied over the first cch bytes of the default CHP or PAP structure. For example, if a character run were bold, but in all other respects just like the default, a cch of 2 would be stored to followed by the first two bytes of the CHP (footnote: Two bytes are necessary since the fBold bit happens to be in the second byte of the CHP structure.). To recover the full character properties, Word would start with the default character properties, then replace the first two bytes with those from the file.
Since the offsets stored in the RUN entries (bProp) allow random acces throughout the FKP, space within an FKP can be conserved by storing the offset of the same physical FPROP in several RUN entries for paragraph or character runs that happen to have the same properties. Word uses this optimization only if consecutive paragraphs have the same properties.
The text of a footnote is anchored to a particular position within the document's body text, the location of its footnote reference. There is a structure referenced by the FIB, the FNTB (footnote table), which relates the location of each footnote references to the corresponding footnote. The FNTB is a table of footnote descriptors (FNDs). Each FND contains a cpRef which points to a footnote reference mark, and a cpFtn which to point to the beginning of the corresponding footnote text in the document's footnote section. The footnote text extends until the character immediately preceding the one indexed by cpFtn in the next FND.
The CP of the point in the document where body text ends and footnote text begins can be determined by examining the cpFtn stored in the 0th FND of the FNTB. If there is no FNTB, all the text in the document is body text.
The last two characters of footnote text for a footnote (ie. the character at limit CP minus 2) are always <CR> <LF> (a paragraph mark). Word will not allow this paragraph mark to be deleted since each footnote must begin at the start of a new paragraph.
When there are n footnotes, the FNTB structure consists of n + 1 FNDs. The final FND serves only to provide the CP limit of footnote text for the previous FND. This is, of course, the end of the document, so cpFtn and cpRef for the this FND are both set to the document's cpMac.
The footnote reference is whatever character in the body text is pointed to by and FND's cpRef. If it happens to be autonumbered footnote reference (ASCII 5), or an autonumbered annotation reference (ASCII 4), Word will automatically generate a footnote number based on the number of footnote references which precede it in its division. Thus the first footnote in in a division will automatically be numbered 1, the second 2, etc.
| bit 0: | Bookmarks exist, so plcfbkmkf and plcbkmkl are present |
| bit 1: | User defined sequences exist, so plcfsqd is present |
| bit 2: | Sequences are cross-referenced, so plcfsqr is present |
| bit 3: | Bookmarks or user defined sequences exist, so there it a string table (sttbNames) to store their names. |
As their names imply, plcfbkmkf, plcfbkmkl, plcfsqd and plcfsqr are all PLCF tables and are accessed as such (see page 4). The tables are saved in immediate sequential order starting at byte 2 in the disk page in the following order: plcfbkmkf, plcfbkmkl, plcfsqd, plcfsqr, sttbNames.
plcfbkmkf associates the name of each bookmark to the beginning CP of the next marked by that bookmark. Each cp points to the beginning of a bookmark except the last one which points to the end (cpMac) of the document. Each 4 byte BKMK structure (see page 18) contains the index of the bookmark's name in sttbNames (iName) followed by the index of the bookmark's cpLim in plcfbkmkl.
plcfbkmkl contains the cpLim (CP of the character after the end of each bookmark) for each bookmark. This PLCF contains only CPs, to its cb should be set to 0.
plcfsqd associates the location of each sequence marker to the name of its sequence. Each cp points to a sequence marker except the last one which points to the end (cpMac) of the document. Each 4 byte SQD (see page 30) structure contains the index of its sequence's name in sttbNames (iName), followed by a 13 bit cache to its current position in its sequence (value) and a 3 bit code (action). The 3 bit action can be 0 (Increment sequence value and print new value. For example "(table:)"), 1 (Increment sequence value and don't print new value. For example "(table::)"), or 2 (Set sequence value to constant stored in value. For example "(table:0)").
plcfsqr associates the location of each sequence reference mark to the name of its sequence and the name of the bookmark being cross-referenced. Each cp points to a sequence cross reference mark except the last one which points to the end (cpMac) of the document. Each 4 byte SQR structure stores the index of the sequence name (iName) and bookmark name (iNameBkmk) into the sttbNames string table.
sttbNames is an STTB table (see page 5) which holds names for all user defined
bookmarks and sequences. It is referenced in the same manner as all STTBs.
REMEMBER: the index to the first string is 1, not 0.
Third-party creators of Word files should not attempt to creat a plcfpgd. It can only be created properly using Word's layout routines. If a Word document is edited in any way, the plcfpgd should be deleted by setting fib.pnPgtb to 0.
Third-party readers of Word files will similarly have a tough time interpreting them. The CPs stored in the table are NOT always the real CPs on which the respective pages begin. The real page breaks are located by cp, cl pairs which translates to "This page starts cl lines AFTER cp." If pgd.cl is non-zero, the page break was calculated using paragraph heights (PHE) where the height of all lines in the paragraph were the same (!phe.fDiffLines). All Word knows in this case is that the -- this part is missing on the scan! -- knowledge of Words formatting and layout rules and the exact widths of all characters as reported in Word's PRD drivers.
This is a standard PLCF structure (see page 4) which contains an array RHD structures (see page 27). The plcfrhd is to be written and read the same way as other PLCF structures.
Only Word should read and write this table.
| byte offset | points to: |
|---|---|
| 0 - 1 | szTitle (document title - up to 40 chars) |
| 2 - 3 | szAuthor (document's author - up to 40 chars) |
| 4 - 5 | szOperator (operator - up to 40 chars) |
| 6 - 7 | szKeyword (keywords - up to 80 chars) |
| 8 - 9 | szComments (comment - up to 220 chars) |
| 10 - 11 | szVersion (version - up to 10 chars) |
| 12 - 13 |
|
| 14 - 15 |
|
| 16 - 17 |
|
The following definitions are necessary in order to compile structures defined below:
Some of these structures will compile only if your compiler supports unnamed unions. If yours doesn't, you'll need to provide union names.
typedef unsigned BF; /* Bit field */ typedef long FC; /* FC = Byte Offset into File */ typedef unsigned PN; /* Page Number = Page Offset into File */ #define cchMaxFIBFile 66 /* Maximum length of PRD path in FIB */ #define itbdMax 20 /* Maximum number of tabs (19) plus one */
struct BKMK
{
int iName; /* index of name into string table */
int ibkmkl; /* index of end anchor in plcfbkmkl */
/* SIZE = 4 bytes */
};
struct CHP /* Character properties */
{
BF fStyled : 1; /* if true, ignore all fields in this CHP
structure except stc, fSpecial and fNew,
and get properties from the style
sheet instead */
BF stc : 7; /* if fStyled, this will hold a style
code from 0 to 29 - see belowe */
BF fBold : 1; /* bold */
BF fItalic : 1; /* italic */
BF ftc : 6; /* font code from 0 to 62 -- see below */
/* BYTE 2 */
BF hps : 8; /* size in half pts */
BF fUnline : 1; /* underline */
BF fStrike : 1; /* strikethrough */
BF fDline : 1; /* double underline */
BF fNew : 1; /* insert while revision marking was
enabled. Will be cleared when revision
is "Accepted" */
BF csm : 2; /* case modifier - see below */
BF fSpecial : 1; /* character should take on alternate
definition. For example, character 5
with fSpecial is a footnote reference mark
see page 11. */
BF fHidden : 1; /* hidden text */
/* BYTE 4 */
BF bUnunsed : 8;
BF hpsPos : 8; /* superscript/subscript */
/* BYTE 6 */
BF clr : 3; /* font color - see below */
BF : 13;
/* SIZE = 8 BYTES */
};
/* Definitions for stc (style code in CHP) */
#define stcNormal 0 /* Character Standard */
#define stcFtnRef 13 /* Footnote Reference */
#define stcFolio 19 /* Page Number */
#define stcAnnRef 26 /* Annotation Reference */
#define stcLineDraw 27 /* Line Draw */
#define stcSummaryInfo 28 /* Summary Info */
#define stcLNum 29 /* Line Number */
stc 1 through 12 represent character variants 1 thorugh 12 respectively
stc 14 through 18 represent character variants 13 through 17 respectively
stc 20 through 25 represent character variants 18 through 23 respectively
/* definitions for ftc (font code) */
ftc 0 through 15 represent (modern a) through (modern p) respectively
ftc 16 through 31 represent (roman a) through (roman p) respectively
ftc 32 through 39 represent (script a) through (script h) respectively
ftc 40 through 47 represent (foreign a) through (foreign h) respectively
ftc 48 through 55 represent (decor a) through (decor h) respectively
ftc 56 through 63 represent (symbol a) through (symbol h) respectively
If a printer driver is loaded, the font codes will receive printer specific
font names in addition to the generic font names above, For example,
for the HP LaserJet, ftc 0 translates to "Courier (modern a)"
/* definitions for csm (case modifier) */
#define csmNormal 0 /* don't do any case transformation */
#define csmUpper 1 /* print characters in uppercase */
#define csmSmallCaps 2 /* print characters in small caps */
/* definitions for hpsPos (half point size position) */
#define hpsNormal 0 /* Neither superscript or subscript */
#define hpsSuperscript 12 /* superscript */
#define hpsSubscript 244 /* subscript (8 bit integer = -12) */
Word's file format was designed to allow degrees of superscript
and subscript represented in half point units. This is currently
not supported, but Word does respect the following mapping
8 bit integers: hps 1 through 127 represent subscript,
hps -1 through -128 represent superscript
/* definitions for clr (font color) */
#define clrBlack 0
#define clrRed 1
#define clrGreen 2
#define clrBlue 3
#define clrViolet 4 /* Dark gray for monochrome printers */
#define clrMagenta 5 /* Medium gray for monochrome printers */
#define clrYellow 6 /* Light gray for monochrome printers */
#define clrWhite 7
#define cclrMac 8
/* This structure is included in the File Information Block.
Only fMarkRev and revText are true document properties.
The rest of the fields are used to validate options set and
style sheet and printer driver loaded when the document was
saved vs. conditions when it will be loaded. If the conditions
don't match, paragraph heights will be ignored and the page
table dirtied. */
struct DOP /* Current Pagination State (Document Properties) */
{
BF fMarkRev : 1; /* mark revisions? */
BF revText : 3; /* revision text modification */
BF revBar : 2; /* revision bar position */
BF fWidowControl : 1; /* widow/orphan control? */
BF fSeeHidden : 1; /* print hidden text? */
BF fOutLine : 1; /* print in outline mode */
BF wReserved : 7;
int prid; /* printer driver checksum */
int dxaTab; /* default tab width */
int sshtsum; /* style sheet checksum
set to zero if no style sheet */
/* SIZE = 8 BYTES */
};
/* Definitions necessary to interpret DOP structure */
/* possible values for revText field
- special format for text inserted while marking enabled */
#define revTextUline 0 /* inserted text displayed as underline */
#define revTextUpper 1 /* inserted text displayed as uppercase */
#define revTextNormal 2 /* inserted text displayed as formatted */
#define revTextBold 3 /* inserted text displayed as bold */
#define revTextDline 6 /* inserted text double underlined */
/* NOTE: When creating a Word document from scratch, just fill in the
DOP structure with zeros */
struct FIB
{
int wIdent; /* must contain 0x6031 */
int dty; /* document type - see below */
int wTool; /* most contain 0xAB00 */
/* NOTE: The following 4 pn's are only for incrementally saved
Word documents. They should be set to zero for normal documents. */
PN pnNextFib; /* pointer to incremental save FIB */
PN pnChar; /* pointer to Char formatting,
only valid in second or greater
FIBs in an incremental save file */
PN pnPlcpcd; /* pointer to piece table */
PN pnPlcphe; /* paragraph height table */
/* BYTE 14 */
FC fcMac; /* FC of end of section */
PN pnPara; /* location of paragraph formatting */
/* BYTE 20 */
PN pnFntb; /* location of footnote table */
PN pnBkmk; /* bookmarks and sequence information */
PN pnSetb; /* section table */
PN pnBftb; /* buffer table (glossaries only) */
PN pnSumd; /* summary information */
/* BYTE 30 */
char szSsht[cchMaxFIBFile];
/* style sheet path\name ASCIIZ -
up to 65 characters followed by '\0' */
int wReserved; /* Windows write uses it */
/* BYTE 98 */
char rgchPrtNm[8]; /* 8 character PRD name without path */
/* not an ASCIIZ - NULL terminated only
if name is lessthan 8 characters */
PN pnMac; /* one PN past end of document */
/* BYTE 108 */
struct DOP dop; /* document properties */
/* BYTE 116 */
BF Version : 8; /* word version - see below */
BF fAsvFormatted : 1; /* was this a formatted file
before autosave? */
BF fAsv : 1; /* autosave */
BF : 6;
/* BYTE 118 */
PN pnPgtb; /* Word 5.0 page table */
PN pnMacBkmk; /* Mac of Bkmk stuff,
0 for pre word 5.0 */
PN pnFilename; /* only used for Asv files */
PN pnRhtb; /* running head table */
PN codepage; /* if known, else 0 */
/* codepage is usually 437 (U.S.),
or 850 (International). Other
localized character sets exist.
see your MS DOS or MS OS/2
documentation */
/* SIZE = 128 BYTES = 1 PAGE */
};
/* Definitions to interpret FIB structure */
/* dty - document type */
#define dtyNormal 0 /* normal word document (i.e. typos.doc) */
#define dtyBuffer 1 /* glossary file (i.e. normal.gly) */
#define dtySsht 2 /* style sheet (i.e. normal.sty) */
#define dtyPrd 3 /* printer driver (i.e. epsonfx.prd) */
/* version - Word verion */
#define versionOld 0 /* Written by Word 4.0 or earlier version */
#define version5_0OEM 3 /* Written in Word 5.0 format by any program
other than Word 5.0. This will cause
Word to ignore paragraph height and
treat the page table with a grain of
salt. */
#define version5_0MS 4 /* Written by Microsoft Word 5.0. If that
is not the name of your program, don't
set version = 4! */
struct FKP /* Formatted disK Page */
{
FC fcFirst; /* first fc which has formatting info here */
char rgb[123]; /* contains rgRun, rgPhe and FPROPS */
/* BYTE 127 */
char crun; /* number of runs */
/* SIZE = 128 BYTES = 1 PAGE */
};
struct PAP /* Paragraph properties */
{
BF fStyled : 1; /* If true, ignore all fields in this PAP
structure except stc, rhc,
fUseDivMarg, level, and fHidden.
Get the rest from the style sheet */
BF stc : 7; /* if fStyled, this will hold a style
code from 30 through 104 - see belowe */
BF jc : 2; /* paragraph alignment - see below */
BF fKeep : 1; /* keep together */
BF fKeepFollow : 1;/* keep follow */
BF fSideBySide : 1;/* side by side paragraph */
BF fUseDivMarg : 1;/* running head alignment -
0 = edge of paper, 1 = left margin */
BF : 2;
/* BYTE 2 */
BF stcNormChp : 7; /* Style code from 30 through 104. If
paragraph is styled, this should be the
same as stc. Otherwise, this should be
the paragraph variant to used to get
formatting for characters attached to
Character Standard. */
BF : 1;
BF level : 7; /* outline level -
0 for body text, else just store the
outline level as displayed on the
status line */
BF fHidden : 1; /* true if paragraph would be
collapsed if displayed in
outline mode */
/* BYTE 4 */
unsigned dxaRight; /* right indent */
unsigned dxaLeft; /* left indent */
int dxaLeft1; /* first line indent */
/* BYTE 10 */
unsigned dyaLine /* line spacing - stored in twips,
but -80 means Auto */
unsigned dyaBefore; /* space before */
unsigned dyaAfter; /* space after */
/* BYTE 16 */
unsigned rhc : 4; /* running head code - see below */
unsigned btc : 2; /* border type code - see below */
unsigned bsc : 2; /* border style code - see below */
unsigned fBorderLeft : 1; /* which borders to show? */
unsigned fBorderRight : 1; /* these flags are referred to */
unsigned fBorderAbove : 1; /* only when btc == btcLines */
unsigned fBorderBelow : 1;
unsigned bclr : 3; /* border color -
see clr definitions under CHP */
unsigned wUnused1 : 1;
/* BYTE 18 */
BF shade : 7; /* paragraph shading - 0 to 100% */
BF bUnused : 1;
/* BYTE 19 */
BF pcVert : 2; /* vertical position - see below */
BF pcHorz : 2; /* horizontal postion - see below */
BF sclr ; 3; /* shading color
see clr definitions under CHP */
BF wUnused2 : 1;
/* BYTE 20 */
int dxaFromText; /* distance from text in twips */
/* BYTE 22: Array for up to 19 tabs plus NULL entry */
struct TBD rgtbd[itbdMax]; /* itbdMax is 20 */
/* This is the end of Word 4.0's PAP structure */
/* BYTE 102: Format Position measurements */
/* Format Position -- absolute position properties */
int dxaAbs; /* horizontal position - see below */
int dyaAbs; /* vertical position - see below */
int dxaWidth; /* paragraph frame width - see below */
/* SIZE = 108 BYTES */
};
/* definitions for src and stcNormChp (style codes) in PAP */
#define stcParaMin 30 /* Paragraph Standard */
#define stcFtnText 39 /* Footnote Text */
#define stcAnnText 87 /* Annotation Text */
#define stcHeadLev1 88 /* Heading Level 1 */
#define stcHeadLev2 89 /* Heading Level 2 */
#define stcHeadLev3 90 /* Heading Level 3 */
#define stcHeadLev4 91 /* Heading Level 4 */
#define stcHeadLev5 92 /* Heading Level 5 */
#define stcHeadLev6 93 /* Heading Level 6 */
#define stcHeadLev7 94 /* Heading Level 7 */
#define stcIndLev1 95 /* Index Level 1 */
#define stcIndLev2 96 /* Index Level 2 */
#define stcIndLev3 97 /* Index Level 3 */
#define stcIndLev4 98 /* Index Level 4 */
#define stcTabLev1 99 /* Table Level 1 */
#define stcTabLev2 100 /* Table Level 2 */
#define stcTabLev3 101 /* Table Level 3 */
#define stcTabLev4 102 /* Table Level 4 */
#define stcRunningHead 103 /* Running Head */
stc 31 through 38 represent paragraph variants 1 through 8 respectively
stc 40 through 86 represent paragraph variants 9 through 55 respectively
/* Definitions for jc (paragraph justification code) in PAP */
#define jcLeft 0 /* left alignment */
#define jcCenter 1 /* centered */
#define jcRight 2 /* right alignment */
#define jcBoth 3 /* justified */
/* Definitions for rhc (running head code) in PAP
For complete rhc definition, add up relevant bits */
#define RHC_fBottom 1 /* bit 0: bottom running head, not top */
#define RHC_fOdd 2 /* bit 1: print on odd pages */
#define RHC_fEven 4 /* bit 2: print on even pages */
#define RHC_fFirst 8 /* bit 3: print on first page */
/* Definitions for btc (border type code) in PAP */
#define btcNone 0 /* no paragraph borders */
#define btcBox 1 /* all four paragraph borders */
#define btcLines 2 /* refer to fBorderRight, fBorderLeft,
fBorderAbove, and fBorderBelow */
/* Definitions for bsc (border style code) in PAP */
#define bscNormal 0 /* use single line drawing characters */
#define bscBold 1 /* use bold font for line drawing */
#define bscDouble 2 /* use double line drawing characters */
#define bscThick 3 /* use block characters for the borders */
/* Definitions for pcVert (Position "relative to" in vertical direction) */
#define pcVMargin 0 /* relative to margins */
#define pcVPage 1 /* relative to page */
/* Definitions for pcHorz (Position "relative to" in horizontal direction) */
#define pcHColumn 0 /* relative to column */
#define pcHMargin 1 /* relative to margins */
#define pcHPage 2 /* relative to page */
/* Definitions for dxaAbs (horizontal frame position) */
#define dxaAbsLeft (-80) /* Left */
#define dxaAbsCenter (-81) /* Centered */
#define dxaAbsRight (-82) /* Right */
#define dxaAbsInside (-83) /* Inside */
#define dxaAbsOutside (-83) /* Outside */
/* Definitios for dyaAbs (vertical frame position) */
#define dyaAbsInline (-70) /* In line */
#define dyaAbsTop (-71) /* Top */
#define dyaAbsCenter (-72) /* Centered */
#define dyaAbsBottom (-73) /* Bottom */
/* Definitions for dxaWidth (frame width) */
#define dxaAbsWidthCol (-90) /* Single Column */
#define dxaAbsWidth2Col (-91) /* Double Column */
#define dxaAbsWidthMarg (-92) /* Between Margins */
#define dxaAbsGrWidth (-93) /* Width of Graphic */
struct PGD
{
BF fUnk : 1; /* if fTrue, redo this page next pagination */
BF : 1;
BF fPending : 1; /* this page has footnotes which need to
be continued to next page */
BF fSimpleLbs : 1; /* this page has no APOs, is single column,
and running heads don't push the text.
This means it can be displayed in Show
Layout mode without doing much work. */
BF fPgnrestart : 1;/* next page page should be page 1 again */
BF fEmptyPage : 1; /* this page is left totally empty in order
satisfy the section break code -
that is, if section must start on even or
odd page */
BF fAllFtn : 1; /* this page contains only footnotes and
annotations */
BF fContinue : 1; /* same as fPending */
BF bkc : 8; /* section break code (see SEP) - not looked
at by anyone */
/* BYTE 2 */
unsigned lnn; /* line number of 1st line, -1 if no line numbering */
int cl; /* count of of line into paragraph for 1st line */
int pgn; /* page number as printed */
int dcpDepend; /* number of cp's on next page which might
effect THIS page if edited */
/* SIZE = 10 BYTES */
};
/* NOTE - dypLine, dypHeight are stored in printer specific units. dyp is
usually measured in 1440ths of inch (twips)m or 1/300ths of an inch for
certain laser printers. */
/* This information is valid only with a certian printer driver, style sheet,
version of Word and set of options. Word stores necessary information in
the FIB and DOP to know whether it can safely use this information when a
file is reloaded. */
struct PHE
{
BF fUnk : 1; /* phe entry is invalid */
BF : 7;
BF clMac : 8; /* number of lines in para, if known */
BF fDifflines : 1; /* total height is known,
lines are different */
BF dxaCol : 15; /* width of column when height was
calculated */
union
{
unsigned dypLine; /* height of each line if !fDiffLines */
unsigned dupHeight; /* height of entire paragraph if
fDifflines */
}
/* SIZE = 6 BYTES */
};
/* This an abstract structure which can't be compiled as declared
since iMac is not a constant, and ITEM is an arbitrary structure
whose size happens to be cb. */
struct PLCF
{
int iMac; /* number of items stored */
int cb; /* size of struct ITEM in bytes */
CP rgcp[iMac + 1]; /* there are iMac + 1 CPs */
struct ITEM rgItem[iMac]; /* there iMac items */
/* SIZE = 4 + 4 * (iMac + 1) + iMac * cb */
};
struct RHD
{
BF fUnk : 8; /* fTrue is running head has been edited since
last repag. If so, all applicable pages
will have to be repaginated */
BF rhc : 8; /* running head code at last pagination
(see definitions under PAP)
this rhc is used in conjunction with current
rhc (in PAP) to decide which pages to redo */
unsigned dcpDepend; /* number of bytes in paragraph - used by
editing code to quickly decided whether to
set fUnk */
/* size = 4 BYTES */
};
struct SEDF /* Section descriptor */
{
CP cp; /* cpLim of section */
int fn; /* file number of properties -
ignore me: you're looking at the right file now */
FC fc; /* location of properties in file or
0xFFFFFFFF for default section properties */
/* SIZE = 10 BYTES */
};
struct SEP /* Section properties */
{
BF fStyled : 1; /* if true, ignore all fields in this SEP
except stc and get properties from the
style sheet instead */
BF stc : 7; /* if fStyled, this will hold a style
code from 105 to 127 - see below */
BF bkc : 3; /* page break code - see below /
BF nfcPgn : 3; /* page number format code - see below */
BF lnc : 2; /* line number restart code - see below */
/* BYTE 2 */
unsigned yaPage; /* page height */
unsigned xaPage; /* page width */
unsigned pgnStart; /* starting page number -
0 to continue page numbers from
previous section */
unsigned yaTop; /* top margin */
/* BYTE 10 */
unsigned dyaText; /* height of text */
unsigned xaLeft; /* left margin */
unsigned dxaText; /* width of column */
BF rhc : 4; /* set to zero */
BF fMirrorMargins : 1; /* flip margins on even pages */
BF fLnn : 1; /* print line numbers */
BF fAutoPgn : 1; /* print page number on each page */
BF fEndFtns : 1; /* put footnotes at end of section */
BF cColumns : 8; /* number of columns */
unsigned yaRH1; /* header position from top of page */
/* BYTE 20 */
unsigned yaRH2; /* footer position from top of page */
unsigned dxaColumns; /* space between columns */
unsigned dxaGutter; /* gutter margin */
unsigned yaPgn; /* page number pos. from top of page */
unsigned xaPgn; /* page number pos. from left of page */
/* BYTE 30 */
unsigned dxaLnn; /* line number distance from text */
char nLnnMod; /* line number increment -
example: if nLnnMod = 5, only
print numbers for lines whose number
would be divisible by 5. */
BF fHardMargTop:1; /* allow header to overlap text
if it goes too long. this is
represented in the menu by putting
a hyphen before the top margin
measurement */
BF fHardMargBottom:1; /* allow footer to overlap text if
it is positioned too high. This is
represented in the menu by putting
a hyphen before the bottom margin
measurement */
BF wReserved : 5;
/* SIZE = 34 BYTES */
};
/* definitions for stc (style code) in SEP */
#define stcSectMin 105 /* Division Standard */
stc 106 through 127 represent division variants 1 through 21 respectively
/* definitions for bkc (page break code) in SEP */
#define bkcNoBreak 0 /* continue on same page
as last division */
#define bkcNewColumn 1 /* start a new column */
#define bkcNewPage 2 /* start a new page */
#define bkcOddPage 3 /* make sure this division starts
on an odd page */
#define bkcEvenPage 4 /* make sure this division starts
on an even page */
/* definitions for nfcPgn (number format code for page numbers in SEP */
#define nfcArabic 0 /* standard number format */
#define nfcUCRoman 1 /* uppercase roman numerals */
#define nfcLCRoman 2 /* lowercase roman numerals */
#define nfcUCLetter 3 /* uppercase letters in
alphabetical order */
#define nfcLCLetter 4 /* lowercase letters in
alphabetical order */
/* definitions for lnc (line number continuation code) in SEP */
#define lncPerPage 0 /* start from line 1 on each page */
#define lncRestart 1 /* start at line 1 at the beginning of
this section, but don't restart
at the top of each page */
#define lncContinue 2 /* do not restart line numbers at the
beginning of this section or at
the beginning of each page */
struct RUN /* Char or para run descriptor */
{
FC fcLim; /* last fc of run */
int bProps; /* byte offset from rgb; if -1, standard props */
/* SIZE = 6 BYTES */
};
/* This an abstract structure which can't be compiled as declared
since cch is not a constant */
typedef struct
{
char cch;
rgch[cch];
} ST:
/* SIZE = cch + 1 BYTES */
/* This an abstract structure which can't be compiled as declared
since istMac is not a constant and STs vary in size */
struct STTB
{
int istMac;
ST grpst[istMac - 1]; /* NOT a true array since STs do not
have a constant size. Also, the
strings are indexed from 1 to istMac
- 1. There is no string index by 0 */
};
struct SQD
{
int iName; /* index into string table for this sequence
name */
BF value : 13; /* value of sequence at this point - only
only valid while printing the document */
BF action : 3; /* action code - see below */
};
/* definitions for action code in SQD */
#define sqdIncIns 0 /* increment sequence and print new value */
#define sqdInc 1 /* increment sequence but don't print value */
#define sqdSet 2 /* increment sequence value to sqd.value
(don't print value */
struct SQR
{
int iName; /* index into string table for this sequence
name */
int iBkmkName; /* index into string table for Bookmark Name */
};
/* This is an abstract structure which can't be compiled as declared
since iMac is not a constant, and ITEM is an arbitrary structure
whose size happens to be cb. */
struct PLCF
{
int iMac; /* number of items stored */
int iMax; /* number of items allocated
in memory. this field is
meaningless when stored in
file. */
struct ITEM rgItem[Imac]; /* there iMac items */
};